ការរុករកម៉ាស៊ីន Mediastreamer2 VoIP ។ ផ្នែកទី 11

សម្ភារៈនៃអត្ថបទគឺយកពីខ្ញុំ ប៉ុស្តិ៍ zen.

យន្តការនៃចលនាទិន្នន័យ

• ប្លុកទិន្នន័យ dblk_t
• សារ mblk_t
• មុខងារសម្រាប់ធ្វើការជាមួយសារ mblk_t
• ជួរជួរ_t
• អនុគមន៍​សម្រាប់​ធ្វើ​ការ​ជាមួយ​នឹង​ជួរ queue_t
• ការភ្ជាប់តម្រង
• ចំណុចសញ្ញានៃក្រាហ្វដំណើរការទិន្នន័យ
• សកម្មភាពនៅពីក្រោយឆាករបស់ ticker
• Bufferizer (MSBufferizer)
• មុខងារសម្រាប់ធ្វើការជាមួយ MSBufferizer

ក្នុង​អតីតកាល អត្ថបទ យើងបានបង្កើតតម្រងផ្ទាល់ខ្លួនរបស់យើង។ អត្ថបទនេះនឹងផ្តោតលើយន្តការខាងក្នុងសម្រាប់ការផ្លាស់ប្តូរទិន្នន័យរវាងតម្រងប្រព័ន្ធផ្សព្វផ្សាយ។ វានឹងអនុញ្ញាតឱ្យអ្នកសរសេរតម្រងស្មុគ្រស្មាញដោយមានការខិតខំប្រឹងប្រែងតិចនាពេលអនាគត។

យន្តការនៃចលនាទិន្នន័យ

ចលនាទិន្នន័យនៅក្នុងកម្មវិធីផ្សាយមេឌៀត្រូវបានអនុវត្តដោយប្រើជួរដែលបានពិពណ៌នាដោយរចនាសម្ព័ន្ធ ជួរ_t. ខ្សែអក្សរនៃសារដូចជា mblk_tដែលខ្លួនវាមិនមានទិន្នន័យសញ្ញា ប៉ុន្តែមានតែតំណភ្ជាប់ទៅសារមុន សារបន្ទាប់ និងទៅប្លុកទិន្នន័យប៉ុណ្ណោះ។ លើសពីនេះ ខ្ញុំចង់បញ្ជាក់ជាពិសេសថា វាក៏មានវាលសម្រាប់ភ្ជាប់ទៅសារនៃប្រភេទដូចគ្នា ដែលអនុញ្ញាតឱ្យអ្នករៀបចំបញ្ជីសារដែលមានតំណភ្ជាប់តែមួយ។ យើងនឹងហៅក្រុមសារដែលរួបរួមគ្នាដោយបញ្ជីបែបនេះថាជា tuple ដូច្នេះ ធាតុណាមួយនៃជួរអាចជាសារតែមួយ mblk_tហើយប្រហែលជាក្បាលនៃសារ tuple mblk_t. សារ tuple នីមួយៗអាចមានប្លុកទិន្នន័យវួដផ្ទាល់ខ្លួនរបស់វា។ យើងនឹងពិភាក្សាអំពីមូលហេតុដែល tuples ត្រូវការនៅពេលក្រោយបន្តិច។

ដូចដែលបានរៀបរាប់ខាងលើ សារខ្លួនវាមិនមានប្លុកទិន្នន័យទេ ផ្ទុយទៅវិញ វាមានតែទ្រនិចទៅកាន់តំបន់អង្គចងចាំដែលប្លុកត្រូវបានរក្សាទុក។ នៅក្នុងផ្នែកនេះ រូបភាពរួមនៃការងាររបស់អ្នកផ្សាយប្រព័ន្ធផ្សព្វផ្សាយគឺនឹកឃើញដល់ឃ្លាំងទ្វារនៅក្នុងតុក្កតា "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_prev, b_បន្ទាប់ដែលចាំបាច់ដើម្បីរៀបចំបញ្ជីដែលភ្ជាប់ទ្វេដង (ដែលជាជួរ ជួរ_t).

បន្ទាប់មកទ្រនិចមក b_contដែលត្រូវបានប្រើតែនៅពេលដែលសារជាផ្នែកនៃ tuple ប៉ុណ្ណោះ។ សម្រាប់សារចុងក្រោយនៅក្នុង 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 ជាមួយនឹងប្លុកទិន្នន័យនៃទំហំដែលបានបញ្ជាក់ ទំហំ, អាគុយម៉ង់ទីពីរ - pri មិនត្រូវបានប្រើនៅក្នុងកំណែបណ្ណាល័យនេះទេ។ វាគួរតែនៅតែសូន្យ។ កំឡុងពេលប្រតិបត្តិការរបស់មុខងារ អង្គចងចាំនឹងត្រូវបានបម្រុងទុកសម្រាប់រចនាសម្ព័ន្ធសារថ្មី ហើយមុខងារនឹងត្រូវបានហៅ 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);

ដែលជាកន្លែងដែល data subfolder គឺជាទ្រនិចទៅកាន់ប្រភពទិន្នន័យ និង ទំហំ - ទំហំរបស់ពួកគេ។
បន្ទាប់មកអ្នកត្រូវធ្វើបច្ចុប្បន្នភាពទ្រនិចទៅចំណុចសរសេរ ដូច្នេះវាចង្អុលម្តងទៀតទៅការចាប់ផ្តើមនៃផ្ទៃទំនេរនៅក្នុងសតិបណ្ដោះអាសន្ន៖

msg->b_wptr = msg->b_wptr + size

ប្រសិនបើអ្នកត្រូវការបង្កើតសារពីសតិបណ្ដោះអាសន្នដែលមានស្រាប់ ដោយមិនចាំបាច់ចម្លង បន្ទាប់មកប្រើមុខងារ៖

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

មុខងារ បន្ទាប់ពីបង្កើតសារ និងរចនាសម្ព័ន្ធនៃប្លុកទិន្នន័យ នឹងកំណត់រចនាសម្ព័ន្ធទ្រនិចរបស់វាទៅនឹងទិន្នន័យនៅអាសយដ្ឋាន buf ។. ទាំងនោះ។ ក្នុងករណីនេះ អង្គចងចាំទិន្នន័យមិនមានទីតាំងនៅបន្ទាប់ពីវាលបឋមកថានៃប្លុកទិន្នន័យ ដូចករណីនៅពេលបង្កើតប្លុកទិន្នន័យដែលមានមុខងារ datab_alloc(). សតិបណ្ដោះអាសន្នដែលមានទិន្នន័យបញ្ជូនទៅមុខងារនឹងនៅដដែល ប៉ុន្តែដោយមានជំនួយពីទ្រនិចវានឹងត្រូវបានភ្ជាប់ទៅបឋមកថាដែលបានបង្កើតថ្មីនៃប្លុកទិន្នន័យ ហើយនោះតាមសារ។

ទៅសារមួយ។ mblk_t ប្លុកទិន្នន័យជាច្រើនអាចត្រូវបានភ្ជាប់ជាបន្តបន្ទាប់។ នេះត្រូវបានធ្វើដោយមុខងារ៖

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

mp - សារដែលប្លុកទិន្នន័យផ្សេងទៀតនឹងត្រូវបានបន្ថែម។
data subfolder - ចង្អុលទៅប្លុក ច្បាប់ចម្លងដែលនឹងត្រូវបានបន្ថែមទៅសារ។
ទំហំ - ទំហំទិន្នន័យ;
បន្ទះ - ទង់ជាតិដែលទំហំនៃអង្គចងចាំដែលបានបែងចែកត្រូវតែត្រូវបានតម្រឹមតាមព្រំដែន 4 បៃ (បន្ទះនឹងត្រូវបានធ្វើដោយលេខសូន្យ)។

ប្រសិនបើមានកន្លែងទំនេរគ្រប់គ្រាន់នៅក្នុងបណ្តុំទិន្នន័យសារដែលមានស្រាប់ នោះទិន្នន័យថ្មីនឹងត្រូវបានបិទភ្ជាប់នៅពីក្រោយទិន្នន័យដែលមានរួចហើយនៅទីនោះ។ ប្រសិន​បើ​មាន​ទំហំ​ទំនេរ​តិច​ក្នុង​ការ​ផ្ទុក​ទិន្នន័យ​សារ​ជាង ទំហំបន្ទាប់មក សារថ្មីមួយត្រូវបានបង្កើតជាមួយនឹងទំហំផ្ទុកគ្រប់គ្រាន់ ហើយទិន្នន័យត្រូវបានចម្លងទៅសតិបណ្ដោះអាសន្នរបស់វា។ នេះ​ជា​សារ​ថ្មី​ដែល​ភ្ជាប់​ទៅ​នឹង​សារ​ដើម​ដោយ​ប្រើ​ទ្រនិច b_cont. ក្នុងករណីនេះសារប្រែទៅជា tuple ។

ប្រសិនបើអ្នកត្រូវការបន្ថែមប្លុកទិន្នន័យផ្សេងទៀតទៅ tuple នោះអ្នកត្រូវប្រើមុខងារ៖

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

នាងនឹងរកឃើញសារចុងក្រោយនៅក្នុង tuple (គាត់មាន b_cont នឹងទុកជាមោឃៈ) ហើយនឹងហៅមុខងារសម្រាប់សារនេះ។ ឧបសម្ព័ន្ធ().

អ្នកអាចស្វែងយល់ពីទំហំនៃទិន្នន័យនៅក្នុងសារ ឬ tuple ដោយប្រើមុខងារ៖

int msgdsize(const mblk_t *mp);

វានឹងរង្វិលជុំតាមរយៈសារទាំងអស់នៅក្នុង tuple ហើយត្រឡប់ចំនួនសរុបនៃទិន្នន័យនៅក្នុងបណ្តុំទិន្នន័យនៃសារទាំងនោះ។ សម្រាប់សារនីមួយៗ ចំនួនទិន្នន័យត្រូវបានគណនាដូចខាងក្រោម៖

 mp->b_wptr - mp->b_rptr

ដើម្បីផ្សំពីរ tuple សូមប្រើមុខងារ៖

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

នាងបន្ថែម tuple ថ្មី ទៅកន្ទុយនៃ tuple នេះ។ mp ហើយត្រឡប់ទ្រនិចទៅសារចុងក្រោយនៃ tuple លទ្ធផល។

បើចាំបាច់ tuple អាចត្រូវបានប្រែក្លាយទៅជាសារមួយដែលមានប្លុកតែមួយនៃទិន្នន័យ នេះត្រូវបានធ្វើដោយមុខងារ៖

void msgpullup(mblk_t *mp,int len);

ប្រសិនបើអាគុយម៉ង់ len ។ គឺ -1 បន្ទាប់មកទំហំនៃសតិបណ្ដោះអាសន្នដែលបានបែងចែកត្រូវបានកំណត់ដោយស្វ័យប្រវត្តិ។ ប្រសិនបើ len ។ គឺជាលេខវិជ្ជមាន សតិបណ្ដោះអាសន្ននៃទំហំនេះនឹងត្រូវបានបង្កើត ហើយទិន្នន័យសារ tuple នឹងត្រូវបានចម្លងទៅក្នុងវា។ ប្រសិនបើសតិបណ្ដោះអាសន្នអស់ ការចម្លងនឹងឈប់នៅទីនោះ។ សារដំបូងនៃ tuple នឹងទទួលបានសតិបណ្ដោះអាសន្នទំហំថ្មីជាមួយនឹងទិន្នន័យដែលបានចម្លង។ សារដែលនៅសេសសល់នឹងត្រូវបានលុប ហើយអង្គចងចាំបានត្រលប់ទៅហ៊ាវិញ។

នៅពេលលុបរចនាសម្ព័ន្ធ mblk_t ចំនួនយោងនៃប្លុកទិន្នន័យត្រូវបានយកទៅក្នុងគណនីប្រសិនបើនៅពេលហៅទូរសព្ទ freeb() វាប្រែជាសូន្យ បន្ទាប់មកសតិបណ្ដោះអាសន្នទិន្នន័យត្រូវបានលុបរួមជាមួយឧទាហរណ៍ mblk_tដែលចង្អុលទៅវា។

ការចាប់ផ្តើមវាលសារថ្មី៖

void mblk_init(mblk_t *mp);

ការបន្ថែមទិន្នន័យផ្សេងទៀតទៅសារ៖

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

ប្រសិនបើទិន្នន័យថ្មីមិនសមនឹងទំហំទំនេរនៃសតិបណ្ដោះអាសន្នទិន្នន័យសារទេ នោះសារដែលបានបង្កើតដាច់ដោយឡែកជាមួយនឹងសតិបណ្ដោះអាសន្ននៃទំហំដែលត្រូវការត្រូវបានភ្ជាប់ទៅសារ (ទ្រនិចទៅសារដែលបានបន្ថែមត្រូវបានកំណត់ក្នុងសារដំបូង) និង សារប្រែទៅជា tuple ។

ការបន្ថែមទិន្នន័យមួយទៅ tuple៖

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

មុខងារហៅ appendb() នៅក្នុងរង្វិលជុំមួយ។

រួមបញ្ចូលគ្នានូវ tuple ពីរចូលទៅក្នុងមួយ:

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

សារ ថ្មី នឹងត្រូវបានភ្ជាប់ជាមួយ mp.

បង្កើតច្បាប់ចម្លងនៃសារតែមួយ៖

mblk_t *copyb(const mblk_t *mp);

ការចម្លងពេញលេញនៃ tuple ជាមួយនឹងប្លុកទិន្នន័យទាំងអស់៖

mblk_t *copymsg(const mblk_t *mp);

ធាតុនៃ tuple ត្រូវបានចម្លងដោយមុខងារ copyb().

បង្កើតច្បាប់ចម្លងងាយស្រួលនៃសារមួយ។ mblk_t. ក្នុងករណីនេះ ប្លុកទិន្នន័យមិនត្រូវបានចម្លងទេ ប៉ុន្តែបញ្ជរយោងរបស់វាត្រូវបានកើនឡើង db_ref:

mblk_t *dupb(mblk_t *mp);

ការធ្វើច្បាប់ចម្លងស្រាលនៃ tuple ។ ប្លុកទិន្នន័យមិនត្រូវបានចម្លងទេ មានតែបញ្ជរយោងរបស់ពួកគេប៉ុណ្ណោះដែលត្រូវបានបង្កើន db_ref:

mblk_t *dupmsg(mblk_t* m);

ការភ្ជាប់សារទាំងអស់នៃ tuple ចូលទៅក្នុងសារតែមួយ៖

void msgpullup(mblk_t *mp,size_t len);

ប្រសិនបើអាគុយម៉ង់ len ។ គឺ -1 បន្ទាប់មកទំហំនៃសតិបណ្ដោះអាសន្នដែលបានបែងចែកត្រូវបានកំណត់ដោយស្វ័យប្រវត្តិ។

កំពុងលុបសារ, tuple៖

void freemsg(mblk_t *mp);

ចំនួនយោងនៃប្លុកទិន្នន័យត្រូវបានកាត់បន្ថយដោយមួយ។ ប្រសិនបើវាឈានដល់សូន្យ ប្លុកទិន្នន័យក៏ត្រូវបានលុបផងដែរ។

ការគណនាចំនួនសរុបនៃទិន្នន័យនៅក្នុងសារឬ tuple ។

size_t msgdsize(const mblk_t *mp);

ទាញយកសារពីកន្ទុយនៃជួរ៖

mblk_t *ms_queue_peek_last (q);

ការចម្លងមាតិកានៃវាលដែលបានបម្រុងទុកនៃសារមួយទៅសារមួយផ្សេងទៀត (តាមពិត វាលទាំងនេះមានទង់ដែលត្រូវបានប្រើដោយអ្នកផ្សាយព័ត៌មាន)៖

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

ជួរ ជួរ_t

ជួរ​សារ​ក្នុង​កម្មវិធី​ផ្សាយ​មេឌៀ​ត្រូវ​បាន​អនុវត្ត​ជា​រង្វង់​បញ្ជី​ដែល​ភ្ជាប់​ទ្វេ​ដង។ ធាតុបញ្ជីនីមួយៗមានទ្រនិចទៅប្លុកទិន្នន័យដែលមានគំរូសញ្ញា។ វាប្រែថាមានតែចង្អុលទៅប្លុកទិន្នន័យផ្លាស់ទីជាវេនខណៈពេលដែលទិន្នន័យខ្លួនឯងនៅតែមិនមានចលនា។ ទាំងនោះ។ មានតែតំណភ្ជាប់ទៅពួកវាប៉ុណ្ណោះដែលត្រូវបានផ្លាស់ទី។
រចនាសម្ព័ន្ធពិពណ៌នាអំពីជួរ ជួរ_t, បង្ហាញខាងក្រោម៖

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

រចនាសម្ព័ន្ធមានវាលមួយ - ទ្រនិចមួយ។ _q_ឈប់ វាយ *mblk_t វាចង្អុលទៅធាតុទីមួយ (សារ) ក្នុងជួរ។ វាលទីពីរនៃរចនាសម្ព័ន្ធគឺជាការរាប់សារនៅក្នុងជួរ។
រូបខាងក្រោមបង្ហាញពីជួរឈ្មោះ q1 ដែលមានសារ 4 m1, m2, m3, m4 ។

រូបខាងក្រោមបង្ហាញជួរមួយឈ្មោះ q1 ដែលមានសារ 4 m1,m2,m3,m4 ។ សារ m2 គឺជាក្បាលរបស់ tuple ដែលមានសារពីរទៀត m2_1 និង m2_2 ។

អនុគមន៍​សម្រាប់​ធ្វើ​ការ​ជាមួយ​នឹង​ជួរ queue_t

ការចាប់ផ្តើមជួរ៖

void qinit(queue_t *q);

វាល _q_ឈប់ (តទៅនេះយើងនឹងហៅវាថា "ឈប់") ត្រូវបានចាប់ផ្តើមដោយមុខងារ mblk_init()ធាតុមុនរបស់វា និងទ្រនិចធាតុបន្ទាប់ត្រូវបានកែតម្រូវដើម្បីចង្អុលទៅខ្លួនវាផ្ទាល់។ ការរាប់ធាតុជួរត្រូវបានកំណត់ឡើងវិញទៅសូន្យ។

ការបន្ថែមធាតុថ្មី (សារ)៖

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

ធាតុថ្មី។ m ត្រូវ​បាន​បន្ថែម​ទៅ​ខាង​ចុង​នៃ​បញ្ជី ទ្រនិច​ធាតុ​ត្រូវ​បាន​កែ​សម្រួល ដូច្នេះ​ stopper ក្លាយ​ជា​ធាតុ​បន្ទាប់​សម្រាប់​វា ហើយ​វា​ក្លាយ​ជា​ធាតុ​មុន​សម្រាប់ stopper ។ ការរាប់ធាតុជួរត្រូវបានបង្កើន។

ការទាញយកធាតុពីជួរ៖

mblk_t * getq(queue_t *q); 

សារដែលមកបន្ទាប់ពីស្តុបត្រូវបានទាញយកមកវិញ ហើយការរាប់ធាតុត្រូវបានបន្ថយ។ ប្រសិនបើមិនមានធាតុនៅក្នុងជួរទេលើកលែងតែ stopper នោះ 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).

ការភ្ជាប់តម្រង

ជួរដែលបានពិពណ៌នាខាងលើត្រូវបានប្រើដើម្បីបញ្ជូនសារពីតម្រងមួយទៅតម្រងមួយទៀត ឬពីតម្រងមួយទៅតម្រងជាច្រើន។ តម្រង និងការតភ្ជាប់របស់ពួកគេបង្កើតជាក្រាហ្វដឹកនាំ។ ការបញ្ចូលឬលទ្ធផលនៃតម្រងនឹងត្រូវបានគេហៅថាពាក្យទូទៅ "pin" ។ ដើម្បីពិពណ៌នាអំពីលំដាប់ដែលតម្រងត្រូវបានភ្ជាប់ទៅគ្នាទៅវិញទៅមក អ្នកផ្សាយព័ត៌មានប្រើប្រាស់គំនិតនៃ "ចំណុចសញ្ញា" ។ ចំណុចសញ្ញាគឺជារចនាសម្ព័ន្ធ _MSCPPointដែលផ្ទុកទ្រនិចទៅតម្រង និងចំនួនម្ជុលមួយរបស់វា តាមនោះ វាពិពណ៌នាអំពីការតភ្ជាប់នៃធាតុបញ្ចូល ឬលទ្ធផលនៃតម្រង។

ចំណុចសញ្ញានៃក្រាហ្វដំណើរការទិន្នន័យ

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

ម្ជុលតម្រងត្រូវបានដាក់លេខដោយចាប់ផ្តើមពីសូន្យ។

ការភ្ជាប់ម្ជុលពីរដោយជួរសារត្រូវបានពិពណ៌នាដោយរចនាសម្ព័ន្ធ _MSQueueដែលមានជួរសារ និងចង្អុលទៅចំណុចសញ្ញាពីរដែលវាភ្ជាប់៖

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

យើងនឹងហៅរចនាសម្ព័ន្ធនេះថាជាតំណភ្ជាប់សញ្ញា។ តម្រងប្រព័ន្ធផ្សព្វផ្សាយនីមួយៗមានតារាងនៃតំណភ្ជាប់បញ្ចូល និងតារាងនៃតំណភ្ជាប់លទ្ធផល (MSQueue) ទំហំនៃតារាងត្រូវបានកំណត់នៅពេលបង្កើតតម្រង យើងបានធ្វើរួចហើយដោយប្រើអថេរដែលបាននាំចេញនៃប្រភេទ MSFilterDescនៅពេលដែលយើងបង្កើតតម្រងផ្ទាល់ខ្លួនរបស់យើង។ ខាងក្រោមនេះគឺជារចនាសម្ព័ន្ធដែលពិពណ៌នាអំពីតម្រងណាមួយនៅក្នុងកម្មវិធីផ្សាយមេឌៀ តម្រង MSF:

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 ដោយ​អនុលោម​តាម​គម្រោង​របស់​យើង (ប៉ុន្តែ​មិន​បាន​ភ្ជាប់​សញ្ញា​ធីក) ដោយ​ហេតុ​នេះ​យើង​បាន​បង្កើត​ក្រាហ្វ​ដែល​បាន​ដឹកនាំ​ដែល​ជា​ឧទាហរណ៍​នៃ​រចនាសម្ព័ន្ធ តម្រង MSFហើយគែមគឺជាឧទាហរណ៍នៃតំណភ្ជាប់ MSQueue.

សកម្មភាពនៅពីក្រោយឆាករបស់ ticker

នៅពេលដែលខ្ញុំបានប្រាប់អ្នកថា ticker គឺជាតម្រងសម្រាប់ប្រភពនៃឆ្ក វាមិនមែនជាការពិតទាំងស្រុងអំពីវានោះទេ។ សញ្ញាធីកគឺជាវត្ថុដែលដំណើរការមុខងារនៅលើនាឡិកា ដំណើរការ() តម្រងទាំងអស់នៃសៀគ្វី (ក្រាហ្វ) ដែលវាត្រូវបានភ្ជាប់។ នៅពេលយើងភ្ជាប់ ticker ទៅនឹងតម្រងក្រាហ្វក្នុងកម្មវិធី C យើងបង្ហាញសញ្ញាធីកក្រាហ្វដែលវានឹងគ្រប់គ្រងចាប់ពីពេលនេះតទៅរហូតដល់យើងបិទវា។ បន្ទាប់ពីភ្ជាប់ ធីកចាប់ផ្តើមពិនិត្យមើលក្រាហ្វដែលប្រគល់ឱ្យការថែទាំរបស់វា ដោយចងក្រងបញ្ជីតម្រងដែលរួមបញ្ចូលវា។ ដើម្បីកុំឱ្យ "រាប់" តម្រងដូចគ្នាពីរដង វាសម្គាល់តម្រងដែលបានរកឃើញដោយដាក់ប្រអប់ធីកនៅក្នុងពួកវា បានឃើញ. ការស្វែងរកត្រូវបានអនុវត្តដោយប្រើតារាងតំណដែលតម្រងនីមួយៗមាន។

ក្នុងអំឡុងពេលដំណើរទេសចរណ៍ណែនាំនៃក្រាហ្វនេះ ធីកឃឺពិនិត្យមើលថាតើក្នុងចំណោមតម្រងមានយ៉ាងហោចណាស់មួយ ដែលដើរតួជាប្រភពនៃប្លុកទិន្នន័យ។ ប្រសិនបើមិនមានទេ នោះក្រាហ្វត្រូវបានចាត់ទុកថាមិនត្រឹមត្រូវ ហើយសន្លឹកឆ្នោតគាំង។

ប្រសិនបើក្រាហ្វប្រែថា "ត្រឹមត្រូវ" សម្រាប់តម្រងដែលបានរកឃើញនីមួយៗ មុខងារត្រូវបានហៅឱ្យចាប់ផ្តើម ដំណើរការមុន (). ដរាបណាពេលមកដល់សម្រាប់វដ្តដំណើរការបន្ទាប់ (រៀងរាល់ 10 មិល្លីវិនាទីតាមលំនាំដើម) ធីកហៅមុខងារ ដំណើរការ() សម្រាប់តម្រងប្រភពដែលបានរកឃើញពីមុនទាំងអស់ ហើយបន្ទាប់មកសម្រាប់តម្រងដែលនៅសល់ក្នុងបញ្ជី។ ប្រសិនបើតម្រងមានតំណភ្ជាប់បញ្ចូល បន្ទាប់មកដំណើរការមុខងារ ដំណើរការ() ធ្វើម្តងទៀតរហូតដល់ជួរនៃតំណបញ្ចូលគឺទទេ។ បន្ទាប់ពីនេះ វាបន្តទៅតម្រងបន្ទាប់នៅក្នុងបញ្ជី ហើយ "រមូរ" វារហូតទាល់តែតំណភ្ជាប់បញ្ចូលមិនមានសារ។ សំបុត្រផ្លាស់ទីពីតម្រងមួយទៅតម្រងរហូតដល់បញ្ជីបញ្ចប់។ នេះបញ្ចប់ដំណើរការនៃវដ្ត។

ឥឡូវនេះយើងនឹងត្រលប់ទៅ tuples ហើយនិយាយអំពីមូលហេតុដែលអង្គភាពបែបនេះត្រូវបានបន្ថែមទៅអ្នកផ្សាយព័ត៌មាន។ ជាទូទៅ បរិមាណទិន្នន័យដែលទាមទារដោយក្បួនដោះស្រាយដែលដំណើរការនៅខាងក្នុងតម្រងមិនស្របគ្នាទេ ហើយមិនមែនជាពហុគុណនៃទំហំផ្ទុកទិន្នន័យដែលទទួលបាននៅពេលបញ្ចូលនោះទេ។ ឧទាហរណ៍ យើងកំពុងសរសេរតម្រងដែលដំណើរការបំលែង Fourier លឿន ដែលតាមនិយមន័យអាចដំណើរការបានតែប្លុកទិន្នន័យដែលទំហំរបស់វាមានថាមពលពីរប៉ុណ្ណោះ។ សូមឱ្យវាមានចំនួន 512 ។ ប្រសិនបើទិន្នន័យត្រូវបានបង្កើតដោយបណ្តាញទូរស័ព្ទ នោះបណ្តុំទិន្នន័យនៃសារនីមួយៗនៅពេលបញ្ចូលនឹងនាំមកយើងនូវគំរូសញ្ញាចំនួន 160 ។ វាទាក់ទាញមិនឱ្យប្រមូលទិន្នន័យពីការបញ្ចូលរហូតដល់ចំនួនទិន្នន័យដែលត្រូវការនៅទីនោះ។ ប៉ុន្តែក្នុងករណីនេះ ការប៉ះទង្គិចនឹងកើតឡើងជាមួយសញ្ញាធីក ដែលនឹងមិនជោគជ័យក្នុងការព្យាយាមរមូរតម្រងរហូតដល់តំណបញ្ចូលទទេ។ ពីមុនយើងបានកំណត់ច្បាប់នេះជាគោលការណ៍ទីបីនៃតម្រង។ យោងតាមគោលការណ៍នេះ មុខងាររបស់តម្រងត្រូវតែយកទិន្នន័យទាំងអស់ពីជួរបញ្ចូល។

លើសពីនេះទៀតវានឹងមិនអាចយកតែ 512 គំរូពីការបញ្ចូលបានទេព្រោះអ្នកអាចយកតែប្លុកទាំងមូលពោលគឺឧ។ តម្រងនឹងត្រូវយកគំរូចំនួន 640 ហើយប្រើប្រាស់ 512 ក្នុងចំណោមពួកគេ ដែលនៅសេសសល់មុននឹងប្រមូលផ្តុំផ្នែកថ្មីមួយនៃទិន្នន័យ។ ដូច្នេះ តម្រងរបស់យើង បន្ថែមពីលើការងារចម្បងរបស់វា ត្រូវតែផ្តល់សកម្មភាពជំនួយសម្រាប់ការផ្ទុកទិន្នន័យបញ្ចូលកម្រិតមធ្យម។ អ្នកបង្កើតកម្មវិធីផ្សាយមេឌៀ និងដំណោះស្រាយចំពោះបញ្ហាទូទៅនេះបានបង្កើតវត្ថុពិសេសមួយ - MSBufferizer (bufferer) ដែលដោះស្រាយបញ្ហានេះដោយប្រើ tuples ។

Bufferizer (MSBufferizer)

នេះគឺជាវត្ថុដែលនឹងប្រមូលផ្តុំទិន្នន័យបញ្ចូលនៅខាងក្នុងតម្រង ហើយចាប់ផ្តើមបញ្ជូនវាសម្រាប់ដំណើរការភ្លាមៗនៅពេលដែលចំនួនព័ត៌មានគ្រប់គ្រាន់ដើម្បីដំណើរការក្បួនដោះស្រាយតម្រង។ ខណៈពេលដែលសតិបណ្ដោះអាសន្នកំពុងប្រមូលទិន្នន័យ តម្រងនឹងដំណើរការក្នុងរបៀបទំនេរ ដោយមិនប្រើប្រាស់ថាមពលដំណើរការរបស់ខួរក្បាល។ ប៉ុន្តែដរាបណាមុខងារអានពីសតិបណ្ដោះអាសន្នត្រឡប់តម្លៃផ្សេងពីសូន្យ មុខងារដំណើរការ() របស់តម្រងចាប់ផ្តើមយក និងដំណើរការទិន្នន័យពីសតិបណ្ដោះអាសន្នក្នុងផ្នែកនៃទំហំដែលត្រូវការ រហូតដល់វាអស់។
ទិន្នន័យដែលមិនទាន់ត្រូវបានទាមទារនៅតែមាននៅក្នុងសតិបណ្ដោះអាសន្នដែលជាធាតុដំបូងនៃ 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); 

ប្រសិនបើទំហំនៃទិន្នន័យដែលបានបង្គរនៅក្នុងសតិបណ្ដោះអាសន្នគឺតិចជាងចំនួនដែលបានស្នើសុំ (ទិន្នន័យ) បន្ទាប់មកមុខងារត្រឡប់សូន្យទិន្នន័យមិនត្រូវបានចម្លងទៅទិន្នន័យទេ។ បើមិនដូច្នេះទេ ការចម្លងទិន្នន័យតាមលំដាប់លំដោយពី tuples ដែលមានទីតាំងនៅក្នុងសតិបណ្ដោះអាសន្នត្រូវបានអនុវត្ត។ បន្ទាប់ពីថតចម្លង tuple ត្រូវបានលុបហើយអង្គចងចាំត្រូវបានដោះលែង។ ការចម្លងបញ្ចប់នៅពេល datalen bytes ត្រូវបានចម្លង។ ប្រសិនបើទំហំទំនេរអស់នៅចំកណ្តាលប្លុកទិន្នន័យ នោះនៅក្នុងសារនេះ ប្លុកទិន្នន័យនឹងត្រូវបានកាត់បន្ថយទៅផ្នែកដែលមិនទាន់បានចម្លង។ នៅពេលដែលអ្នកទូរស័ព្ទទៅលើកក្រោយ ការចម្លងនឹងបន្តពីចំណុចនេះ។

ការអានចំនួនទិន្នន័យដែលបច្ចុប្បន្នមាននៅក្នុងបណ្តុំ៖

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);  

ឧទាហរណ៍នៃការប្រើប្រាស់ bufferer អាចរកបាននៅក្នុង source code នៃ media streamer filters ជាច្រើន។ ឧទាហរណ៍ នៅក្នុងតម្រង MS_L16_ENC ដែលរៀបចំឡើងវិញបៃក្នុងគំរូពីលំដាប់បណ្តាញទៅលំដាប់ម៉ាស៊ីន៖ l16.c

នៅក្នុងអត្ថបទបន្ទាប់ យើងនឹងពិនិត្យមើលបញ្ហានៃការប៉ាន់ប្រមាណការផ្ទុក ticker និងរបៀបដោះស្រាយជាមួយនឹងការផ្ទុកកុំព្យូទ័រលើសលប់នៅក្នុង media streamer។

ប្រភព: www.habr.com