ການສຳຫຼວດເຄື່ອງຈັກ Mediastreamer2 VoIP. ພາກທີ 11

ເອກະສານຂອງບົດຄວາມແມ່ນເອົາມາຈາກຂອງຂ້ອຍ ຊ່ອງ zen.

ກົນໄກການເຄື່ອນໄຫວຂໍ້ມູນ

• ບລັອກຂໍ້ມູນ dblk_t
• ຂໍ້ຄວາມ mblk_t
• ຟັງຊັນສໍາລັບການເຮັດວຽກກັບຂໍ້ຄວາມ mblk_t
• ຄິວ queue_t
• ຟັງຊັນສໍາລັບການເຮັດວຽກກັບແຖວ queue_t
• ເຊື່ອມຕໍ່ຕົວກອງ
• ຈຸດສັນຍານຂອງກາຟປະມວນຜົນຂໍ້ມູນ
• ກິດຈະກໍາທາງຫລັງຂອງ ticker ໄດ້
• Bufferizer (MSBufferizer)
• ຫນ້າທີ່ເຮັດວຽກກັບ MSBufferizer

ໃນທີ່ສຸດ ບົດຄວາມ ພວກເຮົາໄດ້ພັດທະນາຕົວກອງຂອງພວກເຮົາເອງ. ບົດຄວາມນີ້ຈະເນັ້ນໃສ່ກົນໄກພາຍໃນສໍາລັບການເຄື່ອນຍ້າຍຂໍ້ມູນລະຫວ່າງຕົວກອງ media streamer. ນີ້ຈະຊ່ວຍໃຫ້ທ່ານຂຽນຕົວກອງທີ່ຊັບຊ້ອນດ້ວຍຄວາມພະຍາຍາມຫນ້ອຍໃນອະນາຄົດ.

ກົນໄກການເຄື່ອນໄຫວຂໍ້ມູນ

ການ​ເຄື່ອນ​ໄຫວ​ຂໍ້​ມູນ​ໃນ​ສື່​ມວນ​ຊົນ streamer ແມ່ນ​ປະ​ຕິ​ບັດ​ໂດຍ​ການ​ນໍາ​ໃຊ້​ແຖວ​ອະ​ທິ​ບາຍ​ໂດຍ​ໂຄງ​ປະ​ກອບ​ການ​ ຄິວ_ທ. ສາຍຂອງຂໍ້ຄວາມເຊັ່ນ mblk_t, ເຊິ່ງຕົວຂອງມັນເອງບໍ່ມີຂໍ້ມູນສັນຍານ, ແຕ່ພຽງແຕ່ເຊື່ອມຕໍ່ກັບຂໍ້ຄວາມທີ່ຜ່ານມາ, ຕໍ່ໄປແລະບລັອກຂໍ້ມູນ. ນອກຈາກນັ້ນ, ຂ້າພະເຈົ້າຕ້ອງການເນັ້ນຫນັກໂດຍສະເພາະວ່າຍັງມີພາກສະຫນາມສໍາລັບການເຊື່ອມຕໍ່ກັບຂໍ້ຄວາມຂອງປະເພດດຽວກັນ, ເຊິ່ງຊ່ວຍໃຫ້ທ່ານສາມາດຈັດລໍາດັບຂໍ້ຄວາມທີ່ມີການເຊື່ອມໂຍງແບບດ່ຽວ. ພວກ​ເຮົາ​ຈະ​ເອີ້ນ​ກຸ່ມ​ຂອງ​ຂໍ້​ຄວາມ​ທີ່​ໂຮມ​ກັນ​ໂດຍ​ບັນ​ຊີ​ລາຍ​ການ​ດັ່ງ​ກ່າວ​ເປັນ tuple. ດັ່ງນັ້ນ, ອົງປະກອບໃດໆຂອງແຖວສາມາດເປັນຂໍ້ຄວາມດຽວ mblk_t, ແລະບາງທີຫົວຂອງ tuple ຂໍ້ຄວາມ mblk_t. ແຕ່ລະຂໍ້ຄວາມ tuple ສາມາດມີຕັນຂໍ້ມູນອຸປະຖໍາຂອງຕົນເອງ. ພວກເຮົາຈະປຶກສາຫາລືວ່າເປັນຫຍັງ tuples ແມ່ນຈໍາເປັນເລັກນ້ອຍຕໍ່ມາ.

ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ຂໍ້ຄວາມຕົວມັນເອງບໍ່ມີບລັອກຂອງຂໍ້ມູນ; ແທນທີ່ຈະ, ມັນມີພຽງແຕ່ຕົວຊີ້ໄປຫາພື້ນທີ່ຫນ່ວຍຄວາມຈໍາທີ່ບລັອກຖືກເກັບໄວ້. ໃນສ່ວນນີ້, ຮູບພາບລວມຂອງການເຮັດວຽກຂອງຜູ້ສື່ຂ່າວແມ່ນ reminiscent ຂອງສາງປະຕູໃນກາຕູນ "Monsters, Inc.," ບ່ອນທີ່ປະຕູ (ການເຊື່ອມຕໍ່ກັບຂໍ້ມູນ - ຫ້ອງ) ເຄື່ອນທີ່ດ້ວຍຄວາມໄວ insane ຕາມ conveyors overhead, ໃນຂະນະທີ່ຫ້ອງຂອງຕົນເອງ. ຍັງບໍ່ມີການເຄື່ອນໄຫວ.

ໃນປັດຈຸບັນ, ການເຄື່ອນຍ້າຍໄປຕາມລໍາດັບຊັ້ນຈາກລຸ່ມຫາເທິງ, ໃຫ້ພິຈາລະນາຢ່າງລະອຽດກ່ຽວກັບຫນ່ວຍງານທີ່ມີລາຍຊື່ຂອງກົນໄກການສົ່ງຂໍ້ມູນໃນສື່ streamer.

ບລັອກຂໍ້ມູນ dblk_t

ບລັອກຂໍ້ມູນປະກອບດ້ວຍ header ແລະ buffer ຂໍ້ມູນ. ສ່ວນຫົວແມ່ນອະທິບາຍໂດຍໂຄງສ້າງຕໍ່ໄປນີ້,

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

ຊ່ອງຂໍ້ມູນຂອງໂຄງສ້າງມີຕົວຊີ້ໄປຫາຈຸດເລີ່ມຕົ້ນຂອງບັຟເຟີ, ຈຸດສິ້ນສຸດຂອງບັຟເຟີ, ແລະຟັງຊັນສໍາລັບການລຶບແບັກອັບຂໍ້ມູນ. ອົງປະກອບສຸດທ້າຍໃນສ່ວນຫົວ db_ref — ຕົວ​ຊີ້​ວັດ​ການ​ອ້າງ​ອີງ​, ຖ້າ​ຫາກ​ວ່າ​ມັນ​ໄປ​ຮອດ​ສູນ​, ນີ້​ເຮັດ​ຫນ້າ​ທີ່​ເປັນ​ສັນ​ຍານ​ທີ່​ຈະ​ລົບ block ນີ້​ຈາກ​ຄວາມ​ຊົງ​ຈໍາ​. ຖ້າບລັອກຂໍ້ມູນຖືກສ້າງຂື້ນໂດຍຟັງຊັນ datab_alloc() , ຫຼັງຈາກນັ້ນ buffer ຂໍ້ມູນຈະຖືກວາງໄວ້ໃນຫນ່ວຍຄວາມຈໍາທັນທີຫຼັງຈາກ header. ໃນກໍລະນີອື່ນໆທັງຫມົດ, buffer ສາມາດຕັ້ງຢູ່ບ່ອນໃດບ່ອນຫນຶ່ງແຍກຕ່າງຫາກ. ຂໍ້ມູນ buffer ຈະມີຕົວຢ່າງສັນຍານຫຼືຂໍ້ມູນອື່ນໆທີ່ພວກເຮົາຕ້ອງການທີ່ຈະດໍາເນີນການກັບການກັ່ນຕອງ.

ຕົວຢ່າງໃໝ່ຂອງບລັອກຂໍ້ມູນຖືກສ້າງຂື້ນໂດຍໃຊ້ຟັງຊັນ:

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_ຖັດໄປ, ເຊິ່ງມີຄວາມຈໍາເປັນໃນການຈັດຕັ້ງບັນຊີລາຍຊື່ທີ່ເຊື່ອມຕໍ່ສອງເທົ່າ (ເຊິ່ງເປັນແຖວ ຄິວ_ທ).

ຫຼັງຈາກນັ້ນ, ຕົວຊີ້ມາ b_cont, ເຊິ່ງຖືກນໍາໃຊ້ພຽງແຕ່ໃນເວລາທີ່ຂໍ້ຄວາມເປັນສ່ວນຫນຶ່ງຂອງ tuple. ສໍາລັບຂໍ້ຄວາມສຸດທ້າຍໃນ tuple, ຕົວຊີ້ນີ້ຍັງຄົງເປັນ null.

ຕໍ່ໄປພວກເຮົາເຫັນຕົວຊີ້ໄປຫາບລັອກຂໍ້ມູນ b_datap, ສໍາລັບຂໍ້ຄວາມທີ່ມີຢູ່. ມັນຕິດຕາມດ້ວຍຕົວຊີ້ໄປຫາພື້ນທີ່ພາຍໃນ buffer ຂໍ້ມູນບລັອກ. ພາກສະຫນາມ b_rptr ລະບຸສະຖານທີ່ທີ່ຂໍ້ມູນຈາກ buffer ຈະຖືກອ່ານ. ພາກສະຫນາມ b_wptr ຊີ້ບອກສະຖານທີ່ທີ່ຂຽນໃສ່ buffer ຈະຖືກປະຕິບັດ.

ທົ່ງນາທີ່ຍັງເຫຼືອແມ່ນມີລັກສະນະການບໍລິການແລະບໍ່ກ່ຽວຂ້ອງກັບການດໍາເນີນງານຂອງກົນໄກການໂອນຂໍ້ມູນ.

ຂ້າງລຸ່ມນີ້ແມ່ນຂໍ້ຄວາມດຽວທີ່ມີຊື່ m1 ແລະຕັນຂໍ້ມູນ d1.

ຕົວເລກຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນເຖິງ tuple ຂອງສາມຂໍ້ຄວາມ m1, m1_1, m1_2.

ຟັງຊັນການສົ່ງຂໍ້ຄວາມ mblk_t

ຂໍ້ຄວາມໃໝ່ mblk_t ສ້າງ​ໂດຍ​ການ​ທໍາ​ງານ​:

mblk_t *allocb(int size, int pri); 

ນາງວາງຂໍ້ຄວາມໃຫມ່ໃນຄວາມຊົງຈໍາ mblk_t ກັບຕັນຂໍ້ມູນຂອງຂະຫນາດທີ່ກໍານົດໄວ້ ຂະຫນາດ, ການໂຕ້ຖຽງທີສອງ - pri ບໍ່ໄດ້ໃຊ້ໃນຫ້ອງສະໝຸດສະບັບນີ້. ມັນຄວນຈະເປັນສູນ. ໃນລະຫວ່າງການປະຕິບັດງານຂອງຟັງຊັນ, ຫນ່ວຍຄວາມຈໍາຈະຖືກຈັດສັນສໍາລັບໂຄງສ້າງຂອງຂໍ້ຄວາມໃຫມ່ແລະຫນ້າທີ່ຈະຖືກເອີ້ນ mblk_init(), ເຊິ່ງຈະປັບທຸກຂົງເຂດຂອງຕົວຢ່າງທີ່ສ້າງຂື້ນຂອງໂຄງສ້າງແລະຫຼັງຈາກນັ້ນ, ການນໍາໃຊ້ທີ່ໄດ້ກ່າວມາຂ້າງເທິງ datab_alloc(), ຈະສ້າງ buffer ຂໍ້ມູນ. ຫຼັງຈາກນັ້ນ, ຊ່ອງຂໍ້ມູນໃນໂຄງສ້າງຈະຖືກຕັ້ງຄ່າ:

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

ຢູ່ທີ່ຜົນຜະລິດພວກເຮົາໄດ້ຮັບຂໍ້ຄວາມໃຫມ່ທີ່ມີຊ່ອງຂໍ້ມູນເບື້ອງຕົ້ນແລະ buffer ຂໍ້ມູນຫວ່າງເປົ່າ. ເພື່ອ​ເພີ່ມ​ຂໍ້​ມູນ​ໃສ່​ຂໍ້​ຄວາມ​ໃດ​ຫນຶ່ງ​, ທ່ານ​ຈໍາ​ເປັນ​ຕ້ອງ​ສໍາ​ເນົາ​ເອົາ​ມັນ​ໄປ​ທີ່​ຂໍ້​ມູນ block buffer​:

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

ບ່ອນທີ່ ຂໍ້ມູນ ເປັນຕົວຊີ້ໄປຫາແຫຼ່ງຂໍ້ມູນ, ແລະ ຂະຫນາດ - ຂະ​ຫນາດ​ຂອງ​ເຂົາ​ເຈົ້າ​.
ຫຼັງຈາກນັ້ນ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ປັບປຸງຕົວຊີ້ໄປຫາຈຸດຂຽນເພື່ອໃຫ້ມັນຊີ້ໃຫ້ເຫັນເຖິງຈຸດເລີ່ມຕົ້ນຂອງພື້ນທີ່ຫວ່າງໃນ buffer:

msg->b_wptr = msg->b_wptr + size

ຖ້າທ່ານຕ້ອງການສ້າງຂໍ້ຄວາມຈາກ buffer ທີ່ມີຢູ່ແລ້ວ, ໂດຍບໍ່ມີການຄັດລອກ, ຫຼັງຈາກນັ້ນໃຊ້ຟັງຊັນ:

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

ຟັງຊັນ, ຫຼັງຈາກການສ້າງຂໍ້ຄວາມແລະໂຄງສ້າງຂອງຕັນຂໍ້ມູນ, ຈະ configure ຕົວຊີ້ຂອງມັນກັບຂໍ້ມູນຢູ່ໃນທີ່ຢູ່. buff. ເຫຼົ່ານັ້ນ. ໃນ​ກໍ​ລະ​ນີ​ນີ້, buffer ຂໍ້​ມູນ​ບໍ່​ໄດ້​ຕັ້ງ​ຢູ່​ຫຼັງ​ຈາກ​ພາກ​ສະ​ຫນາມ header ຂອງ block ຂໍ້​ມູນ, ເຊັ່ນ​ດຽວ​ກັນ​ກັບ​ກໍ​ລະ​ນີ​ໃນ​ການ​ສ້າງ block ຂໍ້​ມູນ​ທີ່​ມີ​ຫນ້າ​ທີ່ datab_alloc(). buffer ທີ່ມີຂໍ້ມູນທີ່ສົ່ງກັບຟັງຊັນຈະຍັງຄົງຢູ່, ແຕ່ດ້ວຍການຊ່ວຍເຫຼືອຂອງ pointers ມັນຈະຕິດກັບ header ທີ່ສ້າງຂຶ້ນໃຫມ່ຂອງ block ຂໍ້ມູນ, ແລະວ່າ, ຕາມຄວາມເຫມາະສົມ, ຂໍ້ຄວາມ.

ຕໍ່ກັບຂໍ້ຄວາມດຽວ mblk_t ບລັອກຂໍ້ມູນຫຼາຍອັນສາມາດເຂົ້າກັນໄດ້ຕາມລຳດັບ. ນີ້ແມ່ນເຮັດໄດ້ໂດຍຫນ້າທີ່:

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

mp — ຂໍ້ຄວາມທີ່ບລັອກຂໍ້ມູນອື່ນຈະຖືກເພີ່ມ;
ຂໍ້ມູນ — ຊີ້ໄປທີ່ບລັອກ, ສຳເນົາທີ່ຈະຖືກເພີ່ມໃສ່ຂໍ້ຄວາມ;
ຂະຫນາດ - ຂະ​ຫນາດ​ຂໍ້​ມູນ​;
pad — ທຸງວ່າຂະໜາດຂອງໜ່ວຍຄວາມຈຳທີ່ຈັດສັນຕ້ອງຖືກຈັດລຽງຕາມຂອບເຂດ 4-byte (padding ຈະເຮັດດ້ວຍສູນ).

ຖ້າມີພື້ນທີ່ພຽງພໍໃນ buffer ຂໍ້ມູນຂໍ້ຄວາມທີ່ມີຢູ່ແລ້ວ, ຂໍ້ມູນໃຫມ່ຈະຖືກວາງໄວ້ທາງຫລັງຂອງຂໍ້ມູນທີ່ມີຢູ່ແລ້ວ. ຖ້າມີພື້ນທີ່ຫວ່າງຫນ້ອຍລົງໃນຂໍ້ຄວາມ buffer ຂໍ້ມູນ ຂະຫນາດ, ຫຼັງຈາກນັ້ນ, ຂໍ້ຄວາມໃຫມ່ຖືກສ້າງຂື້ນດ້ວຍຂະຫນາດ buffer ທີ່ພຽງພໍແລະຂໍ້ມູນຈະຖືກຄັດລອກໄປທີ່ buffer ຂອງມັນ. ນີ້ແມ່ນຂໍ້ຄວາມໃໝ່, ເຊື່ອມຕໍ່ກັບຂໍ້ຄວາມຕົ້ນສະບັບໂດຍໃຊ້ຕົວຊີ້ b_cont. ໃນກໍລະນີນີ້, ຂໍ້ຄວາມປ່ຽນເປັນ tuple.

ຖ້າທ່ານຕ້ອງການເພີ່ມຂໍ້ມູນບລັອກອື່ນໃສ່ tuple, ທ່ານຈໍາເປັນຕ້ອງໃຊ້ຟັງຊັນ:

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

ນາງຈະພົບເຫັນຂໍ້ຄວາມສຸດທ້າຍໃນ tuple (ລາວມີ b_cont ຈະເປັນ null) ແລະຈະໂທຫາຫນ້າທີ່ສໍາລັບຂໍ້ຄວາມນີ້ ເອກະສານຊ້ອນທ້າຍ().

ທ່ານສາມາດຊອກຫາຂະຫນາດຂອງຂໍ້ມູນໃນຂໍ້ຄວາມຫຼື tuple ໂດຍໃຊ້ຟັງຊັນ:

int msgdsize(const mblk_t *mp);

ມັນຈະ loop ຜ່ານຂໍ້ຄວາມທັງຫມົດໃນ tuple ແລະສົ່ງຄືນຈໍານວນຂໍ້ມູນທັງຫມົດໃນ buffers ຂໍ້ມູນຂອງຂໍ້ຄວາມເຫຼົ່ານັ້ນ. ສໍາລັບແຕ່ລະຂໍ້ຄວາມ, ຈໍານວນຂໍ້ມູນແມ່ນຄິດໄລ່ດັ່ງຕໍ່ໄປນີ້:

 mp->b_wptr - mp->b_rptr

ເພື່ອສົມທົບສອງ tuple, ໃຊ້ຟັງຊັນ:

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

ນາງຕື່ມ tuple ໄດ້ ໃໝ່ ກັບຫາງຂອງ tuple ໄດ້ mp ແລະສົ່ງຕົວຊີ້ໄປຫາຂໍ້ຄວາມສຸດທ້າຍຂອງ tuple ຜົນໄດ້ຮັບ.

ຖ້າຈໍາເປັນ, tuple ສາມາດປ່ຽນເປັນຂໍ້ຄວາມດຽວທີ່ມີຂໍ້ມູນດຽວ; ນີ້ແມ່ນເຮັດໄດ້ໂດຍຫນ້າທີ່:

void msgpullup(mblk_t *mp,int len);

ຖ້າການໂຕ້ຖຽງ len ແມ່ນ -1, ຫຼັງຈາກນັ້ນ, ຂະຫນາດຂອງ buffer ທີ່ຖືກຈັດສັນແມ່ນຖືກກໍານົດໂດຍອັດຕະໂນມັດ. ຖ້າ len ເປັນຕົວເລກບວກ, buffer ຂະຫນາດນີ້ຈະຖືກສ້າງຂື້ນແລະຂໍ້ມູນຂໍ້ຄວາມ tuple ຈະຖືກຄັດລອກໃສ່ມັນ. ຖ້າບັຟເຟີໝົດ, ການສຳເນົາຈະຢຸດຢູ່ທີ່ນັ້ນ. ຂໍ້ຄວາມທໍາອິດຂອງ tuple ຈະໄດ້ຮັບ buffer ຂະຫນາດໃຫມ່ທີ່ມີຂໍ້ມູນທີ່ຄັດລອກ. ຂໍ້ຄວາມທີ່ຍັງເຫຼືອຈະຖືກລຶບອອກແລະຫນ່ວຍຄວາມຈໍາໄດ້ກັບຄືນສູ່ heap.

ເມື່ອລຶບໂຄງສ້າງ mblk_t ຈໍານວນການອ້າງອິງຂອງຕັນຂໍ້ມູນໄດ້ຖືກພິຈາລະນາຖ້າຫາກວ່າ, ໃນເວລາທີ່ໂທຫາ freeb() ມັນປ່ຽນເປັນສູນ, ຫຼັງຈາກນັ້ນ buffer ຂໍ້ມູນຖືກລຶບພ້ອມກັບຕົວຢ່າງ mblk_t, ເຊິ່ງຊີ້ໃຫ້ເຫັນມັນ.

ການເລີ່ມຕົ້ນຊ່ອງຂໍ້ມູນຂອງຂໍ້ຄວາມໃໝ່:

void mblk_init(mblk_t *mp);

ການເພີ່ມຂໍ້ມູນອື່ນໃສ່ຂໍ້ຄວາມ:

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

ຖ້າຂໍ້ມູນໃຫມ່ບໍ່ເຫມາະສົມກັບພື້ນທີ່ຫວ່າງຂອງຂໍ້ມູນຂໍ້ຄວາມ, ຫຼັງຈາກນັ້ນ, ຂໍ້ຄວາມທີ່ຖືກສ້າງຂື້ນແຍກຕ່າງຫາກທີ່ມີ buffer ຂອງຂະຫນາດທີ່ກໍານົດໄວ້ແມ່ນຕິດກັບຂໍ້ຄວາມ (ຕົວຊີ້ໄປຫາຂໍ້ຄວາມທີ່ເພີ່ມແມ່ນຖືກກໍານົດໄວ້ໃນຂໍ້ຄວາມທໍາອິດ) ແລະ ຂໍ້ຄວາມປ່ຽນເປັນ tuple.

ການເພີ່ມຊິ້ນສ່ວນຂອງຂໍ້ມູນໃສ່ tuple:

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

ຟັງຊັນເອີ້ນ appendb() ໃນ loop.

ສົມທົບສອງ tuple ເຂົ້າໄປໃນຫນຶ່ງ:

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

ຂໍ້​ຄວາມ ໃໝ່ ຈະ​ຕິດ​ກັບ mp.

ສ້າງສຳເນົາຂອງຂໍ້ຄວາມດຽວ:

mblk_t *copyb(const mblk_t *mp);

ສໍາ​ເລັດ​ການ​ສໍາ​ເນົາ​ຂອງ tuple ກັບ​ຕັນ​ຂໍ້​ມູນ​ທັງ​ຫມົດ​:

mblk_t *copymsg(const mblk_t *mp);

ອົງປະກອບຂອງ tuple ຖືກຄັດລອກໂດຍຟັງຊັນ copyb().

ສ້າງສໍາເນົາງ່າຍຂອງຂໍ້ຄວາມ mblk_t. ໃນກໍລະນີນີ້, ບລັອກຂໍ້ມູນບໍ່ໄດ້ຖືກຄັດລອກ, ແຕ່ຕົວຊີ້ອ້າງອີງຂອງມັນເພີ່ມຂຶ້ນ db_ref:

mblk_t *dupb(mblk_t *mp);

ການເຮັດສໍາເນົາທີ່ມີນ້ໍາຫນັກເບົາຂອງ tuple. ບລັອກຂໍ້ມູນບໍ່ໄດ້ຖືກຄັດລອກ, ພຽງແຕ່ຕົວນັບອ້າງອີງຂອງພວກເຂົາຖືກເພີ່ມຂຶ້ນ db_ref:

mblk_t *dupmsg(mblk_t* m);

ການຕິດຂໍ້ຄວາມທັງຫມົດຂອງ tuple ເຂົ້າໄປໃນຂໍ້ຄວາມດຽວ:

void msgpullup(mblk_t *mp,size_t len);

ຖ້າການໂຕ້ຖຽງ len ແມ່ນ -1, ຫຼັງຈາກນັ້ນ, ຂະຫນາດຂອງ buffer ທີ່ຖືກຈັດສັນແມ່ນຖືກກໍານົດໂດຍອັດຕະໂນມັດ.

ການລຶບຂໍ້ຄວາມ, tuple:

void freemsg(mblk_t *mp);

ຈຳນວນອ້າງອີງຂອງບລັອກຂໍ້ມູນແມ່ນຫຼຸດລົງເທື່ອລະອັນ. ຖ້າມັນຮອດສູນ, ບລັອກຂໍ້ມູນກໍ່ຈະຖືກລຶບຖິ້ມ.

ການຄິດໄລ່ຈໍານວນຂໍ້ມູນທັງຫມົດໃນຂໍ້ຄວາມຫຼື tuple.

size_t msgdsize(const mblk_t *mp);

ດຶງຂໍ້ຄວາມຈາກຫາງຂອງຄິວ:

mblk_t *ms_queue_peek_last (q);

ການຄັດລອກເນື້ອໃນຂອງຊ່ອງຂໍ້ມູນທີ່ສະຫງວນໄວ້ຂອງຂໍ້ຄວາມຫນຶ່ງເຂົ້າໄປໃນຂໍ້ຄວາມອື່ນ (ໃນຄວາມເປັນຈິງ, ຊ່ອງຂໍ້ມູນເຫຼົ່ານີ້ມີທຸງທີ່ຖືກນໍາໃຊ້ໂດຍ media streamer):

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

ຄິວ ຄິວ_ທ

ແຖວຂໍ້ຄວາມໃນຕົວຖ່າຍທອດສື່ແມ່ນຖືກປະຕິບັດເປັນລາຍການເຊື່ອມຕໍ່ສອງເທົ່າວົງວຽນ. ແຕ່ລະອົງປະກອບລາຍຊື່ປະກອບດ້ວຍຕົວຊີ້ໄປຫາບລັອກຂໍ້ມູນທີ່ມີຕົວຢ່າງສັນຍານ. ມັນ turns ໃຫ້ເຫັນວ່າພຽງແຕ່ຊີ້ໃຫ້ເຫັນເຖິງ block ຂໍ້ມູນຍ້າຍໃນ turns, ໃນຂະນະທີ່ຂໍ້ມູນຕົວມັນເອງຍັງ motionless. ເຫຼົ່ານັ້ນ. ພຽງແຕ່ການເຊື່ອມຕໍ່ກັບພວກມັນຖືກຍ້າຍ.
ໂຄງສ້າງອະທິບາຍແຖວ ຄິວ_ທ, ສະ​ແດງ​ໃຫ້​ເຫັນ​ຂ້າງ​ລຸ່ມ​ນີ້​:

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

ໂຄງສ້າງປະກອບດ້ວຍພາກສະຫນາມ - ຕົວຊີ້ _q_ຢຸດ ພິມ *mblk_t, ມັນຊີ້ໄປຫາອົງປະກອບທໍາອິດ (ຂໍ້ຄວາມ) ໃນແຖວ. ພາກສະຫນາມທີສອງຂອງໂຄງສ້າງແມ່ນ counter ຂອງຂໍ້ຄວາມໃນແຖວ.
ຮູບຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນແຖວຊື່ q1 ທີ່ມີ 4 ຂໍ້ຄວາມ m1, m2, m3, m4.

ຮູບຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນແຖວຊື່ q1 ທີ່ມີ 4 ຂໍ້ຄວາມ m1,m2,m3,m4. ຂໍ້ຄວາມ m2 ແມ່ນຫົວຂອງ tuple ທີ່ມີສອງຂໍ້ຄວາມເພີ່ມເຕີມ m2_1 ແລະ m2_2.

ຟັງຊັນສໍາລັບການເຮັດວຽກກັບແຖວ queue_t

ການເລີ່ມຕົ້ນແຖວ:

void qinit(queue_t *q);

ພາກສະຫນາມ _q_ຢຸດ (ຕໍ່​ໄປ​ນີ້​ພວກ​ເຮົາ​ຈະ​ເອີ້ນ​ມັນ​ວ່າ "stopper​"​) ແມ່ນ​ເລີ່ມ​ຕົ້ນ​ໂດຍ​ການ​ທໍາ​ງານ​ mblk_init(), ອົງປະກອບກ່ອນຫນ້າຂອງມັນແລະຕົວຊີ້ອົງປະກອບຕໍ່ໄປແມ່ນຖືກປັບໃຫ້ຊີ້ໄປຫາຕົວມັນເອງ. ຕົວນັບອົງປະກອບແຖວຖືກຣີເຊັດເປັນສູນ.

ເພີ່ມອົງປະກອບໃຫມ່ (ຂໍ້ຄວາມ):

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

ອົງປະກອບໃຫມ່ m ໄດ້ຖືກເພີ່ມໃສ່ໃນຕອນທ້າຍຂອງບັນຊີລາຍຊື່, ຕົວຊີ້ອົງປະກອບໄດ້ຖືກປັບເພື່ອໃຫ້ stopper ກາຍເປັນອົງປະກອບຕໍ່ໄປສໍາລັບມັນ, ແລະມັນຈະກາຍເປັນອົງປະກອບທີ່ຜ່ານມາສໍາລັບ stopper. ຕົວນັບອົງປະກອບແຖວແມ່ນເພີ່ມຂຶ້ນ.

ດຶງຂໍ້ມູນອົງປະກອບຈາກຄິວ:

mblk_t * getq(queue_t *q); 

ຂໍ້ຄວາມທີ່ມາຫຼັງຈາກ stopper ໄດ້ຖືກດຶງມາ, ແລະຕົວນັບອົງປະກອບແມ່ນ decremented. ຖ້າບໍ່ມີອົງປະກອບໃນແຖວຍົກເວັ້ນ stopper, ຫຼັງຈາກນັ້ນ 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);

ການໂຕ້ຖຽງ ວິທີການ ບໍ່​ໄດ້​ນໍາ​ໃຊ້. ຕົວນັບອົງປະກອບແຖວຖືກຕັ້ງເປັນສູນ.

Macro ສໍາລັບການອ່ານຕົວຊີ້ໄປຫາອົງປະກອບສຸດທ້າຍຂອງແຖວ:

mblk_t * qlast(queue_t *q);

ເມື່ອເຮັດວຽກກັບຄິວຂໍ້ຄວາມ, ຈົ່ງຮູ້ວ່າເມື່ອທ່ານໂທຫາ ms_queue_put(q, m) ດ້ວຍຕົວຊີ້ null ໄປຫາຂໍ້ຄວາມ, ຟັງຊັນ loops. ໂຄງ​ການ​ຂອງ​ທ່ານ​ຈະ freeze​. ປະຕິບັດຕົວຄ້າຍຄືກັນ ms_queue_next(q, m).

ເຊື່ອມຕໍ່ຕົວກອງ

ແຖວທີ່ອະທິບາຍໄວ້ຂ້າງເທິງແມ່ນໃຊ້ເພື່ອສົ່ງຂໍ້ຄວາມຈາກຕົວກອງໜຶ່ງໄປຫາອີກຕົວກອງໜຶ່ງ ຫຼືຈາກໜຶ່ງໄປຫາຫຼາຍຕົວກອງ. ການກັ່ນຕອງແລະການເຊື່ອມຕໍ່ຂອງເຂົາເຈົ້າປະກອບເປັນເສັ້ນສະແດງການຊີ້ນໍາ. ການປ້ອນຂໍ້ມູນຫຼືຜົນຜະລິດຂອງການກັ່ນຕອງຈະຖືກເອີ້ນວ່າ "pin". ເພື່ອອະທິບາຍລໍາດັບທີ່ຕົວກອງເຊື່ອມຕໍ່ກັນ, ຜູ້ສື່ໂຄສະນາໃຊ້ແນວຄວາມຄິດຂອງ "ຈຸດສັນຍານ". ຈຸດສັນຍານແມ່ນໂຄງສ້າງ _MSCPPoint, ເຊິ່ງປະກອບດ້ວຍຕົວຊີ້ໄປຫາຕົວກອງແລະຈໍານວນຂອງຫນຶ່ງຂອງ pins ຂອງມັນ; ຕາມນັ້ນ, ມັນອະທິບາຍການເຊື່ອມຕໍ່ຂອງຫນຶ່ງໃນ inputs ຫຼື outputs ຂອງການກັ່ນຕອງ.

ຈຸດສັນຍານຂອງກາຟປະມວນຜົນຂໍ້ມູນ

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

pins ການກັ່ນຕອງແມ່ນຕົວເລກເລີ່ມຕົ້ນຈາກສູນ.

ການເຊື່ອມຕໍ່ຂອງສອງ pins ໂດຍແຖວຂໍ້ຄວາມແມ່ນອະທິບາຍໂດຍໂຄງສ້າງ _MSQueue, ເຊິ່ງປະກອບດ້ວຍແຖວຂໍ້ຄວາມແລະຕົວຊີ້ໄປຫາສອງຈຸດສັນຍານທີ່ມັນເຊື່ອມຕໍ່:

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

ພວກເຮົາຈະເອີ້ນໂຄງສ້າງນີ້ວ່າການເຊື່ອມຕໍ່ສັນຍານ. ແຕ່ລະຕົວກອງສື່ streamer ມີຕາຕະລາງຂອງການເຊື່ອມຕໍ່ຂາເຂົ້າແລະຕາຕະລາງຂອງການເຊື່ອມຕໍ່ຜົນຜະລິດ (MSQueue). ຂະ​ຫນາດ​ຂອງ​ຕາ​ຕະ​ລາງ​ໄດ້​ຖືກ​ກໍາ​ນົດ​ໃນ​ເວ​ລາ​ທີ່​ການ​ສ້າງ​ຕົວ​ກັ່ນ​ຕອງ​; ພວກ​ເຮົາ​ໄດ້​ເຮັດ​ການ​ນີ້​ແລ້ວ​ໂດຍ​ການ​ນໍາ​ໃຊ້​ຕົວ​ແປ​ທີ່​ສົ່ງ​ອອກ​ຂອງ​ປະ​ເພດ​ MSFilterDesc, ເມື່ອພວກເຮົາພັດທະນາຕົວກອງຂອງພວກເຮົາເອງ. ຂ້າງລຸ່ມນີ້ແມ່ນໂຄງສ້າງທີ່ອະທິບາຍການກັ່ນຕອງໃດໆໃນສື່ 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;

ຫຼັງຈາກທີ່ພວກເຮົາເຊື່ອມຕໍ່ຕົວກອງໃນໂຄງການ C ຕາມແຜນການຂອງພວກເຮົາ (ແຕ່ບໍ່ໄດ້ເຊື່ອມຕໍ່ ticker), ດັ່ງນັ້ນພວກເຮົາຈຶ່ງສ້າງເສັ້ນສະແດງການຊີ້ນໍາ, ເສັ້ນທີ່ເປັນຕົວຢ່າງຂອງໂຄງສ້າງ. MSFilter, ແລະຂອບແມ່ນຕົວຢ່າງຂອງການເຊື່ອມຕໍ່ MSQueue.

ກິດຈະກໍາທາງຫລັງຂອງ ticker ໄດ້

ເມື່ອຂ້ອຍບອກເຈົ້າວ່າ ticker ແມ່ນຕົວກອງສໍາລັບແຫຼ່ງຂອງຫມາຍຕິກ, ມັນບໍ່ແມ່ນຄວາມຈິງທັງຫມົດກ່ຽວກັບມັນ. ເຄື່ອງໝາຍຕິກແມ່ນວັດຖຸທີ່ເຮັດວຽກຢູ່ໃນໂມງ ຂະບວນການ() ການກັ່ນຕອງທັງຫມົດຂອງວົງຈອນ (ກາຟ) ທີ່ມັນເຊື່ອມຕໍ່. ເມື່ອພວກເຮົາເຊື່ອມຕໍ່ ticker ກັບຕົວກອງກາຟໃນໂຄງການ C, ພວກເຮົາສະແດງ ticker ເສັ້ນສະແດງທີ່ມັນຈະຄວບຄຸມຈາກນີ້ຈົນກ່ວາພວກເຮົາປິດມັນ. ຫຼັງຈາກການເຊື່ອມຕໍ່, ticker ເລີ່ມຕົ້ນກວດເບິ່ງກາຟທີ່ມອບໃຫ້ການດູແລຂອງມັນ, ລວບລວມບັນຊີລາຍຊື່ຂອງການກັ່ນຕອງທີ່ປະກອບມີມັນ. ເພື່ອບໍ່ໃຫ້ "ນັບ" ຕົວກອງດຽວກັນສອງຄັ້ງ, ມັນຫມາຍການກັ່ນຕອງທີ່ກວດພົບໂດຍການວາງກ່ອງກາເຄື່ອງຫມາຍໃສ່ພວກມັນ. ເຫັນ. ການຄົ້ນຫາແມ່ນດໍາເນີນການໂດຍໃຊ້ຕາຕະລາງເຊື່ອມຕໍ່ທີ່ແຕ່ລະຕົວກອງມີ.

ໃນລະຫວ່າງການນໍາທ່ຽວຂອງກາຟຂອງມັນ, ticker ກວດເບິ່ງວ່າໃນບັນດາຕົວກອງມີຢ່າງຫນ້ອຍຫນຶ່ງທີ່ເຮັດຫນ້າທີ່ເປັນແຫຼ່ງຂອງບລັອກຂໍ້ມູນ. ຖ້າບໍ່ມີ, ຫຼັງຈາກນັ້ນ, ເສັ້ນສະແດງແມ່ນຖືວ່າບໍ່ຖືກຕ້ອງແລະ ticker crashes.

ຖ້າເສັ້ນສະແດງກາຍເປັນ "ຖືກຕ້ອງ", ສໍາລັບແຕ່ລະຕົວກອງທີ່ພົບເຫັນ, ຫນ້າທີ່ຖືກເອີ້ນວ່າສໍາລັບການເລີ່ມຕົ້ນ ຂະບວນການກ່ອນ (). ທັນທີທີ່ມາຮອດປັດຈຸບັນສໍາລັບຮອບປະມວນຜົນຕໍ່ໄປ (ທຸກໆ 10 milliseconds ຕາມຄ່າເລີ່ມຕົ້ນ), ticker ໂທຫາຟັງຊັນ. ຂະບວນການ() ສໍາລັບການກັ່ນຕອງແຫຼ່ງທັງຫມົດທີ່ພົບໃນເມື່ອກ່ອນ, ແລະຫຼັງຈາກນັ້ນສໍາລັບການກັ່ນຕອງທີ່ຍັງເຫຼືອຢູ່ໃນບັນຊີລາຍຊື່. ຖ້າຕົວກອງມີການເຊື່ອມຕໍ່ຂາເຂົ້າ, ຫຼັງຈາກນັ້ນດໍາເນີນການຟັງຊັນ ຂະບວນການ() ເຮັດເລື້ມຄືນຈົນກ່ວາຄິວການເຊື່ອມຕໍ່ຂາເຂົ້າຫວ່າງເປົ່າ. ຫຼັງຈາກນີ້, ມັນຍ້າຍໄປຕົວກອງຕໍ່ໄປໃນບັນຊີລາຍຊື່ແລະ "ເລື່ອນ" ມັນຈົນກ່ວາການເຊື່ອມຕໍ່ຂາເຂົ້າບໍ່ມີຂໍ້ຄວາມ. ticker ຍ້າຍຈາກການກັ່ນຕອງໄປຫາການກັ່ນຕອງຈົນກ່ວາບັນຊີລາຍຊື່ສິ້ນສຸດລົງ. ນີ້ສໍາເລັດການປຸງແຕ່ງຂອງວົງຈອນ.

ຕອນນີ້ພວກເຮົາຈະກັບຄືນສູ່ tuples ແລະສົນທະນາກ່ຽວກັບວ່າເປັນຫຍັງຫນ່ວຍງານດັ່ງກ່າວຖືກເພີ່ມເຂົ້າໃນ media streamer. ໂດຍທົ່ວໄປແລ້ວ, ຈໍານວນຂໍ້ມູນທີ່ຕ້ອງການໂດຍ algorithm ທີ່ດໍາເນີນການພາຍໃນຕົວກອງບໍ່ກົງກັນແລະບໍ່ແມ່ນຄວາມຫຼາກຫຼາຍຂອງຂະຫນາດຂອງ buffers ຂໍ້ມູນທີ່ໄດ້ຮັບຢູ່ໃນວັດສະດຸປ້ອນ. ຕົວຢ່າງ, ພວກເຮົາກໍາລັງຂຽນຕົວກອງທີ່ປະຕິບັດການຫັນປ່ຽນ Fourier ໄວ, ເຊິ່ງຕາມຄໍານິຍາມພຽງແຕ່ສາມາດປຸງແຕ່ງຂໍ້ມູນທີ່ມີຂະຫນາດຂອງສອງ. ໃຫ້ມັນເປັນ 512 ນັບ. ຖ້າຂໍ້ມູນຖືກສ້າງຂື້ນໂດຍຊ່ອງທາງໂທລະສັບ, ຂໍ້ມູນ buffer ຂອງແຕ່ລະຂໍ້ຄວາມຢູ່ທີ່ວັດສະດຸປ້ອນຈະນໍາພວກເຮົາ 160 ຕົວຢ່າງສັນຍານ. ມັນເປັນການລໍ້ລວງທີ່ຈະບໍ່ເກັບກໍາຂໍ້ມູນຈາກການປ້ອນຂໍ້ມູນຈົນກ່ວາຈໍານວນຂໍ້ມູນທີ່ຈໍາເປັນຢູ່ທີ່ນັ້ນ. ແຕ່ໃນກໍລະນີນີ້, ການຂັດກັນຈະເກີດຂື້ນກັບ ticker, ເຊິ່ງບໍ່ສໍາເລັດຈະພະຍາຍາມເລື່ອນຕົວກອງຈົນກ່ວາການເຊື່ອມຕໍ່ຂາເຂົ້າຈະຫວ່າງເປົ່າ. ກ່ອນຫນ້ານີ້, ພວກເຮົາໄດ້ກໍານົດກົດລະບຽບນີ້ເປັນຫຼັກການທີສາມຂອງການກັ່ນຕອງ. ອີງຕາມຫຼັກການນີ້, ຂະບວນການຂອງຕົວກອງຕ້ອງເອົາຂໍ້ມູນທັງຫມົດຈາກແຖວປ້ອນຂໍ້ມູນ.

ນອກຈາກນັ້ນ, ມັນຈະບໍ່ສາມາດເອົາພຽງແຕ່ 512 ຕົວຢ່າງຈາກການປ້ອນຂໍ້ມູນ, ເພາະວ່າທ່ານພຽງແຕ່ສາມາດເອົາທ່ອນໄມ້ທັງຫມົດ, i.e. ການກັ່ນຕອງຈະຕ້ອງເອົາ 640 ຕົວຢ່າງແລະນໍາໃຊ້ 512 ຂອງພວກເຂົາ, ສ່ວນທີ່ເຫຼືອກ່ອນທີ່ຈະສະສົມຂໍ້ມູນໃຫມ່. ດັ່ງນັ້ນ, ການກັ່ນຕອງຂອງພວກເຮົາ, ນອກເຫນືອຈາກການເຮັດວຽກຕົ້ນຕໍຂອງມັນ, ຕ້ອງສະຫນອງການປະຕິບັດການຊ່ວຍເຫຼືອສໍາລັບການເກັບຮັກສາຂໍ້ມູນການປ້ອນຂໍ້ມູນລະດັບປານກາງ. ນັກພັດທະນາຂອງ media streamer ແລະການແກ້ໄຂບັນຫາທົ່ວໄປນີ້ໄດ້ພັດທະນາວັດຖຸພິເສດ - MSBufferizer (buffer), ເຊິ່ງແກ້ໄຂບັນຫານີ້ໂດຍໃຊ້ tuples.

Bufferizer (MSBufferizer)

ນີ້ແມ່ນວັດຖຸທີ່ຈະສະສົມຂໍ້ມູນປ້ອນເຂົ້າພາຍໃນການກັ່ນຕອງແລະເລີ່ມຕົ້ນສົ່ງມັນສໍາລັບການປະມວນຜົນທັນທີທີ່ຈໍານວນຂໍ້ມູນພຽງພໍເພື່ອດໍາເນີນການ algorithm ການກັ່ນຕອງ. ໃນຂະນະທີ່ buffer ກຳ ລັງສະສົມຂໍ້ມູນ, ຕົວກອງຈະເຮັດວຽກຢູ່ໃນໂໝດບໍ່ເຮັດວຽກ, ໂດຍບໍ່ຕ້ອງໃຊ້ພະລັງງານປະມວນຜົນຂອງໂປເຊດເຊີ. ແຕ່ທັນທີທີ່ຟັງຊັນການອ່ານຈາກ bufferer ສົ່ງຄືນຄ່າອື່ນທີ່ບໍ່ແມ່ນສູນ, ຟັງຊັນ process() ຂອງຕົວກອງຈະເລີ່ມເອົາແລະປະມວນຜົນຂໍ້ມູນຈາກ bufferer ໃນສ່ວນຂອງຂະຫນາດທີ່ຕ້ອງການ, ຈົນກ່ວາມັນຫມົດໄປ.
ຂໍ້ມູນທີ່ຍັງບໍ່ທັນໄດ້ຕ້ອງການຍັງຄົງຢູ່ໃນ buffer ເປັນອົງປະກອບທໍາອິດຂອງ tuple, ເຊິ່ງ blocks ຕໍ່ໄປຂອງຂໍ້ມູນປ້ອນເຂົ້າ.

ໂຄງສ້າງທີ່ອະທິບາຍເຖິງ buffer:

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

ຫນ້າທີ່ເຮັດວຽກກັບ MSBufferizer

ການສ້າງຕົວຢ່າງ buffer ໃໝ່:

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 ຖືກເພີ່ມໃສ່ຄິວ. ຂະ​ຫນາດ​ຂອງ​ການ​ຄິດ​ໄລ່​ຂອງ​ຂໍ້​ມູນ​ໄດ້​ຖືກ​ເພີ່ມ​ເຂົ້າ​ໄປ​ໃນ​ ຂະຫນາດ.

ການໂອນຂໍ້ຄວາມທັງໝົດຈາກແຖວຂໍ້ມູນເຊື່ອມຕໍ່ໄປຫາ buffer q:

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

ການໂອນຂໍ້ຄວາມຈາກການເຊື່ອມຕໍ່ q ໃນ buffer ແມ່ນດໍາເນີນການໂດຍໃຊ້ຟັງຊັນ ms_bufferizer_put().

ອ່ານຈາກ buffer:

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

ຖ້າຂະຫນາດຂອງຂໍ້ມູນທີ່ສະສົມຢູ່ໃນ buffer ຫນ້ອຍກວ່າທີ່ຮ້ອງຂໍ (ຂໍ້ມູນເລນ), ຫຼັງຈາກນັ້ນ, ຟັງຊັນກັບຄືນສູນ, ຂໍ້ມູນບໍ່ໄດ້ຖືກຄັດລອກໄປຫາຂໍ້ມູນ. ຖ້າບໍ່ດັ່ງນັ້ນ, ການຄັດລອກຂໍ້ມູນຕາມລໍາດັບຈາກ tuples ທີ່ຕັ້ງຢູ່ໃນ buffer ແມ່ນປະຕິບັດ. ຫຼັງ​ຈາກ​ການ​ສໍາ​ເນົາ​, tuple ຈະ​ຖືກ​ລົບ​ແລະ​ຄວາມ​ຊົງ​ຈໍາ​ແມ່ນ​ໄດ້​ປ່ອຍ​ອອກ​ມາ​. ການຄັດລອກຈະສິ້ນສຸດໃນຂະນະນີ້ເມື່ອ datalen bytes ຖືກສຳເນົາ. ຖ້າພື້ນທີ່ຫວ່າງຢູ່ໃນກາງຂອງບລັອກຂໍ້ມູນ, ຫຼັງຈາກນັ້ນໃນຂໍ້ຄວາມນີ້, ບລັອກຂໍ້ມູນຈະຖືກຫຼຸດລົງເປັນສ່ວນທີ່ຍັງບໍ່ໄດ້ຄັດລອກ. ໃນຄັ້ງຕໍ່ໄປທີ່ທ່ານໂທຫາ, ການຄັດລອກຈະສືບຕໍ່ຈາກຈຸດນີ້.

ການອ່ານຈໍານວນຂໍ້ມູນທີ່ມີຢູ່ໃນ buffer:

int ms_bufferizer_get_avail(MSBufferizer *obj); 

ສົ່ງຄືນພາກສະຫນາມ ຂະຫນາດ buffer.

ການຍົກເລີກບາງສ່ວນຂອງຂໍ້ມູນໃນ buffer:

void ms_bufferizer_skip_bytes(MSBufferizer *obj, int bytes);

ຈໍານວນໄບຕ໌ທີ່ລະບຸໄວ້ຈະຖືກດຶງ ແລະຍົກເລີກ. ຂໍ້ມູນເກົ່າແກ່ທີ່ສຸດຖືກຍົກເລີກ.

ການລຶບຂໍ້ຄວາມທັງໝົດໃນ buffer:

void ms_bufferizer_flush(MSBufferizer *obj); 

ຕົວນັບຂໍ້ມູນຖືກຣີເຊັດເປັນສູນ.

ການລຶບຂໍ້ຄວາມທັງໝົດໃນ buffer:

void ms_bufferizer_uninit(MSBufferizer *obj); 

ໂຕນັບບໍ່ໄດ້ຖືກຕັ້ງຄືນໃໝ່.

ການຖອດບັຟເຟີແລະປ່ອຍຄວາມຊົງຈໍາ:

void ms_bufferizer_destroy(MSBufferizer *obj);  

ຕົວຢ່າງຂອງການໃຊ້ buffer ສາມາດພົບໄດ້ໃນລະຫັດແຫຼ່ງຂອງຕົວກອງກະແສສື່ຫຼາຍອັນ. ຕົວຢ່າງ, ໃນຕົວກອງ MS_L16_ENC, ເຊິ່ງຈັດລຽງໄບຕ໌ຄືນໃຫມ່ໃນຕົວຢ່າງຈາກລໍາດັບເຄືອຂ່າຍໄປຫາຄໍາສັ່ງໂຮດ: l16.c

ໃນບົດຄວາມຕໍ່ໄປ, ພວກເຮົາຈະເບິ່ງບັນຫາຂອງການຄາດຄະເນການໂຫຼດໃນ ticker ແລະວິທີການທີ່ຈະຕໍ່ສູ້ກັບການໂຫຼດຄອມພິວເຕີ້ຫຼາຍເກີນໄປໃນ media streamer.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com