Uurime VoIP mootorit Mediastreamer2. Osa 11

Artikli materjal on saadud minu Dzen-kanalist.

Andmete ülekande mehhanism

• Andmeplokk dblk_t
• Sõnum mblk_t
• Sõnumitega töötamise funktsioonid mblk_t
• Järjekord queue_t
• Järjekordadega töötamise funktsioonid queue_t
• Filterite ühendamine
• Signaalipunkt andmeprotsessi graafikus
• Tickere kulisside tegevus
• Mäbuffer (MSBufferizer)
• MSBufferizeriga töötamise funktsioonid

Eelmisel artiklis Oleme arendanud oma filtri. Selle artikli pühendame meedia edastusfiltrite vaheliste andmete ülekande sisemiste mehhanismide seadmele. See võimaldab tulevikus kirjutada keerukaid filtreid väiksema vaevaga.

Andmete ülekande mehhanism

Andmete ülekande protsess meedia edastusfiltris toimub järjekordade abil, mille struktuuri kirjeldatakse queue_t. Järjekordades liigutatakse sõnumite jadad, mis on tüübi mblk_t, mis ise ei sisaldanud signaalide andmeid, vaid ainult viite eelnenud ja järgmise sõnumi ja andmeploki juurde. Lisaks tahan eraldi rõhutada, et on olemas ka väli sama tüüpi sõnumite viitamiseks, mis võimaldab korraldada seotud sõnumite nimekirja. Kogumit sõnumeid, mis on sellesse nimekirja koondunud, nimetame tupleks. Seega võib iga elemendi järjekorras olla kas üksik sõnum mblk_t, või tuple sõnumite pea mblk_t. Igal tuple sõnumil võib olla oma seotud andmeplokk. Miks me vajame tupleid, arutame veidi hiljem.

Nagu eespool mainitud, ei sisalda sõnum ise andmeplokki, vaid sisaldab ainult viidat mälu alale, kus andmeplokk asub. Selles osas meenutab meedia edastusfiltri töö üldine pilt multika 'Koletiste korporatsioon' uksehoidjate ladustamist, kus uksed (andmete viidatud — ruumid) liiguvad meeletu kiirusel rippkonveieridel, samas kui toad ise jäävad paigale.

Nüüd, liikudes hierarhias alt üles, vaatame lähemalt andmete edastamise mehhanismis loetletud üksusi meedia edastusfiltris.

Andmeplokk dblk_t

Andmeplokk koosneb päisest ja andmebufferist. Pealkiri määratletakse järgmise struktuuri abil,

typedef struct datab
{
unsigned char *db_base; // Viidatud andmebufferi algus.
unsigned char *db_lim;  // Viidatud andmebufferi lõpp.
void (*db_freefn)(void*); // Funktsioon mälu vabastamiseks ploki kustutamisel.
int db_ref; // Viidete loendur.
} dblk_t;

Struktuuri valdkonnad sisaldavad viiteid puutöö algusele, puutöö lõppule ja andmete puhastamise funktsiooni. Peamine element on pealkirjas db_ref — viidete loendur, kui see jõuab nullini, on see signaal, et see plokk tuleks mälust eemaldada. Kui andmeplokk loodi funktsiooni datab_alloc() , siis andmepuhver paigutatakse mällu kohe pealkirja järele. Kõigil muudel juhtudel võib puhver asuda kuskil eraldi. Andmepuhvrisse paigutatakse signaali andmed või muud andmed, mida soovime filtreerimisega töödelda.

Uus andmeploki eksemplar luuakse funktsiooni abil:

dblk_t *datab_alloc(int size);

Sisendparameetrina edastatakse sellele andmete suurus, mida plokk talletab. Mälu eraldatakse rohkem, et eraldatud mälu algusesse paigutada pealkiri — struktuur datab. Kuid teiste funktsioonide kasutamisel ei pruugi see alati nii olla, mõnel juhul võib andmepuhver asuda eraldi andmeploki pealkirjast. Struktuuri väljad seadistatakse loomisel nii, et tema väli db_base osutaks andmeala algusele ja db_lim tema lõppu. Viidete loendur db_ref seatakse ühele. Andmete puhastamise funktsiooni viidatakse nulli.

Teade mblk_t

Nagu öeldud, järjekorra elemendid on tüüpi mblk_t, see on määratletud järgmiselt:

typedef struct msgb
{
  struct msgb *b_prev;   // Viidatud eelmine elemendi nimekiri.
  struct msgb *b_next;   // Viidatud järgmine elemendi nimekiri.
  struct msgb *b_cont;   // Viidatud, et kleepida teistele sõnumitele, et luua sõnumite kombinatsioon.
  struct datab *b_datap; // Viidatud andmeploki struktuurile.
  unsigned char *b_rptr; // Viidatud andmeala algusele andmete lugemiseks b_datap puhvrist.
  unsigned char *b_wptr; // Viidatud andmeala algusele andmete salvestamiseks b_datap puhvrist.
  uint32_t reserved1;    // Reserveeritud väli1, meedia voogedastaja paigutab sinna teenuseinformatsiooni. 
  uint32_t reserved2;    // Reserveeritud väli2, meedia voogedastaja paigutab sinna teenuseinformatsiooni.
  #if defined(ORTP_TIMESTAMP)
  struct timeval timestamp;
  #endif
  ortp_recv_addr_t recv_addr;
} mblk_t;

Struktuur mblk_t alguses sisaldab viidatud b_prev, b_next, mis on vajalikud kahekordse lingi loomiseks (milleks on järjekord queue_t).

Seejärel tuleb viidatud b_cont, mis seda kasutatakse ainult siis, kui sõnum siseneb tuplesse. Viimase sõnumi jaoks tuples jääb viitamine nulliks.

Järgmisena näeme viidet andmeblokkile b_datap, mille tõttu ja eksisteerib sõnum. Selle järel tulevad viidatud blokkide andmebufferi sees. Välja b_rptr näitab kohta, kust andmed luetakse bufferist. Välja b_wptr näitab kohta, kust andmed kirjutatakse bufferisse.

Ülejäänud väljad on teenuslikud ja ei seostu andmete edastamise mehhanismi toimingutega.

Allpool on näidatud üksik sõnum nimega m1 ja andmeblokk d1.

Järgmises joonises on kujutatud kolme sõnumi tupliku m1, m1_1, m1_2.

Sõnumite töötlemise funktsioonid mblk_t

Uus sõnum mblk_t loodakse funktsiooni abil:

mblk_t *allocb(int size, int pri); 

see allotab mälus uue sõnumi mblk_t mooduliga, mille andmeblokki suurus on size, teine argument — pri ei kasutata antud teegi versioonis. See peab jääma nulliks. Funktsiooni töö käigus eraldatakse mälu uue sõnumi struktuuri jaoks ja kutsutakse välja funktsioon mblk_init(), mis nullib kõik loodud struktuuri väljad ja seejärel, kasutades eelpool mainitud, datab_alloc()loob andmebufferi. Pärast seda seadistatakse väljad struktuuris:

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

Väljundina saame uue sõnumi initsialiseeritud väljade ja tühja andmebufferiga. Andmete lisamiseks sõnumisse tuleb nad kopeerida andmebloki bufferisse:

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

kus data — viit andmeallikale, ja size — nende suurus.
siis tuleb uuendada kirjutamise viit, et see osutaks taas vaba ala algusele bufferis:

msg->b_wptr = msg->b_wptr + size

Kui on vaja luua sõnum juba olemasolevast bufferist, ilma kopeerimiseta, siis selleks kasutatakse funktsiooni:

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

Funktsioon seadistab pärast sõnumi ja andmebloki struktuuri loomist selle viidete andmed aadressil buf. St. sel juhul ei asu andmebuffer headeri väljade järel, nagu see oli andmebloki loomisel funktsiooni abil. datab_alloc()Käivitatud funktsioonile edastatud andmepuhver jääb sinna, kus ta oli, kuid näidikute abil suunatakse see just loodud andmeploki päisele, mis omakorda suunatakse sõnumile.

Ühe sõnumiga mblk_t võib järjestikku liita mitu andmeplokki. Seda teeb funktsioon:

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

mp — sõnum, millele lisatakse veel üks andmeplokk;
data — näidik plokile, mille koopia lisatakse sõnumisse;
size — andmete suurus;
pad — lipp, et määratud mäluruumi suurus peaks olema jagatav 4 baidi piiriga (täiendamine toimub nullidega).

Kui olemasolevas sõnumi andmepuhveres on piisavalt ruumi, siis uued andmed liidetakse seal juba olevatele andmetele. Kui sõnumi andmepuvris on vähem ruumi kui size, siis luuakse uus sõnum, millel on piisava suurusega puhver ja andmed kopeeritakse selle puhpvrisse. See uus sõnum kinnitatakse algsega näidiku abil b_cont. Sel juhul muutub sõnum tupleks.

Kui tuplekusse tuleb lisada veel üks andmeplokk, tuleb kasutada funktsiooni:

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

see leiab tuple lõpus oleva viimase sõnumi (tal b_cont on null) ja kutsub selle sõnumi jaoks välja funktsiooni appendb().

Andmete suurust sõnumis või tupleksis saab teada funktsiooni abil:

int msgdsize(const mblk_t *mp);

see läbib kõik tuple sõnumid ja tagastab andmete koguhulga nende sõnumite andmepuvrites. Iga sõnumi andmete hulga arvutamine toimub nii:

 mp->b_wptr - mp->b_rptr

Kaks tuplekust ühendamiseks kasutatakse funktsiooni:

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

see liidab tuple newm tuple lõppu mp ja tagastab näidiku saadud tuple viimasele sõnumile.

Kui on vajalik, võib tuple muundada üheks sõnumiks ühe andmeplokiga, seda teeb funktsioon:

void msgpullup(mblk_t *mp,int len);

kui argument len on -1, siis määratakse eraldatud puhvri suurus automaatselt. Kui len Kui see on positiivne number, luuakse selle suuruse puhver ja sinna kopeeritakse sõnumite tupikandja andmed. Kui puhver täitub, siis kopeerimine lõpetatakse. Esimene tupikusõnum saab uue suurusega puhvri koos kopeeritud andmetega. Ülejäänud sõnumid kustutatakse ja mälu tagastatakse kuhja.

Struktuuri eemaldamisel mblk_t arvestatakse andmeploki viidete loendit, kui kutse ajal freeb() on see null, siis andmepuhver eemaldatakse koos eksemplariga mblk_t, millele see viitab.

Uue sõnumi väljade initsialiseerimine:

void mblk_init(mblk_t *mp);

Andmete lisamine sõnumile:

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

Kui uued andmed ei mahu sõnumi andmepuhvri vabasse ruumi, lisatakse sõnumile eraldi loodud sõnum soovitud suurusega puhvri jaoks (esimeses sõnumis määratakse viit lisatud sõnumile) ja sõnum muutub tupikuks.

Andmete lisamine tupikusse:

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

Funktsioon kutsub appendb() tsüklis.

Kahte tupikut liitmine üheks:

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

Teade newm seda lisatakse mp.

Ühe sõnumi koopia loomine:

mblk_t *copyb(const mblk_t *mp);

Terve tupiku täielik kopeerimine koos kõikide andmeplokkidega:

mblk_t *copymsg(const mblk_t *mp);

Tupiku elemendid kopeeritakse funktsiooni copyb().

Kerge koopia loomine sõnumist. mblk_tSiinjuures andmeplokk ei kopeerita, vaid selle viidete loend suurendab. db_ref:

mblk_t *dupb(mblk_t *mp);

Kerge koopia loomine tupikust. Andmeplokke ei kopeerita, ainult nende viidete loendid suurenevad. db_ref:

mblk_t *dupmsg(mblk_t* m);

Kõikide tupiku sõnumite liitmine üheks sõnumiks:

void msgpullup(mblk_t *mp,size_t len);

Kui argument len on -1, siis määratakse puhvri suurus automaatselt.

Sõnumi, tupiku eemaldamine:

void freemsg(mblk_t *mp);

Andmeploki viidete loend väheneb ühe võrra. Kui see saavutab nulli, eemaldatakse ka andmeplokk.

Sõnumi või tupiku andmemahtude koguse arvutamine.

size_t msgdsize(const mblk_t *mp);

Sõnumi eemaldamine rea sabast:

mblk_t *ms_queue_peek_last (q);

Ühe sõnumi reserveeritud väljade sisu kopeerimine teise sõnumisse (neis väljad on tõeliselt lipud, mida meediavooluote kasutab):

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

Järjekord queue_t

Sõnumite järjekord meediastreamer'is on teostatud kui ringikujuline kahekordne seotud loend. Iga loendi element sisaldab näidikut andm blokkide kohta signaali näidudega. Tulemuseks on see, et liigutatakse ainult viiteid andm blokkidele, samas kui andmed jäävad liikumatuks. St. liiguvad ainult viidatud.
Järjekorra struktuur queue_t, on toodud allpool:

typedef struct _queue
{
   mblk_t _q_stopper; /* "Tühi" järjekorra element, mis ei viita andmetele, kasutatakse ainult järjekorra haldamiseks. Järjekorra algatamisel (qinit()) seadistatakse selle viidatud nii, et need osutavad sellele endast. */
   int q_mcount;        // Elementide arv järjekorras.
} queue_t;

Struktuur sisaldab välja - viidatud _q_stopper tüübist *mblk_t, mis osutab esimesele elemendile (sõnumile) järjekorras. Struktuuri teine väli on sõnumite loendur, mis asub järjekorras.
Alloleval joonisel on kujutatud järjekord nimega q1, mis sisaldab 4 sõnumit m1, m2, m3, m4.

Järgmises joonises on kujutatud järjekord nimega q1, mis sisaldab 4 sõnumit m1, m2, m3, m4. Sõnum m2 on paarituse pea, kuhu sisenevad veel kaks sõnumit m2_1 ja m2_2.

Järjekordadega töötamise funktsioonid queue_t

Järjekorra algatamine:

void qinit(queue_t *q);

Väli _q_stopper (edaspidi nimetame seda "peatus") algatatakse funktsiooni kaudu mblk_init(), tema eelmine ja järgmine elemendi viidatud seadistatakse nii, et nad osutavad sellele endale. Järjekorra elementide loendur nullitakse.

Uue elemendi (sõnumi) lisamine:

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

Uus element m lisatakse loendi lõppu, elemendi viidatud seadistatakse nii, et peatus muutub selle järgneks elemendiks ja tema jaoks peatus eelneks. Järjekorra elementide loendurit suurendatakse.

Elemendi eemaldamine järjekorrast:

mblk_t * getq(queue_t *q); 

eemaldatakse see sõnum, mis on peatusest järgmine, järjekorra elementide loendurit vähendatakse. Kui järjekorras, peale peatuse, elemente pole, tagastatakse 0.

Sõnumi sisestamine järjekorda:

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

Element mp sisestatakse enne elementi emp. Kui emp=0, siis sõnum lisatakse järjekorra sabasse.

Sõnumi eemaldamine järjekorra peast:

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

Elementide loendurit vähendatakse.

Viidatud esimesele elemendile järjekorras:

mblk_t * peekq(queue_t *q); 

Küsimise kõikide elementide eemaldamine järjekorrast koos elementide eemaldamisega:

void flushq(queue_t *q, int how);

Argumendiks how ei kasutata. Ooteelemendi arv loenduri seadistamine toimub nulli.

Makro lugemisnäitaja viimase ooteelemendi jaoks:

mblk_t * qlast(queue_t *q);

Kasutades sõnumi järjekordi, tuleb meeles pidada, et kutsudes ms_queue_put(q, m) nullnäidikuga sõnumile, sumbub funktsioon. Teie programm hangub. Samuti käitub ms_queue_next(q, m).

Filterite ühendamine

Ülaltoodud järjekord kasutatakse sõnumite edastamiseks ühelt filtrilt teisele või ühelt mitmele filtrile. Filtrid ja nende ühendused omavahel moodustavad suunatud graafi. Filtri sisendit või väljundit nimetatakse üldiselt "pin". Filtritevahelise ühenduse järjekorra kirjeldamiseks kasutatakse meediastreameris mõistet "signaalpunkt". Signaalpunkt on struktuur _MSCPoint, mis sisaldab näidikut filtrile ja numbri ühe oma pin'ist, seega kirjeldab see ühe filtri sisendi või väljundi ühendust.

Signaalipunkt andmeprotsessi graafikus

typedef struct _MSCPoint{
struct _MSFilter *filter; // Näidik meediastreameri filtrile.
int pin;                        // Ühe filtri sisendi või väljundi number, st pin.
} MSCPoint;

Filtri pins on nummerdatud alates nullist.

Kahte pinni ühendav sõnumijärjekord on kirjeldatud struktuuris _MSQueue, mis sisaldab sõnumijärjekorda ja näidikuid kahe signaalpunkti vahel, mida see ühendab:

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

Kutsume seda struktuuri signaallingiks. Igal meediastreameri filtril on sisendi linkide tabel ja väljundi linkide tabel (MSQueue). Tabelite suurus määratakse filtri loomisel, seda oleme juba teinud eksporditud muutuja tüübi abil MSFilterDesc, kui töötasime välja oma filtri. Allpool on toodud struktuur, mis kirjeldab igat filtrit meediastreameris, MSFilter:

struct _MSFilter{
    MSFilterDesc *desc;    
    /* Näidik filtrile. */
    /* Kaitstud atribuudid, neid ei tohi nihutada ega eemaldada, vastasel juhul lakkab pluginatega töötamine. */
    ms_mutex_t lock;      /* Semafor. */
    MSQueue **inputs;     /* Sissepääsude lingid. */
    MSQueue **outputs;    /* Väljundite lingid. */
    struct _MSFactory *factory; /* Näidik tehasele, mis lõi selle filtrite jälje. */
    void *padding;              /* Mitte kasutatav, kasutatakse, kui lisatakse kaitstud väljad. */
    void *data;                 /* Näidik suvalisele struktuurile filtrite sisemise oleku ja vahepealsete arvutuste andmete hoidmiseks. */
    struct _MSTicker *ticker;   /* Näidik tikker-objektile, mis ei tohi olla null, kui kutsutakse välja funktsiooni process(). */
    /*privaatsed atribuudid, neid saab igal ajal nihutada ja muuta*/
    MSList *notify_callbacks; /* Tagasiside nimekiri, mida kasutatakse filtrite sündmuste töötlemiseks. */
    uint32_t last_tick;       /* Viimane takti number, mil process() funktsiooni kutsuti. */
    MSFilterStats *stats;     /* Filtri tööstatistika.*/
    int postponed_task; /*Õhtukeelustatud ülesannete arv. Mõned filtrid võivad edasilükata andmete töötlemist (process() funktsiooni kutse) mitmeks taktimiseks.*/
    bool_t seen;  /* Lipp, mida tikker kasutab, et tähistada, et see filtrite jälgimine on selle takti jooksul möödunud.*/
};
typedef struct _MSFilter MSFilter;

Pärast seda, kui oleme C-programmis filtrid vastavalt meie kavandile kokku ühendanud (kuid tikkerit ei ole ühendatud), oleme loonud suunatud graafi, mille sõlmed on struktuuri eksemplarid MSFilter, ja servad on lingi eksemplarid MSQueue.

Tickere kulisside tegevus

Kui ma ütlesin, et tikker on taktimine filtri allikas, siis see polnud kogu tõde tema kohta. Tikker on objekt, mis käivitab funktsioone vastavalt kellale process() kõikide filtrite skeemi (graafi) kohta, kuhu ta on ühendatud. Kui me C-programmis ühendame tikkeri graafi filtriga, näitame tikkerile graafi, mida ta hakkab haldama, kuni me ta lahti ühendame. Pärast ühendamist hakkab tikker vaatama temale usaldatud graafi, koostades nimekirja filtritest, kuhu ta kuulub. Et mitte "loendada" sama filtrit kaks korda, märgib ta kindlaks leitud filtrid, seades neisse lipu seen. Otsing toimub iga filtri lingi tabelite kaudu.

Ekskursiooni ajal kontrollib ticker, kas filtrite seas on vähemalt üks, mis täidab andmeplokkide allika rolli. Kui selliseid ei leidu, tunnistatakse graaf vääraks ja ticker lõpetab töö.

Kui graaf osutub "õigeks", kutsutakse iga leitud filtri jaoks initsialiseerimiseks välja funktsioon preprocess(). Kui tuleb aeg järgmise töötlemise tsükli jaoks (vaikimisi iga 10 millisecondi järel), kutsub ticker välja funktsiooni process() kõigi varem leitud allikafilterite jaoks ning seejärel ka ülejäänud filtrite loendis. Kui filtril on sisendlingid, siis käivitatakse funktsioon process() uuesti, kuni sisendlinkide järjekorrad on tühjad. Pärast seda liigub ta järgmise filtri juurde loendis ja "kerib" selle, kuni sõnumid on sisendlinkidelt vabastatud. Ticker liigub filtrilt filtrile, kuni loend lõppeb. Sellega lõpeb tsükli töötlemine.

Nüüd pöördume tupikute juurde ja räägime, miks on meediastreamerisse lisatud selline entiteet. Üldiselt ei ühti ja ei ole proportsionaalne algoritmi jaoks vajalik andmemahu suurus, mis töötab filtris, sisenevate andmebufferite suurusega. Näiteks kirjutame filtri, mis teostab kiire Fourier' transformatsiooni, mis definitsiooni kohaselt suudab töödelda ainult andmeplokke, mille suurus on kahe astme. Olgu see 512 näidust. Kui andmed genereeritakse telefoniühenduse kaudu, toob iga sõnumi sisenemise buffer andmed meile 160 näidust signaalist. On kiusatus mitte võtta andmeid sisse, kuni vajalik andmemahu hulk on täis. Kuid sel juhul tekib konflikt tickeriga, mis üritab tulutult kerida filtrit, kuni sisendlink on tühjendatud. Oleme varem määratlenud selle reegli kui filtri töö kolmanda põhimõtte. Selle põhimõtte kohaselt peab filtri funktsioon process() võtma kõik andmed sisendjoontest.

Lisaks ei saa sissevoolust võtta ainult 512 arvestust, kuna neid võib võtta ainult täisarvudena, st filter peab võtma 640 arvestust ja kasutades neist 512, jääb ülejääk uue andmepartiini kogumiseks. Seega peab meie filter, peale oma põhifunktsioonide, tagama ka abitegevused sisendandmete vahepealseks salvestamiseks. Meediavoodetootjate lahenduste jaoks selle üldise ülesande täitmiseks on välja töötatud spetsiaalne objekt - MSBufferizer (puhvritaja), mis lahendab selle ülesande kasutades tuplette.

Mäbuffer (MSBufferizer)

See on objekt, mis kogub sisendandmeid filtri sees ja hakkab neid töötlemiseks andma, kui informatsiooni kogus on piisav filtri algoritmi käivitamiseks. Seni, kuni puhvritaja kogub andmeid, töötab filter tühja režiimis, mitte raisates protsessori arvutusvõimet. Kuid niipea kui funktsioon, mis loeb puhvritajast, tagastab väärtuse, mis ei ole null, alustab filtri process() funktsioon ekraanilolliste andmete kogumist ja töötlemist täpses koguses kuni nende lõppemiseni.
Kasutamata andmed jäävad puhvritajas esimeseks elementiks tupletes, kuhu kinnitatakse järgmised sisendandmeplokid.

Struktuur, mis kirjeldab puhvritajat:

struct _MSBufferizer{
queue_t q; /* Teate järjekord. */
int size; /* Kokku andmete suurus, mis asub praegu puhvritajas. */
};
typedef struct _MSBufferizer MSBufferizer;

MSBufferizeriga töötamise funktsioonid

Uue puhvritaja eksemplari loomine:

MSBufferizer * ms_bufferizer_new(void);

Mälu eraldatakse, initsialiseeritakse ms_bufferizer_init() ja tagastatakse osuti.

Initsialiseerimise funktsioon:

void ms_bufferizer_init(MSBufferizer *obj); 

Initsialiseeritakse järjekord q, väli size seadistatakse nulliks.

Teate lisamine:

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

Teade m lisatakse järjekorda. Arvutatud plokkide andmete suurus lisatakse size.

Kõik teated, mis on järjekorras andmelingis, ummistuvad puhvritajasse q:

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

Teate edastamine lingist q puhvritajasse toimub funktsiooni kaudu ms_bufferizer_put().

Lugemine puhvritajast:

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

Kui puhvritajasse kogutud andmete suurus on väiksem kui nõutud (datalen), siis funktsioon tagastab null, andmete kopeerimine data ei toimu. Vastupidisel juhul toimub järjestikune andmete kopeerimine puhvrisse salvestatud tuple'itest. Pärast kopeerimist eemaldatakse tuple ja mälu vabastatakse. Kopeerimine lõppeb hetkel, kui on kopeeritud datalen bait'i. Kui koht lõppeb andmeploki keskel, siis piiratakse selle sõnumi andmeplokk järelejäänud kopeerimata osani. Järgmise kutse ajal jätkatakse kopeerimist sellest kohast.

Andmete hulga lugemine, mis on praegu puhvris saadaval:

int ms_bufferizer_get_avail(MSBufferizer *obj); 

Tagastab valdkonna size puhvrisse.

Puhvri andmete osa mahaviskamine:

void ms_bufferizer_skip_bytes(MSBufferizer *obj, int bytes);

Määratud hulga baite andmeid eemaldatakse ja mahaviskatakse. Mahaviskamine toimub vanematest andmetest.

Kogu puhvris olevate sõnumite eemaldamine:

void ms_bufferizer_flush(MSBufferizer *obj); 

Andmete loendur lähtestatakse nulli.

Kogu puhvris olevate sõnumite eemaldamine:

void ms_bufferizer_uninit(MSBufferizer *obj); 

Loenduri nullimist ei toimu.

Puhvri eemaldamine ja mälu vabastamine:

void ms_bufferizer_destroy(MSBufferizer *obj);  

Puhvrile kasutamise näiteid võib leida mitmest meediastrimmeri filtri lähtekoodist. Näiteks filtris MS_L16_ENC, mis teostab baitide ümberkorraldamist võrgujärjekorrast hosti järjestusse: l16.c

Järgmises artiklis käsitleme koormuse hindamise küsimust tickeril ja viise, kuidas vältida ülemäärast arvutuskoormust meediastrimmeris.

Allikas: habr.com