De Mediastreamer2 VoIP-engine verkennen. Deel 6

Het materiaal van het artikel is afkomstig uit mijn zen-kanaal.

Een audiosignaal verzenden via RTP-stream

In het verleden статье We hebben een afstandsbedieningscircuit samengesteld uit een toongenerator en een toondetector die binnen hetzelfde programma werken. In dit artikel leren we hoe we het RTP-protocol (RFC 3550 - RTP: een transportprotocol voor real-time toepassingen) voor het ontvangen/verzenden van een audiosignaal via een Ethernet-netwerk.

RTP-protocol (Realtime-protocol) vertaald betekent real-time protocol, het wordt gebruikt om audio, video, gegevens, alles wat transmissie in realtime vereist, te verzenden. Laten we als voorbeeld een audiosignaal nemen. De flexibiliteit van het protocol is zodanig dat je een audiosignaal met een vooraf bepaalde kwaliteit kunt verzenden.

De verzending wordt uitgevoerd met behulp van UDP-pakketten, wat betekent dat pakketverlies tijdens de verzending zeer acceptabel is. Elk pakket bevat een speciale RTP-header en een datablok van het verzonden signaal. De header bevat een willekeurig geselecteerde signaalbronidentificatie, informatie over het type signaal dat wordt verzonden en een uniek pakketvolgnummer, zodat de pakketten bij het decoderen in de juiste volgorde kunnen worden gerangschikt, ongeacht de volgorde waarin ze door de ontvanger zijn afgeleverd. netwerk. De header kan ook aanvullende informatie bevatten, de zogenaamde extensie, waarmee de header kan worden aangepast voor gebruik in een specifieke applicatietaak.

Het datablok bevat de payload van het pakket. De interne organisatie van de inhoud is afhankelijk van het type belasting, het kunnen samples zijn van een monosignaal, een stereosignaal, een videobeeldlijn, enz.

Het belastingstype wordt aangegeven door een getal van zeven bits. Aanbeveling RFC3551 (RTP-profiel voor audio- en videoconferenties met minimale controle) stelt verschillende soorten belastingen vast; de bijbehorende tabel geeft een beschrijving van de soorten belastingen en de betekenis van de codes waarmee ze worden aangeduid. Sommige codes zijn niet strikt gebonden aan welk type belasting dan ook; ze kunnen worden gebruikt om een ​​willekeurige belasting aan te duiden.

De grootte van een datablok wordt hierboven beperkt door de maximale pakketgrootte die zonder segmentatie op een bepaald netwerk kan worden verzonden (MTU-parameter). Over het algemeen is dit niet meer dan 1500 bytes. Om de hoeveelheid gegevens die per seconde wordt verzonden te vergroten, kunt u dus de pakketgrootte tot een bepaald punt vergroten, en dan moet u de frequentie van het verzenden van pakketten verhogen. In een mediastreamer is dit een configureerbare instelling. Standaard is dit 50 Hz, d.w.z. 50 pakketten per seconde. We zullen de reeks verzonden RTP-pakketten een RTP-stream noemen.

Om te beginnen met het verzenden van gegevens tussen de bron en de ontvanger, is het voldoende dat de zender het IP-adres van de ontvanger kent en het poortnummer dat hij gebruikt voor ontvangst. Die. zonder voorafgaande procedures begint de bron gegevens te verzenden en is de ontvanger op zijn beurt klaar om deze onmiddellijk te ontvangen en te verwerken. Volgens de standaard moet het poortnummer dat wordt gebruikt om een ​​RTP-stream te verzenden of te ontvangen, even zijn.

In situaties waarin het onmogelijk is om het adres van de ontvanger van tevoren te weten, worden servers gebruikt waar ontvangers hun adres achterlaten, en de zender kan dit opvragen door te verwijzen naar een unieke naam van de ontvanger.

In gevallen waarin de kwaliteit van het communicatiekanaal of de mogelijkheden van de ontvanger onbekend zijn, wordt een feedbackkanaal georganiseerd waarmee de ontvanger de zender kan informeren over zijn mogelijkheden, het aantal pakketten dat hij heeft gemist, enz. Dit kanaal maakt gebruik van het RTCP-protocol. Het formaat van de pakketten die via dit kanaal worden verzonden, is gedefinieerd in RFC 3605. Er worden relatief weinig gegevens via dit kanaal verzonden, 200..300 bytes per seconde, dus over het algemeen is de aanwezigheid ervan niet belastend. Het poortnummer waarnaar RTCP-pakketten worden verzonden, moet oneven zijn en één groter dan het poortnummer waar de RTP-stroom vandaan komt. In ons voorbeeld zullen we dit kanaal niet gebruiken, omdat de mogelijkheden van de ontvanger en het kanaal duidelijk onze, tot nu toe bescheiden, behoeften overtreffen.

In ons programma zal het datatransmissiecircuit, in tegenstelling tot het vorige voorbeeld, in twee delen worden verdeeld: een zendpad en een ontvangstpad. Voor elk onderdeel maken we onze eigen klokbron, zoals weergegeven in de titelafbeelding.

De eenrichtingscommunicatie tussen hen zal plaatsvinden via het RTP-protocol. In dit voorbeeld hebben we geen extern netwerk nodig, omdat zowel de zender als de ontvanger zich op dezelfde computer bevinden - de pakketten zullen daarbinnen reizen.

Om een ​​RTP-stream tot stand te brengen, gebruikt de mediastreamer twee filters: MS_RTP_SEND en MS_RTP_RECV. De eerste verzendt de tweede en ontvangt de RTP-stream. Om deze filters te laten werken, moeten ze een pointer doorgeven aan een RTP-sessieobject, dat een stroom datablokken kan omzetten in een stroom RTP-pakketten of het tegenovergestelde kan doen. Omdat het interne gegevensformaat van de mediastreamer niet overeenkomt met het gegevensformaat van het RTP-pakket, moet u, voordat u de gegevens naar MS_RTP_SEND overdraagt, een encoderfilter gebruiken dat 16-bits audiosignaalsamples omzet in XNUMX-bits gecodeerd volgens de u-wet (mu-wet). Aan de ontvangstzijde vervult het decoderfilter de tegenovergestelde functie.

Hieronder staat de tekst van het programma dat het schema uit de afbeelding implementeert (de #-symbolen vóór de include-richtlijnen zijn verwijderd, vergeet niet deze op te nemen):

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

Wij compileren en draaien. Het programma werkt zoals in het vorige voorbeeld, maar de gegevens worden verzonden via een RTP-stream.

In het volgende artikel zullen we dit programma verdelen in twee onafhankelijke applicaties: een ontvanger en een zender, en deze op verschillende terminals lanceren. Tegelijkertijd zullen we leren hoe we RTP-pakketten kunnen analyseren met behulp van het TShark-programma.

Bron: www.habr.com