Menjelajahi mesin VoIP Mediastreamer2. Bagian 6

Materi artikel diambil dari saya saluran Zen.

Mengirimkan sinyal audio melalui aliran RTP

Terakhir Artikel Kami telah merakit rangkaian kendali jarak jauh dari generator nada dan detektor nada yang beroperasi dalam program yang sama. Pada artikel ini kita akan mempelajari cara menggunakan protokol RTP (RFC 3550 - RTP: Protokol Transportasi untuk Aplikasi Real-Time) untuk menerima/mentransmisikan sinyal audio melalui jaringan Ethernet.

Protokol RTP (Protokol Waktu Nyata) diterjemahkan berarti protokol waktu nyata, digunakan untuk mengirimkan audio, video, data, segala sesuatu yang memerlukan transmisi secara waktu nyata. Mari kita ambil sinyal audio sebagai contoh. Fleksibilitas protokol sedemikian rupa sehingga memungkinkan Anda mengirimkan sinyal audio dengan kualitas yang telah ditentukan.

Transmisi dilakukan dengan menggunakan paket UDP, yang berarti kehilangan paket cukup dapat diterima selama transmisi. Setiap paket berisi header RTP khusus dan blok data dari sinyal yang dikirimkan. Header berisi pengidentifikasi sumber sinyal yang dipilih secara acak, informasi tentang jenis sinyal yang ditransmisikan, dan nomor urut paket yang unik sehingga paket dapat disusun dalam urutan yang benar saat decoding, terlepas dari urutan pengirimannya oleh paket. jaringan. Header juga dapat berisi informasi tambahan, yang disebut ekstensi, yang memungkinkan header diadaptasi untuk digunakan dalam tugas aplikasi tertentu.

Blok data berisi payload paket. Organisasi internal konten bergantung pada jenis beban, dapat berupa sampel sinyal mono, sinyal stereo, saluran gambar video, dll.

Jenis beban ditunjukkan dengan angka tujuh bit. Rekomendasi RFC3551 (Profil RTP untuk Konferensi Audio dan Video dengan Kontrol Minimal) menetapkan beberapa jenis beban; tabel terkait memberikan deskripsi jenis beban dan arti kode yang digunakan untuk menentukannya. Beberapa kode tidak terikat secara ketat pada jenis beban apa pun; kode tersebut dapat digunakan untuk menunjukkan beban yang berubah-ubah.

Ukuran blok data dibatasi di atas oleh ukuran paket maksimum yang dapat ditransmisikan pada jaringan tertentu tanpa segmentasi (parameter MTU). Secara umum, ini tidak lebih dari 1500 byte. Jadi, untuk meningkatkan jumlah data yang dikirimkan per detik, Anda dapat meningkatkan ukuran paket hingga titik tertentu, dan kemudian Anda perlu meningkatkan frekuensi pengiriman paket. Di media streamer, ini adalah pengaturan yang dapat dikonfigurasi. Secara default adalah 50 Hz, mis. 50 paket per detik. Kami akan menyebut urutan paket RTP yang dikirimkan sebagai aliran RTP.

Untuk mulai mentransmisikan data antara sumber dan penerima, pemancar cukup mengetahui alamat IP penerima dan nomor port yang digunakan untuk menerima. Itu. tanpa prosedur awal apa pun, sumber mulai mengirimkan data, dan penerima, pada gilirannya, siap untuk segera menerima dan memprosesnya. Menurut standar, nomor port yang digunakan untuk mengirim atau menerima aliran RTP harus genap.

Dalam situasi di mana tidak mungkin mengetahui alamat penerima terlebih dahulu, server digunakan di mana penerima meninggalkan alamatnya, dan pemancar dapat memintanya dengan merujuk pada beberapa nama unik penerima.

Dalam kasus di mana kualitas saluran komunikasi atau kemampuan penerima tidak diketahui, saluran umpan balik diatur melalui mana penerima dapat memberi tahu pemancar tentang kemampuannya, jumlah paket yang terlewat, dll. Saluran ini menggunakan protokol RTCP. Format paket yang dikirimkan dalam saluran ini ditentukan dalam RFC 3605. Data yang dikirimkan melalui saluran ini relatif sedikit, 200..300 byte per detik, sehingga secara umum kehadirannya tidak memberatkan. Nomor port tujuan pengiriman paket RTCP harus ganjil dan satu lebih besar dari nomor port asal aliran RTP. Dalam contoh kami, kami tidak akan menggunakan saluran ini, karena kemampuan receiver dan saluran jelas melebihi kebutuhan kami yang sejauh ini sederhana.

Dalam program kita, rangkaian transmisi data, tidak seperti contoh sebelumnya, akan dibagi menjadi dua bagian: jalur transmisi dan jalur penerima. Untuk setiap bagian kita akan membuat sumber jamnya sendiri, seperti terlihat pada gambar judul.

Komunikasi satu arah di antara mereka akan dilakukan menggunakan protokol RTP. Dalam contoh ini, kita tidak memerlukan jaringan eksternal, karena pemancar dan penerima akan ditempatkan di komputer yang sama - paket akan berjalan di dalamnya.

Untuk membuat aliran RTP, streamer media menggunakan dua filter: MS_RTP_SEND dan MS_RTP_RECV. Yang pertama mengirimkan yang kedua dan menerima aliran RTP. Agar filter ini berfungsi, mereka perlu meneruskan pointer ke objek sesi RTP, yang dapat mengubah aliran blok data menjadi aliran paket RTP atau melakukan sebaliknya. Karena format data internal media streamer tidak cocok dengan format data paket RTP, sebelum mentransfer data ke MS_RTP_SEND, Anda perlu menggunakan filter encoder yang mengubah sampel sinyal audio 16-bit menjadi delapan-bit yang dikodekan sesuai dengan u-hukum (mu-hukum). Di sisi penerima, filter dekoder menjalankan fungsi sebaliknya.

Di bawah ini adalah teks program yang mengimplementasikan skema yang ditunjukkan pada gambar (simbol # sebelum arahan include dihilangkan, jangan lupa untuk menyertakannya):

/* Файл 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 mengkompilasi dan menjalankan. Program ini akan bekerja seperti pada contoh sebelumnya, tetapi data akan dikirimkan melalui aliran RTP.

Pada artikel berikutnya kami akan membagi program ini menjadi dua aplikasi independen - penerima dan pemancar dan meluncurkannya di terminal berbeda. Pada saat yang sama, kita akan mempelajari cara menganalisis paket RTP menggunakan program TShark.

Sumber: www.habr.com