UltraGrid
UltraGrid Low-Latency High-Resolution Transmission System
Loading...
Searching...
No Matches
audio.h File Reference
#include "audio/types.h"
#include "host.h"
#include "module.h"
#include "tv.h"
#include <chrono>
Include dependency graph for audio.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  additional_audio_data
 
struct  audio_options
 

Macros

#define AUDIO_PROTOCOLS   "JACK, rtsp, sdp or ultragrid_rtp"
 
#define DEFAULT_AUDIO_FEC   "none"
 
#define DEFAULT_AUDIO_SCALE   "mixauto"
 
#define PORT_AUDIO   5006
 

Functions

void audio_done (struct state_audio *s)
 
unsigned int audio_get_display_flags (struct state_audio *s)
 
struct audio_frame * audio_get_frame (struct state_audio *s)
 
int audio_init (struct state_audio **state, const struct audio_options *opt, const struct common_opts *common)
 
void audio_join (struct state_audio *s)
 
void audio_register_aux_data (struct state_audio *s, struct additional_audio_data data)
 
void audio_sdi_send (struct state_audio *s, struct audio_frame *frame)
 
void audio_start (struct state_audio *s)
 
struct audio_frame * sdi_get_frame (void *state)
 
void sdi_put_frame (void *state, struct audio_frame *frame)
 
void sdp_send_change_address_message (struct module *root, const enum module_class *path, const char *address)
 

Macro Definition Documentation

◆ AUDIO_PROTOCOLS

#define AUDIO_PROTOCOLS   "JACK, rtsp, sdp or ultragrid_rtp"

Definition at line 55 of file audio.h.

Referenced by parse_protocol().

◆ DEFAULT_AUDIO_FEC

#define DEFAULT_AUDIO_FEC   "none"

Definition at line 52 of file audio.h.

◆ DEFAULT_AUDIO_SCALE

#define DEFAULT_AUDIO_SCALE   "mixauto"

Definition at line 53 of file audio.h.

◆ PORT_AUDIO

#define PORT_AUDIO   5006

Definition at line 56 of file audio.h.

Function Documentation

◆ audio_done()

void audio_done ( struct state_audio * s)

Definition at line 512 of file audio.cpp.

513{
514 if (!s) {
515 return;
516 }
519 // process remaining messages
520 struct message *msg;
521 while ((msg = check_message(s->audio_receiver_module.get()))) {
522 struct response *r = audio_receiver_process_message(s, (struct msg_receiver *) msg);
523 free_message(msg, r);
524 }
525 while ((msg = check_message(s->audio_sender_module.get()))) {
526 struct response *r = audio_sender_process_message(s, (struct msg_sender *) msg);
527 free_message(msg, r);
528 }
529
533 if(s->audio_participants) {
535 }
536
537 free(s->audio_network_parameters.addr);
538
540
543
544 delete s;
545}
static void should_exit_audio(void *state)
Definition audio.cpp:232
static struct response * audio_sender_process_message(struct state_audio *s, struct msg_sender *msg)
Definition audio.cpp:866
static struct response * audio_receiver_process_message(struct state_audio *s, struct msg_receiver *msg)
Definition audio.cpp:578
void audio_capture_done(struct state_audio_capture *s)
void audio_playback_done(struct state_audio_playback *s)
void audio_codec_done(struct audio_codec_state *s)
Definition codec.cpp:372
void module_done(struct module *module_data)
Definition module.c:93
#define CAST_MODULE(x)
Definition module.h:197
struct module * get_root_module(struct module *node)
Definition module.c:203
void unregister_should_exit_callback(struct module *mod, void(*callback)(void *), void *udata)
Definition host.cpp:1158
void free_message(struct message *msg, struct response *r)
struct message * check_message(struct module *mod)
void pdb_destroy(struct pdb **db_p)
Definition pdb.c:256
void rtp_done(struct rtp *session)
Definition rtp.c:3676
struct msghdr msg
module_raii mod
Definition audio.cpp:138
module_raii audio_sender_module
Definition audio.cpp:143
struct pdb * audio_participants
Definition audio.cpp:151
module_raii audio_receiver_module
Definition audio.cpp:142
struct state_audio_playback * audio_playback_device
Definition audio.cpp:140
struct tx * tx_session
Definition audio.cpp:162
struct audio_codec_state * audio_encoder
Definition audio.cpp:147
struct rtp * audio_network_device
Definition audio.cpp:150
struct state_audio_capture * audio_capture_device
Definition audio.cpp:139

References state_audio::audio_capture_device, audio_capture_done(), audio_codec_done(), state_audio::audio_encoder, state_audio::audio_network_device, state_audio::audio_participants, state_audio::audio_playback_device, audio_playback_done(), state_audio::audio_receiver_module, audio_receiver_process_message(), state_audio::audio_sender_module, audio_sender_process_message(), CAST_MODULE, check_message(), free_message(), get_root_module(), state_audio::mod, module_done(), msg, pdb_destroy(), rtp_done(), should_exit_audio(), state_audio::tx_session, and unregister_should_exit_callback().

Referenced by main(), and vidcap_ug_input_done().

Here is the call graph for this function:

◆ audio_get_display_flags()

unsigned int audio_get_display_flags ( struct state_audio * s)

Definition at line 1210 of file audio.cpp.

1211{
1213}
unsigned int audio_playback_get_display_flags(struct state_audio_playback *s)

References state_audio::audio_playback_device, and audio_playback_get_display_flags().

Referenced by main().

Here is the call graph for this function:

◆ audio_get_frame()

struct audio_frame * audio_get_frame ( struct state_audio * s)

◆ audio_init()

int audio_init ( struct state_audio ** ret,
const struct audio_options * opt,
const struct common_opts * common )

take care that addrs can also be comma-separated list of addresses !

Return values
0state succesfully initialized
<0error occured
>0success but no state was created (eg. help printed)

Definition at line 272 of file audio.cpp.

275{
276 char *tmp, *unused = NULL;
277 char *addr;
278 int retval = -1;
279
280 assert(opt->send_cfg != NULL);
281 assert(opt->recv_cfg != NULL);
282
283 if (opt->channel_map &&
284 strcmp("help", opt->channel_map) == 0) {
286 return 1;
287 }
288
289 if (opt->scale &&
290 strcmp("help", opt->scale) == 0) {
292 return 1;
293 }
294
295 struct state_audio *s =
296 new state_audio(common->parent, common->start_time);
297
299 s->audio_scale = opt->scale;
300
303
304 s->exporter = common->exporter;
305
306 if (opt->echo_cancellation) {
307#ifdef HAVE_SPEEXDSP
309 fprintf(stderr, "Echo cancellation is currently experimental "
310 "and may not work as expected.");
311 goto error;
312#else
313 fprintf(stderr, "Speex not compiled in. Could not enable echo cancellation.\n");
314 delete s;
315 goto error;
316#endif /* HAVE_SPEEXDSP */
317 } else {
318 s->echo_state = NULL;
319 }
320
321 if(opt->filter_cfg){
322 std::string_view cfg_sv = opt->filter_cfg;;
323 std::string_view item;
324 while(item = tokenize(cfg_sv, '#'), !item.empty()) {
325 if(!s->filter_chain.emplace_new(item)) {
326 log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to init audio filter\n");
327 goto error;
328 }
329 }
330 }
331
332 s->opts = *common;
333
334 assert(opt->host != nullptr);
335 tmp = strdup(opt->host);
337 addr = strtok_r(tmp, ",", &unused);
338 assert(addr != nullptr);
339
340 s->audio_network_parameters.addr = strdup(addr);
341 s->audio_network_parameters.recv_port = opt->recv_port;
342 s->audio_network_parameters.send_port = opt->send_port;
343 s->audio_network_parameters.participants = s->audio_participants;
344 s->audio_network_parameters.force_ip_version = common->force_ip_version;
345 s->audio_network_parameters.mcast_if =
346 strlen(s->opts.mcast_if) > 0 ? s->opts.mcast_if : nullptr;
347 s->audio_network_parameters.ttl = s->opts.ttl;
348 free(tmp);
349
350 if (strcmp(opt->send_cfg, "none") != 0) {
351 const char *cfg = "";
352 char *device = strdup(opt->send_cfg);
353 if(strchr(device, ':')) {
354 char *delim = strchr(device, ':');
355 *delim = '\0';
356 cfg = delim + 1;
357 }
358
359 int ret = audio_capture_init(s->audio_sender_module.get(), device, cfg, &s->audio_capture_device);
360 free(device);
361 if (ret != 0) {
362 retval = ret;
363 goto error;
364 }
365 s->tx_session = tx_init(
366 s->audio_sender_module.get(), common->mtu, TX_MEDIA_AUDIO,
367 opt->fec_cfg, common->encryption, 0 /* unused */);
368 if(!s->tx_session) {
369 fprintf(stderr, "Unable to initialize audio transmit.\n");
370 goto error;
371 }
372
374 } else {
376 }
377
378 if (strcmp(opt->recv_cfg, "none") != 0) {
379 const char *cfg = "";
380 char *device = strdup(opt->recv_cfg);
381 if(strchr(device, ':')) {
382 char *delim = strchr(device, ':');
383 *delim = '\0';
384 cfg = delim + 1;
385 }
386
387 int ret = audio_playback_init(device, cfg, &s->audio_playback_device);
388 free(device);
389 if (ret != 0) {
390 retval = ret;
391 goto error;
392 }
394 } else {
396 }
397
398 if (s->audio_tx_mode != 0) {
401 == nullptr) {
402 LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Unable to open audio network\n";
403 goto error;
404 }
405 }
406 if ((s->audio_tx_mode & MODE_RECEIVER) != 0U) {
407 size_t len = sizeof(struct rtp *);
411 }
412
413 if ((s->audio_tx_mode & MODE_SENDER) != 0U || "help"s == opt->codec_cfg) {
414 if ((s->audio_encoder = audio_codec_init_cfg(opt->codec_cfg, AUDIO_CODER)) == nullptr) {
415 goto error;
416 }
417 }
418
419 s->proto_cfg = opt->proto_cfg;
420
421 if (strcasecmp(opt->proto, "ultragrid_rtp") == 0) {
422 s->sender = NET_NATIVE;
423 s->receiver = NET_NATIVE;
424 } else if (strcasecmp(opt->proto, "rtsp") == 0 || strcasecmp(opt->proto, "sdp") == 0) {
426 s->sender = NET_STANDARD;
427 if (strcasecmp(opt->proto, "sdp") == 0) {
428 if (sdp_set_options(opt->proto_cfg) != 0) {
429 goto error;
430 }
431 }
432 } else if (strcasecmp(opt->proto, "JACK") == 0) {
433#ifndef HAVE_JACK_TRANS
434 fprintf(stderr, "[Audio] JACK transport requested, "
435 "but JACK support isn't compiled.\n");
436 goto error;
437#else
438 s->sender = NET_JACK;
439 s->receiver = NET_JACK;
440#endif
441 } else if (s->audio_tx_mode != 0) {
442 log_msg(LOG_LEVEL_ERROR, "Unknow audio protocol: %s\n", opt->proto);
443 goto error;
444 }
445
447
448 *ret = s;
449 return 0;
450
451error:
452 if(s->tx_session)
454 if(s->audio_participants) {
456 }
457
459 delete s;
460 return retval;
461}
int void size_t * len
static struct rtp * initialize_audio_network(struct audio_network_parameters *params)
Definition audio.cpp:547
static void audio_scale_usage(void)
Definition audio.cpp:219
@ NET_JACK
Definition audio.cpp:105
@ NET_STANDARD
Definition audio.cpp:106
@ NET_NATIVE
Definition audio.cpp:104
#define MOD_NAME
Definition audio.cpp:110
static void audio_channel_map_usage(void)
Definition audio.cpp:205
int audio_capture_init(struct module *parent, const char *driver, const char *cfg, struct state_audio_capture **state)
struct state_audio_capture * audio_capture_init_null_device()
bool audio_playback_ctl(struct state_audio_playback *s, int request, void *data, size_t *len)
int audio_playback_init(const char *device, const char *cfg, struct state_audio_playback **state)
struct state_audio_playback * audio_playback_init_null_device(void)
#define AUDIO_PLAYBACK_PUT_NETWORK_DEVICE
bool emplace_new(std::string_view cfg)
struct audio_codec_state * audio_codec_init_cfg(const char *audio_codec_cfg, audio_codec_direction_t direction)
Definition codec.cpp:165
struct audio_codec_params parse_audio_codec_params(const char *ccfg)
Definition codec.cpp:402
@ AUDIO_CODER
Definition codec.h:46
void log_msg(int level, const char *format,...)
Definition debug.cpp:130
#define LOG_LEVEL_ERROR
general errors
Definition debug.h:59
#define LOG(level)
Definition debug.h:313
struct echo_cancellation * echo_cancellation_init(void)
Definition echo.cpp:132
void register_should_exit_callback(struct module *mod, void(*callback)(void *), void *udata)
Definition host.cpp:1144
volatile int audio_offset
added audio delay in ms (non-negative), can be used to tune AV sync
Definition host.cpp:178
#define MODE_SENDER
Definition host.h:102
#define MODE_RECEIVER
Definition host.h:103
struct pdb * pdb_init(volatile int *delay_ms)
Definition pdb.c:244
int sdp_set_options(const char *opts)
Definition sdp.c:585
std::string_view tokenize(std::string_view &str, char delim, char quot)
Tokenizer for string_view.
const char * fec_cfg
Definition audio.h:76
const char * host
Definition audio.h:69
const char * recv_cfg
Definition audio.h:72
const char * send_cfg
Definition audio.h:73
int send_port
Definition audio.h:71
const char * filter_cfg
Definition audio.h:81
int recv_port
Definition audio.h:70
bool echo_cancellation
Definition audio.h:79
char * channel_map
Definition audio.h:77
const char * scale
Definition audio.h:78
const char * codec_cfg
Definition audio.h:80
char encryption[STR_LEN]
Definition host.h:172
int mtu
Definition host.h:174
struct module * parent
Definition host.h:171
struct exporter * exporter
Definition host.h:177
time_ns_t start_time
Definition host.h:178
int force_ip_version
Definition host.h:176
Definition hd-rum.c:27
Definition rtp.c:274
options * opt
Definition rtp.c:284
bool audio_receiver_thread_started
Definition audio.cpp:168
int resample_to
Definition audio.cpp:174
state_audio(struct module *parent, time_ns_t st)
Definition audio.cpp:123
std::string proto_cfg
Definition audio.cpp:152
enum audio_transport_device sender
Definition audio.cpp:154
bool audio_sender_thread_started
Definition audio.cpp:167
enum audio_transport_device receiver
Definition audio.cpp:155
Filter_chain filter_chain
Definition audio.cpp:145
int audio_tx_mode
Definition audio.cpp:178
echo_cancellation_t * echo_state
Definition audio.cpp:172
char * audio_channel_map
Definition audio.cpp:170
struct exporter * exporter
Definition audio.cpp:173
const char * audio_scale
Definition audio.cpp:171
struct tx * tx_init(struct module *parent, unsigned mtu, enum tx_media_type media_type, const char *fec, const char *encryption, long long int bitrate)
Definition transmit.cpp:201
@ TX_MEDIA_AUDIO
Definition types.h:364

References state_audio::state_audio(), state_audio::audio_capture_device, audio_capture_init(), audio_capture_init_null_device(), state_audio::audio_channel_map, audio_channel_map_usage(), audio_codec_done(), audio_codec_init_cfg(), AUDIO_CODER, state_audio::audio_encoder, state_audio::audio_network_device, audio_offset, state_audio::audio_participants, audio_playback_ctl(), state_audio::audio_playback_device, audio_playback_init(), audio_playback_init_null_device(), AUDIO_PLAYBACK_PUT_NETWORK_DEVICE, state_audio::audio_receiver_thread_started, state_audio::audio_scale, audio_scale_usage(), state_audio::audio_sender_module, state_audio::audio_sender_thread_started, state_audio::audio_tx_mode, CAST_MODULE, audio_options::channel_map, audio_options::codec_cfg, audio_options::echo_cancellation, echo_cancellation_init(), state_audio::echo_state, Filter_chain::emplace_new(), common_opts::encryption, common_opts::exporter, state_audio::exporter, audio_options::fec_cfg, audio_options::filter_cfg, state_audio::filter_chain, common_opts::force_ip_version, audio_options::host, initialize_audio_network(), len, LOG, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, MODE_RECEIVER, MODE_SENDER, module_done(), common_opts::mtu, NET_JACK, NET_NATIVE, NET_STANDARD, rtp::opt, common_opts::parent, parse_audio_codec_params(), pdb_destroy(), pdb_init(), state_audio::proto_cfg, state_audio::receiver, audio_options::recv_cfg, audio_options::recv_port, register_should_exit_callback(), state_audio::resample_to, audio_codec_params::sample_rate, audio_options::scale, sdp_set_options(), audio_options::send_cfg, audio_options::send_port, state_audio::sender, should_exit_audio(), common_opts::start_time, tokenize(), tx_init(), TX_MEDIA_AUDIO, and state_audio::tx_session.

Referenced by main(), and vidcap_ug_input_init().

Here is the call graph for this function:

◆ audio_join()

void audio_join ( struct state_audio * s)

Definition at line 502 of file audio.cpp.

502 {
503 if (!s) {
504 return;
505 }
507 pthread_join(s->audio_receiver_thread_id, NULL);
509 pthread_join(s->audio_sender_thread_id, NULL);
510}
pthread_t audio_sender_thread_id
Definition audio.cpp:165
pthread_t audio_receiver_thread_id
Definition audio.cpp:166

References state_audio::audio_receiver_thread_id, state_audio::audio_receiver_thread_started, state_audio::audio_sender_thread_id, and state_audio::audio_sender_thread_started.

Referenced by main(), and vidcap_ug_input_done().

◆ audio_register_aux_data()

void audio_register_aux_data ( struct state_audio * s,
struct additional_audio_data data )

Definition at line 1191 of file audio.cpp.

1193{
1195 auto *sdi_playback = (struct state_sdi_playback *)
1198 sdi_playback, data.display_callbacks.udata,
1199 (void (*)(void *, const struct audio_frame *))
1201 (bool (*)(void *, int, int,
1202 int)) data.display_callbacks.reconfigure,
1203 (bool (*)(void *, int, void *,
1204 size_t *)) data.display_callbacks.get_property);
1205 }
1206
1207 s->vrxtx = data.vrxtx;
1208}
void * audio_playback_get_state_pointer(struct state_audio_playback *s)
void sdi_register_display_callbacks(void *state, void *udata, void(*putf)(void *, const struct audio_frame *), bool(*reconfigure)(void *, int, int, int), bool(*get_property)(void *, int, void *, size_t *))
Definition sdi.c:117
struct additional_audio_data::@2 display_callbacks
void(* putf)(struct display *, const struct audio_frame *)
Definition audio.h:106
bool(* reconfigure)(struct display *, int, int, int)
Definition audio.h:107
bool(* get_property)(struct display *, int, void *, size_t *)
Definition audio.h:108
struct video_rxtx * vrxtx
Definition audio.h:110
struct used to comunicate with audio capture/playback device
Definition types.h:99
struct video_rxtx * vrxtx
Definition audio.cpp:186

References state_audio::audio_playback_device, audio_playback_get_display_flags(), audio_playback_get_state_pointer(), additional_audio_data::display_callbacks, additional_audio_data::get_property, additional_audio_data::putf, additional_audio_data::reconfigure, sdi_register_display_callbacks(), additional_audio_data::udata, additional_audio_data::vrxtx, and state_audio::vrxtx.

Referenced by main(), and vidcap_ug_input_init().

Here is the call graph for this function:

◆ audio_sdi_send()

void audio_sdi_send ( struct state_audio * s,
struct audio_frame * frame )

Definition at line 1179 of file audio.cpp.

1179 {
1180 void *sdi_capture;
1181 if (!s->audio_capture_device)
1182 return;
1184 return;
1185
1188}
struct video_frame * frame
unsigned int audio_capture_get_vidcap_flags(const char *const_device_name)
void * audio_capture_get_state_pointer(struct state_audio_capture *s)
const char * audio_capture_get_driver_name(struct state_audio_capture *s)
void sdi_capture_new_incoming_frame(void *state, struct audio_frame *frame)
Definition sdi.cpp:174

References state_audio::audio_capture_device, audio_capture_get_driver_name(), audio_capture_get_state_pointer(), audio_capture_get_vidcap_flags(), frame, and sdi_capture_new_incoming_frame().

Referenced by capture_thread().

Here is the call graph for this function:

◆ audio_start()

void audio_start ( struct state_audio * s)

Definition at line 463 of file audio.cpp.

463 {
464#ifdef HAVE_JACK_TRANS
465 if (s->sender == NET_JACK || s->receiver == NET_JACK) {
466 s->jack_connection = jack_start(s->proto_cfg.c_str());
467 if (s->jack_connection) {
469 s->sender = NET_NATIVE;
470 }
472 s->receiver = NET_NATIVE;
473 }
474 } else {
475 log_msg(LOG_LEVEL_FATAL, "JACK transport initialization failed!\n");
477 }
478 }
479#endif
480
481 if (s->audio_tx_mode & MODE_SENDER) {
482 if (pthread_create
483 (&s->audio_sender_thread_id, NULL, audio_sender_thread, (void *)s) != 0) {
484 log_msg(LOG_LEVEL_FATAL, "Error creating audio thread. Quitting\n");
486 } else {
487 s->audio_sender_thread_started = true;
488 }
489 }
490
491 if (s->audio_tx_mode & MODE_RECEIVER) {
492 if (pthread_create
493 (&s->audio_receiver_thread_id, NULL, audio_receiver_thread, (void *)s) != 0) {
494 log_msg(LOG_LEVEL_FATAL, "Error creating audio thread. Quitting\n");
496 } else {
497 s->audio_receiver_thread_started = true;
498 }
499 }
500}
static void * audio_sender_thread(void *arg)
Definition audio.cpp:1072
static void * audio_receiver_thread(void *arg)
Definition audio.cpp:695
#define LOG_LEVEL_FATAL
errors that prevent UG run
Definition debug.h:58
void exit_uv(int status)
Definition host.cpp:625
#define EXIT_FAIL_AUDIO
Definition host.h:70
void * jack_start(const char *cfg)
Definition jack.c:264
int is_jack_receiver(void *state)
Definition jack.c:426
int is_jack_sender(void *state)
Definition jack.c:421
void * jack_connection
Definition audio.cpp:153

References audio_receiver_thread(), state_audio::audio_receiver_thread_id, audio_sender_thread(), state_audio::audio_sender_thread_id, state_audio::audio_tx_mode, EXIT_FAIL_AUDIO, exit_uv(), is_jack_receiver(), is_jack_sender(), state_audio::jack_connection, jack_start(), LOG_LEVEL_FATAL, log_msg(), MODE_RECEIVER, MODE_SENDER, NET_JACK, NET_NATIVE, state_audio::proto_cfg, state_audio::receiver, and state_audio::sender.

Referenced by main(), vidcap_ug_input_init(), and write_video_frame().

Here is the call graph for this function:

◆ sdi_get_frame()

struct audio_frame * sdi_get_frame ( void * state)

◆ sdi_put_frame()

void sdi_put_frame ( void * state,
struct audio_frame * frame )

◆ sdp_send_change_address_message()

void sdp_send_change_address_message ( struct module * root,
const enum module_class * path,
const char * address )

Definition at line 238 of file audio.cpp.

241{
242 array<char, 1024> pathV{};
243
244 append_message_path(pathV.data(), pathV.size(), path);
245
246 // CHANGE DST ADDRESS
247 auto *msgV2 = reinterpret_cast<struct msg_sender *>(
248 new_message(sizeof(struct msg_sender)));
249 strncpy(static_cast<char *>(msgV2->receiver), address,
250 sizeof(msgV2->receiver) - 1);
251 msgV2->type = SENDER_MSG_CHANGE_RECEIVER;
252
253 auto *resp = send_message(root, pathV.data(),
254 reinterpret_cast<struct message *>(msgV2));
255 if (response_get_status(resp) == RESPONSE_OK) {
257 << "[SDP] Changing address to " << address << "\n";
258 } else {
260 << "[SDP] Unable to change address to " << address << " ("
261 << response_get_status(resp) << ")\n";
262 }
263 free_response(resp);
264}
static void new_message(struct module *m)
#define LOG_LEVEL_NOTICE
information that may be interesting
Definition debug.h:61
#define LOG_LEVEL_WARNING
less severe errors
Definition debug.h:60
void append_message_path(char *buf, int buflen, const enum module_class *modules)
Definition module.c:187
int response_get_status(struct response *r)
struct response * send_message(struct module *root, const char *const_path, struct message *msg)
Sends message without waiting for response.
void free_response(struct response *r)
@ SENDER_MSG_CHANGE_RECEIVER
Definition messaging.h:84
#define RESPONSE_OK
Definition messaging.h:57

References append_message_path(), free_response(), LOG, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, new_message(), response_get_status(), RESPONSE_OK, send_message(), and SENDER_MSG_CHANGE_RECEIVER.

Referenced by h264_sdp_video_rxtx::change_address_callback(), and sdp_change_address_callback().

Here is the call graph for this function: