Mediastreamer2 VoIP इन्जिन अन्वेषण गर्दै। भाग ८

लेखको सामग्री मेरो बाट लिइएको हो zen च्यानल.

डाटा आन्दोलन संयन्त्र

• डाटा ब्लक dblk_t
• सन्देश mblk_t
• सन्देशहरू mblk_t सँग काम गर्ने कार्यहरू
• लाइन queue_t
• queues queue_t सँग काम गर्ने कार्यहरू
• जडान फिल्टरहरू
• डाटा प्रोसेसिङ ग्राफको सिग्नल बिन्दु
• टिकरको पर्दा पछाडिका गतिविधिहरू
• बफराइजर (MSBufferizer)
• MSBufferizer सँग काम गर्नका लागि कार्यहरू

विगतमा लेख हामीले हाम्रो आफ्नै फिल्टर विकास गरेका छौं। यस लेखले मिडिया स्ट्रिमर फिल्टरहरू बीच डाटा सार्नको लागि आन्तरिक संयन्त्रमा फोकस गर्नेछ। यसले तपाईंलाई भविष्यमा कम प्रयासमा परिष्कृत फिल्टरहरू लेख्न अनुमति दिनेछ।

डाटा आन्दोलन संयन्त्र

मिडिया स्ट्रिमरमा डेटा आन्दोलन संरचना द्वारा वर्णन गरिएको लामहरू प्रयोग गरी गरिन्छ queue_t। जस्तै सन्देशहरूको स्ट्रिङ mblk_t, जुन आफैंमा सिग्नल डाटा समावेश गर्दैन, तर केवल अघिल्लो, अर्को सन्देश र डाटा ब्लकमा लिङ्कहरू। थप रूपमा, म विशेष रूपमा जोड दिन चाहन्छु कि त्यहाँ समान प्रकारको सन्देशको लिङ्कको लागि एक फिल्ड पनि छ, जसले तपाईंलाई सन्देशहरूको एकल लिङ्क गरिएको सूची व्यवस्थित गर्न अनुमति दिन्छ। हामी यस्तो सूचीद्वारा संयुक्त सन्देशहरूको समूहलाई टपल भन्नेछौं। यसरी, लामको कुनै पनि तत्व एकल सन्देश हुन सक्छ mblk_t, र सायद सन्देश टपलको टाउको mblk_t। प्रत्येक टपल सन्देशको आफ्नै वार्ड डाटा ब्लक हुन सक्छ। टुपलहरू किन आवश्यक छ हामी केही पछि छलफल गर्नेछौं।

माथि उल्लेख गरिए अनुसार, सन्देशले डेटाको ब्लक समावेश गर्दैन; यसको सट्टा, यसले केवल मेमोरी क्षेत्रको लागि सूचक समावेश गर्दछ जहाँ ब्लक भण्डार गरिएको छ। यस भागमा, मिडिया स्ट्रिमरको कामको समग्र तस्विरले कार्टुन "Monsters, Inc." मा रहेको ढोका गोदामको सम्झना दिलाउँछ, जहाँ ढोकाहरू (डेटा - कोठाहरूका लागि लिङ्कहरू) ओभरहेड कन्भेयरहरूसँग पागल गतिमा सर्छन्, जबकि कोठाहरू आफैंमा गतिहीन रहन्छ।

अब, तलदेखि माथि सम्म पदानुक्रमको साथमा, मिडिया स्ट्रिमरमा डाटा ट्रान्समिशन मेकानिजमको सूचीबद्ध संस्थाहरूलाई विस्तृत रूपमा विचार गरौं।

डाटा ब्लक dblk_t

डाटा ब्लकमा हेडर र डाटा बफर हुन्छ। हेडर निम्न संरचना द्वारा वर्णन गरिएको छ,

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

संरचनाको क्षेत्रहरूमा बफरको सुरुमा, बफरको अन्त्य, र डेटा बफर मेटाउने प्रकार्यमा संकेतहरू समावेश छन्। हेडरमा अन्तिम तत्व db_ref - सन्दर्भ काउन्टर, यदि यो शून्य पुग्यो भने, यसले मेमोरीबाट यो ब्लक मेटाउन संकेतको रूपमा कार्य गर्दछ। यदि डेटा ब्लक प्रकार्य द्वारा सिर्जना गरिएको थियो datab_alloc() , त्यसपछि डाटा बफर हेडर पछि तुरुन्तै मेमोरीमा राखिनेछ। अन्य सबै अवस्थामा, बफर कतै छुट्टै अवस्थित गर्न सकिन्छ। डेटा बफरले संकेत नमूनाहरू वा अन्य डेटा समावेश गर्दछ जुन हामीले फिल्टरहरूसँग प्रक्रिया गर्न चाहन्छौं।

प्रकार्य प्रयोग गरेर डाटा ब्लकको नयाँ उदाहरण सिर्जना गरिएको छ:

dblk_t *datab_alloc(int size);

इनपुट प्यारामिटरको रूपमा, यसलाई ब्लकले भण्डारण गर्ने डाटाको साइज दिइएको छ। थप मेमोरी आवंटित गरिएको मेमोरीको सुरुमा हेडर - संरचना - राख्नको लागि आवंटित गरिएको छ डाटाब। तर अन्य प्रकार्यहरू प्रयोग गर्दा, यो सधैं हुँदैन; केहि अवस्थामा, डाटा बफर डाटा ब्लक हेडरबाट अलग अवस्थित हुन सक्छ। संरचना सिर्जना गर्दा, फिल्डहरू कन्फिगर गरिएका छन् ताकि यसको क्षेत्र db_base डाटा क्षेत्रको सुरुमा औंल्याइएको, र db_lim यसको अन्त्य सम्म। लिङ्क गणना db_ref एक मा सेट गरिएको छ। डेटा स्पष्ट प्रकार्य सूचक शून्यमा सेट गरिएको छ।

सन्देश mblk_t

भनिएको छ, लाम तत्वहरू प्रकारका छन् mblk_t, यसलाई निम्नानुसार परिभाषित गरिएको छ:

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

संरचना mblk_t सुरुमा सूचकहरू समावेश गर्दछ b_prev, b_next, जुन एक दोहोरो लिङ्क गरिएको सूची व्यवस्थित गर्न आवश्यक छ (जुन एक लाम हो queue_t).

त्यसपछि सूचक आउँछ 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*)); 

प्रकार्य, सन्देश र डाटा ब्लकको संरचना सिर्जना गरेपछि, ठेगानामा डाटामा यसको सूचकहरू कन्फिगर गर्नेछ। बुफ। ती। यस अवस्थामा, डाटा बफर डाटा ब्लकको हेडर फिल्डहरू पछि अवस्थित हुँदैन, जस्तै प्रकार्यसँग डाटा ब्लक सिर्जना गर्दा भएको थियो। 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

दुई tuples संयोजन गर्न, प्रकार्य प्रयोग गर्नुहोस्:

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

प्रकार्यले appendb() लाई लुपमा कल गर्छ।

दुई टुपलहरू एकमा जोड्दै:

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

टपलका तत्वहरू प्रकार्यद्वारा प्रतिलिपि गरिएका छन् 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);

लाम queue_t

मिडिया स्ट्रिमरमा सन्देश कतार गोलाकार दोहोरो लिङ्क गरिएको सूचीको रूपमा लागू गरिएको छ। प्रत्येक सूची तत्वले संकेत नमूनाहरूको साथ डाटा ब्लकको लागि सूचक समावेश गर्दछ। यो बाहिर जान्छ कि केवल डेटा ब्लकमा संकेतकहरू बारीमा सर्छन्, जबकि डेटा आफैं गतिहीन रहन्छ। ती। तिनीहरूका लिङ्कहरू मात्र सारियो।
लाम वर्णन गर्ने संरचना queue_t, तल देखाइएको छ:

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

संरचनाले क्षेत्र समावेश गर्दछ - एक सूचक _q_stopper *mblk_t टाइप गर्नुहोस्, यसले लाममा पहिलो तत्व (सन्देश) लाई देखाउँछ। संरचनाको दोस्रो क्षेत्र लाममा सन्देशहरूको काउन्टर हो।
तलको चित्रले m1, m4, m1, m2 3 सन्देशहरू समावेश भएको q4 नामको लाइन देखाउँछ।

निम्न चित्रले m1,m4,m1,m2 3 सन्देशहरू भएको q4 नामक लाम देखाउँछ। सन्देश m2 एउटा टपलको टाउको हो जसमा दुई थप सन्देशहरू m2_1 र m2_2 छन्।

queues queue_t सँग काम गर्ने कार्यहरू

लाइन प्रारम्भिकरण:

void qinit(queue_t *q);

क्षेत्र _q_stopper (यसपछि हामी यसलाई "स्टपर" भन्नेछौं) फंक्शनद्वारा प्रारम्भ गरिएको छ mblk_init(), यसको अघिल्लो तत्व र अर्को तत्व सूचकलाई आफैमा बिन्दु गर्न समायोजन गरिन्छ। लाइन तत्व काउन्टर शून्यमा रिसेट गरिएको छ।

नयाँ तत्व थप्दै (सन्देशहरू):

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

नयाँ तत्व m सूचीको अन्त्यमा थपिएको छ, तत्व सूचकहरू समायोजन गरिन्छ ताकि स्टपर यसको लागि अर्को तत्व हुन्छ, र यो स्टपरको लागि अघिल्लो तत्व हुन्छ। लाम तत्व काउन्टर बढाइएको छ।

लामबाट एक तत्व पुन: प्राप्त गर्दै:

mblk_t * getq(queue_t *q); 

स्टपर पुन: प्राप्त भएपछि आउने सन्देश, र तत्व काउन्टर घटाइन्छ। यदि लाममा स्टपर बाहेक कुनै तत्वहरू छैनन् भने, ० फर्काइन्छ।

लाममा सन्देश सम्मिलित गर्दै:

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, जब हामीले हाम्रो आफ्नै फिल्टर विकास गर्यौं। तल एक संरचना हो जसले मिडिया स्ट्रिमरमा कुनै पनि फिल्टरको वर्णन गर्दछ, MSFilter:

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

हामीले हाम्रो योजना अनुसार C कार्यक्रममा फिल्टरहरू जडान गरेपछि (तर टिकर जडान गरेन), हामीले यसरी निर्देशित ग्राफ सिर्जना गर्यौं, जसका नोडहरू संरचनाका उदाहरणहरू हुन्। MSFilter, र किनाराहरू लिङ्कहरूको उदाहरण हुन् MSQueue.

टिकरको पर्दा पछाडिका गतिविधिहरू

जब मैले तपाईलाई भनें कि टिकर टिकको स्रोतको लागि फिल्टर हो, यो यसको बारेमा पूर्ण सत्य थिएन। टिकर भनेको घडीमा कार्य चलाउने वस्तु हो प्रक्रिया() सर्किटका सबै फिल्टरहरू (ग्राफ) जसमा यो जडान गरिएको छ। जब हामीले एउटा C कार्यक्रममा ग्राफ फिल्टरमा टिकर जडान गर्छौं, हामी टिकरलाई ग्राफ देखाउँछौं जुन हामीले यसलाई बन्द नगरेसम्म यसले अबदेखि नियन्त्रण गर्नेछ। जडान गरेपछि, टिकरले यसको हेरचाहमा सुम्पिएको ग्राफको जाँच गर्न थाल्छ, यसमा समावेश भएका फिल्टरहरूको सूची कम्पाइल गर्दै। एउटै फिल्टरलाई दुई पटक "गणना" नगर्नका लागि, यसले पत्ता लगाइएका फिल्टरहरूलाई चेकबक्स राखेर चिन्ह लगाउँछ। देखेको। प्रत्येक फिल्टरमा रहेको लिङ्क तालिकाहरू प्रयोग गरेर खोजी गरिन्छ।

ग्राफको यसको परिचयात्मक भ्रमणको क्रममा, टिकरले फिल्टरहरू बीचमा डाटा ब्लकहरूको स्रोतको रूपमा काम गर्ने कम्तिमा एउटा छ कि छैन भनेर जाँच गर्दछ। यदि त्यहाँ कुनै पनि छैन भने, ग्राफलाई गलत मानिन्छ र टिकर क्र्यास हुन्छ।

यदि ग्राफ "सही" हो भने, प्रत्येक फेला परेको फिल्टरको लागि, प्रकार्यलाई प्रारम्भिकरणको लागि बोलाइन्छ। पूर्व प्रक्रिया ()। अर्को प्रशोधन चक्रको लागि पल आउने बित्तिकै (पूर्वनिर्धारित रूपमा प्रत्येक १० मिलिसेकेन्डमा), टिकरले प्रकार्यलाई कल गर्छ। प्रक्रिया() सबै पहिले फेला परेका स्रोत फिल्टरहरूको लागि, र त्यसपछि सूचीमा बाँकी फिल्टरहरूको लागि। यदि फिल्टरमा इनपुट लिङ्कहरू छन् भने, त्यसपछि प्रकार्य चलाउनुहोस् प्रक्रिया() इनपुट लिङ्क लाइनहरू खाली नभएसम्म दोहोर्याउँछ। यसपछि, यो सूचीको अर्को फिल्टरमा जान्छ र इनपुट लिङ्कहरू सन्देशहरूबाट मुक्त नभएसम्म यसलाई "स्क्रोल" गर्छ। सूची समाप्त नभएसम्म टिकर फिल्टरबाट फिल्टरमा सर्छ। यसले चक्रको प्रशोधन पूरा गर्दछ।

अब हामी टुपल्समा फर्कनेछौं र किन मिडिया स्ट्रिमरमा यस्तो इकाई थपियो भन्ने बारे कुरा गर्नेछौं। सामान्यतया, फिल्टर भित्र काम गर्ने एल्गोरिथ्म द्वारा आवश्यक डेटाको मात्रा मिल्दैन र इनपुटमा प्राप्त डाटा बफरहरूको आकारको गुणन होइन। उदाहरण को लागी, हामी एक फिल्टर लेख्दै छौ जसले छिटो फुरियर रूपान्तरण गर्दछ, जुन परिभाषा अनुसार केवल डाटा ब्लकहरु लाई प्रक्रिया गर्न सक्छ जसको साइज दुई को शक्ति हो। यसलाई 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); 

यदि बफरमा संचित डाटाको आकार अनुरोध गरिएको भन्दा कम छ (datalen), त्यसपछि प्रकार्यले शून्य फर्काउँछ, डाटा डाटामा प्रतिलिपि गरिएको छैन। अन्यथा, बफर मा स्थित tuples बाट डाटा को क्रमिक प्रतिलिपि प्रदर्शन गरिन्छ। प्रतिलिपि गरेपछि, टपल मेटाइन्छ र मेमोरी खाली हुन्छ। डाटालेन बाइटहरू प्रतिलिपि हुँदा प्रतिलिपि गर्ने समय समाप्त हुन्छ। यदि डाटा ब्लकको बीचमा स्पेस समाप्त भयो भने, त्यसपछि यो सन्देशमा, डाटा ब्लकलाई बाँकी नक्कलिएको भागमा घटाइनेछ। अर्को पटक तपाईंले कल गर्नुहुन्छ, प्रतिलिपि गर्ने काम यस बिन्दुबाट जारी रहनेछ।

हाल बफरमा उपलब्ध डाटाको मात्रा पढ्दै:

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