Paggalugad sa Mediastreamer2 VoIP engine. Bahagi 6

Ang materyal ng artikulo ay kinuha mula sa aking zen channel.

Pagpapadala ng audio signal sa pamamagitan ng RTP stream

Sa huli Artikulo Nag-assemble kami ng remote control circuit mula sa tone generator at tone detector na gumagana sa loob ng parehong programa. Sa artikulong ito matututunan natin kung paano gamitin ang RTP protocol (RFC 3550 - RTP: Isang Transport Protocol para sa Mga Real-Time na Application) para sa pagtanggap/pagpapadala ng audio signal sa isang Ethernet network.

RTP protocol (Real Time Protocol) isinalin ay nangangahulugan ng real-time na protocol, ito ay ginagamit upang magpadala ng audio, video, data, lahat ng bagay na nangangailangan ng paghahatid sa real time. Kunin natin ang isang audio signal bilang isang halimbawa. Ang kakayahang umangkop ng protocol ay tulad na pinapayagan ka nitong magpadala ng isang audio signal na may paunang natukoy na kalidad.

Ang paghahatid ay isinasagawa gamit ang mga UDP packet, na nangangahulugan na ang packet loss ay lubos na katanggap-tanggap sa panahon ng paghahatid. Ang bawat packet ay naglalaman ng isang espesyal na header ng RTP at isang bloke ng data ng ipinadalang signal. Ang header ay naglalaman ng random na piniling signal source identifier, impormasyon tungkol sa uri ng signal na ipinapadala, at isang natatanging packet sequence number upang ang mga packet ay maiayos sa tamang pagkakasunod-sunod kapag nagde-decode, anuman ang pagkakasunud-sunod kung saan sila inihatid ng network. Ang header ay maaari ding maglaman ng karagdagang impormasyon, ang tinatawag na extension, na nagpapahintulot sa header na maiangkop para sa paggamit sa isang partikular na gawain ng application.

Ang data block ay naglalaman ng payload ng packet. Ang panloob na organisasyon ng nilalaman ay nakasalalay sa uri ng pag-load, maaari itong maging mga sample ng isang mono signal, isang stereo signal, isang linya ng imahe ng video, atbp.

Ang uri ng pag-load ay ipinahiwatig ng isang pitong-bit na numero. Rekomendasyon RFC3551 (RTP Profile para sa Audio at Video Conference na may Minimal Control) ay nagtatatag ng ilang uri ng pagkarga; ang kaukulang talahanayan ay nagbibigay ng paglalarawan ng mga uri ng pagkarga at ang kahulugan ng mga code kung saan sila itinalaga. Ang ilang mga code ay hindi mahigpit na nakatali sa anumang uri ng pagkarga; maaari silang magamit upang magtalaga ng isang arbitrary na pagkarga.

Ang laki ng isang data block ay nililimitahan sa itaas ng maximum na laki ng packet na maaaring ipadala sa isang partikular na network nang walang segmentation (MTU parameter). Sa pangkalahatan, ito ay hindi hihigit sa 1500 bytes. Kaya, upang madagdagan ang dami ng data na ipinadala sa bawat segundo, maaari mong dagdagan ang laki ng packet hanggang sa isang tiyak na punto, at pagkatapos ay kakailanganin mong dagdagan ang dalas ng pagpapadala ng mga packet. Sa isang media streamer, isa itong na-configure na setting. Bilang default ito ay 50 Hz, i.e. 50 pakete bawat segundo. Tatawagin namin ang pagkakasunud-sunod ng mga ipinadalang RTP packet na isang RTP stream.

Upang simulan ang pagpapadala ng data sa pagitan ng pinagmulan at ng receiver, sapat na alam ng transmitter ang IP address ng receiver at ang port number na ginagamit nito para sa pagtanggap. Yung. nang walang anumang mga paunang pamamaraan, ang pinagmulan ay nagsisimulang magpadala ng data, at ang tagatanggap, naman, ay handa na agad na tumanggap at magproseso nito. Ayon sa pamantayan, ang port number na ginamit upang magpadala o tumanggap ng RTP stream ay dapat na pantay.

Sa mga sitwasyon kung saan imposibleng malaman ang address ng receiver nang maaga, ginagamit ang mga server kung saan iniiwan ng mga receiver ang kanilang address, at maaaring hilingin ito ng transmitter sa pamamagitan ng pagtukoy sa ilang natatanging pangalan ng receiver.

Sa mga kaso kung saan ang kalidad ng channel ng komunikasyon o ang mga kakayahan ng receiver ay hindi alam, ang isang feedback channel ay isinaayos kung saan maaaring ipaalam ng receiver ang transmitter tungkol sa mga kakayahan nito, ang bilang ng mga packet na napalampas nito, atbp. Ginagamit ng channel na ito ang RTCP protocol. Ang format ng mga packet na ipinadala sa channel na ito ay tinukoy sa RFC 3605. Medyo maliit na data ang ipinadala sa channel na ito, 200..300 bytes bawat segundo, kaya sa pangkalahatan, ang presensya nito ay hindi mabigat. Ang numero ng port kung saan ipinapadala ang mga RTCP packet ay dapat na kakaiba at isang mas malaki kaysa sa numero ng port kung saan nagmumula ang RTP stream. Sa aming halimbawa, hindi namin gagamitin ang channel na ito, dahil ang mga kakayahan ng receiver at channel ay halatang lumampas sa aming, sa ngayon ay katamtaman, na mga pangangailangan.

Sa aming programa, ang circuit ng paghahatid ng data, hindi tulad ng nakaraang halimbawa, ay mahahati sa dalawang bahagi: isang landas sa pagpapadala at isang landas sa pagtanggap. Para sa bawat bahagi gagawa kami ng sarili naming mapagkukunan ng orasan, tulad ng ipinapakita sa pamagat na larawan.

Ang one-way na komunikasyon sa pagitan nila ay isasagawa gamit ang RTP protocol. Sa halimbawang ito, hindi namin kailangan ang isang panlabas na network, dahil ang transmitter at ang receiver ay matatagpuan sa parehong computer - ang mga packet ay maglalakbay sa loob nito.

Upang magtatag ng RTP stream, ang media streamer ay gumagamit ng dalawang filter: MS_RTP_SEND at MS_RTP_RECV. Ang una ay nagpapadala ng pangalawa at tumatanggap ng RTP stream. Upang gumana ang mga filter na ito, kailangan nilang magpasa ng pointer sa isang object ng session ng RTP, na maaaring mag-convert ng stream ng mga bloke ng data sa isang stream ng mga RTP packet o gawin ang kabaligtaran. Dahil ang panloob na format ng data ng media streamer ay hindi tumutugma sa format ng data ng RTP packet, bago ilipat ang data sa MS_RTP_SEND, kailangan mong gumamit ng encoder filter na nagko-convert ng 16-bit na audio signal sample sa eight-bit na naka-encode ayon sa u-law (mu-law). Sa gilid ng pagtanggap, ang filter ng decoder ay gumaganap ng kabaligtaran na pag-andar.

Nasa ibaba ang teksto ng programa na nagpapatupad ng scheme na ipinapakita sa figure (ang # na mga simbolo bago ang mga isamang direktiba ay tinanggal, huwag kalimutang isama ang mga ito):

/* Файл 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);
}
}

Kami ay nag-compile at tumatakbo. Ang programa ay gagana tulad ng sa nakaraang halimbawa, ngunit ang data ay ipapadala sa pamamagitan ng isang RTP stream.

Sa susunod na artikulo ay hahatiin natin ang program na ito sa dalawang independiyenteng aplikasyon - isang receiver at isang transmitter at ilulunsad ang mga ito sa iba't ibang mga terminal. Kasabay nito, matututunan natin kung paano suriin ang mga RTP packet gamit ang TShark program.

Pinagmulan: www.habr.com