main/bridging.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2007 - 2009, Digium, Inc.
   5  *
   6  * Joshua Colp <jcolp@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Channel Bridging API
  22  *
  23  * \author Joshua Colp <jcolp@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <signal.h>
  31
  32 #include "asterisk/logger.h"
  33 #include "asterisk/channel.h"
  34 #include "asterisk/options.h"
  35 #include "asterisk/utils.h"
  36 #include "asterisk/lock.h"
  37 #include "asterisk/linkedlists.h"
  38 #include "asterisk/bridging.h"
  39 #include "asterisk/bridging_technology.h"
  40 #include "asterisk/app.h"
  41 #include "asterisk/file.h"
  42 #include "asterisk/module.h"
  43 #include "asterisk/astobj2.h"
  44
  45 static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);
  46
  47 /* Initial starting point for the bridge array of channels */
  48 #define BRIDGE_ARRAY_START 128
  49
  50 /* Grow rate of bridge array of channels */
  51 #define BRIDGE_ARRAY_GROW 32
  52
  53 static void cleanup_video_mode(struct ast_bridge *bridge);
  54
  55 /*! Default DTMF keys for built in features */
  56 static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];
  57
  58 /*! Function handlers for the built in features */
  59 static void *builtin_features_handlers[AST_BRIDGE_BUILTIN_END];
  60
  61 int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
  62 {
  63         struct ast_bridge_technology *current = NULL;
  64
  65         /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
  66         if (ast_strlen_zero(technology->name) || !technology->capabilities || !technology->write) {
  67                 ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n", technology->name);
  68                 return -1;
  69         }
  70
  71         AST_RWLIST_WRLOCK(&bridge_technologies);
  72
  73         /* Look for duplicate bridge technology already using this name, or already registered */
  74         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
  75                 if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
  76                         ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n", technology->name);
  77                         AST_RWLIST_UNLOCK(&bridge_technologies);
  78                         return -1;
  79                 }
  80         }
  81
  82         /* Copy module pointer so reference counting can keep the module from unloading */
  83         technology->mod = module;
  84
  85         /* Insert our new bridge technology into the list and print out a pretty message */
  86         AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);
  87
  88         AST_RWLIST_UNLOCK(&bridge_technologies);
  89
  90         if (option_verbose > 1) {
  91                 ast_verbose(VERBOSE_PREFIX_2 "Registered bridge technology %s\n", technology->name);
  92         }
  93
  94         return 0;
  95 }
  96
  97 int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
  98 {
  99         struct ast_bridge_technology *current = NULL;
 100
 101         AST_RWLIST_WRLOCK(&bridge_technologies);
 102
 103         /* Ensure the bridge technology is registered before removing it */
 104         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
 105                 if (current == technology) {
 106                         AST_RWLIST_REMOVE_CURRENT(entry);
 107                         if (option_verbose > 1) {
 108                                 ast_verbose(VERBOSE_PREFIX_2 "Unregistered bridge technology %s\n", technology->name);
 109                         }
 110                         break;
 111                 }
 112         }
 113         AST_RWLIST_TRAVERSE_SAFE_END;
 114
 115         AST_RWLIST_UNLOCK(&bridge_technologies);
 116
 117         return current ? 0 : -1;
 118 }
 119
 120 void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
 121 {
 122         /* Change the state on the bridge channel */
 123         bridge_channel->state = new_state;
 124
 125         /* Only poke the channel's thread if it is not us */
 126         if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
 127                 pthread_kill(bridge_channel->thread, SIGURG);
 128                 ao2_lock(bridge_channel);
 129                 ast_cond_signal(&bridge_channel->cond);
 130                 ao2_unlock(bridge_channel);
 131         }
 132
 133         return;
 134 }
 135
 136 /*! \brief Helper function to poke the bridge thread */
 137 static void bridge_poke(struct ast_bridge *bridge)
 138 {
 139         /* Poke the thread just in case */
 140         if (bridge->thread != AST_PTHREADT_NULL && bridge->thread != AST_PTHREADT_STOP) {
 141                 pthread_kill(bridge->thread, SIGURG);
 142         }
 143
 144         return;
 145 }
 146
 147 /*! \brief Helper function to add a channel to the bridge array
 148  *
 149  * \note This function assumes the bridge is locked.
 150  */
 151 static void bridge_array_add(struct ast_bridge *bridge, struct ast_channel *chan)
 152 {
 153         /* We have to make sure the bridge thread is not using the bridge array before messing with it */
 154         while (bridge->waiting) {
 155                 bridge_poke(bridge);
 156                 sched_yield();
 157         }
 158
 159         bridge->array[bridge->array_num++] = chan;
 160
 161         ast_debug(1, "Added channel %s(%p) to bridge array on %p, new count is %d\n", chan->name, chan, bridge, (int)bridge->array_num);
 162
 163         /* If the next addition of a channel will exceed our array size grow it out */
 164         if (bridge->array_num == bridge->array_size) {
 165                 struct ast_channel **tmp;
 166                 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);
 167                 if (!(tmp = ast_realloc(bridge->array, (bridge->array_size + BRIDGE_ARRAY_GROW) * sizeof(struct ast_channel *)))) {
 168                         ast_log(LOG_ERROR, "Failed to allocate more space for another channel on bridge '%p', this is not going to end well\n", bridge);
 169                         return;
 170                 }
 171                 bridge->array = tmp;
 172                 bridge->array_size += BRIDGE_ARRAY_GROW;
 173         }
 174
 175         return;
 176 }
 177
 178 /*! \brief Helper function to remove a channel from the bridge array
 179  *
 180  * \note This function assumes the bridge is locked.
 181  */
 182 static void bridge_array_remove(struct ast_bridge *bridge, struct ast_channel *chan)
 183 {
 184         int i;
 185
 186         /* We have to make sure the bridge thread is not using the bridge array before messing with it */
 187         while (bridge->waiting) {
 188                 bridge_poke(bridge);
 189                 sched_yield();
 190         }
 191
 192         for (i = 0; i < bridge->array_num; i++) {
 193                 if (bridge->array[i] == chan) {
 194                         bridge->array[i] = (bridge->array[(bridge->array_num - 1)] != chan ? bridge->array[(bridge->array_num - 1)] : NULL);
 195                         bridge->array[(bridge->array_num - 1)] = NULL;
 196                         bridge->array_num--;
 197                         ast_debug(1, "Removed channel %p from bridge array on %p, new count is %d\n", chan, bridge, (int)bridge->array_num);
 198                         break;
 199                 }
 200         }
 201
 202         return;
 203 }
 204
 205 /*! \brief Helper function to find a bridge channel given a channel */
 206 static struct ast_bridge_channel *find_bridge_channel(struct ast_bridge *bridge, struct ast_channel *chan)
 207 {
 208         struct ast_bridge_channel *bridge_channel = NULL;
 209
 210         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
 211                 if (bridge_channel->chan == chan) {
 212                         break;
 213                 }
 214         }
 215
 216         return bridge_channel;
 217 }
 218
 219 /*! \brief Internal function to see whether a bridge should dissolve, and if so do it */
 220 static void bridge_check_dissolve(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 221 {
 222         struct ast_bridge_channel *bridge_channel2 = NULL;
 223
 224         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))) {
 225                 return;
 226         }
 227
 228         ast_debug(1, "Dissolving bridge %p\n", bridge);
 229
 230         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) {
 231                 if (bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_END && bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_DEPART) {
 232                         ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP);
 233                 }
 234         }
 235
 236         /* Since all the channels are going away let's go ahead and stop our on thread */
 237         bridge->stop = 1;
 238
 239         return;
 240 }
 241
 242 /*! \brief Internal function to handle DTMF from a channel */
 243 static struct ast_frame *bridge_handle_dtmf(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
 244 {
 245         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 246         struct ast_bridge_features_hook *hook = NULL;
 247
 248         /* If the features structure we grabbed is not usable immediately return the frame */
 249         if (!features->usable) {
 250                 return frame;
 251         }
 252
 253         /* See if this DTMF matches the beginnings of any feature hooks, if so we switch to the feature state to either execute the feature or collect more DTMF */
 254         AST_LIST_TRAVERSE(&features->hooks, hook, entry) {
 255                 if (hook->dtmf[0] == frame->subclass.integer) {
 256                         ast_frfree(frame);
 257                         frame = NULL;
 258                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_FEATURE);
 259                         break;
 260                 }
 261         }
 262
 263         return frame;
 264 }
 265
 266 /*! \brief Internal function used to determine whether a control frame should be dropped or not */
 267 static int bridge_drop_control_frame(int subclass)
 268 {
 269         switch (subclass) {
 270         case AST_CONTROL_ANSWER:
 271         case -1:
 272                 return 1;
 273         default:
 274                 return 0;
 275         }
 276 }
 277
 278 void ast_bridge_notify_talking(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int started_talking)
 279 {
 280         if (started_talking) {
 281                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_START_TALKING);
 282         } else {
 283                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_STOP_TALKING);
 284         }
 285 }
 286
 287 void ast_bridge_handle_trip(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_channel *chan, int outfd)
 288 {
 289         /* If no bridge channel has been provided and the actual channel has been provided find it */
 290         if (chan && !bridge_channel) {
 291                 bridge_channel = find_bridge_channel(bridge, chan);
 292         }
 293
 294         /* If a bridge channel with actual channel is present read a frame and handle it */
 295         if (chan && bridge_channel) {
 296                 struct ast_frame *frame = (((bridge->features.mute) || (bridge_channel->features && bridge_channel->features->mute)) ? ast_read_noaudio(chan) : ast_read(chan));
 297
 298                 /* This is pretty simple... see if they hung up */
 299                 if (!frame || (frame->frametype == AST_FRAME_CONTROL && frame->subclass.integer == AST_CONTROL_HANGUP)) {
 300                         /* Signal the thread that is handling the bridged channel that it should be ended */
 301                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
 302                 } else if (frame->frametype == AST_FRAME_CONTROL && bridge_drop_control_frame(frame->subclass.integer)) {
 303                         ast_debug(1, "Dropping control frame from bridge channel %p\n", bridge_channel);
 304                 } else if (frame->frametype == AST_FRAME_DTMF_BEGIN || frame->frametype == AST_FRAME_DTMF_END) {
 305                         int dtmf_passthrough = bridge_channel->features ?
 306                                 bridge_channel->features->dtmf_passthrough :
 307                                 bridge->features.dtmf_passthrough;
 308
 309                         if (frame->frametype == AST_FRAME_DTMF_BEGIN) {
 310                                 frame = bridge_handle_dtmf(bridge, bridge_channel, frame);
 311                         }
 312
 313                         if (frame && dtmf_passthrough) {
 314                                 bridge->technology->write(bridge, bridge_channel, frame);
 315                         }
 316                 } else {
 317                         /* Simply write the frame out to the bridge technology if it still exists */
 318                         bridge->technology->write(bridge, bridge_channel, frame);
 319                 }
 320
 321                 if (frame) {
 322                         ast_frfree(frame);
 323                 }
 324                 return;
 325         }
 326
 327         /* If a file descriptor actually tripped pass it off to the bridge technology */
 328         if (outfd > -1 && bridge->technology->fd) {
 329                 bridge->technology->fd(bridge, bridge_channel, outfd);
 330                 return;
 331         }
 332
 333         /* If all else fails just poke the bridge */
 334         if (bridge->technology->poke && bridge_channel) {
 335                 bridge->technology->poke(bridge, bridge_channel);
 336                 return;
 337         }
 338
 339         return;
 340 }
 341
 342 /*! \brief Generic thread loop, TODO: Rethink this/improve it */
 343 static int generic_thread_loop(struct ast_bridge *bridge)
 344 {
 345         while (!bridge->stop && !bridge->refresh && bridge->array_num) {
 346                 struct ast_channel *winner = NULL;
 347                 int to = -1;
 348
 349                 /* Move channels around for priority reasons if we have more than one channel in our array */
 350                 if (bridge->array_num > 1) {
 351                         struct ast_channel *first = bridge->array[0];
 352                         memmove(bridge->array, bridge->array + 1, sizeof(struct ast_channel *) * (bridge->array_num - 1));
 353                         bridge->array[(bridge->array_num - 1)] = first;
 354                 }
 355
 356                 /* Wait on the channels */
 357                 bridge->waiting = 1;
 358                 ao2_unlock(bridge);
 359                 winner = ast_waitfor_n(bridge->array, (int)bridge->array_num, &to);
 360                 bridge->waiting = 0;
 361                 ao2_lock(bridge);
 362
 363                 /* Process whatever they did */
 364                 ast_bridge_handle_trip(bridge, NULL, winner, -1);
 365         }
 366
 367         return 0;
 368 }
 369
 370 /*! \brief Bridge thread function */
 371 static void *bridge_thread(void *data)
 372 {
 373         struct ast_bridge *bridge = data;
 374         int res = 0;
 375
 376         ao2_lock(bridge);
 377
 378         ast_debug(1, "Started bridge thread for %p\n", bridge);
 379
 380         /* Loop around until we are told to stop */
 381         while (!bridge->stop && bridge->array_num && !res) {
 382                 /* In case the refresh bit was set simply set it back to off */
 383                 bridge->refresh = 0;
 384
 385                 ast_debug(1, "Launching bridge thread function %p for bridge %p\n", (bridge->technology->thread ? bridge->technology->thread : &generic_thread_loop), bridge);
 386
 387                 /* Execute the appropriate thread function. If the technology does not provide one we use the generic one */
 388                 res = (bridge->technology->thread ? bridge->technology->thread(bridge) : generic_thread_loop(bridge));
 389         }
 390
 391         ast_debug(1, "Ending bridge thread for %p\n", bridge);
 392
 393         /* Indicate the bridge thread is no longer active */
 394         bridge->thread = AST_PTHREADT_NULL;
 395         ao2_unlock(bridge);
 396
 397         ao2_ref(bridge, -1);
 398
 399         return NULL;
 400 }
 401
 402 /*! \brief Helper function used to find the "best" bridge technology given a specified capabilities */
 403 static struct ast_bridge_technology *find_best_technology(uint32_t capabilities)
 404 {
 405         struct ast_bridge_technology *current = NULL, *best = NULL;
 406
 407         AST_RWLIST_RDLOCK(&bridge_technologies);
 408         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
 409                 if (current->suspended) {
 410                         ast_debug(1, "Bridge technology %s is suspended. Skipping.\n", current->name);
 411                         continue;
 412                 }
 413                 if (!(current->capabilities & capabilities)) {
 414                         ast_debug(1, "Bridge technology %s does not have the capabilities we need.\n", current->name);
 415                         continue;
 416                 }
 417                 if (best && best->preference < current->preference) {
 418                         ast_debug(1, "Bridge technology %s has preference %d while %s has preference %d. Skipping.\n", current->name, current->preference, best->name, best->preference);
 419                         continue;
 420                 }
 421                 best = current;
 422         }
 423
 424         if (best) {
 425                 /* Increment it's module reference count if present so it does not get unloaded while in use */
 426                 if (best->mod) {
 427                         ast_module_ref(best->mod);
 428                 }
 429                 ast_debug(1, "Chose bridge technology %s\n", best->name);
 430         }
 431
 432         AST_RWLIST_UNLOCK(&bridge_technologies);
 433
 434         return best;
 435 }
 436
 437 static void destroy_bridge(void *obj)
 438 {
 439         struct ast_bridge *bridge = obj;
 440
 441         ast_debug(1, "Actually destroying bridge %p, nobody wants it anymore\n", bridge);
 442
 443         /* Pass off the bridge to the technology to destroy if needed */
 444         if (bridge->technology->destroy) {
 445                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to destroy\n", bridge->technology->name, bridge);
 446                 if (bridge->technology->destroy(bridge)) {
 447                         ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... trying our best\n", bridge->technology->name, bridge);
 448                 }
 449         }
 450
 451         /* We are no longer using the bridge technology so decrement the module reference count on it */
 452         if (bridge->technology->mod) {
 453                 ast_module_unref(bridge->technology->mod);
 454         }
 455
 456         /* Last but not least clean up the features configuration */
 457         ast_bridge_features_cleanup(&bridge->features);
 458
 459         /* Drop the array of channels */
 460         ast_free(bridge->array);
 461
 462         cleanup_video_mode(bridge);
 463
 464         return;
 465 }
 466
 467 struct ast_bridge *ast_bridge_new(uint32_t capabilities, int flags)
 468 {
 469         struct ast_bridge *bridge = NULL;
 470         struct ast_bridge_technology *bridge_technology = NULL;
 471
 472         /* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */
 473         if (flags & AST_BRIDGE_FLAG_SMART) {
 474                 struct ast_bridge *other_bridge;
 475
 476                 if (!(other_bridge = ast_bridge_new((capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) ? AST_BRIDGE_CAPABILITY_MULTIMIX : AST_BRIDGE_CAPABILITY_1TO1MIX, 0))) {
 477                         return NULL;
 478                 }
 479
 480                 ast_bridge_destroy(other_bridge);
 481         }
 482
 483         /* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can
 484          * just look for the most basic capability needed, single 1to1 mixing. */
 485         bridge_technology = (capabilities ? find_best_technology(capabilities) : find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX));
 486
 487         /* If no bridge technology was found we can't possibly do bridging so fail creation of the bridge */
 488         if (!bridge_technology) {
 489                 return NULL;
 490         }
 491
 492         /* We have everything we need to create this bridge... so allocate the memory, link things together, and fire her up! */
 493         if (!(bridge = ao2_alloc(sizeof(*bridge), destroy_bridge))) {
 494                 return NULL;
 495         }
 496
 497         bridge->technology = bridge_technology;
 498         bridge->thread = AST_PTHREADT_NULL;
 499
 500         /* Create an array of pointers for the channels that will be joining us */
 501         bridge->array = ast_calloc(BRIDGE_ARRAY_START, sizeof(struct ast_channel*));
 502         bridge->array_size = BRIDGE_ARRAY_START;
 503
 504         ast_set_flag(&bridge->feature_flags, flags);
 505
 506         /* Pass off the bridge to the technology to manipulate if needed */
 507         if (bridge->technology->create) {
 508                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", bridge->technology->name, bridge);
 509                 if (bridge->technology->create(bridge)) {
 510                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge);
 511                         ao2_ref(bridge, -1);
 512                         bridge = NULL;
 513                 }
 514         }
 515
 516         return bridge;
 517 }
 518
 519 int ast_bridge_check(uint32_t capabilities)
 520 {
 521         struct ast_bridge_technology *bridge_technology = NULL;
 522
 523         if (!(bridge_technology = find_best_technology(capabilities))) {
 524                 return 0;
 525         }
 526
 527         ast_module_unref(bridge_technology->mod);
 528
 529         return 1;
 530 }
 531
 532 int ast_bridge_destroy(struct ast_bridge *bridge)
 533 {
 534         struct ast_bridge_channel *bridge_channel = NULL;
 535
 536         ao2_lock(bridge);
 537
 538         bridge->stop = 1;
 539
 540         bridge_poke(bridge);
 541
 542         ast_debug(1, "Telling all channels in bridge %p to end and leave the party\n", bridge);
 543
 544         /* Drop every bridged channel, the last one will cause the bridge thread (if it exists) to exit */
 545         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
 546                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
 547         }
 548
 549         ao2_unlock(bridge);
 550
 551         ao2_ref(bridge, -1);
 552
 553         return 0;
 554 }
 555
 556 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 557 {
 558         struct ast_format formats[2];
 559         ast_format_copy(&formats[0], &bridge_channel->chan->readformat);
 560         ast_format_copy(&formats[1], &bridge_channel->chan->writeformat);
 561
 562         /* Are the formats currently in use something ths bridge can handle? */
 563         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &bridge_channel->chan->readformat)) {
 564                 struct ast_format best_format;
 565                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
 566
 567                 /* Read format is a no go... */
 568                 if (option_debug) {
 569                         char codec_buf[512];
 570                         ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n", bridge->technology->name,
 571                                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
 572                                 ast_getformatname(&formats[0]));
 573                 }
 574                 /* Switch read format to the best one chosen */
 575                 if (ast_set_read_format(bridge_channel->chan, &best_format)) {
 576                         ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n", bridge_channel->chan->name, ast_getformatname(&best_format));
 577                         return -1;
 578                 }
 579                 ast_debug(1, "Bridge %p put channel %s into read format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&best_format));
 580         } else {
 581                 ast_debug(1, "Bridge %p is happy that channel %s already has read format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&formats[0]));
 582         }
 583
 584         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &formats[1])) {
 585                 struct ast_format best_format;
 586                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
 587
 588                 /* Write format is a no go... */
 589                 if (option_debug) {
 590                         char codec_buf[512];
 591                         ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n", bridge->technology->name,
 592                                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
 593                                 ast_getformatname(&formats[1]));
 594                 }
 595                 /* Switch write format to the best one chosen */
 596                 if (ast_set_write_format(bridge_channel->chan, &best_format)) {
 597                         ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n", bridge_channel->chan->name, ast_getformatname(&best_format));
 598                         return -1;
 599                 }
 600                 ast_debug(1, "Bridge %p put channel %s into write format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&best_format));
 601         } else {
 602                 ast_debug(1, "Bridge %p is happy that channel %s already has write format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&formats[1]));
 603         }
 604
 605         return 0;
 606 }
 607
 608 /*! \brief Perform the smart bridge operation. Basically sees if a new bridge technology should be used instead of the current one. */
 609 static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int count)
 610 {
 611         uint32_t new_capabilities = 0;
 612         struct ast_bridge_technology *new_technology = NULL, *old_technology = bridge->technology;
 613         struct ast_bridge temp_bridge = {
 614                 .technology = bridge->technology,
 615                 .bridge_pvt = bridge->bridge_pvt,
 616         };
 617         struct ast_bridge_channel *bridge_channel2 = NULL;
 618
 619         /* Based on current feature determine whether we want to change bridge technologies or not */
 620         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) {
 621                 if (count <= 2) {
 622                         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);
 623                         return 0;
 624                 }
 625                 new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
 626         } else if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
 627                 if (count > 2) {
 628                         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);
 629                         return 0;
 630                 }
 631                 new_capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX;
 632         }
 633
 634         if (!new_capabilities) {
 635                 ast_debug(1, "Bridge '%p' has no new capabilities, not performing smart bridge operation.\n", bridge);
 636                 return 0;
 637         }
 638
 639         /* Attempt to find a new bridge technology to satisfy the capabilities */
 640         if (!(new_technology = find_best_technology(new_capabilities))) {
 641                 return -1;
 642         }
 643
 644         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);
 645
 646         /* If a thread is currently executing for the current technology tell it to stop */
 647         if (bridge->thread != AST_PTHREADT_NULL) {
 648                 /* 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. */
 649                 if (new_technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD) {
 650                         ast_debug(1, "Telling current bridge thread for bridge %p to refresh\n", bridge);
 651                         bridge->refresh = 1;
 652                         bridge_poke(bridge);
 653                 } else {
 654                         pthread_t bridge_thread = bridge->thread;
 655                         ast_debug(1, "Telling current bridge thread for bridge %p to stop\n", bridge);
 656                         bridge->stop = 1;
 657                         bridge_poke(bridge);
 658                         ao2_unlock(bridge);
 659                         pthread_join(bridge_thread, NULL);
 660                         ao2_lock(bridge);
 661                 }
 662         }
 663
 664         /* 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 */
 665         bridge->bridge_pvt = NULL;
 666         bridge->technology = new_technology;
 667
 668         /* Pass the bridge to the new bridge technology so it can set it up */
 669         if (new_technology->create) {
 670                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", new_technology->name, bridge);
 671                 if (new_technology->create(bridge)) {
 672                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", new_technology->name, bridge);
 673                 }
 674         }
 675
 676         /* Move existing channels over to the new technology, while taking them away from the old one */
 677         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) {
 678                 /* Skip over channel that initiated the smart bridge operation */
 679                 if (bridge_channel == bridge_channel2) {
 680                         continue;
 681                 }
 682
 683                 /* First we part them from the old technology */
 684                 if (old_technology->leave) {
 685                         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);
 686                         if (old_technology->leave(&temp_bridge, bridge_channel2)) {
 687                                 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);
 688                         }
 689                 }
 690
 691                 /* Second we make them compatible again with the bridge */
 692                 bridge_make_compatible(bridge, bridge_channel2);
 693
 694                 /* Third we join them to the new technology */
 695                 if (new_technology->join) {
 696                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", new_technology->name, bridge_channel2, bridge);
 697                         if (new_technology->join(bridge, bridge_channel2)) {
 698                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", new_technology->name, bridge_channel2, bridge);
 699                         }
 700                 }
 701
 702                 /* Fourth we tell them to wake up so they become aware that they above has happened */
 703                 pthread_kill(bridge_channel2->thread, SIGURG);
 704                 ao2_lock(bridge_channel2);
 705                 ast_cond_signal(&bridge_channel2->cond);
 706                 ao2_unlock(bridge_channel2);
 707         }
 708
 709         /* 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 */
 710         if (old_technology->destroy) {
 711                 ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n", old_technology->name, &temp_bridge, bridge);
 712                 if (old_technology->destroy(&temp_bridge)) {
 713                         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);
 714                 }
 715         }
 716
 717         /* Finally if the old technology has module referencing remove our reference, we are no longer going to use it */
 718         if (old_technology->mod) {
 719                 ast_module_unref(old_technology->mod);
 720         }
 721
 722         return 0;
 723 }
 724
 725 /*! \brief Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve */
 726 static enum ast_bridge_channel_state bridge_channel_join_multithreaded(struct ast_bridge_channel *bridge_channel)
 727 {
 728         int fds[4] = { -1, }, nfds = 0, i = 0, outfd = -1, ms = -1;
 729         struct ast_channel *chan = NULL;
 730
 731         /* Add any file descriptors we may want to monitor */
 732         if (bridge_channel->bridge->technology->fd) {
 733                 for (i = 0; i < 4; i ++) {
 734                         if (bridge_channel->fds[i] >= 0) {
 735                                 fds[nfds++] = bridge_channel->fds[i];
 736                         }
 737                 }
 738         }
 739
 740         ao2_unlock(bridge_channel->bridge);
 741
 742         /* Wait for data to either come from the channel or us to be signalled */
 743         if (!bridge_channel->suspended) {
 744                 ast_debug(10, "Going into a multithreaded waitfor for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 745                 chan = ast_waitfor_nandfds(&bridge_channel->chan, 1, fds, nfds, NULL, &outfd, &ms);
 746         } else {
 747                 ao2_lock(bridge_channel);
 748                 ast_debug(10, "Going into a multithreaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 749                 ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
 750                 ao2_unlock(bridge_channel);
 751         }
 752
 753         ao2_lock(bridge_channel->bridge);
 754
 755         if (!bridge_channel->suspended) {
 756                 ast_bridge_handle_trip(bridge_channel->bridge, bridge_channel, chan, outfd);
 757         }
 758
 759         return bridge_channel->state;
 760 }
 761
 762 /*! \brief Run in a singlethreaded model. Each joined channel yields itself to the main bridge thread. TODO: Improve */
 763 static enum ast_bridge_channel_state bridge_channel_join_singlethreaded(struct ast_bridge_channel *bridge_channel)
 764 {
 765         ao2_unlock(bridge_channel->bridge);
 766         ao2_lock(bridge_channel);
 767         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 768                 ast_debug(1, "Going into a single threaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 769                 ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
 770         }
 771         ao2_unlock(bridge_channel);
 772         ao2_lock(bridge_channel->bridge);
 773
 774         return bridge_channel->state;
 775 }
 776
 777 /*! \brief Internal function that suspends a channel from a bridge */
 778 static void bridge_channel_suspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 779 {
 780         bridge_channel->suspended = 1;
 781
 782         bridge_array_remove(bridge, bridge_channel->chan);
 783
 784         if (bridge->technology->suspend) {
 785                 bridge->technology->suspend(bridge, bridge_channel);
 786         }
 787
 788         return;
 789 }
 790
 791 /*! \brief Internal function that unsuspends a channel from a bridge */
 792 static void bridge_channel_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 793 {
 794         bridge_channel->suspended =0;
 795
 796         bridge_array_add(bridge, bridge_channel->chan);
 797
 798         if (bridge->technology->unsuspend) {
 799                 bridge->technology->unsuspend(bridge, bridge_channel);
 800         }
 801
 802         return;
 803 }
 804
 805 /*!
 806  * \brief Internal function that executes a feature on a bridge channel
 807  * \note Neither the bridge nor the bridge_channel locks should be held when entering
 808  * this function.
 809  */
 810 static void bridge_channel_feature(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 811 {
 812         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 813         struct ast_bridge_features_hook *hook = NULL;
 814         char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = "";
 815         int look_for_dtmf = 1, dtmf_len = 0;
 816
 817         /* The channel is now under our control and we don't really want any begin frames to do our DTMF matching so disable 'em at the core level */
 818         ast_set_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 819
 820         /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */
 821         while (look_for_dtmf) {
 822                 int res = ast_waitfordigit(bridge_channel->chan, 3000);
 823
 824                 /* If the above timed out simply exit */
 825                 if (!res) {
 826                         ast_debug(1, "DTMF feature string collection on bridge channel %p timed out\n", bridge_channel);
 827                         break;
 828                 } else if (res < 0) {
 829                         ast_debug(1, "DTMF feature string collection failed on bridge channel %p for some reason\n", bridge_channel);
 830                         break;
 831                 }
 832
 833                 /* Add the above DTMF into the DTMF string so we can do our matching */
 834                 dtmf[dtmf_len++] = res;
 835
 836                 ast_debug(1, "DTMF feature string on bridge channel %p is now '%s'\n", bridge_channel, dtmf);
 837
 838                 /* Assume that we do not want to look for DTMF any longer */
 839                 look_for_dtmf = 0;
 840
 841                 /* See if a DTMF feature hook matches or can match */
 842                 AST_LIST_TRAVERSE(&features->hooks, hook, entry) {
 843                         /* If this hook matches just break out now */
 844                         if (!strcmp(hook->dtmf, dtmf)) {
 845                                 ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on bridge channel %p\n", hook, dtmf, bridge_channel);
 846                                 look_for_dtmf = 0;
 847                                 break;
 848                         } else if (!strncmp(hook->dtmf, dtmf, dtmf_len)) {
 849                                 ast_debug(1, "DTMF feature hook %p can match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel);
 850                                 look_for_dtmf = 1;
 851                         } else {
 852                                 ast_debug(1, "DTMF feature hook %p does not match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel);
 853                         }
 854                 }
 855
 856                 /* If we have reached the maximum length of a DTMF feature string bail out */
 857                 if (dtmf_len == MAXIMUM_DTMF_FEATURE_STRING) {
 858                         break;
 859                 }
 860         }
 861
 862         /* Since we are done bringing DTMF in return to using both begin and end frames */
 863         ast_clear_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 864
 865         /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
 866         if (hook) {
 867                 hook->callback(bridge, bridge_channel, hook->hook_pvt);
 868         } else {
 869                 ast_bridge_dtmf_stream(bridge, dtmf, bridge_channel->chan);
 870         }
 871
 872         /* if the channel is still in feature state, revert it back to wait state */
 873         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_FEATURE) {
 874                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 875         }
 876
 877         return;
 878 }
 879
 880 static void bridge_channel_talking(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 881 {
 882         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 883
 884         if (features && features->talker_cb) {
 885                 features->talker_cb(bridge, bridge_channel, features->talker_pvt_data);
 886         }
 887         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 888 }
 889
 890 /*! \brief Internal function that plays back DTMF on a bridge channel */
 891 static void bridge_channel_dtmf_stream(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 892 {
 893         char dtmf_q[8] = "";
 894
 895         ast_copy_string(dtmf_q, bridge_channel->dtmf_stream_q, sizeof(dtmf_q));
 896         bridge_channel->dtmf_stream_q[0] = '\0';
 897
 898         ast_debug(1, "Playing DTMF stream '%s' out to bridge channel %p\n", dtmf_q, bridge_channel);
 899         ast_dtmf_stream(bridge_channel->chan, NULL, dtmf_q, 250, 0);
 900
 901         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 902
 903         return;
 904 }
 905
 906 /*! \brief Join a channel to a bridge and handle anything the bridge may want us to do */
 907 static enum ast_bridge_channel_state bridge_channel_join(struct ast_bridge_channel *bridge_channel)
 908 {
 909         struct ast_format formats[2];
 910         enum ast_bridge_channel_state state;
 911         ast_format_copy(&formats[0], &bridge_channel->chan->readformat);
 912         ast_format_copy(&formats[1], &bridge_channel->chan->writeformat);
 913
 914         /* Record the thread that will be the owner of us */
 915         bridge_channel->thread = pthread_self();
 916
 917         ast_debug(1, "Joining bridge channel %p to bridge %p\n", bridge_channel, bridge_channel->bridge);
 918
 919         ao2_lock(bridge_channel->bridge);
 920
 921         state = bridge_channel->state;
 922
 923         /* Add channel into the bridge */
 924         AST_LIST_INSERT_TAIL(&bridge_channel->bridge->channels, bridge_channel, entry);
 925         bridge_channel->bridge->num++;
 926
 927         bridge_array_add(bridge_channel->bridge, bridge_channel->chan);
 928
 929         if (bridge_channel->swap) {
 930                 struct ast_bridge_channel *bridge_channel2 = NULL;
 931
 932                 /* If we are performing a swap operation we do not need
 933                  * to execute the smart bridge operation as the actual number
 934                  * of channels involved will not have changed, we just need to
 935                  * tell the other channel to leave */
 936                 if ((bridge_channel2 = find_bridge_channel(bridge_channel->bridge, bridge_channel->swap))) {
 937                         ast_debug(1, "Swapping bridge channel %p out from bridge %p so bridge channel %p can slip in\n", bridge_channel2, bridge_channel->bridge, bridge_channel);
 938                         ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP);
 939                 }
 940
 941                 bridge_channel->swap = NULL;
 942         } else if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
 943                 /* Perform the smart bridge operation, basically see if we need to move around between technologies */
 944                 smart_bridge_operation(bridge_channel->bridge, bridge_channel, bridge_channel->bridge->num);
 945         }
 946
 947         /* Make the channel compatible with the bridge */
 948         bridge_make_compatible(bridge_channel->bridge, bridge_channel);
 949
 950         /* Tell the bridge technology we are joining so they set us up */
 951         if (bridge_channel->bridge->technology->join) {
 952                 ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 953                 if (bridge_channel->bridge->technology->join(bridge_channel->bridge, bridge_channel)) {
 954                         ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 955                 }
 956         }
 957
 958         /* Actually execute the respective threading model, and keep our bridge thread alive */
 959         while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 960                 /* Update bridge pointer on channel */
 961                 bridge_channel->chan->bridge = bridge_channel->bridge;
 962                 /* If the technology requires a thread and one is not running, start it up */
 963                 if (bridge_channel->bridge->thread == AST_PTHREADT_NULL && (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) {
 964                         bridge_channel->bridge->stop = 0;
 965                         ast_debug(1, "Starting a bridge thread for bridge %p\n", bridge_channel->bridge);
 966                         ao2_ref(bridge_channel->bridge, +1);
 967                         if (ast_pthread_create(&bridge_channel->bridge->thread, NULL, bridge_thread, bridge_channel->bridge)) {
 968                                 ast_debug(1, "Failed to create a bridge thread for bridge %p, giving it another go.\n", bridge_channel->bridge);
 969                                 ao2_ref(bridge_channel->bridge, -1);
 970                                 continue;
 971                         }
 972                 }
 973                 /* Execute the threading model */
 974                 state = (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTITHREADED ? bridge_channel_join_multithreaded(bridge_channel) : bridge_channel_join_singlethreaded(bridge_channel));
 975                 /* Depending on the above state see what we need to do */
 976                 switch (state) {
 977                 case AST_BRIDGE_CHANNEL_STATE_FEATURE:
 978                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 979                         ao2_unlock(bridge_channel->bridge);
 980                         bridge_channel_feature(bridge_channel->bridge, bridge_channel);
 981                         ao2_lock(bridge_channel->bridge);
 982                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 983                         break;
 984                 case AST_BRIDGE_CHANNEL_STATE_DTMF:
 985                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 986                         bridge_channel_dtmf_stream(bridge_channel->bridge, bridge_channel);
 987                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 988                         break;
 989                 case AST_BRIDGE_CHANNEL_STATE_START_TALKING:
 990                 case AST_BRIDGE_CHANNEL_STATE_STOP_TALKING:
 991                         ao2_unlock(bridge_channel->bridge);
 992                         bridge_channel_talking(bridge_channel->bridge, bridge_channel);
 993                         ao2_lock(bridge_channel->bridge);
 994                         break;
 995                 default:
 996                         break;
 997                 }
 998         }
 999
1000         bridge_channel->chan->bridge = NULL;
1001
1002         /* See if we need to dissolve the bridge itself if they hung up */
1003         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_END) {
1004                 bridge_check_dissolve(bridge_channel->bridge, bridge_channel);
1005         }
1006
1007         /* Tell the bridge technology we are leaving so they tear us down */
1008         if (bridge_channel->bridge->technology->leave) {
1009                 ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
1010                 if (bridge_channel->bridge->technology->leave(bridge_channel->bridge, bridge_channel)) {
1011                         ast_debug(1, "Bridge technology %s failed to leave %p from bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
1012                 }
1013         }
1014
1015         /* Remove channel from the bridge */
1016         bridge_channel->bridge->num--;
1017         AST_LIST_REMOVE(&bridge_channel->bridge->channels, bridge_channel, entry);
1018
1019         bridge_array_remove(bridge_channel->bridge, bridge_channel->chan);
1020
1021         /* Perform the smart bridge operation if needed since a channel has left */
1022         if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
1023                 smart_bridge_operation(bridge_channel->bridge, NULL, bridge_channel->bridge->num);
1024         }
1025
1026         ao2_unlock(bridge_channel->bridge);
1027
1028         /* Restore original formats of the channel as they came in */
1029         if (ast_format_cmp(&bridge_channel->chan->readformat, &formats[0]) == AST_FORMAT_CMP_NOT_EQUAL) {
1030                 ast_debug(1, "Bridge is returning %p to read format %s(%d)\n", bridge_channel, ast_getformatname(&formats[0]), formats[0].id);
1031                 if (ast_set_read_format(bridge_channel->chan, &formats[0])) {
1032                         ast_debug(1, "Bridge failed to return channel %p to read format %s(%d)\n", bridge_channel, ast_getformatname(&formats[0]), formats[0].id);
1033                 }
1034         }
1035         if (ast_format_cmp(&bridge_channel->chan->writeformat, &formats[1]) == AST_FORMAT_CMP_NOT_EQUAL) {
1036                 ast_debug(1, "Bridge is returning %p to write format %s(%d)\n", bridge_channel, ast_getformatname(&formats[1]), formats[1].id);
1037                 if (ast_set_write_format(bridge_channel->chan, &formats[1])) {
1038                         ast_debug(1, "Bridge failed to return channel %p to write format %s(%d)\n", bridge_channel, ast_getformatname(&formats[1]), formats[1].id);
1039                 }
1040         }
1041
1042         return bridge_channel->state;
1043 }
1044
1045 static void bridge_channel_destroy(void *obj)
1046 {
1047         struct ast_bridge_channel *bridge_channel = obj;
1048
1049         if (bridge_channel->bridge) {
1050                 ao2_ref(bridge_channel->bridge, -1);
1051                 bridge_channel->bridge = NULL;
1052         }
1053         /* Destroy elements of the bridge channel structure and the bridge channel structure itself */
1054         ast_cond_destroy(&bridge_channel->cond);
1055 }
1056
1057 static struct ast_bridge_channel *bridge_channel_alloc(struct ast_bridge *bridge)
1058 {
1059         struct ast_bridge_channel *bridge_channel = ao2_alloc(sizeof(struct ast_bridge_channel), bridge_channel_destroy);
1060         if (!(bridge_channel)) {
1061                 return NULL;
1062         }
1063         ast_cond_init(&bridge_channel->cond, NULL);
1064         if (bridge) {
1065                 bridge_channel->bridge = bridge;
1066                 ao2_ref(bridge_channel->bridge, +1);
1067         }
1068         return bridge_channel;
1069 }
1070
1071 enum ast_bridge_channel_state ast_bridge_join(struct ast_bridge *bridge,
1072         struct ast_channel *chan,
1073         struct ast_channel *swap,
1074         struct ast_bridge_features *features,
1075         struct ast_bridge_tech_optimizations *tech_args)
1076 {
1077         struct ast_bridge_channel *bridge_channel = bridge_channel_alloc(bridge);
1078         enum ast_bridge_channel_state state = AST_BRIDGE_CHANNEL_STATE_HANGUP;
1079
1080         if (!bridge_channel) {
1081                 return state;
1082         }
1083         if (tech_args) {
1084                 memcpy(&bridge_channel->tech_args, tech_args, sizeof(bridge_channel->tech_args));
1085         }
1086
1087         /* Initialize various other elements of the bridge channel structure that we can't do above */
1088         bridge_channel->chan = chan;
1089         bridge_channel->swap = swap;
1090         bridge_channel->features = features;
1091
1092         state = bridge_channel_join(bridge_channel);
1093
1094         /* Cleanup all the data in the bridge channel after it leaves the bridge. */
1095         ao2_lock(bridge_channel);
1096         bridge_channel->chan = NULL;
1097         bridge_channel->swap = NULL;
1098         bridge_channel->features = NULL;
1099         ao2_unlock(bridge_channel);
1100
1101         ao2_ref(bridge_channel, -1);
1102
1103         return state;
1104 }
1105
1106 /*! \brief Thread responsible for imparted bridged channels */
1107 static void *bridge_channel_thread(void *data)
1108 {
1109         struct ast_bridge_channel *bridge_channel = data;
1110         enum ast_bridge_channel_state state;
1111
1112         state = bridge_channel_join(bridge_channel);
1113
1114         /* If no other thread is going to take the channel then hang it up, or else we would have to service it until something else came along */
1115         if (state == AST_BRIDGE_CHANNEL_STATE_END || state == AST_BRIDGE_CHANNEL_STATE_HANGUP) {
1116                 ast_hangup(bridge_channel->chan);
1117         }
1118
1119         /* cleanup */
1120         ao2_lock(bridge_channel);
1121         bridge_channel->chan = NULL;
1122         bridge_channel->swap = NULL;
1123         bridge_channel->features = NULL;
1124         ao2_unlock(bridge_channel);
1125
1126         ao2_ref(bridge_channel, -1);
1127
1128         return NULL;
1129 }
1130
1131 int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
1132 {
1133         struct ast_bridge_channel *bridge_channel = bridge_channel_alloc(bridge);
1134         /* Try to allocate a structure for the bridge channel */
1135         if (!(bridge_channel)) {
1136                 return -1;
1137         }
1138
1139         /* Setup various parameters */
1140         bridge_channel->chan = chan;
1141         bridge_channel->swap = swap;
1142         bridge_channel->features = features;
1143
1144         /* Actually create the thread that will handle the channel */
1145         if (ast_pthread_create(&bridge_channel->thread, NULL, bridge_channel_thread, bridge_channel)) {
1146                 ao2_ref(bridge_channel, -1);
1147                 return -1;
1148         }
1149
1150         return 0;
1151 }
1152
1153 int ast_bridge_depart(struct ast_bridge *bridge, struct ast_channel *chan)
1154 {
1155         struct ast_bridge_channel *bridge_channel = NULL;
1156         pthread_t thread;
1157
1158         ao2_lock(bridge);
1159
1160         /* Try to find the channel that we want to depart */
1161         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1162                 ao2_unlock(bridge);
1163                 return -1;
1164         }
1165
1166         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DEPART);
1167         thread = bridge_channel->thread;
1168
1169         ao2_unlock(bridge);
1170
1171         pthread_join(thread, NULL);
1172
1173         return 0;
1174 }
1175
1176 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
1177 {
1178         struct ast_bridge_channel *bridge_channel = NULL;
1179
1180         ao2_lock(bridge);
1181
1182         /* Try to find the channel that we want to remove */
1183         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1184                 ao2_unlock(bridge);
1185                 return -1;
1186         }
1187
1188         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
1189
1190         ao2_unlock(bridge);
1191
1192         return 0;
1193 }
1194
1195 int ast_bridge_merge(struct ast_bridge *bridge0, struct ast_bridge *bridge1)
1196 {
1197         struct ast_bridge_channel *bridge_channel = NULL;
1198
1199         ao2_lock(bridge0);
1200         ao2_lock(bridge1);
1201
1202         /* If the first bridge currently has 2 channels and is not capable of becoming a multimixing bridge we can not merge */
1203         if ((bridge0->num + bridge1->num) > 2 && (!(bridge0->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) && !ast_test_flag(&bridge0->feature_flags, AST_BRIDGE_FLAG_SMART))) {
1204                 ao2_unlock(bridge1);
1205                 ao2_unlock(bridge0);
1206                 ast_debug(1, "Can't merge bridge %p into bridge %p, multimix is needed and it could not be acquired.\n", bridge1, bridge0);
1207                 return -1;
1208         }
1209
1210         ast_debug(1, "Merging channels from bridge %p into bridge %p\n", bridge1, bridge0);
1211
1212         /* Perform smart bridge operation on bridge we are merging into so it can change bridge technology if needed */
1213         if (smart_bridge_operation(bridge0, NULL, bridge0->num + bridge1->num)) {
1214                 ao2_unlock(bridge1);
1215                 ao2_unlock(bridge0);
1216                 ast_debug(1, "Can't merge bridge %p into bridge %p, tried to perform smart bridge operation and failed.\n", bridge1, bridge0);
1217                 return -1;
1218         }
1219
1220         /* If a thread is currently executing on bridge1 tell it to stop */
1221         if (bridge1->thread) {
1222                 ast_debug(1, "Telling bridge thread on bridge %p to stop as it is being merged into %p\n", bridge1, bridge0);
1223                 bridge1->thread = AST_PTHREADT_STOP;
1224         }
1225
1226         /* Move channels from bridge1 over to bridge0 */
1227         while ((bridge_channel = AST_LIST_REMOVE_HEAD(&bridge1->channels, entry))) {
1228                 /* Tell the technology handling bridge1 that the bridge channel is leaving */
1229                 if (bridge1->technology->leave) {
1230                         ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1231                         if (bridge1->technology->leave(bridge1, bridge_channel)) {
1232                                 ast_debug(1, "Bridge technology %s failed to allow %p to leave bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1233                         }
1234                 }
1235
1236                 /* Drop channel count and reference count on the bridge they are leaving */
1237                 bridge1->num--;
1238                 ao2_ref(bridge1, -1);
1239
1240                 bridge_array_remove(bridge1, bridge_channel->chan);
1241
1242                 /* Now add them into the bridge they are joining, increase channel count, and bump up reference count */
1243                 bridge_channel->bridge = bridge0;
1244                 AST_LIST_INSERT_TAIL(&bridge0->channels, bridge_channel, entry);
1245                 bridge0->num++;
1246                 ao2_ref(bridge0, +1);
1247
1248                 bridge_array_add(bridge0, bridge_channel->chan);
1249
1250                 /* Make the channel compatible with the new bridge it is joining or else formats would go amuck */
1251                 bridge_make_compatible(bridge0, bridge_channel);
1252
1253                 /* Tell the technology handling bridge0 that the bridge channel is joining */
1254                 if (bridge0->technology->join) {
1255                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1256                         if (bridge0->technology->join(bridge0, bridge_channel)) {
1257                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1258                         }
1259                 }
1260
1261                 /* Poke the bridge channel, this will cause it to wake up and execute the proper threading model for the new bridge it is in */
1262                 pthread_kill(bridge_channel->thread, SIGURG);
1263                 ao2_lock(bridge_channel);
1264                 ast_cond_signal(&bridge_channel->cond);
1265                 ao2_unlock(bridge_channel);
1266         }
1267
1268         ast_debug(1, "Merged channels from bridge %p into bridge %p\n", bridge1, bridge0);
1269
1270         ao2_unlock(bridge1);
1271         ao2_unlock(bridge0);
1272
1273         return 0;
1274 }
1275
1276 int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
1277 {
1278         struct ast_bridge_channel *bridge_channel;
1279
1280         ao2_lock(bridge);
1281
1282         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1283                 ao2_unlock(bridge);
1284                 return -1;
1285         }
1286
1287         bridge_channel_suspend(bridge, bridge_channel);
1288
1289         ao2_unlock(bridge);
1290
1291         return 0;
1292 }
1293
1294 int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
1295 {
1296         struct ast_bridge_channel *bridge_channel;
1297
1298         ao2_lock(bridge);
1299
1300         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1301                 ao2_unlock(bridge);
1302                 return -1;
1303         }
1304
1305         bridge_channel_unsuspend(bridge, bridge_channel);
1306
1307         ao2_unlock(bridge);
1308
1309         return 0;
1310 }
1311
1312 void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
1313 {
1314         technology->suspended = 1;
1315         return;
1316 }
1317
1318 void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
1319 {
1320         technology->suspended = 0;
1321         return;
1322 }
1323
1324 int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_features_hook_callback callback, const char *dtmf)
1325 {
1326         if (builtin_features_handlers[feature]) {
1327                 return -1;
1328         }
1329
1330         if (!ast_strlen_zero(dtmf)) {
1331                 ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
1332         }
1333
1334         builtin_features_handlers[feature] = callback;
1335
1336         return 0;
1337 }
1338
1339 int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
1340 {
1341         if (!builtin_features_handlers[feature]) {
1342                 return -1;
1343         }
1344
1345         builtin_features_handlers[feature] = NULL;
1346
1347         return 0;
1348 }
1349
1350 int ast_bridge_features_hook(struct ast_bridge_features *features,
1351         const char *dtmf,
1352         ast_bridge_features_hook_callback callback,
1353         void *hook_pvt,
1354         ast_bridge_features_hook_pvt_destructor destructor)
1355 {
1356         struct ast_bridge_features_hook *hook = NULL;
1357
1358         /* Allocate new memory and setup it's various variables */
1359         if (!(hook = ast_calloc(1, sizeof(*hook)))) {
1360                 return -1;
1361         }
1362
1363         ast_copy_string(hook->dtmf, dtmf, sizeof(hook->dtmf));
1364         hook->callback = callback;
1365         hook->destructor = destructor;
1366         hook->hook_pvt = hook_pvt;
1367
1368         /* Once done we add it onto the list. Now it will be picked up when DTMF is used */
1369         AST_LIST_INSERT_TAIL(&features->hooks, hook, entry);
1370
1371         features->usable = 1;
1372
1373         return 0;
1374 }
1375
1376 int ast_bridge_features_set_talk_detector(struct ast_bridge_features *features,
1377         ast_bridge_talking_indicate_callback talker_cb,
1378         ast_bridge_talking_indicate_destructor talker_destructor,
1379         void *pvt_data)
1380 {
1381         features->talker_cb = talker_cb;
1382         features->talker_destructor_cb = talker_destructor;
1383         features->talker_pvt_data = pvt_data;
1384         return 0;
1385 }
1386
1387 int ast_bridge_features_enable(struct ast_bridge_features *features, enum ast_bridge_builtin_feature feature, const char *dtmf, void *config)
1388 {
1389         /* If no alternate DTMF stream was provided use the default one */
1390         if (ast_strlen_zero(dtmf)) {
1391                 dtmf = builtin_features_dtmf[feature];
1392                 /* If no DTMF is still available (ie: it has been disabled) then error out now */
1393                 if (ast_strlen_zero(dtmf)) {
1394                         ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n", feature, features);
1395                         return -1;
1396                 }
1397         }
1398
1399         if (!builtin_features_handlers[feature]) {
1400                 return -1;
1401         }
1402
1403         /* The rest is basically pretty easy. We create another hook using the built in feature's callback and DTMF, easy as pie. */
1404         return ast_bridge_features_hook(features, dtmf, builtin_features_handlers[feature], config, NULL);
1405 }
1406
1407 int ast_bridge_features_set_flag(struct ast_bridge_features *features, enum ast_bridge_feature_flags flag)
1408 {
1409         ast_set_flag(&features->feature_flags, flag);
1410         features->usable = 1;
1411         return 0;
1412 }
1413
1414 int ast_bridge_features_init(struct ast_bridge_features *features)
1415 {
1416         /* Zero out the structure */
1417         memset(features, 0, sizeof(*features));
1418
1419         /* Initialize the hooks list, just in case */
1420         AST_LIST_HEAD_INIT_NOLOCK(&features->hooks);
1421
1422         return 0;
1423 }
1424
1425 int ast_bridge_features_cleanup(struct ast_bridge_features *features)
1426 {
1427         struct ast_bridge_features_hook *hook = NULL;
1428
1429         /* This is relatively simple, hooks are kept as a list on the features structure so we just pop them off and free them */
1430         while ((hook = AST_LIST_REMOVE_HEAD(&features->hooks, entry))) {
1431                 if (hook->destructor) {
1432                         hook->destructor(hook->hook_pvt);
1433                 }
1434                 ast_free(hook);
1435         }
1436         if (features->talker_destructor_cb && features->talker_pvt_data) {
1437                 features->talker_destructor_cb(features->talker_pvt_data);
1438                 features->talker_pvt_data = NULL;
1439         }
1440
1441         return 0;
1442 }
1443
1444 int ast_bridge_dtmf_stream(struct ast_bridge *bridge, const char *dtmf, struct ast_channel *chan)
1445 {
1446         struct ast_bridge_channel *bridge_channel = NULL;
1447
1448         ao2_lock(bridge);
1449
1450         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1451                 if (bridge_channel->chan == chan) {
1452                         continue;
1453                 }
1454                 ast_copy_string(bridge_channel->dtmf_stream_q, dtmf, sizeof(bridge_channel->dtmf_stream_q));
1455                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DTMF);
1456         }
1457
1458         ao2_unlock(bridge);
1459
1460         return 0;
1461 }
1462
1463 void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval)
1464 {
1465         ao2_lock(bridge);
1466         bridge->internal_mixing_interval = mixing_interval;
1467         ao2_unlock(bridge);
1468 }
1469
1470 void ast_bridge_set_internal_sample_rate(struct ast_bridge *bridge, unsigned int sample_rate)
1471 {
1472
1473         ao2_lock(bridge);
1474         bridge->internal_sample_rate = sample_rate;
1475         ao2_unlock(bridge);
1476 }
1477
1478 static void cleanup_video_mode(struct ast_bridge *bridge)
1479 {
1480         switch (bridge->video_mode.mode) {
1481         case AST_BRIDGE_VIDEO_MODE_NONE:
1482                 break;
1483         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1484                 if (bridge->video_mode.mode_data.single_src_data.chan_vsrc) {
1485                         ast_channel_unref(bridge->video_mode.mode_data.single_src_data.chan_vsrc);
1486                 }
1487                 break;
1488         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1489                 if (bridge->video_mode.mode_data.talker_src_data.chan_vsrc) {
1490                         ast_channel_unref(bridge->video_mode.mode_data.talker_src_data.chan_vsrc);
1491                 }
1492                 if (bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc) {
1493                         ast_channel_unref(bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc);
1494                 }
1495         }
1496         memset(&bridge->video_mode, 0, sizeof(bridge->video_mode));
1497 }
1498
1499 void ast_bridge_set_single_src_video_mode(struct ast_bridge *bridge, struct ast_channel *video_src_chan)
1500 {
1501         ao2_lock(bridge);
1502         cleanup_video_mode(bridge);
1503         bridge->video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
1504         bridge->video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan);
1505         ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE);
1506         ao2_unlock(bridge);
1507 }
1508
1509 void ast_bridge_set_talker_src_video_mode(struct ast_bridge *bridge)
1510 {
1511         ao2_lock(bridge);
1512         cleanup_video_mode(bridge);
1513         bridge->video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
1514         ao2_unlock(bridge);
1515 }
1516
1517 void ast_bridge_update_talker_src_video_mode(struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe)
1518 {
1519         struct ast_bridge_video_talker_src_data *data;
1520         /* If the channel doesn't support video, we don't care about it */
1521         if (!ast_format_cap_has_type(chan->nativeformats, AST_FORMAT_TYPE_VIDEO)) {
1522                 return;
1523         }
1524
1525         ao2_lock(bridge);
1526         data = &bridge->video_mode.mode_data.talker_src_data;
1527
1528         if (data->chan_vsrc == chan) {
1529                 data->average_talking_energy = talker_energy;
1530         } else if ((data->average_talking_energy < talker_energy) && is_keyframe) {
1531                 if (data->chan_old_vsrc) {
1532                         ast_channel_unref(data->chan_old_vsrc);
1533                 }
1534                 if (data->chan_vsrc) {
1535                         data->chan_old_vsrc = data->chan_vsrc;
1536                         ast_indicate(data->chan_old_vsrc, AST_CONTROL_VIDUPDATE);
1537                 }
1538                 data->chan_vsrc = ast_channel_ref(chan);
1539                 data->average_talking_energy = talker_energy;
1540         } else if ((data->average_talking_energy < talker_energy) && !is_keyframe) {
1541                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
1542         } else if (!data->chan_vsrc && is_keyframe) {
1543                 data->chan_vsrc = ast_channel_ref(chan);
1544                 data->average_talking_energy = talker_energy;
1545                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
1546         } else if (!data->chan_old_vsrc && is_keyframe) {
1547                 data->chan_old_vsrc = ast_channel_ref(chan);
1548                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
1549         }
1550         ao2_unlock(bridge);
1551 }
1552
1553 int ast_bridge_number_video_src(struct ast_bridge *bridge)
1554 {
1555         int res = 0;
1556
1557         ao2_lock(bridge);
1558         switch (bridge->video_mode.mode) {
1559         case AST_BRIDGE_VIDEO_MODE_NONE:
1560                 break;
1561         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1562                 if (bridge->video_mode.mode_data.single_src_data.chan_vsrc) {
1563                         res = 1;
1564                 }
1565                 break;
1566         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1567                 if (bridge->video_mode.mode_data.talker_src_data.chan_vsrc) {
1568                         res++;
1569                 }
1570                 if (bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc) {
1571                         res++;
1572                 }
1573         }
1574         ao2_unlock(bridge);
1575         return res;
1576 }
1577
1578 int ast_bridge_is_video_src(struct ast_bridge *bridge, struct ast_channel *chan)
1579 {
1580         int res = 0;
1581
1582         ao2_lock(bridge);
1583         switch (bridge->video_mode.mode) {
1584         case AST_BRIDGE_VIDEO_MODE_NONE:
1585                 break;
1586         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1587                 if (bridge->video_mode.mode_data.single_src_data.chan_vsrc == chan) {
1588                         res = 1;
1589                 }
1590                 break;
1591         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1592                 if (bridge->video_mode.mode_data.talker_src_data.chan_vsrc == chan) {
1593                         res = 1;
1594                 } else if (bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) {
1595                         res = 2;
1596                 }
1597
1598         }
1599         ao2_unlock(bridge);
1600         return res;
1601 }
1602
1603 void ast_bridge_remove_video_src(struct ast_bridge *bridge, struct ast_channel *chan)
1604 {
1605         ao2_lock(bridge);
1606         switch (bridge->video_mode.mode) {
1607         case AST_BRIDGE_VIDEO_MODE_NONE:
1608                 break;
1609         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
1610                 if (bridge->video_mode.mode_data.single_src_data.chan_vsrc == chan) {
1611                         if (bridge->video_mode.mode_data.single_src_data.chan_vsrc) {
1612                                 ast_channel_unref(bridge->video_mode.mode_data.single_src_data.chan_vsrc);
1613                         }
1614                         bridge->video_mode.mode_data.single_src_data.chan_vsrc = NULL;
1615                 }
1616                 break;
1617         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
1618                 if (bridge->video_mode.mode_data.talker_src_data.chan_vsrc == chan) {
1619                         if (bridge->video_mode.mode_data.talker_src_data.chan_vsrc) {
1620                                 ast_channel_unref(bridge->video_mode.mode_data.talker_src_data.chan_vsrc);
1621                         }
1622                         bridge->video_mode.mode_data.talker_src_data.chan_vsrc = NULL;
1623                         bridge->video_mode.mode_data.talker_src_data.average_talking_energy = 0;
1624                 }
1625                 if (bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) {
1626                         if (bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc) {
1627                                 ast_channel_unref(bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc);
1628                         }
1629                         bridge->video_mode.mode_data.talker_src_data.chan_old_vsrc = NULL;
1630                 }
1631         }
1632         ao2_unlock(bridge);
1633 }