/* caller has the playlist locked */
static int gen_nextfile(struct gen_state *state)
{
struct ivr_localuser *u = state->u;
char *file_to_stream;
u->abort_current_sound = 0;
u->playing_silence = 0;
gen_closestream(state);
while (!state->stream) {
state->current = AST_LIST_FIRST(&u->playlist);
if (state->current) {
file_to_stream = state->current->filename;
} else {
file_to_stream = "silence/10";
u->playing_silence = 1;
}
if (!(state->stream = ast_openstream_full(u->chan, file_to_stream, u->chan->language, 1))) {
ast_chan_log(LOG_WARNING, u->chan, "File '%s' could not be opened: %s\n", file_to_stream, strerror(errno));
AST_LIST_LOCK(&u->playlist);
AST_LIST_REMOVE_HEAD(&u->playlist, list);
AST_LIST_UNLOCK(&u->playlist);
if (!u->playing_silence) {
continue;
} else {
break;
}
}
}
return (!state->stream);
}
static struct ast_frame *gen_readframe(struct gen_state *state)
{
struct ast_frame *f = NULL;
struct ivr_localuser *u = state->u;
if (u->abort_current_sound ||
(u->playing_silence && AST_LIST_FIRST(&u->playlist))) {
gen_closestream(state);
AST_LIST_LOCK(&u->playlist);
gen_nextfile(state);
AST_LIST_UNLOCK(&u->playlist);
}
if (!(state->stream && (f = ast_readframe(state->stream)))) {
if (state->current) {
AST_LIST_LOCK(&u->finishlist);
AST_LIST_INSERT_TAIL(&u->finishlist, state->current, list);
AST_LIST_UNLOCK(&u->finishlist);
state->current = NULL;
}
if (!gen_nextfile(state))
f = ast_readframe(state->stream);
}
return f;
}
static void native_rtp_bridge_stop(struct ast_bridge *bridge, struct ast_channel *target)
{
struct ast_bridge_channel *bc0 = AST_LIST_FIRST(&bridge->channels);
struct ast_bridge_channel *bc1 = AST_LIST_LAST(&bridge->channels);
enum ast_rtp_glue_result native_type;
struct ast_rtp_glue *glue0, *glue1 = NULL;
RAII_VAR(struct ast_rtp_instance *, instance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, instance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance1, NULL, ao2_cleanup);
if (bc0 == bc1) {
return;
}
ast_channel_lock_both(bc0->chan, bc1->chan);
native_type = native_rtp_bridge_get(bc0->chan, bc1->chan, &glue0, &glue1, &instance0, &instance1, &vinstance0, &vinstance1);
switch (native_type) {
case AST_RTP_GLUE_RESULT_LOCAL:
if (ast_rtp_instance_get_engine(instance0)->local_bridge) {
ast_rtp_instance_get_engine(instance0)->local_bridge(instance0, NULL);
}
if (instance1 && ast_rtp_instance_get_engine(instance1)->local_bridge) {
ast_rtp_instance_get_engine(instance1)->local_bridge(instance1, NULL);
}
ast_rtp_instance_set_bridged(instance0, NULL);
if (instance1) {
ast_rtp_instance_set_bridged(instance1, NULL);
}
break;
case AST_RTP_GLUE_RESULT_REMOTE:
if (target) {
/*
* If a target was provided, it is being put on hold and should expect to
* receive media from Asterisk instead of what it was previously connected to.
*/
if (bc0->chan == target) {
glue0->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
} else {
glue1->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
}
}
break;
case AST_RTP_GLUE_RESULT_FORBID:
break;
}
if (!target && native_type != AST_RTP_GLUE_RESULT_FORBID) {
glue0->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
glue1->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
}
ast_debug(2, "Discontinued RTP bridging of '%s' and '%s' - media will flow through Asterisk core\n",
ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
ast_channel_unlock(bc0->chan);
ast_channel_unlock(bc1->chan);
}
/*! \brief Write function for writing frames into the bridge */
static enum ast_bridge_write_result multiplexed_bridge_write(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
{
struct ast_bridge_channel *other;
if (AST_LIST_FIRST(&bridge->channels) == AST_LIST_LAST(&bridge->channels)) {
return AST_BRIDGE_WRITE_FAILED;
}
if (!(other = (AST_LIST_FIRST(&bridge->channels) == bridge_channel ? AST_LIST_LAST(&bridge->channels) : AST_LIST_FIRST(&bridge->channels)))) {
return AST_BRIDGE_WRITE_FAILED;
}
if (other->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
ast_write(other->chan, frame);
}
return AST_BRIDGE_WRITE_SUCCESS;
}
/*!
* \internal
* \brief Merge the given sorted sublists into sorted order onto the end of the list.
*
* \param list Merge sublists onto this list.
* \param sub1 First sublist to merge.
* \param sub2 Second sublist to merge.
*
* \return Nothing
*/
static void mm_atexit_list_merge(struct region_list *list, struct region_list *sub1, struct region_list *sub2)
{
struct ast_region *reg;
for (;;) {
if (AST_LIST_EMPTY(sub1)) {
/* The remaining sublist goes onto the list. */
AST_LIST_APPEND_LIST(list, sub2, node);
break;
}
if (AST_LIST_EMPTY(sub2)) {
/* The remaining sublist goes onto the list. */
AST_LIST_APPEND_LIST(list, sub1, node);
break;
}
if (mm_atexit_cmp(AST_LIST_FIRST(sub1), AST_LIST_FIRST(sub2)) <= 0) {
reg = AST_LIST_REMOVE_HEAD(sub1, node);
} else {
reg = AST_LIST_REMOVE_HEAD(sub2, node);
}
AST_LIST_INSERT_TAIL(list, reg, node);
}
}
/*! \brief Attended transfer abort feature */
static int attended_abort_transfer(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, void *hook_pvt)
{
struct ast_bridge_channel *called_bridge_channel = NULL;
/* It is possible (albeit unlikely) that the bridge channels list may change, so we have to ensure we do all of our magic while locked */
ao2_lock(bridge);
if (AST_LIST_FIRST(&bridge->channels) != bridge_channel) {
called_bridge_channel = AST_LIST_FIRST(&bridge->channels);
} else {
called_bridge_channel = AST_LIST_LAST(&bridge->channels);
}
/* Now we basically eject the other channel from the bridge. This will cause their thread to hang them up, and our own code to consider the transfer failed. */
if (called_bridge_channel) {
ast_bridge_change_state(called_bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
}
ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
ao2_unlock(bridge);
return 0;
}
static int simple_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{
struct ast_channel *c0 = AST_LIST_FIRST(&bridge->channels)->chan;
struct ast_channel *c1 = AST_LIST_LAST(&bridge->channels)->chan;
/*
* If this is the first channel we can't make it compatible...
* unless we make it compatible with itself. O.o
*/
if (c0 == c1) {
return 0;
}
return ast_channel_make_compatible(c0, c1);
}
/*! \brief Join function which actually adds the channel into the array to be monitored */
static int multiplexed_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{
struct ast_channel *c0 = AST_LIST_FIRST(&bridge->channels)->chan, *c1 = AST_LIST_LAST(&bridge->channels)->chan;
struct multiplexed_thread *multiplexed_thread = bridge->bridge_pvt;
ast_debug(1, "Adding channel '%s' to multiplexed thread '%p' for monitoring\n", bridge_channel->chan->name, multiplexed_thread);
multiplexed_add_or_remove(multiplexed_thread, bridge_channel->chan, 1);
/* If the second channel has not yet joined do not make things compatible */
if (c0 == c1) {
return 0;
}
if (((c0->writeformat == c1->readformat) && (c0->readformat == c1->writeformat) && (c0->nativeformats == c1->nativeformats))) {
return 0;
}
return ast_channel_make_compatible(c0, c1);
}
static int native_rtp_bridge_compatible(struct ast_bridge *bridge)
{
struct ast_bridge_channel *bc0;
struct ast_bridge_channel *bc1;
int is_compatible;
/* We require two channels before even considering native bridging */
if (bridge->num_channels != 2) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as two channels are required\n",
bridge->uniqueid);
return 0;
}
bc0 = AST_LIST_FIRST(&bridge->channels);
bc1 = AST_LIST_LAST(&bridge->channels);
ast_channel_lock_both(bc0->chan, bc1->chan);
is_compatible = native_rtp_bridge_compatible_check(bridge, bc0, bc1);
ast_channel_unlock(bc0->chan);
ast_channel_unlock(bc1->chan);
return is_compatible;
}
/*!
* \internal
* \note This function assumes that we're only called from the "outbound" local channel side
*
* \note it is assummed p is locked and reffed before entering this function
*/
static void check_bridge(struct ast_channel *ast, struct local_pvt *p)
{
struct ast_channel *owner;
struct ast_channel *chan;
struct ast_channel *bridged_chan;
struct ast_frame *f;
/* Do a few conditional checks early on just to see if this optimization is possible */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner) {
return;
}
/* Safely get the channel bridged to p->chan */
chan = ast_channel_ref(p->chan);
ao2_unlock(p); /* don't call bridged channel with the pvt locked */
bridged_chan = ast_bridged_channel(chan);
ao2_lock(p);
chan = ast_channel_unref(chan);
/* since we had to unlock p to get the bridged chan, validate our
* data once again and verify the bridged channel is what we expect
* it to be in order to perform this optimization */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner
|| (ast_channel_internal_bridged_channel(p->chan) != bridged_chan)) {
return;
}
/* only do the masquerade if we are being called on the outbound channel,
if it has been bridged to another channel and if there are no pending
frames on the owner channel (because they would be transferred to the
outbound channel during the masquerade)
*/
if (!ast_channel_internal_bridged_channel(p->chan) /* Not ast_bridged_channel! Only go one step! */
|| !AST_LIST_EMPTY(ast_channel_readq(p->owner))
|| ast != p->chan /* Sanity check (should always be false) */) {
return;
}
/* Masquerade bridged channel into owner */
/* Lock everything we need, one by one, and give up if
we can't get everything. Remember, we'll get another
chance in just a little bit */
if (ast_channel_trylock(ast_channel_internal_bridged_channel(p->chan))) {
return;
}
if (ast_check_hangup(ast_channel_internal_bridged_channel(p->chan))
|| ast_channel_trylock(p->owner)) {
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/*
* At this point we have 4 locks:
* p, p->chan (same as ast), p->chan->_bridge, p->owner
*
* Flush a voice or video frame on the outbound channel to make
* the queue empty faster so we can get optimized out.
*/
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
AST_LIST_REMOVE_HEAD(ast_channel_readq(p->chan), frame_list);
ast_frfree(f);
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
}
if (f
|| ast_check_hangup(p->owner)
|| ast_channel_masquerade(p->owner, ast_channel_internal_bridged_channel(p->chan))) {
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/* Masquerade got setup. */
ast_debug(4, "Masquerading %s <- %s\n",
ast_channel_name(p->owner),
ast_channel_name(ast_channel_internal_bridged_channel(p->chan)));
if (ast_channel_monitor(p->owner)
&& !ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan))) {
struct ast_channel_monitor *tmp;
/* If a local channel is being monitored, we don't want a masquerade
* to cause the monitor to go away. Since the masquerade swaps the monitors,
* pre-swapping the monitors before the masquerade will ensure that the monitor
* ends up where it is expected.
*/
tmp = ast_channel_monitor(p->owner);
ast_channel_monitor_set(p->owner, ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan)));
ast_channel_monitor_set(ast_channel_internal_bridged_channel(p->chan), tmp);
}
if (ast_channel_audiohooks(p->chan)) {
struct ast_audiohook_list *audiohooks_swapper;
audiohooks_swapper = ast_channel_audiohooks(p->chan);
ast_channel_audiohooks_set(p->chan, ast_channel_audiohooks(p->owner));
ast_channel_audiohooks_set(p->owner, audiohooks_swapper);
}
/* If any Caller ID was set, preserve it after masquerade like above. We must check
* to see if Caller ID was set because otherwise we'll mistakingly copy info not
* set from the dialplan and will overwrite the real channel Caller ID. The reason
* for this whole preswapping action is because the Caller ID is set on the channel
* thread (which is the to be masqueraded away local channel) before both local
* channels are optimized away.
*/
if (ast_channel_caller(p->owner)->id.name.valid || ast_channel_caller(p->owner)->id.number.valid
|| ast_channel_caller(p->owner)->id.subaddress.valid || ast_channel_caller(p->owner)->ani.name.valid
|| ast_channel_caller(p->owner)->ani.number.valid || ast_channel_caller(p->owner)->ani.subaddress.valid) {
SWAP(*ast_channel_caller(p->owner), *ast_channel_caller(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_redirecting(p->owner)->from.name.valid || ast_channel_redirecting(p->owner)->from.number.valid
|| ast_channel_redirecting(p->owner)->from.subaddress.valid || ast_channel_redirecting(p->owner)->to.name.valid
|| ast_channel_redirecting(p->owner)->to.number.valid || ast_channel_redirecting(p->owner)->to.subaddress.valid) {
SWAP(*ast_channel_redirecting(p->owner), *ast_channel_redirecting(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_dialed(p->owner)->number.str || ast_channel_dialed(p->owner)->subaddress.valid) {
SWAP(*ast_channel_dialed(p->owner), *ast_channel_dialed(ast_channel_internal_bridged_channel(p->chan)));
}
ast_app_group_update(p->chan, p->owner);
ast_set_flag(p, LOCAL_ALREADY_MASQED);
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
/* Do the masquerade now. */
owner = ast_channel_ref(p->owner);
ao2_unlock(p);
ast_channel_unlock(ast);
ast_do_masquerade(owner);
ast_channel_unref(owner);
ast_channel_lock(ast);
ao2_lock(p);
}
/*!
* \internal
* \brief Start native RTP bridging of two channels
*
* \param bridge The bridge that had native RTP bridging happening on it
* \param target If remote RTP bridging, the channel that is unheld.
*
* \note Bridge must be locked when calling this function.
*/
static void native_rtp_bridge_start(struct ast_bridge *bridge, struct ast_channel *target)
{
struct ast_bridge_channel *bc0 = AST_LIST_FIRST(&bridge->channels);
struct ast_bridge_channel *bc1 = AST_LIST_LAST(&bridge->channels);
enum ast_rtp_glue_result native_type = AST_RTP_GLUE_RESULT_FORBID;
struct ast_rtp_glue *glue0, *glue1;
RAII_VAR(struct ast_rtp_instance *, instance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, instance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, tinstance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, tinstance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_format_cap *, cap0, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
RAII_VAR(struct ast_format_cap *, cap1, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
if (bc0 == bc1) {
return;
}
ast_channel_lock_both(bc0->chan, bc1->chan);
if (!bc0->suspended && !bc1->suspended) {
native_type = native_rtp_bridge_get(bc0->chan, bc1->chan, &glue0, &glue1, &instance0, &instance1, &vinstance0, &vinstance1);
}
switch (native_type) {
case AST_RTP_GLUE_RESULT_LOCAL:
if (ast_rtp_instance_get_engine(instance0)->local_bridge) {
ast_rtp_instance_get_engine(instance0)->local_bridge(instance0, instance1);
}
if (ast_rtp_instance_get_engine(instance1)->local_bridge) {
ast_rtp_instance_get_engine(instance1)->local_bridge(instance1, instance0);
}
ast_rtp_instance_set_bridged(instance0, instance1);
ast_rtp_instance_set_bridged(instance1, instance0);
ast_verb(4, "Locally RTP bridged '%s' and '%s' in stack\n",
ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
break;
case AST_RTP_GLUE_RESULT_REMOTE:
if (glue0->get_codec) {
glue0->get_codec(bc0->chan, cap0);
}
if (glue1->get_codec) {
glue1->get_codec(bc1->chan, cap1);
}
/* If we have a target, it's the channel that received the UNHOLD or UPDATE_RTP_PEER frame and was told to resume */
if (!target) {
glue0->update_peer(bc0->chan, instance1, vinstance1, tinstance1, cap1, 0);
glue1->update_peer(bc1->chan, instance0, vinstance0, tinstance0, cap0, 0);
ast_verb(4, "Remotely bridged '%s' and '%s' - media will flow directly between them\n",
ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
} else {
/*
* If a target was provided, it is the recipient of an unhold or an update and needs to have
* its media redirected to fit the current remote bridging needs. The other channel is either
* already set up to handle the new media path or will have its own set of updates independent
* of this pass.
*/
if (bc0->chan == target) {
glue0->update_peer(bc0->chan, instance1, vinstance1, tinstance1, cap1, 0);
} else {
glue1->update_peer(bc1->chan, instance0, vinstance0, tinstance0, cap0, 0);
}
}
break;
case AST_RTP_GLUE_RESULT_FORBID:
break;
}
ast_channel_unlock(bc0->chan);
ast_channel_unlock(bc1->chan);
}
static int native_rtp_bridge_compatible(struct ast_bridge *bridge)
{
struct ast_bridge_channel *bc0 = AST_LIST_FIRST(&bridge->channels);
struct ast_bridge_channel *bc1 = AST_LIST_LAST(&bridge->channels);
enum ast_rtp_glue_result native_type;
struct ast_rtp_glue *glue0, *glue1;
RAII_VAR(struct ast_rtp_instance *, instance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, instance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance0, NULL, ao2_cleanup);
RAII_VAR(struct ast_rtp_instance *, vinstance1, NULL, ao2_cleanup);
RAII_VAR(struct ast_format_cap *, cap0, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
RAII_VAR(struct ast_format_cap *, cap1, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
int read_ptime0, read_ptime1, write_ptime0, write_ptime1;
/* We require two channels before even considering native bridging */
if (bridge->num_channels != 2) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as two channels are required\n",
bridge->uniqueid);
return 0;
}
if (!native_rtp_bridge_capable(bc0->chan)) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has features which prevent it\n",
bridge->uniqueid, ast_channel_name(bc0->chan));
return 0;
}
if (!native_rtp_bridge_capable(bc1->chan)) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has features which prevent it\n",
bridge->uniqueid, ast_channel_name(bc1->chan));
return 0;
}
if ((native_type = native_rtp_bridge_get(bc0->chan, bc1->chan, &glue0, &glue1, &instance0, &instance1, &vinstance0, &vinstance1))
== AST_RTP_GLUE_RESULT_FORBID) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as it was forbidden while getting details\n",
bridge->uniqueid);
return 0;
}
if (ao2_container_count(bc0->features->dtmf_hooks) && ast_rtp_instance_dtmf_mode_get(instance0)) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has DTMF hooks\n",
bridge->uniqueid, ast_channel_name(bc0->chan));
return 0;
}
if (ao2_container_count(bc1->features->dtmf_hooks) && ast_rtp_instance_dtmf_mode_get(instance1)) {
ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has DTMF hooks\n",
bridge->uniqueid, ast_channel_name(bc1->chan));
return 0;
}
if ((native_type == AST_RTP_GLUE_RESULT_LOCAL) && ((ast_rtp_instance_get_engine(instance0)->local_bridge !=
ast_rtp_instance_get_engine(instance1)->local_bridge) ||
(ast_rtp_instance_get_engine(instance0)->dtmf_compatible &&
!ast_rtp_instance_get_engine(instance0)->dtmf_compatible(bc0->chan, instance0, bc1->chan, instance1)))) {
ast_debug(1, "Bridge '%s' can not use local native RTP bridge as local bridge or DTMF is not compatible\n",
bridge->uniqueid);
return 0;
}
/* Make sure that codecs match */
if (glue0->get_codec) {
glue0->get_codec(bc0->chan, cap0);
}
if (glue1->get_codec) {
glue1->get_codec(bc1->chan, cap1);
}
if (ast_format_cap_count(cap0) != 0 && ast_format_cap_count(cap1) != 0 && !ast_format_cap_iscompatible(cap0, cap1)) {
struct ast_str *codec_buf0 = ast_str_alloca(64);
struct ast_str *codec_buf1 = ast_str_alloca(64);
ast_debug(1, "Channel codec0 = %s is not codec1 = %s, cannot native bridge in RTP.\n",
ast_format_cap_get_names(cap0, &codec_buf0), ast_format_cap_get_names(cap1, &codec_buf1));
return 0;
}
read_ptime0 = ast_format_cap_get_format_framing(cap0, ast_channel_rawreadformat(bc0->chan));
read_ptime1 = ast_format_cap_get_format_framing(cap1, ast_channel_rawreadformat(bc1->chan));
write_ptime0 = ast_format_cap_get_format_framing(cap0, ast_channel_rawwriteformat(bc0->chan));
write_ptime1 = ast_format_cap_get_format_framing(cap1, ast_channel_rawwriteformat(bc1->chan));
if (read_ptime0 != write_ptime1 || read_ptime1 != write_ptime0) {
ast_debug(1, "Packetization differs between RTP streams (%d != %d or %d != %d). Cannot native bridge in RTP\n",
read_ptime0, write_ptime1, read_ptime1, write_ptime0);
return 0;
}
return 1;
}
static inline at_queue_t* at_fifo_queue_head (pvt_t* pvt)
{
return AST_LIST_FIRST (&pvt->at_queue);
}
