Mediastreamer2 VoIP ძრავის შესწავლა. ნაწილი 11

სტატიის მასალა აღებულია ჩემი ზენ არხი.

მონაცემთა გადაადგილების მექანიზმი

• მონაცემთა ბლოკი dblk_t
• შეტყობინება mblk_t
• mblk_t შეტყობინებებთან მუშაობის ფუნქციები
• რიგი queue_t
• რიგებთან მუშაობის ფუნქციები queue_t
• ფილტრების დაკავშირება
• მონაცემთა დამუშავების გრაფიკის სიგნალის წერტილი
• ტიკერის საქმიანობა კულისებში
• ბუფერიზატორი (MSBufferizer)
• MSBufferizer-თან მუშაობის ფუნქციები

Ბოლოს მუხლი ჩვენ შევიმუშავეთ ჩვენი საკუთარი ფილტრი. ეს სტატია ყურადღებას გაამახვილებს მონაცემთა გადაადგილების შიდა მექანიზმზე მედია ნაკადის ფილტრებს შორის. ეს საშუალებას მოგცემთ დაწეროთ დახვეწილი ფილტრები მომავალში ნაკლები ძალისხმევით.

მონაცემთა გადაადგილების მექანიზმი

მონაცემთა გადაადგილება მედია სტრიმერში ხორციელდება სტრუქტურის მიერ აღწერილი რიგების გამოყენებით რიგი_ტ. შეტყობინებების სტრიქონები, როგორიცაა mblk_t, რომელიც თავისთავად არ შეიცავს სიგნალის მონაცემებს, არამედ მხოლოდ ბმულებს წინა, მომდევნო შეტყობინებასთან და მონაცემთა ბლოკთან. გარდა ამისა, მინდა განსაკუთრებით ხაზგასმით აღვნიშნო, რომ ასევე არის ველი იმავე ტიპის გზავნილის ბმულისთვის, რომელიც საშუალებას გაძლევთ მოაწყოთ შეტყობინებების ცალმხრივად დაკავშირებული სია. ასეთი სიით გაერთიანებულ შეტყობინებების ჯგუფს ჩვენ ვუწოდებთ ტოპს. ამრიგად, რიგის ნებისმიერი ელემენტი შეიძლება იყოს ერთი შეტყობინება mblk_t, და შესაძლოა მესიჯის ხელმძღვანელი mblk_t. თითოეულ მესიჯს შეიძლება ჰქონდეს საკუთარი პალატის მონაცემთა ბლოკი. რატომ არის საჭირო ტუპლები ცოტა მოგვიანებით განვიხილავთ.

როგორც ზემოთ აღინიშნა, შეტყობინება თავისთავად არ შეიცავს მონაცემთა ბლოკს; სამაგიეროდ, ის შეიცავს მხოლოდ მაჩვენებელს მეხსიერების არეზე, სადაც ბლოკი ინახება. ამ ნაწილში, მედია სტრიმერის მუშაობის საერთო სურათი მოგვაგონებს კარის საწყობს მულტფილმში "Monsters, Inc.", სადაც კარები (მონაცემების ბმულები - ოთახები) გიჟური სიჩქარით მოძრაობენ ზედა კონვეიერების გასწვრივ, ხოლო თავად ოთახები. დარჩეს უმოძრაოდ.

ახლა, იერარქიის გასწვრივ ქვემოდან ზევით გადაადგილებით, დეტალურად განვიხილოთ მონაცემთა გადაცემის მექანიზმის ჩამოთვლილი ერთეულები მედია სტრიმერში.

მონაცემთა ბლოკი dblk_t

მონაცემთა ბლოკი შედგება სათაურისა და მონაცემთა ბუფერისგან. სათაური აღწერილია შემდეგი სტრუქტურით,

typedef struct datab
{
unsigned char *db_base; // Указатель на начало буфер данных.
unsigned char *db_lim;  // Указатель на конец буфер данных.
void (*db_freefn)(void*); // Функция освобождения памяти при удалении блока.
int db_ref; // Счетчик ссылок.
} dblk_t;

სტრუქტურის ველები შეიცავს მითითებებს ბუფერის დასაწყისში, ბუფერის ბოლოს და მონაცემთა ბუფერის წაშლის ფუნქციას. ბოლო ელემენტი სათაურში db_ref - მითითების მრიცხველი, თუ ის მიაღწევს ნულს, ეს ემსახურება როგორც სიგნალს, რომ წაშალოთ ეს ბლოკი მეხსიერებიდან. თუ მონაცემთა ბლოკი შეიქმნა ფუნქციით datab_alloc() , მაშინ მონაცემთა ბუფერი განთავსდება მეხსიერებაში სათაურის შემდეგ დაუყოვნებლივ. ყველა სხვა შემთხვევაში, ბუფერი შეიძლება განთავსდეს სადმე ცალკე. მონაცემთა ბუფერი შეიცავს სიგნალის ნიმუშებს ან სხვა მონაცემებს, რომელთა დამუშავება გვინდა ფილტრებით.

მონაცემთა ბლოკის ახალი მაგალითი იქმნება ფუნქციის გამოყენებით:

dblk_t *datab_alloc(int size);

როგორც შეყვანის პარამეტრი, მოცემულია იმ მონაცემების ზომა, რომელსაც ბლოკი შეინახავს. მეტი მეხსიერება გამოყოფილია იმისათვის, რომ განთავსდეს სათაური - სტრუქტურა - გამოყოფილი მეხსიერების დასაწყისში მონაცემთა ბაზა. მაგრამ სხვა ფუნქციების გამოყენებისას ეს ყოველთვის არ ხდება; ზოგიერთ შემთხვევაში, მონაცემთა ბუფერი შეიძლება განთავსდეს მონაცემთა ბლოკის სათაურისგან დამოუკიდებლად. სტრუქტურის შექმნისას ველები კონფიგურირებულია ისე, რომ მისი ველი db_base მიუთითა მონაცემთა არეალის დასაწყისზე და db_lim მის ბოლომდე. ბმულების რაოდენობა db_ref დაყენებულია ერთზე. მონაცემთა გასუფთავების ფუნქციის მაჩვენებელი დაყენებულია ნულზე.

შეტყობინება mblk_t

როგორც აღინიშნა, რიგის ელემენტები არის ტიპის mblk_t, იგი განისაზღვრება შემდეგნაირად:

typedef struct msgb
{
  struct msgb *b_prev;   // Указатель на предыдущий элемент списка.
  struct msgb *b_next;   // Указатель на следующий элемент списка.
  struct msgb *b_cont;   // Указатель для подклейки к сообщению других сообщений, для создания кортежа сообщений.
  struct datab *b_datap; // Указатель на структуру блока данных.
  unsigned char *b_rptr; // Указатель на начало области данных для чтения данных буфера b_datap.
  unsigned char *b_wptr; // Указатель на начало области данных для записи данных буфера b_datap.
  uint32_t reserved1;    // Зарезервированное поле1, медиастример помещает туда служебную информацию. 
  uint32_t reserved2;    // Зарезервированное поле2, медиастример помещает туда служебную информацию.
  #if defined(ORTP_TIMESTAMP)
  struct timeval timestamp;
  #endif
  ortp_recv_addr_t recv_addr;
} mblk_t;

სტრუქტურა mblk_t შეიცავს მითითებებს დასაწყისში b_წინა, ბ_შემდეგი, რომლებიც აუცილებელია ორმაგად დაკავშირებული სიის ორგანიზებისთვის (რომელიც არის რიგი რიგი_ტ).

შემდეგ მოდის მაჩვენებელი b_cont, რომელიც გამოიყენება მხოლოდ მაშინ, როდესაც შეტყობინება არის tuple-ის ნაწილი. ტუპლის ბოლო გზავნილისთვის ეს მაჩვენებელი ნული რჩება.

შემდეგ ჩვენ ვხედავთ მაჩვენებელს მონაცემთა ბლოკზე b_datap, რისთვისაც არსებობს შეტყობინება. მას მოსდევს მაჩვენებლები ბლოკის მონაცემთა ბუფერის შიგნით. ველი b_rptr განსაზღვრავს ადგილს, საიდანაც წაიკითხება ბუფერის მონაცემები. ველი b_wptr მიუთითებს ადგილს, საიდანაც შესრულდება ბუფერში ჩაწერა.

დანარჩენი ველები არის სერვისული ხასიათისა და არ ეხება მონაცემთა გადაცემის მექანიზმის მუშაობას.

ქვემოთ მოცემულია ერთი შეტყობინება სახელით m1 და მონაცემთა ბლოკი d1.

ქვემოთ მოყვანილი ფიგურა გვიჩვენებს სამი შეტყობინების წყებას m1, m1_1, m1_2.

შეტყობინებების ფუნქციები mblk_t

ახალი მესიჯი mblk_t შექმნილი ფუნქციით:

mblk_t *allocb(int size, int pri); 

ის ახალ მესიჯს დებს მეხსიერებაში mblk_t მითითებული ზომის მონაცემთა ბლოკით ზომამეორე არგუმენტი - პრი არ გამოიყენება ბიბლიოთეკის ამ ვერსიაში. ნული უნდა დარჩეს. ფუნქციის მუშაობისას მეხსიერება გამოიყოფა ახალი შეტყობინების სტრუქტურისთვის და გამოიძახება ფუნქცია mblk_init (), რომელიც გადატვირთავს სტრუქტურის შექმნილი ინსტანციის ყველა ველს და შემდეგ ზემოთ აღნიშნულის გამოყენებით datab_alloc(), შექმნის მონაცემთა ბუფერს. რის შემდეგაც სტრუქტურაში ველები კონფიგურირებული იქნება:

mp->b_datap=datab;
mp->b_rptr=mp->b_wptr=datab->db_base;
mp->b_next=mp->b_prev=mp->b_cont=NULL;

გამოსავალზე ვიღებთ ახალ შეტყობინებას ინიციალიზებული ველებით და ცარიელი მონაცემთა ბუფერით. შეტყობინებაში მონაცემების დასამატებლად, თქვენ უნდა დააკოპიროთ იგი მონაცემთა ბლოკის ბუფერში:

memcpy(msg->b_rptr, data, size);

სადაც მონაცემები არის მაჩვენებელი მონაცემთა წყაროზე და ზომა - მათი ზომა.
შემდეგ თქვენ უნდა განაახლოთ მაჩვენებელი ჩაწერის წერტილამდე ისე, რომ ის კვლავ მიუთითებდეს ბუფერში თავისუფალი ზონის დასაწყისზე:

msg->b_wptr = msg->b_wptr + size

თუ თქვენ გჭირდებათ შეტყობინების შექმნა არსებული ბუფერიდან, კოპირების გარეშე, გამოიყენეთ ფუნქცია:

mblk_t *esballoc(uint8_t *buf, int size, int pri, void (*freefn)(void*)); 

ფუნქცია, შეტყობინებისა და მონაცემთა ბლოკის სტრუქტურის შექმნის შემდეგ, დააკონფიგურირებს მის მითითებებს მისამართზე მოცემულ მონაცემებზე. ბუფეტი. იმათ. ამ შემთხვევაში, მონაცემთა ბუფერი არ არის განთავსებული მონაცემთა ბლოკის სათაურის ველების შემდეგ, როგორც ეს იყო ფუნქციით მონაცემთა ბლოკის შექმნისას. datab_alloc(). ფუნქციაზე გადაცემული მონაცემების ბუფერი დარჩება იქ, სადაც იყო, მაგრამ პოინტერების დახმარებით იგი მიმაგრებული იქნება მონაცემთა ბლოკის ახლად შექმნილ სათაურზე და, შესაბამისად, შეტყობინებაზე.

ერთ შეტყობინებაზე mblk_t რამდენიმე მონაცემთა ბლოკი შეიძლება თანმიმდევრულად იყოს დაკავშირებული. ეს კეთდება ფუნქციით:

mblk_t * appendb(mblk_t *mp, const char *data, int size, bool_t pad); 

mp — შეტყობინება, რომელსაც დაემატება მონაცემთა სხვა ბლოკი;
მონაცემები — მაჩვენებელი ბლოკზე, რომლის ასლი დაემატება შეტყობინებას;
ზომა - მონაცემთა ზომა;
pad — დროშა, რომლის მიხედვითაც გამოყოფილი მეხსიერების ზომა უნდა იყოს გასწორებული 4-ბაიტიანი საზღვრის გასწვრივ (შეფუთვა მოხდება ნულებით).

თუ არსებული შეტყობინებების მონაცემთა ბუფერში საკმარისი ადგილია, მაშინ ახალი მონაცემები ჩასმული იქნება უკვე იქ არსებული მონაცემების უკან. თუ შეტყობინების მონაცემთა ბუფერში ნაკლები თავისუფალი ადგილია ვიდრე ზომა, შემდეგ იქმნება ახალი შეტყობინება ბუფერის საკმარისი ზომით და მონაცემები კოპირდება მის ბუფერში. ეს არის ახალი შეტყობინება, რომელიც დაკავშირებულია ორიგინალთან პოინტერის გამოყენებით b_cont. ამ შემთხვევაში, მესიჯი იქცევა ტოტად.

თუ თქვენ გჭირდებათ მონაცემთა სხვა ბლოკის დამატება tuple-ში, მაშინ უნდა გამოიყენოთ ფუნქცია:

void msgappend(mblk_t *mp, const char *data, int size, bool_t pad);

ის იპოვის ბოლო შეტყობინებას ტუპში (მას აქვს b_cont იქნება null) და გამოიძახებს ფუნქციას ამ შეტყობინებისთვის appendb ().

თქვენ შეგიძლიათ გაიგოთ მონაცემების ზომა შეტყობინებაში ან ტოპში ფუნქციის გამოყენებით:

int msgdsize(const mblk_t *mp);

ის გადააბრუნებს ყველა შეტყობინებას tuple-ში და დააბრუნებს მონაცემთა მთლიან რაოდენობას ამ შეტყობინებების მონაცემთა ბუფერებში. თითოეული შეტყობინებისთვის, მონაცემების რაოდენობა გამოითვლება შემდეგნაირად:

 mp->b_wptr - mp->b_rptr

ორი ტოპის დასაკავშირებლად გამოიყენეთ ფუნქცია:

mblk_t *concatb(mblk_t *mp, mblk_t *newm);

იგი ამაგრებს ტოპს ახალი ტუპლის კუდამდე mp და აბრუნებს მაჩვენებელს მიღებული ტოპის ბოლო შეტყობინებაზე.

საჭიროების შემთხვევაში, ტუპლი შეიძლება გადაიქცეს ერთ შეტყობინებად მონაცემთა ერთი ბლოკით; ეს კეთდება ფუნქციით:

void msgpullup(mblk_t *mp,int len);

თუ არგუმენტი len არის -1, მაშინ გამოყოფილი ბუფერის ზომა განისაზღვრება ავტომატურად. თუ len არის დადებითი რიცხვი, შეიქმნება ამ ზომის ბუფერი და მასში დაკოპირდება შეტყობინებების მონაცემები. თუ ბუფერი ამოიწურება, კოპირება შეჩერდება. ტუპლის პირველი შეტყობინება მიიღებს ახალი ზომის ბუფერს დაკოპირებული მონაცემებით. დარჩენილი შეტყობინებები წაიშლება და მეხსიერება დაბრუნდება გროვაში.

სტრუქტურის წაშლისას mblk_t მონაცემთა ბლოკის მითითების რაოდენობა გათვალისწინებულია, თუ დარეკვისას უფასო () აღმოჩნდება ნული, შემდეგ იშლება მონაცემთა ბუფერი ინსტანციასთან ერთად mblk_t, რაც მასზე მიუთითებს.

ახალი შეტყობინების ველების ინიცირება:

void mblk_init(mblk_t *mp);

შეტყობინებას კიდევ ერთი მონაცემების დამატება:

mblk_t * appendb(mblk_t *mp, const char *data, size_t size, bool_t pad);

თუ ახალი მონაცემები არ ჯდება შეტყობინების მონაცემთა ბუფერის თავისუფალ სივრცეში, მაშინ შეტყობინებას მიმაგრებულია ცალკე შექმნილი შეტყობინება საჭირო ზომის ბუფერით (დამატებული შეტყობინების მაჩვენებელი მითითებულია პირველ შეტყობინებაში) და მესიჯი იქცევა ტოტად.

მონაცემთა ნაწილის დამატება tuple-ში:

void msgappend(mblk_t *mp, const char *data, size_t size, bool_t pad); 

ფუნქცია გამოიძახებს appendb()-ს მარყუჟში.

ორი ტოპის ერთში გაერთიანება:

mblk_t *concatb(mblk_t *mp, mblk_t *newm);

შეტყობინება ახალი მიმაგრებული იქნება mp.

ერთი შეტყობინების ასლის გაკეთება:

mblk_t *copyb(const mblk_t *mp);

ტუპლის სრული კოპირება მონაცემთა ყველა ბლოკით:

mblk_t *copymsg(const mblk_t *mp);

ტუპლის ელემენტები კოპირებულია ფუნქციით copyb ().

შექმენით შეტყობინების მარტივი ასლი mblk_t. ამ შემთხვევაში, მონაცემთა ბლოკი არ კოპირდება, მაგრამ მისი მითითების მრიცხველი იზრდება db_ref:

mblk_t *dupb(mblk_t *mp);

ტუპლის მსუბუქი ასლის დამზადება. მონაცემთა ბლოკები არ კოპირდება, მხოლოდ მათი მითითების მრიცხველები იზრდება db_ref:

mblk_t *dupmsg(mblk_t* m);

ტუპლის ყველა შეტყობინების გაერთიანება ერთ შეტყობინებაში:

void msgpullup(mblk_t *mp,size_t len);

თუ არგუმენტი len არის -1, მაშინ გამოყოფილი ბუფერის ზომა განისაზღვრება ავტომატურად.

შეტყობინების წაშლა, გამრავლება:

void freemsg(mblk_t *mp);

მონაცემთა ბლოკის მითითების რაოდენობა მცირდება ერთით. თუ ის ნულს მიაღწევს, მონაცემთა ბლოკი ასევე წაიშლება.

შეტყობინებების ან ტუპლის მონაცემების მთლიანი რაოდენობის გაანგარიშება.

size_t msgdsize(const mblk_t *mp);

შეტყობინების მიღება რიგის კუდიდან:

mblk_t *ms_queue_peek_last (q);

ერთი შეტყობინების რეზერვირებული ველების შიგთავსის კოპირება მეორე შეტყობინებაში (ფაქტობრივად, ეს ველები შეიცავს დროშებს, რომლებსაც იყენებს მედია სტრიმერი):

mblk_meta_copy(const mblk_t *source, mblk *dest);

რიგში რიგი_ტ

შეტყობინებების რიგი მედია სტრიმერში განხორციელებულია წრიული ორმაგად დაკავშირებული სიის სახით. სიის თითოეული ელემენტი შეიცავს მაჩვენებელს მონაცემთა ბლოკისკენ სიგნალის ნიმუშებით. გამოდის, რომ მხოლოდ მონაცემთა ბლოკის მითითებები მოძრაობს თავის მხრივ, ხოლო თავად მონაცემები უმოძრაო რჩება. იმათ. გადატანილია მხოლოდ მათთან დაკავშირებული ბმულები.
სტრუქტურა, რომელიც აღწერს რიგში რიგი_ტ, ნაჩვენებია ქვემოთ:

typedef struct _queue
{
   mblk_t _q_stopper; /* "Холостой" элемент очереди, не указывает на данные, используется только для управления очередью. При инициализации очереди (qinit()) его указатели настраиваются так, чтобы они указывали на него самого. */
   int q_mcount;        // Количество элементов в очереди.
} queue_t;

სტრუქტურა შეიცავს ველს - მაჩვენებელს _q_stopper აკრიფეთ *mblk_t, ის მიუთითებს რიგში პირველ ელემენტზე (მესიჯზე). სტრუქტურის მეორე ველი არის შეტყობინებების მრიცხველი რიგში.
ქვემოთ მოყვანილი სურათი გვიჩვენებს რიგს სახელად q1, რომელიც შეიცავს 4 შეტყობინებას m1, m2, m3, m4.

შემდეგ სურათზე ნაჩვენებია რიგი სახელად q1, რომელიც შეიცავს 4 შეტყობინებას m1,m2,m3,m4. შეტყობინება m2 არის ტუპლის თავი, რომელიც შეიცავს კიდევ ორ შეტყობინებას m2_1 და m2_2.

რიგებთან მუშაობის ფუნქციები queue_t

რიგის ინიციალიზაცია:

void qinit(queue_t *q);

საველე _q_stopper (შემდგომში ჩვენ მას "სტოპერს" დავარქმევთ) ინიციალიზებულია ფუნქციით mblk_init (), მისი წინა ელემენტი და შემდეგი ელემენტის მაჩვენებელი მორგებულია, რათა მიუთითოს საკუთარ თავზე. რიგის ელემენტების მრიცხველი აღდგება ნულამდე.

ახალი ელემენტის დამატება (შეტყობინებები):

void putq(queue_t *q, mblk_t *m);

ახალი ელემენტი m ემატება სიის ბოლოს, ელემენტის მაჩვენებლები მორგებულია ისე, რომ საცობი ხდება მისთვის შემდეგი ელემენტი და ის ხდება წინა ელემენტი საცობისთვის. რიგის ელემენტის მრიცხველი იზრდება.

ელემენტის მოძიება რიგიდან:

mblk_t * getq(queue_t *q); 

შეტყობინება, რომელიც მოდის საცობის შემდეგ, ამოღებულია და ელემენტის მრიცხველი მცირდება. თუ რიგში არ არის ელემენტები, გარდა საცობისა, მაშინ ბრუნდება 0.

შეტყობინების ჩასმა რიგში:

void insq(queue_t *q, mblk_t *emp, mblk_t *mp); 

ელემენტი mp ელემენტის წინ ჩასმული emp. თუ emp=0, შემდეგ შეტყობინება ემატება რიგის ბოლოში.

რიგის ხელმძღვანელისგან შეტყობინების მიღება:

void remq(queue_t *q, mblk_t *mp); 

ელემენტის მრიცხველი მცირდება.

რიგის პირველი ელემენტის მაჩვენებლის კითხვა:

mblk_t * peekq(queue_t *q); 

რიგებიდან ყველა ელემენტის ამოღება თავად ელემენტების წაშლისას:

void flushq(queue_t *q, int how);

კამათი როგორ არ გამოიყენება. რიგის ელემენტის მრიცხველი დაყენებულია ნულზე.

მაკრო რიგის ბოლო ელემენტის მაჩვენებლის წასაკითხად:

mblk_t * qlast(queue_t *q);

შეტყობინების რიგებთან მუშაობისას გაითვალისწინეთ, რომ დარეკვისას ms_queue_put (q, m) გზავნილის ნულოვანი მაჩვენებლით, ფუნქცია მარყუჟდება. თქვენი პროგრამა გაიყინება. იქცევა ანალოგიურად ms_queue_next(q, m).

ფილტრების დაკავშირება

ზემოთ აღწერილი რიგი გამოიყენება შეტყობინებების გადასაცემად ერთი ფილტრიდან მეორეზე ან ერთიდან რამდენიმე ფილტრზე. ფილტრები და მათი კავშირები ქმნიან მიმართულ გრაფიკს. ფილტრის შეყვანას ან გამომავალს ეწოდება ზოგადი სიტყვა "პინი". ფილტრების ერთმანეთთან დაკავშირების თანმიმდევრობის აღსაწერად მედია სტრიმერი იყენებს „სიგნალის წერტილის“ კონცეფციას. სიგნალის წერტილი არის სტრუქტურა _MSCPpoint, რომელიც შეიცავს ფილტრის მაჩვენებელს და მისი ერთ-ერთი პინის ნომერს; შესაბამისად, იგი აღწერს ფილტრის ერთ-ერთი შეყვანის ან გამოსასვლელის კავშირს.

მონაცემთა დამუშავების გრაფიკის სიგნალის წერტილი

typedef struct _MSCPoint{
struct _MSFilter *filter; // Указатель на фильтр медиастримера.
int pin;                        // Номер одного из входов или выходов фильтра, т.е. пин.
} MSCPoint;

ფილტრის ქინძისთავები დანომრილია ნულიდან.

ორი პინის დაკავშირება შეტყობინებების რიგით აღწერილია სტრუქტურით _MSQueue, რომელიც შეიცავს შეტყობინებების რიგს და მითითებებს იმ ორი სიგნალის წერტილისკენ, რომელსაც ის აკავშირებს:

typedef struct _MSQueue
{
queue_t q;
MSCPoint prev;
MSCPoint next;
}MSQueue;

ჩვენ ამ სტრუქტურას სიგნალის ბმულს დავარქმევთ. თითოეული მედია სტრიმერის ფილტრი შეიცავს შეყვანის ბმულების ცხრილს და გამომავალი ბმულების ცხრილს (MSQueue). ცხრილების ზომა დგინდება ფილტრის შექმნისას; ჩვენ ეს უკვე გავაკეთეთ ექსპორტირებული ტიპის ცვლადის გამოყენებით MSFilterDesc, როდესაც ჩვენ შევიმუშავეთ ჩვენი საკუთარი ფილტრი. ქვემოთ მოცემულია სტრუქტურა, რომელიც აღწერს ნებისმიერ ფილტრს მედია სტრიმერში, MSFilter:

struct _MSFilter{
    MSFilterDesc *desc;    /* Указатель на дескриптор фильтра. */
    /* Защищенные атрибуты, их нельзя сдвигать или убирать иначе будет нарушена работа с плагинами. */
    ms_mutex_t lock;      /* Семафор. */
    MSQueue **inputs;     /* Таблица входных линков. */
    MSQueue **outputs;    /* Таблица выходных линков. */
    struct _MSFactory *factory; /* Указатель на фабрику, которая создала данный экземпляр фильтра. */
    void *padding;              /* Не используется, будет задействован если добавятся защищенные поля. */
    void *data;                 /* Указатель на произвольную структуру для хранения данных внутреннего состояния фильтра и промежуточных вычислений. */
    struct _MSTicker *ticker;   /* Указатель на объект тикера, который не должен быть нулевым когда вызывается функция process(). */
    /*private attributes, they can be moved and changed at any time*/
    MSList *notify_callbacks; /* Список обратных вызовов, используемых для обработки событий фильтра. */
    uint32_t last_tick;       /* Номер последнего такта, когда выполнялся вызов process(). */ 
    MSFilterStats *stats;     /* Статистика работы фильтра.*/
    int postponed_task; /*Количество отложенных задач. Некоторые фильтры могут откладывать обработку данных (вызов process()) на несколько тактов.*/
    bool_t seen;  /* Флаг, который использует тикер, чтобы помечать что этот экземпляр фильтра он уже обслужил на данном такте.*/
};
typedef struct _MSFilter MSFilter;

მას შემდეგ რაც ჩვენ დავაკავშირეთ ფილტრები C პროგრამაში ჩვენი გეგმის შესაბამისად (მაგრამ არ დავაკავშირეთ ტიკერი), ამით შევქმენით მიმართული გრაფიკი, რომლის კვანძები სტრუქტურის მაგალითებია. MSFilter, და კიდეები ბმულების მაგალითებია MSQueue.

ტიკერის საქმიანობა კულისებში

როცა გითხარით, რომ ტიკერი არის ტკიპების წყაროს ფილტრი, ეს არ იყო სრული სიმართლე. ტიკერი არის ობიექტი, რომელიც ასრულებს ფუნქციებს საათზე პროცესი () მიკროსქემის (გრაფიკის) ყველა ფილტრი, რომელსაც იგი უკავშირდება. როდესაც ჩვენ ვაკავშირებთ ტიკერს გრაფიკულ ფილტრს C პროგრამაში, ტიკერს ვაჩვენებთ გრაფიკს, რომელსაც ის ამიერიდან გააკონტროლებს, სანამ არ გამორთავთ. დაკავშირების შემდეგ, ტიკერი იწყებს მის მოვლაზე მინდობილი გრაფიკის შემოწმებას, ადგენს ფილტრების ჩამონათვალს, რომელიც მოიცავს მას. იმისათვის, რომ ერთი და იგივე ფილტრი ორჯერ არ "დაითვალოს", ის აღნიშნავს აღმოჩენილ ფილტრებს მათში ჩამრთველის მოთავსებით. ჩანს. ძიება ხორციელდება ბმულების ცხრილების გამოყენებით, რომლებიც თითოეულ ფილტრს აქვს.

გრაფიკის შესავალი ტურის დროს, ტიკერი ამოწმებს, არის თუ არა ფილტრებს შორის მინიმუმ ერთი, რომელიც მოქმედებს როგორც მონაცემთა ბლოკების წყარო. თუ არცერთი არ არის, მაშინ გრაფიკი არასწორად ითვლება და ტიკერი იშლება.

თუ გრაფიკი აღმოჩნდება "სწორი", თითოეული ნაპოვნი ფილტრისთვის, ფუნქცია გამოიძახება ინიციალიზაციისთვის წინასწარი პროცესი (). როგორც კი დადგება მომენტი შემდეგი დამუშავების ციკლისთვის (ნაგულისხმევად ყოველ 10 მილიწამში), ტიკერი იძახებს ფუნქციას პროცესი () ყველა ადრე ნაპოვნი წყაროს ფილტრებისთვის და შემდეგ სიაში დარჩენილი ფილტრებისთვის. თუ ფილტრს აქვს შეყვანის ბმულები, მაშინ გაუშვით ფუნქცია პროცესი () მეორდება მანამ, სანამ შეყვანის ბმულების რიგები ცარიელია. ამის შემდეგ ის გადადის სიის შემდეგ ფილტრზე და „გადახვევს“ სანამ შეყვანის ბმულები არ იქნება შეტყობინებებისგან. ტიკერი გადადის ფილტრიდან ფილტრზე, სანამ სია არ დასრულდება. ეს ასრულებს ციკლის დამუშავებას.

ახლა ჩვენ დავუბრუნდებით tuples-ს და ვისაუბრებთ იმაზე, თუ რატომ დაემატა ასეთი სუბიექტი მედიასტრიმერს. ზოგადად, ფილტრის შიგნით მოქმედი ალგორითმის მიერ მოთხოვნილი მონაცემების რაოდენობა არ ემთხვევა და არ არის შეყვანისას მიღებული მონაცემთა ბუფერების ზომის ჯერადი. მაგალითად, ჩვენ ვწერთ ფილტრს, რომელიც ასრულებს ფურიეს სწრაფ ტრანსფორმაციას, რომელსაც განსაზღვრებით შეუძლია მხოლოდ მონაცემთა ბლოკების დამუშავება, რომელთა ზომა არის ორი სიმძლავრის. იყოს 512 რაოდენობა. თუ მონაცემები გენერირებულია სატელეფონო არხით, მაშინ თითოეული შეტყობინების ბუფერი შეყვანისას მოგვიტანს სიგნალის 160 ნიმუშს. მაცდურია არ შეაგროვოთ მონაცემები შეყვანიდან, სანამ მონაცემების საჭირო რაოდენობა არ იქნება. მაგრამ ამ შემთხვევაში, შეჯახება მოხდება ტიკერთან, რომელიც წარუმატებლად შეეცდება ფილტრის გადახვევას მანამ, სანამ შეყვანის ბმული ცარიელია. ადრე, ჩვენ აღვნიშნეთ ეს წესი, როგორც ფილტრის მესამე პრინციპი. ამ პრინციპის მიხედვით, ფილტრის process() ფუნქციამ უნდა მიიღოს ყველა მონაცემი შეყვანის რიგებიდან.

გარდა ამისა, შეყვანიდან შეუძლებელი იქნება მხოლოდ 512 ნიმუშის აღება, ვინაიდან შეგიძლიათ მხოლოდ მთლიანი ბლოკების აღება, ე.ი. ფილტრს მოუწევს 640 ნიმუშის აღება და მათგან 512-ის გამოყენება, დანარჩენი მონაცემების ახალი ნაწილის დაგროვებამდე. ამრიგად, ჩვენმა ფილტრმა, თავისი ძირითადი სამუშაოს გარდა, უნდა უზრუნველყოს დამხმარე მოქმედებები შეყვანის მონაცემების შუალედურ შესანახად. მედია სტრიმერის დეველოპერებმა და ამ ზოგადი პრობლემის გადაწყვეტა შეიმუშავეს სპეციალური ობიექტი - MSBufferizer (ბუფერერი), რომელიც ამ პრობლემას აგვარებს ტუპლების გამოყენებით.

ბუფერიზატორი (MSBufferizer)

ეს არის ობიექტი, რომელიც დააგროვებს შეყვანის მონაცემებს ფილტრის შიგნით და დაიწყებს მის დასამუშავებლად გაგზავნას, როგორც კი ინფორმაციის რაოდენობა საკმარისი იქნება ფილტრის ალგორითმის გასაშვებად. სანამ ბუფერი აგროვებს მონაცემებს, ფილტრი იმუშავებს უმოქმედო რეჟიმში, პროცესორის დამუშავების სიმძლავრის გამოყენების გარეშე. მაგრამ როგორც კი ბუფერიდან წაკითხვის ფუნქცია დააბრუნებს ნულის გარდა სხვა მნიშვნელობას, ფილტრის process() ფუნქცია იწყებს ბუფერიდან მონაცემების მიღებას და დამუშავებას საჭირო ზომის ნაწილებში, სანამ ის ამოიწურება.
მონაცემები, რომლებიც ჯერ კიდევ არ არის საჭირო, რჩება ბუფერში, როგორც პირველი ელემენტი tuple, რომელსაც თან ერთვის შეყვანის მონაცემების შემდგომი ბლოკები.

სტრუქტურა, რომელიც აღწერს ბუფერს:

struct _MSBufferizer{
queue_t q; /* Очередь сообщений. */
int size; /* Суммарный размер данных находящихся в буферизаторе в данный момент. */
};
typedef struct _MSBufferizer MSBufferizer;

MSBufferizer-თან მუშაობის ფუნქციები

ახალი ბუფერული ინსტანციის შექმნა:

MSBufferizer * ms_bufferizer_new(void);

მეხსიერება გამოყოფილია, ინიციალიზებულია ms_bufferizer_init() და ბრუნდება მაჩვენებელი.

ინიციალიზაციის ფუნქცია:

void ms_bufferizer_init(MSBufferizer *obj); 

რიგის ინიციალიზაცია ხდება q, ველი ზომა დაყენებულია ნულზე.

შეტყობინების დამატება:

void ms_bufferizer_put(MSBufferizer *obj, mblk_t *m); 

რიგს ემატება შეტყობინება m. მონაცემთა ბლოკების გამოთვლილ ზომას ემატება ზომა.

ყველა შეტყობინების გადატანა ბმულის მონაცემთა რიგიდან ბუფერში q:

void ms_bufferizer_put_from_queue(MSBufferizer *obj, MSQueue *q);   

შეტყობინებების გადატანა ბმულიდან q ბუფერში ხორციელდება ფუნქციის გამოყენებით ms_bufferizer_put().

წაკითხვა ბუფერიდან:

int ms_bufferizer_read(MSBufferizer *obj, uint8_t *data, int datalen); 

თუ ბუფერში დაგროვილი მონაცემების ზომა მოთხოვნილზე ნაკლებია (დატალენი), შემდეგ ფუნქცია აბრუნებს ნულს, მონაცემები არ კოპირდება მონაცემებში. წინააღმდეგ შემთხვევაში, შესრულებულია მონაცემთა თანმიმდევრული კოპირება ბუფერში მდებარე ტოპებიდან. კოპირების შემდეგ, tuple წაიშლება და მეხსიერება თავისუფლდება. კოპირება სრულდება მონაცემთა ბაიტების კოპირების მომენტში. თუ სივრცე ამოიწურება მონაცემთა ბლოკის შუაში, მაშინ ამ შეტყობინებაში მონაცემთა ბლოკი შემცირდება დარჩენილ დაუკოპირებულ ნაწილამდე. შემდეგ ჯერზე დარეკვისას, კოპირება გაგრძელდება ამ წერტილიდან.

მონაცემთა იმ რაოდენობის წაკითხვა, რომელიც ამჟამად ხელმისაწვდომია ბუფერში:

int ms_bufferizer_get_avail(MSBufferizer *obj); 

აბრუნებს ველს ზომა ბუფერერი.

მონაცემთა ნაწილის გაუქმება ბუფერში:

void ms_bufferizer_skip_bytes(MSBufferizer *obj, int bytes);

ბაიტის მონაცემების მითითებული რაოდენობა ამოღებულია და გაუქმებულია. უძველესი მონაცემები გაუქმებულია.

ბუფერში ყველა შეტყობინების წაშლა:

void ms_bufferizer_flush(MSBufferizer *obj); 

მონაცემთა მრიცხველი აღდგება ნულამდე.

ბუფერში ყველა შეტყობინების წაშლა:

void ms_bufferizer_uninit(MSBufferizer *obj); 

მრიცხველი არ არის გადატვირთული.

ბუფერის ამოღება და მეხსიერების განთავისუფლება:

void ms_bufferizer_destroy(MSBufferizer *obj);  

ბუფერერის გამოყენების მაგალითები შეგიძლიათ იხილოთ რამდენიმე მედია ნაკადის ფილტრის საწყის კოდში. მაგალითად, MS_L16_ENC ფილტრში, რომელიც აწესრიგებს ნიმუშებში ბაიტებს ქსელის შეკვეთიდან ჰოსტის ბრძანებამდე: l16.c

შემდეგ სტატიაში განვიხილავთ ტიკერის დატვირთვის შეფასების საკითხს და როგორ გავუმკლავდეთ გადაჭარბებულ გამოთვლით დატვირთვას მედია სტრიმერში.

წყარო: www.habr.com