Mediastreamer2 VoIP ਇੰਜਣ ਦੀ ਪੜਚੋਲ ਕਰ ਰਿਹਾ ਹੈ। ਭਾਗ 11

ਲੇਖ ਸਮੱਗਰੀ ਮੇਰੇ ਤੋਂ ਲਈ ਗਈ ਹੈ ਜ਼ੈਨ ਚੈਨਲ.

ਡਾਟਾ ਅੰਦੋਲਨ ਵਿਧੀ

• ਡਾਟਾ ਬਲਾਕ dblk_t
• ਸੁਨੇਹਾ mblk_t
• mblk_t ਸੁਨੇਹਿਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ
• ਕਤਾਰ ਕਤਾਰ_t
• queues queue_t ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ
• ਕਨੈਕਟ ਕਰਨ ਵਾਲੇ ਫਿਲਟਰ
• ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਗ੍ਰਾਫ ਦਾ ਸਿਗਨਲ ਪੁਆਇੰਟ
• ਪਰਦੇ ਪਿੱਛੇ ਟਿਕਰ ਦੀਆਂ ਗਤੀਵਿਧੀਆਂ
• ਬਫਰਾਈਜ਼ਰ (MSBufferizer)
• MSBufferizer ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ

ਪਿਛਲੇ ਵਿੱਚ ਲੇਖ ਅਸੀਂ ਆਪਣਾ ਫਿਲਟਰ ਤਿਆਰ ਕੀਤਾ ਹੈ। ਇਹ ਲੇਖ ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਫਿਲਟਰਾਂ ਵਿਚਕਾਰ ਡੇਟਾ ਨੂੰ ਮੂਵ ਕਰਨ ਲਈ ਅੰਦਰੂਨੀ ਵਿਧੀ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰੇਗਾ। ਇਹ ਤੁਹਾਨੂੰ ਭਵਿੱਖ ਵਿੱਚ ਘੱਟ ਮਿਹਨਤ ਨਾਲ ਵਧੀਆ ਫਿਲਟਰ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।

ਡਾਟਾ ਅੰਦੋਲਨ ਵਿਧੀ

ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਵਿੱਚ ਡੇਟਾ ਮੂਵਮੈਂਟ ਨੂੰ ਢਾਂਚੇ ਦੁਆਰਾ ਵਰਣਿਤ ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਤਾਰ_ਟੀ. ਵਰਗੇ ਸੁਨੇਹਿਆਂ ਦੀਆਂ ਸਤਰਾਂ mblk_t, ਜਿਸ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਸਿਗਨਲ ਡੇਟਾ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਪਰ ਸਿਰਫ ਪਿਛਲੇ, ਅਗਲੇ ਸੰਦੇਸ਼ ਅਤੇ ਡੇਟਾ ਬਲਾਕ ਨਾਲ ਲਿੰਕ ਹੁੰਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਖਾਸ ਤੌਰ 'ਤੇ ਇਸ ਗੱਲ 'ਤੇ ਜ਼ੋਰ ਦੇਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਉਸੇ ਕਿਸਮ ਦੇ ਸੰਦੇਸ਼ ਦੇ ਲਿੰਕ ਲਈ ਇੱਕ ਖੇਤਰ ਵੀ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਸੁਨੇਹਿਆਂ ਦੀ ਇੱਕ ਸਿੰਗਲ ਲਿੰਕਡ ਸੂਚੀ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਅਸੀਂ ਅਜਿਹੀ ਸੂਚੀ ਦੁਆਰਾ ਸੰਯੁਕਤ ਸੰਦੇਸ਼ਾਂ ਦੇ ਸਮੂਹ ਨੂੰ ਇੱਕ ਟੂਪਲ ਕਹਾਂਗੇ। ਇਸ ਤਰ੍ਹਾਂ, ਕਤਾਰ ਦਾ ਕੋਈ ਵੀ ਤੱਤ ਇੱਕ ਸਿੰਗਲ ਸੁਨੇਹਾ ਹੋ ਸਕਦਾ ਹੈ mblk_t, ਅਤੇ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕ ਸੁਨੇਹਾ tuple ਦਾ ਸਿਰ mblk_t. ਹਰੇਕ ਟੂਪਲ ਸੰਦੇਸ਼ ਦਾ ਆਪਣਾ ਵਾਰਡ ਡਾਟਾ ਬਲਾਕ ਹੋ ਸਕਦਾ ਹੈ। ਅਸੀਂ ਥੋੜੀ ਦੇਰ ਬਾਅਦ ਚਰਚਾ ਕਰਾਂਗੇ ਕਿ ਟੂਪਲਾਂ ਦੀ ਕਿਉਂ ਲੋੜ ਹੈ।

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਸੁਨੇਹੇ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਡੇਟਾ ਦਾ ਇੱਕ ਬਲਾਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ; ਇਸ ਦੀ ਬਜਾਏ, ਇਸ ਵਿੱਚ ਸਿਰਫ ਮੈਮੋਰੀ ਖੇਤਰ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਬਲਾਕ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਹਿੱਸੇ ਵਿੱਚ, ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਦੇ ਕੰਮ ਦੀ ਸਮੁੱਚੀ ਤਸਵੀਰ ਕਾਰਟੂਨ "ਮੌਨਸਟਰਜ਼, ਇੰਕ." ਵਿੱਚ ਦਰਵਾਜ਼ੇ ਦੇ ਗੋਦਾਮ ਦੀ ਯਾਦ ਦਿਵਾਉਂਦੀ ਹੈ, ਜਿੱਥੇ ਦਰਵਾਜ਼ੇ (ਡੇਟਾ - ਕਮਰਿਆਂ ਦੇ ਲਿੰਕ) ਓਵਰਹੈੱਡ ਕਨਵੇਅਰਾਂ ਦੇ ਨਾਲ ਇੱਕ ਪਾਗਲ ਗਤੀ ਨਾਲ ਅੱਗੇ ਵਧਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਕਮਰੇ ਖੁਦ ਗਤੀਹੀਣ ਰਹਿਣਾ।

ਹੁਣ, ਹੇਠਾਂ ਤੋਂ ਸਿਖਰ ਤੱਕ ਲੜੀ ਦੇ ਨਾਲ ਅੱਗੇ ਵਧਦੇ ਹੋਏ, ਆਓ ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਵਿਧੀ ਦੀਆਂ ਸੂਚੀਬੱਧ ਇਕਾਈਆਂ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਵਿਚਾਰ ਕਰੀਏ।

ਡਾਟਾ ਬਲਾਕ 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_ਅਗਲਾ, ਜੋ ਕਿ ਇੱਕ ਦੁੱਗਣੀ ਲਿੰਕਡ ਸੂਚੀ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹਨ (ਜੋ ਕਿ ਇੱਕ ਕਤਾਰ ਹੈ ਕਤਾਰ_ਟੀ).

ਫਿਰ ਪੁਆਇੰਟਰ ਆਉਂਦਾ ਹੈ b_cont, ਜੋ ਸਿਰਫ ਉਦੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਸੁਨੇਹਾ ਇੱਕ ਟੂਪਲ ਦਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ। ਟੂਪਲ ਵਿੱਚ ਆਖਰੀ ਸੰਦੇਸ਼ ਲਈ, ਇਹ ਪੁਆਇੰਟਰ ਖਾਲੀ ਰਹਿੰਦਾ ਹੈ।

ਅੱਗੇ ਅਸੀਂ ਡੇਟਾ ਬਲਾਕ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਦੇਖਦੇ ਹਾਂ 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*)); 

ਫੰਕਸ਼ਨ, ਸੁਨੇਹਾ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ ਅਤੇ ਡੇਟਾ ਬਲਾਕ ਦੀ ਬਣਤਰ, ਪਤੇ 'ਤੇ ਡੇਟਾ ਲਈ ਇਸਦੇ ਪੁਆਇੰਟਰ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੇਗਾ ਬੂਫ. ਉਹ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਡੇਟਾ ਬਫਰ ਡੇਟਾ ਬਲਾਕ ਦੇ ਸਿਰਲੇਖ ਖੇਤਰਾਂ ਤੋਂ ਬਾਅਦ ਸਥਿਤ ਨਹੀਂ ਹੁੰਦਾ, ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਨਾਲ ਡੇਟਾ ਬਲਾਕ ਬਣਾਉਣ ਵੇਲੇ ਹੁੰਦਾ ਸੀ। datab_alloc(). ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ ਡੇਟਾ ਵਾਲਾ ਬਫਰ ਉੱਥੇ ਹੀ ਰਹੇਗਾ, ਪਰ ਪੁਆਇੰਟਰਾਂ ਦੀ ਮਦਦ ਨਾਲ ਇਹ ਡੇਟਾ ਬਲਾਕ ਦੇ ਨਵੇਂ ਸਿਰਲੇਖ ਨਾਲ ਜੁੜ ਜਾਵੇਗਾ, ਅਤੇ ਉਸ ਅਨੁਸਾਰ, ਸੰਦੇਸ਼ ਨਾਲ.

ਇੱਕ ਸੰਦੇਸ਼ ਨੂੰ mblk_t ਕਈ ਡਾਟਾ ਬਲਾਕਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

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

mp - ਇੱਕ ਸੁਨੇਹਾ ਜਿਸ ਵਿੱਚ ਇੱਕ ਹੋਰ ਡਾਟਾ ਬਲਾਕ ਜੋੜਿਆ ਜਾਵੇਗਾ;
ਡਾਟਾ - ਬਲਾਕ ਵੱਲ ਪੁਆਇੰਟਰ, ਜਿਸ ਦੀ ਇੱਕ ਕਾਪੀ ਸੁਨੇਹੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਜਾਵੇਗੀ;
ਦਾ ਆਕਾਰ - ਡਾਟਾ ਆਕਾਰ;
ਪੈਡ - ਇੱਕ ਫਲੈਗ ਜੋ ਨਿਰਧਾਰਤ ਕੀਤੀ ਮੈਮੋਰੀ ਦਾ ਆਕਾਰ 4-ਬਾਈਟ ਸੀਮਾ ਦੇ ਨਾਲ ਇਕਸਾਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਪੈਡਿੰਗ ਜ਼ੀਰੋ ਨਾਲ ਕੀਤੀ ਜਾਵੇਗੀ)।

ਜੇਕਰ ਮੌਜੂਦਾ ਮੈਸੇਜ ਡੇਟਾ ਬਫਰ ਵਿੱਚ ਕਾਫ਼ੀ ਸਪੇਸ ਹੈ, ਤਾਂ ਨਵਾਂ ਡੇਟਾ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਡੇਟਾ ਦੇ ਪਿੱਛੇ ਪੇਸਟ ਕੀਤਾ ਜਾਵੇਗਾ। ਜੇਕਰ ਮੈਸੇਜ ਡਾਟਾ ਬਫਰ ਵਿੱਚ ਘੱਟ ਖਾਲੀ ਥਾਂ ਹੈ ਦਾ ਆਕਾਰ, ਫਿਰ ਇੱਕ ਕਾਫੀ ਬਫਰ ਆਕਾਰ ਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ ਸੁਨੇਹਾ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਡੇਟਾ ਨੂੰ ਇਸਦੇ ਬਫਰ ਵਿੱਚ ਕਾਪੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਨਵਾਂ ਸੁਨੇਹਾ ਹੈ, ਜੋ ਇੱਕ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੂਲ ਨਾਲ ਲਿੰਕ ਕੀਤਾ ਗਿਆ ਹੈ b_cont. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸੁਨੇਹਾ ਇੱਕ ਟੂਪਲ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ.

ਜੇ ਤੁਹਾਨੂੰ ਟੂਪਲ ਵਿੱਚ ਡੇਟਾ ਦਾ ਇੱਕ ਹੋਰ ਬਲਾਕ ਜੋੜਨਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ:

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

ਉਸਨੂੰ ਟੂਪਲ ਵਿੱਚ ਆਖਰੀ ਸੁਨੇਹਾ ਮਿਲੇਗਾ (ਉਸ ਕੋਲ ਹੈ b_cont null) ਹੋ ਜਾਵੇਗਾ ਅਤੇ ਇਸ ਸੁਨੇਹੇ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੇਗਾ addendb().

ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸੰਦੇਸ਼ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਡੇਟਾ ਦੇ ਆਕਾਰ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹੋ:

int msgdsize(const mblk_t *mp);

ਇਹ ਟੂਪਲ ਵਿੱਚ ਸਾਰੇ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਲੂਪ ਕਰੇਗਾ ਅਤੇ ਉਹਨਾਂ ਸੰਦੇਸ਼ਾਂ ਦੇ ਡੇਟਾ ਬਫਰਾਂ ਵਿੱਚ ਡੇਟਾ ਦੀ ਕੁੱਲ ਮਾਤਰਾ ਵਾਪਸ ਕਰੇਗਾ। ਹਰੇਕ ਸੁਨੇਹੇ ਲਈ, ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਦੀ ਗਣਨਾ ਇਸ ਤਰ੍ਹਾਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

 mp->b_wptr - mp->b_rptr

ਦੋ ਟੂਪਲਾਂ ਨੂੰ ਜੋੜਨ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ:

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

ਉਹ ਟੂਪਲ ਜੋੜਦੀ ਹੈ newm tuple ਦੀ ਪੂਛ ਨੂੰ mp ਅਤੇ ਨਤੀਜੇ ਵਾਲੇ ਟੂਪਲ ਦੇ ਆਖਰੀ ਸੰਦੇਸ਼ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਜੇ ਜਰੂਰੀ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਟੂਪਲ ਨੂੰ ਡੇਟਾ ਦੇ ਇੱਕ ਬਲਾਕ ਨਾਲ ਇੱਕ ਸੰਦੇਸ਼ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ; ਇਹ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

void msgpullup(mblk_t *mp,int len);

ਜੇਕਰ ਦਲੀਲ len -1 ਹੈ, ਫਿਰ ਨਿਰਧਾਰਤ ਬਫਰ ਦਾ ਆਕਾਰ ਆਪਣੇ ਆਪ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇ len ਇੱਕ ਸਕਾਰਾਤਮਕ ਸੰਖਿਆ ਹੈ, ਇਸ ਆਕਾਰ ਦਾ ਇੱਕ ਬਫਰ ਬਣਾਇਆ ਜਾਵੇਗਾ ਅਤੇ ਟੂਪਲ ਸੁਨੇਹਾ ਡੇਟਾ ਇਸ ਵਿੱਚ ਕਾਪੀ ਕੀਤਾ ਜਾਵੇਗਾ। ਜੇਕਰ ਬਫਰ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਨਕਲ ਕਰਨਾ ਉੱਥੇ ਹੀ ਬੰਦ ਹੋ ਜਾਵੇਗਾ। ਟੂਪਲ ਦਾ ਪਹਿਲਾ ਸੁਨੇਹਾ ਕਾਪੀ ਕੀਤੇ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਨਵੇਂ ਆਕਾਰ ਦਾ ਬਫਰ ਪ੍ਰਾਪਤ ਕਰੇਗਾ। ਬਾਕੀ ਬਚੇ ਸੁਨੇਹੇ ਮਿਟਾ ਦਿੱਤੇ ਜਾਣਗੇ ਅਤੇ ਮੈਮੋਰੀ ਹੀਪ ਵਿੱਚ ਵਾਪਸ ਆ ਜਾਵੇਗੀ।

ਇੱਕ ਬਣਤਰ ਨੂੰ ਮਿਟਾਉਣ ਵੇਲੇ 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);

ਜੇਕਰ ਨਵਾਂ ਡੇਟਾ ਮੈਸੇਜ ਡੇਟਾ ਬਫਰ ਦੀ ਖਾਲੀ ਥਾਂ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਲੋੜੀਂਦੇ ਆਕਾਰ ਦੇ ਇੱਕ ਬਫਰ ਦੇ ਨਾਲ ਇੱਕ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਸੁਨੇਹਾ ਸੰਦੇਸ਼ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ (ਜੋੜੇ ਗਏ ਸੰਦੇਸ਼ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਪਹਿਲੇ ਸੰਦੇਸ਼ ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ) ਅਤੇ ਸੁਨੇਹਾ ਇੱਕ tuple ਵਿੱਚ ਬਦਲਦਾ ਹੈ.

ਇੱਕ ਟੂਪਲ ਵਿੱਚ ਡੇਟਾ ਦੇ ਇੱਕ ਟੁਕੜੇ ਨੂੰ ਜੋੜਨਾ:

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);

ਟੂਪਲ ਦੇ ਤੱਤ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਨਕਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ 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);

ਜੇ ਦਲੀਲ 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);

ਕਤਾਰ ਕਤਾਰ_ਟੀ

ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਵਿੱਚ ਸੁਨੇਹਾ ਕਤਾਰ ਇੱਕ ਸਰਕੂਲਰ ਡਬਲ ਲਿੰਕਡ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਲਾਗੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹਰੇਕ ਸੂਚੀ ਤੱਤ ਵਿੱਚ ਸਿਗਨਲ ਨਮੂਨਿਆਂ ਵਾਲੇ ਡੇਟਾ ਬਲਾਕ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਹੁੰਦਾ ਹੈ। ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਸਿਰਫ ਡੇਟਾ ਬਲਾਕ ਵੱਲ ਪੁਆਇੰਟਰ ਬਦਲੇ ਵਿੱਚ ਚਲੇ ਜਾਂਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਡੇਟਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਗਤੀਹੀਣ ਰਹਿੰਦਾ ਹੈ. ਉਹ. ਉਹਨਾਂ ਲਈ ਸਿਰਫ਼ ਲਿੰਕ ਹੀ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।
ਕਤਾਰ ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੀ ਬਣਤਰ ਕਤਾਰ_ਟੀ, ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ:

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

ਬਣਤਰ ਵਿੱਚ ਇੱਕ ਖੇਤਰ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ - ਇੱਕ ਪੁਆਇੰਟਰ _q_ਸਟੌਪਰ *mblk_t ਟਾਈਪ ਕਰੋ, ਇਹ ਕਤਾਰ ਵਿੱਚ ਪਹਿਲੇ ਤੱਤ (ਸੰਦੇਸ਼) ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ। ਢਾਂਚੇ ਦਾ ਦੂਜਾ ਖੇਤਰ ਕਤਾਰ ਵਿੱਚ ਸੰਦੇਸ਼ਾਂ ਦਾ ਕਾਊਂਟਰ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ q1 ਨਾਮ ਦੀ ਇੱਕ ਕਤਾਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ 4 ਸੁਨੇਹੇ m1, m2, m3, m4 ਹਨ।

ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ q1 ਨਾਮ ਦੀ ਇੱਕ ਕਤਾਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ 4 ਸੁਨੇਹੇ m1,m2,m3,m4 ਹਨ। ਸੁਨੇਹਾ m2 ਇੱਕ ਟੂਪਲ ਦਾ ਸਿਰ ਹੈ ਜਿਸ ਵਿੱਚ ਦੋ ਹੋਰ ਸੁਨੇਹੇ m2_1 ਅਤੇ m2_2 ਹਨ।

queues queue_t ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ

ਕਤਾਰ ਸ਼ੁਰੂਆਤ:

void qinit(queue_t *q);

ਖੇਤਰ _q_ਸਟੌਪਰ (ਇਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਇਸਨੂੰ "ਸਟੌਪਰ" ਕਹਾਂਗੇ) ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ 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) ਸੁਨੇਹੇ ਲਈ ਇੱਕ ਨਲ ਪੁਆਇੰਟਰ ਨਾਲ, ਫੰਕਸ਼ਨ ਲੂਪ ਹੋ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਫ੍ਰੀਜ਼ ਹੋ ਜਾਵੇਗਾ। ਇਸੇ ਤਰ੍ਹਾਂ ਵਿਹਾਰ ਕਰਦਾ ਹੈ ms_queue_next(q, m).

ਕਨੈਕਟ ਕਰਨ ਵਾਲੇ ਫਿਲਟਰ

ਉੱਪਰ ਦੱਸੇ ਗਏ ਕਤਾਰ ਨੂੰ ਇੱਕ ਫਿਲਟਰ ਤੋਂ ਦੂਜੇ ਜਾਂ ਇੱਕ ਤੋਂ ਕਈ ਫਿਲਟਰਾਂ ਵਿੱਚ ਸੰਦੇਸ਼ ਭੇਜਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਫਿਲਟਰ ਅਤੇ ਉਹਨਾਂ ਦੇ ਕਨੈਕਸ਼ਨ ਇੱਕ ਨਿਰਦੇਸ਼ਿਤ ਗ੍ਰਾਫ ਬਣਾਉਂਦੇ ਹਨ। ਫਿਲਟਰ ਦੇ ਇਨਪੁਟ ਜਾਂ ਆਉਟਪੁੱਟ ਨੂੰ ਆਮ ਸ਼ਬਦ "ਪਿੰਨ" ਕਿਹਾ ਜਾਵੇਗਾ। ਉਸ ਕ੍ਰਮ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਜਿਸ ਵਿੱਚ ਫਿਲਟਰ ਇੱਕ ਦੂਜੇ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ, ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਇੱਕ "ਸਿਗਨਲ ਪੁਆਇੰਟ" ਦੀ ਧਾਰਨਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਸਿਗਨਲ ਪੁਆਇੰਟ ਬਣਤਰ ਹੈ _MSCPpoint, ਜਿਸ ਵਿੱਚ ਫਿਲਟਰ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਅਤੇ ਇਸਦੇ ਇੱਕ ਪਿੰਨ ਦੀ ਸੰਖਿਆ ਹੁੰਦੀ ਹੈ; ਇਸਦੇ ਅਨੁਸਾਰ, ਇਹ ਫਿਲਟਰ ਦੇ ਇਨਪੁਟਸ ਜਾਂ ਆਉਟਪੁੱਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੇ ਕਨੈਕਸ਼ਨ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।

ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਗ੍ਰਾਫ ਦਾ ਸਿਗਨਲ ਪੁਆਇੰਟ

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

ਫਿਲਟਰ ਪਿੰਨਾਂ ਨੂੰ ਸਿਫ਼ਰ ਤੋਂ ਸ਼ੁਰੂ ਕਰਕੇ ਨੰਬਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

ਇੱਕ ਸੁਨੇਹਾ ਕਤਾਰ ਦੁਆਰਾ ਦੋ ਪਿੰਨਾਂ ਦੇ ਕਨੈਕਸ਼ਨ ਨੂੰ ਬਣਤਰ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ _MS ਕਤਾਰ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਸੁਨੇਹਾ ਕਤਾਰ ਅਤੇ ਦੋ ਸਿਗਨਲ ਪੁਆਇੰਟਾਂ ਲਈ ਪੁਆਇੰਟਰ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਜੋ ਇਸਨੂੰ ਜੋੜਦਾ ਹੈ:

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

ਅਸੀਂ ਇਸ ਢਾਂਚੇ ਨੂੰ ਸਿਗਨਲ ਲਿੰਕ ਕਹਾਂਗੇ। ਹਰੇਕ ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਫਿਲਟਰ ਵਿੱਚ ਇਨਪੁਟ ਲਿੰਕਾਂ ਦੀ ਇੱਕ ਸਾਰਣੀ ਅਤੇ ਆਉਟਪੁੱਟ ਲਿੰਕਾਂ ਦੀ ਇੱਕ ਸਾਰਣੀ ਹੁੰਦੀ ਹੈ (MSQueue). ਫਿਲਟਰ ਬਣਾਉਣ ਵੇਲੇ ਟੇਬਲਾਂ ਦਾ ਆਕਾਰ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕਿਸਮ ਦੇ ਨਿਰਯਾਤ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹਾ ਕਰ ਚੁੱਕੇ ਹਾਂ MSFilterDesc, ਜਦੋਂ ਅਸੀਂ ਆਪਣਾ ਫਿਲਟਰ ਵਿਕਸਿਤ ਕੀਤਾ ਹੈ। ਹੇਠਾਂ ਇੱਕ ਢਾਂਚਾ ਹੈ ਜੋ ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਵਿੱਚ ਕਿਸੇ ਵੀ ਫਿਲਟਰ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ, 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;

ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਯੋਜਨਾ ਦੇ ਅਨੁਸਾਰ ਸੀ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਫਿਲਟਰਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ (ਪਰ ਟਿਕਰ ਨੂੰ ਨਹੀਂ ਜੋੜਿਆ), ਤਾਂ ਅਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਨਿਰਦੇਸ਼ਿਤ ਗ੍ਰਾਫ ਬਣਾਇਆ, ਜਿਸ ਦੇ ਨੋਡ ਬਣਤਰ ਦੇ ਉਦਾਹਰਣ ਹਨ MSFilter, ਅਤੇ ਕਿਨਾਰੇ ਲਿੰਕਾਂ ਦੇ ਉਦਾਹਰਣ ਹਨ MSQueue.

ਪਰਦੇ ਪਿੱਛੇ ਟਿਕਰ ਦੀਆਂ ਗਤੀਵਿਧੀਆਂ

ਜਦੋਂ ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਿਆ ਕਿ ਟਿਕਰ ਟਿੱਕ ਦੇ ਸਰੋਤ ਲਈ ਇੱਕ ਫਿਲਟਰ ਹੈ, ਤਾਂ ਇਸ ਬਾਰੇ ਪੂਰੀ ਸੱਚਾਈ ਨਹੀਂ ਸੀ। ਇੱਕ ਟਿਕਰ ਇੱਕ ਵਸਤੂ ਹੈ ਜੋ ਘੜੀ 'ਤੇ ਫੰਕਸ਼ਨ ਚਲਾਉਂਦੀ ਹੈ ਪ੍ਰਕਿਰਿਆ() ਸਰਕਟ ਦੇ ਸਾਰੇ ਫਿਲਟਰ (ਗ੍ਰਾਫ) ਜਿਸ ਨਾਲ ਇਹ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਜਦੋਂ ਅਸੀਂ ਇੱਕ C ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੱਕ ਟਿਕਰ ਨੂੰ ਇੱਕ ਗ੍ਰਾਫ ਫਿਲਟਰ ਨਾਲ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਟਿਕਰ ਨੂੰ ਉਹ ਗ੍ਰਾਫ ਦਿਖਾਉਂਦੇ ਹਾਂ ਜਿਸਨੂੰ ਇਹ ਹੁਣ ਤੋਂ ਉਦੋਂ ਤੱਕ ਕੰਟਰੋਲ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਇਸਨੂੰ ਬੰਦ ਨਹੀਂ ਕਰਦੇ ਹਾਂ। ਕਨੈਕਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਟਿਕਰ ਆਪਣੀ ਦੇਖਭਾਲ ਲਈ ਸੌਂਪੇ ਗਏ ਗ੍ਰਾਫ ਦੀ ਜਾਂਚ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਫਿਲਟਰਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਇੱਕੋ ਫਿਲਟਰ ਨੂੰ ਦੋ ਵਾਰ "ਗਣਨਾ" ਨਾ ਕਰਨ ਲਈ, ਇਹ ਖੋਜੇ ਗਏ ਫਿਲਟਰਾਂ ਨੂੰ ਉਹਨਾਂ ਵਿੱਚ ਇੱਕ ਚੈਕਬਾਕਸ ਰੱਖ ਕੇ ਨਿਸ਼ਾਨਬੱਧ ਕਰਦਾ ਹੈ ਨੂੰ ਵੇਖਿਆ. ਖੋਜ ਉਹਨਾਂ ਲਿੰਕ ਟੇਬਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਹਰੇਕ ਫਿਲਟਰ ਕੋਲ ਹਨ।

ਗ੍ਰਾਫ ਦੇ ਆਪਣੇ ਸ਼ੁਰੂਆਤੀ ਦੌਰੇ ਦੌਰਾਨ, ਟਿਕਰ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਫਿਲਟਰਾਂ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਅਜਿਹਾ ਹੈ ਜੋ ਡੇਟਾ ਬਲਾਕਾਂ ਦੇ ਸਰੋਤ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਵੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਗ੍ਰਾਫ ਨੂੰ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਟਿਕਰ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ।

ਜੇਕਰ ਗ੍ਰਾਫ "ਸਹੀ" ਨਿਕਲਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਲੱਭੇ ਗਏ ਫਿਲਟਰ ਲਈ, ਫੰਕਸ਼ਨ ਨੂੰ ਸ਼ੁਰੂਆਤੀਕਰਣ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਪ੍ਰੀਪ੍ਰੋਸੈਸ(). ਜਿਵੇਂ ਹੀ ਅਗਲੇ ਪ੍ਰੋਸੈਸਿੰਗ ਚੱਕਰ ਲਈ ਪਲ ਆਉਂਦਾ ਹੈ (ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਹਰ 10 ਮਿਲੀਸਕਿੰਟ), ਟਿਕਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਪ੍ਰਕਿਰਿਆ() ਸਾਰੇ ਪਹਿਲਾਂ ਮਿਲੇ ਸਰੋਤ ਫਿਲਟਰਾਂ ਲਈ, ਅਤੇ ਫਿਰ ਸੂਚੀ ਵਿੱਚ ਬਾਕੀ ਬਚੇ ਫਿਲਟਰਾਂ ਲਈ। ਜੇਕਰ ਫਿਲਟਰ ਵਿੱਚ ਇਨਪੁਟ ਲਿੰਕ ਹਨ, ਤਾਂ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ ਪ੍ਰਕਿਰਿਆ() ਇੰਪੁੱਟ ਲਿੰਕ ਕਤਾਰਾਂ ਖਾਲੀ ਹੋਣ ਤੱਕ ਦੁਹਰਾਉਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ, ਇਹ ਸੂਚੀ ਵਿੱਚ ਅਗਲੇ ਫਿਲਟਰ 'ਤੇ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਉਦੋਂ ਤੱਕ "ਸਕ੍ਰੌਲ" ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਨਪੁਟ ਲਿੰਕ ਸੁਨੇਹਿਆਂ ਤੋਂ ਮੁਕਤ ਨਹੀਂ ਹੁੰਦੇ। ਟਿਕਰ ਸੂਚੀ ਦੇ ਖਤਮ ਹੋਣ ਤੱਕ ਫਿਲਟਰ ਤੋਂ ਫਿਲਟਰ ਤੱਕ ਜਾਂਦਾ ਹੈ। ਇਹ ਚੱਕਰ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ.

ਹੁਣ ਅਸੀਂ ਟੂਪਲਜ਼ 'ਤੇ ਵਾਪਸ ਆਵਾਂਗੇ ਅਤੇ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ ਕਿ ਅਜਿਹੀ ਇਕਾਈ ਨੂੰ ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਵਿੱਚ ਕਿਉਂ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਆਮ ਤੌਰ 'ਤੇ, ਫਿਲਟਰ ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਨ ਵਾਲੇ ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ ਲੋੜੀਂਦੇ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ ਹੈ ਅਤੇ ਇਨਪੁਟ 'ਤੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਬਫਰਾਂ ਦੇ ਆਕਾਰ ਦਾ ਗੁਣਕ ਨਹੀਂ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਫਿਲਟਰ ਲਿਖ ਰਹੇ ਹਾਂ ਜੋ ਇੱਕ ਤੇਜ਼ ਫੁਰੀਅਰ ਟਰਾਂਸਫਾਰਮ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਪਰਿਭਾਸ਼ਾ ਦੁਆਰਾ ਸਿਰਫ ਉਹਨਾਂ ਡੇਟਾ ਬਲਾਕਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਆਕਾਰ ਦੋ ਦੀ ਸ਼ਕਤੀ ਹੈ। ਇਸ ਨੂੰ 512 ਗਿਣਨ ਦਿਓ. ਜੇਕਰ ਡੇਟਾ ਇੱਕ ਟੈਲੀਫੋਨ ਚੈਨਲ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਨਪੁਟ 'ਤੇ ਹਰੇਕ ਸੰਦੇਸ਼ ਦਾ ਡੇਟਾ ਬਫਰ ਸਾਡੇ ਲਈ 160 ਸਿਗਨਲ ਨਮੂਨੇ ਲਿਆਏਗਾ। ਜਦੋਂ ਤੱਕ ਡੇਟਾ ਦੀ ਲੋੜੀਂਦੀ ਮਾਤਰਾ ਨਹੀਂ ਹੁੰਦੀ ਉਦੋਂ ਤੱਕ ਇਨਪੁਟ ਤੋਂ ਡੇਟਾ ਇਕੱਠਾ ਨਾ ਕਰਨ ਲਈ ਇਹ ਲੁਭਾਉਣ ਵਾਲਾ ਹੈ। ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਟਿਕਰ ਦੇ ਨਾਲ ਇੱਕ ਟੱਕਰ ਹੋਵੇਗੀ, ਜੋ ਕਿ ਇਨਪੁਟ ਲਿੰਕ ਖਾਲੀ ਹੋਣ ਤੱਕ ਫਿਲਟਰ ਨੂੰ ਸਕ੍ਰੋਲ ਕਰਨ ਦੀ ਅਸਫਲ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ। ਪਹਿਲਾਂ, ਅਸੀਂ ਇਸ ਨਿਯਮ ਨੂੰ ਫਿਲਟਰ ਦੇ ਤੀਜੇ ਸਿਧਾਂਤ ਵਜੋਂ ਮਨੋਨੀਤ ਕੀਤਾ ਸੀ। ਇਸ ਸਿਧਾਂਤ ਦੇ ਅਨੁਸਾਰ, ਫਿਲਟਰ ਦੀ ਪ੍ਰਕਿਰਿਆ() ਫੰਕਸ਼ਨ ਨੂੰ ਇਨਪੁਟ ਕਤਾਰਾਂ ਤੋਂ ਸਾਰਾ ਡਾਟਾ ਲੈਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਨਪੁਟ ਤੋਂ ਸਿਰਫ 512 ਨਮੂਨੇ ਲੈਣਾ ਸੰਭਵ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਤੁਸੀਂ ਸਿਰਫ ਪੂਰੇ ਬਲਾਕ ਹੀ ਲੈ ਸਕਦੇ ਹੋ, ਯਾਨੀ. ਫਿਲਟਰ ਨੂੰ 640 ਨਮੂਨੇ ਲੈਣੇ ਪੈਣਗੇ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ 512 ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ, ਬਾਕੀ ਡੇਟਾ ਦੇ ਇੱਕ ਨਵੇਂ ਹਿੱਸੇ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ। ਇਸ ਤਰ੍ਹਾਂ, ਸਾਡੇ ਫਿਲਟਰ ਨੂੰ, ਇਸਦੇ ਮੁੱਖ ਕੰਮ ਤੋਂ ਇਲਾਵਾ, ਇਨਪੁਟ ਡੇਟਾ ਦੇ ਵਿਚਕਾਰਲੇ ਸਟੋਰੇਜ ਲਈ ਸਹਾਇਕ ਕਿਰਿਆਵਾਂ ਪ੍ਰਦਾਨ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਮੀਡੀਆ ਸਟ੍ਰੀਮਰ ਦੇ ਡਿਵੈਲਪਰਾਂ ਅਤੇ ਇਸ ਆਮ ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਆਬਜੈਕਟ - MSBufferizer (ਬਫਰਰ) ਵਿਕਸਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਟੂਪਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।

ਬਫਰਾਈਜ਼ਰ (MSBufferizer)

ਇਹ ਇੱਕ ਅਜਿਹਾ ਆਬਜੈਕਟ ਹੈ ਜੋ ਫਿਲਟਰ ਦੇ ਅੰਦਰ ਇਨਪੁਟ ਡੇਟਾ ਨੂੰ ਇਕੱਠਾ ਕਰੇਗਾ ਅਤੇ ਫਿਲਟਰ ਐਲਗੋਰਿਦਮ ਨੂੰ ਚਲਾਉਣ ਲਈ ਜਾਣਕਾਰੀ ਦੀ ਮਾਤਰਾ ਕਾਫ਼ੀ ਹੋਣ ਦੇ ਨਾਲ ਹੀ ਇਸਨੂੰ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਜਮ੍ਹਾਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦੇਵੇਗਾ। ਜਦੋਂ ਬਫਰ ਡਾਟਾ ਇਕੱਠਾ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ, ਫਿਲਟਰ ਪ੍ਰੋਸੈਸਰ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਪਾਵਰ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਨਿਸ਼ਕਿਰਿਆ ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰੇਗਾ। ਪਰ ਜਿਵੇਂ ਹੀ ਬਫਰਰ ਤੋਂ ਰੀਡਿੰਗ ਫੰਕਸ਼ਨ ਜ਼ੀਰੋ ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਹੋਰ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਫਿਲਟਰ ਦਾ process() ਫੰਕਸ਼ਨ ਲੋੜੀਂਦੇ ਆਕਾਰ ਦੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਬਫਰਰ ਤੋਂ ਡੇਟਾ ਲੈਣਾ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਤੱਕ ਇਹ ਖਤਮ ਨਹੀਂ ਹੋ ਜਾਂਦਾ।
ਉਹ ਡੇਟਾ ਜੋ ਅਜੇ ਲੋੜੀਂਦਾ ਨਹੀਂ ਹੈ, ਟੂਪਲ ਦੇ ਪਹਿਲੇ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਬਫਰ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਇਨਪੁਟ ਡੇਟਾ ਦੇ ਬਾਅਦ ਦੇ ਬਲਾਕ ਜੁੜੇ ਹੁੰਦੇ ਹਨ।

ਬਣਤਰ ਜੋ ਬਫਰ ਦਾ ਵਰਣਨ ਕਰਦੀ ਹੈ:

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

MSBufferizer ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ

ਇੱਕ ਨਵਾਂ ਬਫਰ ਉਦਾਹਰਨ ਬਣਾਉਣਾ:

MSBufferizer * ms_bufferizer_new(void);

ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਹੈ, ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਹੈ ms_buferizer_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_buferizer_put().

ਬਫਰ ਤੋਂ ਪੜ੍ਹਨਾ:

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

ਜੇਕਰ ਬਫਰ ਵਿੱਚ ਇਕੱਤਰ ਕੀਤੇ ਡੇਟਾ ਦਾ ਆਕਾਰ ਬੇਨਤੀ ਕੀਤੇ ਡੇਟਾ ਤੋਂ ਘੱਟ ਹੈ (datalen), ਫਿਰ ਫੰਕਸ਼ਨ ਜ਼ੀਰੋ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਡੇਟਾ ਨੂੰ ਡੇਟਾ ਵਿੱਚ ਕਾਪੀ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, ਬਫਰ ਵਿੱਚ ਸਥਿਤ ਟੂਪਲਾਂ ਤੋਂ ਡੇਟਾ ਦੀ ਕ੍ਰਮਵਾਰ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਕਾਪੀ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਟੂਪਲ ਮਿਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮੈਮੋਰੀ ਖਾਲੀ ਹੋ ਜਾਂਦੀ ਹੈ। ਕਾਪੀ ਕਰਨਾ ਉਸ ਸਮੇਂ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਡੇਟਾਲੇਨ ਬਾਈਟਾਂ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਡੇਟਾ ਬਲਾਕ ਦੇ ਵਿਚਕਾਰ ਸਪੇਸ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਸ ਸੁਨੇਹੇ ਵਿੱਚ, ਡੇਟਾ ਬਲਾਕ ਨੂੰ ਬਾਕੀ ਅਣਕਾਪੀ ਕੀਤੇ ਹਿੱਸੇ ਵਿੱਚ ਘਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਅਗਲੀ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਕਾਲ ਕਰੋਗੇ, ਤਾਂ ਇਸ ਬਿੰਦੂ ਤੋਂ ਕਾਪੀ ਕਰਨਾ ਜਾਰੀ ਰਹੇਗਾ।

ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਪੜ੍ਹਨਾ ਜੋ ਵਰਤਮਾਨ ਵਿੱਚ ਬਫਰ ਵਿੱਚ ਉਪਲਬਧ ਹੈ:

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