Sapian
/
asterisk
mirror of http://gerrit.asterisk.org/asterisk
3
0
Fork 0
Code Issues Releases Wiki Activity

More trivial bridge code cleanup.

Browse Source 
* Breaking long lines
* Word wrapping comment blocks.
* Removing redundant initializers.
* Debug message wording.


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@380108 65c4cc65-6c06-0410-ace0-fbb531ad65f3
changes/78/78/1
Richard Mudgett 13 years ago
parent 6300c37152
commit 7bb540dc80
4 changed files with 116 additions and 58 deletions
Show Stats Download Patch File Download Diff File

21
bridges/bridge_multiplexed.c
Unescape View File

@ -100,11 +100,13 @@ static int multiplexed_bridge_create(struct ast_bridge *bridge)
ao2_lock(multiplexed_threads);
/* Try to find an existing thread to handle our additional channels */
if (!(multiplexed_thread = ao2_callback(multiplexed_threads, 0, find_multiplexed_thread, NULL))) {
multiplexed_thread = ao2_callback(multiplexed_threads, 0, find_multiplexed_thread, NULL);
if (!multiplexed_thread) {
int flags;
/* If we failed we will have to create a new one from scratch */
if (!(multiplexed_thread = ao2_alloc(sizeof(*multiplexed_thread), destroy_multiplexed_thread))) {
multiplexed_thread = ao2_alloc(sizeof(*multiplexed_thread), destroy_multiplexed_thread);
if (!multiplexed_thread) {
ast_debug(1, "Failed to find or create a new multiplexed thread for bridge '%p'\n", bridge);
ao2_unlock(multiplexed_threads);
return -1;
@ -207,11 +209,14 @@ static void *multiplexed_thread_function(void *data)
ast_debug(1, "Starting actual thread for multiplexed thread '%p'\n", multiplexed_thread);
while (multiplexed_thread->thread != AST_PTHREADT_STOP) {
struct ast_channel *winner = NULL, *first = multiplexed_thread->chans[0];
int to = -1, outfd = -1;
struct ast_channel *winner;
struct ast_channel *first = multiplexed_thread->chans[0];
int to = -1;
int outfd = -1;
/* Move channels around so not just the first one gets priority */
memmove(multiplexed_thread->chans, multiplexed_thread->chans + 1, sizeof(struct ast_channel *) * (multiplexed_thread->service_count - 1));
memmove(multiplexed_thread->chans, multiplexed_thread->chans + 1,
sizeof(struct ast_channel *) * (multiplexed_thread->service_count - 1));
multiplexed_thread->chans[multiplexed_thread->service_count - 1] = first;
multiplexed_thread->waiting = 1;
@ -233,8 +238,9 @@ static void *multiplexed_thread_function(void *data)
}
}
if (winner && ast_channel_internal_bridge(winner)) {
struct ast_bridge *bridge = ast_channel_internal_bridge(winner);
struct ast_bridge *bridge;
int stop = 0;
ao2_unlock(multiplexed_thread);
while ((bridge = ast_channel_internal_bridge(winner)) && ao2_trylock(bridge)) {
sched_yield();
@ -310,7 +316,8 @@ static void multiplexed_add_or_remove(struct multiplexed_thread *multiplexed_thr
/*! \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 ast_channel *c0 = AST_LIST_FIRST(&bridge->channels)->chan;
struct ast_channel *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", ast_channel_name(bridge_channel->chan), multiplexed_thread);

3
bridges/bridge_simple.c
Unescape View File

@ -47,7 +47,8 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
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, *c1 = AST_LIST_LAST(&bridge->channels)->chan;
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 (AST_LIST_FIRST(&bridge->channels) == AST_LIST_LAST(&bridge->channels)) {

28
bridges/bridge_softmix.c
Unescape View File

@ -284,7 +284,8 @@ static void softmix_process_write_audio(struct softmix_translate_helper *trans_h
static void softmix_translate_helper_cleanup(struct softmix_translate_helper *trans_helper)
{
struct softmix_translate_helper_entry *entry = NULL;
struct softmix_translate_helper_entry *entry;
AST_LIST_TRAVERSE(&trans_helper->entries, entry, entry) {
if (entry->out_frame) {
ast_frfree(entry->out_frame);
@ -328,8 +329,10 @@ static int softmix_bridge_create(struct ast_bridge *bridge)
/*! \brief Function called when a bridge is destroyed */
static int softmix_bridge_destroy(struct ast_bridge *bridge)
{
struct softmix_bridge_data *softmix_data = bridge->bridge_pvt;
if (!bridge->bridge_pvt) {
struct softmix_bridge_data *softmix_data;
softmix_data = bridge->bridge_pvt;
if (!softmix_data) {
return -1;
}
ao2_ref(softmix_data, -1);
@ -382,7 +385,7 @@ static void set_softmix_bridge_data(int rate, int interval, struct ast_bridge_ch
/*! \brief Function called when a channel is joined into the bridge */
static int softmix_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{
struct softmix_channel *sc = NULL;
struct softmix_channel *sc;
struct softmix_bridge_data *softmix_data = bridge->bridge_pvt;
/* Create a new softmix_channel structure and allocate various things on it */
@ -718,7 +721,7 @@ static int softmix_mixing_array_init(struct softmix_mixing_array *mixing_array,
memset(mixing_array, 0, sizeof(*mixing_array));
mixing_array->max_num_entries = starting_num_entries;
if (!(mixing_array->buffers = ast_calloc(mixing_array->max_num_entries, sizeof(int16_t *)))) {
ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure. \n");
ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure.\n");
return -1;
}
return 0;
@ -735,7 +738,7 @@ static int softmix_mixing_array_grow(struct softmix_mixing_array *mixing_array,
/* give it some room to grow since memory is cheap but allocations can be expensive */
mixing_array->max_num_entries = num_entries;
if (!(tmp = ast_realloc(mixing_array->buffers, (mixing_array->max_num_entries * sizeof(int16_t *))))) {
ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure. \n");
ast_log(LOG_NOTICE, "Failed to re-allocate softmix mixing structure.\n");
return -1;
}
mixing_array->buffers = tmp;
@ -747,7 +750,7 @@ static int softmix_bridge_thread(struct ast_bridge *bridge)
{
struct softmix_stats stats = { { 0 }, };
struct softmix_mixing_array mixing_array;
struct softmix_bridge_data *softmix_data = bridge->bridge_pvt;
struct softmix_bridge_data *softmix_data;
struct ast_timer *timer;
struct softmix_translate_helper trans_helper;
int16_t buf[MAX_DATALEN];
@ -757,7 +760,8 @@ static int softmix_bridge_thread(struct ast_bridge *bridge)
int i, x;
int res = -1;
if (!(softmix_data = bridge->bridge_pvt)) {
softmix_data = bridge->bridge_pvt;
if (!softmix_data) {
goto softmix_cleanup;
}
@ -769,12 +773,11 @@ static int softmix_bridge_thread(struct ast_bridge *bridge)
/* Give the mixing array room to grow, memory is cheap but allocations are expensive. */
if (softmix_mixing_array_init(&mixing_array, bridge->num + 10)) {
ast_log(LOG_NOTICE, "Failed to allocate softmix mixing structure. \n");
goto softmix_cleanup;
}
while (!bridge->stop && !bridge->refresh && bridge->array_num) {
struct ast_bridge_channel *bridge_channel = NULL;
struct ast_bridge_channel *bridge_channel;
int timeout = -1;
enum ast_format_id cur_slin_id = ast_format_slin_by_rate(softmix_data->internal_rate);
unsigned int softmix_samples = SOFTMIX_SAMPLES(softmix_data->internal_rate, softmix_data->internal_mixing_interval);
@ -790,7 +793,8 @@ static int softmix_bridge_thread(struct ast_bridge *bridge)
}
/* Grow the mixing array buffer as participants are added. */
if (mixing_array.max_num_entries < bridge->num && softmix_mixing_array_grow(&mixing_array, bridge->num + 5)) {
if (mixing_array.max_num_entries < bridge->num
&& softmix_mixing_array_grow(&mixing_array, bridge->num + 5)) {
goto softmix_cleanup;
}
@ -887,7 +891,7 @@ static int softmix_bridge_thread(struct ast_bridge *bridge)
/* Wait for the timing source to tell us to wake up and get things done */
ast_waitfor_n_fd(&timingfd, 1, &timeout, NULL);
if (ast_timer_ack(timer, 1) < 0) {
ast_log(LOG_ERROR, "Failed to acknowledge timer in softmix bridge\n");
ast_log(LOG_ERROR, "Failed to acknowledge timer in softmix bridge.\n");
ao2_lock(bridge);
goto softmix_cleanup;
}

122
main/bridging.c
Unescape View File

@ -138,7 +138,11 @@ void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast
ao2_unlock(bridge_channel);
}
/*! \brief Helper function to poke the bridge thread */
/*!
* \brief Helper function to poke the bridge thread
*
* \note This function assumes the bridge is locked.
*/
static void bridge_poke(struct ast_bridge *bridge)
{
/* Poke the thread just in case */
@ -167,7 +171,8 @@ static void bridge_stop(struct ast_bridge *bridge)
ao2_lock(bridge);
}
/*! \brief Helper function to add a channel to the bridge array
/*!
* \brief Helper function to add a channel to the bridge array
*
* \note This function assumes the bridge is locked.
*/
@ -181,17 +186,21 @@ static void bridge_array_add(struct ast_bridge *bridge, struct ast_channel *chan
bridge->array[bridge->array_num++] = chan;
ast_debug(1, "Added channel %s(%p) to bridge array on %p, new count is %d\n", ast_channel_name(chan), chan, bridge, (int)bridge->array_num);
ast_debug(1, "Added channel %s(%p) to bridge array on %p, new count is %d\n",
ast_channel_name(chan), chan, bridge, (int) bridge->array_num);
/* If the next addition of a channel will exceed our array size grow it out */
if (bridge->array_num == bridge->array_size) {
struct ast_channel **tmp;
ast_debug(1, "Growing bridge array on %p from %d to %d\n", bridge, (int)bridge->array_size, (int)bridge->array_size + BRIDGE_ARRAY_GROW);
if (!(tmp = ast_realloc(bridge->array, (bridge->array_size + BRIDGE_ARRAY_GROW) * sizeof(struct ast_channel *)))) {
ast_log(LOG_ERROR, "Failed to allocate more space for another channel on bridge '%p', this is not going to end well\n", bridge);
struct ast_channel **new_array;
ast_debug(1, "Growing bridge array on %p from %d to %d\n",
bridge, (int) bridge->array_size, (int) bridge->array_size + BRIDGE_ARRAY_GROW);
new_array = ast_realloc(bridge->array,
(bridge->array_size + BRIDGE_ARRAY_GROW) * sizeof(*bridge->array));
if (!new_array) {
return;
}
bridge->array = tmp;
bridge->array = new_array;
bridge->array_size += BRIDGE_ARRAY_GROW;
}
}
@ -268,7 +277,10 @@ static void bridge_force_out_all(struct ast_bridge *bridge)
/*! \brief Internal function to see whether a bridge should dissolve, and if so do it */
static void bridge_check_dissolve(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{
if (!ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE) && (!bridge_channel->features || !bridge_channel->features->usable || !ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_FLAG_DISSOLVE))) {
if (!ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE)
&& (!bridge_channel->features
|| !bridge_channel->features->usable
|| !ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_FLAG_DISSOLVE))) {
return;
}
@ -343,7 +355,8 @@ void ast_bridge_handle_trip(struct ast_bridge *bridge, struct ast_bridge_channel
/* Signal the thread that is handling the bridged channel that it should be ended */
ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
} else if (frame->frametype == AST_FRAME_CONTROL && bridge_drop_control_frame(frame->subclass.integer)) {
ast_debug(1, "Dropping control frame from bridge channel %p\n", bridge_channel);
ast_debug(1, "Dropping control frame %d from bridge channel %p\n",
frame->subclass.integer, bridge_channel);
} else if (frame->frametype == AST_FRAME_DTMF_BEGIN || frame->frametype == AST_FRAME_DTMF_END) {
int dtmf_passthrough = bridge_channel->features ?
bridge_channel->features->dtmf_passthrough :
@ -384,7 +397,7 @@ void ast_bridge_handle_trip(struct ast_bridge *bridge, struct ast_bridge_channel
static int generic_thread_loop(struct ast_bridge *bridge)
{
while (!bridge->stop && !bridge->refresh && bridge->array_num) {
struct ast_channel *winner = NULL;
struct ast_channel *winner;
int to = -1;
/* Move channels around for priority reasons if we have more than one channel in our array */
@ -397,7 +410,7 @@ static int generic_thread_loop(struct ast_bridge *bridge)
/* Wait on the channels */
bridge->waiting = 1;
ao2_unlock(bridge);
winner = ast_waitfor_n(bridge->array, (int)bridge->array_num, &to);
winner = ast_waitfor_n(bridge->array, (int) bridge->array_num, &to);
bridge->waiting = 0;
ao2_lock(bridge);
@ -431,7 +444,10 @@ static void *bridge_thread(void *data)
bridge->technology->thread ? bridge->technology->thread : generic_thread_loop,
bridge);
/* Execute the appropriate thread function. If the technology does not provide one we use the generic one */
/*
* Execute the appropriate thread function. If the technology
* does not provide one we use the generic one.
*/
res = bridge->technology->thread
? bridge->technology->thread(bridge)
: generic_thread_loop(bridge);
@ -494,7 +510,8 @@ static void destroy_bridge(void *obj)
if (bridge->technology->destroy) {
ast_debug(1, "Giving bridge technology %s the bridge structure %p to destroy\n", bridge->technology->name, bridge);
if (bridge->technology->destroy(bridge)) {
ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... trying our best\n", bridge->technology->name, bridge);
ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... some memory may have leaked\n",
bridge->technology->name, bridge);
}
}
@ -512,8 +529,8 @@ static void destroy_bridge(void *obj)
struct ast_bridge *ast_bridge_new(uint32_t capabilities, int flags)
{
struct ast_bridge *bridge = NULL;
struct ast_bridge_technology *bridge_technology = NULL;
struct ast_bridge *bridge;
struct ast_bridge_technology *bridge_technology;
/* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */
if (flags & AST_BRIDGE_FLAG_SMART) {
@ -526,8 +543,11 @@ struct ast_bridge *ast_bridge_new(uint32_t capabilities, int flags)
ast_bridge_destroy(other_bridge);
}
/* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can
* just look for the most basic capability needed, single 1to1 mixing. */
/*
* If capabilities were provided use our helper function to find
* the "best" bridge technology, otherwise we can just look for
* the most basic capability needed, single 1to1 mixing.
*/
bridge_technology = capabilities
? find_best_technology(capabilities)
: find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX);
@ -557,7 +577,7 @@ struct ast_bridge *ast_bridge_new(uint32_t capabilities, int flags)
if (bridge->technology->create(bridge)) {
ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge);
ao2_ref(bridge, -1);
bridge = NULL;
return NULL;
}
}
@ -657,23 +677,26 @@ static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_c
static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int count)
{
uint32_t new_capabilities = 0;
struct ast_bridge_technology *new_technology = NULL, *old_technology = bridge->technology;
struct ast_bridge_technology *new_technology;
struct ast_bridge_technology *old_technology = bridge->technology;
struct ast_bridge temp_bridge = {
.technology = bridge->technology,
.bridge_pvt = bridge->bridge_pvt,
};
struct ast_bridge_channel *bridge_channel2 = NULL;
struct ast_bridge_channel *bridge_channel2;
/* Based on current feature determine whether we want to change bridge technologies or not */
if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) {
if (count <= 2) {
ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name);
ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n",
bridge, count, bridge->technology->name);
return 0;
}
new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
} else if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
if (count > 2) {
ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name);
ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n",
bridge, count, bridge->technology->name);
return 0;
}
new_capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX;
@ -689,11 +712,17 @@ static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_c
return -1;
}
ast_debug(1, "Performing smart bridge operation on bridge %p, moving from bridge technology %s to %s\n", bridge, old_technology->name, new_technology->name);
ast_debug(1, "Performing smart bridge operation on bridge %p, moving from bridge technology %s to %s\n",
bridge, old_technology->name, new_technology->name);
/* If a thread is currently executing for the current technology tell it to stop */
if (bridge->thread != AST_PTHREADT_NULL) {
/* If the new bridge technology also needs a thread simply tell the bridge thread to refresh itself. This has the benefit of not incurring the cost/time of tearing down and bringing up a new thread. */
/*
* If the new bridge technology also needs a thread simply tell
* the bridge thread to refresh itself. This has the benefit of
* not incurring the cost/time of tearing down and bringing up a
* new thread.
*/
if (new_technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD) {
ast_debug(1, "Telling current bridge thread for bridge %p to refresh\n", bridge);
bridge->refresh = 1;
@ -704,15 +733,22 @@ static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_c
}
}
/* Since we are soon going to pass this bridge to a new technology we need to NULL out the bridge_pvt pointer but don't worry as it still exists in temp_bridge, ditto for the old technology */
/*
* Since we are soon going to pass this bridge to a new
* technology we need to NULL out the bridge_pvt pointer but
* don't worry as it still exists in temp_bridge, ditto for the
* old technology.
*/
bridge->bridge_pvt = NULL;
bridge->technology = new_technology;
/* Pass the bridge to the new bridge technology so it can set it up */
if (new_technology->create) {
ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", new_technology->name, bridge);
ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n",
new_technology->name, bridge);
if (new_technology->create(bridge)) {
ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", new_technology->name, bridge);
ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n",
new_technology->name, bridge);
}
}
@ -725,9 +761,11 @@ static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_c
/* First we part them from the old technology */
if (old_technology->leave) {
ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p (really %p)\n", old_technology->name, bridge_channel2, &temp_bridge, bridge);
ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p (really %p)\n",
old_technology->name, bridge_channel2, &temp_bridge, bridge);
if (old_technology->leave(&temp_bridge, bridge_channel2)) {
ast_debug(1, "Bridge technology %s failed to allow %p (really %p) to leave bridge %p\n", old_technology->name, bridge_channel2, &temp_bridge, bridge);
ast_debug(1, "Bridge technology %s failed to allow %p (really %p) to leave bridge %p\n",
old_technology->name, bridge_channel2, &temp_bridge, bridge);
}
}
@ -736,9 +774,11 @@ static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_c
/* Third we join them to the new technology */
if (new_technology->join) {
ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", new_technology->name, bridge_channel2, bridge);
ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n",
new_technology->name, bridge_channel2, bridge);
if (new_technology->join(bridge, bridge_channel2)) {
ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", new_technology->name, bridge_channel2, bridge);
ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n",
new_technology->name, bridge_channel2, bridge);
}
}
@ -751,9 +791,11 @@ static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_c
/* Now that all the channels have been moved over we need to get rid of all the information the old technology may have left around */
if (old_technology->destroy) {
ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n", old_technology->name, &temp_bridge, bridge);
ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n",
old_technology->name, &temp_bridge, bridge);
if (old_technology->destroy(&temp_bridge)) {
ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p (really %p)... some memory may have leaked\n", old_technology->name, &temp_bridge, bridge);
ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p (really %p)... some memory may have leaked\n",
old_technology->name, &temp_bridge, bridge);
}
}
@ -907,9 +949,12 @@ static void bridge_channel_feature(struct ast_bridge *bridge, struct ast_bridge_
/* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
if (hook) {
hook->callback(bridge, bridge_channel, hook->hook_pvt);
/* If we are handing the channel off to an external hook for ownership,
* we are not guaranteed what kind of state it will come back in. If
* the channel hungup, we need to detect that here. */
/*
* If we are handing the channel off to an external hook for
* ownership, we are not guaranteed what kind of state it will
* come back in. If the channel hungup, we need to detect that
* here if the hook did not already change the state.
*/
if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
}
@ -1000,7 +1045,8 @@ static enum ast_bridge_channel_state bridge_channel_join(struct ast_bridge_chann
/* Update bridge pointer on channel */
ast_channel_internal_bridge_set(bridge_channel->chan, bridge_channel->bridge);
/* If the technology requires a thread and one is not running, start it up */
if (bridge_channel->bridge->thread == AST_PTHREADT_NULL && (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) {
if (bridge_channel->bridge->thread == AST_PTHREADT_NULL
&& (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) {
bridge_channel->bridge->stop = 0;
ast_debug(1, "Starting a bridge thread for bridge %p\n", bridge_channel->bridge);
ao2_ref(bridge_channel->bridge, +1);

Write Preview
Loading…
Cancel
Save