/*!
* \brief orginate a call from the CLI
* \param fd file descriptor for cli
* \param chan channel to create type/data
* \param app application you want to run
* \param appdata data for application
* \retval CLI_SUCCESS on success.
* \retval CLI_SHOWUSAGE on failure.
*/
static char *orig_app(int fd, const char *chan, const char *app, const char *appdata)
{
char *chantech;
char *chandata;
int reason = 0;
struct ast_format_cap *cap;
if (ast_strlen_zero(app))
return CLI_SHOWUSAGE;
chandata = ast_strdupa(chan);
chantech = strsep(&chandata, "/");
if (!chandata) {
ast_cli(fd, "*** No data provided after channel type! ***\n");
return CLI_SHOWUSAGE;
}
if (!(cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
return CLI_FAILURE;
}
ast_format_cap_append(cap, ast_format_slin, 0);
ast_pbx_outgoing_app(chantech, cap, chandata, TIMEOUT * 1000, app, appdata,
&reason, AST_OUTGOING_NO_WAIT, NULL, NULL, NULL, NULL,
NULL, NULL);
ao2_ref(cap, -1);
return CLI_SUCCESS;
}
/*!
* \brief orginate from extension
* \param fd file descriptor for cli
* \param chan channel to create type/data
* \param data contains exten\@context
* \retval CLI_SUCCESS on success.
* \retval CLI_SHOWUSAGE on failure.
*/
static char *orig_exten(int fd, const char *chan, const char *data)
{
char *chantech;
char *chandata;
char *exten = NULL;
char *context = NULL;
int reason = 0;
struct ast_format_cap *cap;
chandata = ast_strdupa(chan);
chantech = strsep(&chandata, "/");
if (!chandata) {
ast_cli(fd, "*** No data provided after channel type! ***\n");
return CLI_SHOWUSAGE;
}
if (!ast_strlen_zero(data)) {
context = ast_strdupa(data);
exten = strsep(&context, "@");
}
if (ast_strlen_zero(exten))
exten = "s";
if (ast_strlen_zero(context))
context = "default";
if (!(cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
return CLI_FAILURE;
}
ast_format_cap_append(cap, ast_format_slin, 0);
ast_pbx_outgoing_exten(chantech, cap, chandata, TIMEOUT * 1000, context, exten, 1, &reason, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL);
ao2_ref(cap, -1);
return CLI_SUCCESS;
}
/** \brief Load module */
static int load_module(void)
{
ast_log(LOG_NOTICE, "Load Res-Speech-UniMRCP module\n");
if(uni_engine_load() == FALSE) {
return AST_MODULE_LOAD_FAILURE;
}
if(mrcp_client_start(uni_engine.client) != TRUE) {
ast_log(LOG_ERROR, "Failed to start MRCP client\n");
uni_engine_unload();
return AST_MODULE_LOAD_FAILURE;
}
#if AST_VERSION_AT_LEAST(10,0,0)
#if AST_VERSION_AT_LEAST(13,0,0)
ast_engine.formats = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
#elif AST_VERSION_AT_LEAST(12,0,0)
ast_engine.formats = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_NOLOCK);
#else /* <= 11 */
ast_engine.formats = ast_format_cap_alloc_nolock();
#endif
if(!ast_engine.formats) {
ast_log(LOG_ERROR, "Failed to alloc media format capabilities\n");
uni_engine_unload();
return AST_MODULE_LOAD_FAILURE;
}
#if AST_VERSION_AT_LEAST(13,0,0)
ast_format_cap_append(ast_engine.formats, ast_format_slin, 0);
#else
struct ast_format format;
ast_format_set(&format, AST_FORMAT_SLINEAR, 0);
ast_format_cap_add(ast_engine.formats, &format);
#endif
#else /* <= 1.8 */
ast_engine.formats = AST_FORMAT_SLINEAR;
#endif
if(ast_speech_register(&ast_engine)) {
ast_log(LOG_ERROR, "Failed to register module\n");
mrcp_client_shutdown(uni_engine.client);
uni_engine_unload();
return AST_MODULE_LOAD_FAILURE;
}
return AST_MODULE_LOAD_SUCCESS;
}
int iax2_format_compatibility_bitfield2cap(uint64_t bitfield, struct ast_format_cap *cap)
{
int bit;
for (bit = 0; bit < 64; ++bit) {
uint64_t mask = (1ULL << bit);
if (mask & bitfield) {
struct ast_format *format;
format = ast_format_compatibility_bitfield2format(mask);
if (format && ast_format_cap_append(cap, format, 0)) {
return -1;
}
}
}
return 0;
}
static struct ast_channel *prepare_bridge_media_channel(const char *type)
{
RAII_VAR(struct ast_format_cap *, cap, NULL, ao2_cleanup);
struct ast_channel *chan;
cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!cap) {
return NULL;
}
ast_format_cap_append(cap, ast_format_slin, 0);
chan = ast_request(type, cap, NULL, NULL, "ARI", NULL);
if (!chan) {
return NULL;
}
if (stasis_app_channel_unreal_set_internal(chan)) {
ast_channel_cleanup(chan);
return NULL;
}
return chan;
}
static void ari_channels_handle_originate_with_id(const char *args_endpoint,
const char *args_extension,
const char *args_context,
long args_priority,
const char *args_app,
const char *args_app_args,
const char *args_caller_id,
int args_timeout,
struct ast_variable *variables,
const char *args_channel_id,
const char *args_other_channel_id,
const char *args_originator,
struct ast_ari_response *response)
{
char *dialtech;
char dialdevice[AST_CHANNEL_NAME];
struct ast_dial *dial;
char *caller_id = NULL;
char *cid_num = NULL;
char *cid_name = NULL;
RAII_VAR(struct ast_format_cap *, cap,
ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
char *stuff;
struct ast_channel *other = NULL;
struct ast_channel *chan;
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
struct ast_assigned_ids assignedids = {
.uniqueid = args_channel_id,
.uniqueid2 = args_other_channel_id,
};
struct ari_origination *origination;
pthread_t thread;
if (!cap) {
ast_ari_response_alloc_failed(response);
return;
}
ast_format_cap_append(cap, ast_format_slin, 0);
if ((assignedids.uniqueid && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid))
|| (assignedids.uniqueid2 && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid2))) {
ast_ari_response_error(response, 400, "Bad Request",
"Uniqueid length exceeds maximum of %d", AST_MAX_PUBLIC_UNIQUEID);
return;
}
if (ast_strlen_zero(args_endpoint)) {
ast_ari_response_error(response, 400, "Bad Request",
"Endpoint must be specified");
return;
}
dialtech = ast_strdupa(args_endpoint);
if ((stuff = strchr(dialtech, '/'))) {
*stuff++ = '\0';
ast_copy_string(dialdevice, stuff, sizeof(dialdevice));
}
if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
ast_ari_response_error(response, 400, "Bad Request",
"Invalid endpoint specified");
return;
}
if (!ast_strlen_zero(args_app)) {
RAII_VAR(struct ast_str *, appdata, ast_str_create(64), ast_free);
if (!appdata) {
ast_ari_response_alloc_failed(response);
return;
}
ast_str_set(&appdata, 0, "%s", args_app);
if (!ast_strlen_zero(args_app_args)) {
ast_str_append(&appdata, 0, ",%s", args_app_args);
}
origination = ast_calloc(1, sizeof(*origination) + ast_str_size(appdata) + 1);
if (!origination) {
ast_ari_response_alloc_failed(response);
return;
}
strcpy(origination->appdata, ast_str_buffer(appdata));
} else if (!ast_strlen_zero(args_extension)) {
static int set_caps(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
const struct pjmedia_sdp_media *stream)
{
RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
RAII_VAR(struct ast_format_cap *, peer, NULL, ao2_cleanup);
RAII_VAR(struct ast_format_cap *, joint, NULL, ao2_cleanup);
enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
struct ast_rtp_codecs codecs = AST_RTP_CODECS_NULL_INIT;
int fmts = 0;
int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
ast_format_cap_count(session->direct_media_cap);
if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
!(peer = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
!(joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
return -1;
}
/* get the endpoint capabilities */
if (direct_media_enabled) {
ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
format_cap_only_type(caps, media_type);
} else {
ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
}
/* get the capabilities on the peer */
get_codecs(session, stream, &codecs);
ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
/* get the joint capabilities between peer and endpoint */
ast_format_cap_get_compatible(caps, peer, joint);
if (!ast_format_cap_count(joint)) {
struct ast_str *usbuf = ast_str_alloca(64);
struct ast_str *thembuf = ast_str_alloca(64);
ast_rtp_codecs_payloads_destroy(&codecs);
ast_log(LOG_NOTICE, "No joint capabilities for '%s' media stream between our configuration(%s) and incoming SDP(%s)\n",
session_media->stream_type,
ast_format_cap_get_names(caps, &usbuf),
ast_format_cap_get_names(peer, &thembuf));
return -1;
}
ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
session_media->rtp);
ast_format_cap_append_from_cap(session->req_caps, joint, AST_MEDIA_TYPE_UNKNOWN);
if (session->channel) {
struct ast_format *fmt;
ast_channel_lock(session->channel);
ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel), AST_MEDIA_TYPE_UNKNOWN);
ast_format_cap_remove_by_type(caps, media_type);
/*
* XXX Historically we picked the "best" joint format to use
* and stuck with it. It would be nice to just append the
* determined joint media capabilities to give translation
* more formats to choose from when necessary. Unfortunately,
* there are some areas of the system where this doesn't work
* very well. (The softmix bridge in particular is reluctant
* to pick higher fidelity formats and has a problem with
* asymmetric sample rates.)
*/
fmt = ast_format_cap_get_format(joint, 0);
ast_format_cap_append(caps, fmt, 0);
/*
* Apply the new formats to the channel, potentially changing
* raw read/write formats and translation path while doing so.
*/
ast_channel_nativeformats_set(session->channel, caps);
ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
ast_channel_unlock(session->channel);
ao2_ref(fmt, -1);
}
ast_rtp_codecs_payloads_destroy(&codecs);
return 0;
}
static int container_test1_helper(struct ast_format_cap *cap1, struct ast_format_cap *cap2, struct ast_test *test)
{
int res = AST_TEST_PASS;
struct ast_format_cap *cap_joint = NULL;
struct ast_format tmpformat;
if (ast_format_attr_reg_interface(&test_interface)) {
ast_test_status_update(test, "test_interface failed to register.\n");
ast_format_cap_destroy(cap1);
ast_format_cap_destroy(cap2);
return AST_TEST_FAIL;
}
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_ULAW, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_G722, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_ALAW, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_H264, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_H263, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_T140, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_JPEG, 0));
ast_format_cap_add(cap1, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_STRING, "testing caps hooray",
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_16KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_32KHZ,
AST_FORMAT_ATTR_END));
/* Test is compatible */
if (!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_ALAW, 0)) ||
!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_ULAW, 0)) ||
!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0)) ||
!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_H264, 0)) ||
!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_JPEG, 0)) ||
!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_T140, 0))) {
ast_test_status_update(test, "ast cap1 failed to properly detect compatibility test 1.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Test things that are not compatible */
if (ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_SPEEX, 0)) ||
ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_SPEEX16, 0)) ||
ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_H261, 0))) {
ast_test_status_update(test, "ast cap1 failed to properly detect compatibility test 2.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Test compatiblity with format with attributes. */
if (!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_STRING, "testing caps hooray",
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_16KHZ,
AST_FORMAT_ATTR_END))) {
ast_test_status_update(test, "ast cap1 failed to properly detect compatibility test 3.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
if (!ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
AST_FORMAT_ATTR_END))) {
ast_test_status_update(test, "ast cap1 failed to properly detect compatibility test 4.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
if (ast_format_cap_iscompatible(cap1, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_48KHZ, /* 48khz was not compatible, so this should fail iscompatible check */
AST_FORMAT_ATTR_END))) {
ast_test_status_update(test, "ast cap1 failed to properly detect compatibility test 5.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Lets start testing the functions that compare ast_format_cap objects.
* Genreate the cap2 object to contain some similar formats as cap1
* and some different formats as well. */
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0));
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_ULAW, 0));
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_SIREN7, 0));
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_H261, 0));
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_T140, 0));
ast_format_cap_add(cap2, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_STRING, "testing caps hooray",
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_12KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_16KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_32KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_48KHZ,
AST_FORMAT_ATTR_END));
/* find joint formats between cap1 and cap2 */
cap_joint = ast_format_cap_joint(cap1, cap2);
if (!cap_joint) {
ast_test_status_update(test, "failed to create joint capabilities correctly.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* determine if cap_joint is what we think it should be */
if (!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0)) ||
!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_ULAW, 0)) ||
!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_T140, 0)) ||
!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_STRING, "testing caps hooray",
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_16KHZ,
AST_FORMAT_ATTR_END))) {
ast_test_status_update(test, "ast cap_joint failed to properly detect compatibility test 1.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* make sure joint cap does not have formats that should not be there */
if (ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_SIREN7, 0)) ||
ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_TESTLAW, 1,
TEST_ATTR_KEY_STRING, "testing caps hooray",
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_8KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_16KHZ,
TEST_ATTR_KEY_SAMP_RATE, TEST_ATTR_VAL_SAMP_48KHZ,
AST_FORMAT_ATTR_END))) {
ast_test_status_update(test, "ast cap_joint failed to properly detect compatibility test 1.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Lets test removing a capability */
if (ast_format_cap_remove(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_T140, 0))) {
ast_test_status_update(test, "ast_format_cap_remove failed. \n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Lets make sure what we just removed does not still exist */
if (ast_format_cap_iscompatible(cap_joint, &tmpformat)) {
ast_test_status_update(test, "ast_format_cap_remove failed 2. \n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Lets test removing a capability by id.*/
if (ast_format_cap_remove_byid(cap_joint, AST_FORMAT_GSM)) {
ast_test_status_update(test, "ast_format_cap_remove failed 3. \n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* Lets make sure what we just removed does not still exist */
if (ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0))) {
ast_test_status_update(test, "ast_format_cap_remove failed 4. \n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* lets test getting joint formats by type */
ast_format_cap_destroy(cap_joint);
if (!(cap_joint = ast_format_cap_get_type(cap1, AST_FORMAT_TYPE_VIDEO))) {
ast_test_status_update(test, "ast_format_cap_get_type failed.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* lets make sure our joint capability structure has what we expect */
if (!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_H264, 0)) ||
!ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_H263, 0))) {
ast_test_status_update(test, "get_type failed 2.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* now make sure joint does not have anything but video */
if (ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_ALAW, 0)) ||
ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_ULAW, 0)) ||
ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_GSM, 0)) ||
ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_JPEG, 0)) ||
ast_format_cap_iscompatible(cap_joint, ast_format_set(&tmpformat, AST_FORMAT_T140, 0))) {
ast_test_status_update(test, "get_type failed 3.\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* now lets remove everythign from cap_joint */
ast_format_cap_remove_all(cap_joint);
if (!ast_format_cap_is_empty(cap_joint)) {
ast_test_status_update(test, "failed to remove all\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* now lets add all by type */
ast_format_cap_add_all_by_type(cap_joint, AST_FORMAT_TYPE_AUDIO);
if (ast_format_cap_is_empty(cap_joint)) {
ast_test_status_update(test, "failed to add all by type AUDIO\n");
res = AST_TEST_FAIL;
}
ast_format_cap_iter_start(cap_joint);
while (!(ast_format_cap_iter_next(cap_joint, &tmpformat))) {
if (AST_FORMAT_GET_TYPE(tmpformat.id) != AST_FORMAT_TYPE_AUDIO) {
ast_test_status_update(test, "failed to add all by type AUDIO\n");
res = AST_TEST_FAIL;
ast_format_cap_iter_end(cap_joint);
goto test3_cleanup;
}
}
ast_format_cap_iter_end(cap_joint);
/* test append */
ast_format_cap_append(cap_joint, cap1);
ast_format_cap_iter_start(cap1);
while (!(ast_format_cap_iter_next(cap1, &tmpformat))) {
if (!ast_format_cap_iscompatible(cap_joint, &tmpformat)) {
ast_test_status_update(test, "failed to append format capabilities.\n");
res = AST_TEST_FAIL;
ast_format_cap_iter_end(cap1);
goto test3_cleanup;
}
}
ast_format_cap_iter_end(cap1);
/* test copy */
cap1 = ast_format_cap_destroy(cap1);
cap1 = ast_format_cap_dup(cap_joint);
if (!ast_format_cap_identical(cap_joint, cap1)) {
ast_test_status_update(test, "failed to copy capabilities\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
/* test remove by type */
ast_format_cap_remove_bytype(cap_joint, AST_FORMAT_TYPE_AUDIO);
if (ast_format_cap_has_type(cap_joint, AST_FORMAT_TYPE_AUDIO)) {
ast_test_status_update(test, "failed to remove all by type audio\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
if (!ast_format_cap_has_type(cap_joint, AST_FORMAT_TYPE_TEXT)) { /* it should still have text */
ast_test_status_update(test, "failed to remove all by type audio\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
ast_format_cap_iter_start(cap_joint);
while (!(ast_format_cap_iter_next(cap_joint, &tmpformat))) {
if (AST_FORMAT_GET_TYPE(tmpformat.id) == AST_FORMAT_TYPE_AUDIO) {
ast_test_status_update(test, "failed to remove all by type audio\n");
res = AST_TEST_FAIL;
ast_format_cap_iter_end(cap_joint);
goto test3_cleanup;
}
}
ast_format_cap_iter_end(cap_joint);
/* test add all */
ast_format_cap_remove_all(cap_joint);
ast_format_cap_add_all(cap_joint);
{
int video = 0, audio = 0, text = 0, image = 0;
ast_format_cap_iter_start(cap_joint);
while (!(ast_format_cap_iter_next(cap_joint, &tmpformat))) {
switch (AST_FORMAT_GET_TYPE(tmpformat.id)) {
case AST_FORMAT_TYPE_AUDIO:
audio++;
break;
case AST_FORMAT_TYPE_VIDEO:
video++;
break;
case AST_FORMAT_TYPE_TEXT:
text++;
break;
case AST_FORMAT_TYPE_IMAGE:
image++;
break;
}
}
ast_format_cap_iter_end(cap_joint);
if (!video || !audio || !text || !image) {
ast_test_status_update(test, "failed to add all\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
}
/* test copy2 */
ast_format_cap_copy(cap2, cap_joint);
if (!ast_format_cap_identical(cap2, cap_joint)) {
ast_test_status_update(test, "ast_format_cap_copy failed\n");
res = AST_TEST_FAIL;
goto test3_cleanup;
}
test3_cleanup:
ast_format_cap_destroy(cap1);
ast_format_cap_destroy(cap2);
ast_format_cap_destroy(cap_joint);
/* unregister interface */
if (ast_format_attr_unreg_interface(&test_interface)) {
ast_test_status_update(test, "test_interface failed to unregister.\n");
res = AST_TEST_FAIL;
}
return res;
}
static int set_caps(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
const struct pjmedia_sdp_media *stream)
{
RAII_VAR(struct ast_format_cap *, caps, NULL, ast_format_cap_destroy);
RAII_VAR(struct ast_format_cap *, peer, NULL, ast_format_cap_destroy);
RAII_VAR(struct ast_format_cap *, joint, NULL, ast_format_cap_destroy);
enum ast_format_type media_type = stream_to_media_type(session_media->stream_type);
struct ast_rtp_codecs codecs;
struct ast_format fmt;
int fmts = 0;
int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
!ast_format_cap_is_empty(session->direct_media_cap);
if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_NOLOCK)) ||
!(peer = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_NOLOCK))) {
ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
return -1;
}
/* get the endpoint capabilities */
if (direct_media_enabled) {
ast_format_cap_joint_copy(session->endpoint->media.codecs, session->direct_media_cap, caps);
} else {
ast_format_cap_copy(caps, session->endpoint->media.codecs);
}
format_cap_only_type(caps, media_type);
/* get the capabilities on the peer */
get_codecs(session, stream, &codecs);
ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
/* get the joint capabilities between peer and endpoint */
if (!(joint = ast_format_cap_joint(caps, peer))) {
char usbuf[64], thembuf[64];
ast_rtp_codecs_payloads_destroy(&codecs);
ast_getformatname_multiple(usbuf, sizeof(usbuf), caps);
ast_getformatname_multiple(thembuf, sizeof(thembuf), peer);
ast_log(LOG_WARNING, "No joint capabilities between our configuration(%s) and incoming SDP(%s)\n", usbuf, thembuf);
return -1;
}
ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
session_media->rtp);
ast_format_cap_copy(caps, session->req_caps);
ast_format_cap_remove_bytype(caps, media_type);
ast_format_cap_append(caps, joint);
ast_format_cap_append(session->req_caps, caps);
if (session->channel) {
ast_format_cap_copy(caps, ast_channel_nativeformats(session->channel));
ast_format_cap_remove_bytype(caps, media_type);
ast_codec_choose(&session->endpoint->media.prefs, joint, 1, &fmt);
ast_format_cap_add(caps, &fmt);
/* Apply the new formats to the channel, potentially changing read/write formats while doing so */
ast_format_cap_copy(ast_channel_nativeformats(session->channel), caps);
ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
}
ast_rtp_codecs_payloads_destroy(&codecs);
return 0;
}
struct ast_channel *stasis_app_control_snoop(struct ast_channel *chan,
enum stasis_app_snoop_direction spy, enum stasis_app_snoop_direction whisper,
const char *app, const char *app_args, const char *snoop_id)
{
RAII_VAR(struct stasis_app_snoop *, snoop, NULL, ao2_cleanup);
struct ast_format_cap *caps;
pthread_t thread;
struct ast_assigned_ids assignedids = {
.uniqueid = snoop_id,
};
if (spy == STASIS_SNOOP_DIRECTION_NONE &&
whisper == STASIS_SNOOP_DIRECTION_NONE) {
return NULL;
}
snoop = ao2_alloc_options(sizeof(*snoop), snoop_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!snoop) {
return NULL;
}
/* Allocate a buffer to store the Stasis application and arguments in */
snoop->app = ast_str_create(64);
if (!snoop->app) {
return NULL;
}
ast_str_set(&snoop->app, 0, "%s", app);
if (!ast_strlen_zero(app_args)) {
ast_str_append(&snoop->app, 0, ",%s", app_args);
}
/* Set up a timer for the Snoop channel so it wakes up at a specific interval */
snoop->timer = ast_timer_open();
if (!snoop->timer) {
return NULL;
}
ast_timer_set_rate(snoop->timer, 1000 / SNOOP_INTERVAL);
/* Determine which signed linear format should be used */
snoop_determine_format(chan, snoop);
/* Allocate a Snoop channel and set up various parameters */
snoop->chan = ast_channel_alloc(1, AST_STATE_UP, "", "", "", "", "", &assignedids, NULL, 0, "Snoop/%s-%08x", ast_channel_uniqueid(chan),
(unsigned)ast_atomic_fetchadd_int((int *)&chan_idx, +1));
if (!snoop->chan) {
return NULL;
}
ast_copy_string(snoop->uniqueid, ast_channel_uniqueid(chan), sizeof(snoop->uniqueid));
/* To keep the channel valid on the Snoop structure until it is destroyed we bump the ref up here */
ast_channel_ref(snoop->chan);
ast_channel_tech_set(snoop->chan, &snoop_tech);
ao2_ref(snoop, +1);
ast_channel_tech_pvt_set(snoop->chan, snoop);
ast_channel_set_fd(snoop->chan, 0, ast_timer_fd(snoop->timer));
/* The format on the Snoop channel will be this signed linear format, and it will never change */
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!caps) {
ast_channel_unlock(snoop->chan);
ast_hangup(snoop->chan);
return NULL;
}
ast_format_cap_append(caps, snoop->spy_format, 0);
ast_channel_nativeformats_set(snoop->chan, caps);
ao2_ref(caps, -1);
ast_channel_set_writeformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawwriteformat(snoop->chan, snoop->spy_format);
ast_channel_set_readformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawreadformat(snoop->chan, snoop->spy_format);
ast_channel_unlock(snoop->chan);
if (spy != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_SPY, spy, &snoop->spy_direction, &snoop->spy)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->spy_samples = ast_format_get_sample_rate(snoop->spy_format) / (1000 / SNOOP_INTERVAL);
snoop->spy_active = 1;
}
/* If whispering is enabled set up the audiohook */
if (whisper != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_WHISPER, whisper, &snoop->whisper_direction, &snoop->whisper)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->whisper_active = 1;
}
/* Create the thread which services the Snoop channel */
ao2_ref(snoop, +1);
if (ast_pthread_create_detached_background(&thread, NULL, snoop_stasis_thread, snoop)) {
ao2_cleanup(snoop);
/* No other thread is servicing this channel so we can immediately hang it up */
ast_hangup(snoop->chan);
return NULL;
}
publish_chanspy_message(snoop, 1);
/* The caller of this has a reference as well */
return ast_channel_ref(snoop->chan);
}