Mediastreamer2 VoIP इंजिन एक्सप्लोर करत आहे. भाग 11

लेखाचे साहित्य माझ्याकडून घेतले आहे झेन चॅनेल.

डेटा हालचाल यंत्रणा

• डेटा ब्लॉक dblk_t
• संदेश mblk_t
• संदेशांसह कार्य करण्यासाठी कार्ये mblk_t
• रांग रांग_टी
• quees 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 निर्दिष्ट आकाराच्या डेटा ब्लॉकसह आकार, दुसरा युक्तिवाद - प्रा लायब्ररीच्या या आवृत्तीमध्ये वापरलेले नाही. ते शून्यच राहिले पाहिजे. फंक्शनच्या ऑपरेशन दरम्यान, नवीन संदेशाच्या संरचनेसाठी मेमरी वाटप केली जाईल आणि फंक्शन कॉल केले जाईल 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);

तिला शेवटचा संदेश tuple मध्ये सापडेल (त्याच्याकडे आहे b_cont शून्य असेल) आणि या संदेशासाठी फंक्शन कॉल करेल परिशिष्ट ().

फंक्शन वापरून तुम्ही मेसेज किंवा टपलमधील डेटाचा आकार शोधू शकता:

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

वाद असल्यास LEN -1 आहे, नंतर वाटप केलेल्या बफरचा आकार स्वयंचलितपणे निर्धारित केला जातो. तर LEN धन संख्या आहे, या आकाराचा बफर तयार केला जाईल आणि टपल संदेश डेटा त्यात कॉपी केला जाईल. बफर संपल्यास, कॉपी करणे तिथेच थांबेल. ट्युपलचा पहिला संदेश कॉपी केलेल्या डेटासह नवीन आकाराचा बफर प्राप्त करेल. उर्वरित संदेश हटविले जातील आणि मेमरी ढीगमध्ये परत येईल.

रचना हटवताना 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);

वाद तर 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 नावाची रांग दाखवते ज्यामध्ये m4, m1, m2, m3 असे 4 संदेश आहेत.

खालील आकृती q1 नावाची रांग दर्शवते ज्यामध्ये m4,m1,m2,m3 असे 4 संदेश आहेत. संदेश m2 हे टपलचे प्रमुख आहे ज्यामध्ये आणखी दोन संदेश m2_1 आणि m2_2 आहेत.

quees 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 घटकापूर्वी घातले 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;

फिल्टर पिन शून्य पासून प्रारंभ करून क्रमांकित आहेत.

संदेशाच्या रांगेद्वारे दोन पिनचे कनेक्शन संरचनेद्वारे वर्णन केले आहे _MS रांग, ज्यामध्ये संदेशाची रांग असते आणि ते कनेक्ट केलेल्या दोन सिग्नल बिंदूंकडे पॉइंटर असतात:

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

या संरचनेला आपण सिग्नल लिंक म्हणू. प्रत्येक मीडिया स्ट्रीमर फिल्टरमध्ये इनपुट लिंक्सची टेबल आणि आउटपुट लिंक्सची टेबल असते (MSQueue). फिल्टर तयार करताना सारण्यांचा आकार सेट केला जातो; आम्ही हे आधीच निर्यात केलेल्या प्रकाराचा वापर करून केले आहे. MSFilterDesc, जेव्हा आम्ही आमचे स्वतःचे फिल्टर विकसित केले. खाली एक रचना आहे जी मीडिया स्ट्रीमरमधील कोणत्याही फिल्टरचे वर्णन करते, एमएसफिल्टर:

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;

आम्ही आमच्या योजनेनुसार सी प्रोग्राममध्ये फिल्टर कनेक्ट केल्यानंतर (परंतु टिकर कनेक्ट केले नाही), आम्ही त्याद्वारे एक निर्देशित आलेख तयार केला, ज्याचे नोड हे संरचनेचे उदाहरण आहेत. एमएसफिल्टर, आणि कडा ही लिंक्सची उदाहरणे आहेत MSQueue.

टिकरच्या पडद्यामागील क्रियाकलाप

जेव्हा मी तुम्हाला सांगितले की टिकर हे टिक्सच्या स्त्रोतासाठी एक फिल्टर आहे, तेव्हा त्याबद्दल संपूर्ण सत्य नव्हते. टिकर ही एक वस्तू आहे जी घड्याळावर कार्य करते प्रक्रिया() सर्किटचे सर्व फिल्टर (ग्राफ) ज्याशी ते जोडलेले आहे. जेव्हा आम्ही C प्रोग्राममध्ये आलेख फिल्टरशी टिकर कनेक्ट करतो, तेव्हा आम्ही टिकरला तो आलेख दाखवतो जो तो आतापासून बंद करेपर्यंत नियंत्रित करेल. कनेक्ट केल्यानंतर, टिकर त्याच्या काळजीसाठी सोपवलेल्या आलेखाचे परीक्षण करण्यास सुरवात करतो, त्यात समाविष्ट असलेल्या फिल्टरची सूची संकलित करतो. एकच फिल्टर दोनदा “गणना” न करण्यासाठी, ते सापडलेल्या फिल्टर्समध्ये चेकबॉक्स ठेवून चिन्हांकित करते पाहिले. शोध प्रत्येक फिल्टरमध्ये असलेल्या लिंक टेबल्सचा वापर करून केला जातो.

आलेखाच्या त्याच्या प्रास्ताविक दौर्‍यादरम्यान, टिकर फिल्टरमध्ये डेटा ब्लॉक्सचा स्रोत म्हणून काम करणारा किमान एक तरी आहे की नाही हे तपासतो. जर तेथे काहीही नसेल, तर आलेख चुकीचा मानला जाईल आणि टिकर क्रॅश होईल.

आलेख "बरोबर" असल्याचे आढळल्यास, प्रत्येक सापडलेल्या फिल्टरसाठी, फंक्शनला प्रारंभ करण्यासाठी कॉल केले जाते. पूर्वप्रक्रिया(). पुढील प्रक्रिया चक्राचा क्षण येताच (प्रत्येक 10 मिलिसेकंदांनी डीफॉल्टनुसार), टिकर फंक्शनला कॉल करतो. प्रक्रिया() पूर्वी सापडलेल्या सर्व स्रोत फिल्टरसाठी आणि नंतर सूचीतील उर्वरित फिल्टरसाठी. जर फिल्टरमध्ये इनपुट लिंक्स असतील तर फंक्शन चालू करा प्रक्रिया() इनपुट लिंक रांगा रिक्त होईपर्यंत पुनरावृत्ती होते. यानंतर, ते सूचीतील पुढील फिल्टरवर जाते आणि इनपुट लिंक संदेशांपासून मुक्त होईपर्यंत ते "स्क्रोल" करते. यादी संपेपर्यंत टिकर फिल्टरमधून फिल्टरवर फिरतो. हे सायकलची प्रक्रिया पूर्ण करते.

आता आम्ही ट्यूपल्सवर परत येऊ आणि मीडिया स्ट्रीमरमध्ये अशी संस्था का जोडली गेली याबद्दल बोलू. सर्वसाधारणपणे, फिल्टरमध्ये कार्यरत अल्गोरिदमद्वारे आवश्यक डेटाचे प्रमाण एकरूप होत नाही आणि इनपुटवर प्राप्त झालेल्या डेटा बफरच्या आकाराच्या गुणाकार नाही. उदाहरणार्थ, आम्ही एक फिल्टर लिहित आहोत जे एक जलद फूरियर ट्रान्सफॉर्म करते, जे परिभाषानुसार फक्त डेटा ब्लॉक्सवर प्रक्रिया करू शकते ज्यांचा आकार दोनचा आहे. त्याची संख्या ५१२ असू द्या. जर डेटा टेलिफोन चॅनेलद्वारे व्युत्पन्न केला गेला असेल, तर इनपुटवरील प्रत्येक संदेशाचा डेटा बफर आम्हाला 512 सिग्नल नमुने आणेल. जोपर्यंत आवश्यक प्रमाणात डेटा मिळत नाही तोपर्यंत इनपुटमधून डेटा संकलित न करण्याचा मोह होतो. परंतु या प्रकरणात, टिकरशी टक्कर होईल, जो इनपुट लिंक रिक्त होईपर्यंत फिल्टर स्क्रोल करण्याचा अयशस्वी प्रयत्न करेल. पूर्वी, आम्ही हा नियम फिल्टरचा तिसरा सिद्धांत म्हणून नियुक्त केला होता. या तत्त्वानुसार, फिल्टरच्या प्रक्रिया() फंक्शनने इनपुट रांगांमधून सर्व डेटा घेणे आवश्यक आहे.

याव्यतिरिक्त, इनपुटमधून केवळ 512 नमुने घेणे शक्य होणार नाही, कारण आपण फक्त संपूर्ण ब्लॉक घेऊ शकता, म्हणजे. फिल्टरला 640 नमुने घ्यावे लागतील आणि त्यातील 512 वापरावे लागतील, उर्वरित डेटाचा नवीन भाग जमा करण्यापूर्वी. अशा प्रकारे, आमचे फिल्टर, त्याच्या मुख्य कार्याव्यतिरिक्त, इनपुट डेटाच्या इंटरमीडिएट स्टोरेजसाठी सहाय्यक क्रिया प्रदान करणे आवश्यक आहे. मीडिया स्ट्रीमरच्या विकसकांनी आणि या सामान्य समस्येचे निराकरण करण्यासाठी एक विशेष ऑब्जेक्ट विकसित केला आहे - MSBufferizer (बफरर), जो tuples वापरून ही समस्या सोडवते.

बफरायझर (MSBufferizer)

हा एक ऑब्जेक्ट आहे जो फिल्टरमध्ये इनपुट डेटा जमा करेल आणि फिल्टर अल्गोरिदम चालविण्यासाठी माहितीची मात्रा पुरेशी होताच प्रक्रियेसाठी सबमिट करणे सुरू करेल. बफर डेटा जमा करत असताना, प्रोसेसरची प्रोसेसिंग पॉवर न वापरता फिल्टर निष्क्रिय मोडमध्ये काम करेल. पण बफररकडून वाचन फंक्शन शून्याव्यतिरिक्त इतर मूल्य परतवताच, फिल्टरचे process() फंक्शन आवश्यक आकाराच्या भागांमध्ये बफररकडून डेटा घेणे आणि प्रक्रिया करणे सुरू करते, जोपर्यंत ते संपत नाही.
अद्याप आवश्यक नसलेला डेटा ट्युपलचा पहिला घटक म्हणून बफरमध्ये राहतो, ज्याला इनपुट डेटाचे त्यानंतरचे ब्लॉक्स संलग्न केले जातात.

बफरचे वर्णन करणारी रचना:

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

बफरमध्ये जमा केलेल्या डेटाचा आकार विनंती केलेल्या डेटापेक्षा कमी असल्यास (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