Mediastreamer2 VoIP એન્જિનની શોધખોળ. ભાગ 11

લેખની સામગ્રી મારા પરથી લેવામાં આવી છે ઝેન ચેનલ.

ડેટા મૂવમેન્ટ મિકેનિઝમ

• ડેટા બ્લોક dblk_t
• સંદેશ mblk_t
• સંદેશાઓ સાથે કામ કરવા માટેના કાર્યો mblk_t
• કતાર કતાર_ટી
• queues 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, એમ 1_1, એમ 1_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 — એક સંદેશ જેમાં અન્ય ડેટા બ્લોક ઉમેરવામાં આવશે;
માહિતી — બ્લોક પર નિર્દેશક, જેની એક નકલ સંદેશમાં ઉમેરવામાં આવશે;
કદ - ડેટા કદ;
પેડ — એક ધ્વજ કે જે ફાળવેલ મેમરીનું કદ 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);

તેણી ટપલ જોડે છે newm ટપલની પૂંછડી સુધી mp અને પરિણામી ટ્યુપલના છેલ્લા સંદેશ પર એક નિર્દેશક પરત કરે છે.

જો જરૂરી હોય તો, ટ્યુપલને ડેટાના એક બ્લોક સાથે એક સંદેશમાં ફેરવી શકાય છે; આ કાર્ય દ્વારા કરવામાં આવે છે:

void msgpullup(mblk_t *mp,int len);

જો દલીલ લેન -1 છે, તો ફાળવેલ બફરનું કદ આપમેળે નક્કી થાય છે. જો લેન ધન સંખ્યા છે, આ કદનું બફર બનાવવામાં આવશે અને તેમાં ટપલ મેસેજ ડેટા કોપી કરવામાં આવશે. જો બફર સમાપ્ત થાય, તો નકલ કરવાનું બંધ થઈ જશે. ટ્યુપલનો પહેલો સંદેશ કોપી કરેલા ડેટા સાથે નવા કદનું બફર પ્રાપ્ત કરશે. બાકીના સંદેશાઓ કાઢી નાખવામાં આવશે અને મેમરી ઢગલા પર પાછી આવશે.

રચના કાઢી નાખતી વખતે 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);

જો નવો ડેટા મેસેજ ડેટા બફરની ખાલી જગ્યામાં બંધબેસતો નથી, તો જરૂરી કદના બફર સાથે અલગથી બનાવેલો સંદેશ સંદેશ સાથે જોડવામાં આવે છે (ઉમેરેલા સંદેશ માટેનો નિર્દેશક પ્રથમ સંદેશમાં સેટ કરેલ છે) અને સંદેશ ટપલમાં ફેરવાય છે.

ટપલમાં ડેટાનો ટુકડો ઉમેરી રહ્યા છે:

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

ફંક્શન એપેન્ડબી() ને લૂપમાં કૉલ કરે છે.

બે ટ્યુપલને એકમાં જોડીને:

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

સંદેશ newm સાથે જોડવામાં આવશે mp.

એક સંદેશની નકલ બનાવવી:

mblk_t *copyb(const mblk_t *mp);

બધા ડેટા બ્લોક્સ સાથે ટ્યુપલની સંપૂર્ણ નકલ:

mblk_t *copymsg(const mblk_t *mp);

ટ્યુપલના તત્વો ફંક્શન દ્વારા કૉપિ કરવામાં આવે છે કોપીબી().

સંદેશની સરળ નકલ બનાવો 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 ટાઇપ કરો, તે કતારમાં પ્રથમ તત્વ (સંદેશ) તરફ નિર્દેશ કરે છે. બંધારણનું બીજું ક્ષેત્ર એ કતારમાં સંદેશાઓનું કાઉન્ટર છે.
નીચેની આકૃતિ q1 નામની કતાર બતાવે છે જેમાં 4 સંદેશા m1, m2, m3, m4 છે.

નીચેનો આંકડો q1 નામની કતાર બતાવે છે જેમાં 4 સંદેશા m1,m2,m3,m4 છે. સંદેશ m2 એ ટપલનું હેડ છે જેમાં વધુ બે સંદેશા m2_1 અને m2_2 છે.

queues 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).

કનેક્ટિંગ ફિલ્ટર્સ

ઉપર વર્ણવેલ કતારનો ઉપયોગ એક ફિલ્ટરમાંથી બીજા ફિલ્ટરમાં અથવા એકથી અનેક ફિલ્ટર્સમાં સંદેશા મોકલવા માટે થાય છે. ફિલ્ટર્સ અને તેમના જોડાણો નિર્દેશિત ગ્રાફ બનાવે છે. ફિલ્ટરના ઇનપુટ અથવા આઉટપુટને સામાન્ય શબ્દ "પિન" કહેવામાં આવશે. ફિલ્ટર્સ એકબીજા સાથે જોડાયેલા છે તે ક્રમનું વર્ણન કરવા માટે, મીડિયા સ્ટ્રીમર "સિગ્નલ પોઈન્ટ" ના ખ્યાલનો ઉપયોગ કરે છે. સિગ્નલ પોઇન્ટ માળખું છે _MSCPpoint, જેમાં ફિલ્ટર માટે એક નિર્દેશક અને તેની એક પિનની સંખ્યા હોય છે; તે મુજબ, તે ફિલ્ટરના ઇનપુટ અથવા આઉટપુટમાંથી એકના જોડાણનું વર્ણન કરે છે.

ડેટા પ્રોસેસિંગ ગ્રાફનો સિગ્નલ પોઈન્ટ

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

ફિલ્ટર પિન શૂન્યથી શરૂ કરીને ક્રમાંકિત છે.

સંદેશ કતાર દ્વારા બે પિનનું જોડાણ બંધારણ દ્વારા વર્ણવેલ છે _MSકતાર, જેમાં એક સંદેશ કતાર છે અને તે જે બે સિગ્નલ પોઈન્ટને જોડે છે તેના માટે નિર્દેશકો ધરાવે છે:

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.

ટિકરની પડદા પાછળની પ્રવૃત્તિઓ

જ્યારે મેં તમને કહ્યું કે ટીકર એ ટિકના સ્ત્રોત માટેનું ફિલ્ટર છે, તે તેના વિશે સંપૂર્ણ સત્ય ન હતું. ટીકર એ એક પદાર્થ છે જે ઘડિયાળ પર કાર્ય કરે છે પ્રક્રિયા() સર્કિટના તમામ ફિલ્ટર્સ (ગ્રાફ) જેની સાથે તે જોડાયેલ છે. જ્યારે આપણે સી પ્રોગ્રામમાં ગ્રાફ ફિલ્ટર સાથે ટિકરને કનેક્ટ કરીએ છીએ, ત્યારે અમે ટિકરને તે ગ્રાફ બતાવીએ છીએ જે તે હવેથી નિયંત્રિત કરશે જ્યાં સુધી આપણે તેને બંધ ન કરીએ. કનેક્ટ કર્યા પછી, ટીકર તેની સંભાળને સોંપવામાં આવેલ ગ્રાફની તપાસ કરવાનું શરૂ કરે છે, તેમાં શામેલ હોય તેવા ફિલ્ટર્સની સૂચિનું સંકલન કરે છે. એક જ ફિલ્ટરને બે વાર "ગણતરી" ન કરવા માટે, તે શોધાયેલ ફિલ્ટર્સને તેમાં ચેકબોક્સ મૂકીને ચિહ્નિત કરે છે. જોઈ. દરેક ફિલ્ટરમાં હોય તેવા લિંક કોષ્ટકોનો ઉપયોગ કરીને શોધ હાથ ધરવામાં આવે છે.

ગ્રાફના તેના પ્રારંભિક પ્રવાસ દરમિયાન, ટીકર તપાસ કરે છે કે ફિલ્ટર્સમાં ઓછામાં ઓછું એક છે કે જે ડેટા બ્લોક્સના સ્ત્રોત તરીકે કાર્ય કરે છે. જો ત્યાં કોઈ ન હોય, તો ગ્રાફ ખોટો માનવામાં આવે છે અને ટીકર ક્રેશ થાય છે.

જો ગ્રાફ "સાચો" હોવાનું બહાર આવે છે, તો દરેક મળેલા ફિલ્ટર માટે, ફંક્શનને પ્રારંભ માટે કહેવામાં આવે છે. પૂર્વ પ્રક્રિયા(). જલદી જ આગળના પ્રોસેસિંગ ચક્ર (ડિફૉલ્ટ રૂપે દર 10 મિલીસેકન્ડે) માટે ક્ષણ આવે છે, ટિકર ફંક્શનને કૉલ કરે છે. પ્રક્રિયા() અગાઉ મળેલા તમામ સ્ત્રોત ફિલ્ટર્સ માટે અને પછી યાદીમાંના બાકીના ફિલ્ટર્સ માટે. જો ફિલ્ટરમાં ઇનપુટ લિંક્સ હોય, તો ફંક્શન ચલાવો પ્રક્રિયા() જ્યાં સુધી ઇનપુટ લિંક કતાર ખાલી ન થાય ત્યાં સુધી પુનરાવર્તન થાય છે. આ પછી, તે સૂચિમાંના આગલા ફિલ્ટર પર જાય છે અને જ્યાં સુધી ઇનપુટ લિંક્સ સંદેશાઓથી મુક્ત ન થાય ત્યાં સુધી તેને "સ્ક્રોલ" કરે છે. સૂચિ સમાપ્ત થાય ત્યાં સુધી ટીકર ફિલ્ટરથી ફિલ્ટર તરફ આગળ વધે છે. આ ચક્રની પ્રક્રિયા પૂર્ણ કરે છે.

હવે અમે ટ્યુપલ્સ પર પાછા આવીશું અને મીડિયા સ્ટ્રીમરમાં આવી એન્ટિટી કેમ ઉમેરવામાં આવી તે વિશે વાત કરીશું. સામાન્ય રીતે, ફિલ્ટરની અંદર કાર્યરત અલ્ગોરિધમ દ્વારા જરૂરી ડેટાની માત્રા એકરૂપ થતી નથી અને તે ઇનપુટ પર પ્રાપ્ત ડેટા બફરના કદના ગુણાંકમાં નથી. ઉદાહરણ તરીકે, અમે એક ફિલ્ટર લખી રહ્યા છીએ જે ઝડપી ફોરિયર ટ્રાન્સફોર્મ કરે છે, જે વ્યાખ્યા મુજબ ફક્ત ડેટા બ્લોક્સ પર પ્રક્રિયા કરી શકે છે જેની સાઈઝ બેની શક્તિ છે. તેને 512 ગણવા દો. જો ડેટા ટેલિફોન ચેનલ દ્વારા જનરેટ કરવામાં આવે છે, તો ઇનપુટ પરના દરેક સંદેશનો ડેટા બફર અમને 160 સિગ્નલ નમૂનાઓ લાવશે. જ્યાં સુધી જરૂરી માત્રામાં ડેટા ન હોય ત્યાં સુધી ઇનપુટમાંથી ડેટા એકત્રિત ન કરવાનું આકર્ષિત કરે છે. પરંતુ આ કિસ્સામાં, ટીકર સાથે અથડામણ થશે, જે ઇનપુટ લિંક ખાલી ન થાય ત્યાં સુધી ફિલ્ટરને સ્ક્રોલ કરવાનો અસફળ પ્રયાસ કરશે. અગાઉ, અમે આ નિયમને ફિલ્ટરના ત્રીજા સિદ્ધાંત તરીકે નિયુક્ત કર્યો હતો. આ સિદ્ધાંત અનુસાર, ફિલ્ટરની પ્રક્રિયા() ફંક્શને ઇનપુટ કતારમાંથી તમામ ડેટા લેવો જોઈએ.

વધુમાં, ઇનપુટમાંથી ફક્ત 512 નમૂના લેવાનું શક્ય બનશે નહીં, કારણ કે તમે ફક્ત સંપૂર્ણ બ્લોક્સ લઈ શકો છો, એટલે કે. ફિલ્ટરે 640 નમૂનાઓ લેવા પડશે અને તેમાંથી 512નો ઉપયોગ કરવો પડશે, બાકીનો ડેટાનો નવો ભાગ એકત્રિત કરતા પહેલા. આમ, અમારા ફિલ્ટરે, તેના મુખ્ય કાર્ય ઉપરાંત, ઇનપુટ ડેટાના મધ્યવર્તી સંગ્રહ માટે સહાયક ક્રિયાઓ પ્રદાન કરવી આવશ્યક છે. મીડિયા સ્ટ્રીમરના વિકાસકર્તાઓએ અને આ સામાન્ય સમસ્યાના ઉકેલ માટે એક વિશિષ્ટ ઑબ્જેક્ટ વિકસાવી છે - MSBufferizer (બફરર), જે ટ્યુપલ્સનો ઉપયોગ કરીને આ સમસ્યાને હલ કરે છે.

બફરાઇઝર (MSBufferizer)

આ એક ઑબ્જેક્ટ છે જે ફિલ્ટરની અંદર ઇનપુટ ડેટા એકઠા કરશે અને ફિલ્ટર અલ્ગોરિધમ ચલાવવા માટે પૂરતી માહિતીની માત્રા હોય તેટલી જલ્દી પ્રક્રિયા માટે તેને સબમિટ કરવાનું શરૂ કરશે. જ્યારે બફર ડેટા એકઠું કરી રહ્યું હોય, ત્યારે ફિલ્ટર પ્રોસેસરની પ્રોસેસિંગ પાવરનો ઉપયોગ કર્યા વિના, નિષ્ક્રિય મોડમાં કાર્ય કરશે. પરંતુ જલદી જ બફરરમાંથી રીડિંગ ફંક્શન શૂન્ય સિવાયનું મૂલ્ય પરત કરે છે, ફિલ્ટરનું પ્રોસેસ() ફંક્શન બફરર પાસેથી જરૂરી કદના ભાગોમાં ડેટા લેવાનું અને પ્રક્રિયા કરવાનું શરૂ કરે છે, જ્યાં સુધી તે સમાપ્ત ન થાય.
ડેટા કે જે હજુ સુધી જરૂરી નથી તે ટ્યુપલના પ્રથમ તત્વ તરીકે બફરમાં રહે છે, જેની સાથે ઇનપુટ ડેટાના અનુગામી બ્લોક્સ જોડાયેલા છે.

માળખું જે બફરનું વર્ણન કરે છે:

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

MSBufferizer સાથે કામ કરવા માટેના કાર્યો

નવો બફર દાખલો બનાવી રહ્યા છે:

MSBufferizer * ms_bufferizer_new(void);

મેમરી ફાળવવામાં આવે છે, માં પ્રારંભ થાય છે ms_buferizer_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_buferizer_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