Ho hlahloba enjene ea Mediastreamer2 VoIP. Karolo ea 11

Thepa ea sehlooho e nkiloe ho ea ka mocha oa zen.

Mokhoa oa ho tsamaisa data

• Thibelo ea data dblk_t
• Molaetsa mblk_t
• Mesebetsi ea ho sebetsa ka melaetsa mblk_t
• Queue_t
• Mesebetsi ea ho sebetsa ka queue queue_t
• Lisefe tse hokelang
• Sebaka sa pontšo sa kerafo ea ts'ebetso ea data
• Ka morao ho lits'ebetso tsa ticker
• Bufferizer (MSBufferizer)
• Mesebetsi ea ho sebetsa le MSBufferizer

Qetellong sehlooho re iketselitse sefe ea rona. Sengoliloeng sena se tla shebana le mochini o ka hare oa ho tsamaisa data lipakeng tsa li-filters tsa media streamer. Sena se tla u lumella ho ngola li-filters tse tsoetseng pele ka boiteko bo fokolang nakong e tlang.

Mokhoa oa ho tsamaisa data

Tsamaiso ea data ho media streamer e etsoa ho sebelisoa mela e hlalositsoeng ke sebopeho queue_t. Likhoele tsa melaetsa tse kang mblk_t, tseo ka botsona li se nang lintlha tsa matšoao, empa li hokahanya feela molaetsa o fetileng, o latelang le ho thibela data. Ho phaella moo, ke batla ho hatisa ka ho khetheha hore ho boetse ho na le tšimo ea ho hokahanya molaetsa oa mofuta o le mong, e leng se u lumellang hore u hlophise lethathamo le le leng le amanang le melaetsa. Re tla bitsa sehlopha sa melaetsa se kopantsoeng ke lenane le joalo tuple. Ka hona, karolo efe kapa efe ea mokoloko e ka ba molaetsa o le mong mblk_t, mme mohlomong hlooho ea molaetsa tuple mblk_t. Molaetsa o mong le o mong oa tuple o ka ba le block ea ona ea data. Re tla tšohla hore na ke hobane'ng ha li-tuples li hlokahala hamorao.

Joalokaha ho boletsoe ka holimo, molaetsa ka boeona ha o na sekheo sa data; ho e-na le hoo, o na le pointer feela sebakeng sa memori moo thibela e bolokiloeng teng. Karolong ena, setšoantšo se akaretsang sa mosebetsi oa media streamer se re hopotsa ntlo ea polokelo ea mamati e setšoantšong sa "Monsters, Inc.," moo mamati (mahokelo a likamore tsa data) a tsamaeang ka lebelo la bohlanya haufi le lipalangoang tse holimo, ha likamore ka botsona. dula o sa sisinyehe.

Joale, ha re ntse re tsamaisana le bolaoli ho tloha tlase ho ea holimo, a re ke re hlahlobeng ka botlalo likarolo tse thathamisitsoeng tsa mochine oa phetiso ea data ho media streamer.

Sebaka sa data dblk_t

Thibelo ea data e na le hlooho le "buffer" ea data. Sehlooho se hlalosoa ke sebopeho se latelang,

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

Likarolo tsa sebopeho li na le lintlha tse lebisang qalong ea buffer, qetellong ea buffer, le mosebetsi oa ho hlakola "buffer" ea data. Karolo ea ho qetela ho hlooho db_ref — counter counter, haeba e fihla ho zero, sena se sebetsa e le lets'oao la ho hlakola boloko bona mohopolong. Haeba thibela ea data e entsoe ke mosebetsi datab_alloc() , ebe data buffer e tla behoa mohopolong hang ka mor'a hlooho. Maemong a mang kaofela, buffer e ka fumaneha kae-kae ka thoko. Sebaka sa polokelo ea data se tla ba le lisampole tsa matšoao kapa lintlha tse ling tseo re batlang ho li sebelisa ka li-filters.

Mohlala o mocha oa "data block" o etsoa ho sebelisoa ts'ebetso ena:

dblk_t *datab_alloc(int size);

E le parameter ea ho kenya, e fuoa boholo ba data eo thibela e tla e boloka. Mehopolo e eketsehileng e abeloa ho beha hlooho - sebopeho - qalong ea mohopolo o fanoeng datab. Empa ha o sebelisa lits'ebetso tse ling, sena ha se etsahale kamehla; maemong a mang, buffer ea data e ka beoa ka thoko ho hlooho ea block block. Ha ho etsoa sebopeho, masimo a lokisoa e le hore tšimo ea eona db_base e supile qalo ea sebaka sa data, le db_lim ho isa pheletsong ya yona. Palo ea lihokelo db_ref e behiloe ho e 'ngoe. Sesupa sa tšebetso se hlakileng sa data se behiloe ho zero.

Molaetsa oa hau mblk_t

Joalokaha ho boletsoe, likarolo tsa queue ke tsa mofuta mblk_t, e hlalosoa ka tsela e latelang:

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;

sebopeho sa mblk_t e na le litsupa qalong b_prev, b_e latelang, tse hlokahalang ho hlophisa lenane le hokahaneng habeli (e leng queue queue_t).

Joale ho tla pointer b_tswella, e sebelisoang feela ha molaetsa e le karolo ea tuple. Bakeng sa molaetsa oa ho qetela ho tuple, pointer ena e lula e le lefeela.

Ka mor'a moo re bona pointer ho thibela data b_datap, eo molaetsa o leng teng. E lateloa ke litsupa sebakeng se ka hare ho block data buffer. Tšimo b_rptr e hlalosa sebaka seo data e tsoang ho buffer e tla baloa ho sona. Tšimo b_wptr e bonts'a sebaka seo ho ngolla buffer ho tla etsoa ho sona.

Libaka tse setseng ke tsa mofuta oa ts'ebeletso 'me ha li amane le ts'ebetso ea mokhoa oa phetisetso ea data.

Ka tlase ke molaetsa o le mong o nang le lebitso m1 le data block d1.

Setšoantšo se latelang se bontša palo ea melaetsa e meraro m1, M1_1, M1_2.

Mesebetsi ea melaetsa mblk_t

Molaetsa o mocha mblk_t e entsoeng ke mosebetsi:

mblk_t *allocb(int size, int pri); 

o kenya molaetsa o mocha mohopolong mblk_t e nang le block ea data ea boholo bo boletsoeng boholo, khang ea bobeli - pele ha e sebelisoe mofuteng ona oa pokello ea libuka. E lokela ho lula e le zero. Nakong ea ts'ebetso ea ts'ebetso, mohopolo o tla abeloa sebopeho sa molaetsa o mocha mme mosebetsi o tla bitsoa mblk_init(), e tla tsosolosa likarolo tsohle tsa mohlala o bōpiloeng oa mohaho ebe o sebelisa se boletsoeng ka holimo datab_alloc(), e tla theha polokelo ea data. Ka mor'a moo, likarolo tsa sebopeho li tla hlophisoa:

mp->b_datap=datab;
mp->b_rptr=mp->b_wptr=datab->db_base;
mp->b_next=mp->b_prev=mp->b_cont=NULL;

Sephethong re fumana molaetsa o mocha o nang le masimo a qaliloeng le buffer ea data e se nang letho. Ho kenya data molaetsa, o hloka ho e kopitsa ho "data block buffer":

memcpy(msg->b_rptr, data, size);

moo ya data ke sesupo sa mohloli oa data, le boholo - boholo ba tsona.
joale o hloka ho nchafatsa pointer sebakeng sa ho ngola e le hore e ka supa hape qalong ea sebaka sa mahala se buffer:

msg->b_wptr = msg->b_wptr + size

Haeba o hloka ho etsa molaetsa ho tsoa ho buffer e seng e ntse e le teng, ntle le ho kopitsa, sebelisa ts'ebetso:

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

Mosebetsi, ka mor'a ho theha molaetsa le sebopeho sa "data block", e tla lokisa lintlha tsa eona ho data atereseng. buff. Tseo. Tabeng ena, buffer ea data ha e fumanehe ka mor'a masimo a lihlooho tsa "data block", joalo ka ha ho ne ho le joalo ha ho etsoa "data block" ka mosebetsi. datab_alloc(). Buffer e nang le data e fetiselitsoeng mosebetsing e tla sala moo e neng e le teng, empa ka thuso ea litsupa e tla khomarela hlooho e sa tsoa bōptjoa ea "data block", le hore, ho latela molaetsa.

Ho molaetsa o le mong mblk_t Li-block tsa data tse 'maloa li ka kopanngoa ka tatellano. Sena se etsoa ka ts'ebetso:

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

mp - molaetsa oo ho tla ekeletsoa ho thibela e 'ngoe ea data;
ya data - pointer ho thibela, kopi ea eona e tla ekeletsoa molaetsa;
boholo - boholo ba data;
pad - folakha ea hore boholo ba mohopolo o fanoeng o tlameha ho tsamaisana le moeli oa 4-byte (padding e tla etsoa ka zero).

Haeba ho na le sebaka se lekaneng ho buffer ea data ea molaetsa e teng, joale data e ncha e tla kenngoa ka morao ho data e seng e ntse e le teng. Haeba ho na le sebaka se tlase sa mahala ho buffer ea data ea molaetsa ho feta boholo, ebe molaetsa o mocha o etsoa ka boholo bo lekaneng ba buffer mme data e kopitsoa ho buffer ea eona. Ona ke molaetsa o mocha, o hokahantsoeng le oa mantlha o sebelisang sesupo b_tswella. Tabeng ena, molaetsa o fetoha tuple.

Haeba o hloka ho kenyelletsa block e 'ngoe ea data ho tuple, joale o hloka ho sebelisa ts'ebetso:

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

o tla fumana molaetsa oa ho qetela ho tuple (o na le b_tswella e tla ba lefeela) mme e tla letsetsa tšebetso ea molaetsa ona appendb().

U ka fumana boholo ba data molaetsa kapa tuple u sebelisa ts'ebetso:

int msgdsize(const mblk_t *mp);

e tla loop ka melaetsa eohle e tuple le khutlisetsa palo yohle ya data ka buffers ya data melaetsa eo. Bakeng sa molaetsa o mong le o mong, palo ea data e baloa ka tsela e latelang:

 mp->b_wptr - mp->b_rptr

Ho kopanya li-tuple tse peli, sebelisa ts'ebetso:

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

o hlomathisa tuple newm ho isa mohatleng wa tuple mp ebe e khutlisetsa pointer molaetsa oa ho qetela oa tuple e hlahisitsoeng.

Haeba ho hlokahala, tuple e ka fetoloa molaetsa o le mong ka "data" e le 'ngoe; sena se etsoa ke mosebetsi:

void msgpullup(mblk_t *mp,int len);

haeba khang len ke -1, ebe boholo ba buffer e abetsoeng bo khethoa ka bohona. Haeba len ke nomoro e nepahetseng, buffer ea boholo bona e tla etsoa mme data ea molaetsa oa tuple e tla kopitsoa ho eona. Haeba buffer e fela, ho kopitsa ho tla emisa moo. Molaetsa oa pele oa tuple o tla fumana buffer e ncha e nang le data e kopilitsoeng. Melaetsa e setseng e tla hlakoloa mme memori e khutlisetsoe qubung.

Ha o hlakola sebopeho mblk_t palo ea litšupiso ea "data block" e nkoa e le ea bohlokoa haeba, ha o letsetsa mahalab() e fetoha zero, ebe data buffer e hlakoloa hammoho le mohlala mblk_t, e supang ho eona.

Ho qala likarolo tsa molaetsa o mocha:

void mblk_init(mblk_t *mp);

Ho eketsa karolo e 'ngoe ea data molaetseng:

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

Haeba data e ncha e sa kenelle sebakeng sa mahala sa buffer ea data ea molaetsa, molaetsa o entsoeng ka thoko o nang le buffer ea boholo bo hlokahalang o hoketsoe molaetseng (ponts'o ea molaetsa o kentsoeng e behiloe molaetseng oa pele) ebe molaetsa o fetoha tuple.

Ho eketsa karolo ea data ho tuple:

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

Tshebetso e bitsa appendb() ka loop.

Ho kopanya li-tuple tse peli ho e le 'ngoe:

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

Molaetsa oa hau newm e tla hokelloa ho mp.

Ho etsa kopi ea molaetsa o le mong:

mblk_t *copyb(const mblk_t *mp);

Qetella ho kopitsa tuple ka li-blocks tsohle tsa data:

mblk_t *copymsg(const mblk_t *mp);

Lintlha tsa tuple li kopitsoa ke mosebetsi kopi ().

Etsa kopi e bonolo ea molaetsa mblk_t. Tabeng ena, thibela ea data ha e kopitsoe, empa k'hamera ea eona ea boitsebiso e eketseha db_ref:

mblk_t *dupb(mblk_t *mp);

Ho etsa kopi e bobebe ea tuple. Li-block tsa data ha li kopitsoe, ke li-counter tsa tsona feela tse ntseng li eketseha db_ref:

mblk_t *dupmsg(mblk_t* m);

Ho kenya melaetsa eohle ea tuple molaetseng o le mong:

void msgpullup(mblk_t *mp,size_t len);

Haeba khang len ke -1, ebe boholo ba buffer e abetsoeng bo khethoa ka bohona.

Ho hlakola molaetsa, tuple:

void freemsg(mblk_t *mp);

Palo ea litšupiso tsa block block ea data e fokotsoa ke e le 'ngoe. Haeba e fihla ho zero, "data block" le eona e tla hlakoloa.

Palo ea kakaretso ea data molaetsa kapa tuple.

size_t msgdsize(const mblk_t *mp);

Ho khutlisa molaetsa ho tsoa mohatleng oa mokoloko:

mblk_t *ms_queue_peek_last (q);

Ho kopitsa litaba tsa masimo a bolokiloeng a molaetsa o mong ho ea molaetseng o mong (ha e le hantle, masimo ana a na le lifolakha tse sebelisoang ke media streamer):

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

Moeli queue_t

Lethathamo la melaetsa ho media streamer le kengoa tšebetsong e le lenane le chitja le hokahantsoeng habeli. Karolo e 'ngoe le e' ngoe ea lethathamo e na le pointer ho block block ea data e nang le lisampole tsa matšoao. Hoa etsahala hore litsupa feela tsa block block ea data li tsamaellana, ha data ka boeona e ntse e sa sisinyehe. Tseo. ke lihokelo tsa tsona feela tse tlositsoeng.
Sebopeho se hlalosang mokoloko queue_t, e bontšitsoeng ka tlase:

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

Sebopeho se na le tšimo - pointer _q_sethiba thaepa *mblk_t, e supa ntho ea pele (molaetsa) moleng. Lekala la bobeli la sebopeho ke palo ea melaetsa e moleng.
Setšoantšo se ka tlase se bontša letoto le bitsoang q1 le nang le melaetsa e 4 m1, m2, m3, m4.

Setšoantšo se latelang se bontša letoto le bitsoang q1 le nang le melaetsa e 4 m1,m2,m3,m4. Message m2 ke hlooho ea tuple e nang le melaetsa e meng e 'meli m2_1 le m2_2.

Mesebetsi ea ho sebetsa ka queue queue_t

Ho qala mola:

void qinit(queue_t *q);

tšimo _q_sethiba (ka mor'a moo re tla e bitsa "stopper") e qalisoa ke mosebetsi mblk_init(), element ea eona e fetileng le pointer e latelang ea element li lokisoa ho iponahatsa. The queue elements counter is set reset to zero.

Ho eketsa ntho e ncha (melaetsa):

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

Ntho e ncha m e eketsoa qetellong ea lenane, lintlha tsa lintlha li lokisoa e le hore setopo e be ntho e latelang bakeng sa sona, 'me e fetoha ntho e fetileng bakeng sa setopo. The queue element counter is incremented.

Ho khutlisa element ho tsoa moleng:

mblk_t * getq(queue_t *q); 

Molaetsa o hlahang ka mor'a hore setopo se khutlisetsoe, 'me counter counter e fokotsehile. Haeba ho se na lielemente moleng ntle le setopo, joale 0 ea khutlisoa.

Ho kenya molaetsa moleng:

void insq(queue_t *q, mblk_t *emp, mblk_t *mp); 

Element mp e kentsoeng ka pele ho element emp. Haeba emp=0, ebe molaetsa o eketsoa mohatleng oa mokoloko.

Ho khutlisa molaetsa ho tsoa ho hlooho ea letoto:

void remq(queue_t *q, mblk_t *mp); 

The element counter e fokotsehile.

Ho bala sesupa ho ntlha ea pele moleng:

mblk_t * peekq(queue_t *q); 

Ho tlosa likarolo tsohle moleng ha o ntse o hlakola likarolo ka botsona:

void flushq(queue_t *q, int how);

khang kamoo e sa sebedisoang. The queue element counter is set to zero.

Macro ea ho bala pointer ho karolo ea ho qetela ea queue:

mblk_t * qlast(queue_t *q);

Ha u sebetsa ka mela ea melaetsa, hlokomela hore ha u letsetsa ms_queue_put(q, m) ka lesupa le se nang thuso ho molaetsa, ts'ebetso ea loops. Lenaneo la hau le tla hoama. itšoara joalo ms_queue_e latelang(q, m).

Lisefe tse hokelang

Lethathamo le hlalositsoeng ka holimo le sebelisetsoa ho fetisa melaetsa ho tloha ho sefe se seng ho ea ho se seng kapa ho tloha ho sefe se seng ho ea ho tse 'maloa. Li-filters le likhokahano tsa tsona li etsa kerafo e tobileng. Kenyelletso kapa tlhahiso ea sefe e tla bitsoa lentsoe le akaretsang "pin". Ho hlalosa tatellano eo li-filters li kopantsoeng ka eona, mecha ea litaba e sebelisa mohopolo oa "pontšo ea pontšo". Sebaka sa pontšo ke sebopeho _MSCPpoint, e nang le pointer ho filthara le palo ea e 'ngoe ea lithakhisa tsa eona; ka hona, e hlalosa khokahano ea e 'ngoe ea lintho tse kenang kapa tse hlahisoang ke sefe.

Sebaka sa pontšo sa kerafo ea ts'ebetso ea data

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

Lithapa tsa sefa li baloa ho qala ho noto.

Khokahano ea lithakhisa tse peli ka mola oa melaetsa e hlalosoa ke sebopeho _MSQueue, e nang le mola oa molaetsa le lisupa ho lintlha tse peli tseo e li hokahanyang:

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

Re tla bitsa sebopeho sena sehokelo sa matšoao. Sefahla se seng le se seng sa media streamer se na le tafole ea lihokelo tsa ho kenya le tafole ea lihokelo tsa tlhahiso (MQueue). Boholo ba litafole bo behiloe ha ho etsoa filthara; re se re entse sena re sebelisa mofuta o romelloang kantle ho naha MSFilterDesc, ha re ne re iketsetsa sefe ea rona. Ka tlase ke sebopeho se hlalosang filthara efe kapa efe ho media streamer, 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;

Ka mor'a hore re kopanye li-filters lenaneong la C ho ea ka moralo oa rona (empa re sa ka ra kopanya ticker), ka hona re ile ra theha graph e tobileng, eo li-node tsa eona e leng mehlala ea sebopeho. MSFilter, 'me lithako ke mehlala ea lihokelo MQueue.

Ka morao ho lits'ebetso tsa ticker

Ha ke le bolella hore ticker ke sefe ea mohloli oa liboseleise, e ne e se 'nete eohle ka eona. Ticker ke ntho e tsamaisang mesebetsi oacheng tshebetso() li-filters tsohle tsa potoloho (graph) eo e hokahaneng le eona. Ha re hokela ticker ho sefe ea graph lenaneong la C, re bonts'a ticker graph eo e tla e laola ho tloha joale ho ea pele ho fihlela re e tima. Ka mor'a ho hokahanya, ticker e qala ho hlahloba kerafo e filoeng tlhokomelo ea eona, ho bokella lethathamo la li-filters tse kenyelletsang eona. E le hore u se ke ua "bala" filthara e le 'ngoe habeli, e tšoaea li-filters tse fumanoeng ka ho beha lebokose la ho hlahloba ho tsona. bonoa. Patlisiso e etsoa ho sebelisoa litafole tsa likhokahano tseo filthara ka 'ngoe e nang le tsona.

Nakong ea ketelo ea eona ea kenyelletso ea kerafo, ticker e hlahloba hore na har'a li-filters ho na le bonyane e sebetsang e le mohloli oa li-blocks tsa data. Haeba li le sieo, joale graph e nkoa e fosahetse 'me ticker e senyeha.

Haeba graph e bonahala e "nepahetse", bakeng sa sefe se seng le se seng se fumanoeng, tšebetso e bitsoa bakeng sa ho qala preprocess(). Hang ha nako e fihla bakeng sa potoloho e latelang ea ts'ebetso (li-milliseconds tse ling le tse ling tse 10 ka ho sa feleng), ticker e bitsa ts'ebetso. tshebetso() bakeng sa disefe tsohle tsa mohlodi tse fumanweng pele, mme hape bakeng sa disefe tse setseng lenaneng. Haeba sefe se na le likhokahano tsa ho kenya, sebelisa tšebetso tshebetso() e pheta-pheta ho fihlela mela ea lihokelo e se na letho. Ka mor'a sena, e fetela pele ho sefe se latelang lethathamong ebe e "tsamaisa" ho fihlela lihokelo tsa ho kenya li se na melaetsa. Letshwao le tloha ho sefe ho ya ho sefe ho fihlela lenane le fela. Sena se phethela tšebetso ea potoloho.

Joale re tla khutlela ho li-tuples 'me re bue ka hore na ke hobane'ng ha mokhatlo o joalo o kentsoe ho media streamer. Ka kakaretso, palo ea data e hlokoang ke algorithm e sebetsang ka har'a sefe ha e tsamaisane ebile ha se bongata ba boholo ba li-buffers tsa data tse amohetsoeng ha ho kenngoa. Mohlala, re ngola sefe se etsang phetoho e potlakileng ea Fourier, eo ka tlhaloso e ka sebetsang feela li-block tsa data tseo boholo ba tsona e leng matla a mabeli. E ke e be lipalo tse 512. Haeba data e hlahisoa ke mocha oa thelefono, joale buffer ea data ea molaetsa o mong le o mong ho kenya letsoho e tla re tlisetsa mehlala ea matšoao a 160. Hoa leka ho se bokelle data ho tsoa ho kenyelletso ho fihlela palo e hlokahalang ea data e le teng. Empa tabeng ena, ho tla ba le ho thulana le ticker, e leng tla leka ka katleho ho tsamaisetsa filthara ho fihlela sehokelo se kenyang se se na letho. Pejana, re khethile molao ona e le molao-motheo oa boraro oa sefahla. Ho latela molao-motheo ona, ts'ebetso ea filthara () e tlameha ho nka data eohle ho tsoa meleng ea ho kenya.

Ho phaella moo, ho ke ke ha khoneha ho nka li-sampuli tse 512 feela ho tsoa ho kenyelletsong, kaha u ka nka li-blocks tse feletseng feela, i.e. filthara e tla tlameha ho nka lisampole tse 640 ebe li sebelisa tse 512 tsa tsona, tse setseng pele li bokella karolo e ncha ea data. Ka hona, sefahla sa rona, ho phaella mosebetsing oa sona o ka sehloohong, se tlameha ho fana ka liketso tse thusang bakeng sa polokelo ea mahareng ea data ea ho kenya. Baetsi ba mecha ea litaba le tharollo ea bothata bona bo akaretsang ba thehile ntho e khethehileng - MSBufferizer (bufferer), e rarollang bothata bona ka li-tuples.

Bufferizer (MSBufferizer)

Ena ke ntho e tla bokella data ea ho kenya ka har'a sefa ebe e qala ho e romella bakeng sa ts'ebetso hang ha tlhaiso-leseling e lekane ho tsamaisa algorithm ea filthara. Ha buffer e ntse e bokella data, filthara e tla sebetsa ka mokhoa o sa sebetseng, ntle le ho sebelisa matla a ho sebetsa a processor. Empa hang ha ts'ebetso ea ho bala ho tsoa ho bufferer e khutlisa boleng ntle le zero, ts'ebetso () ts'ebetso ea sefe e qala ho nka le ho sebetsana le data ho tsoa ho bufferer ka likarolo tsa boholo bo hlokahalang, ho fihlela bo felile.
Lintlha tse e-so hlokehe li ntse li le ka har'a buffer e le ntho ea pele ea tuple, eo li-blocks tse latelang tsa data tse kenyelitsoeng li kenngoeng ho tsona.

Sebopeho se hlalosang buffer:

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

Mesebetsi ea ho sebetsa le MSBufferizer

Ho theha mohlala o mocha oa buffer:

MSBufferizer * ms_bufferizer_new(void);

Memori e abiloe, e qalisoa ka ms_bufferizer_init() mme lesupa le buswa.

Mosebetsi oa ho qala:

void ms_bufferizer_init(MSBufferizer *obj); 

Lethathamo lea qala q, tšimo boholo e behiloe ho zero.

Ho kenya molaetsa:

void ms_bufferizer_put(MSBufferizer *obj, mblk_t *m); 

Molaetsa m o kentsoe moleng. Boholo bo baloang ba li-block tsa data bo eketsoa ho boholo.

E fetisetsa melaetsa eohle ho tloha lethathamong la data ho ea ho buffer q:

void ms_bufferizer_put_from_queue(MSBufferizer *obj, MSQueue *q);   

Ho fetisa melaetsa ho tsoa ho sehokelo q ka har'a buffer e etsoa ka ts'ebetso ms_bufferizer_put().

Ho bala ho tsoa ho buffer:

int ms_bufferizer_read(MSBufferizer *obj, uint8_t *data, int datalen); 

Haeba boholo ba data e bokelletsoeng ka har'a buffer e ka tlase ho e batloang (datalen), ebe mosebetsi o khutlisa zero, data ha e kopitsoe ho data. Ho seng joalo, ho kopitsoa ka tatellano ea data ho tsoa ho li-tuples tse ka har'a buffer ho etsoa. Kamora ho kopitsa, tuple ea hlakolwa mme memori e lokollwa. Ho kopitsa ho fela nakong eo datalen byte e kopitsoang. Haeba sebaka se fela bohareng ba sekoahelo sa data, joale molaetseng ona, thibelo ea data e tla fokotsoa ho karolo e setseng e sa kopitsoang. Nakong e tlang ha u letsa, ho kopitsa ho tla tsoela pele ho tloha ntlheng ena.

Ho bala palo ea data e fumanehang hona joale buffer:

int ms_bufferizer_get_avail(MSBufferizer *obj); 

E khutlisetsa tšimo boholo mohlokomedi.

Ho lahla karolo ea data ho buffer:

void ms_bufferizer_skip_bytes(MSBufferizer *obj, int bytes);

Nomoro e boletsoeng ea li-byte tsa data e tla khutlisoa ebe e lahloa. Lintlha tsa khale li lahliloe.

Ho hlakola melaetsa eohle e buffer:

void ms_bufferizer_flush(MSBufferizer *obj); 

Khaontara ea data e setiloe bocha ho zero.

Ho hlakola melaetsa eohle e buffer:

void ms_bufferizer_uninit(MSBufferizer *obj); 

Khaontara ha e so hlophisoa bocha.

Ho tlosa buffer le ho lokolla memori:

void ms_bufferizer_destroy(MSBufferizer *obj);  

Mehlala ea ho sebelisa bufferer e ka fumanoa khoutu ea mohloli oa li-filters tse 'maloa tsa media streamer. Mohlala, ho filthara ea MS_L16_ENC, e hlophisang li-byte ka lisampole ho tloha ho tatellano ea marang-rang ho ea ho taelo ea moamoheli: l16.c

Sehloohong se latelang, re tla sheba taba ea khakanyo ea mojaro oa li-ticker le mokhoa oa ho sebetsana le mojaro o feteletseng oa komporo ho media streamer.

Source: www.habr.com