Esploriamo il motore VoIP Mediastreamer2. Parte 6

Il materiale dell'articolo è tratto dal mio canale zen.

Trasmissione del segnale audio tramite flusso RTP

Nell'articolo precedente abbiamo chiarito il corretto completamento dei programmi che utilizzano il mediastreamer. abbiamo assemblato uno schema di controllo remoto da un generatore e da un rilevatore di segnali tonali, che funzionano all'interno di un unico programma. In questo articolo impareremo a utilizzare il protocollo RTP (RFC 3550 — RTP: Un protocollo di trasporto per applicazioni in tempo reale) per la ricezione/trasmissione del segnale audio su rete Ethernet.

Il protocollo RTP (Real Time Protocol) in traduzione significa protocollo in tempo reale, ed è utilizzato per la trasmissione di audio, video, dati, tutto ciò che richiede trasmissione in tempo reale. Prendiamo ad esempio il segnale audio. La flessibilità del protocollo è tale da consentire di trasmettere il segnale audio con una qualità predefinita.

La trasmissione avviene tramite pacchetti UDP, il che significa che durante la trasmissione è accettabile una certa perdita di pacchetti. In ogni pacchetto viene inserito un'intestazione RTP e un blocco di dati del segnale trasmesso. L'intestazione contiene un identificatore casualmente selezionato della sorgente del segnale, informazioni sul tipo di segnale trasmesso, un numero di sequenza unico del pacchetto, affinché i pacchetti possano essere ricostruiti nell'ordine corretto al momento della decodifica, indipendentemente dall'ordine in cui sono stati consegnati dalla rete. L'intestazione può inoltre contenere informazioni aggiuntive, note come estensione, che permettono di adattare l'intestazione all'uso in un compito applicativo specifico.

Il blocco dati contiene il payload del pacchetto. L'organizzazione interna del contenuto dipende dal tipo di payload, che può essere campioni di segnale monofonico, segnale stereo, una linea di immagine video, ecc.

Il tipo di payload è indicato da un numero a sette bit. La raccomandazione RFC3551 (RTP Profile for Audio and Video Conferences with Minimal Control) stabilisce diversi tipi di payload, e la tabella corrispondente contiene la descrizione dei tipi di payload e il valore dei codici con cui sono contrassegnati. Alcuni codici non hanno un legame rigido con alcun tipo di payload — possono essere utilizzati per indicare payload arbitrari.

La dimensione del blocco di dati è limitata dalla dimensione massima del pacchetto che può essere trasmesso in questa rete senza segmentazione (parametro MTU). In generale, non supera i 1500 byte. Pertanto, per aumentare la quantità di dati trasmessi al secondo, è possibile aumentare la dimensione del pacchetto fino a un certo punto, dopodiché sarà necessario aumentare la frequenza di invio dei pacchetti. Nel media streamer questo è un parametro configurabile. Per impostazione predefinita, è pari a 50 Hz, cioè 50 pacchetti al secondo. La sequenza di pacchetti RTP trasmessi sarà chiamata flusso RTP.

Per iniziare la trasmissione dei dati tra sorgente e ricevente, è sufficiente che il trasmettitore conosca l'indirizzo IP del ricevente e il numero di porta che utilizza per ricevere. Cioè, senza alcuna procedura preliminare, la sorgente inizia a trasmettere dati e il ricevente è subito pronto ad accettarli e elaborarli. Secondo lo standard, il numero di porta utilizzato per trasmettere o ricevere il flusso RTP deve essere pari.

In situazioni in cui non è possibile conoscere in anticipo l'indirizzo del ricevente, vengono utilizzati server sui quali i riceventi lasciano il proprio indirizzo, e il trasmettitore può richiederlo facendo riferimento a un nome unico del ricevente.

Nei casi in cui la qualità del canale di comunicazione o le capacità del ricevente non siano note, viene istituito un canale di feedback, tramite il quale il ricevente può informare il trasmettitore sulle proprie capacità, sul numero di pacchetti che non ha ricevuto, ecc. In questo canale viene utilizzato il protocollo RTCP. Il formato dei pacchetti trasmessi in questo canale è definito nel RFC 3605. Attraverso questo canale vengono trasmessi relativamente pochi dati, 200-300 byte al secondo, quindi in generale, la sua presenza non è gravosa. Il numero di porta a cui vengono inviati i pacchetti RTCP deve essere dispari e superiore di uno al numero di porta da cui proviene il flusso RTP. Nel nostro esempio non utilizzeremo questo canale, poiché le capacità del ricevente e del canale superano già le nostre, attualmente modeste, esigenze.

Nel nostro programma, lo schema di trasmissione dei dati, a differenza dello schema del precedente esempio, sarà suddiviso in due parti: il percorso di trasmissione e il percorso di ricezione. Per ciascuna parte creeremo il proprio clock, come mostrato nell'immagine principale.

La comunicazione unidirezionale tra di loro avverrà tramite il protocollo RTP. In questo esempio non avremo bisogno di una rete esterna, poiché sia il trasmettitore che il ricevitore saranno posizionati sullo stesso computer: i pacchetti si muoveranno al suo interno.

Per stabilire un flusso RTP nel media streamer vengono utilizzati due filtri: MS_RTP_SEND e MS_RTP_RECV. Il primo esegue la trasmissione, mentre il secondo riceve il flusso RTP. Affinché questi filtri inizino a funzionare, è necessario fornire un puntatore all'oggetto della sessione RTP, che può sia convertire il flusso di blocchi di dati in un flusso di pacchetti RTP sia eseguire l'azione inversa. Poiché il formato interno dei dati del media streamer non corrisponde al formato dei pacchetti RTP, prima di inviare i dati a MS_RTP_SEND è necessario utilizzare un filtro di conversione (encoder) che trasforma le registrazioni audio a 16 bit in otto bit codificati secondo la legge u (legge mu). Dall'altra parte, la funzione inversa è eseguita da un filtro decoder.

Di seguito è riportato il testo del programma che implementa lo schema mostrato nell'immagine (i simboli # davanti alle direttive include sono stati rimossi, non dimenticate di inserirli):

/* Файл mstest6.c Имитатор пульта управления и приемника. */

#include <mediastreamer2/msfilter.h>
#include <mediastreamer2/msticker.h>
#include <mediastreamer2/dtmfgen.h>
#include <mediastreamer2/mssndcard.h>
#include <mediastreamer2/msvolume.h>
#include <mediastreamer2/mstonedetector.h>
#include <mediastreamer2/msrtp.h>
#include <ortp/rtpsession.h>
#include <ortp/payloadtype.h>

/* Подключаем заголовочный файл с функциями управления событиями
* медиастримера.*/
include <mediastreamer2/mseventqueue.h>

#define PCMU 0

/* Функция обратного вызова, она будет вызвана фильтром, как только он
обнаружит совпадение характеристик входного сигнала с заданными. */
static void tone_detected_cb(void *data, MSFilter *f, unsigned int event_id,
MSToneDetectorEvent *ev)
{
printf("Принята команда: %sn", ev->tone_name);
}

/*----------------------------------------------------------------------------*/
/* Функция регистрации типов полезных нагрузок. */
void register_payloads(void)
{
/*Регистрируем типы нагрузок в таблице профилей. Позднее, по индексу
взятому из заголовка RTP-пакета из этой таблицы будут извлекаться
параметры нагрузки, необходимые для декодирования данных пакета. */
rtp_profile_set_payload (&av_profile, PCMU, &payload_type_pcm8000);
}

/*----------------------------------------------------------------------------*/
/* Эта функция создана из функции create_duplex_rtpsession() в audiostream.c
медиастримера2. */
static RtpSession *
create_rtpsession (int loc_rtp_port, int loc_rtcp_port,
bool_t ipv6, RtpSessionMode mode)
{
RtpSession *rtpr;
rtpr = rtp_session_new ((int) mode);
rtp_session_set_scheduling_mode (rtpr, 0);
rtp_session_set_blocking_mode (rtpr, 0);
rtp_session_enable_adaptive_jitter_compensation (rtpr, TRUE);
rtp_session_set_symmetric_rtp (rtpr, TRUE);
rtp_session_set_local_addr (rtpr, ipv6 ? "::" : "0.0.0.0", loc_rtp_port,
loc_rtcp_port);
rtp_session_signal_connect (rtpr, "timestamp_jump",
(RtpCallback) rtp_session_resync, 0);
rtp_session_signal_connect (rtpr, "ssrc_changed",
(RtpCallback) rtp_session_resync, 0);
rtp_session_set_ssrc_changed_threshold (rtpr, 0);
rtp_session_set_send_payload_type(rtpr, PCMU);

/* По умолчанию выключаем RTCP-сессию, так как наш пульт не будет использовать её. */
rtp_session_enable_rtcp (rtpr, FALSE);
return rtpr;
}

/*----------------------------------------------------------------------------*/
int main()
{
ms_init();

/* Создаем экземпляры фильтров. */
MSFilter *voidsource = ms_filter_new(MS_VOID_SOURCE_ID);
MSFilter *dtmfgen = ms_filter_new(MS_DTMF_GEN_ID);
MSFilter *volume = ms_filter_new(MS_VOLUME_ID);
MSSndCard *card_playback =
ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
MSFilter *snd_card_write = ms_snd_card_create_writer(card_playback);
MSFilter *detector = ms_filter_new(MS_TONE_DETECTOR_ID);

/* Очищаем массив находящийся внутри детектора тонов, он описывает
* особые приметы разыскиваемых сигналов.*/
ms_filter_call_method(detector, MS_TONE_DETECTOR_CLEAR_SCANS, 0);

/* Подключаем к фильтру функцию обратного вызова. */
ms_filter_set_notify_callback(detector,
(MSFilterNotifyFunc)tone_detected_cb, NULL);

/* Создаем массив, каждый элемент которого описывает характеристику
* одного из тонов, который требуется обнаруживать: Текстовое имя
* данного элемента, частота в герцах, длительность в миллисекундах,
* минимальный уровень относительно 0,775В. */
MSToneDetectorDef scan[6]=
{
{"V+",440, 100, 0.1}, /* Команда "Увеличить громкость". */
{"V-",540, 100, 0.1}, /* Команда "Уменьшить громкость". */
{"C+",640, 100, 0.1}, /* Команда "Увеличить номер канала". */
{"C-",740, 100, 0.1}, /* Команда "Уменьшить номер канала". */
{"ON",840, 100, 0.1}, /* Команда "Включить телевизор". */
{"OFF", 940, 100, 0.1}/* Команда "Выключить телевизор". */
};

/* Передаем "приметы" сигналов детектор тонов. */
int i;
for (i = 0; i < 6; i++)
{
ms_filter_call_method(detector, MS_TONE_DETECTOR_ADD_SCAN,
&scan[i]);
}

/* Создаем фильтры кодера и декодера */
MSFilter *encoder = ms_filter_create_encoder("PCMU");
MSFilter *decoder=ms_filter_create_decoder("PCMU");
/* Регистрируем типы нагрузки. */
register_payloads();

/* Создаем RTP-сессию передатчика. */
RtpSession *tx_rtp_session = create_rtpsession (8010, 8011, FALSE, RTP_SESSION_SENDONLY);
rtp_session_set_remote_addr_and_port(tx_rtp_session,"127.0.0.1", 7010, 7011);
rtp_session_set_send_payload_type(tx_rtp_session, PCMU);
MSFilter *rtpsend = ms_filter_new(MS_RTP_SEND_ID);
ms_filter_call_method(rtpsend, MS_RTP_SEND_SET_SESSION, tx_rtp_session);

/* Создаем RTP-сессию приемника. */
MSFilter *rtprecv = ms_filter_new(MS_RTP_RECV_ID);
RtpSession *rx_rtp_session = create_rtpsession (7010, 7011, FALSE, RTP_SESSION_RECVONLY);
ms_filter_call_method(rtprecv, MS_RTP_RECV_SET_SESSION, rx_rtp_session);

/* Создаем источники тактов - тикеры. */
MSTicker *ticker_tx = ms_ticker_new();
MSTicker *ticker_rx = ms_ticker_new();

/* Соединяем фильтры передатчика. */
ms_filter_link(voidsource, 0, dtmfgen, 0);
ms_filter_link(dtmfgen, 0, volume, 0);
ms_filter_link(volume, 0, encoder, 0);
ms_filter_link(encoder, 0, rtpsend, 0);

/* Соединяем фильтры приёмника. */
ms_filter_link(rtprecv, 0, decoder, 0);
ms_filter_link(decoder, 0, detector, 0);
ms_filter_link(detector, 0, snd_card_write, 0);

/* Подключаем источник тактов. */
ms_ticker_attach(ticker_tx, voidsource);
ms_ticker_attach(ticker_rx, rtprecv);

/* Настраиваем структуру, управляющую выходным сигналом генератора. */
MSDtmfGenCustomTone dtmf_cfg;
dtmf_cfg.tone_name[0] = 0;
dtmf_cfg.duration = 1000;
dtmf_cfg.frequencies[0] = 440;
/* Будем генерировать один тон, частоту второго тона установим в 0. */
dtmf_cfg.frequencies[1] = 0;
dtmf_cfg.amplitude = 1.0;
dtmf_cfg.interval = 0.;
dtmf_cfg.repeat_count = 0.;

/* Организуем цикл сканирования нажатых клавиш. Ввод нуля завершает
* цикл и работу программы. */
char key='9';
printf("Нажмите клавишу команды, затем ввод.n"
"Для завершения программы введите 0.n");
while(key != '0')
{
key = getchar();
if ((key >= 49) && (key <= 54))
{
printf("Отправлена команда: %cn", key);

/* Устанавливаем частоту генератора в соответствии с
 * кодом нажатой клавиши. */
dtmf_cfg.frequencies[0] = 440 + 100*(key-49);

/* Включаем звуковой генератор c обновленной частотой. */
ms_filter_call_method(dtmfgen, MS_DTMF_GEN_PLAY_CUSTOM,
(void*)&dtmf_cfg);
}

/* Укладываем тред в спячку на 20мс, чтобы другие треды
 * приложения получили время на работу. */
ms_usleep(20000);
}
}

Compilare e avviare. Il programma funzionerà come nell'esempio precedente, ma i dati verranno trasmessi tramite flusso RTP.

Nell'articolo successivo divideremo questo programma in due applicazioni indipendenti: ricevitore e trasmettitore, e li avvieremo in terminali diversi. Parallelamente, impareremo ad analizzare i pacchetti RTP utilizzando il programma TShark.

Fonte: habr.com