Explorans machinam Mediastreamer2 VoIP. Pars I

Materia articuli sumitur ex my rhoncus channel.

Data motus mechanism

• Data obstructionum dblk_t
• Nuntius mblk_t
• Munera operandi cum nuntiis mblk_t
• Queue queue_t
• Munera operandi cum queues queue_t
• Filtra connectens
• Signum punctum MGE graph
• Post scaenae actiones ticker
• Bufferizer (MSBufferizer)
• Munera operandi cum MSBufferizer

In novissimis articulus colum nostra elaboraverunt. Hic articulus in mechanismum internum versabit ad movendas notitias inter medias filtras streaming. Id tibi permittet ut columellas scribeas minori conatu in futurum.

Data motus mechanism

Data motus in instrumentis streamer fit utens queues per structuram descriptos queue_t. Fila epistularum similis mblk_tquae ipsae notitias notas non continent, sed tantum nexus ad nuntium priorem, proximum nuntium et ad schedulam indicalem. Insuper in primis confirmare volumus etiam campum esse nexum cum nuntio eiusdem generis, quod permittit te unum indicem epistularum coniunctum instruere. Epistularum coetum tali indice tuplum unitum appellabimus. Ita quodlibet elementum queue unum nuntium esse potest mblk_tet fortasse caput epistulae tuple mblk_t. Quisque nuntius tuple suum pupillum notitias scandalum habere potest. Cur tuples paulo post opus fuerit, discutiemus.

Ut supra dictum est, nuntius ipse truncum notitiarum non continet, sed solum monstratorem areae memoriae continet ubi scandalum reponitur. In hac parte, altiore pictura instrumentorum conniventis operis simile est ostio cellae in viverra "Monstra, Inc", ubi portae (nexiones data - cubicula) insana celeritate movent per vectores supra caput, dum ipsae conclavia immobilis manet.

Nunc, hierarchiam ab imo ad summum movens, singillatim expendamus quae enumerantur notarum transmissionum mechanismum in instrumentis confluentibus.

Data obstructionum dblk_t

Truncus notitia in capite et quiddam notitiae consistit. Caput sequens describitur per structuram.

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

Agrorum structurae argumenta continent principia quiddam, finis quiddam, et munus delendae notitiae quiddam. Ultimum elementum in header db_ref - Renuntiatio contra, si nulla attingit, hoc pro signo est ut hunc scandalum e memoria deleret. Si data obstructionum munus creatum est datab_alloc () tunc notitia quiddam statim post caput in memoria ponetur. In omnibus aliis casibus collocari potest quiddam separatim. Quiddam notitiae signum exempla vel alia notitia continebit quae cum columella procedere volumus.

Novum instantia data scandalum utens munere creatur;

dblk_t *datab_alloc(int size);

Pro modulo input, datum est amplitudo notitiarum quam scandalum congreget. Plures memoria collocatur ad titulum titulumque structurae in principio memoriae datum datab. Sed cum aliis functionibus utens, hoc non semper accidit: in quibusdam in casibus, notitiae quiddam separatim ab indice notitiae capitis collocari possunt. Cum structuram creant, conformantur agri ut campus eius db_base data area ostendit principium et db_lim ad finem. Link comitem db_ref positum est. Notitia functionis manifestae monstratorem nulla est.

Nuntius mblk_t

Ut dictum, elementa generis sunt mblk_t, diffinitur sic:

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;

structure mblk_t habet indicium in principio b_prev, b_nextquae necessaria sunt in indice duplici coniuncto constituendo (quod est a queue queue_t).

Tum est regula b_contqui tantum nuntius est pars tupli. Ad ultimum nuntium in tupla, monstrator hic nullus manet.

Deinde videmus monstratorem notitia scandalum b_datappro quo exstat nuntius. Sequitur indicium ad aream datam intra clausuram quiddam. Agro b_rptr denotat locum ex quo notitia quiddam legetur. Agro b_wptr indicat locus ex quo scribit ad quiddam agetur.

Reliquae regiones naturae inserviunt et operationi notae translationis mechanismum non referunt.

Infra est nuntius una cum nomine m1 et data obstructionum d1.

Sequens figura ostendit tuple trium epistularum m1, m1_1, m1_2.

Munera Nuntius mblk_t

Epistula nova mblk_t munus creatum est;

mblk_t *allocb(int size, int pri); 

quae ponit nuntium novum in memoria mblk_t cum data obstructionum de certa magnitudine magnitudine, secunda ratio - Codex in hac versione non adhibita bibliotheca. Nulla ut dictum nulla. In operatione functionis memoria collocabitur ad structuram novi nuntii et munus vocabitur mblk_init (), quae omnia agri instantia fabricae creatae reset erit ac deinde, adhibito supradicto datab_alloc (), quiddam notitia creabit. Post quem configurabuntur agri in structura;

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

In output novum nuntium accipimus cum agris initialized et inani notitia quiddam. Ut notitias nuntium addas, necesse est eam imitari ad quiddam clausus dati:

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

quibus Data monstratorem est fons notitiae et magnitudine — magnitudo eorum.
tunc debes monstratorem renovare ad punctum scribendum ut rursus ad initium liberae area in quiddam;

msg->b_wptr = msg->b_wptr + size

Si nuntium ex quiddam exsistenti creare debes, sine exscribendo, functione utere;

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

Munus, post nuntium et structuram claustrorum creans, eius indicia configurabit cum inscriptione electronica colaphis. Illae. hoc in casu, quiddam notitiarum non est collocatum post caput capitis in schedula stipendii, sicut in casu datorum stipem cum functione creando. datab_alloc (). Quiddam cum notitia ad munus transiit ubi erat, remanebit, sed indicibus adiuvantibus ad novum caput dati clausculi applicabitur, ac proinde ad nuntium.

Ad unum nuntium mblk_t Plures notitiae caudices consequenter concatenari possunt. Hoc fit munere;

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

mp - nuntius cui adicietur alius clausus;
Data — monstratorem scandali, cuius exemplum ad nuntium apponetur;
magnitudine - data magnitudine;
pad - Vexillum, quod magnitudo memoriae partita est per 4-byte limitem aligned (finda erit cum cyphris).

Si spatium satis est in notitia quiddam existente nuntio, tunc nova notitia conglutinabitur post notitias iam ibi. Si spatium vacuum minus est in verbo notitia quiddam quam magnitudineergo nuntius novus creatur cum sufficienti magnitudine et notitia eius quiddam exscribatur. Hoc est nuntium novum, coniunctum cum originali monstratore utente b_cont. Hoc in casu nuntius in tuple vertit.

Si alium scandalum notitiarum tuplum addere debes, functione uti debes:

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

et invenies in tuple ultimum nuntium (habet b_cont nulla erit) et munus hoc nuntium vocabo appendb ().

Magnitudinem notitiarum invenire potes in epistula vel tuple utens munere:

int msgdsize(const mblk_t *mp);

per omnes nuntios in tupla solvet et totam summam notitiarum in datorum buffers epistularum reddet. Pro unoquoque nuntio, summa rerum notitiarum hoc modo computatur:

 mp->b_wptr - mp->b_rptr

Ad duas tuplas coniungendas, utere functione;

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

apponit tuple newm ad caudam tuple mp et monstratorem reddit ad ultimum nuntium consequentis tuple.

Si opus est, tupla in unum nuntium verti potest cum uno trunco ​​notitiarum, hoc fit munere;

void msgpullup(mblk_t *mp,int len);

si argumentum ben est -1, tunc magnitudo quiddam collocandi determinatum est ipso facto. Si ben numerus positivus est, quiddam magnitudinis huius creabitur et nuntius tuples in eo transcribendus erit. Si quiddam deficiet, illic sistendum describendo. Primus nuntius tuple novam quiddam amplitudinis cum notitia exscripta accipiet. Reliquae epistulae delebuntur et memoria in cumulum rediit.

Cum delendo compages mblk_t referat comitem de notitia scandalum habetur si, cum vocantem freeb () evenit ut nulla, notitia quiddam deletum cum instantia mblk_tquae demonstrat.

Agros novi nuntii initializing:

void mblk_init(mblk_t *mp);

Addens aliud fragmen notitia ad nuntium:

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

Si nova notitia in vacuum nuntiationis quiddam datorum non convenit, tunc separatim creatum nuntium cum quiddam quaesitae quantitatis adnectitur nuntio (monstratorem nuntium additum in primo nuntio positum) et nuntius in tuple vertit.

Addito fragmen data ad tuple;

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

Munus appellat appendb() in ansa.

Tuples combining duos in unum:

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

Nuntius newm attachiatus erit mp.

Exemplar unum nuntium faciens:

mblk_t *copyb(const mblk_t *mp);

Tuple cum omnibus notitia cuneos exscribend testatem:

mblk_t *copymsg(const mblk_t *mp);

Elementa tuple munere transcribuntur copyb ().

Facilis exemplum creare nuntium mblk_t. Hoc in casu, notitia scandali non exscriptus est, sed eius relatio contra augetur db_ref:

mblk_t *dupb(mblk_t *mp);

Faciens leve exemplum tuple. Caudices datae non sunt exscriptae, calculis tantum referentibus incremented sunt db_ref:

mblk_t *dupmsg(mblk_t* m);

Conglutinata omnia mandata tubi in unum nuntium:

void msgpullup(mblk_t *mp,size_t len);

Si argumentum ben est -1, tunc magnitudo quiddam collocandi determinatum est ipso facto.

Epistula delendo, tuple:

void freemsg(mblk_t *mp);

Notitia scandali referat comitem ab uno decretur. Si nulla attingit, scandalum schedula etiam deletum est.

Calculus in summa copia notitiarum per nuntium vel tuple.

size_t msgdsize(const mblk_t *mp);

Nuntium recuperare a cauda queue;

mblk_t *ms_queue_peek_last (q);

Effingo contenta agrorum reservatorum unius nuntii in alium nuntium (re vera, hi agri vexilla continent quae in instrumentis streamer utuntur);

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

rursus queue_t

Nuntium queue in instrumentis streaming perficiatur ut indicem rotundum duplici coniuncto. Unumquodque elementum album continet monstratorem ad stipitem datae cum signo exemplorum. Evenit ut solum indices ad scandalum notae se moveant, dum ipsa notitia immobilis manet. Illae. tantum nexus illis moventur.
Describit structura queue queue_tinfra:

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

Structura campum continet - monstratorem _q_stopper typus *mblk_t, primo elementum (nuntium) in queue demonstrat. Secundus structurae campus est abacum nuntiorum in queue.
Figura infra ostendit queue nominata q1 continens 4 epistulas m1, m2, m3, m4.

Sequens figura queue nomine q1 demonstrat continens 4 epistulas m1,m2,m3,m4. Mandatum m2 est caput tuplae quod continet duas epistulas plures m2_1 et m2_2.

Munera operandi cum queues queue_t

Queue initialization:

void qinit(queue_t *q);

agri _q_stopper (infra postea appellabimus eam "spissator") initialized a munere est mblk_init ()elementum eius prius et sequens monstratorem ad designandum sibi adaptantur. Nulla elementum lorem non est reset queue.

Novum elementum addit (epistulae);

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

Novum elementum m ad finem catalogi additur, elementum indicibus ita adaptatur ut illud spissamentum fiat proximum elementum, et prius elementum spissamentum fit. Contra elementum queue incremented est.

Elementum recuperare a queue:

mblk_t * getq(queue_t *q); 

Nuntius qui venit post spissamentum restituit, elementum calculo decretur. Si elementa non sunt in queue nisi spissamentum, 0 redditur.

Nuntium in queue inserens:

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

elementum mp inserta ante elementum emp. si emp=0, nuntius caudae queue additur.

Nuntium recuperare de capite queue;

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

Contra elementum decretur.

Lectio regula primi elementi in queue;

mblk_t * peekq(queue_t *q); 

Omnia elementa a queue tollens, delendo ipsis elementis;

void flushq(queue_t *q, int how);

ratio quam non usi. Nulla in lorem non lorem elementum posuere.

Macro legendo monstratorem ultimum elementum queue:

mblk_t * qlast(queue_t *q);

Cum opus per nuntium queues, scito quod vocas ms_queue_put (q, m) cum nullo monstrante ad nuntium, munus ansas. Programma tuum durabitur. se similiter ms_queue_next (q, m).

Filtra connectens

Queue supra scripta sunt nuntiis ab uno ad aliud vel ab uno in plures columellas transire. Filtra et nexus eorum graphium directum formant. Initus seu output colum vocabitur generale verbum "acum". Ordinem describere quo filamenta inter se connexa sunt, media streaming conceptu "puncti signi" utitur. Signum punctum est structuram _MSCPointquae monstratorem colum et numerum unius fibulae continet, nexum inputs seu outputs colum describit.

Signum punctum MGE graph

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

Fibulae columellae a nulla inceptio numerantur.

Connexio duarum fibularum per nuntium queue per structuram describitur _MSQueue, quod continet nuntium queue et indicibus duobus notis notis quod nectit:

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

Hanc structuram signum vinculi vocabimus. Singulis instrumentis streamer colum continet mensam input nexuum et mensam de nexus output (MSQueue). Mensarum magnitudo ponitur cum filtrum creando, iam hoc utendo exportato variabilis speciei fecimus MSFilterDesccum elaboravimus nostrum Colum. Infra est structura quae colum in instrumentis streamer describit ; 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;

Postquam Filtra in C programmatis secundum consilium nostrum conteximus (non autem cum ticker coniungimus), inde graphum directum creavimus, cuius nodi sunt instantiae structurae. MSFilterIn marginibus sunt instantiae nexuum MSQueue.

Post scaenae actiones ticker

Cum dixeram tibi tesseram esse colum ad fontem ricini, non tota veritas de eo erat. A ticker est res quae munera in horologium decurrit processus () omnes filamenta in circuitu (grapho) cui coniungitur. Cum tesseram ad graphium colum in a C programmate coniungimus, graphium ticker demonstramus quod posthac moderabitur donec avertatur. Post connexionem, ticker incipit examinare graphum suae curae commissum, componens indicem filorum qui eum includunt. Ut ne bis idem "numerare" colum, detectas filtras notat ponendo perscriptio in illis videtur. Investigatio exercetur in tabulis ligaminis quas singulas colum habet.

In itinere introductorio graphi, ticker compescit num inter filtras sit saltem qui fons notitiarum caudices agit. Si nullae sunt, purus ac purus existimatur et cum fragore ticker.

Si graphum evadit "rectum", pro singulis inventis colum, munus vocatur ad initialization preprocess (). Cum primum momentum advenit pro proximo processui cycli (omnis 10 milliseconds per defaltam), munus vocat ticker processus () omnia enim prius inventa sunt de fonte filorum, deinde pro reliquis filtra in indice. Si colum nexus initus habet, tunc munus currit processus () repetit dum initus nexus queues vacua sunt. Postea in proximum colum in indicem ac "cartis" transit usque dum nexus initus epistularum immunes sunt. Acta ticker ex colum ad colum usque in album desinunt. Haec processus cycli perficit.

Nunc ad tuples revertemur et de causa loquamur cur talis res in instrumentis streaming addita sit. In genere, copia notitiarum quae algorithm in colum operante requirunt, non coincidit neque multiplex est magnitudo datarum buffers acceptorum in input. Exempli gratia, scribimus filtrum, quod velocitatem Fourieriani transformat, quae per definitionem solum potest processus notitiarum stipitiorum, quarum magnitudo duorum potentiae est. 512 Esto comitum. Si notitia ex alveo telephonico generatur, notitia quiddam cuiusque nuntii in initus nobis 160 signum exempla afferet. Temptat non colligere notitias ab input, donec quantitas data ibi est. Sed in hoc casu occurret collisio cum ticker, quod infeliciter temptabit colum librum usque dum input nexus inanis est. Antea designavimus hanc regulam ut tertium principium colum. Secundum hoc principium, processus colum () functiones omnes notitias ab initus queues accipere debet.

Praeterea non poterit tantum 512 exempla ex initus accipere, cum tantum caudices integros capere potes, i.e. colum debebit accipere 640 exempla et uti 512 ex eis, residuum antequam novam portionem notitiarum accumulant. Ita nostrum colum, praeter suum principale opus, actiones auxiliares praebere debet pro repositione intermedia input data. Tincimenta instrumentorum confluentia et solutionis huius generalis quaestionis specialem obiectum elaboraverunt - MSBufferizer (bufferer), qui hanc quaestionem solvit per tuples.

Bufferizer (MSBufferizer)

Hoc objectum est quod notitias intra colum initus coacervabit et submittere incipiet ad expediendas ubi copia notitiarum sufficit ad algorithmum colum ad currendum. Dum quiddam notitia accumulat, colum in modo otioso operabitur, sine processu processus potentiae adhibita. Sed ubi primum munus lectionis e bufferer praeter nullum valorem reddit, processus () functionis colum incipit accipere et processus notitia ex bufferer in portionibus magnitudinis debitae, donec defatigatus est.
Data quae nondum requiruntur, remanet in quiddam ut primum elementum tuple, cui subsequens cunei input datae adnectuntur.

Structuram quiddam quod describitur:

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

Munera operandi cum MSBufferizer

Novum quiddam exempli gratia:

MSBufferizer * ms_bufferizer_new(void);

Memoria collocatur, initialized in ms_bufferizer_init () et regula redditur.

Munus initialization:

void ms_bufferizer_init(MSBufferizer *obj); 

Queue est initializing q, ager magnitudine ut nulla posuere.

Epistulam addens:

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

Nuntius m queue additur. Calculus initus magnitudinem data cuneos additur magnitudine.

Mandata omnia transferens e nexu data queue ad quiddam q:

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

Transferre nuntios ex nexum q in quiddam fit per munus ms_bufferizer_put ().

Lectio quiddam est:

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

Si magnitudo notitia exaggeratus in quiddam minus est quam petitum unum (datalen) ergo munus nulla recurrit, notitia ad data non est transcribenda. Alioquin exemplum sequentiae notitiarum e tuples in quiddam collocatur. Post exscriptum, tuple deletum est et memoria liberatur. Desinit in tempore quo datalen bytes exscribuntur. Si spatium in medio schedulae excurrit, hoc nuntio, scandalum notitia ad reliquam partem non copitabitur. Proximo tempore vocas, ab hoc loco perseveres imitando.

Legere moles notitia quod est available in quiddam:

int ms_bufferizer_get_avail(MSBufferizer *obj); 

Redit in agro magnitudine bufferer.

Pars data in quiddam abiecta:

void ms_bufferizer_skip_bytes(MSBufferizer *obj, int bytes);

Certus numerus notitiarum bytes receptae et abiectae sunt. Antiquissima notitia exuitur.

Deletis omnia mandata in quiddam:

void ms_bufferizer_flush(MSBufferizer *obj); 

Contra data est nulla ad reset.

Deletis omnia mandata in quiddam:

void ms_bufferizer_uninit(MSBufferizer *obj); 

Contra non reset.

De tollendo quiddam et morlis memoria;

void ms_bufferizer_destroy(MSBufferizer *obj);  

Exempla utendi bufferer in fonte codice plurium instrumentorum eliquatorum conglutinatorum inveniuntur. Exempli gratia in MS_L16_ENC filter, qui ordinat bytes in speciminibus e retiacula ordinis ad exercitum: l16.c

In proximo articulo, exitum ticker aestimationis oneris spectabimus et quomodo cum nimio computatione oneris in instrumentis streamer tractabimus.

Source: www.habr.com