A great big renaming patch

This patch renames the bridging* files to bridge*. This may seem pedantic
and silly, but it fits better in line with current Asterisk naming conventions:
* channel is not "channeling"
* monitor is not "monitoring"
etc.

A bridge is an object. It is a first class citizen in Asterisk. "Bridging" is
the act of using a bridge on a set of channels - and the API that fulfills that
role is more than just the action.

(closes issue ASTERISK-22130)


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@395378 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 0 insertions, 4831 deletions

diff --git a/main/bridging.c b/main/bridging.c
deleted file mode 100644
index 1e1e6c763..000000000
--- a/main/bridging.c
+++ /dev/null
@@ -1,4831 +0,0 @@
-/*
- * Asterisk -- An open source telephony toolkit.
- *
- * Copyright (C) 2007 - 2009, Digium, Inc.
- *
- * Joshua Colp <jcolp@digium.com>
- *
- * See http://www.asterisk.org for more information about
- * the Asterisk project. Please do not directly contact
- * any of the maintainers of this project for assistance;
- * the project provides a web site, mailing lists and IRC
- * channels for your use.
- *
- * This program is free software, distributed under the terms of
- * the GNU General Public License Version 2. See the LICENSE file
- * at the top of the source tree.
- */
-
-/*! \file
- *
- * \brief Bridging API
- *
- * \author Joshua Colp <jcolp@digium.com>
- */
-
-/*** MODULEINFO
-	<support_level>core</support_level>
- ***/
-
-#include "asterisk.h"
-
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
-
-#include "asterisk/logger.h"
-#include "asterisk/channel.h"
-#include "asterisk/options.h"
-#include "asterisk/utils.h"
-#include "asterisk/lock.h"
-#include "asterisk/linkedlists.h"
-#include "asterisk/bridging.h"
-#include "asterisk/bridging_internal.h"
-#include "asterisk/bridging_channel_internal.h"
-#include "asterisk/bridging_basic.h"
-#include "asterisk/bridging_technology.h"
-#include "asterisk/bridging_channel.h"
-#include "asterisk/bridging_after.h"
-#include "asterisk/stasis_bridging.h"
-#include "asterisk/stasis_channels.h"
-#include "asterisk/app.h"
-#include "asterisk/file.h"
-#include "asterisk/module.h"
-#include "asterisk/astobj2.h"
-#include "asterisk/pbx.h"
-#include "asterisk/test.h"
-#include "asterisk/_private.h"
-
-#include "asterisk/heap.h"
-#include "asterisk/say.h"
-#include "asterisk/timing.h"
-#include "asterisk/stringfields.h"
-#include "asterisk/musiconhold.h"
-#include "asterisk/features.h"
-#include "asterisk/cli.h"
-#include "asterisk/parking.h"
-#include "asterisk/core_local.h"
-#include "asterisk/core_unreal.h"
-
-/*! All bridges container. */
-static struct ao2_container *bridges;
-
-static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);
-
-/* Initial starting point for the bridge array of channels */
-#define BRIDGE_ARRAY_START 128
-
-/* Grow rate of bridge array of channels */
-#define BRIDGE_ARRAY_GROW 32
-
-static void cleanup_video_mode(struct ast_bridge *bridge);
-static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
-
-/*! Default DTMF keys for built in features */
-static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];
-
-/*! Function handlers for the built in features */
-static ast_bridge_hook_callback builtin_features_handlers[AST_BRIDGE_BUILTIN_END];
-
-/*! Function handlers for built in interval features */
-static ast_bridge_builtin_set_limits_fn builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_END];
-
-/*! Bridge manager service request */
-struct bridge_manager_request {
-	/*! List of bridge service requests. */
-	AST_LIST_ENTRY(bridge_manager_request) node;
-	/*! Refed bridge requesting service. */
-	struct ast_bridge *bridge;
-};
-
-struct bridge_manager_controller {
-	/*! Condition, used to wake up the bridge manager thread. */
-	ast_cond_t cond;
-	/*! Queue of bridge service requests. */
-	AST_LIST_HEAD_NOLOCK(, bridge_manager_request) service_requests;
-	/*! Manager thread */
-	pthread_t thread;
-	/*! TRUE if the manager needs to stop. */
-	unsigned int stop:1;
-};
-
-/*! Bridge manager controller. */
-static struct bridge_manager_controller *bridge_manager;
-
-/*!
- * \internal
- * \brief Request service for a bridge from the bridge manager.
- * \since 12.0.0
- *
- * \param bridge Requesting service.
- *
- * \return Nothing
- */
-static void bridge_manager_service_req(struct ast_bridge *bridge)
-{
-	struct bridge_manager_request *request;
-
-	ao2_lock(bridge_manager);
-	if (bridge_manager->stop) {
-		ao2_unlock(bridge_manager);
-		return;
-	}
-
-	/* Create the service request. */
-	request = ast_calloc(1, sizeof(*request));
-	if (!request) {
-		/* Well. This isn't good. */
-		ao2_unlock(bridge_manager);
-		return;
-	}
-	ao2_ref(bridge, +1);
-	request->bridge = bridge;
-
-	/* Put request into the queue and wake the bridge manager. */
-	AST_LIST_INSERT_TAIL(&bridge_manager->service_requests, request, node);
-	ast_cond_signal(&bridge_manager->cond);
-	ao2_unlock(bridge_manager);
-}
-
-int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
-{
-	struct ast_bridge_technology *current;
-
-	/* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
-	if (ast_strlen_zero(technology->name)
-		|| !technology->capabilities
-		|| !technology->write) {
-		ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n",
-			technology->name);
-		return -1;
-	}
-
-	AST_RWLIST_WRLOCK(&bridge_technologies);
-
-	/* Look for duplicate bridge technology already using this name, or already registered */
-	AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
-		if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
-			ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n",
-				technology->name);
-			AST_RWLIST_UNLOCK(&bridge_technologies);
-			return -1;
-		}
-	}
-
-	/* Copy module pointer so reference counting can keep the module from unloading */
-	technology->mod = module;
-
-	/* Insert our new bridge technology into the list and print out a pretty message */
-	AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);
-
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-
-	ast_verb(2, "Registered bridge technology %s\n", technology->name);
-
-	return 0;
-}
-
-int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
-{
-	struct ast_bridge_technology *current;
-
-	AST_RWLIST_WRLOCK(&bridge_technologies);
-
-	/* Ensure the bridge technology is registered before removing it */
-	AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
-		if (current == technology) {
-			AST_RWLIST_REMOVE_CURRENT(entry);
-			ast_verb(2, "Unregistered bridge technology %s\n", technology->name);
-			break;
-		}
-	}
-	AST_RWLIST_TRAVERSE_SAFE_END;
-
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-
-	return current ? 0 : -1;
-}
-
-/*!
- * \internal
- * \brief Put an action onto the specified bridge. Don't dup the action frame.
- * \since 12.0.0
- *
- * \param bridge What to queue the action on.
- * \param action What to do.
- *
- * \return Nothing
- */
-static void bridge_queue_action_nodup(struct ast_bridge *bridge, struct ast_frame *action)
-{
-	ast_debug(1, "Bridge %s: queueing action type:%d sub:%d\n",
-		bridge->uniqueid, action->frametype, action->subclass.integer);
-
-	ast_bridge_lock(bridge);
-	AST_LIST_INSERT_TAIL(&bridge->action_queue, action, frame_list);
-	ast_bridge_unlock(bridge);
-	bridge_manager_service_req(bridge);
-}
-
-int ast_bridge_queue_action(struct ast_bridge *bridge, struct ast_frame *action)
-{
-	struct ast_frame *dup;
-
-	dup = ast_frdup(action);
-	if (!dup) {
-		return -1;
-	}
-	bridge_queue_action_nodup(bridge, dup);
-	return 0;
-}
-
-/*!
- * \internal
- * \brief Dissolve the bridge.
- * \since 12.0.0
- *
- * \param bridge Bridge to eject all channels
- *
- * \details
- * Force out all channels that are not already going out of the
- * bridge.  Any new channels joining will leave immediately.
- *
- * \note On entry, bridge is already locked.
- *
- * \return Nothing
- */
-void bridge_dissolve(struct ast_bridge *bridge)
-{
-	struct ast_bridge_channel *bridge_channel;
-	struct ast_frame action = {
-		.frametype = AST_FRAME_BRIDGE_ACTION,
-		.subclass.integer = BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING,
-	};
-
-	if (bridge->dissolved) {
-		return;
-	}
-	bridge->dissolved = 1;
-
-	ast_debug(1, "Bridge %s: dissolving bridge\n", bridge->uniqueid);
-
-/* BUGBUG need a cause code on the bridge for the later ejected channels. */
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-	}
-
-	/* Must defer dissolving bridge because it is already locked. */
-	ast_bridge_queue_action(bridge, &action);
-}
-
-/*!
- * \internal
- * \brief Check if a bridge should dissolve because of a stolen channel and do it.
- * \since 12.0.0
- *
- * \param bridge Bridge to check.
- * \param bridge_channel Stolen channel causing the check.  It is not in the bridge to check and may be in another bridge.
- *
- * \note On entry, bridge and bridge_channel->bridge are already locked.
- *
- * \return Nothing
- */
-static void bridge_dissolve_check_stolen(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
-{
-	if (bridge->dissolved) {
-		return;
-	}
-
-	if (bridge_channel->features->usable
-		&& ast_test_flag(&bridge_channel->features->feature_flags,
-			AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP)) {
-		/* The stolen channel controlled the bridge it was stolen from. */
-		bridge_dissolve(bridge);
-		return;
-	}
-	if (bridge->num_channels < 2
-		&& ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)) {
-		/*
-		 * The stolen channel has not left enough channels to keep the
-		 * bridge alive.  Assume the stolen channel hung up.
-		 */
-		bridge_dissolve(bridge);
-		return;
-	}
-}
-
-/*!
- * \internal
- * \brief Update connected line information after a bridge has been reconfigured.
- *
- * \param bridge The bridge itself.
- *
- * \return Nothing
- */
-static void bridge_reconfigured_connected_line_update(struct ast_bridge *bridge)
-{
-	struct ast_party_connected_line connected;
-	struct ast_bridge_channel *bridge_channel = AST_LIST_FIRST(&bridge->channels), *peer;
-	unsigned char data[1024];
-	size_t datalen;
-
-	if (!bridge_channel ||
-		!(bridge->technology->capabilities & (AST_BRIDGE_CAPABILITY_1TO1MIX | AST_BRIDGE_CAPABILITY_NATIVE)) ||
-		!(peer = ast_bridge_channel_peer(bridge_channel)) ||
-		ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE) ||
-		ast_test_flag(ast_channel_flags(peer->chan), AST_FLAG_ZOMBIE) ||
-		ast_check_hangup_locked(bridge_channel->chan) ||
-		ast_check_hangup_locked(peer->chan)) {
-		return;
-	}
-
-	ast_party_connected_line_init(&connected);
-
-	ast_channel_lock(bridge_channel->chan);
-	ast_connected_line_copy_from_caller(&connected, ast_channel_caller(bridge_channel->chan));
-	ast_channel_unlock(bridge_channel->chan);
-
-	if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) {
-		ast_bridge_channel_queue_control_data(peer, AST_CONTROL_CONNECTED_LINE, data, datalen);
-	}
-
-	ast_channel_lock(peer->chan);
-	ast_connected_line_copy_from_caller(&connected, ast_channel_caller(peer->chan));
-	ast_channel_unlock(peer->chan);
-
-	if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) {
-		ast_bridge_channel_queue_control_data(bridge_channel, AST_CONTROL_CONNECTED_LINE, data, datalen);
-	}
-
-	ast_party_connected_line_free(&connected);
-}
-
-/*!
- * \internal
- * \brief Complete joining a channel to the bridge.
- * \since 12.0.0
- *
- * \param bridge What to operate upon.
- * \param bridge_channel What is joining the bridge technology.
- *
- * \note On entry, bridge is already locked.
- *
- * \return Nothing
- */
-static void bridge_channel_complete_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
-{
-	/* Make the channel compatible with the bridge */
-	bridge_make_compatible(bridge, bridge_channel);
-
-	/* Tell the bridge technology we are joining so they set us up */
-	ast_debug(1, "Bridge %s: %p(%s) is joining %s technology\n",
-		bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
-		bridge->technology->name);
-	if (bridge->technology->join
-		&& bridge->technology->join(bridge, bridge_channel)) {
-		ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology\n",
-			bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
-			bridge->technology->name);
-		bridge_channel->just_joined = 1;
-		return;
-	}
-
-	bridge_channel->just_joined = 0;
-}
-
-/*!
- * \internal
- * \brief Complete joining new channels to the bridge.
- * \since 12.0.0
- *
- * \param bridge Check for new channels on this bridge.
- *
- * \note On entry, bridge is already locked.
- *
- * \return Nothing
- */
-static void bridge_complete_join(struct ast_bridge *bridge)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	if (bridge->dissolved) {
-		/*
-		 * No sense in completing the join on channels for a dissolved
-		 * bridge.  They are just going to be removed soon anyway.
-		 * However, we do have reason to abort here because the bridge
-		 * technology may not be able to handle the number of channels
-		 * still in the bridge.
-		 */
-		return;
-	}
-
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		if (!bridge_channel->just_joined) {
-			continue;
-		}
-		bridge_channel_complete_join(bridge, bridge_channel);
-	}
-}
-
-/*! \brief Helper function used to find the "best" bridge technology given specified capabilities */
-static struct ast_bridge_technology *find_best_technology(uint32_t capabilities, struct ast_bridge *bridge)
-{
-	struct ast_bridge_technology *current;
-	struct ast_bridge_technology *best = NULL;
-
-	AST_RWLIST_RDLOCK(&bridge_technologies);
-	AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
-		if (current->suspended) {
-			ast_debug(1, "Bridge technology %s is suspended. Skipping.\n",
-				current->name);
-			continue;
-		}
-		if (!(current->capabilities & capabilities)) {
-			ast_debug(1, "Bridge technology %s does not have any capabilities we want.\n",
-				current->name);
-			continue;
-		}
-		if (best && current->preference <= best->preference) {
-			ast_debug(1, "Bridge technology %s has less preference than %s (%d <= %d). Skipping.\n",
-				current->name, best->name, current->preference, best->preference);
-			continue;
-		}
-		if (current->compatible && !current->compatible(bridge)) {
-			ast_debug(1, "Bridge technology %s is not compatible with properties of existing bridge.\n",
-				current->name);
-			continue;
-		}
-		best = current;
-	}
-
-	if (best) {
-		/* Increment it's module reference count if present so it does not get unloaded while in use */
-		ast_module_ref(best->mod);
-		ast_debug(1, "Chose bridge technology %s\n", best->name);
-	}
-
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-
-	return best;
-}
-
-struct tech_deferred_destroy {
-	struct ast_bridge_technology *tech;
-	void *tech_pvt;
-};
-
-/*!
- * \internal
- * \brief Deferred destruction of bridge tech private structure.
- * \since 12.0.0
- *
- * \param bridge What to execute the action on.
- * \param action Deferred bridge tech destruction.
- *
- * \note On entry, bridge must not be locked.
- *
- * \return Nothing
- */
-static void bridge_tech_deferred_destroy(struct ast_bridge *bridge, struct ast_frame *action)
-{
-	struct tech_deferred_destroy *deferred = action->data.ptr;
-	struct ast_bridge dummy_bridge = {
-		.technology = deferred->tech,
-		.tech_pvt = deferred->tech_pvt,
-		};
-
-	ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
-	ast_debug(1, "Bridge %s: calling %s technology destructor (deferred, dummy)\n",
-		dummy_bridge.uniqueid, dummy_bridge.technology->name);
-	dummy_bridge.technology->destroy(&dummy_bridge);
-	ast_module_unref(dummy_bridge.technology->mod);
-}
-
-/*!
- * \internal
- * \brief Handle bridge action frame.
- * \since 12.0.0
- *
- * \param bridge What to execute the action on.
- * \param action What to do.
- *
- * \note On entry, bridge is already locked.
- * \note Can be called by the bridge destructor.
- *
- * \return Nothing
- */
-static void bridge_action_bridge(struct ast_bridge *bridge, struct ast_frame *action)
-{
-#if 0	/* In case we need to know when the destructor is calling us. */
-	int in_destructor = !ao2_ref(bridge, 0);
-#endif
-
-	switch (action->subclass.integer) {
-	case BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY:
-		ast_bridge_unlock(bridge);
-		bridge_tech_deferred_destroy(bridge, action);
-		ast_bridge_lock(bridge);
-		break;
-	case BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING:
-		ast_bridge_unlock(bridge);
-		bridge->v_table->dissolving(bridge);
-		ast_bridge_lock(bridge);
-		break;
-	default:
-		/* Unexpected deferred action type.  Should never happen. */
-		ast_assert(0);
-		break;
-	}
-}
-
-/*!
- * \internal
- * \brief Do any pending bridge actions.
- * \since 12.0.0
- *
- * \param bridge What to do actions on.
- *
- * \note On entry, bridge is already locked.
- * \note Can be called by the bridge destructor.
- *
- * \return Nothing
- */
-static void bridge_handle_actions(struct ast_bridge *bridge)
-{
-	struct ast_frame *action;
-
-	while ((action = AST_LIST_REMOVE_HEAD(&bridge->action_queue, frame_list))) {
-		switch (action->frametype) {
-		case AST_FRAME_BRIDGE_ACTION:
-			bridge_action_bridge(bridge, action);
-			break;
-		default:
-			/* Unexpected deferred frame type.  Should never happen. */
-			ast_assert(0);
-			break;
-		}
-		ast_frfree(action);
-	}
-}
-
-static struct stasis_message *create_bridge_snapshot_message(struct ast_bridge *bridge)
-{
-	RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup);
-
-	snapshot = ast_bridge_snapshot_create(bridge);
-	if (!snapshot) {
-		return NULL;
-	}
-
-	return stasis_message_create(ast_bridge_snapshot_type(), snapshot);
-}
-
-static void destroy_bridge(void *obj)
-{
-	struct ast_bridge *bridge = obj;
-
-	ast_debug(1, "Bridge %s: actually destroying %s bridge, nobody wants it anymore\n",
-		bridge->uniqueid, bridge->v_table->name);
-
-	if (bridge->construction_completed) {
-		RAII_VAR(struct stasis_message *, clear_msg, NULL, ao2_cleanup);
-
-		clear_msg = create_bridge_snapshot_message(bridge);
-		if (clear_msg) {
-			RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
-
-			msg = stasis_cache_clear_create(clear_msg);
-			if (msg) {
-				stasis_publish(ast_bridge_topic(bridge), msg);
-			}
-		}
-	}
-
-	/* Do any pending actions in the context of destruction. */
-	ast_bridge_lock(bridge);
-	bridge_handle_actions(bridge);
-	ast_bridge_unlock(bridge);
-
-	/* There should not be any channels left in the bridge. */
-	ast_assert(AST_LIST_EMPTY(&bridge->channels));
-
-	ast_debug(1, "Bridge %s: calling %s bridge destructor\n",
-		bridge->uniqueid, bridge->v_table->name);
-	bridge->v_table->destroy(bridge);
-
-	/* Pass off the bridge to the technology to destroy if needed */
-	if (bridge->technology) {
-		ast_debug(1, "Bridge %s: calling %s technology stop\n",
-			bridge->uniqueid, bridge->technology->name);
-		if (bridge->technology->stop) {
-			ast_bridge_lock(bridge);
-			bridge->technology->stop(bridge);
-			ast_bridge_unlock(bridge);
-		}
-		ast_debug(1, "Bridge %s: calling %s technology destructor\n",
-			bridge->uniqueid, bridge->technology->name);
-		if (bridge->technology->destroy) {
-			bridge->technology->destroy(bridge);
-		}
-		ast_module_unref(bridge->technology->mod);
-		bridge->technology = NULL;
-	}
-
-	if (bridge->callid) {
-		bridge->callid = ast_callid_unref(bridge->callid);
-	}
-
-	cleanup_video_mode(bridge);
-}
-
-struct ast_bridge *bridge_register(struct ast_bridge *bridge)
-{
-	if (bridge) {
-		bridge->construction_completed = 1;
-		ast_bridge_publish_state(bridge);
-		if (!ao2_link(bridges, bridge)) {
-			ast_bridge_destroy(bridge);
-			bridge = NULL;
-		}
-	}
-	return bridge;
-}
-
-struct ast_bridge *bridge_alloc(size_t size, const struct ast_bridge_methods *v_table)
-{
-	struct ast_bridge *bridge;
-
-	/* Check v_table that all methods are present. */
-	if (!v_table
-		|| !v_table->name
-		|| !v_table->destroy
-		|| !v_table->dissolving
-		|| !v_table->push
-		|| !v_table->pull
-		|| !v_table->notify_masquerade
-		|| !v_table->get_merge_priority) {
-		ast_log(LOG_ERROR, "Virtual method table for bridge class %s not complete.\n",
-			v_table && v_table->name ? v_table->name : "<unknown>");
-		ast_assert(0);
-		return NULL;
-	}
-
-	bridge = ao2_alloc(size, destroy_bridge);
-	if (bridge) {
-		bridge->v_table = v_table;
-	}
-	return bridge;
-}
-
-struct ast_bridge *bridge_base_init(struct ast_bridge *self, uint32_t capabilities, unsigned int flags)
-{
-	if (!self) {
-		return NULL;
-	}
-
-	ast_uuid_generate_str(self->uniqueid, sizeof(self->uniqueid));
-	ast_set_flag(&self->feature_flags, flags);
-	self->allowed_capabilities = capabilities;
-
-	/* Use our helper function to find the "best" bridge technology. */
-	self->technology = find_best_technology(capabilities, self);
-	if (!self->technology) {
-		ast_log(LOG_WARNING, "Bridge %s: Could not create class %s.  No technology to support it.\n",
-			self->uniqueid, self->v_table->name);
-		ao2_ref(self, -1);
-		return NULL;
-	}
-
-	/* Pass off the bridge to the technology to manipulate if needed */
-	ast_debug(1, "Bridge %s: calling %s technology constructor\n",
-		self->uniqueid, self->technology->name);
-	if (self->technology->create && self->technology->create(self)) {
-		ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
-			self->uniqueid, self->technology->name);
-		ao2_ref(self, -1);
-		return NULL;
-	}
-	ast_debug(1, "Bridge %s: calling %s technology start\n",
-		self->uniqueid, self->technology->name);
-	if (self->technology->start && self->technology->start(self)) {
-		ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
-			self->uniqueid, self->technology->name);
-		ao2_ref(self, -1);
-		return NULL;
-	}
-
-	if (!ast_bridge_topic(self)) {
-		ao2_ref(self, -1);
-		return NULL;
-	}
-
-	return self;
-}
-
-/*!
- * \internal
- * \brief ast_bridge base class destructor.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- *
- * \note Stub because of nothing to do.
- *
- * \return Nothing
- */
-static void bridge_base_destroy(struct ast_bridge *self)
-{
-}
-
-/*!
- * \internal
- * \brief The bridge is being dissolved.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- *
- * \return Nothing
- */
-static void bridge_base_dissolving(struct ast_bridge *self)
-{
-	ao2_unlink(bridges, self);
-}
-
-/*!
- * \internal
- * \brief ast_bridge base push method.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- * \param bridge_channel Bridge channel to push.
- * \param swap Bridge channel to swap places with if not NULL.
- *
- * \note On entry, self is already locked.
- * \note Stub because of nothing to do.
- *
- * \retval 0 on success
- * \retval -1 on failure
- */
-static int bridge_base_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
-{
-	return 0;
-}
-
-/*!
- * \internal
- * \brief ast_bridge base pull method.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- * \param bridge_channel Bridge channel to pull.
- *
- * \note On entry, self is already locked.
- *
- * \return Nothing
- */
-static void bridge_base_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
-{
-	ast_bridge_features_remove(bridge_channel->features, AST_BRIDGE_HOOK_REMOVE_ON_PULL);
-}
-
-/*!
- * \internal
- * \brief ast_bridge base notify_masquerade method.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- * \param bridge_channel Bridge channel that was masqueraded.
- *
- * \note On entry, self is already locked.
- *
- * \return Nothing
- */
-static void bridge_base_notify_masquerade(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
-{
-	self->reconfigured = 1;
-}
-
-/*!
- * \internal
- * \brief Get the merge priority of this bridge.
- * \since 12.0.0
- *
- * \param self Bridge to operate upon.
- *
- * \note On entry, self is already locked.
- *
- * \return Merge priority
- */
-static int bridge_base_get_merge_priority(struct ast_bridge *self)
-{
-	return 0;
-}
-
-struct ast_bridge_methods ast_bridge_base_v_table = {
-	.name = "base",
-	.destroy = bridge_base_destroy,
-	.dissolving = bridge_base_dissolving,
-	.push = bridge_base_push,
-	.pull = bridge_base_pull,
-	.notify_masquerade = bridge_base_notify_masquerade,
-	.get_merge_priority = bridge_base_get_merge_priority,
-};
-
-struct ast_bridge *ast_bridge_base_new(uint32_t capabilities, unsigned int flags)
-{
-	void *bridge;
-
-	bridge = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table);
-	bridge = bridge_base_init(bridge, capabilities, flags);
-	bridge = bridge_register(bridge);
-	return bridge;
-}
-
-int ast_bridge_destroy(struct ast_bridge *bridge)
-{
-	ast_debug(1, "Bridge %s: telling all channels to leave the party\n", bridge->uniqueid);
-	ast_bridge_lock(bridge);
-	bridge_dissolve(bridge);
-	ast_bridge_unlock(bridge);
-
-	ao2_ref(bridge, -1);
-
-	return 0;
-}
-
-static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
-{
-	struct ast_format read_format;
-	struct ast_format write_format;
-	struct ast_format best_format;
-	char codec_buf[512];
-
-	ast_format_copy(&read_format, ast_channel_readformat(bridge_channel->chan));
-	ast_format_copy(&write_format, ast_channel_writeformat(bridge_channel->chan));
-
-	/* Are the formats currently in use something this bridge can handle? */
-	if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, ast_channel_readformat(bridge_channel->chan))) {
-		ast_best_codec(bridge->technology->format_capabilities, &best_format);
-
-		/* Read format is a no go... */
-		ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n",
-			bridge->technology->name,
-			ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
-			ast_getformatname(&read_format));
-
-		/* Switch read format to the best one chosen */
-		if (ast_set_read_format(bridge_channel->chan, &best_format)) {
-			ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n",
-				ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
-			return -1;
-		}
-		ast_debug(1, "Bridge %s put channel %s into read format %s\n",
-			bridge->uniqueid, ast_channel_name(bridge_channel->chan),
-			ast_getformatname(&best_format));
-	} else {
-		ast_debug(1, "Bridge %s is happy that channel %s already has read format %s\n",
-			bridge->uniqueid, ast_channel_name(bridge_channel->chan),
-			ast_getformatname(&read_format));
-	}
-
-	if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &write_format)) {
-		ast_best_codec(bridge->technology->format_capabilities, &best_format);
-
-		/* Write format is a no go... */
-		ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n",
-			bridge->technology->name,
-			ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
-			ast_getformatname(&write_format));
-
-		/* Switch write format to the best one chosen */
-		if (ast_set_write_format(bridge_channel->chan, &best_format)) {
-			ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n",
-				ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
-			return -1;
-		}
-		ast_debug(1, "Bridge %s put channel %s into write format %s\n",
-			bridge->uniqueid, ast_channel_name(bridge_channel->chan),
-			ast_getformatname(&best_format));
-	} else {
-		ast_debug(1, "Bridge %s is happy that channel %s already has write format %s\n",
-			bridge->uniqueid, ast_channel_name(bridge_channel->chan),
-			ast_getformatname(&write_format));
-	}
-
-	return 0;
-}
-
-/*!
- * \internal
- * \brief Perform the smart bridge operation.
- * \since 12.0.0
- *
- * \param bridge Work on this bridge.
- *
- * \details
- * Basically see if a new bridge technology should be used instead
- * of the current one.
- *
- * \note On entry, bridge is already locked.
- *
- * \retval 0 on success.
- * \retval -1 on error.
- */
-static int smart_bridge_operation(struct ast_bridge *bridge)
-{
-	uint32_t new_capabilities;
-	struct ast_bridge_technology *new_technology;
-	struct ast_bridge_technology *old_technology = bridge->technology;
-	struct ast_bridge_channel *bridge_channel;
-	struct ast_frame *deferred_action;
-	struct ast_bridge dummy_bridge = {
-		.technology = bridge->technology,
-		.tech_pvt = bridge->tech_pvt,
-	};
-
-	if (bridge->dissolved) {
-		ast_debug(1, "Bridge %s is dissolved, not performing smart bridge operation.\n",
-			bridge->uniqueid);
-		return 0;
-	}
-
-	/* Determine new bridge technology capabilities needed. */
-	if (2 < bridge->num_channels) {
-		new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
-		new_capabilities &= bridge->allowed_capabilities;
-	} else {
-		new_capabilities = AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX;
-		new_capabilities &= bridge->allowed_capabilities;
-		if (!new_capabilities
-			&& (bridge->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
-			/* Allow switching between different multimix bridge technologies. */
-			new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
-		}
-	}
-
-	/* Find a bridge technology to satisfy the new capabilities. */
-	new_technology = find_best_technology(new_capabilities, bridge);
-	if (!new_technology) {
-		int is_compatible = 0;
-
-		if (old_technology->compatible) {
-			is_compatible = old_technology->compatible(bridge);
-		} else if (old_technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
-			is_compatible = 1;
-		} else if (bridge->num_channels <= 2
-			&& (old_technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX)) {
-			is_compatible = 1;
-		}
-
-		if (is_compatible) {
-			ast_debug(1, "Bridge %s could not get a new technology, staying with old technology.\n",
-				bridge->uniqueid);
-			return 0;
-		}
-		ast_log(LOG_WARNING, "Bridge %s has no technology available to support it.\n",
-			bridge->uniqueid);
-		return -1;
-	}
-	if (new_technology == old_technology) {
-		ast_debug(1, "Bridge %s is already using the new technology.\n",
-			bridge->uniqueid);
-		ast_module_unref(old_technology->mod);
-		return 0;
-	}
-
-	ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
-
-	if (old_technology->destroy) {
-		struct tech_deferred_destroy deferred_tech_destroy = {
-			.tech = dummy_bridge.technology,
-			.tech_pvt = dummy_bridge.tech_pvt,
-		};
-		struct ast_frame action = {
-			.frametype = AST_FRAME_BRIDGE_ACTION,
-			.subclass.integer = BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY,
-			.data.ptr = &deferred_tech_destroy,
-			.datalen = sizeof(deferred_tech_destroy),
-		};
-
-		/*
-		 * We need to defer the bridge technology destroy callback
-		 * because we have the bridge locked.
-		 */
-		deferred_action = ast_frdup(&action);
-		if (!deferred_action) {
-			ast_module_unref(new_technology->mod);
-			return -1;
-		}
-	} else {
-		deferred_action = NULL;
-	}
-
-	/*
-	 * We are now committed to changing the bridge technology.  We
-	 * must not release the bridge lock until we have installed the
-	 * new bridge technology.
-	 */
-	ast_verb(4, "Bridge %s: switching from %s technology to %s\n",
-		bridge->uniqueid, old_technology->name, new_technology->name);
-
-	/*
-	 * Since we are soon going to pass this bridge to a new
-	 * technology we need to NULL out the tech_pvt pointer but
-	 * don't worry as it still exists in dummy_bridge, ditto for the
-	 * old technology.
-	 */
-	bridge->tech_pvt = NULL;
-	bridge->technology = new_technology;
-
-	/* Setup the new bridge technology. */
-	ast_debug(1, "Bridge %s: calling %s technology constructor\n",
-		bridge->uniqueid, new_technology->name);
-	if (new_technology->create && new_technology->create(bridge)) {
-		ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
-			bridge->uniqueid, new_technology->name);
-		bridge->tech_pvt = dummy_bridge.tech_pvt;
-		bridge->technology = dummy_bridge.technology;
-		ast_module_unref(new_technology->mod);
-		return -1;
-	}
-
-	ast_debug(1, "Bridge %s: calling %s technology stop\n",
-		dummy_bridge.uniqueid, old_technology->name);
-	if (old_technology->stop) {
-		old_technology->stop(&dummy_bridge);
-	}
-
-	/*
-	 * Move existing channels over to the new technology and
-	 * complete joining any new channels to the bridge.
-	 */
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		if (!bridge_channel->just_joined) {
-			/* Take existing channel from the old technology. */
-			ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology (dummy)\n",
-				dummy_bridge.uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
-				old_technology->name);
-			if (old_technology->leave) {
-				old_technology->leave(&dummy_bridge, bridge_channel);
-			}
-		}
-
-		/* Add any new channels or re-add an existing channel to the bridge. */
-		bridge_channel_complete_join(bridge, bridge_channel);
-	}
-
-	ast_debug(1, "Bridge %s: calling %s technology start\n",
-		bridge->uniqueid, new_technology->name);
-	if (new_technology->start && new_technology->start(bridge)) {
-		ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
-			bridge->uniqueid, new_technology->name);
-	}
-
-	/*
-	 * Now that all the channels have been moved over we need to get
-	 * rid of all the information the old technology may have left
-	 * around.
-	 */
-	if (old_technology->destroy) {
-		ast_debug(1, "Bridge %s: deferring %s technology destructor\n",
-			dummy_bridge.uniqueid, old_technology->name);
-		bridge_queue_action_nodup(bridge, deferred_action);
-	} else {
-		ast_debug(1, "Bridge %s: calling %s technology destructor\n",
-			dummy_bridge.uniqueid, old_technology->name);
-		ast_module_unref(old_technology->mod);
-	}
-
-	return 0;
-}
-
-/*!
- * \internal
- * \brief Bridge channel to check if a BRIDGE_PLAY_SOUND needs to be played.
- * \since 12.0.0
- *
- * \param bridge_channel What to check.
- *
- * \return Nothing
- */
-static void check_bridge_play_sound(struct ast_bridge_channel *bridge_channel)
-{
-	const char *play_file;
-
-	ast_channel_lock(bridge_channel->chan);
-	play_file = pbx_builtin_getvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND");
-	if (!ast_strlen_zero(play_file)) {
-		play_file = ast_strdupa(play_file);
-		pbx_builtin_setvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND", NULL);
-	} else {
-		play_file = NULL;
-	}
-	ast_channel_unlock(bridge_channel->chan);
-
-	if (play_file) {
-		ast_bridge_channel_queue_playfile(bridge_channel, NULL, play_file, NULL);
-	}
-}
-
-/*!
- * \internal
- * \brief Check for any BRIDGE_PLAY_SOUND channel variables in the bridge.
- * \since 12.0.0
- *
- * \param bridge What to operate on.
- *
- * \note On entry, the bridge is already locked.
- *
- * \return Nothing
- */
-static void check_bridge_play_sounds(struct ast_bridge *bridge)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		check_bridge_play_sound(bridge_channel);
-	}
-}
-
-static void update_bridge_vars_set(struct ast_channel *chan, const char *name, const char *pvtid)
-{
-	pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name);
-	pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid);
-}
-
-/*!
- * \internal
- * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a 2 party bridge.
- * \since 12.0.0
- *
- * \param c0 Party of the first part.
- * \param c1 Party of the second part.
- *
- * \note On entry, the bridge is already locked.
- * \note The bridge is expected to have exactly two parties.
- *
- * \return Nothing
- */
-static void set_bridge_peer_vars_2party(struct ast_channel *c0, struct ast_channel *c1)
-{
-	const char *c0_name;
-	const char *c1_name;
-	const char *c0_pvtid = NULL;
-	const char *c1_pvtid = NULL;
-#define UPDATE_BRIDGE_VARS_GET(chan, name, pvtid)									\
-	do {																			\
-		name = ast_strdupa(ast_channel_name(chan));									\
-		if (ast_channel_tech(chan)->get_pvt_uniqueid) {								\
-			pvtid = ast_strdupa(ast_channel_tech(chan)->get_pvt_uniqueid(chan));	\
-		}																			\
-	} while (0)
-
-	ast_channel_lock(c1);
-	UPDATE_BRIDGE_VARS_GET(c1, c1_name, c1_pvtid);
-	ast_channel_unlock(c1);
-
-	ast_channel_lock(c0);
-	update_bridge_vars_set(c0, c1_name, c1_pvtid);
-	UPDATE_BRIDGE_VARS_GET(c0, c0_name, c0_pvtid);
-	ast_channel_unlock(c0);
-
-	ast_channel_lock(c1);
-	update_bridge_vars_set(c1, c0_name, c0_pvtid);
-	ast_channel_unlock(c1);
-}
-
-/*!
- * \internal
- * \brief Fill the BRIDGEPEER value buffer with a comma separated list of channel names.
- * \since 12.0.0
- *
- * \param buf Buffer to fill.  The caller must guarantee the buffer is large enough.
- * \param cur_idx Which index into names[] to skip.
- * \param names Channel names to put in the buffer.
- * \param num_names Number of names in the array.
- *
- * \return Nothing
- */
-static void fill_bridgepeer_buf(char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names)
-{
-	int need_separator = 0;
-	unsigned int idx;
-	const char *src;
-	char *pos;
-
-	pos = buf;
-	for (idx = 0; idx < num_names; ++idx) {
-		if (idx == cur_idx) {
-			continue;
-		}
-
-		if (need_separator) {
-			*pos++ = ',';
-		}
-		need_separator = 1;
-
-		/* Copy name into buffer. */
-		src = names[idx];
-		while (*src) {
-			*pos++ = *src++;
-		}
-	}
-	*pos = '\0';
-}
-
-/*!
- * \internal
- * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a multi-party bridge.
- * \since 12.0.0
- *
- * \param bridge What to operate on.
- *
- * \note On entry, the bridge is already locked.
- * \note The bridge is expected to have more than two parties.
- *
- * \return Nothing
- */
-static void set_bridge_peer_vars_multiparty(struct ast_bridge *bridge)
-{
-/*
- * Set a maximum number of channel names for the BRIDGEPEER
- * list.  The plus one is for the current channel which is not
- * put in the list.
- */
-#define MAX_BRIDGEPEER_CHANS	(10 + 1)
-
-	unsigned int idx;
-	unsigned int num_names;
-	unsigned int len;
-	const char **names;
-	char *buf;
-	struct ast_bridge_channel *bridge_channel;
-
-	/* Get first MAX_BRIDGEPEER_CHANS channel names. */
-	num_names = MIN(bridge->num_channels, MAX_BRIDGEPEER_CHANS);
-	names = ast_alloca(num_names * sizeof(*names));
-	idx = 0;
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		if (num_names <= idx) {
-			break;
-		}
-		ast_channel_lock(bridge_channel->chan);
-		names[idx++] = ast_strdupa(ast_channel_name(bridge_channel->chan));
-		ast_channel_unlock(bridge_channel->chan);
-	}
-
-	/* Determine maximum buf size needed. */
-	len = num_names;
-	for (idx = 0; idx < num_names; ++idx) {
-		len += strlen(names[idx]);
-	}
-	buf = ast_alloca(len);
-
-	/* Set the bridge channel variables. */
-	idx = 0;
-	buf[0] = '\0';
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		if (idx < num_names) {
-			fill_bridgepeer_buf(buf, idx, names, num_names);
-		}
-		++idx;
-
-		ast_channel_lock(bridge_channel->chan);
-		update_bridge_vars_set(bridge_channel->chan, buf, NULL);
-		ast_channel_unlock(bridge_channel->chan);
-	}
-}
-
-/*!
- * \internal
- * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a holding bridge.
- * \since 12.0.0
- *
- * \param bridge What to operate on.
- *
- * \note On entry, the bridge is already locked.
- *
- * \return Nothing
- */
-static void set_bridge_peer_vars_holding(struct ast_bridge *bridge)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		ast_channel_lock(bridge_channel->chan);
-		update_bridge_vars_set(bridge_channel->chan, NULL, NULL);
-		ast_channel_unlock(bridge_channel->chan);
-	}
-}
-
-/*!
- * \internal
- * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in the bridge.
- * \since 12.0.0
- *
- * \param bridge What to operate on.
- *
- * \note On entry, the bridge is already locked.
- *
- * \return Nothing
- */
-static void set_bridge_peer_vars(struct ast_bridge *bridge)
-{
-	if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_HOLDING) {
-		set_bridge_peer_vars_holding(bridge);
-		return;
-	}
-	if (bridge->num_channels < 2) {
-		return;
-	}
-	if (bridge->num_channels == 2) {
-		set_bridge_peer_vars_2party(AST_LIST_FIRST(&bridge->channels)->chan,
-			AST_LIST_LAST(&bridge->channels)->chan);
-	} else {
-		set_bridge_peer_vars_multiparty(bridge);
-	}
-}
-
-void bridge_reconfigured(struct ast_bridge *bridge, unsigned int colp_update)
-{
-	if (!bridge->reconfigured) {
-		return;
-	}
-	bridge->reconfigured = 0;
-	if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_SMART)
-		&& smart_bridge_operation(bridge)) {
-		/* Smart bridge failed. */
-		bridge_dissolve(bridge);
-		return;
-	}
-	bridge_complete_join(bridge);
-
-	if (bridge->dissolved) {
-		return;
-	}
-	check_bridge_play_sounds(bridge);
-	set_bridge_peer_vars(bridge);
-	ast_bridge_publish_state(bridge);
-
-	if (colp_update) {
-		bridge_reconfigured_connected_line_update(bridge);
-	}
-}
-
-struct ast_bridge_channel *bridge_find_channel(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-		if (bridge_channel->chan == chan) {
-			break;
-		}
-	}
-
-	return bridge_channel;
-}
-
-void ast_bridge_notify_masquerade(struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-	struct ast_bridge *bridge;
-
-	/* Safely get the bridge_channel pointer for the chan. */
-	ast_channel_lock(chan);
-	bridge_channel = ast_channel_get_bridge_channel(chan);
-	ast_channel_unlock(chan);
-	if (!bridge_channel) {
-		/* Not in a bridge */
-		return;
-	}
-
-	ast_bridge_channel_lock_bridge(bridge_channel);
-	bridge = bridge_channel->bridge;
-	if (bridge_channel == bridge_find_channel(bridge, chan)) {
-/* BUGBUG this needs more work.  The channels need to be made compatible again if the formats change. The bridge_channel thread needs to monitor for this case. */
-		/* The channel we want to notify is still in a bridge. */
-		bridge->v_table->notify_masquerade(bridge, bridge_channel);
-		bridge_reconfigured(bridge, 1);
-	}
-	ast_bridge_unlock(bridge);
-	ao2_ref(bridge_channel, -1);
-}
-
-/*
- * BUGBUG make ast_bridge_join() require features to be allocated just like ast_bridge_impart() and not expect the struct back.
- *
- * This change is really going to break ConfBridge.  All other
- * users are easily changed.  However, it is needed so the
- * bridging code can manipulate features on all channels
- * consistently no matter how they joined.
- *
- * Need to update the features parameter doxygen when this
- * change is made to be like ast_bridge_impart().
- */
-enum bridge_channel_state ast_bridge_join(struct ast_bridge *bridge,
-	struct ast_channel *chan,
-	struct ast_channel *swap,
-	struct ast_bridge_features *features,
-	struct ast_bridge_tech_optimizations *tech_args,
-	int pass_reference)
-{
-	struct ast_bridge_channel *bridge_channel;
-	enum bridge_channel_state state;
-
-	bridge_channel = bridge_channel_internal_alloc(bridge);
-	if (pass_reference) {
-		ao2_ref(bridge, -1);
-	}
-	if (!bridge_channel) {
-		state = BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE;
-		goto join_exit;
-	}
-/* BUGBUG features cannot be NULL when passed in. When it is changed to allocated we can do like ast_bridge_impart() and allocate one. */
-	ast_assert(features != NULL);
-	if (!features) {
-		ao2_ref(bridge_channel, -1);
-		state = BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE;
-		goto join_exit;
-	}
-	if (tech_args) {
-		bridge_channel->tech_args = *tech_args;
-	}
-
-	/* Initialize various other elements of the bridge channel structure that we can't do above */
-	ast_channel_lock(chan);
-	ast_channel_internal_bridge_channel_set(chan, bridge_channel);
-	ast_channel_unlock(chan);
-	bridge_channel->thread = pthread_self();
-	bridge_channel->chan = chan;
-	bridge_channel->swap = swap;
-	bridge_channel->features = features;
-
-	bridge_channel_internal_join(bridge_channel);
-	state = bridge_channel->state;
-
-	/* Cleanup all the data in the bridge channel after it leaves the bridge. */
-	ast_channel_lock(chan);
-	ast_channel_internal_bridge_channel_set(chan, NULL);
-	ast_channel_unlock(chan);
-	bridge_channel->chan = NULL;
-	bridge_channel->swap = NULL;
-	bridge_channel->features = NULL;
-
-	ao2_ref(bridge_channel, -1);
-
-join_exit:;
-/* BUGBUG this is going to cause problems for DTMF atxfer attended bridge between B & C.  Maybe an ast_bridge_join_internal() that does not do the after bridge goto for this case. */
-	ast_bridge_run_after_callback(chan);
-	if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)
-		&& !ast_bridge_setup_after_goto(chan)) {
-		/* Claim the after bridge goto is an async goto destination. */
-		ast_channel_lock(chan);
-		ast_softhangup_nolock(chan, AST_SOFTHANGUP_ASYNCGOTO);
-		ast_channel_unlock(chan);
-	}
-	return state;
-}
-
-/*! \brief Thread responsible for imparted bridged channels to be departed */
-static void *bridge_channel_depart_thread(void *data)
-{
-	struct ast_bridge_channel *bridge_channel = data;
-
-	if (bridge_channel->callid) {
-		ast_callid_threadassoc_add(bridge_channel->callid);
-	}
-
-	bridge_channel_internal_join(bridge_channel);
-
-	/* cleanup */
-	bridge_channel->swap = NULL;
-	ast_bridge_features_destroy(bridge_channel->features);
-	bridge_channel->features = NULL;
-
-	ast_bridge_discard_after_callback(bridge_channel->chan, AST_BRIDGE_AFTER_CB_REASON_DEPART);
-	ast_bridge_discard_after_goto(bridge_channel->chan);
-
-	return NULL;
-}
-
-/*! \brief Thread responsible for independent imparted bridged channels */
-static void *bridge_channel_ind_thread(void *data)
-{
-	struct ast_bridge_channel *bridge_channel = data;
-	struct ast_channel *chan;
-
-	if (bridge_channel->callid) {
-		ast_callid_threadassoc_add(bridge_channel->callid);
-	}
-
-	bridge_channel_internal_join(bridge_channel);
-	chan = bridge_channel->chan;
-
-	/* cleanup */
-	ast_channel_lock(chan);
-	ast_channel_internal_bridge_channel_set(chan, NULL);
-	ast_channel_unlock(chan);
-	bridge_channel->chan = NULL;
-	bridge_channel->swap = NULL;
-	ast_bridge_features_destroy(bridge_channel->features);
-	bridge_channel->features = NULL;
-
-	ao2_ref(bridge_channel, -1);
-
-	ast_bridge_run_after_callback(chan);
-	ast_bridge_run_after_goto(chan);
-	return NULL;
-}
-
-int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, int independent)
-{
-	int res;
-	struct ast_bridge_channel *bridge_channel;
-
-	/* Supply an empty features structure if the caller did not. */
-	if (!features) {
-		features = ast_bridge_features_new();
-		if (!features) {
-			return -1;
-		}
-	}
-
-	/* Try to allocate a structure for the bridge channel */
-	bridge_channel = bridge_channel_internal_alloc(bridge);
-	if (!bridge_channel) {
-		ast_bridge_features_destroy(features);
-		return -1;
-	}
-
-	/* Setup various parameters */
-	ast_channel_lock(chan);
-	ast_channel_internal_bridge_channel_set(chan, bridge_channel);
-	ast_channel_unlock(chan);
-	bridge_channel->chan = chan;
-	bridge_channel->swap = swap;
-	bridge_channel->features = features;
-	bridge_channel->depart_wait = independent ? 0 : 1;
-	bridge_channel->callid = ast_read_threadstorage_callid();
-
-	/* Actually create the thread that will handle the channel */
-	if (independent) {
-		/* Independently imparted channels cannot have a PBX. */
-		ast_assert(!ast_channel_pbx(chan));
-
-		res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
-			bridge_channel_ind_thread, bridge_channel);
-	} else {
-		/* Imparted channels to be departed should not have a PBX either. */
-		ast_assert(!ast_channel_pbx(chan));
-
-		res = ast_pthread_create(&bridge_channel->thread, NULL,
-			bridge_channel_depart_thread, bridge_channel);
-	}
-
-	if (res) {
-		/* cleanup */
-		ast_channel_lock(chan);
-		ast_channel_internal_bridge_channel_set(chan, NULL);
-		ast_channel_unlock(chan);
-		bridge_channel->chan = NULL;
-		bridge_channel->swap = NULL;
-		ast_bridge_features_destroy(bridge_channel->features);
-		bridge_channel->features = NULL;
-
-		ao2_ref(bridge_channel, -1);
-		return -1;
-	}
-
-	return 0;
-}
-
-int ast_bridge_depart(struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-	int departable;
-
-	ast_channel_lock(chan);
-	bridge_channel = ast_channel_internal_bridge_channel(chan);
-	departable = bridge_channel && bridge_channel->depart_wait;
-	ast_channel_unlock(chan);
-	if (!departable) {
-		ast_log(LOG_ERROR, "Channel %s cannot be departed.\n",
-			ast_channel_name(chan));
-		/*
-		 * Should never happen.  It likely means that
-		 * ast_bridge_depart() is called by two threads for the same
-		 * channel, the channel was never imparted to be departed, or it
-		 * has already been departed.
-		 */
-		ast_assert(0);
-		return -1;
-	}
-
-	/*
-	 * We are claiming the reference held by the depart bridge
-	 * channel thread.
-	 */
-
-	ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-
-	/* Wait for the depart thread to die */
-	ast_debug(1, "Waiting for %p(%s) bridge thread to die.\n",
-		bridge_channel, ast_channel_name(bridge_channel->chan));
-	pthread_join(bridge_channel->thread, NULL);
-
-	ast_channel_lock(chan);
-	ast_channel_internal_bridge_channel_set(chan, NULL);
-	ast_channel_unlock(chan);
-
-	/* We can get rid of the bridge_channel after the depart thread has died. */
-	ao2_ref(bridge_channel, -1);
-	return 0;
-}
-
-int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	ast_bridge_lock(bridge);
-
-	/* Try to find the channel that we want to remove */
-	if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
-		ast_bridge_unlock(bridge);
-		return -1;
-	}
-
-	ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-
-	ast_bridge_unlock(bridge);
-
-	return 0;
-}
-
-/*!
- * \internal
- * \brief Point the bridge_channel to a new bridge.
- * \since 12.0.0
- *
- * \param bridge_channel What is to point to a new bridge.
- * \param new_bridge Where the bridge channel should point.
- *
- * \return Nothing
- */
-static void bridge_channel_change_bridge(struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
-{
-	struct ast_bridge *old_bridge;
-
-	ao2_ref(new_bridge, +1);
-	ast_bridge_channel_lock(bridge_channel);
-	ast_channel_lock(bridge_channel->chan);
-	old_bridge = bridge_channel->bridge;
-	bridge_channel->bridge = new_bridge;
-	ast_channel_internal_bridge_set(bridge_channel->chan, new_bridge);
-	ast_channel_unlock(bridge_channel->chan);
-	ast_bridge_channel_unlock(bridge_channel);
-	ao2_ref(old_bridge, -1);
-}
-
-void bridge_do_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick,
-	unsigned int optimized)
-{
-	struct ast_bridge_channel *bridge_channel;
-	unsigned int idx;
-
-	ast_debug(1, "Merging bridge %s into bridge %s\n",
-		src_bridge->uniqueid, dst_bridge->uniqueid);
-
-	ast_bridge_publish_merge(dst_bridge, src_bridge);
-
-	/*
-	 * Move channels from src_bridge over to dst_bridge.
-	 *
-	 * We must use AST_LIST_TRAVERSE_SAFE_BEGIN() because
-	 * bridge_channel_internal_pull() alters the list we are traversing.
-	 */
-	AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) {
-		if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
-			/*
-			 * The channel is already leaving let it leave normally because
-			 * pulling it may delete hooks that should run for this channel.
-			 */
-			continue;
-		}
-		if (ast_test_flag(&bridge_channel->features->feature_flags,
-			AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
-			continue;
-		}
-
-		if (kick_me) {
-			for (idx = 0; idx < num_kick; ++idx) {
-				if (bridge_channel == kick_me[idx]) {
-					ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-					break;
-				}
-			}
-		}
-		bridge_channel_internal_pull(bridge_channel);
-		if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
-			/*
-			 * The channel died as a result of being pulled or it was
-			 * kicked.  Leave it pointing to the original bridge.
-			 */
-			continue;
-		}
-
-		/* Point to new bridge.*/
-		bridge_channel_change_bridge(bridge_channel, dst_bridge);
-
-		if (bridge_channel_internal_push(bridge_channel)) {
-			ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-		}
-	}
-	AST_LIST_TRAVERSE_SAFE_END;
-
-	if (kick_me) {
-		/*
-		 * Now we can kick any channels in the dst_bridge without
-		 * potentially dissolving the bridge.
-		 */
-		for (idx = 0; idx < num_kick; ++idx) {
-			bridge_channel = kick_me[idx];
-			ast_bridge_channel_lock(bridge_channel);
-			if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
-				ast_bridge_channel_leave_bridge_nolock(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-				bridge_channel_internal_pull(bridge_channel);
-			}
-			ast_bridge_channel_unlock(bridge_channel);
-		}
-	}
-
-	bridge_reconfigured(dst_bridge, !optimized);
-	bridge_reconfigured(src_bridge, !optimized);
-
-	ast_debug(1, "Merged bridge %s into bridge %s\n",
-		src_bridge->uniqueid, dst_bridge->uniqueid);
-}
-
-struct merge_direction {
-	/*! Destination merge bridge. */
-	struct ast_bridge *dest;
-	/*! Source merge bridge. */
-	struct ast_bridge *src;
-};
-
-/*!
- * \internal
- * \brief Determine which bridge should merge into the other.
- * \since 12.0.0
- *
- * \param bridge1 A bridge for merging
- * \param bridge2 A bridge for merging
- *
- * \note The two bridges are assumed already locked.
- *
- * \return Which bridge merges into which or NULL bridges if cannot merge.
- */
-static struct merge_direction bridge_merge_determine_direction(struct ast_bridge *bridge1, struct ast_bridge *bridge2)
-{
-	struct merge_direction merge = { NULL, NULL };
-	int bridge1_priority;
-	int bridge2_priority;
-
-	if (!ast_test_flag(&bridge1->feature_flags,
-			AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)
-		&& !ast_test_flag(&bridge2->feature_flags,
-			AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
-		/*
-		 * Can merge either way.  Merge to the higher priority merge
-		 * bridge.  Otherwise merge to the larger bridge.
-		 */
-		bridge1_priority = bridge1->v_table->get_merge_priority(bridge1);
-		bridge2_priority = bridge2->v_table->get_merge_priority(bridge2);
-		if (bridge2_priority < bridge1_priority) {
-			merge.dest = bridge1;
-			merge.src = bridge2;
-		} else if (bridge1_priority < bridge2_priority) {
-			merge.dest = bridge2;
-			merge.src = bridge1;
-		} else {
-			/* Merge to the larger bridge. */
-			if (bridge2->num_channels <= bridge1->num_channels) {
-				merge.dest = bridge1;
-				merge.src = bridge2;
-			} else {
-				merge.dest = bridge2;
-				merge.src = bridge1;
-			}
-		}
-	} else if (!ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
-		&& !ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
-		/* Can merge only one way. */
-		merge.dest = bridge1;
-		merge.src = bridge2;
-	} else if (!ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
-		&& !ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
-		/* Can merge only one way. */
-		merge.dest = bridge2;
-		merge.src = bridge1;
-	}
-
-	return merge;
-}
-
-/*!
- * \internal
- * \brief Merge two bridges together
- * \since 12.0.0
- *
- * \param dst_bridge Destination bridge of merge.
- * \param src_bridge Source bridge of merge.
- * \param merge_best_direction TRUE if don't care about which bridge merges into the other.
- * \param kick_me Array of channels to kick from the bridges.
- * \param num_kick Number of channels in the kick_me array.
- *
- * \note The dst_bridge and src_bridge are assumed already locked.
- *
- * \retval 0 on success
- * \retval -1 on failure
- */
-static int bridge_merge_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
-{
-	struct merge_direction merge;
-	struct ast_bridge_channel **kick_them = NULL;
-
-	/* Sanity check. */
-	ast_assert(dst_bridge && src_bridge && dst_bridge != src_bridge && (!num_kick || kick_me));
-
-	if (dst_bridge->dissolved || src_bridge->dissolved) {
-		ast_debug(1, "Can't merge bridges %s and %s, at least one bridge is dissolved.\n",
-			src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
-		|| ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
-		ast_debug(1, "Can't merge bridges %s and %s, masquerade only.\n",
-			src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
-		ast_debug(1, "Can't merge bridges %s and %s, merging temporarily inhibited.\n",
-			src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-
-	if (merge_best_direction) {
-		merge = bridge_merge_determine_direction(dst_bridge, src_bridge);
-	} else {
-		merge.dest = dst_bridge;
-		merge.src = src_bridge;
-	}
-
-	if (!merge.dest
-		|| ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
-		|| ast_test_flag(&merge.src->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
-		ast_debug(1, "Can't merge bridges %s and %s, merging inhibited.\n",
-			src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (merge.src->num_channels < 2) {
-		/*
-		 * For a two party bridge, a channel may be temporarily removed
-		 * from the source bridge or the initial bridge members have not
-		 * joined yet.
-		 */
-		ast_debug(1, "Can't merge bridge %s into bridge %s, not enough channels in source bridge.\n",
-			merge.src->uniqueid, merge.dest->uniqueid);
-		return -1;
-	}
-	if (2 + num_kick < merge.dest->num_channels + merge.src->num_channels
-		&& !(merge.dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
-		&& (!ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_SMART)
-			|| !(merge.dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
-		ast_debug(1, "Can't merge bridge %s into bridge %s, multimix is needed and it cannot be acquired.\n",
-			merge.src->uniqueid, merge.dest->uniqueid);
-		return -1;
-	}
-
-	if (num_kick) {
-		unsigned int num_to_kick = 0;
-		unsigned int idx;
-
-		kick_them = ast_alloca(num_kick * sizeof(*kick_them));
-		for (idx = 0; idx < num_kick; ++idx) {
-			kick_them[num_to_kick] = bridge_find_channel(merge.src, kick_me[idx]);
-			if (!kick_them[num_to_kick]) {
-				kick_them[num_to_kick] = bridge_find_channel(merge.dest, kick_me[idx]);
-			}
-			if (kick_them[num_to_kick]) {
-				++num_to_kick;
-			}
-		}
-
-		if (num_to_kick != num_kick) {
-			ast_debug(1, "Can't merge bridge %s into bridge %s, at least one kicked channel is not in either bridge.\n",
-				merge.src->uniqueid, merge.dest->uniqueid);
-			return -1;
-		}
-	}
-
-	bridge_do_merge(merge.dest, merge.src, kick_them, num_kick, 0);
-	return 0;
-}
-
-int ast_bridge_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
-{
-	int res;
-
-	/* Sanity check. */
-	ast_assert(dst_bridge && src_bridge);
-
-	ast_bridge_lock_both(dst_bridge, src_bridge);
-	res = bridge_merge_locked(dst_bridge, src_bridge, merge_best_direction, kick_me, num_kick);
-	ast_bridge_unlock(src_bridge);
-	ast_bridge_unlock(dst_bridge);
-	return res;
-}
-
-int bridge_do_move(struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery,
-	unsigned int optimized)
-{
-	struct ast_bridge *orig_bridge;
-	int was_in_bridge;
-	int res = 0;
-
-/* BUGBUG need bridge move stasis event and a success/fail event. */
-	if (bridge_channel->swap) {
-		ast_debug(1, "Moving %p(%s) into bridge %s swapping with %s\n",
-			bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid,
-			ast_channel_name(bridge_channel->swap));
-	} else {
-		ast_debug(1, "Moving %p(%s) into bridge %s\n",
-			bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid);
-	}
-
-	orig_bridge = bridge_channel->bridge;
-	was_in_bridge = bridge_channel->in_bridge;
-
-	bridge_channel_internal_pull(bridge_channel);
-	if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
-		/*
-		 * The channel died as a result of being pulled.  Leave it
-		 * pointing to the original bridge.
-		 */
-		bridge_reconfigured(orig_bridge, 0);
-		return -1;
-	}
-
-	/* Point to new bridge.*/
-	ao2_ref(orig_bridge, +1);/* Keep a ref in case the push fails. */
-	bridge_channel_change_bridge(bridge_channel, dst_bridge);
-
-	if (bridge_channel_internal_push(bridge_channel)) {
-		/* Try to put the channel back into the original bridge. */
-		if (attempt_recovery && was_in_bridge) {
-			/* Point back to original bridge. */
-			bridge_channel_change_bridge(bridge_channel, orig_bridge);
-
-			if (bridge_channel_internal_push(bridge_channel)) {
-				ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-			}
-		} else {
-			ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-		}
-		res = -1;
-	}
-
-	bridge_reconfigured(dst_bridge, !optimized);
-	bridge_reconfigured(orig_bridge, !optimized);
-	ao2_ref(orig_bridge, -1);
-	return res;
-}
-
-/*!
- * \internal
- * \brief Move a channel from one bridge to another.
- * \since 12.0.0
- *
- * \param dst_bridge Destination bridge of bridge channel move.
- * \param src_bridge Source bridge of bridge channel move.
- * \param chan Channel to move.
- * \param swap Channel to replace in dst_bridge.
- * \param attempt_recovery TRUE if failure attempts to push channel back into original bridge.
- *
- * \note The dst_bridge and src_bridge are assumed already locked.
- *
- * \retval 0 on success.
- * \retval -1 on failure.
- */
-static int bridge_move_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
-{
-	struct ast_bridge_channel *bridge_channel;
-
-	if (dst_bridge->dissolved || src_bridge->dissolved) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, at least one bridge is dissolved.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
-		|| ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, masquerade only.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, temporarily inhibited.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-
-	bridge_channel = bridge_find_channel(src_bridge, chan);
-	if (!bridge_channel) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel not in bridge.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel leaving bridge.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-	if (ast_test_flag(&bridge_channel->features->feature_flags,
-		AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
-		ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel immovable.\n",
-			ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
-		return -1;
-	}
-
-	if (swap) {
-		struct ast_bridge_channel *bridge_channel_swap;
-
-		bridge_channel_swap = bridge_find_channel(dst_bridge, swap);
-		if (!bridge_channel_swap) {
-			ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s not in bridge.\n",
-				ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
-				ast_channel_name(swap));
-			return -1;
-		}
-		if (bridge_channel_swap->state != BRIDGE_CHANNEL_STATE_WAIT) {
-			ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s leaving bridge.\n",
-				ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
-				ast_channel_name(swap));
-			return -1;
-		}
-	}
-
-	bridge_channel->swap = swap;
-	return bridge_do_move(dst_bridge, bridge_channel, attempt_recovery, 0);
-}
-
-int ast_bridge_move(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
-{
-	int res;
-
-	ast_bridge_lock_both(dst_bridge, src_bridge);
-	res = bridge_move_locked(dst_bridge, src_bridge, chan, swap, attempt_recovery);
-	ast_bridge_unlock(src_bridge);
-	ast_bridge_unlock(dst_bridge);
-	return res;
-}
-
-int ast_bridge_add_channel(struct ast_bridge *bridge, struct ast_channel *chan,
-	struct ast_bridge_features *features, int play_tone, const char *xfersound)
-{
-	RAII_VAR(struct ast_bridge *, chan_bridge, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_channel *, yanked_chan, NULL, ao2_cleanup);
-
-	ast_channel_lock(chan);
-	chan_bridge = ast_channel_get_bridge(chan);
-	ast_channel_unlock(chan);
-
-	if (chan_bridge) {
-		RAII_VAR(struct ast_bridge_channel *, bridge_channel, NULL, ao2_cleanup);
-
-		ast_bridge_lock_both(bridge, chan_bridge);
-		bridge_channel = bridge_find_channel(chan_bridge, chan);
-		if (bridge_move_locked(bridge, chan_bridge, chan, NULL, 1)) {
-			ast_bridge_unlock(chan_bridge);
-			ast_bridge_unlock(bridge);
-			return -1;
-		}
-
-		/*
-		 * bridge_move_locked() will implicitly ensure that
-		 * bridge_channel is not NULL.
-		 */
-		ast_assert(bridge_channel != NULL);
-
-		/*
-		 * Additional checks if the channel we just stole dissolves the
-		 * original bridge.
-		 */
-		bridge_dissolve_check_stolen(chan_bridge, bridge_channel);
-		ast_bridge_unlock(chan_bridge);
-		ast_bridge_unlock(bridge);
-
-		/* The channel was in a bridge so it is not getting any new features. */
-		ast_bridge_features_destroy(features);
-	} else {
-		/* Slightly less easy case. We need to yank channel A from
-		 * where he currently is and impart him into our bridge.
-		 */
-		yanked_chan = ast_channel_yank(chan);
-		if (!yanked_chan) {
-			ast_log(LOG_WARNING, "Could not gain control of channel %s\n", ast_channel_name(chan));
-			return -1;
-		}
-		if (ast_channel_state(yanked_chan) != AST_STATE_UP) {
-			ast_answer(yanked_chan);
-		}
-		ast_channel_ref(yanked_chan);
-		if (ast_bridge_impart(bridge, yanked_chan, NULL, features, 1)) {
-			ast_log(LOG_WARNING, "Could not add %s to the bridge\n", ast_channel_name(chan));
-			ast_hangup(yanked_chan);
-			return -1;
-		}
-	}
-
-	if (play_tone && !ast_strlen_zero(xfersound)) {
-		struct ast_channel *play_chan = yanked_chan ?: chan;
-		RAII_VAR(struct ast_bridge_channel *, play_bridge_channel, NULL, ao2_cleanup);
-
-		ast_channel_lock(play_chan);
-		play_bridge_channel = ast_channel_get_bridge_channel(play_chan);
-		ast_channel_unlock(play_chan);
-
-		if (!play_bridge_channel) {
-			ast_log(LOG_WARNING, "Unable to play tone for channel %s. No longer in a bridge.\n",
-				ast_channel_name(play_chan));
-		} else {
-			ast_bridge_channel_queue_playfile(play_bridge_channel, NULL, xfersound, NULL);
-		}
-	}
-	return 0;
-}
-
-static int bridge_allows_optimization(struct ast_bridge *bridge)
-{
-	return !(bridge->inhibit_merge
-		|| bridge->dissolved
-		|| ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY));
-}
-
-/*!
- * \internal
- * \brief Lock the unreal channel stack for chan and prequalify it.
- * \since 12.0.0
- *
- * \param chan Unreal channel writing a frame into the channel driver.
- *
- * \note It is assumed that chan is already locked.
- *
- * \retval bridge on success with bridge and bridge_channel locked.
- * \retval NULL if cannot do optimization now.
- */
-static struct ast_bridge *optimize_lock_chan_stack(struct ast_channel *chan)
-{
-	struct ast_bridge *bridge;
-	struct ast_bridge_channel *bridge_channel;
-
-	if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
-		return NULL;
-	}
-	if (ast_channel_has_audio_frame_or_monitor(chan)) {
-		/* Channel has an active monitor, audiohook, or framehook. */
-		return NULL;
-	}
-	bridge_channel = ast_channel_internal_bridge_channel(chan);
-	if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
-		return NULL;
-	}
-	bridge = bridge_channel->bridge;
-	if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_SIMPLE
-		|| bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
-		|| ast_bridge_trylock(bridge)) {
-		ast_bridge_channel_unlock(bridge_channel);
-		return NULL;
-	}
-	if (!bridge_channel_internal_allows_optimization(bridge_channel) ||
-			!bridge_allows_optimization(bridge)) {
-		ast_bridge_unlock(bridge);
-		ast_bridge_channel_unlock(bridge_channel);
-		return NULL;
-	}
-	return bridge;
-}
-
-/*!
- * \internal
- * \brief Lock the unreal channel stack for peer and prequalify it.
- * \since 12.0.0
- *
- * \param peer Other unreal channel in the pair.
- *
- * \retval bridge on success with bridge, bridge_channel, and peer locked.
- * \retval NULL if cannot do optimization now.
- */
-static struct ast_bridge *optimize_lock_peer_stack(struct ast_channel *peer)
-{
-	struct ast_bridge *bridge;
-	struct ast_bridge_channel *bridge_channel;
-
-	if (ast_channel_trylock(peer)) {
-		return NULL;
-	}
-	if (!AST_LIST_EMPTY(ast_channel_readq(peer))) {
-		ast_channel_unlock(peer);
-		return NULL;
-	}
-	if (ast_channel_has_audio_frame_or_monitor(peer)) {
-		/* Peer has an active monitor, audiohook, or framehook. */
-		ast_channel_unlock(peer);
-		return NULL;
-	}
-	bridge_channel = ast_channel_internal_bridge_channel(peer);
-	if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
-		ast_channel_unlock(peer);
-		return NULL;
-	}
-	bridge = bridge_channel->bridge;
-	if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_IDLE
-		|| bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
-		|| ast_bridge_trylock(bridge)) {
-		ast_bridge_channel_unlock(bridge_channel);
-		ast_channel_unlock(peer);
-		return NULL;
-	}
-	if (!bridge_allows_optimization(bridge) ||
-			!bridge_channel_internal_allows_optimization(bridge_channel)) {
-		ast_bridge_unlock(bridge);
-		ast_bridge_channel_unlock(bridge_channel);
-		ast_channel_unlock(peer);
-		return NULL;
-	}
-	return bridge;
-}
-
-/*!
- * \internal
- * \brief Indicates allowability of a swap optimization
- */
-enum bridge_allow_swap {
-	/*! Bridges cannot allow for a swap optimization to occur */
-	SWAP_PROHIBITED,
-	/*! Bridge swap optimization can occur into the chan_bridge */
-	SWAP_TO_CHAN_BRIDGE,
-	/*! Bridge swap optimization can occur into the peer_bridge */
-	SWAP_TO_PEER_BRIDGE,
-};
-
-/*!
- * \internal
- * \brief Determine if two bridges allow for swap optimization to occur
- *
- * \param chan_bridge First bridge being tested
- * \param peer_bridge Second bridge being tested
- * \return Allowability of swap optimization
- */
-static enum bridge_allow_swap bridges_allow_swap_optimization(struct ast_bridge *chan_bridge,
-		struct ast_bridge *peer_bridge)
-{
-	int chan_priority;
-	int peer_priority;
-
-	if (!ast_test_flag(&chan_bridge->feature_flags,
-			AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
-			AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
-		&& !ast_test_flag(&peer_bridge->feature_flags,
-			AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
-			AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)) {
-		/*
-		 * Can swap either way.  Swap to the higher priority merge
-		 * bridge.
-		 */
-		chan_priority = chan_bridge->v_table->get_merge_priority(chan_bridge);
-		peer_priority = peer_bridge->v_table->get_merge_priority(peer_bridge);
-		if (chan_bridge->num_channels == 2
-			&& chan_priority <= peer_priority) {
-			return SWAP_TO_PEER_BRIDGE;
-		} else if (peer_bridge->num_channels == 2
-			&& peer_priority <= chan_priority) {
-			return SWAP_TO_CHAN_BRIDGE;
-		}
-	} else if (chan_bridge->num_channels == 2
-		&& !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
-		&& !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
-		/* Can swap optimize only one way. */
-		return SWAP_TO_PEER_BRIDGE;
-	} else if (peer_bridge->num_channels == 2
-		&& !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
-		&& !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
-		/* Can swap optimize only one way. */
-		return SWAP_TO_CHAN_BRIDGE;
-	}
-
-	return SWAP_PROHIBITED;
-}
-
-/*!
- * \internal
- * \brief Check and attempt to swap optimize out the unreal channels.
- * \since 12.0.0
- *
- * \param chan_bridge
- * \param chan_bridge_channel
- * \param peer_bridge
- * \param peer_bridge_channel
- * \param pvt Unreal data containing callbacks to call if the optimization actually
- * happens
- *
- * \retval 1 if unreal channels failed to optimize out.
- * \retval 0 if unreal channels were not optimized out.
- * \retval -1 if unreal channels were optimized out.
- */
-static int try_swap_optimize_out(struct ast_bridge *chan_bridge,
-	struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
-	struct ast_bridge_channel *peer_bridge_channel,
-	struct ast_unreal_pvt *pvt)
-{
-	struct ast_bridge *dst_bridge;
-	struct ast_bridge_channel *dst_bridge_channel;
-	struct ast_bridge_channel *src_bridge_channel;
-	struct ast_bridge_channel *other;
-	int res = 1;
-
-	switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
-	case SWAP_TO_CHAN_BRIDGE:
-		dst_bridge = chan_bridge;
-		dst_bridge_channel = chan_bridge_channel;
-		src_bridge_channel = peer_bridge_channel;
-		break;
-	case SWAP_TO_PEER_BRIDGE:
-		dst_bridge = peer_bridge;
-		dst_bridge_channel = peer_bridge_channel;
-		src_bridge_channel = chan_bridge_channel;
-		break;
-	case SWAP_PROHIBITED:
-	default:
-		return 0;
-	}
-
-	other = ast_bridge_channel_peer(src_bridge_channel);
-	if (other && other->state == BRIDGE_CHANNEL_STATE_WAIT) {
-		ast_verb(3, "Move-swap optimizing %s <-- %s.\n",
-			ast_channel_name(dst_bridge_channel->chan),
-			ast_channel_name(other->chan));
-
-		if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
-				&& pvt->callbacks->optimization_started) {
-			pvt->callbacks->optimization_started(pvt);
-			ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
-		}
-		other->swap = dst_bridge_channel->chan;
-		if (!bridge_do_move(dst_bridge, other, 1, 1)) {
-			ast_bridge_channel_leave_bridge(src_bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-			res = -1;
-			if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
-				pvt->callbacks->optimization_finished(pvt);
-			}
-		}
-	}
-	return res;
-}
-
-/*!
- * \internal
- * \brief Indicates allowability of a merge optimization
- */
-enum bridge_allow_merge {
-	/*! Bridge properties prohibit merge optimization */
-	MERGE_PROHIBITED,
-	/*! Merge optimization cannot occur because the source bridge has too few channels */
-	MERGE_NOT_ENOUGH_CHANNELS,
-	/*! Merge optimization cannot occur because multimix capability could not be requested */
-	MERGE_NO_MULTIMIX,
-	/*! Merge optimization allowed between bridges */
-	MERGE_ALLOWED,
-};
-
-/*!
- * \internal
- * \brief Determines allowability of a merge optimization
- *
- * \note The merge output parameter is undefined if MERGE_PROHIBITED is returned. For success
- * and other failure returns, a merge direction was determined, and the parameter is safe to
- * access.
- *
- * \param chan_bridge First bridge being tested
- * \param peer_bridge Second bridge being tested
- * \param num_kick_channels The number of channels to remove from the bridges during merging
- * \param[out] merge Indicates the recommended direction for the bridge merge
- */
-static enum bridge_allow_merge bridges_allow_merge_optimization(struct ast_bridge *chan_bridge,
-		struct ast_bridge *peer_bridge, int num_kick_channels, struct merge_direction *merge)
-{
-	*merge = bridge_merge_determine_direction(chan_bridge, peer_bridge);
-	if (!merge->dest) {
-		return MERGE_PROHIBITED;
-	}
-	if (merge->src->num_channels < 2) {
-		return MERGE_NOT_ENOUGH_CHANNELS;
-	} else if ((2 + num_kick_channels) < merge->dest->num_channels + merge->src->num_channels
-		&& !(merge->dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
-		&& (!ast_test_flag(&merge->dest->feature_flags, AST_BRIDGE_FLAG_SMART)
-			|| !(merge->dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
-		return MERGE_NO_MULTIMIX;
-	}
-
-	return MERGE_ALLOWED;
-}
-
-/*!
- * \internal
- * \brief Check and attempt to merge optimize out the unreal channels.
- * \since 12.0.0
- *
- * \param chan_bridge
- * \param chan_bridge_channel
- * \param peer_bridge
- * \param peer_bridge_channel
- * \param pvt Unreal data containing callbacks to call if the optimization actually
- * happens
- *
- * \retval 0 if unreal channels were not optimized out.
- * \retval -1 if unreal channels were optimized out.
- */
-static int try_merge_optimize_out(struct ast_bridge *chan_bridge,
-	struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
-	struct ast_bridge_channel *peer_bridge_channel,
-	struct ast_unreal_pvt *pvt)
-{
-	struct merge_direction merge;
-	struct ast_bridge_channel *kick_me[] = {
-		chan_bridge_channel,
-		peer_bridge_channel,
-	};
-
-	switch (bridges_allow_merge_optimization(chan_bridge, peer_bridge, ARRAY_LEN(kick_me), &merge)) {
-	case MERGE_ALLOWED:
-		break;
-	case MERGE_PROHIBITED:
-		return 0;
-	case MERGE_NOT_ENOUGH_CHANNELS:
-		ast_debug(4, "Can't optimize %s -- %s out, not enough channels in bridge %s.\n",
-			ast_channel_name(chan_bridge_channel->chan),
-			ast_channel_name(peer_bridge_channel->chan),
-			merge.src->uniqueid);
-		return 0;
-	case MERGE_NO_MULTIMIX:
-		ast_debug(4, "Can't optimize %s -- %s out, multimix is needed and it cannot be acquired.\n",
-			ast_channel_name(chan_bridge_channel->chan),
-			ast_channel_name(peer_bridge_channel->chan));
-		return 0;
-	}
-
-	ast_verb(3, "Merge optimizing %s -- %s out.\n",
-		ast_channel_name(chan_bridge_channel->chan),
-		ast_channel_name(peer_bridge_channel->chan));
-
-	if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
-			&& pvt->callbacks->optimization_started) {
-		pvt->callbacks->optimization_started(pvt);
-		ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
-	}
-	bridge_do_merge(merge.dest, merge.src, kick_me, ARRAY_LEN(kick_me), 1);
-	if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
-		pvt->callbacks->optimization_finished(pvt);
-	}
-
-	return -1;
-}
-
-int ast_bridge_unreal_optimize_out(struct ast_channel *chan, struct ast_channel *peer, struct ast_unreal_pvt *pvt)
-{
-	struct ast_bridge *chan_bridge;
-	struct ast_bridge *peer_bridge;
-	struct ast_bridge_channel *chan_bridge_channel;
-	struct ast_bridge_channel *peer_bridge_channel;
-	int res = 0;
-
-	chan_bridge = optimize_lock_chan_stack(chan);
-	if (!chan_bridge) {
-		return res;
-	}
-	chan_bridge_channel = ast_channel_internal_bridge_channel(chan);
-
-	peer_bridge = optimize_lock_peer_stack(peer);
-	if (peer_bridge) {
-		peer_bridge_channel = ast_channel_internal_bridge_channel(peer);
-
-		res = try_swap_optimize_out(chan_bridge, chan_bridge_channel,
-			peer_bridge, peer_bridge_channel, pvt);
-		if (!res) {
-			res = try_merge_optimize_out(chan_bridge, chan_bridge_channel,
-				peer_bridge, peer_bridge_channel, pvt);
-		} else if (0 < res) {
-			res = 0;
-		}
-
-		/* Release peer locks. */
-		ast_bridge_unlock(peer_bridge);
-		ast_bridge_channel_unlock(peer_bridge_channel);
-		ast_channel_unlock(peer);
-	}
-
-	/* Release chan locks. */
-	ast_bridge_unlock(chan_bridge);
-	ast_bridge_channel_unlock(chan_bridge_channel);
-
-	return res;
-}
-
-enum ast_bridge_optimization ast_bridges_allow_optimization(struct ast_bridge *chan_bridge,
-		struct ast_bridge *peer_bridge)
-{
-	struct merge_direction merge;
-
-	if (!bridge_allows_optimization(chan_bridge) || !bridge_allows_optimization(peer_bridge)) {
-		return AST_BRIDGE_OPTIMIZE_PROHIBITED;
-	}
-
-	switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
-	case SWAP_TO_CHAN_BRIDGE:
-		return AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE;
-	case SWAP_TO_PEER_BRIDGE:
-		return AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE;
-	case SWAP_PROHIBITED:
-	default:
-		break;
-	}
-
-	/* Two channels will be kicked from the bridges, the unreal;1 and unreal;2 channels */
-	if (bridges_allow_merge_optimization(chan_bridge, peer_bridge, 2, &merge) != MERGE_ALLOWED) {
-		return AST_BRIDGE_OPTIMIZE_PROHIBITED;
-	}
-
-	if (merge.dest == chan_bridge) {
-		return AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE;
-	} else {
-		return AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE;
-	}
-}
-
-/*!
- * \internal
- * \brief Adjust the bridge merge inhibit request count.
- * \since 12.0.0
- *
- * \param bridge What to operate on.
- * \param request Inhibit request increment.
- *     (Positive to add requests.  Negative to remove requests.)
- *
- * \note This function assumes bridge is locked.
- *
- * \return Nothing
- */
-void bridge_merge_inhibit_nolock(struct ast_bridge *bridge, int request)
-{
-	int new_request;
-
-	new_request = bridge->inhibit_merge + request;
-	ast_assert(0 <= new_request);
-	bridge->inhibit_merge = new_request;
-}
-
-void ast_bridge_merge_inhibit(struct ast_bridge *bridge, int request)
-{
-	ast_bridge_lock(bridge);
-	bridge_merge_inhibit_nolock(bridge, request);
-	ast_bridge_unlock(bridge);
-}
-
-int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-/* BUGBUG the case of a disolved bridge while channel is suspended is not handled. */
-/* BUGBUG suspend/unsuspend needs to be rethought. The caller must block until it has successfully suspended the channel for temporary control. */
-/* BUGBUG external suspend/unsuspend needs to be eliminated. The channel may be playing a file at the time and stealing it then is not good. */
-
-	ast_bridge_lock(bridge);
-
-	if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
-		ast_bridge_unlock(bridge);
-		return -1;
-	}
-
-	bridge_channel_internal_suspend_nolock(bridge_channel);
-
-	ast_bridge_unlock(bridge);
-
-	return 0;
-}
-
-int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_bridge_channel *bridge_channel;
-/* BUGBUG the case of a disolved bridge while channel is suspended is not handled. */
-
-	ast_bridge_lock(bridge);
-
-	if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
-		ast_bridge_unlock(bridge);
-		return -1;
-	}
-
-	bridge_channel_internal_unsuspend_nolock(bridge_channel);
-
-	ast_bridge_unlock(bridge);
-
-	return 0;
-}
-
-void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
-{
-	technology->suspended = 1;
-}
-
-void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
-{
-/* BUGBUG unsuspending a bridge technology probably needs to prod all existing bridges to see if they should start using it. */
-	technology->suspended = 0;
-}
-
-int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf)
-{
-	if (ARRAY_LEN(builtin_features_handlers) <= feature
-		|| builtin_features_handlers[feature]) {
-		return -1;
-	}
-
-	if (!ast_strlen_zero(dtmf)) {
-		ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
-	}
-
-	builtin_features_handlers[feature] = callback;
-
-	return 0;
-}
-
-int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
-{
-	if (ARRAY_LEN(builtin_features_handlers) <= feature
-		|| !builtin_features_handlers[feature]) {
-		return -1;
-	}
-
-	builtin_features_handlers[feature] = NULL;
-
-	return 0;
-}
-
-int ast_bridge_features_do(enum ast_bridge_builtin_feature feature, struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, void *hook_pvt)
-{
-	ast_bridge_hook_callback callback;
-
-	if (ARRAY_LEN(builtin_features_handlers) <= feature) {
-		return -1;
-	}
-
-	callback = builtin_features_handlers[feature];
-	if (!callback) {
-		return -1;
-	}
-	callback(bridge, bridge_channel, hook_pvt);
-
-	return 0;
-}
-
-int ast_bridge_interval_register(enum ast_bridge_builtin_interval interval, ast_bridge_builtin_set_limits_fn callback)
-{
-	if (ARRAY_LEN(builtin_interval_handlers) <= interval
-		|| builtin_interval_handlers[interval]) {
-		return -1;
-	}
-
-	builtin_interval_handlers[interval] = callback;
-
-	return 0;
-}
-
-int ast_bridge_interval_unregister(enum ast_bridge_builtin_interval interval)
-{
-	if (ARRAY_LEN(builtin_interval_handlers) <= interval
-		|| !builtin_interval_handlers[interval]) {
-		return -1;
-	}
-
-	builtin_interval_handlers[interval] = NULL;
-
-	return 0;
-
-}
-
-/*!
- * \internal
- * \brief Bridge hook destructor.
- * \since 12.0.0
- *
- * \param vhook Object to destroy.
- *
- * \return Nothing
- */
-static void bridge_hook_destroy(void *vhook)
-{
-	struct ast_bridge_hook *hook = vhook;
-
-	if (hook->destructor) {
-		hook->destructor(hook->hook_pvt);
-	}
-}
-
-/*!
- * \internal
- * \brief Allocate and setup a generic bridge hook.
- * \since 12.0.0
- *
- * \param size How big an object to allocate.
- * \param callback Function to execute upon activation
- * \param hook_pvt Unique data
- * \param destructor Optional destructor callback for hook_pvt data
- * \param remove_flags Dictates what situations the hook should be removed.
- *
- * \retval hook on success.
- * \retval NULL on error.
- */
-static struct ast_bridge_hook *bridge_hook_generic(size_t size,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	struct ast_bridge_hook *hook;
-
-	/* Allocate new hook and setup it's basic variables */
-	hook = ao2_alloc_options(size, bridge_hook_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
-	if (hook) {
-		hook->callback = callback;
-		hook->destructor = destructor;
-		hook->hook_pvt = hook_pvt;
-		ast_set_flag(&hook->remove_flags, remove_flags);
-	}
-
-	return hook;
-}
-
-int ast_bridge_dtmf_hook(struct ast_bridge_features *features,
-	const char *dtmf,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	struct ast_bridge_hook_dtmf *hook;
-	int res;
-
-	/* Allocate new hook and setup it's various variables */
-	hook = (struct ast_bridge_hook_dtmf *) bridge_hook_generic(sizeof(*hook), callback,
-		hook_pvt, destructor, remove_flags);
-	if (!hook) {
-		return -1;
-	}
-	hook->generic.type = AST_BRIDGE_HOOK_TYPE_DTMF;
-	ast_copy_string(hook->dtmf.code, dtmf, sizeof(hook->dtmf.code));
-
-	/* Once done we put it in the container. */
-	res = ao2_link(features->dtmf_hooks, hook) ? 0 : -1;
-	if (res) {
-		/*
-		 * Could not link the hook into the container.
-		 *
-		 * Remove the hook_pvt destructor call from the hook since we
-		 * are returning failure to install the hook.
-		 */
-		hook->generic.destructor = NULL;
-	}
-	ao2_ref(hook, -1);
-
-	return res;
-}
-
-/*!
- * \internal
- * \brief Attach an other hook to a bridge features structure
- *
- * \param features Bridge features structure
- * \param callback Function to execute upon activation
- * \param hook_pvt Unique data
- * \param destructor Optional destructor callback for hook_pvt data
- * \param remove_flags Dictates what situations the hook should be removed.
- * \param type What type of hook is being attached.
- *
- * \retval 0 on success
- * \retval -1 on failure (The caller must cleanup any hook_pvt resources.)
- */
-static int bridge_other_hook(struct ast_bridge_features *features,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags,
-	enum ast_bridge_hook_type type)
-{
-	struct ast_bridge_hook *hook;
-	int res;
-
-	/* Allocate new hook and setup it's various variables */
-	hook = bridge_hook_generic(sizeof(*hook), callback, hook_pvt, destructor,
-		remove_flags);
-	if (!hook) {
-		return -1;
-	}
-	hook->type = type;
-
-	/* Once done we put it in the container. */
-	res = ao2_link(features->other_hooks, hook) ? 0 : -1;
-	if (res) {
-		/*
-		 * Could not link the hook into the container.
-		 *
-		 * Remove the hook_pvt destructor call from the hook since we
-		 * are returning failure to install the hook.
-		 */
-		hook->destructor = NULL;
-	}
-	ao2_ref(hook, -1);
-
-	return res;
-}
-
-int ast_bridge_hangup_hook(struct ast_bridge_features *features,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
-		AST_BRIDGE_HOOK_TYPE_HANGUP);
-}
-
-int ast_bridge_join_hook(struct ast_bridge_features *features,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
-		AST_BRIDGE_HOOK_TYPE_JOIN);
-}
-
-int ast_bridge_leave_hook(struct ast_bridge_features *features,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
-		AST_BRIDGE_HOOK_TYPE_LEAVE);
-}
-
-int ast_bridge_talk_detector_hook(struct ast_bridge_features *features,
-	ast_bridge_talking_indicate_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	ast_bridge_hook_callback hook_cb = (ast_bridge_hook_callback) callback;
-
-	return bridge_other_hook(features, hook_cb, hook_pvt, destructor, remove_flags,
-		AST_BRIDGE_HOOK_TYPE_TALK);
-}
-
-int ast_bridge_interval_hook(struct ast_bridge_features *features,
-	unsigned int interval,
-	ast_bridge_hook_callback callback,
-	void *hook_pvt,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	struct ast_bridge_hook_timer *hook;
-	int res;
-
-	if (!features ||!interval || !callback) {
-		return -1;
-	}
-
-	/* Allocate new hook and setup it's various variables */
-	hook = (struct ast_bridge_hook_timer *) bridge_hook_generic(sizeof(*hook), callback,
-		hook_pvt, destructor, remove_flags);
-	if (!hook) {
-		return -1;
-	}
-	hook->generic.type = AST_BRIDGE_HOOK_TYPE_TIMER;
-	hook->timer.interval = interval;
-	hook->timer.trip_time = ast_tvadd(ast_tvnow(), ast_samp2tv(hook->timer.interval, 1000));
-	hook->timer.seqno = ast_atomic_fetchadd_int((int *) &features->interval_sequence, +1);
-
-	ast_debug(1, "Putting interval hook %p with interval %u in the heap on features %p\n",
-		hook, hook->timer.interval, features);
-	ast_heap_wrlock(features->interval_hooks);
-	res = ast_heap_push(features->interval_hooks, hook);
-	ast_heap_unlock(features->interval_hooks);
-	if (res) {
-		/*
-		 * Could not push the hook into the heap
-		 *
-		 * Remove the hook_pvt destructor call from the hook since we
-		 * are returning failure to install the hook.
-		 */
-		hook->generic.destructor = NULL;
-		ao2_ref(hook, -1);
-	}
-
-	return res ? -1 : 0;
-}
-
-int ast_bridge_features_enable(struct ast_bridge_features *features,
-	enum ast_bridge_builtin_feature feature,
-	const char *dtmf,
-	void *config,
-	ast_bridge_hook_pvt_destructor destructor,
-	enum ast_bridge_hook_remove_flags remove_flags)
-{
-	if (ARRAY_LEN(builtin_features_handlers) <= feature
-		|| !builtin_features_handlers[feature]) {
-		return -1;
-	}
-
-	/* If no alternate DTMF stream was provided use the default one */
-	if (ast_strlen_zero(dtmf)) {
-		dtmf = builtin_features_dtmf[feature];
-		/* If no DTMF is still available (ie: it has been disabled) then error out now */
-		if (ast_strlen_zero(dtmf)) {
-			ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n",
-				feature, features);
-			return -1;
-		}
-	}
-
-	/*
-	 * The rest is basically pretty easy.  We create another hook
-	 * using the built in feature's DTMF callback.  Easy as pie.
-	 */
-	return ast_bridge_dtmf_hook(features, dtmf, builtin_features_handlers[feature],
-		config, destructor, remove_flags);
-}
-
-int ast_bridge_features_limits_construct(struct ast_bridge_features_limits *limits)
-{
-	memset(limits, 0, sizeof(*limits));
-
-	if (ast_string_field_init(limits, 256)) {
-		ast_free(limits);
-		return -1;
-	}
-
-	return 0;
-}
-
-void ast_bridge_features_limits_destroy(struct ast_bridge_features_limits *limits)
-{
-	ast_string_field_free_memory(limits);
-}
-
-int ast_bridge_features_set_limits(struct ast_bridge_features *features,
-		struct ast_bridge_features_limits *limits, enum ast_bridge_hook_remove_flags remove_flags)
-{
-	if (builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]) {
-		ast_bridge_builtin_set_limits_fn bridge_features_set_limits_callback;
-
-		bridge_features_set_limits_callback = builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS];
-		return bridge_features_set_limits_callback(features, limits, remove_flags);
-	}
-
-	ast_log(LOG_ERROR, "Attempted to set limits without an AST_BRIDGE_BUILTIN_INTERVAL_LIMITS callback registered.\n");
-	return -1;
-}
-
-void ast_bridge_features_set_flag(struct ast_bridge_features *features, unsigned int flag)
-{
-	ast_set_flag(&features->feature_flags, flag);
-	features->usable = 1;
-}
-
-/*!
- * \internal
- * \brief ao2 object match hooks with appropriate remove_flags.
- * \since 12.0.0
- *
- * \param obj Feature hook object.
- * \param arg Removal flags
- * \param flags Not used
- *
- * \retval CMP_MATCH if hook's remove_flags match the removal flags set.
- * \retval 0 if not match.
- */
-static int hook_remove_match(void *obj, void *arg, int flags)
-{
-	struct ast_bridge_hook *hook = obj;
-	enum ast_bridge_hook_remove_flags *remove_flags = arg;
-
-	if (ast_test_flag(&hook->remove_flags, *remove_flags)) {
-		return CMP_MATCH;
-	} else {
-		return 0;
-	}
-}
-
-/*!
- * \internal
- * \brief Remove all hooks with appropriate remove_flags in the container.
- * \since 12.0.0
- *
- * \param hooks Hooks container to work on.
- * \param remove_flags Determinator for whether hook is removed
- *
- * \return Nothing
- */
-static void hooks_remove_container(struct ao2_container *hooks, enum ast_bridge_hook_remove_flags remove_flags)
-{
-	ao2_callback(hooks, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
-		hook_remove_match, &remove_flags);
-}
-
-/*!
- * \internal
- * \brief Remove all hooks in the heap with appropriate remove_flags set.
- * \since 12.0.0
- *
- * \param hooks Hooks heap to work on.
- * \param remove_flags Determinator for whether hook is removed
- *
- * \return Nothing
- */
-static void hooks_remove_heap(struct ast_heap *hooks, enum ast_bridge_hook_remove_flags remove_flags)
-{
-	struct ast_bridge_hook *hook;
-	int changed;
-
-	ast_heap_wrlock(hooks);
-	do {
-		int idx;
-
-		changed = 0;
-		for (idx = ast_heap_size(hooks); idx; --idx) {
-			hook = ast_heap_peek(hooks, idx);
-			if (ast_test_flag(&hook->remove_flags, remove_flags)) {
-				ast_heap_remove(hooks, hook);
-				ao2_ref(hook, -1);
-				changed = 1;
-			}
-		}
-	} while (changed);
-	ast_heap_unlock(hooks);
-}
-
-void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags)
-{
-	hooks_remove_container(features->dtmf_hooks, remove_flags);
-	hooks_remove_container(features->other_hooks, remove_flags);
-	hooks_remove_heap(features->interval_hooks, remove_flags);
-}
-
-static int interval_hook_time_cmp(void *a, void *b)
-{
-	struct ast_bridge_hook_timer *hook_a = a;
-	struct ast_bridge_hook_timer *hook_b = b;
-	int cmp;
-
-	cmp = ast_tvcmp(hook_b->timer.trip_time, hook_a->timer.trip_time);
-	if (cmp) {
-		return cmp;
-	}
-
-	cmp = hook_b->timer.seqno - hook_a->timer.seqno;
-	return cmp;
-}
-
-/*!
- * \internal
- * \brief DTMF hook container sort comparison function.
- * \since 12.0.0
- *
- * \param obj_left pointer to the (user-defined part) of an object.
- * \param obj_right pointer to the (user-defined part) of an object.
- * \param flags flags from ao2_callback()
- *   OBJ_POINTER - if set, 'obj_right', is an object.
- *   OBJ_KEY - if set, 'obj_right', is a search key item that is not an object.
- *   OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object.
- *
- * \retval <0 if obj_left < obj_right
- * \retval =0 if obj_left == obj_right
- * \retval >0 if obj_left > obj_right
- */
-static int bridge_dtmf_hook_sort(const void *obj_left, const void *obj_right, int flags)
-{
-	const struct ast_bridge_hook_dtmf *hook_left = obj_left;
-	const struct ast_bridge_hook_dtmf *hook_right = obj_right;
-	const char *right_key = obj_right;
-	int cmp;
-
-	switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
-	default:
-	case OBJ_POINTER:
-		right_key = hook_right->dtmf.code;
-		/* Fall through */
-	case OBJ_KEY:
-		cmp = strcasecmp(hook_left->dtmf.code, right_key);
-		break;
-	case OBJ_PARTIAL_KEY:
-		cmp = strncasecmp(hook_left->dtmf.code, right_key, strlen(right_key));
-		break;
-	}
-	return cmp;
-}
-
-/* BUGBUG make ast_bridge_features_init() static when make ast_bridge_join() requires features to be allocated. */
-int ast_bridge_features_init(struct ast_bridge_features *features)
-{
-	/* Zero out the structure */
-	memset(features, 0, sizeof(*features));
-
-	/* Initialize the DTMF hooks container */
-	features->dtmf_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX,
-		AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_dtmf_hook_sort, NULL);
-	if (!features->dtmf_hooks) {
-		return -1;
-	}
-
-	/* Initialize the miscellaneous other hooks container */
-	features->other_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL,
-		NULL);
-	if (!features->other_hooks) {
-		return -1;
-	}
-
-	/* Initialize the interval hooks heap */
-	features->interval_hooks = ast_heap_create(8, interval_hook_time_cmp,
-		offsetof(struct ast_bridge_hook_timer, timer.heap_index));
-	if (!features->interval_hooks) {
-		return -1;
-	}
-
-	return 0;
-}
-
-/* BUGBUG make ast_bridge_features_cleanup() static when make ast_bridge_join() requires features to be allocated. */
-void ast_bridge_features_cleanup(struct ast_bridge_features *features)
-{
-	struct ast_bridge_hook_timer *hook;
-
-	/* Destroy the interval hooks heap. */
-	if (features->interval_hooks) {
-		while ((hook = ast_heap_pop(features->interval_hooks))) {
-			ao2_ref(hook, -1);
-		}
-		features->interval_hooks = ast_heap_destroy(features->interval_hooks);
-	}
-
-	/* If the features contains a limits pvt, destroy that as well. */
-	if (features->limits) {
-		ast_bridge_features_limits_destroy(features->limits);
-		ast_free(features->limits);
-		features->limits = NULL;
-	}
-
-	/* Destroy the miscellaneous other hooks container. */
-	ao2_cleanup(features->other_hooks);
-	features->other_hooks = NULL;
-
-	/* Destroy the DTMF hooks container. */
-	ao2_cleanup(features->dtmf_hooks);
-	features->dtmf_hooks = NULL;
-}
-
-void ast_bridge_features_destroy(struct ast_bridge_features *features)
-{
-	if (!features) {
-		return;
-	}
-	ast_bridge_features_cleanup(features);
-	ast_free(features);
-}
-
-struct ast_bridge_features *ast_bridge_features_new(void)
-{
-	struct ast_bridge_features *features;
-
-	features = ast_malloc(sizeof(*features));
-	if (features) {
-		if (ast_bridge_features_init(features)) {
-			ast_bridge_features_destroy(features);
-			features = NULL;
-		}
-	}
-
-	return features;
-}
-
-void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval)
-{
-	ast_bridge_lock(bridge);
-	bridge->softmix.internal_mixing_interval = mixing_interval;
-	ast_bridge_unlock(bridge);
-}
-
-void ast_bridge_set_internal_sample_rate(struct ast_bridge *bridge, unsigned int sample_rate)
-{
-	ast_bridge_lock(bridge);
-	bridge->softmix.internal_sample_rate = sample_rate;
-	ast_bridge_unlock(bridge);
-}
-
-static void cleanup_video_mode(struct ast_bridge *bridge)
-{
-	switch (bridge->softmix.video_mode.mode) {
-	case AST_BRIDGE_VIDEO_MODE_NONE:
-		break;
-	case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
-		if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) {
-			ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc);
-		}
-		break;
-	case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) {
-			ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc);
-		}
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) {
-			ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc);
-		}
-	}
-	memset(&bridge->softmix.video_mode, 0, sizeof(bridge->softmix.video_mode));
-}
-
-void ast_bridge_set_single_src_video_mode(struct ast_bridge *bridge, struct ast_channel *video_src_chan)
-{
-	ast_bridge_lock(bridge);
-	cleanup_video_mode(bridge);
-	bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
-	bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan);
-	ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to single source\r\nVideo Mode: %d\r\nVideo Channel: %s",
-		bridge->softmix.video_mode.mode, ast_channel_name(video_src_chan));
-	ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE);
-	ast_bridge_unlock(bridge);
-}
-
-void ast_bridge_set_talker_src_video_mode(struct ast_bridge *bridge)
-{
-	ast_bridge_lock(bridge);
-	cleanup_video_mode(bridge);
-	bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
-	ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to talker source\r\nVideo Mode: %d",
-		bridge->softmix.video_mode.mode);
-	ast_bridge_unlock(bridge);
-}
-
-void ast_bridge_update_talker_src_video_mode(struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe)
-{
-	struct ast_bridge_video_talker_src_data *data;
-
-	/* If the channel doesn't support video, we don't care about it */
-	if (!ast_format_cap_has_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO)) {
-		return;
-	}
-
-	ast_bridge_lock(bridge);
-	data = &bridge->softmix.video_mode.mode_data.talker_src_data;
-
-	if (data->chan_vsrc == chan) {
-		data->average_talking_energy = talker_energy;
-	} else if ((data->average_talking_energy < talker_energy) && is_keyframe) {
-		if (data->chan_old_vsrc) {
-			ast_channel_unref(data->chan_old_vsrc);
-		}
-		if (data->chan_vsrc) {
-			data->chan_old_vsrc = data->chan_vsrc;
-			ast_indicate(data->chan_old_vsrc, AST_CONTROL_VIDUPDATE);
-		}
-		data->chan_vsrc = ast_channel_ref(chan);
-		data->average_talking_energy = talker_energy;
-		ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc));
-		ast_indicate(data->chan_vsrc, AST_CONTROL_VIDUPDATE);
-	} else if ((data->average_talking_energy < talker_energy) && !is_keyframe) {
-		ast_indicate(chan, AST_CONTROL_VIDUPDATE);
-	} else if (!data->chan_vsrc && is_keyframe) {
-		data->chan_vsrc = ast_channel_ref(chan);
-		data->average_talking_energy = talker_energy;
-		ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc));
-		ast_indicate(chan, AST_CONTROL_VIDUPDATE);
-	} else if (!data->chan_old_vsrc && is_keyframe) {
-		data->chan_old_vsrc = ast_channel_ref(chan);
-		ast_indicate(chan, AST_CONTROL_VIDUPDATE);
-	}
-	ast_bridge_unlock(bridge);
-}
-
-int ast_bridge_number_video_src(struct ast_bridge *bridge)
-{
-	int res = 0;
-
-	ast_bridge_lock(bridge);
-	switch (bridge->softmix.video_mode.mode) {
-	case AST_BRIDGE_VIDEO_MODE_NONE:
-		break;
-	case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
-		if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) {
-			res = 1;
-		}
-		break;
-	case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) {
-			res++;
-		}
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) {
-			res++;
-		}
-	}
-	ast_bridge_unlock(bridge);
-	return res;
-}
-
-int ast_bridge_is_video_src(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	int res = 0;
-
-	ast_bridge_lock(bridge);
-	switch (bridge->softmix.video_mode.mode) {
-	case AST_BRIDGE_VIDEO_MODE_NONE:
-		break;
-	case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
-		if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc == chan) {
-			res = 1;
-		}
-		break;
-	case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc == chan) {
-			res = 1;
-		} else if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) {
-			res = 2;
-		}
-
-	}
-	ast_bridge_unlock(bridge);
-	return res;
-}
-
-void ast_bridge_remove_video_src(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	ast_bridge_lock(bridge);
-	switch (bridge->softmix.video_mode.mode) {
-	case AST_BRIDGE_VIDEO_MODE_NONE:
-		break;
-	case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
-		if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc == chan) {
-			if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) {
-				ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc);
-			}
-			bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = NULL;
-		}
-		break;
-	case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc == chan) {
-			if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) {
-				ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc);
-			}
-			bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc = NULL;
-			bridge->softmix.video_mode.mode_data.talker_src_data.average_talking_energy = 0;
-		}
-		if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) {
-			if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) {
-				ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc);
-			}
-			bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc = NULL;
-		}
-	}
-	ast_bridge_unlock(bridge);
-}
-
-static int channel_hash(const void *obj, int flags)
-{
-	const struct ast_channel *chan = obj;
-	const char *name = obj;
-	int hash;
-
-	switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
-	default:
-	case OBJ_POINTER:
-		name = ast_channel_name(chan);
-		/* Fall through */
-	case OBJ_KEY:
-		hash = ast_str_hash(name);
-		break;
-	case OBJ_PARTIAL_KEY:
-		/* Should never happen in hash callback. */
-		ast_assert(0);
-		hash = 0;
-		break;
-	}
-	return hash;
-}
-
-static int channel_cmp(void *obj, void *arg, int flags)
-{
-	const struct ast_channel *left = obj;
-	const struct ast_channel *right = arg;
-	const char *right_name = arg;
-	int cmp;
-
-	switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
-	default:
-	case OBJ_POINTER:
-		right_name = ast_channel_name(right);
-		/* Fall through */
-	case OBJ_KEY:
-		cmp = strcmp(ast_channel_name(left), right_name);
-		break;
-	case OBJ_PARTIAL_KEY:
-		cmp = strncmp(ast_channel_name(left), right_name, strlen(right_name));
-		break;
-	}
-	return cmp ? 0 : CMP_MATCH;
-}
-
-struct ao2_container *ast_bridge_peers_nolock(struct ast_bridge *bridge)
-{
-	struct ao2_container *channels;
-	struct ast_bridge_channel *iter;
-
-	channels = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK,
-		13, channel_hash, channel_cmp);
-	if (!channels) {
-		return NULL;
-	}
-
-	AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
-		ao2_link(channels, iter->chan);
-	}
-
-	return channels;
-}
-
-struct ao2_container *ast_bridge_peers(struct ast_bridge *bridge)
-{
-	struct ao2_container *channels;
-
-	ast_bridge_lock(bridge);
-	channels = ast_bridge_peers_nolock(bridge);
-	ast_bridge_unlock(bridge);
-
-	return channels;
-}
-
-struct ast_channel *ast_bridge_peer_nolock(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_channel *peer = NULL;
-	struct ast_bridge_channel *iter;
-
-	/* Asking for the peer channel only makes sense on a two-party bridge. */
-	if (bridge->num_channels == 2
-		&& bridge->technology->capabilities
-			& (AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX)) {
-		int in_bridge = 0;
-
-		AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
-			if (iter->chan != chan) {
-				peer = iter->chan;
-			} else {
-				in_bridge = 1;
-			}
-		}
-		if (in_bridge && peer) {
-			ast_channel_ref(peer);
-		} else {
-			peer = NULL;
-		}
-	}
-
-	return peer;
-}
-
-struct ast_channel *ast_bridge_peer(struct ast_bridge *bridge, struct ast_channel *chan)
-{
-	struct ast_channel *peer;
-
-	ast_bridge_lock(bridge);
-	peer = ast_bridge_peer_nolock(bridge, chan);
-	ast_bridge_unlock(bridge);
-
-	return peer;
-}
-
-/*!
- * \internal
- * \brief Transfer an entire bridge to a specific destination.
- *
- * This creates a local channel to dial out and swaps the called local channel
- * with the transferer channel. By doing so, all participants in the bridge are
- * connected to the specified destination.
- *
- * While this means of transferring would work for both two-party and multi-party
- * bridges, this method is only used for multi-party bridges since this method would
- * be less efficient for two-party bridges.
- *
- * \param transferer The channel performing a transfer
- * \param bridge The bridge where the transfer is being performed
- * \param exten The destination extension for the blind transfer
- * \param context The destination context for the blind transfer
- * \param hook Framehook to attach to local channel
- * \return The success or failure of the operation
- */
-static enum ast_transfer_result blind_transfer_bridge(struct ast_channel *transferer,
-		struct ast_bridge *bridge, const char *exten, const char *context,
-		transfer_channel_cb new_channel_cb, void *user_data)
-{
-	struct ast_channel *local;
-	char chan_name[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
-	int cause;
-
-	snprintf(chan_name, sizeof(chan_name), "%s@%s", exten, context);
-	local = ast_request("Local", ast_channel_nativeformats(transferer), transferer,
-			chan_name, &cause);
-	if (!local) {
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-
-	if (new_channel_cb) {
-		new_channel_cb(local, user_data, AST_BRIDGE_TRANSFER_MULTI_PARTY);
-	}
-
-	if (ast_call(local, chan_name, 0)) {
-		ast_hangup(local);
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-	if (ast_bridge_impart(bridge, local, transferer, NULL, 1)) {
-		ast_hangup(local);
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-	return AST_BRIDGE_TRANSFER_SUCCESS;
-}
-
-/*!
- * \internal
- * \brief Base data to publish for stasis attended transfer messages
- */
-struct stasis_attended_transfer_publish_data {
-	/* The bridge between the transferer and transferee, and the transferer channel in this bridge */
-	struct ast_bridge_channel_pair to_transferee;
-	/* The bridge between the transferer and transfer target, and the transferer channel in this bridge */
-	struct ast_bridge_channel_pair to_transfer_target;
-};
-
-static void stasis_publish_data_cleanup(struct stasis_attended_transfer_publish_data *publication)
-{
-	ast_channel_unref(publication->to_transferee.channel);
-	ast_channel_unref(publication->to_transfer_target.channel);
-	ao2_cleanup(publication->to_transferee.bridge);
-	ao2_cleanup(publication->to_transfer_target.bridge);
-}
-
-/*!
- * \internal
- * \brief Set up base data for an attended transfer stasis publication
- *
- * \param to_transferee The original transferer channel, which may be bridged to a transferee
- * \param to_transferee_bridge The bridge that to_transferee is in.
- * \param to_transfer_target The second transferer channel, which may be bridged to a transfer target
- * \param to_target_bridge The bridge that to_transfer_target_is in.
- * \param[out] publication A structure to hold the other parameters
- */
-static void stasis_publish_data_init(struct ast_channel *to_transferee,
-		struct ast_bridge *to_transferee_bridge, struct ast_channel *to_transfer_target,
-		struct ast_bridge *to_target_bridge,
-		struct stasis_attended_transfer_publish_data *publication)
-{
-	memset(publication, 0, sizeof(*publication));
-	publication->to_transferee.channel = ast_channel_ref(to_transferee);
-	if (to_transferee_bridge) {
-		ao2_ref(to_transferee_bridge, +1);
-		publication->to_transferee.bridge = to_transferee_bridge;
-	}
-
-	publication->to_transfer_target.channel = ast_channel_ref(to_transfer_target);
-	if (to_target_bridge) {
-		ao2_ref(to_target_bridge, +1);
-		publication->to_transfer_target.bridge = to_target_bridge;
-	}
-}
-
-/*
- * \internal
- * \brief Publish a stasis attended transfer resulting in a bridge merge
- *
- * \param publication Base data about the attended transfer
- * \param final_bridge The surviving bridge of the attended transfer
- */
-static void publish_attended_transfer_bridge_merge(struct stasis_attended_transfer_publish_data *publication,
-		struct ast_bridge *final_bridge)
-{
-	ast_bridge_publish_attended_transfer_bridge_merge(1, AST_BRIDGE_TRANSFER_SUCCESS,
-			&publication->to_transferee, &publication->to_transfer_target, final_bridge);
-}
-
-/*
- * \internal
- * \brief Publish a stasis attended transfer to an application
- *
- * \param publication Base data about the attended transfer
- * \param app The app that is running at the conclusion of the transfer
- */
-static void publish_attended_transfer_app(struct stasis_attended_transfer_publish_data *publication,
-		const char *app)
-{
-	ast_bridge_publish_attended_transfer_app(1, AST_BRIDGE_TRANSFER_SUCCESS,
-			&publication->to_transferee, &publication->to_transfer_target, app);
-}
-
-/*
- * \internal
- * \brief Publish a stasis attended transfer showing a link between bridges
- *
- * \param publication Base data about the attended transfer
- * \param local_channel1 Local channel in the original bridge
- * \param local_channel2 Local channel in the second bridge
- */
-static void publish_attended_transfer_link(struct stasis_attended_transfer_publish_data *publication,
-		struct ast_channel *local_channel1, struct ast_channel *local_channel2)
-{
-	struct ast_channel *locals[2] = { local_channel1, local_channel2 };
-
-	ast_bridge_publish_attended_transfer_link(1, AST_BRIDGE_TRANSFER_SUCCESS,
-			&publication->to_transferee, &publication->to_transfer_target, locals);
-}
-
-/*
- * \internal
- * \brief Publish a stasis attended transfer failure
- *
- * \param publication Base data about the attended transfer
- * \param result The transfer result
- */
-static void publish_attended_transfer_fail(struct stasis_attended_transfer_publish_data *publication,
-		enum ast_transfer_result result)
-{
-	ast_bridge_publish_attended_transfer_fail(1, result, &publication->to_transferee,
-			&publication->to_transfer_target);
-}
-
-/*!
- * \brief Perform an attended transfer of a bridge
- *
- * This performs an attended transfer of an entire bridge to a target.
- * The target varies, depending on what bridges exist during the transfer
- * attempt.
- *
- * If two bridges exist, then a local channel is created to link the two
- * bridges together.
- *
- * If only one bridge exists, then a local channel is created with one end
- * placed into the existing bridge and the other end masquerading into
- * the unbridged channel.
- *
- * \param chan1 Transferer channel. Guaranteed to be bridged.
- * \param chan2 Other transferer channel. May or may not be bridged.
- * \param bridge1 Bridge that chan1 is in. Guaranteed to be non-NULL.
- * \param bridge2 Bridge that chan2 is in. If NULL, then chan2 is not bridged.
- * \param publication Data to publish for a stasis attended transfer message.
- * \retval AST_BRIDGE_TRANSFER_FAIL Internal error occurred
- * \retval AST_BRIDGE_TRANSFER_SUCCESS Succesfully transferred the bridge
- */
-static enum ast_transfer_result attended_transfer_bridge(struct ast_channel *chan1,
-		struct ast_channel *chan2, struct ast_bridge *bridge1, struct ast_bridge *bridge2,
-		struct stasis_attended_transfer_publish_data *publication)
-{
-	static const char *dest = "_attended@transfer/m";
-	struct ast_channel *local_chan;
-	int cause;
-	int res;
-	const char *app = NULL;
-
-	local_chan = ast_request("Local", ast_channel_nativeformats(chan1), chan1,
-			dest, &cause);
-
-	if (!local_chan) {
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-
-	if (bridge2) {
-		res = ast_local_setup_bridge(local_chan, bridge2, chan2, NULL);
-	} else {
-		app = ast_strdupa(ast_channel_appl(chan2));
-		res = ast_local_setup_masquerade(local_chan, chan2);
-	}
-
-	if (res) {
-		ast_hangup(local_chan);
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-
-	if (ast_call(local_chan, dest, 0)) {
-		ast_hangup(local_chan);
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-
-	if (ast_bridge_impart(bridge1, local_chan, chan1, NULL, 1)) {
-		ast_hangup(local_chan);
-		return AST_BRIDGE_TRANSFER_FAIL;
-	}
-
-	if (bridge2) {
-		RAII_VAR(struct ast_channel *, local_chan2, NULL, ao2_cleanup);
-
-		ast_channel_lock(local_chan);
-		local_chan2 = ast_local_get_peer(local_chan);
-		ast_channel_unlock(local_chan);
-
-		ast_assert(local_chan2 != NULL);
-
-		publish_attended_transfer_link(publication,
-				local_chan, local_chan2);
-	} else {
-		publish_attended_transfer_app(publication, app);
-	}
-	return AST_BRIDGE_TRANSFER_SUCCESS;
-}
-
-/*!
- * \internal
- * \brief Get the transferee channel
- *
- * This is only applicable to cases where a transfer is occurring on a
- * two-party bridge. The channels container passed in is expected to only
- * contain two channels, the transferer and the transferee. The transferer
- * channel is passed in as a parameter to ensure we don't return it as
- * the transferee channel.
- *
- * \param channels A two-channel container containing the transferer and transferee
- * \param transferer The party that is transfering the call
- * \return The party that is being transferred
- */
-static struct ast_channel *get_transferee(struct ao2_container *channels, struct ast_channel *transferer)
-{
-	struct ao2_iterator channel_iter;
-	struct ast_channel *transferee;
-
-	for (channel_iter = ao2_iterator_init(channels, 0);
-			(transferee = ao2_iterator_next(&channel_iter));
-			ao2_cleanup(transferee)) {
-		if (transferee != transferer) {
-			break;
-		}
-	}
-
-	ao2_iterator_destroy(&channel_iter);
-	return transferee;
-}
-
-enum try_parking_result {
-	PARKING_SUCCESS,
-	PARKING_FAILURE,
-	PARKING_NOT_APPLICABLE,
-};
-
-static enum try_parking_result try_parking(struct ast_bridge *bridge, struct ast_channel *transferer,
-		const char *exten, const char *context)
-{
-	RAII_VAR(struct ast_bridge_channel *, transferer_bridge_channel, NULL, ao2_cleanup);
-	struct ast_exten *parking_exten;
-
-	ast_channel_lock(transferer);
-	transferer_bridge_channel = ast_channel_get_bridge_channel(transferer);
-	ast_channel_unlock(transferer);
-
-	if (!transferer_bridge_channel) {
-		return PARKING_FAILURE;
-	}
-
-	parking_exten = ast_get_parking_exten(exten, NULL, context);
-	if (parking_exten) {
-		return ast_park_blind_xfer(bridge, transferer_bridge_channel, parking_exten) == 0 ?
-			PARKING_SUCCESS : PARKING_FAILURE;
-	}
-
-	return PARKING_NOT_APPLICABLE;
-}
-
-/*!
- * \internal
- * \brief Set the BLINDTRANSFER variable as appropriate on channels involved in the transfer
- *
- * The transferer channel will have its BLINDTRANSFER variable set the same as its BRIDGEPEER
- * variable. This will account for all channels that it is bridged to. The other channels
- * involved in the transfer will have their BLINDTRANSFER variable set to the transferer
- * channel's name.
- *
- * \param transferer The channel performing the blind transfer
- * \param channels The channels belonging to the bridge
- */
-static void set_blind_transfer_variables(struct ast_channel *transferer, struct ao2_container *channels)
-{
-	struct ao2_iterator iter;
-	struct ast_channel *chan;
-	const char *transferer_name;
-	const char *transferer_bridgepeer;
-
-	ast_channel_lock(transferer);
-	transferer_name = ast_strdupa(ast_channel_name(transferer));
-	transferer_bridgepeer = ast_strdupa(S_OR(pbx_builtin_getvar_helper(transferer, "BRIDGEPEER"), ""));
-	ast_channel_unlock(transferer);
-
-	for (iter = ao2_iterator_init(channels, 0);
-			(chan = ao2_iterator_next(&iter));
-			ao2_cleanup(chan)) {
-		if (chan == transferer) {
-			pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", transferer_bridgepeer);
-		} else {
-			pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", transferer_name);
-		}
-	}
-
-	ao2_iterator_destroy(&iter);
-}
-
-static struct ast_bridge *acquire_bridge(struct ast_channel *chan)
-{
-	struct ast_bridge *bridge;
-
-	ast_channel_lock(chan);
-	bridge = ast_channel_get_bridge(chan);
-	ast_channel_unlock(chan);
-
-	if (bridge
-		&& ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
-		ao2_ref(bridge, -1);
-		bridge = NULL;
-	}
-
-	return bridge;
-}
-
-static void publish_blind_transfer(int is_external, enum ast_transfer_result result,
-		struct ast_channel *transferer, struct ast_bridge *bridge,
-		const char *context, const char *exten)
-{
-	struct ast_bridge_channel_pair pair;
-	pair.channel = transferer;
-	pair.bridge = bridge;
-	ast_bridge_publish_blind_transfer(is_external, result, &pair, context, exten);
-}
-
-enum ast_transfer_result ast_bridge_transfer_blind(int is_external,
-		struct ast_channel *transferer, const char *exten, const char *context,
-		transfer_channel_cb new_channel_cb, void *user_data)
-{
-	RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_bridge_channel *, bridge_channel, NULL, ao2_cleanup);
-	RAII_VAR(struct ao2_container *, channels, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_channel *, transferee, NULL, ao2_cleanup);
-	int do_bridge_transfer;
-	int transfer_prohibited;
-	enum try_parking_result parking_result;
-	enum ast_transfer_result transfer_result;
-
-	bridge = acquire_bridge(transferer);
-	if (!bridge) {
-		transfer_result = AST_BRIDGE_TRANSFER_INVALID;
-		goto publish;
-	}
-	ast_channel_lock(transferer);
-	bridge_channel = ast_channel_get_bridge_channel(transferer);
-	ast_channel_unlock(transferer);
-	if (!bridge_channel) {
-		transfer_result = AST_BRIDGE_TRANSFER_INVALID;
-		goto publish;
-	}
-
-	/* Take off hold if they are on hold. */
-	ast_bridge_channel_write_unhold(bridge_channel);
-
-	parking_result = try_parking(bridge, transferer, exten, context);
-	switch (parking_result) {
-	case PARKING_SUCCESS:
-		transfer_result = AST_BRIDGE_TRANSFER_SUCCESS;
-		goto publish;
-	case PARKING_FAILURE:
-		transfer_result = AST_BRIDGE_TRANSFER_FAIL;
-		goto publish;
-	case PARKING_NOT_APPLICABLE:
-	default:
-		break;
-	}
-
-	{
-		SCOPED_LOCK(lock, bridge, ast_bridge_lock, ast_bridge_unlock);
-
-		channels = ast_bridge_peers_nolock(bridge);
-		if (!channels) {
-			transfer_result = AST_BRIDGE_TRANSFER_FAIL;
-			goto publish;
-		}
-		if (ao2_container_count(channels) <= 1) {
-			transfer_result = AST_BRIDGE_TRANSFER_INVALID;
-			goto publish;
-		}
-		transfer_prohibited = ast_test_flag(&bridge->feature_flags,
-				AST_BRIDGE_FLAG_TRANSFER_PROHIBITED);
-		do_bridge_transfer = ast_test_flag(&bridge->feature_flags,
-				AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) ||
-				ao2_container_count(channels) > 2;
-	}
-
-	if (transfer_prohibited) {
-		transfer_result = AST_BRIDGE_TRANSFER_NOT_PERMITTED;
-		goto publish;
-	}
-
-	set_blind_transfer_variables(transferer, channels);
-
-	if (do_bridge_transfer) {
-		transfer_result = blind_transfer_bridge(transferer, bridge, exten, context,
-				new_channel_cb, user_data);
-		goto publish;
-	}
-
-	/* Reaching this portion means that we're dealing with a two-party bridge */
-
-	transferee = get_transferee(channels, transferer);
-	if (!transferee) {
-		transfer_result = AST_BRIDGE_TRANSFER_FAIL;
-		goto publish;
-	}
-
-	if (bridge_channel_internal_queue_blind_transfer(transferee, exten, context,
-				new_channel_cb, user_data)) {
-		transfer_result = AST_BRIDGE_TRANSFER_FAIL;
-		goto publish;
-	}
-
-	ast_bridge_remove(bridge, transferer);
-	transfer_result = AST_BRIDGE_TRANSFER_SUCCESS;
-
-publish:
-	publish_blind_transfer(is_external, transfer_result, transferer, bridge, context, exten);
-	return transfer_result;
-}
-
-/*!
- * \internal
- * \brief Performs an attended transfer by moving a channel from one bridge to another
- *
- * The channel that is bridged to the source_channel is moved into the dest_bridge from
- * the source_bridge_channel's bridge. The swap_channel is swapped out of the dest_bridge and placed in
- * the source_bridge_channel's bridge.
- *
- * \note dest_bridge and source_bridge_channel's bridge MUST be locked before calling this function.
- *
- * \param dest_bridge The final bridge for the attended transfer
- * \param source_channel Channel who is bridged to the channel that will move
- * \param swap_channel Channel to be swapped out of the dest_bridge
- * \return The success or failure of the swap attempt
- */
-static enum ast_transfer_result bridge_swap_attended_transfer(struct ast_bridge *dest_bridge,
-		struct ast_bridge_channel *source_bridge_channel, struct ast_channel *swap_channel)
-{
-	struct ast_bridge_channel *bridged_to_source;
-
-	bridged_to_source = ast_bridge_channel_peer(source_bridge_channel);
-	if (bridged_to_source
-		&& bridged_to_source->state == BRIDGE_CHANNEL_STATE_WAIT
-		&& !ast_test_flag(&bridged_to_source->features->feature_flags,
-			AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
-		bridged_to_source->swap = swap_channel;
-		if (bridge_do_move(dest_bridge, bridged_to_source, 1, 0)) {
-			return AST_BRIDGE_TRANSFER_FAIL;
-		}
-		/* Must kick the source channel out of its bridge. */
-		ast_bridge_channel_leave_bridge(source_bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE);
-		return AST_BRIDGE_TRANSFER_SUCCESS;
-	} else {
-		return AST_BRIDGE_TRANSFER_INVALID;
-	}
-}
-
-/*!
- * \internal
- * \brief Function that performs an attended transfer when both transferer channels are bridged
- *
- * The method by which the transfer is performed is dependent on whether the bridges allow for
- * optimization to occur between them. If no optimization is permitted, then an unreal channel
- * is placed as a link between the two bridges. If optimization is permitted, then that means
- * we are free to perform move or merge operations in order to perform the transfer.
- *
- * \note to_transferee_bridge and to_target_bridge MUST be locked before calling this function
- *
- * \param to_transferee The channel that is bridged to the transferee
- * \param to_transferee_bridge_channel to_transferee's bridge_channel
- * \param to_transfer_target The channel that is bridged to the transfer target
- * \param to_target_bridge_channel to_transfer_target's bridge_channel
- * \param to_transferee_bridge The bridge between to_transferee and the transferee
- * \param to_target_bridge The bridge between to_transfer_target and the transfer_target
- * \param publication Data to publish for a stasis attended transfer message
- * \return The success or failure of the attended transfer
- */
-static enum ast_transfer_result two_bridge_attended_transfer(struct ast_channel *to_transferee,
-		struct ast_bridge_channel *to_transferee_bridge_channel,
-		struct ast_channel *to_transfer_target,
-		struct ast_bridge_channel *to_target_bridge_channel,
-		struct ast_bridge *to_transferee_bridge, struct ast_bridge *to_target_bridge,
-		struct stasis_attended_transfer_publish_data *publication)
-{
-	struct ast_bridge_channel *kick_me[] = {
-			to_transferee_bridge_channel,
-			to_target_bridge_channel,
-	};
-	enum ast_transfer_result res;
-	struct ast_bridge *final_bridge = NULL;
-
-	switch (ast_bridges_allow_optimization(to_transferee_bridge, to_target_bridge)) {
-	case AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE:
-		final_bridge = to_transferee_bridge;
-		res = bridge_swap_attended_transfer(to_transferee_bridge, to_target_bridge_channel, to_transferee);
-		goto end;
-	case AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE:
-		final_bridge = to_target_bridge;
-		res = bridge_swap_attended_transfer(to_target_bridge, to_transferee_bridge_channel, to_transfer_target);
-		goto end;
-	case AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE:
-		final_bridge = to_transferee_bridge;
-		bridge_do_merge(to_transferee_bridge, to_target_bridge, kick_me, ARRAY_LEN(kick_me), 0);
-		res = AST_BRIDGE_TRANSFER_SUCCESS;
-		goto end;
-	case AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE:
-		final_bridge = to_target_bridge;
-		bridge_do_merge(to_target_bridge, to_transferee_bridge, kick_me, ARRAY_LEN(kick_me), 0);
-		res = AST_BRIDGE_TRANSFER_SUCCESS;
-		goto end;
-	case AST_BRIDGE_OPTIMIZE_PROHIBITED:
-	default:
-		/* Just because optimization wasn't doable doesn't necessarily mean
-		 * that we can actually perform the transfer. Some reasons for non-optimization
-		 * indicate bridge invalidity, so let's check those before proceeding.
-		 */
-		if (to_transferee_bridge->inhibit_merge || to_transferee_bridge->dissolved ||
-				to_target_bridge->inhibit_merge || to_target_bridge->dissolved) {
-			res = AST_BRIDGE_TRANSFER_INVALID;
-			goto end;
-		}
-
-		/* Don't goto end here. attended_transfer_bridge will publish its own
-		 * stasis message if it succeeds
-		 */
-		return attended_transfer_bridge(to_transferee, to_transfer_target,
-			to_transferee_bridge, to_target_bridge, publication);
-	}
-
-end:
-	if (res == AST_BRIDGE_TRANSFER_SUCCESS) {
-		publish_attended_transfer_bridge_merge(publication, final_bridge);
-	}
-
-	return res;
-}
-
-enum ast_transfer_result ast_bridge_transfer_attended(struct ast_channel *to_transferee,
-		struct ast_channel *to_transfer_target)
-{
-	RAII_VAR(struct ast_bridge *, to_transferee_bridge, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_bridge *, to_target_bridge, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_bridge_channel *, to_transferee_bridge_channel, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_bridge_channel *, to_target_bridge_channel, NULL, ao2_cleanup);
-	RAII_VAR(struct ao2_container *, channels, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_channel *, transferee, NULL, ao2_cleanup);
-	struct ast_bridge *the_bridge;
-	struct ast_channel *chan_bridged;
-	struct ast_channel *chan_unbridged;
-	int transfer_prohibited;
-	int do_bridge_transfer;
-	enum ast_transfer_result res;
-	const char *app = NULL;
-	struct stasis_attended_transfer_publish_data publication;
-
-	to_transferee_bridge = acquire_bridge(to_transferee);
-	to_target_bridge = acquire_bridge(to_transfer_target);
-
-	stasis_publish_data_init(to_transferee, to_transferee_bridge,
-			to_transfer_target, to_target_bridge, &publication);
-
-	/* They can't both be unbridged, you silly goose! */
-	if (!to_transferee_bridge && !to_target_bridge) {
-		res = AST_BRIDGE_TRANSFER_INVALID;
-		goto end;
-	}
-
-	ast_channel_lock(to_transferee);
-	to_transferee_bridge_channel = ast_channel_get_bridge_channel(to_transferee);
-	ast_channel_unlock(to_transferee);
-
-	ast_channel_lock(to_transfer_target);
-	to_target_bridge_channel = ast_channel_get_bridge_channel(to_transfer_target);
-	ast_channel_unlock(to_transfer_target);
-
-	if (to_transferee_bridge_channel) {
-		/* Take off hold if they are on hold. */
-		ast_bridge_channel_write_unhold(to_transferee_bridge_channel);
-	}
-
-	if (to_target_bridge_channel) {
-		const char *target_complete_sound;
-
-		/* Take off hold if they are on hold. */
-		ast_bridge_channel_write_unhold(to_target_bridge_channel);
-
-		/* Is there a courtesy sound to play to the target? */
-		ast_channel_lock(to_transfer_target);
-		target_complete_sound = pbx_builtin_getvar_helper(to_transfer_target,
-			"ATTENDED_TRANSFER_COMPLETE_SOUND");
-		if (!ast_strlen_zero(target_complete_sound)) {
-			target_complete_sound = ast_strdupa(target_complete_sound);
-		} else {
-			target_complete_sound = NULL;
-		}
-		ast_channel_unlock(to_transfer_target);
-		if (!target_complete_sound) {
-			ast_channel_lock(to_transferee);
-			target_complete_sound = pbx_builtin_getvar_helper(to_transferee,
-				"ATTENDED_TRANSFER_COMPLETE_SOUND");
-			if (!ast_strlen_zero(target_complete_sound)) {
-				target_complete_sound = ast_strdupa(target_complete_sound);
-			} else {
-				target_complete_sound = NULL;
-			}
-			ast_channel_unlock(to_transferee);
-		}
-		if (target_complete_sound) {
-			ast_bridge_channel_write_playfile(to_target_bridge_channel, NULL,
-				target_complete_sound, NULL);
-		}
-	}
-
-	/* Let's get the easy one out of the way first */
-	if (to_transferee_bridge && to_target_bridge) {
-
-		if (!to_transferee_bridge_channel || !to_target_bridge_channel) {
-			res = AST_BRIDGE_TRANSFER_INVALID;
-			goto end;
-		}
-
-		ast_bridge_lock_both(to_transferee_bridge, to_target_bridge);
-		res = two_bridge_attended_transfer(to_transferee, to_transferee_bridge_channel,
-				to_transfer_target, to_target_bridge_channel,
-				to_transferee_bridge, to_target_bridge, &publication);
-		ast_bridge_unlock(to_transferee_bridge);
-		ast_bridge_unlock(to_target_bridge);
-
-		goto end;
-	}
-
-	the_bridge = to_transferee_bridge ?: to_target_bridge;
-	chan_bridged = to_transferee_bridge ? to_transferee : to_transfer_target;
-	chan_unbridged = to_transferee_bridge ? to_transfer_target : to_transferee;
-
-	{
-		int chan_count;
-		SCOPED_LOCK(lock, the_bridge, ast_bridge_lock, ast_bridge_unlock);
-
-		channels = ast_bridge_peers_nolock(the_bridge);
-		if (!channels) {
-			res = AST_BRIDGE_TRANSFER_FAIL;
-			goto end;
-		}
-		chan_count = ao2_container_count(channels);
-		if (chan_count <= 1) {
-			res = AST_BRIDGE_TRANSFER_INVALID;
-			goto end;
-		}
-		transfer_prohibited = ast_test_flag(&the_bridge->feature_flags,
-				AST_BRIDGE_FLAG_TRANSFER_PROHIBITED);
-		do_bridge_transfer = ast_test_flag(&the_bridge->feature_flags,
-				AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) ||
-				chan_count > 2;
-	}
-
-	if (transfer_prohibited) {
-		res = AST_BRIDGE_TRANSFER_NOT_PERMITTED;
-		goto end;
-	}
-
-	if (do_bridge_transfer) {
-		 res = attended_transfer_bridge(chan_bridged, chan_unbridged, the_bridge, NULL, &publication);
-		 goto end;
-	}
-
-	transferee = get_transferee(channels, chan_bridged);
-	if (!transferee) {
-		res = AST_BRIDGE_TRANSFER_FAIL;
-		goto end;
-	}
-
-	app = ast_strdupa(ast_channel_appl(chan_unbridged));
-	if (bridge_channel_internal_queue_attended_transfer(transferee, chan_unbridged)) {
-		res = AST_BRIDGE_TRANSFER_FAIL;
-		goto end;
-	}
-
-	ast_bridge_remove(the_bridge, chan_bridged);
-
-	publish_attended_transfer_app(&publication, app);
-	return AST_BRIDGE_TRANSFER_SUCCESS;
-
-end:
-	/* All successful transfer paths have published an appropriate stasis message.
-	 * All failure paths have deferred publishing a stasis message until this point
-	 */
-	if (res != AST_BRIDGE_TRANSFER_SUCCESS) {
-		publish_attended_transfer_fail(&publication, res);
-	}
-	stasis_publish_data_cleanup(&publication);
-	return res;
-}
-
-/*!
- * \internal
- * \brief Service the bridge manager request.
- * \since 12.0.0
- *
- * \param bridge requesting service.
- *
- * \return Nothing
- */
-static void bridge_manager_service(struct ast_bridge *bridge)
-{
-	ast_bridge_lock(bridge);
-	if (bridge->callid) {
-		ast_callid_threadassoc_change(bridge->callid);
-	}
-
-	/* Do any pending bridge actions. */
-	bridge_handle_actions(bridge);
-	ast_bridge_unlock(bridge);
-}
-
-/*!
- * \internal
- * \brief Bridge manager service thread.
- * \since 12.0.0
- *
- * \return Nothing
- */
-static void *bridge_manager_thread(void *data)
-{
-	struct bridge_manager_controller *manager = data;
-	struct bridge_manager_request *request;
-
-	ao2_lock(manager);
-	while (!manager->stop) {
-		request = AST_LIST_REMOVE_HEAD(&manager->service_requests, node);
-		if (!request) {
-			ast_cond_wait(&manager->cond, ao2_object_get_lockaddr(manager));
-			continue;
-		}
-		ao2_unlock(manager);
-
-		/* Service the bridge. */
-		bridge_manager_service(request->bridge);
-		ao2_ref(request->bridge, -1);
-		ast_free(request);
-
-		ao2_lock(manager);
-	}
-	ao2_unlock(manager);
-
-	return NULL;
-}
-
-/*!
- * \internal
- * \brief Destroy the bridge manager controller.
- * \since 12.0.0
- *
- * \param obj Bridge manager to destroy.
- *
- * \return Nothing
- */
-static void bridge_manager_destroy(void *obj)
-{
-	struct bridge_manager_controller *manager = obj;
-	struct bridge_manager_request *request;
-
-	if (manager->thread != AST_PTHREADT_NULL) {
-		/* Stop the manager thread. */
-		ao2_lock(manager);
-		manager->stop = 1;
-		ast_cond_signal(&manager->cond);
-		ao2_unlock(manager);
-		ast_debug(1, "Waiting for bridge manager thread to die.\n");
-		pthread_join(manager->thread, NULL);
-	}
-
-	/* Destroy the service request queue. */
-	while ((request = AST_LIST_REMOVE_HEAD(&manager->service_requests, node))) {
-		ao2_ref(request->bridge, -1);
-		ast_free(request);
-	}
-
-	ast_cond_destroy(&manager->cond);
-}
-
-/*!
- * \internal
- * \brief Create the bridge manager controller.
- * \since 12.0.0
- *
- * \retval manager on success.
- * \retval NULL on error.
- */
-static struct bridge_manager_controller *bridge_manager_create(void)
-{
-	struct bridge_manager_controller *manager;
-
-	manager = ao2_alloc(sizeof(*manager), bridge_manager_destroy);
-	if (!manager) {
-		/* Well. This isn't good. */
-		return NULL;
-	}
-	ast_cond_init(&manager->cond, NULL);
-	AST_LIST_HEAD_INIT_NOLOCK(&manager->service_requests);
-
-	/* Create the bridge manager thread. */
-	if (ast_pthread_create(&manager->thread, NULL, bridge_manager_thread, manager)) {
-		/* Well. This isn't good either. */
-		manager->thread = AST_PTHREADT_NULL;
-		ao2_ref(manager, -1);
-		manager = NULL;
-	}
-
-	return manager;
-}
-
-/*!
- * \internal
- * \brief Bridge ao2 container sort function.
- * \since 12.0.0
- *
- * \param obj_left pointer to the (user-defined part) of an object.
- * \param obj_right pointer to the (user-defined part) of an object.
- * \param flags flags from ao2_callback()
- *   OBJ_POINTER - if set, 'obj_right', is an object.
- *   OBJ_KEY - if set, 'obj_right', is a search key item that is not an object.
- *   OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object.
- *
- * \retval <0 if obj_left < obj_right
- * \retval =0 if obj_left == obj_right
- * \retval >0 if obj_left > obj_right
- */
-static int bridge_sort_cmp(const void *obj_left, const void *obj_right, int flags)
-{
-	const struct ast_bridge *bridge_left = obj_left;
-	const struct ast_bridge *bridge_right = obj_right;
-	const char *right_key = obj_right;
-	int cmp;
-
-	switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
-	default:
-	case OBJ_POINTER:
-		right_key = bridge_right->uniqueid;
-		/* Fall through */
-	case OBJ_KEY:
-		cmp = strcmp(bridge_left->uniqueid, right_key);
-		break;
-	case OBJ_PARTIAL_KEY:
-		cmp = strncmp(bridge_left->uniqueid, right_key, strlen(right_key));
-		break;
-	}
-	return cmp;
-}
-
-static char *complete_bridge(const char *word, int state)
-{
-	char *ret = NULL;
-	int wordlen = strlen(word), which = 0;
-	RAII_VAR(struct ao2_container *, cached_bridges, NULL, ao2_cleanup);
-	struct ao2_iterator iter;
-	struct stasis_message *msg;
-
-	if (!(cached_bridges = stasis_cache_dump(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type()))) {
-		return NULL;
-	}
-
-	iter = ao2_iterator_init(cached_bridges, 0);
-	for (; (msg = ao2_iterator_next(&iter)); ao2_ref(msg, -1)) {
-		struct ast_bridge_snapshot *snapshot = stasis_message_data(msg);
-
-		if (!strncasecmp(word, snapshot->uniqueid, wordlen) && (++which > state)) {
-			ret = ast_strdup(snapshot->uniqueid);
-			break;
-		}
-	}
-	ao2_iterator_destroy(&iter);
-
-	return ret;
-}
-
-static char *handle_bridge_show_all(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-#define FORMAT_HDR "%-36s %5s %-15s %s\n"
-#define FORMAT_ROW "%-36s %5u %-15s %s\n"
-
-	RAII_VAR(struct ao2_container *, cached_bridges, NULL, ao2_cleanup);
-	struct ao2_iterator iter;
-	struct stasis_message *msg;
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge show all";
-		e->usage =
-			"Usage: bridge show all\n"
-			"       List all bridges\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	if (!(cached_bridges = stasis_cache_dump(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type()))) {
-		ast_cli(a->fd, "Failed to retrieve cached bridges\n");
-		return CLI_SUCCESS;
-	}
-
-	ast_cli(a->fd, FORMAT_HDR, "Bridge-ID", "Chans", "Type", "Technology");
-
-	iter = ao2_iterator_init(cached_bridges, 0);
-	for (; (msg = ao2_iterator_next(&iter)); ao2_ref(msg, -1)) {
-		struct ast_bridge_snapshot *snapshot = stasis_message_data(msg);
-
-		ast_cli(a->fd, FORMAT_ROW,
-			snapshot->uniqueid,
-			snapshot->num_channels,
-			S_OR(snapshot->subclass, "<unknown>"),
-			S_OR(snapshot->technology, "<unknown>"));
-	}
-	ao2_iterator_destroy(&iter);
-	return CLI_SUCCESS;
-
-#undef FORMAT_HDR
-#undef FORMAT_ROW
-}
-
-/*! \brief Internal callback function for sending channels in a bridge to the CLI */
-static int bridge_show_specific_print_channel(void *obj, void *arg, int flags)
-{
-	const char *uniqueid = obj;
-	struct ast_cli_args *a = arg;
-	RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
-	struct ast_channel_snapshot *snapshot;
-
-	if (!(msg = stasis_cache_get(ast_channel_topic_all_cached(), ast_channel_snapshot_type(), uniqueid))) {
-		return 0;
-	}
-	snapshot = stasis_message_data(msg);
-
-	ast_cli(a->fd, "Channel: %s\n", snapshot->name);
-
-	return 0;
-}
-
-static char *handle_bridge_show_specific(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
-	struct ast_bridge_snapshot *snapshot;
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge show";
-		e->usage =
-			"Usage: bridge show <bridge-id>\n"
-			"       Show information about the <bridge-id> bridge\n";
-		return NULL;
-	case CLI_GENERATE:
-		if (a->pos == 2) {
-			return complete_bridge(a->word, a->n);
-		}
-		return NULL;
-	}
-
-	if (a->argc != 3) {
-		return CLI_SHOWUSAGE;
-	}
-
-	msg = stasis_cache_get(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type(), a->argv[2]);
-	if (!msg) {
-		ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]);
-		return CLI_SUCCESS;
-	}
-
-	snapshot = stasis_message_data(msg);
-	ast_cli(a->fd, "Id: %s\n", snapshot->uniqueid);
-	ast_cli(a->fd, "Type: %s\n", S_OR(snapshot->subclass, "<unknown>"));
-	ast_cli(a->fd, "Technology: %s\n", S_OR(snapshot->technology, "<unknown>"));
-	ast_cli(a->fd, "Num-Channels: %u\n", snapshot->num_channels);
-	ao2_callback(snapshot->channels, OBJ_NODATA, bridge_show_specific_print_channel, a);
-
-	return CLI_SUCCESS;
-}
-
-static char *handle_bridge_destroy_specific(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	struct ast_bridge *bridge;
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge destroy";
-		e->usage =
-			"Usage: bridge destroy <bridge-id>\n"
-			"       Destroy the <bridge-id> bridge\n";
-		return NULL;
-	case CLI_GENERATE:
-		if (a->pos == 2) {
-			return complete_bridge(a->word, a->n);
-		}
-		return NULL;
-	}
-
-	if (a->argc != 3) {
-		return CLI_SHOWUSAGE;
-	}
-
-	bridge = ao2_find(bridges, a->argv[2], OBJ_KEY);
-	if (!bridge) {
-		ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]);
-		return CLI_SUCCESS;
-	}
-
-	ast_cli(a->fd, "Destroying bridge '%s'\n", a->argv[2]);
-	ast_bridge_destroy(bridge);
-
-	return CLI_SUCCESS;
-}
-
-static char *complete_bridge_participant(const char *bridge_name, const char *line, const char *word, int pos, int state)
-{
-	RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup);
-	struct ast_bridge_channel *bridge_channel;
-	int which;
-	int wordlen;
-
-	bridge = ao2_find(bridges, bridge_name, OBJ_KEY);
-	if (!bridge) {
-		return NULL;
-	}
-
-	{
-		SCOPED_LOCK(bridge_lock, bridge, ast_bridge_lock, ast_bridge_unlock);
-
-		which = 0;
-		wordlen = strlen(word);
-		AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
-			if (!strncasecmp(ast_channel_name(bridge_channel->chan), word, wordlen)
-				&& ++which > state) {
-				return ast_strdup(ast_channel_name(bridge_channel->chan));
-			}
-		}
-	}
-
-	return NULL;
-}
-
-static char *handle_bridge_kick_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup);
-	RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge kick";
-		e->usage =
-			"Usage: bridge kick <bridge-id> <channel-name>\n"
-			"       Kick the <channel-name> channel out of the <bridge-id> bridge\n";
-		return NULL;
-	case CLI_GENERATE:
-		if (a->pos == 2) {
-			return complete_bridge(a->word, a->n);
-		}
-		if (a->pos == 3) {
-			return complete_bridge_participant(a->argv[2], a->line, a->word, a->pos, a->n);
-		}
-		return NULL;
-	}
-
-	if (a->argc != 4) {
-		return CLI_SHOWUSAGE;
-	}
-
-	bridge = ao2_find(bridges, a->argv[2], OBJ_KEY);
-	if (!bridge) {
-		ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]);
-		return CLI_SUCCESS;
-	}
-
-	chan = ast_channel_get_by_name_prefix(a->argv[3], strlen(a->argv[3]));
-	if (!chan) {
-		ast_cli(a->fd, "Channel '%s' not found\n", a->argv[3]);
-		return CLI_SUCCESS;
-	}
-
-/*
- * BUGBUG the CLI kick needs to get the bridge to decide if it should dissolve.
- *
- * Likely the best way to do this is to add a kick method.  The
- * basic bridge class can then decide to dissolve the bridge if
- * one of two channels is kicked.
- *
- * SIP/foo -- Local;1==Local;2 -- .... -- Local;1==Local;2 -- SIP/bar
- * Kick a ;1 channel and the chain toward SIP/foo goes away.
- * Kick a ;2 channel and the chain toward SIP/bar goes away.
- *
- * This can leave a local channel chain between the kicked ;1
- * and ;2 channels that are orphaned until you manually request
- * one of those channels to hangup or request the bridge to
- * dissolve.
- */
-	ast_cli(a->fd, "Kicking channel '%s' from bridge '%s'\n",
-		ast_channel_name(chan), a->argv[2]);
-	ast_bridge_remove(bridge, chan);
-
-	return CLI_SUCCESS;
-}
-
-/*! Bridge technology capabilities to string. */
-static const char *tech_capability2str(uint32_t capabilities)
-{
-	const char *type;
-
-	if (capabilities & AST_BRIDGE_CAPABILITY_HOLDING) {
-		type = "Holding";
-	} else if (capabilities & AST_BRIDGE_CAPABILITY_EARLY) {
-		type = "Early";
-	} else if (capabilities & AST_BRIDGE_CAPABILITY_NATIVE) {
-		type = "Native";
-	} else if (capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) {
-		type = "1to1Mix";
-	} else if (capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
-		type = "MultiMix";
-	} else {
-		type = "<Unknown>";
-	}
-	return type;
-}
-
-static char *handle_bridge_technology_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-#define FORMAT_HDR "%-20s %-20s %8s %s\n"
-#define FORMAT_ROW "%-20s %-20s %8d %s\n"
-
-	struct ast_bridge_technology *cur;
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge technology show";
-		e->usage =
-			"Usage: bridge technology show\n"
-			"       List registered bridge technologies\n";
-		return NULL;
-	case CLI_GENERATE:
-		return NULL;
-	}
-
-	ast_cli(a->fd, FORMAT_HDR, "Name", "Type", "Priority", "Suspended");
-	AST_RWLIST_RDLOCK(&bridge_technologies);
-	AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
-		const char *type;
-
-		/* Decode type for display */
-		type = tech_capability2str(cur->capabilities);
-
-		ast_cli(a->fd, FORMAT_ROW, cur->name, type, cur->preference,
-			AST_CLI_YESNO(cur->suspended));
-	}
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-	return CLI_SUCCESS;
-
-#undef FORMAT
-}
-
-static char *complete_bridge_technology(const char *word, int state)
-{
-	struct ast_bridge_technology *cur;
-	char *res;
-	int which;
-	int wordlen;
-
-	which = 0;
-	wordlen = strlen(word);
-	AST_RWLIST_RDLOCK(&bridge_technologies);
-	AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
-		if (!strncasecmp(cur->name, word, wordlen) && ++which > state) {
-			res = ast_strdup(cur->name);
-			AST_RWLIST_UNLOCK(&bridge_technologies);
-			return res;
-		}
-	}
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-	return NULL;
-}
-
-static char *handle_bridge_technology_suspend(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
-{
-	struct ast_bridge_technology *cur;
-	int suspend;
-	int successful;
-
-	switch (cmd) {
-	case CLI_INIT:
-		e->command = "bridge technology {suspend|unsuspend}";
-		e->usage =
-			"Usage: bridge technology {suspend|unsuspend} <technology-name>\n"
-			"       Suspend or unsuspend a bridge technology.\n";
-		return NULL;
-	case CLI_GENERATE:
-		if (a->pos == 3) {
-			return complete_bridge_technology(a->word, a->n);
-		}
-		return NULL;
-	}
-
-	if (a->argc != 4) {
-		return CLI_SHOWUSAGE;
-	}
-
-	suspend = !strcasecmp(a->argv[2], "suspend");
-	successful = 0;
-	AST_RWLIST_WRLOCK(&bridge_technologies);
-	AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
-		if (!strcasecmp(cur->name, a->argv[3])) {
-			successful = 1;
-			if (suspend) {
-				ast_bridge_technology_suspend(cur);
-			} else {
-				ast_bridge_technology_unsuspend(cur);
-			}
-			break;
-		}
-	}
-	AST_RWLIST_UNLOCK(&bridge_technologies);
-
-	if (successful) {
-		if (suspend) {
-			ast_cli(a->fd, "Suspended bridge technology '%s'\n", a->argv[3]);
-		} else {
-			ast_cli(a->fd, "Unsuspended bridge technology '%s'\n", a->argv[3]);
-		}
-	} else {
-		ast_cli(a->fd, "Bridge technology '%s' not found\n", a->argv[3]);
-	}
-
-	return CLI_SUCCESS;
-}
-
-static struct ast_cli_entry bridge_cli[] = {
-	AST_CLI_DEFINE(handle_bridge_show_all, "List all bridges"),
-	AST_CLI_DEFINE(handle_bridge_show_specific, "Show information about a bridge"),
-	AST_CLI_DEFINE(handle_bridge_destroy_specific, "Destroy a bridge"),
-	AST_CLI_DEFINE(handle_bridge_kick_channel, "Kick a channel from a bridge"),
-	AST_CLI_DEFINE(handle_bridge_technology_show, "List registered bridge technologies"),
-	AST_CLI_DEFINE(handle_bridge_technology_suspend, "Suspend/unsuspend a bridge technology"),
-};
-
-/*!
- * \internal
- * \brief Shutdown the bridging system.
- * \since 12.0.0
- *
- * \return Nothing
- */
-static void bridge_shutdown(void)
-{
-	ast_cli_unregister_multiple(bridge_cli, ARRAY_LEN(bridge_cli));
-	ao2_cleanup(bridges);
-	bridges = NULL;
-	ao2_cleanup(bridge_manager);
-	bridge_manager = NULL;
-}
-
-int ast_bridging_init(void)
-{
-	ast_register_atexit(bridge_shutdown);
-
-	if (ast_stasis_bridging_init()) {
-		return -1;
-	}
-
-	bridge_manager = bridge_manager_create();
-	if (!bridge_manager) {
-		return -1;
-	}
-
-	bridges = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX,
-		AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_sort_cmp, NULL);
-	if (!bridges) {
-		return -1;
-	}
-
-	ast_bridging_init_basic();
-
-/* BUGBUG need AMI action equivalents to the CLI commands. */
-	ast_cli_register_multiple(bridge_cli, ARRAY_LEN(bridge_cli));
-
-	return 0;
-}