חקר מנוע ה-VoIP Mediastreamer2. חלק 11

החומר של המאמר לקוח ממני ערוץ זן.

מנגנון תנועת נתונים

• בלוק נתונים dblk_t
• הודעה mblk_t
• פונקציות לעבודה עם הודעות mblk_t
• תור queue_t
• פונקציות לעבודה עם תורים queue_t
• חיבור מסננים
• גרף נקודת האות של עיבוד נתונים
• פעילות מאחורי הקלעים של הטיקר
• Bufferizer (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, המשמש רק כאשר ההודעה היא חלק מ-tuple. עבור ההודעה האחרונה ב-tuple, מצביע זה נשאר ריק.

לאחר מכן אנו רואים מצביע לבלוק נתונים b_datap, שעבורו קיימת ההודעה. אחריו מופיעים מצביעים לאזור בתוך מאגר נתוני הבלוק. שדה b_rptr מציין את המיקום שממנו ייקראו נתונים מהמאגר. שדה b_wptr מציין את המיקום שממנו תתבצע כתיבה למאגר.

שאר השדות הם בעלי אופי שירות ואינם נוגעים להפעלת מנגנון העברת הנתונים.

להלן הודעה בודדת עם השם m1 ובלוק נתונים d1.

האיור הבא מציג אוסף של שלוש הודעות m1, m1_1, m1_2.

פונקציות העברת הודעות mblk_t

הודעה חדשה mblk_t נוצר על ידי הפונקציה:

mblk_t *allocb(int size, int pri); 

היא מציבה הודעה חדשה בזיכרון mblk_t עם בלוק נתונים בגודל שצוין גודל, טיעון שני - פרי לא בשימוש בגרסה זו של הספרייה. זה צריך להישאר אפס. במהלך פעולת הפונקציה יוקצה זיכרון למבנה ההודעה החדשה והפונקציה תיקרא mblk_init(), אשר יאפס את כל השדות של המופע שנוצר של המבנה ולאחר מכן, באמצעות האמור לעיל datab_alloc(), תיצור מאגר נתונים. לאחר מכן יוגדרו השדות במבנה:

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

בפלט אנו מקבלים הודעה חדשה עם שדות מאותחלים ומאגר נתונים ריק. כדי להוסיף נתונים להודעה, עליך להעתיק אותה למאגר בלוק הנתונים:

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

איפה נתונים הוא מצביע למקור הנתונים, ו גודל - הגודל שלהם.
אז אתה צריך לעדכן את המצביע לנקודת הכתיבה כך שיצביע שוב לתחילת האזור הפנוי במאגר:

msg->b_wptr = msg->b_wptr + size

אם אתה צריך ליצור הודעה ממאגר קיים, ללא העתקה, השתמש בפונקציה:

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

הפונקציה, לאחר יצירת ההודעה ומבנה בלוק הנתונים, תגדיר את המצביעים שלה לנתונים בכתובת buf. הָהֵן. במקרה זה, מאגר הנתונים אינו ממוקם אחרי שדות הכותרת של בלוק הנתונים, כפי שהיה במקרה של יצירת בלוק נתונים עם הפונקציה datab_alloc(). המאגר עם הנתונים המועברים לפונקציה יישאר היכן שהיה, אבל בעזרת מצביעים הוא יצורף לכותרת החדשה שנוצרה של בלוק הנתונים, וזה, בהתאם, להודעה.

להודעה אחת mblk_t ניתן לשרשר מספר בלוקים של נתונים ברצף. זה נעשה על ידי הפונקציה:

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

mp - הודעה שאליה יתווסף בלוק נתונים נוסף;
נתונים - מצביע לבלוק, עותק שלו יתווסף להודעה;
גודל - גודל נתונים;
נתיב - דגל שגודל הזיכרון המוקצה חייב להיות מיושר לאורך גבול של 4 בתים (ריפוד יעשה עם אפסים).

אם יש מספיק מקום במאגר נתוני ההודעה הקיים, הנתונים החדשים יודבקו מאחורי הנתונים שכבר נמצאים שם. אם יש פחות מקום פנוי במאגר נתוני ההודעה מאשר גודל, אז נוצרת הודעה חדשה עם גודל מאגר מספיק והנתונים מועתקים למאגר שלו. זוהי הודעה חדשה, המקושרת להודעה המקורית באמצעות מצביע b_cont. במקרה זה, ההודעה הופכת לטופל.

אם אתה צריך להוסיף גוש נתונים נוסף ל-tuple, אז אתה צריך להשתמש בפונקציה:

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

היא תמצא את ההודעה האחרונה בטופלה (יש לו b_cont יהיה null) ויקרא לפונקציה עבור הודעה זו appendb().

אתה יכול לגלות את גודל הנתונים בהודעה או טופלה באמצעות הפונקציה:

int msgdsize(const mblk_t *mp);

זה יעבור בלולאה דרך כל ההודעות ב-tuple ויחזיר את כמות הנתונים הכוללת במאגרי הנתונים של ההודעות הללו. עבור כל הודעה, כמות הנתונים מחושבת באופן הבא:

 mp->b_wptr - mp->b_rptr

כדי לשלב שני tuples, השתמש בפונקציה:

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

היא מצרף את הטפול newm לזנב של tuple mp ומחזיר מצביע להודעה האחרונה של ה-tuple שהתקבל.

במידת הצורך, ניתן להפוך tuple להודעה אחת עם בלוק נתונים בודד; זה נעשה על ידי הפונקציה:

void msgpullup(mblk_t *mp,int len);

אם טיעון לן הוא -1, ואז גודל המאגר המוקצה נקבע אוטומטית. אם לן הוא מספר חיובי, מאגר בגודל זה ייווצר ונתוני הודעת הטפול יועתקו לתוכו. אם המאגר יגמר, ההעתקה תיעצר שם. ההודעה הראשונה של ה-tuple תקבל מאגר גודל חדש עם הנתונים שהועתקו. שאר ההודעות יימחקו והזיכרון יוחזר לערימה.

בעת מחיקת מבנה mblk_t ספירת ההתייחסות של בלוק הנתונים נלקחת בחשבון אם, בעת ההתקשרות freeb() מסתבר שהוא אפס, ואז מאגר הנתונים נמחק יחד עם המופע mblk_t, מה שמצביע על כך.

אתחול השדות של הודעה חדשה:

void mblk_init(mblk_t *mp);

הוספת נתון נוסף להודעה:

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

אם הנתונים החדשים אינם מתאימים לשטח הפנוי של מאגר נתוני ההודעה, אז מצורפת להודעה הודעה שנוצרה בנפרד עם מאגר בגודל הנדרש (מצביע להודעה שנוספה מוגדר בהודעה הראשונה) הודעה הופכת לטפול.

הוספת פיסת נתונים לטופלה:

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

הפונקציה קוראת ל-appendb() בלולאה.

שילוב של שני טופלים לאחד:

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

הודעה newm יצורף אליו mp.

יצירת עותק של הודעה בודדת:

mblk_t *copyb(const mblk_t *mp);

העתקה מלאה של טופלה עם כל בלוקי הנתונים:

mblk_t *copymsg(const mblk_t *mp);

האלמנטים של ה-tuple מועתקים על ידי הפונקציה 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, זה מצביע על האלמנט הראשון (הודעה) בתור. השדה השני של המבנה הוא מונה ההודעות בתור.
האיור שלהלן מציג תור בשם q1 המכיל 4 הודעות m1, m2, m3, m4.

האיור הבא מציג תור בשם q1 המכיל 4 הודעות m1,m2,m3,m4. Message m2 הוא ראשו של tuple שמכיל עוד שתי הודעות m2_1 ו-m2_2.

פונקציות לעבודה עם תורים queue_t

אתחול התור:

void qinit(queue_t *q);

שדה _q_stopper (להלן נקרא לזה "stopper") מאותחל על ידי הפונקציה mblk_init(), האלמנט הקודם שלו ומצביע האלמנט הבא מותאמים כך שיצביעו על עצמו. מונה רכיבי התור מאופס לאפס.

הוספת אלמנט חדש (הודעות):

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

אלמנט חדש m נוסף לסוף הרשימה, מצביעי האלמנטים מותאמים כך שהפקק יהפוך לאלמנט הבא עבורו, והוא הופך לאלמנט הקודם עבור המעצור. מונה רכיבי התור מוגדל.

אחזור רכיב מהתור:

mblk_t * getq(queue_t *q); 

ההודעה שמגיעה לאחר שליפת המעצור, ומונה האלמנטים מופחת. אם אין אלמנטים בתור מלבד המעצור, אז 0 מוחזר.

הכנסת הודעה לתור:

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

Элемент mp מוכנס לפני האלמנט EMP. אם EMP=0, אז ההודעה מתווספת לזנב התור.

שליפת הודעה מראש התור:

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

מונה האלמנטים מופחת.

קריאת מצביע לרכיב הראשון בתור:

mblk_t * peekq(queue_t *q); 

הסרת כל הרכיבים מהתור תוך מחיקת האלמנטים עצמם:

void flushq(queue_t *q, int how);

טיעון אֵיך לא בשימוש. מונה רכיבי התור מוגדר לאפס.

מאקרו לקריאת מצביע לרכיב האחרון של התור:

mblk_t * qlast(queue_t *q);

כשאתה עובד עם תורי הודעות, שים לב לכך כשאתה מתקשר ms_queue_put(q, m) עם מצביע null להודעה, הפונקציה עוברת לולאה. התוכנית שלך תקפא. מתנהג באופן דומה ms_queue_next(q, m).

חיבור מסננים

התור המתואר לעיל משמש להעברת הודעות ממסנן אחד למשנהו או ממסנן אחד למספר מסננים. מסננים והקשרים ביניהם יוצרים גרף מכוון. הקלט או הפלט של המסנן ייקרא המילה הכללית "pin". כדי לתאר את הסדר שבו מסננים מחוברים זה לזה, סטרימר המדיה משתמש במושג "נקודת אות". נקודת האות היא מבנה _MSCPoint, המכיל מצביע למסנן ומספר אחד מהפינים שלו; בהתאם, הוא מתאר את החיבור של אחת מהכניסות או היציאות של המסנן.

גרף נקודת האות של עיבוד נתונים

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

פיני הסינון ממוספרים החל מאפס.

החיבור של שני פינים על ידי תור הודעות מתואר על ידי המבנה _MSQueue, המכיל תור הודעות ומצביעים לשתי נקודות האות שהוא מחבר:

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

נקרא למבנה הזה קישור אות. כל מסנן סטרימר מדיה מכיל טבלה של קישורי קלט וטבלה של קישורי פלט (MSQueue). גודל הטבלאות נקבע בעת יצירת מסנן; כבר עשינו זאת באמצעות משתנה מיוצא מסוגו MSFilterDesc, כאשר פיתחנו פילטר משלנו. להלן מבנה המתאר כל מסנן בסטרימר מדיה, מסנן MS:

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 בהתאם לתוכנית שלנו (אך לא חיברנו את הטיקר), יצרנו בכך גרף מכוון, שהצמתים שלו הם מופעים של המבנה מסנן MS, וקצוות הם מופעים של קישורים MSQueue.

פעילות מאחורי הקלעים של הטיקר

כשאמרתי לך שהטיקר הוא מסנן למקור הקרציות, זו לא הייתה כל האמת על זה. טיקר הוא אובייקט שמפעיל פונקציות על השעון תהליך() כל המסננים של המעגל (גרף) אליו הוא מחובר. כאשר אנו מחברים טיקר למסנן גרף בתוכנת C, אנו מראים לטיקר את הגרף שהוא ישלוט בו מעתה ואילך עד שנכבה אותו. לאחר החיבור, הטיקר מתחיל לבחון את הגרף שהופקד על טיפולו, ומרכיב רשימה של מסננים הכוללים אותו. כדי לא "לספור" את אותו מסנן פעמיים, הוא מסמן את המסננים שזוהו על ידי הצבת תיבת סימון בהם לראות. החיפוש מתבצע באמצעות טבלאות הקישורים שיש לכל פילטר.

במהלך סיור ההיכרות שלו בגרף, הטיקר בודק אם בין המסננים יש לפחות אחד שפועל כמקור לחסימות נתונים. אם אין כאלה, הגרף נחשב לא נכון והטיקר קורס.

אם הגרף מתברר כ"נכון", עבור כל מסנן שנמצא, הפונקציה נקראת לאתחול preprocess(). ברגע שמגיע הרגע למחזור העיבוד הבא (כל 10 מילישניות כברירת מחדל), הטיקר קורא לפונקציה תהליך() עבור כל מסנני המקור שנמצאו בעבר, ולאחר מכן עבור המסננים הנותרים ברשימה. אם למסנן יש קישורי קלט, אז הפעל את הפונקציה תהליך() חוזר עד שתורי קישורי הקלט ריקים. לאחר מכן, הוא עובר למסנן הבא ברשימה ו"גולל" אותו עד שקישורי הקלט יהיו נקיים מהודעות. הטיקר עובר ממסנן למסנן עד לסיום הרשימה. זה משלים את עיבוד המחזור.

כעת נחזור ל-tuples ונדבר מדוע נוספה ישות כזו לסטרימר המדיה. באופן כללי, כמות הנתונים הנדרשת על ידי האלגוריתם הפועל בתוך המסנן אינה תואמת ואינה כפולה של גודל מאגרי הנתונים המתקבלים בקלט. לדוגמה, אנו כותבים מסנן שמבצע טרנספורמציה פורייה מהירה, שבהגדרה יכול לעבד רק בלוקי נתונים שגודלם הוא חזקת שתיים. תן לזה להיות 512 ספירות. אם הנתונים נוצרים על ידי ערוץ טלפון, אז מאגר הנתונים של כל הודעה בכניסה יביא לנו 160 דגימות אות. מפתה לא לאסוף נתונים מהקלט עד שכמות הנתונים הנדרשת תהיה שם. אבל במקרה זה, תתרחש התנגשות עם הטיקר, אשר ינסה ללא הצלחה לגלול את המסנן עד שקישור הקלט ריק. בעבר, הגדרנו את הכלל הזה כעיקרון השלישי של המסנן. לפי עיקרון זה, הפונקציה process() של המסנן חייבת לקחת את כל הנתונים מתורי הקלט.

בנוסף, לא ניתן יהיה לקחת רק 512 דגימות מהקלט, שכן ניתן לקחת רק בלוקים שלמים, כלומר. המסנן יצטרך לקחת 640 דגימות ולהשתמש ב-512 מהן, השאר לפני צבירת חלק חדש של נתונים. לפיכך, המסנן שלנו, בנוסף לעבודתו העיקרית, חייב לספק פעולות עזר לאחסון ביניים של נתוני קלט. מפתחי המדיה סטרימר ופתרון לבעיה כללית זו פיתחו אובייקט מיוחד - MSBufferizer (bufferer), אשר פותר בעיה זו באמצעות tuples.

Bufferizer (MSBufferizer)

זהו אובייקט שיצבור נתוני קלט בתוך המסנן ויתחיל לשלוח אותם לעיבוד ברגע שכמות המידע מספיקה להפעלת אלגוריתם המסנן. בזמן שהמאגר צובר נתונים, המסנן יפעל במצב סרק, מבלי לנצל את כוח העיבוד של המעבד. אבל ברגע שפונקציית הקריאה מה-buffer מחזירה ערך שונה מאפס, פונקציית process() של המסנן מתחילה לקחת ולעבד נתונים מה-buffer במנות בגודל הנדרש, עד למיצוי.
נתונים שעדיין לא נדרשים נשארים במאגר כאלמנט הראשון של ה-tuple, שאליו מצורפים בלוקים של נתוני קלט עוקבים.

המבנה שמתאר את המאגר:

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

פונקציות לעבודה עם MSBufferizer

יצירת מופע חיץ חדש:

MSBufferizer * ms_bufferizer_new(void);

הזיכרון מוקצה, מאותחל פנימה ms_bufferizer_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_bufferizer_put().

קריאה מהמאגר:

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

אם גודל הנתונים שנצבר במאגר קטן מהמבוקש (דאטלן), ואז הפונקציה מחזירה אפס, הנתונים לא מועתקים לנתונים. אחרת, מתבצעת העתקה רציפה של נתונים מ-tuples הממוקמים במאגר. לאחר ההעתקה, ה-tuple נמחק והזיכרון מתפנה. ההעתקה מסתיימת ברגע שבו מועתקים בתים של dataalen. אם המקום אוזל באמצע בלוק נתונים, אז בהודעה זו, בלוק הנתונים יצטמצם לחלק שנותר שלא הועתק. בפעם הבאה שתתקשר, ההעתקה תמשיך מנקודה זו.

קריאת כמות הנתונים הזמינה כעת במאגר:

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