Wed Jan 27 20:02:23 2016

Asterisk developer's documentation


bridging.h File Reference

Channel Bridging API. More...

#include "asterisk/bridging_features.h"

Go to the source code of this file.

Data Structures

struct  ast_bridge
 Structure that contains information about a bridge. More...
struct  ast_bridge_channel
 Structure that contains information regarding a channel in a bridge. More...

Enumerations

enum  ast_bridge_capability {
  AST_BRIDGE_CAPABILITY_1TO1MIX = (1 << 1), AST_BRIDGE_CAPABILITY_MULTIMIX = (1 << 2), AST_BRIDGE_CAPABILITY_NATIVE = (1 << 3), AST_BRIDGE_CAPABILITY_MULTITHREADED = (1 << 4),
  AST_BRIDGE_CAPABILITY_THREAD = (1 << 5), AST_BRIDGE_CAPABILITY_VIDEO = (1 << 6), AST_BRIDGE_CAPABILITY_OPTIMIZE = (1 << 7)
}
 

Capabilities for a bridge technology.

More...
enum  ast_bridge_channel_state {
  AST_BRIDGE_CHANNEL_STATE_WAIT = 0, AST_BRIDGE_CHANNEL_STATE_END, AST_BRIDGE_CHANNEL_STATE_HANGUP, AST_BRIDGE_CHANNEL_STATE_DEPART,
  AST_BRIDGE_CHANNEL_STATE_FEATURE, AST_BRIDGE_CHANNEL_STATE_DTMF
}
 

State information about a bridged channel.

More...
enum  ast_bridge_write_result { AST_BRIDGE_WRITE_SUCCESS = 0, AST_BRIDGE_WRITE_FAILED, AST_BRIDGE_WRITE_UNSUPPORTED }
 

Return values for bridge technology write function.

More...

Functions

void ast_bridge_change_state (struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
 Change the state of a bridged channel.
int ast_bridge_check (enum ast_bridge_capability capabilities)
 See if it is possible to create a bridge.
int ast_bridge_depart (struct ast_bridge *bridge, struct ast_channel *chan)
 Depart a channel from a bridge.
int ast_bridge_destroy (struct ast_bridge *bridge)
 Destroy a bridge.
int ast_bridge_impart (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
 Impart (non-blocking) a channel on a bridge.
enum ast_bridge_channel_state ast_bridge_join (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
 Join (blocking) a channel to a bridge.
int ast_bridge_merge (struct ast_bridge *bridge0, struct ast_bridge *bridge1)
 Merge two bridges together.
struct ast_bridgeast_bridge_new (enum ast_bridge_capability capabilities, int flags)
 Create a new bridge.
int ast_bridge_remove (struct ast_bridge *bridge, struct ast_channel *chan)
 Remove a channel from a bridge.
int ast_bridge_suspend (struct ast_bridge *bridge, struct ast_channel *chan)
 Suspend a channel temporarily from a bridge.
int ast_bridge_unsuspend (struct ast_bridge *bridge, struct ast_channel *chan)
 Unsuspend a channel from a bridge.

Detailed Description

Channel Bridging API.

Author:
Joshua Colp <jcolp@digium.com> Channel Bridging API

Definition in file bridging.h.


Enumeration Type Documentation

Capabilities for a bridge technology.

Enumerator:
AST_BRIDGE_CAPABILITY_1TO1MIX 

Bridge is only capable of mixing 2 channels

AST_BRIDGE_CAPABILITY_MULTIMIX 

Bridge is capable of mixing 2 or more channels

AST_BRIDGE_CAPABILITY_NATIVE 

Bridge should natively bridge two channels if possible

AST_BRIDGE_CAPABILITY_MULTITHREADED 

Bridge should run using the multithreaded model

AST_BRIDGE_CAPABILITY_THREAD 

Bridge should run a central bridge thread

AST_BRIDGE_CAPABILITY_VIDEO 

Bridge technology can do video mixing (or something along those lines)

AST_BRIDGE_CAPABILITY_OPTIMIZE 

Bridge technology can optimize things based on who is talking

Definition at line 68 of file bridging.h.

00068                            {
00069    /*! Bridge is only capable of mixing 2 channels */
00070    AST_BRIDGE_CAPABILITY_1TO1MIX = (1 << 1),
00071    /*! Bridge is capable of mixing 2 or more channels */
00072    AST_BRIDGE_CAPABILITY_MULTIMIX = (1 << 2),
00073    /*! Bridge should natively bridge two channels if possible */
00074    AST_BRIDGE_CAPABILITY_NATIVE = (1 << 3),
00075    /*! Bridge should run using the multithreaded model */
00076    AST_BRIDGE_CAPABILITY_MULTITHREADED = (1 << 4),
00077    /*! Bridge should run a central bridge thread */
00078    AST_BRIDGE_CAPABILITY_THREAD = (1 << 5),
00079    /*! Bridge technology can do video mixing (or something along those lines) */
00080    AST_BRIDGE_CAPABILITY_VIDEO = (1 << 6),
00081    /*! Bridge technology can optimize things based on who is talking */
00082    AST_BRIDGE_CAPABILITY_OPTIMIZE = (1 << 7),
00083 };

State information about a bridged channel.

Enumerator:
AST_BRIDGE_CHANNEL_STATE_WAIT 

Waiting for a signal

AST_BRIDGE_CHANNEL_STATE_END 

Bridged channel has ended itself (it has hung up)

AST_BRIDGE_CHANNEL_STATE_HANGUP 

Bridged channel should be hung up

AST_BRIDGE_CHANNEL_STATE_DEPART 

Bridged channel should be removed from the bridge without being hung up

AST_BRIDGE_CHANNEL_STATE_FEATURE 

Bridged channel is executing a feature hook

AST_BRIDGE_CHANNEL_STATE_DTMF 

Bridged channel is sending a DTMF stream out

Definition at line 86 of file bridging.h.

00086                               {
00087    /*! Waiting for a signal */
00088    AST_BRIDGE_CHANNEL_STATE_WAIT = 0,
00089    /*! Bridged channel has ended itself (it has hung up) */
00090    AST_BRIDGE_CHANNEL_STATE_END,
00091    /*! Bridged channel should be hung up */
00092    AST_BRIDGE_CHANNEL_STATE_HANGUP,
00093    /*! Bridged channel should be removed from the bridge without being hung up */
00094    AST_BRIDGE_CHANNEL_STATE_DEPART,
00095    /*! Bridged channel is executing a feature hook */
00096    AST_BRIDGE_CHANNEL_STATE_FEATURE,
00097    /*! Bridged channel is sending a DTMF stream out */
00098    AST_BRIDGE_CHANNEL_STATE_DTMF,
00099 };

Return values for bridge technology write function.

Enumerator:
AST_BRIDGE_WRITE_SUCCESS 

Bridge technology wrote out frame fine

AST_BRIDGE_WRITE_FAILED 

Bridge technology attempted to write out the frame but failed

AST_BRIDGE_WRITE_UNSUPPORTED 

Bridge technology does not support writing out a frame of this type

Definition at line 102 of file bridging.h.

00102                              {
00103    /*! Bridge technology wrote out frame fine */
00104    AST_BRIDGE_WRITE_SUCCESS = 0,
00105    /*! Bridge technology attempted to write out the frame but failed */
00106    AST_BRIDGE_WRITE_FAILED,
00107    /*! Bridge technology does not support writing out a frame of this type */
00108    AST_BRIDGE_WRITE_UNSUPPORTED,
00109 };


Function Documentation

void ast_bridge_change_state ( struct ast_bridge_channel bridge_channel,
enum ast_bridge_channel_state  new_state 
)

Change the state of a bridged channel.

Parameters:
bridge_channel Channel to change the state on
new_state The new state to place the channel into

Example usage:

This places the channel pointed to by bridge_channel into the state AST_BRIDGE_CHANNEL_STATE_WAIT.

Note:
This API call is only meant to be used in feature hook callbacks to make sure the channel either hangs up or returns to the bridge.

Definition at line 122 of file bridging.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_bridge_channel::cond, ast_bridge_channel::lock, ast_bridge_channel::state, and ast_bridge_channel::thread.

Referenced by ast_bridge_depart(), ast_bridge_destroy(), ast_bridge_dtmf_stream(), ast_bridge_handle_trip(), ast_bridge_remove(), attended_abort_transfer(), attended_threeway_transfer(), bridge_channel_dtmf_stream(), bridge_channel_feature(), bridge_channel_join(), bridge_check_dissolve(), bridge_handle_dtmf(), feature_attended_transfer(), feature_blind_transfer(), and feature_hangup().

00123 {
00124    /* Change the state on the bridge channel */
00125    bridge_channel->state = new_state;
00126 
00127    /* Only poke the channel's thread if it is not us */
00128    if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
00129       pthread_kill(bridge_channel->thread, SIGURG);
00130       ast_mutex_lock(&bridge_channel->lock);
00131       ast_cond_signal(&bridge_channel->cond);
00132       ast_mutex_unlock(&bridge_channel->lock);
00133    }
00134 
00135    return;
00136 }

int ast_bridge_check ( enum ast_bridge_capability  capabilities  ) 

See if it is possible to create a bridge.

Parameters:
capabilities The capabilities that the bridge will use
Return values:
1 if possible
0 if not possible

Example usage:

This sees if it is possible to create a bridge capable of bridging two channels together.

Definition at line 502 of file bridging.c.

References ast_module_unref(), find_best_technology(), and ast_bridge_technology::mod.

00503 {
00504    struct ast_bridge_technology *bridge_technology = NULL;
00505 
00506    if (!(bridge_technology = find_best_technology(capabilities))) {
00507       return 0;
00508    }
00509 
00510    ast_module_unref(bridge_technology->mod);
00511 
00512    return 1;
00513 }

int ast_bridge_depart ( struct ast_bridge bridge,
struct ast_channel chan 
)

Depart a channel from a bridge.

Parameters:
bridge Bridge to depart from
chan Channel to depart
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_depart(bridge, chan);

This removes the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and gives control to the calling thread. This does not hang up the channel.

Note:
This API call can only be used on channels that were added to the bridge using the ast_bridge_impart API call.

Definition at line 1077 of file bridging.c.

References ao2_lock, ao2_unlock, ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_DEPART, find_bridge_channel(), ast_bridge_channel::thread, and thread.

Referenced by feature_attended_transfer(), and play_sound_file().

01078 {
01079    struct ast_bridge_channel *bridge_channel = NULL;
01080    pthread_t thread;
01081 
01082    ao2_lock(bridge);
01083 
01084    /* Try to find the channel that we want to depart */
01085    if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
01086       ao2_unlock(bridge);
01087       return -1;
01088    }
01089 
01090    ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DEPART);
01091    thread = bridge_channel->thread;
01092 
01093    ao2_unlock(bridge);
01094 
01095    pthread_join(thread, NULL);
01096 
01097    return 0;
01098 }

int ast_bridge_destroy ( struct ast_bridge bridge  ) 

Destroy a bridge.

Parameters:
bridge Bridge to destroy
Return values:
0 on success
-1 on failure

Example usage:

This destroys a bridge that was previously created using ast_bridge_new.

Definition at line 515 of file bridging.c.

References ao2_lock, ao2_ref, ao2_unlock, ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_END, ast_debug, AST_LIST_TRAVERSE, AST_PTHREADT_NULL, bridge_poke(), ast_bridge::stop, thread, and ast_bridge::thread.

Referenced by ast_bridge_new(), destroy_conference_bridge(), and feature_attended_transfer().

00516 {
00517    struct ast_bridge_channel *bridge_channel = NULL;
00518 
00519    ao2_lock(bridge);
00520 
00521    if (bridge->thread != AST_PTHREADT_NULL) {
00522       pthread_t thread = bridge->thread;
00523       bridge->stop = 1;
00524       bridge_poke(bridge);
00525       ao2_unlock(bridge);
00526       pthread_join(thread, NULL);
00527       ao2_lock(bridge);
00528    }
00529 
00530    ast_debug(1, "Telling all channels in bridge %p to end and leave the party\n", bridge);
00531 
00532    /* Drop every bridged channel, the last one will cause the bridge thread (if it exists) to exit */
00533    AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
00534       ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
00535    }
00536 
00537    ao2_unlock(bridge);
00538 
00539    ao2_ref(bridge, -1);
00540 
00541    return 0;
00542 }

int ast_bridge_impart ( struct ast_bridge bridge,
struct ast_channel chan,
struct ast_channel swap,
struct ast_bridge_features features 
)

Impart (non-blocking) a channel on a bridge.

Parameters:
bridge Bridge to impart on
chan Channel to impart
swap Channel to swap out if swapping
features Bridge features structure
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_impart(bridge, chan, NULL, NULL);

This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will return immediately and will not wait until the channel is no longer part of the bridge.

If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.

If channel specific features are enabled a pointer to the features structure can be specified in the features parameter.

Definition at line 1043 of file bridging.c.

References ao2_ref, ast_calloc, ast_cond_destroy, ast_cond_init, ast_free, ast_mutex_destroy, ast_mutex_init, ast_pthread_create, ast_bridge_channel::bridge, bridge_channel_thread(), ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge_channel::features, ast_bridge_channel::lock, ast_bridge_channel::swap, and ast_bridge_channel::thread.

Referenced by bridge_call(), feature_attended_transfer(), feature_blind_transfer(), and play_sound_file().

01044 {
01045    struct ast_bridge_channel *bridge_channel = NULL;
01046 
01047    /* Try to allocate a structure for the bridge channel */
01048    if (!(bridge_channel = ast_calloc(1, sizeof(*bridge_channel)))) {
01049       return -1;
01050    }
01051 
01052    /* Setup various parameters */
01053    bridge_channel->chan = chan;
01054    bridge_channel->swap = swap;
01055    bridge_channel->bridge = bridge;
01056    bridge_channel->features = features;
01057 
01058    /* Initialize our mutex lock and condition */
01059    ast_mutex_init(&bridge_channel->lock);
01060    ast_cond_init(&bridge_channel->cond, NULL);
01061 
01062    /* Bump up the reference count on the bridge, it'll get decremented later */
01063    ao2_ref(bridge, +1);
01064 
01065    /* Actually create the thread that will handle the channel */
01066    if (ast_pthread_create(&bridge_channel->thread, NULL, bridge_channel_thread, bridge_channel)) {
01067       ao2_ref(bridge, -1);
01068       ast_cond_destroy(&bridge_channel->cond);
01069       ast_mutex_destroy(&bridge_channel->lock);
01070       ast_free(bridge_channel);
01071       return -1;
01072    }
01073 
01074    return 0;
01075 }

enum ast_bridge_channel_state ast_bridge_join ( struct ast_bridge bridge,
struct ast_channel chan,
struct ast_channel swap,
struct ast_bridge_features features 
)

Join (blocking) a channel to a bridge.

Parameters:
bridge Bridge to join
chan Channel to join
swap Channel to swap out if swapping
features Bridge features structure
Return values:
state that channel exited the bridge with

Example usage:

 ast_bridge_join(bridge, chan, NULL, NULL);

This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will not return until the channel has been removed from the bridge, swapped out for another channel, or has hung up.

If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.

If channel specific features are enabled a pointer to the features structure can be specified in the features parameter.

Definition at line 993 of file bridging.c.

References ao2_ref, ast_cond_destroy, ast_cond_init, ast_mutex_destroy, ast_mutex_init, ast_bridge_channel::bridge, ast_channel::bridge, bridge_channel_join(), ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge::features, and ast_bridge_channel::lock.

Referenced by confbridge_exec(), and feature_attended_transfer().

00994 {
00995    struct ast_bridge_channel bridge_channel = {
00996       .chan = chan,
00997       .swap = swap,
00998       .bridge = bridge,
00999       .features = features,
01000    };
01001    enum ast_bridge_channel_state state;
01002 
01003    /* Initialize various other elements of the bridge channel structure that we can't do above */
01004    ast_mutex_init(&bridge_channel.lock);
01005    ast_cond_init(&bridge_channel.cond, NULL);
01006 
01007    ao2_ref(bridge_channel.bridge, +1);
01008 
01009    state = bridge_channel_join(&bridge_channel);
01010 
01011    ao2_ref(bridge_channel.bridge, -1);
01012 
01013    /* Destroy some elements of the bridge channel structure above */
01014    ast_mutex_destroy(&bridge_channel.lock);
01015    ast_cond_destroy(&bridge_channel.cond);
01016 
01017    return state;
01018 }

int ast_bridge_merge ( struct ast_bridge bridge0,
struct ast_bridge bridge1 
)

Merge two bridges together.

Parameters:
bridge0 First bridge
bridge1 Second bridge
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_merge(bridge0, bridge1);

This merges the bridge pointed to by bridge1 with the bridge pointed to by bridge0. In reality all of the channels in bridge1 are simply moved to bridge0.

Note:
The second bridge specified is not destroyed when this operation is completed.

Definition at line 1119 of file bridging.c.

References ao2_lock, ao2_ref, ao2_unlock, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_FLAG_SMART, ast_cond_signal, ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_STOP, ast_test_flag, ast_bridge_channel::bridge, bridge_array_add(), bridge_array_remove(), bridge_make_compatible(), ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge::feature_flags, ast_bridge_technology::join, ast_bridge_technology::leave, ast_bridge_channel::lock, ast_bridge_technology::name, ast_bridge::num, smart_bridge_operation(), ast_bridge::technology, ast_bridge_channel::thread, and ast_bridge::thread.

01120 {
01121    struct ast_bridge_channel *bridge_channel = NULL;
01122 
01123    ao2_lock(bridge0);
01124    ao2_lock(bridge1);
01125 
01126    /* If the first bridge currently has 2 channels and is not capable of becoming a multimixing bridge we can not merge */
01127    if ((bridge0->num + bridge1->num) > 2 && (!(bridge0->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) && !ast_test_flag(&bridge0->feature_flags, AST_BRIDGE_FLAG_SMART))) {
01128       ao2_unlock(bridge1);
01129       ao2_unlock(bridge0);
01130       ast_debug(1, "Can't merge bridge %p into bridge %p, multimix is needed and it could not be acquired.\n", bridge1, bridge0);
01131       return -1;
01132    }
01133 
01134    ast_debug(1, "Merging channels from bridge %p into bridge %p\n", bridge1, bridge0);
01135 
01136    /* Perform smart bridge operation on bridge we are merging into so it can change bridge technology if needed */
01137    if (smart_bridge_operation(bridge0, NULL, bridge0->num + bridge1->num)) {
01138       ao2_unlock(bridge1);
01139       ao2_unlock(bridge0);
01140       ast_debug(1, "Can't merge bridge %p into bridge %p, tried to perform smart bridge operation and failed.\n", bridge1, bridge0);
01141       return -1;
01142    }
01143 
01144    /* If a thread is currently executing on bridge1 tell it to stop */
01145    if (bridge1->thread) {
01146       ast_debug(1, "Telling bridge thread on bridge %p to stop as it is being merged into %p\n", bridge1, bridge0);
01147       bridge1->thread = AST_PTHREADT_STOP;
01148    }
01149 
01150    /* Move channels from bridge1 over to bridge0 */
01151    while ((bridge_channel = AST_LIST_REMOVE_HEAD(&bridge1->channels, entry))) {
01152       /* Tell the technology handling bridge1 that the bridge channel is leaving */
01153       if (bridge1->technology->leave) {
01154          ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
01155          if (bridge1->technology->leave(bridge1, bridge_channel)) {
01156             ast_debug(1, "Bridge technology %s failed to allow %p to leave bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
01157          }
01158       }
01159 
01160       /* Drop channel count and reference count on the bridge they are leaving */
01161       bridge1->num--;
01162       ao2_ref(bridge1, -1);
01163 
01164       bridge_array_remove(bridge1, bridge_channel->chan);
01165 
01166       /* Now add them into the bridge they are joining, increase channel count, and bump up reference count */
01167       bridge_channel->bridge = bridge0;
01168       AST_LIST_INSERT_TAIL(&bridge0->channels, bridge_channel, entry);
01169       bridge0->num++;
01170       ao2_ref(bridge0, +1);
01171 
01172       bridge_array_add(bridge0, bridge_channel->chan);
01173 
01174       /* Make the channel compatible with the new bridge it is joining or else formats would go amuck */
01175       bridge_make_compatible(bridge0, bridge_channel);
01176 
01177       /* Tell the technology handling bridge0 that the bridge channel is joining */
01178       if (bridge0->technology->join) {
01179          ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
01180          if (bridge0->technology->join(bridge0, bridge_channel)) {
01181             ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
01182          }
01183       }
01184 
01185       /* Poke the bridge channel, this will cause it to wake up and execute the proper threading model for the new bridge it is in */
01186       pthread_kill(bridge_channel->thread, SIGURG);
01187       ast_mutex_lock(&bridge_channel->lock);
01188       ast_cond_signal(&bridge_channel->cond);
01189       ast_mutex_unlock(&bridge_channel->lock);
01190    }
01191 
01192    ast_debug(1, "Merged channels from bridge %p into bridge %p\n", bridge1, bridge0);
01193 
01194    ao2_unlock(bridge1);
01195    ao2_unlock(bridge0);
01196 
01197    return 0;
01198 }

struct ast_bridge* ast_bridge_new ( enum ast_bridge_capability  capabilities,
int  flags 
) [read]

Create a new bridge.

Parameters:
capabilities The capabilities that we require to be used on the bridge
flags Flags that will alter the behavior of the bridge
Return values:
a pointer to a new bridge on success
NULL on failure

Example usage:

This creates a simple two party bridge that will be destroyed once one of the channels hangs up.

Definition at line 449 of file bridging.c.

References ao2_alloc, ao2_ref, ast_bridge::array, ast_bridge::array_size, AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_MULTIMIX, ast_bridge_destroy(), AST_BRIDGE_FLAG_SMART, ast_bridge_new(), ast_calloc, ast_debug, AST_PTHREADT_NULL, ast_set_flag, BRIDGE_ARRAY_START, ast_bridge_technology::create, destroy_bridge(), ast_bridge::feature_flags, find_best_technology(), ast_bridge_technology::name, ast_bridge::technology, and ast_bridge::thread.

Referenced by ast_bridge_new(), feature_attended_transfer(), and join_conference_bridge().

00450 {
00451    struct ast_bridge *bridge = NULL;
00452    struct ast_bridge_technology *bridge_technology = NULL;
00453 
00454    /* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */
00455    if (flags & AST_BRIDGE_FLAG_SMART) {
00456       struct ast_bridge *other_bridge;
00457 
00458       if (!(other_bridge = ast_bridge_new((capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) ? AST_BRIDGE_CAPABILITY_MULTIMIX : AST_BRIDGE_CAPABILITY_1TO1MIX, 0))) {
00459          return NULL;
00460       }
00461 
00462       ast_bridge_destroy(other_bridge);
00463    }
00464 
00465    /* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can
00466     * just look for the most basic capability needed, single 1to1 mixing. */
00467    bridge_technology = (capabilities ? find_best_technology(capabilities) : find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX));
00468 
00469    /* If no bridge technology was found we can't possibly do bridging so fail creation of the bridge */
00470    if (!bridge_technology) {
00471       ast_debug(1, "Failed to find a bridge technology to satisfy capabilities %u\n", capabilities);
00472       return NULL;
00473    }
00474 
00475    /* We have everything we need to create this bridge... so allocate the memory, link things together, and fire her up! */
00476    if (!(bridge = ao2_alloc(sizeof(*bridge), destroy_bridge))) {
00477       return NULL;
00478    }
00479 
00480    bridge->technology = bridge_technology;
00481    bridge->thread = AST_PTHREADT_NULL;
00482 
00483    /* Create an array of pointers for the channels that will be joining us */
00484    bridge->array = ast_calloc(BRIDGE_ARRAY_START, sizeof(struct ast_channel*));
00485    bridge->array_size = BRIDGE_ARRAY_START;
00486 
00487    ast_set_flag(&bridge->feature_flags, flags);
00488 
00489    /* Pass off the bridge to the technology to manipulate if needed */
00490    if (bridge->technology->create) {
00491       ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", bridge->technology->name, bridge);
00492       if (bridge->technology->create(bridge)) {
00493          ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge);
00494          ao2_ref(bridge, -1);
00495          bridge = NULL;
00496       }
00497    }
00498 
00499    return bridge;
00500 }

int ast_bridge_remove ( struct ast_bridge bridge,
struct ast_channel chan 
)

Remove a channel from a bridge.

Parameters:
bridge Bridge that the channel is to be removed from
chan Channel to remove
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_remove(bridge, chan);

This removes the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and requests that it be hung up. Control over the channel will NOT be given to the calling thread.

Note:
This API call can be used on channels that were added to the bridge using both ast_bridge_join and ast_bridge_impart.

Definition at line 1100 of file bridging.c.

References ao2_lock, ao2_unlock, ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_HANGUP, and find_bridge_channel().

Referenced by menu_callback().

01101 {
01102    struct ast_bridge_channel *bridge_channel = NULL;
01103 
01104    ao2_lock(bridge);
01105 
01106    /* Try to find the channel that we want to remove */
01107    if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
01108       ao2_unlock(bridge);
01109       return -1;
01110    }
01111 
01112    ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
01113 
01114    ao2_unlock(bridge);
01115 
01116    return 0;
01117 }

int ast_bridge_suspend ( struct ast_bridge bridge,
struct ast_channel chan 
)

Suspend a channel temporarily from a bridge.

Parameters:
bridge Bridge to suspend the channel from
chan Channel to suspend
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_suspend(bridge, chan);

This suspends the channel pointed to by chan from the bridge pointed to by bridge temporarily. Control of the channel is given to the calling thread. This differs from ast_bridge_depart as the channel will not be removed from the bridge.

Note:
This API call can be used on channels that were added to the bridge using both ast_bridge_join and ast_bridge_impart.

Definition at line 1200 of file bridging.c.

References ao2_lock, ao2_unlock, bridge_channel_suspend(), and find_bridge_channel().

Referenced by leave_conference_bridge(), post_join_marked(), and post_join_unmarked().

01201 {
01202    struct ast_bridge_channel *bridge_channel;
01203 
01204    ao2_lock(bridge);
01205 
01206    if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
01207       ao2_unlock(bridge);
01208       return -1;
01209    }
01210 
01211    bridge_channel_suspend(bridge, bridge_channel);
01212 
01213    ao2_unlock(bridge);
01214 
01215    return 0;
01216 }

int ast_bridge_unsuspend ( struct ast_bridge bridge,
struct ast_channel chan 
)

Unsuspend a channel from a bridge.

Parameters:
bridge Bridge to unsuspend the channel from
chan Channel to unsuspend
Return values:
0 on success
-1 on failure

Example usage:

 ast_bridge_unsuspend(bridge, chan);

This unsuspends the channel pointed to by chan from the bridge pointed to by bridge. The bridge will go back to handling the channel once this function returns.

Note:
You must not mess with the channel once this function returns. Doing so may result in bad things happening.

Definition at line 1218 of file bridging.c.

References ao2_lock, ao2_unlock, bridge_channel_unsuspend(), and find_bridge_channel().

Referenced by leave_conference_bridge(), post_join_marked(), and post_join_unmarked().

01219 {
01220    struct ast_bridge_channel *bridge_channel;
01221 
01222    ao2_lock(bridge);
01223 
01224    if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
01225       ao2_unlock(bridge);
01226       return -1;
01227    }
01228 
01229    bridge_channel_unsuspend(bridge, bridge_channel);
01230 
01231    ao2_unlock(bridge);
01232 
01233    return 0;
01234 }


Generated on 27 Jan 2016 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1