bridge_simple.c File Reference

Simple two channel bridging module. More...

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_technology.h"
#include "asterisk/frame.h"
#include "asterisk/stream.h"

Include dependency graph for bridge_simple.c:

Go to the source code of this file.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static int	simple_bridge_join (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static struct ast_stream_topology *	simple_bridge_request_stream_topology_update (struct ast_stream_topology *existing_topology, struct ast_stream_topology *requested_topology)
static void	simple_bridge_stream_topology_changed (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static int	simple_bridge_write (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Simple two channel bridging module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_bridge_technology	simple_bridge

Detailed Description

Simple two channel bridging module.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file bridge_simple.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 292 of file bridge_simple.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 292 of file bridge_simple.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 292 of file bridge_simple.c.

load_module()

static int load_module ( void  )

static

Definition at line 283 of file bridge_simple.c.

{
    if (ast_bridge_technology_register(&simple_bridge)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_bridge_technology_register, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, simple_bridge, and unload_module().

simple_bridge_join()

static int simple_bridge_join ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 124 of file bridge_simple.c.

{
    struct ast_stream_topology *req_top;
    struct ast_stream_topology *existing_top;
    struct ast_stream_topology *new_top;
    struct ast_channel *c0 = AST_LIST_FIRST(&bridge->channels)->chan;
    struct ast_channel *c1 = AST_LIST_LAST(&bridge->channels)->chan;
    int unhold_c0, unhold_c1;
 
    /*
     * If this is the first channel we can't make it compatible...
     * unless we make it compatible with itself.  O.o
     */
    if (c0 == c1) {
        return 0;
    }
 
    if (ast_channel_make_compatible(c0, c1)) {
        return -1;
    }
 
    /* When both channels are joined we want to try to improve the experience by
     * raising the number of streams so they match.
     */
    ast_channel_lock_both(c0, c1);
    req_top = ast_channel_get_stream_topology(c0);
    existing_top = ast_channel_get_stream_topology(c1);
    if (ast_stream_topology_get_count(req_top) < ast_stream_topology_get_count(existing_top)) {
        SWAP(req_top, existing_top);
        SWAP(c0, c1);
    }
    new_top = simple_bridge_request_stream_topology_update(existing_top, req_top);
 
    /* The ast_channel_hold_state() and ast_channel_name() accessors need to be
     * called with the associated channel lock held.
     */
    unhold_c1 = (ast_channel_hold_state(c1) == AST_CONTROL_HOLD);
    if (unhold_c1) {
        ast_debug(1, "Channel %s simulating UNHOLD for bridge simple join.\n", ast_channel_name(c1));
    }
 
    unhold_c0 = (ast_channel_hold_state(c0) == AST_CONTROL_HOLD);
    if (unhold_c0) {
        ast_debug(1, "Channel %s simulating UNHOLD for bridge simple join.\n", ast_channel_name(c0));
    }
 
    ast_channel_unlock(c0);
    ast_channel_unlock(c1);
 
    if (unhold_c1) {
        ast_indicate(c1, AST_CONTROL_UNHOLD);
    }
 
    if (unhold_c0) {
        ast_indicate(c0, AST_CONTROL_UNHOLD);
    }
 
    if (!new_top) {
        /* Failure.  We'll just have to live with the current topology. */
        return 0;
    }
 
    if (!ast_stream_topology_equal(new_top, existing_top)) {
        ast_channel_request_stream_topology_change(c1, new_top, &simple_bridge);
    } else {
        ast_debug(3, "%s: Topologies already match. Current: %s  Requested: %s\n",
                ast_channel_name(c1),
                ast_str_tmp(256, ast_stream_topology_to_str(existing_top, &STR_TMP)),
                ast_str_tmp(256, ast_stream_topology_to_str(new_top, &STR_TMP)));
    }
    ast_stream_topology_free(new_top);
 
    return 0;
}

References ast_channel_get_stream_topology(), ast_channel_hold_state(), ast_channel_lock_both, ast_channel_make_compatible(), ast_channel_name(), ast_channel_request_stream_topology_change(), ast_channel_unlock, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, ast_debug, ast_indicate(), AST_LIST_FIRST, AST_LIST_LAST, ast_str_tmp, ast_stream_topology_equal(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_to_str(), ast_channel::bridge, ast_bridge::channels, simple_bridge, simple_bridge_request_stream_topology_update(), and SWAP.

simple_bridge_request_stream_topology_update()

static struct ast_stream_topology * simple_bridge_request_stream_topology_update ( struct ast_stream_topology *  existing_topology, struct ast_stream_topology *  requested_topology  )

static

Definition at line 61 of file bridge_simple.c.

{
    struct ast_stream *stream;
    const struct ast_format_cap *audio_formats = NULL;
    struct ast_stream_topology *new_topology;
    int i;
 
    new_topology = ast_stream_topology_clone(requested_topology);
    if (!new_topology) {
        return NULL;
    }
 
    /* We find an existing stream with negotiated audio formats that we can place into
     * any audio streams in the new topology to ensure that negotiation succeeds. Some
     * endpoints incorrectly terminate the call if SDP negotiation fails.
     */
    for (i = 0; i < ast_stream_topology_get_count(existing_topology); ++i) {
        stream = ast_stream_topology_get_stream(existing_topology, i);
 
        if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO ||
            ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
            continue;
        }
 
        audio_formats = ast_stream_get_formats(stream);
        break;
    }
 
    if (audio_formats) {
        for (i = 0; i < ast_stream_topology_get_count(new_topology); ++i) {
            stream = ast_stream_topology_get_stream(new_topology, i);
 
            if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO ||
                ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
                continue;
            }
 
            /* We haven't actually modified audio_formats so this is safe */
            ast_stream_set_formats(stream, (struct ast_format_cap *)audio_formats);
        }
    }
 
    for (i = 0; i < ast_stream_topology_get_count(new_topology); ++i) {
        stream = ast_stream_topology_get_stream(new_topology, i);
 
        /* For both recvonly and sendonly the stream state reflects our state, that is we
         * are receiving only and we are sending only. Since we are renegotiating a remote
         * party we need to swap this to reflect what we will be doing. That is, if we are
         * receiving from Alice then we want to be sending to Bob, so swap recvonly to
         * sendonly.
         */
        if (ast_stream_get_state(stream) == AST_STREAM_STATE_RECVONLY) {
            ast_stream_set_state(stream, AST_STREAM_STATE_SENDONLY);
        } else if (ast_stream_get_state(stream) == AST_STREAM_STATE_SENDONLY) {
            ast_stream_set_state(stream, AST_STREAM_STATE_RECVONLY);
        }
    }
 
    return new_topology;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_get_formats(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_set_formats(), ast_stream_set_state(), AST_STREAM_STATE_RECVONLY, AST_STREAM_STATE_REMOVED, AST_STREAM_STATE_SENDONLY, ast_stream_topology_clone(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), and NULL.

Referenced by simple_bridge_join(), and simple_bridge_stream_topology_changed().

simple_bridge_stream_topology_changed()

static void simple_bridge_stream_topology_changed ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 234 of file bridge_simple.c.

{
    struct ast_channel *c0 = bridge_channel->chan;
    struct ast_channel *c1 = AST_LIST_FIRST(&bridge->channels)->chan;
    struct ast_stream_topology *req_top;
    struct ast_stream_topology *existing_top;
    struct ast_stream_topology *new_top;
 
    ast_bridge_channel_stream_map(bridge_channel);
 
    if (ast_channel_get_stream_topology_change_source(bridge_channel->chan)
        == &simple_bridge) {
        return;
    }
 
    if (c0 == c1) {
        c1 = AST_LIST_LAST(&bridge->channels)->chan;
    }
 
    if (c0 == c1) {
        return;
    }
 
    /* If a party renegotiates we want to renegotiate their counterpart to a matching
     * topology.
     */
    ast_channel_lock_both(c0, c1);
    req_top = ast_channel_get_stream_topology(c0);
    existing_top = ast_channel_get_stream_topology(c1);
    new_top = simple_bridge_request_stream_topology_update(existing_top, req_top);
    ast_channel_unlock(c0);
    ast_channel_unlock(c1);
 
    if (!new_top) {
        /* Failure.  We'll just have to live with the current topology. */
        return;
    }
 
    ast_channel_request_stream_topology_change(c1, new_top, &simple_bridge);
    ast_stream_topology_free(new_top);
}

References ast_bridge_channel_stream_map(), ast_channel_get_stream_topology(), ast_channel_get_stream_topology_change_source(), ast_channel_lock_both, ast_channel_request_stream_topology_change(), ast_channel_unlock, AST_LIST_FIRST, AST_LIST_LAST, ast_stream_topology_free(), ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, ast_bridge::channels, simple_bridge, and simple_bridge_request_stream_topology_update().

simple_bridge_write()

static int simple_bridge_write ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel, struct ast_frame *  frame  )

static

Definition at line 199 of file bridge_simple.c.

{
    const struct ast_control_t38_parameters *t38_parameters;
    int defer = 0;
 
    if (!ast_bridge_queue_everyone_else(bridge, bridge_channel, frame)) {
        /* This frame was successfully queued so no need to defer */
        return 0;
    }
 
    /* Depending on the frame defer it so when the next channel joins it receives it */
    switch (frame->frametype) {
    case AST_FRAME_CONTROL:
        switch (frame->subclass.integer) {
        case AST_CONTROL_T38_PARAMETERS:
            t38_parameters = frame->data.ptr;
            switch (t38_parameters->request_response) {
            case AST_T38_REQUEST_NEGOTIATE:
                defer = -1;
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
 
    return defer;
}

References ast_bridge_queue_everyone_else(), AST_CONTROL_T38_PARAMETERS, AST_FRAME_CONTROL, AST_T38_REQUEST_NEGOTIATE, ast_frame::data, ast_frame::frametype, ast_frame_subclass::integer, ast_frame::ptr, ast_control_t38_parameters::request_response, and ast_frame::subclass.

unload_module()

static int unload_module ( void  )

static

Definition at line 277 of file bridge_simple.c.

{
    ast_bridge_technology_unregister(&simple_bridge);
    return 0;
}

References ast_bridge_technology_unregister(), and simple_bridge.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Simple two channel bridging module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 292 of file bridge_simple.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 292 of file bridge_simple.c.

simple_bridge

struct ast_bridge_technology simple_bridge

static

Definition at line 52 of file bridge_simple.c.

                                                    {
    .name = "simple_bridge",
    .capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX,
    .preference = AST_BRIDGE_PREFERENCE_BASE_1TO1MIX,
    .join = simple_bridge_join,
    .write = simple_bridge_write,
    .stream_topology_changed = simple_bridge_stream_topology_changed,
};

Referenced by load_module(), simple_bridge_join(), simple_bridge_stream_topology_changed(), and unload_module().