Mediastreamer2 VoIP എഞ്ചിൻ പര്യവേക്ഷണം ചെയ്യുന്നു. ഭാഗം 11

ലേഖനത്തിന്റെ മെറ്റീരിയൽ എന്റെതിൽ നിന്ന് എടുത്തതാണ് സെൻ ചാനൽ.

ഡാറ്റ ചലന സംവിധാനം

• ഡാറ്റ ബ്ലോക്ക് dblk_t
• സന്ദേശം mblk_t
• mblk_t സന്ദേശങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ
• ക്യൂ ക്യൂ_t
• ക്യൂകൾ queue_t ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ
• ഫിൽട്ടറുകൾ ബന്ധിപ്പിക്കുന്നു
• ഡാറ്റ പ്രോസസ്സിംഗ് ഗ്രാഫിന്റെ സിഗ്നൽ പോയിന്റ്
• ടിക്കറിന്റെ തിരശ്ശീലയ്ക്ക് പിന്നിലെ പ്രവർത്തനങ്ങൾ
• ബഫറൈസർ (MSBufferizer)
• MSBufferizer-നൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ

അവസാനത്തിൽ ലേഖനം ഞങ്ങൾ ഞങ്ങളുടെ സ്വന്തം ഫിൽട്ടർ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്. മീഡിയ സ്ട്രീമർ ഫിൽട്ടറുകൾക്കിടയിൽ ഡാറ്റ നീക്കുന്നതിനുള്ള ആന്തരിക സംവിധാനത്തിൽ ഈ ലേഖനം ശ്രദ്ധ കേന്ദ്രീകരിക്കും. ഭാവിയിൽ കുറഞ്ഞ പ്രയത്നത്തിൽ സങ്കീർണ്ണമായ ഫിൽട്ടറുകൾ എഴുതാൻ ഇത് നിങ്ങളെ അനുവദിക്കും.

ഡാറ്റ ചലന സംവിധാനം

ഘടന വിവരിച്ചിരിക്കുന്ന ക്യൂകൾ ഉപയോഗിച്ചാണ് മീഡിയ സ്ട്രീമറിലെ ഡാറ്റാ ചലനം നടത്തുന്നത് ക്യൂ_ടി. തുടങ്ങിയ സന്ദേശങ്ങളുടെ വരികൾ mblk_t, അവയിൽ തന്നെ സിഗ്നൽ ഡാറ്റ അടങ്ങിയിട്ടില്ല, എന്നാൽ മുമ്പത്തെ, അടുത്ത സന്ദേശത്തിലേക്കും ഡാറ്റ ബ്ലോക്കിലേക്കും ലിങ്കുകൾ മാത്രം. കൂടാതെ, ഒരേ തരത്തിലുള്ള ഒരു സന്ദേശത്തിലേക്കുള്ള ലിങ്കിനായി ഒരു ഫീൽഡും ഉണ്ടെന്ന് ഞാൻ പ്രത്യേകം ഊന്നിപ്പറയാൻ ആഗ്രഹിക്കുന്നു, അത് ഒറ്റ ലിങ്ക് ചെയ്ത സന്ദേശങ്ങളുടെ ലിസ്റ്റ് സംഘടിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അത്തരത്തിലുള്ള ഒരു ലിസ്റ്റിനാൽ ഏകീകരിക്കപ്പെട്ട ഒരു കൂട്ടം സന്ദേശങ്ങളെ ഞങ്ങൾ ട്യൂപ്പിൾ എന്ന് വിളിക്കും. അങ്ങനെ, ക്യൂവിന്റെ ഏത് ഘടകവും ഒരൊറ്റ സന്ദേശമാകാം mblk_t, ഒരുപക്ഷേ ഒരു സന്ദേശ ട്യൂപ്പിളിന്റെ തലവൻ mblk_t. ഓരോ ട്യൂപ്പിൾ സന്ദേശത്തിനും അതിന്റേതായ വാർഡ് ഡാറ്റ ബ്ലോക്ക് ഉണ്ടായിരിക്കും. എന്തുകൊണ്ടാണ് ട്യൂപ്പിൾസ് ആവശ്യമായി വരുന്നത് എന്ന് ഞങ്ങൾ കുറച്ച് കഴിഞ്ഞ് ചർച്ച ചെയ്യും.

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, സന്ദേശത്തിൽ തന്നെ ഡാറ്റയുടെ ഒരു ബ്ലോക്ക് അടങ്ങിയിട്ടില്ല; പകരം, ബ്ലോക്ക് സംഭരിച്ചിരിക്കുന്ന മെമ്മറി ഏരിയയിലേക്കുള്ള ഒരു പോയിന്റർ മാത്രമേ അതിൽ അടങ്ങിയിട്ടുള്ളൂ. ഈ ഭാഗത്ത്, മീഡിയ സ്ട്രീമറിന്റെ പ്രവർത്തനത്തിന്റെ മൊത്തത്തിലുള്ള ചിത്രം "മോൺസ്റ്റേഴ്സ്, ഇൻക്" എന്ന കാർട്ടൂണിലെ ഡോർ വെയർഹൗസിനെ അനുസ്മരിപ്പിക്കുന്നു, അവിടെ വാതിലുകൾ (ഡാറ്റ - റൂമുകളിലേക്കുള്ള ലിങ്കുകൾ) ഓവർഹെഡ് കൺവെയറിലൂടെ ഭ്രാന്തമായ വേഗതയിൽ നീങ്ങുന്നു, അതേസമയം മുറികൾ തന്നെ. അനങ്ങാതെ ഇരിക്കുക.

ഇപ്പോൾ, താഴെ നിന്ന് മുകളിലേക്ക് ശ്രേണിയിലൂടെ നീങ്ങുമ്പോൾ, മീഡിയ സ്ട്രീമറിലെ ഡാറ്റാ ട്രാൻസ്മിഷൻ മെക്കാനിസത്തിന്റെ ലിസ്റ്റ് ചെയ്ത എന്റിറ്റികൾ വിശദമായി പരിഗണിക്കാം.

ഡാറ്റ ബ്ലോക്ക് 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_അടുത്തത്, ഇരട്ടി ലിങ്ക് ചെയ്‌ത ലിസ്‌റ്റ് ഓർഗനൈസുചെയ്യാൻ ആവശ്യമായവ (അതൊരു ക്യൂ ആണ് ക്യൂ_ടി).

അപ്പോൾ പോയിന്റർ വരുന്നു b_cont, സന്ദേശം ഒരു ട്യൂപ്പിളിന്റെ ഭാഗമാകുമ്പോൾ മാത്രമേ ഉപയോഗിക്കൂ. ട്യൂപ്പിളിലെ അവസാന സന്ദേശത്തിന്, ഈ പോയിന്റർ അസാധുവായി തുടരുന്നു.

അടുത്തതായി നമ്മൾ ഒരു ഡാറ്റ ബ്ലോക്കിലേക്കുള്ള ഒരു പോയിന്റർ കാണുന്നു 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);

എവിടെ ഡാറ്റ ഡാറ്റ ഉറവിടത്തിലേക്കുള്ള ഒരു പോയിന്ററാണ്, കൂടാതെ വലുപ്പം - അവരുടെ വലിപ്പം.
തുടർന്ന് നിങ്ങൾ പോയിന്റർ റൈറ്റ് പോയിന്റിലേക്ക് അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട്, അങ്ങനെ അത് ബഫറിലെ ഫ്രീ ഏരിയയുടെ തുടക്കത്തിലേക്ക് വീണ്ടും ചൂണ്ടിക്കാണിക്കുന്നു:

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 - മറ്റൊരു ഡാറ്റ ബ്ലോക്ക് ചേർക്കുന്ന ഒരു സന്ദേശം;
ഡാറ്റ - ബ്ലോക്കിലേക്കുള്ള പോയിന്റർ, അതിന്റെ ഒരു പകർപ്പ് സന്ദേശത്തിലേക്ക് ചേർക്കും;
വലുപ്പം - ഡാറ്റ വലുപ്പം;
പാഡ് - അനുവദിച്ച മെമ്മറിയുടെ വലുപ്പം 4-ബൈറ്റ് അതിർത്തിയിൽ വിന്യസിച്ചിരിക്കേണ്ട ഒരു ഫ്ലാഗ് (പൂജ്യം ഉപയോഗിച്ചായിരിക്കും പാഡിംഗ് നടത്തുക).

നിലവിലുള്ള സന്ദേശ ഡാറ്റ ബഫറിൽ മതിയായ ഇടമുണ്ടെങ്കിൽ, പുതിയ ഡാറ്റ ഇതിനകം അവിടെയുള്ള ഡാറ്റയ്ക്ക് പിന്നിൽ ഒട്ടിക്കും. സന്ദേശ ഡാറ്റ ബഫറിൽ ശൂന്യമായ ഇടം കുറവാണെങ്കിൽ വലുപ്പം, തുടർന്ന് മതിയായ ബഫർ വലുപ്പത്തിൽ ഒരു പുതിയ സന്ദേശം സൃഷ്ടിക്കുകയും ഡാറ്റ അതിന്റെ ബഫറിലേക്ക് പകർത്തുകയും ചെയ്യുന്നു. ഇതൊരു പുതിയ സന്ദേശമാണ്, ഒരു പോയിന്റർ ഉപയോഗിച്ച് യഥാർത്ഥ സന്ദേശവുമായി ലിങ്ക് ചെയ്‌തിരിക്കുന്നു b_cont. ഈ സാഹചര്യത്തിൽ, സന്ദേശം ഒരു ട്യൂപ്പിൾ ആയി മാറുന്നു.

നിങ്ങൾക്ക് ട്യൂപ്പിളിലേക്ക് മറ്റൊരു ബ്ലോക്ക് ഡാറ്റ ചേർക്കണമെങ്കിൽ, നിങ്ങൾ ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്:

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

അവൾ ട്യൂപ്പിളിൽ അവസാന സന്ദേശം കണ്ടെത്തും (അവനുണ്ട് b_cont അസാധുവായിരിക്കും) കൂടാതെ ഈ സന്ദേശത്തിനായി ഫംഗ്‌ഷനെ വിളിക്കും appendb().

ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സന്ദേശത്തിലോ ട്യൂപ്പിളിലോ ഡാറ്റയുടെ വലുപ്പം കണ്ടെത്താനാകും:

int msgdsize(const mblk_t *mp);

ഇത് ട്യൂപ്പിളിലെ എല്ലാ സന്ദേശങ്ങളിലൂടെയും ലൂപ്പ് ചെയ്യുകയും ആ സന്ദേശങ്ങളുടെ ഡാറ്റ ബഫറുകളിലെ ഡാറ്റയുടെ ആകെ തുക തിരികെ നൽകുകയും ചെയ്യും. ഓരോ സന്ദേശത്തിനും, ഡാറ്റയുടെ അളവ് ഇനിപ്പറയുന്ന രീതിയിൽ കണക്കാക്കുന്നു:

 mp->b_wptr - mp->b_rptr

രണ്ട് ട്യൂപ്പിളുകൾ സംയോജിപ്പിക്കാൻ, ഫംഗ്ഷൻ ഉപയോഗിക്കുക:

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

അവൾ ട്യൂപ്പിൾ കൂട്ടിച്ചേർക്കുന്നു പുതിയ ട്യൂപ്പിളിന്റെ വാൽ വരെ mp തത്ഫലമായുണ്ടാകുന്ന ട്യൂപ്പിളിന്റെ അവസാന സന്ദേശത്തിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുന്നു.

ആവശ്യമെങ്കിൽ, ഒരൊറ്റ ബ്ലോക്ക് ഡാറ്റ ഉപയോഗിച്ച് ഒരു ട്യൂപ്പിൾ ഒരു സന്ദേശമാക്കി മാറ്റാം; ഇത് ഫംഗ്ഷൻ വഴിയാണ് ചെയ്യുന്നത്:

void msgpullup(mblk_t *mp,int len);

എങ്കിൽ വാദം ലെൻ -1 ആണ്, അപ്പോൾ അനുവദിച്ച ബഫറിന്റെ വലുപ്പം യാന്ത്രികമായി നിർണ്ണയിക്കപ്പെടുന്നു. എങ്കിൽ ലെൻ ഒരു പോസിറ്റീവ് സംഖ്യയാണ്, ഈ വലുപ്പത്തിലുള്ള ഒരു ബഫർ സൃഷ്‌ടിക്കുകയും ട്യൂപ്പിൾ സന്ദേശ ഡാറ്റ അതിലേക്ക് പകർത്തുകയും ചെയ്യും. ബഫർ തീർന്നാൽ, പകർത്തൽ അവിടെ നിർത്തും. 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);

പുതിയ ഡാറ്റ സന്ദേശ ഡാറ്റ ബഫറിന്റെ ശൂന്യമായ ഇടത്തിലേക്ക് യോജിച്ചില്ലെങ്കിൽ, ആവശ്യമുള്ള വലുപ്പത്തിലുള്ള ഒരു ബഫർ ഉപയോഗിച്ച് പ്രത്യേകം സൃഷ്‌ടിച്ച സന്ദേശം സന്ദേശവുമായി അറ്റാച്ചുചെയ്യുന്നു (ചേർത്ത സന്ദേശത്തിലേക്കുള്ള ഒരു പോയിന്റർ ആദ്യ സന്ദേശത്തിൽ സജ്ജീകരിച്ചിരിക്കുന്നു) കൂടാതെ സന്ദേശം ഒരു ട്യൂപ്പിൾ ആയി മാറുന്നു.

ഒരു ട്യൂപ്പിളിലേക്ക് ഒരു കഷണം ഡാറ്റ ചേർക്കുന്നു:

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

വാദം എങ്കിൽ ലെൻ -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_സ്റ്റോപ്പർ *mblk_t എന്ന് ടൈപ്പ് ചെയ്യുക, അത് ക്യൂവിലെ ആദ്യ ഘടകത്തിലേക്ക് (സന്ദേശം) സൂചിപ്പിക്കുന്നു. ഘടനയുടെ രണ്ടാമത്തെ ഫീൽഡ് ക്യൂവിലെ സന്ദേശങ്ങളുടെ കൗണ്ടറാണ്.
m1, m4, m1, m2 എന്നീ 3 സന്ദേശങ്ങൾ അടങ്ങിയ q4 എന്ന് പേരുള്ള ഒരു ക്യൂ താഴെയുള്ള ചിത്രം കാണിക്കുന്നു.

m1,m4,m1,m2 എന്നീ 3 സന്ദേശങ്ങൾ അടങ്ങിയ q4 എന്ന പേരിലുള്ള ഒരു ക്യൂ താഴെയുള്ള ചിത്രം കാണിക്കുന്നു. m2_2, m1_2 എന്നീ രണ്ട് സന്ദേശങ്ങൾ കൂടി ഉൾക്കൊള്ളുന്ന ട്യൂപ്പിളിന്റെ തലയാണ് സന്ദേശം m2.

ക്യൂകൾ queue_t ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ

ക്യൂ ആരംഭിക്കൽ:

void qinit(queue_t *q);

ഫീൽഡ് _q_സ്റ്റോപ്പർ (ഇനി മുതൽ ഞങ്ങൾ അതിനെ "സ്റ്റോപ്പർ" എന്ന് വിളിക്കും) ഫംഗ്ഷൻ ഉപയോഗിച്ച് ആരംഭിക്കുന്നു 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 മൂലകത്തിന് മുമ്പ് ചേർത്തു എംപ്. എങ്കിൽ എംപ്=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).

ഫിൽട്ടറുകൾ ബന്ധിപ്പിക്കുന്നു

മുകളിൽ വിവരിച്ച ക്യൂ ഒരു ഫിൽട്ടറിൽ നിന്ന് മറ്റൊന്നിലേക്കോ ഒന്നിൽ നിന്ന് നിരവധി ഫിൽട്ടറുകളിലേക്കോ സന്ദേശങ്ങൾ കൈമാറാൻ ഉപയോഗിക്കുന്നു. ഫിൽട്ടറുകളും അവയുടെ കണക്ഷനുകളും ഒരു ഡയറക്ട് ഗ്രാഫ് രൂപപ്പെടുത്തുന്നു. ഫിൽട്ടറിന്റെ ഇൻപുട്ട് അല്ലെങ്കിൽ ഔട്ട്പുട്ട് പൊതുവായ വാക്ക് "പിൻ" എന്ന് വിളിക്കപ്പെടും. ഫിൽട്ടറുകൾ പരസ്പരം ബന്ധിപ്പിച്ചിരിക്കുന്ന ക്രമം വിവരിക്കാൻ, മീഡിയ സ്ട്രീമർ ഒരു "സിഗ്നൽ പോയിന്റ്" എന്ന ആശയം ഉപയോഗിക്കുന്നു. സിഗ്നൽ പോയിന്റ് ഘടനയാണ് _MSCPപോയിന്റ്, അതിൽ ഫിൽട്ടറിലേക്കുള്ള ഒരു പോയിന്ററും അതിന്റെ പിന്നുകളിൽ ഒന്നിന്റെ എണ്ണവും അടങ്ങിയിരിക്കുന്നു; അതനുസരിച്ച്, ഫിൽട്ടറിന്റെ ഇൻപുട്ടുകളിലോ ഔട്ട്പുട്ടുകളിലോ ഒന്നിന്റെ കണക്ഷൻ ഇത് വിവരിക്കുന്നു.

ഡാറ്റ പ്രോസസ്സിംഗ് ഗ്രാഫിന്റെ സിഗ്നൽ പോയിന്റ്

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

ഫിൽട്ടർ പിന്നുകൾ പൂജ്യത്തിൽ നിന്ന് ആരംഭിക്കുന്നു.

ഒരു സന്ദേശ ക്യൂ വഴി രണ്ട് പിന്നുകളുടെ കണക്ഷൻ ഘടനയാൽ വിവരിച്ചിരിക്കുന്നു _എംഎസ്ക്യൂ, അതിൽ ഒരു സന്ദേശ ക്യൂവും അത് ബന്ധിപ്പിക്കുന്ന രണ്ട് സിഗ്നൽ പോയിന്റുകളിലേക്കുള്ള പോയിന്ററുകളും അടങ്ങിയിരിക്കുന്നു:

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;

ഞങ്ങളുടെ പ്ലാനിന് അനുസൃതമായി സി പ്രോഗ്രാമിലെ ഫിൽട്ടറുകൾ കണക്റ്റുചെയ്‌ത ശേഷം (എന്നാൽ ടിക്കർ കണക്റ്റുചെയ്‌തിട്ടില്ല), അതുവഴി ഞങ്ങൾ ഒരു ഡയറക്‌റ്റ് ഗ്രാഫ് സൃഷ്‌ടിച്ചു, അതിന്റെ നോഡുകൾ ഘടനയുടെ ഉദാഹരണങ്ങളാണ് MSFilter, ഒപ്പം അരികുകൾ ലിങ്കുകളുടെ ഉദാഹരണങ്ങളാണ് MSQueue.

ടിക്കറിന്റെ തിരശ്ശീലയ്ക്ക് പിന്നിലെ പ്രവർത്തനങ്ങൾ

ടിക്കർ ടിക്കുകളുടെ ഉറവിടത്തിനുള്ള ഫിൽട്ടറാണെന്ന് ഞാൻ നിങ്ങളോട് പറഞ്ഞപ്പോൾ, അതിനെക്കുറിച്ച് മുഴുവൻ സത്യമായിരുന്നില്ല. ക്ലോക്കിൽ പ്രവർത്തനങ്ങൾ നടത്തുന്ന ഒരു വസ്തുവാണ് ടിക്കർ പ്രക്രിയ() അത് ബന്ധിപ്പിച്ചിരിക്കുന്ന സർക്യൂട്ടിന്റെ (ഗ്രാഫ്) എല്ലാ ഫിൽട്ടറുകളും. ഒരു സി പ്രോഗ്രാമിലെ ഗ്രാഫ് ഫിൽട്ടറിലേക്ക് ഒരു ടിക്കറിനെ ബന്ധിപ്പിക്കുമ്പോൾ, അത് ഓഫ് ചെയ്യുന്നതുവരെ ടിക്കർ നിയന്ത്രിക്കുന്ന ഗ്രാഫ് ഞങ്ങൾ കാണിക്കുന്നു. കണക്റ്റുചെയ്‌തതിനുശേഷം, ടിക്കർ അതിന്റെ പരിചരണത്തിൽ ഏൽപ്പിച്ചിരിക്കുന്ന ഗ്രാഫ് പരിശോധിക്കാൻ തുടങ്ങുന്നു, അതിൽ ഉൾപ്പെടുന്ന ഫിൽട്ടറുകളുടെ ഒരു ലിസ്റ്റ് കംപൈൽ ചെയ്യുന്നു. ഒരേ ഫിൽട്ടർ രണ്ടുതവണ "എണ്ണം" ചെയ്യാതിരിക്കാൻ, കണ്ടെത്തിയ ഫിൽട്ടറുകളിൽ ഒരു ചെക്ക്ബോക്സ് സ്ഥാപിച്ച് അത് അടയാളപ്പെടുത്തുന്നു. seen. ഓരോ ഫിൽട്ടറും ഉള്ള ലിങ്ക് ടേബിളുകൾ ഉപയോഗിച്ചാണ് തിരയൽ നടത്തുന്നത്.

ഗ്രാഫിന്റെ ആമുഖ ടൂർ സമയത്ത്, ഫിൽട്ടറുകൾക്കിടയിൽ ഡാറ്റ ബ്ലോക്കുകളുടെ ഉറവിടമായി പ്രവർത്തിക്കുന്ന ഒരെണ്ണമെങ്കിലും ഉണ്ടോ എന്ന് ടിക്കർ പരിശോധിക്കുന്നു. ഒന്നുമില്ലെങ്കിൽ, ഗ്രാഫ് തെറ്റായി കണക്കാക്കുകയും ടിക്കർ തകരുകയും ചെയ്യും.

ഗ്രാഫ് "ശരിയാണ്" എന്ന് മാറുകയാണെങ്കിൽ, കണ്ടെത്തിയ ഓരോ ഫിൽട്ടറിനും, ഫംഗ്ഷൻ ആരംഭിക്കുന്നതിന് വിളിക്കുന്നു പ്രീപ്രോസസ്(). അടുത്ത പ്രോസസ്സിംഗ് സൈക്കിളിനുള്ള നിമിഷം വന്നാലുടൻ (ഓരോ 10 മില്ലിസെക്കൻഡിലും സ്ഥിരസ്ഥിതിയായി), ടിക്കർ ഫംഗ്‌ഷനെ വിളിക്കുന്നു പ്രക്രിയ() മുമ്പ് കണ്ടെത്തിയ എല്ലാ ഉറവിട ഫിൽട്ടറുകൾക്കും തുടർന്ന് ലിസ്റ്റിലെ ശേഷിക്കുന്ന ഫിൽട്ടറുകൾക്കും. ഫിൽട്ടറിന് ഇൻപുട്ട് ലിങ്കുകൾ ഉണ്ടെങ്കിൽ, ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുക പ്രക്രിയ() ഇൻപുട്ട് ലിങ്ക് ക്യൂകൾ ശൂന്യമാകുന്നതുവരെ ആവർത്തിക്കുന്നു. ഇതിനുശേഷം, ഇത് ലിസ്റ്റിലെ അടുത്ത ഫിൽട്ടറിലേക്ക് നീങ്ങുകയും ഇൻപുട്ട് ലിങ്കുകൾ സന്ദേശങ്ങളിൽ നിന്ന് മുക്തമാകുന്നതുവരെ അത് "സ്ക്രോൾ" ചെയ്യുകയും ചെയ്യുന്നു. ലിസ്റ്റ് അവസാനിക്കുന്നത് വരെ ടിക്കർ ഫിൽട്ടറിൽ നിന്ന് ഫിൽട്ടറിലേക്ക് നീങ്ങുന്നു. ഇത് സൈക്കിളിന്റെ പ്രോസസ്സിംഗ് പൂർത്തിയാക്കുന്നു.

ഇപ്പോൾ ഞങ്ങൾ ട്യൂപ്പിലിലേക്ക് മടങ്ങുകയും മീഡിയ സ്ട്രീമറിലേക്ക് എന്തുകൊണ്ടാണ് അത്തരമൊരു എന്റിറ്റി ചേർത്തത് എന്നതിനെക്കുറിച്ച് സംസാരിക്കുകയും ചെയ്യും. പൊതുവേ, ഫിൽട്ടറിനുള്ളിൽ പ്രവർത്തിക്കുന്ന അൽഗോരിതത്തിന് ആവശ്യമായ ഡാറ്റയുടെ അളവ് പൊരുത്തപ്പെടുന്നില്ല, ഇൻപുട്ടിൽ ലഭിച്ച ഡാറ്റ ബഫറുകളുടെ വലുപ്പത്തിന്റെ ഗുണിതമല്ല. ഉദാഹരണത്തിന്, ഞങ്ങൾ ഒരു ഫാസ്റ്റ് ഫ്യൂറിയർ പരിവർത്തനം നടത്തുന്ന ഒരു ഫിൽട്ടർ എഴുതുകയാണ്, നിർവചനം അനുസരിച്ച് രണ്ട് ശക്തിയുള്ള ഡാറ്റ ബ്ലോക്കുകൾ മാത്രമേ പ്രോസസ്സ് ചെയ്യാൻ കഴിയൂ. അത് 512 എണ്ണമാകട്ടെ. ഒരു ടെലിഫോൺ ചാനലാണ് ഡാറ്റ സൃഷ്‌ടിക്കുന്നതെങ്കിൽ, ഇൻപുട്ടിലെ ഓരോ സന്ദേശത്തിന്റെയും ഡാറ്റ ബഫർ ഞങ്ങൾക്ക് 160 സിഗ്നൽ സാമ്പിളുകൾ കൊണ്ടുവരും. ആവശ്യമായ ഡാറ്റ ലഭ്യമാകുന്നതുവരെ ഇൻപുട്ടിൽ നിന്ന് ഡാറ്റ ശേഖരിക്കാതിരിക്കുന്നത് പ്രലോഭനമാണ്. എന്നാൽ ഈ സാഹചര്യത്തിൽ, ടിക്കറുമായി ഒരു കൂട്ടിയിടി സംഭവിക്കും, അത് ഇൻപുട്ട് ലിങ്ക് ശൂന്യമാകുന്നതുവരെ ഫിൽട്ടർ സ്ക്രോൾ ചെയ്യാൻ ശ്രമിക്കുന്നതിൽ പരാജയപ്പെട്ടു. മുമ്പ്, ഞങ്ങൾ ഈ നിയമം ഫിൽട്ടറിന്റെ മൂന്നാമത്തെ തത്വമായി നിശ്ചയിച്ചു. ഈ തത്വമനുസരിച്ച്, ഫിൽട്ടറിന്റെ പ്രോസസ്സ്() ഫംഗ്ഷൻ ഇൻപുട്ട് ക്യൂകളിൽ നിന്ന് എല്ലാ ഡാറ്റയും എടുക്കണം.

കൂടാതെ, ഇൻപുട്ടിൽ നിന്ന് 512 സാമ്പിളുകൾ മാത്രം എടുക്കാൻ കഴിയില്ല, കാരണം നിങ്ങൾക്ക് മുഴുവൻ ബ്ലോക്കുകളും മാത്രമേ എടുക്കാൻ കഴിയൂ, അതായത്. ഫിൽട്ടറിന് 640 സാമ്പിളുകൾ എടുക്കുകയും അവയിൽ 512 എണ്ണം ഉപയോഗിക്കുകയും വേണം, ബാക്കിയുള്ളവ ഡാറ്റയുടെ ഒരു പുതിയ ഭാഗം ശേഖരിക്കുന്നതിന് മുമ്പ്. അതിനാൽ, ഞങ്ങളുടെ ഫിൽട്ടർ, അതിന്റെ പ്രധാന ജോലിക്ക് പുറമേ, ഇൻപുട്ട് ഡാറ്റയുടെ ഇന്റർമീഡിയറ്റ് സംഭരണത്തിനായി സഹായ പ്രവർത്തനങ്ങൾ നൽകണം. മീഡിയ സ്ട്രീമറിന്റെ ഡെവലപ്പർമാരും ഈ പൊതു പ്രശ്നത്തിനുള്ള പരിഹാരവും ഒരു പ്രത്യേക ഒബ്ജക്റ്റ് വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട് - MSBufferizer (bufferer), ഇത് tuples ഉപയോഗിച്ച് ഈ പ്രശ്നം പരിഹരിക്കുന്നു.

ബഫറൈസർ (MSBufferizer)

ഫിൽട്ടറിനുള്ളിൽ ഇൻപുട്ട് ഡാറ്റ ശേഖരിക്കുകയും ഫിൽട്ടർ അൽഗോരിതം പ്രവർത്തിപ്പിക്കുന്നതിന് ആവശ്യമായ വിവരങ്ങൾ മതിയാകുമ്പോൾ അത് പ്രോസസ്സിംഗിനായി സമർപ്പിക്കാൻ തുടങ്ങുകയും ചെയ്യുന്ന ഒരു വസ്തുവാണിത്. ബഫർ ഡാറ്റ ശേഖരിക്കുമ്പോൾ, പ്രോസസ്സറിന്റെ പ്രോസസ്സിംഗ് പവർ ഉപയോഗിക്കാതെ ഫിൽട്ടർ നിഷ്‌ക്രിയ മോഡിൽ പ്രവർത്തിക്കും. എന്നാൽ ബഫററിൽ നിന്നുള്ള റീഡിംഗ് ഫംഗ്‌ഷൻ പൂജ്യം അല്ലാതെ മറ്റൊരു മൂല്യം നൽകുമ്പോൾ, ഫിൽട്ടറിന്റെ പ്രോസസ്സ്() ഫംഗ്‌ഷൻ ബഫററിൽ നിന്ന് ആവശ്യമായ വലുപ്പത്തിലുള്ള ഭാഗങ്ങളിൽ നിന്ന് ഡാറ്റ എടുക്കാനും പ്രോസസ്സ് ചെയ്യാനും തുടങ്ങുന്നു, അത് തീരുന്നതുവരെ.
ഇതുവരെ ആവശ്യമില്ലാത്ത ഡാറ്റ ട്യൂപ്പിളിന്റെ ആദ്യ ഘടകമായി ബഫറിൽ അവശേഷിക്കുന്നു, അതിൽ ഇൻപുട്ട് ഡാറ്റയുടെ തുടർന്നുള്ള ബ്ലോക്കുകൾ ഘടിപ്പിച്ചിരിക്കുന്നു.

ബഫറിനെ വിവരിക്കുന്ന ഘടന:

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

ബഫറിൽ ശേഖരിക്കപ്പെട്ട ഡാറ്റയുടെ വലുപ്പം ആവശ്യപ്പെട്ടതിനേക്കാൾ കുറവാണെങ്കിൽ (ഡാറ്റലെൻ), തുടർന്ന് ഫംഗ്ഷൻ പൂജ്യം നൽകുന്നു, ഡാറ്റ ഡാറ്റയിലേക്ക് പകർത്തില്ല. അല്ലെങ്കിൽ, ബഫറിൽ സ്ഥിതിചെയ്യുന്ന ട്യൂപ്പിളുകളിൽ നിന്നുള്ള ഡാറ്റയുടെ തുടർച്ചയായ പകർപ്പ് നടത്തുന്നു. പകർത്തിയ ശേഷം, ട്യൂപ്പിൾ ഇല്ലാതാക്കുകയും മെമ്മറി സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു. ഡാറ്റലെൻ ബൈറ്റുകൾ പകർത്തുന്ന നിമിഷത്തിൽ പകർത്തൽ അവസാനിക്കുന്നു. ഒരു ഡാറ്റ ബ്ലോക്കിന്റെ മധ്യഭാഗത്ത് ഇടം തീർന്നാൽ, ഈ സന്ദേശത്തിൽ, ഡാറ്റ ബ്ലോക്ക് ബാക്കിയുള്ള പകർത്താത്ത ഭാഗത്തേക്ക് കുറയ്ക്കും. അടുത്ത തവണ നിങ്ങൾ വിളിക്കുമ്പോൾ, ഈ പോയിന്റിൽ നിന്ന് പകർത്തൽ തുടരും.

ബഫറിൽ നിലവിൽ ലഭ്യമായ ഡാറ്റയുടെ അളവ് വായിക്കുന്നു:

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