bridge_native_rtp.c File Reference

Native RTP bridging technology 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/rtp_engine.h"
#include "asterisk/stream.h"

Include dependency graph for bridge_native_rtp.c:

Go to the source code of this file.

Data Structures
struct	native_rtp_bridge_channel_data
	Internal structure which contains instance information about bridged RTP channels. More...
struct	native_rtp_framehook_data
	Internal structure which contains bridged RTP channel hook data. More...
struct	rtp_glue_data
struct	rtp_glue_stream

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	native_rtp_bridge_capable (struct ast_channel *chan)
static struct native_rtp_bridge_channel_data *	native_rtp_bridge_channel_data_alloc (void)
static void	native_rtp_bridge_channel_data_free (struct native_rtp_bridge_channel_data *data)
static int	native_rtp_bridge_compatible (struct ast_bridge *bridge)
static int	native_rtp_bridge_compatible_check (struct ast_bridge *bridge, struct ast_bridge_channel *bc0, struct ast_bridge_channel *bc1)
static int	native_rtp_bridge_framehook_attach (struct ast_bridge_channel *bridge_channel)
static void	native_rtp_bridge_framehook_detach (struct ast_bridge_channel *bridge_channel)
static int	native_rtp_bridge_join (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
	Forward declarations.
static void	native_rtp_bridge_leave (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void	native_rtp_bridge_start (struct ast_bridge *bridge, struct ast_channel *target)
static void	native_rtp_bridge_stop (struct ast_bridge *bridge, struct ast_channel *target)
static void	native_rtp_bridge_suspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void	native_rtp_bridge_unsuspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static int	native_rtp_bridge_write (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static struct ast_frame *	native_rtp_framehook (struct ast_channel *chan, struct ast_frame *f, enum ast_framehook_event event, void *data)
static int	native_rtp_framehook_consume (void *data, enum ast_frame_type type)
static struct ast_stream_topology *	native_rtp_request_stream_topology_update (struct ast_stream_topology *existing_topology, struct ast_stream_topology *requested_topology)
static void	native_rtp_stream_topology_changed (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void	rtp_glue_data_destroy (struct rtp_glue_data *glue)
static int	rtp_glue_data_get (struct ast_channel *c0, struct rtp_glue_data *glue0, struct ast_channel *c1, struct rtp_glue_data *glue1)
static void	rtp_glue_data_init (struct rtp_glue_data *glue)
static void	rtp_glue_data_reset (struct rtp_glue_data *glue)
static enum ast_rtp_glue_result	rtp_glue_get_current_combined_result (struct ast_channel *c0, struct ast_channel *c1)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Native RTP 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	native_rtp_bridge

Detailed Description

Native RTP bridging technology module.

Author

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

Definition in file bridge_native_rtp.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1113 of file bridge_native_rtp.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1113 of file bridge_native_rtp.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1113 of file bridge_native_rtp.c.

load_module()

static int load_module ( void  )

static

Definition at line 1104 of file bridge_native_rtp.c.

{
    if (ast_bridge_technology_register(&native_rtp_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, native_rtp_bridge, and unload_module().

native_rtp_bridge_capable()

static int native_rtp_bridge_capable ( struct ast_channel *  chan )

static

Definition at line 622 of file bridge_native_rtp.c.

{
    return !ast_channel_has_hook_requiring_audio(chan)
            && ast_channel_state(chan) == AST_STATE_UP;
}

References ast_channel_has_hook_requiring_audio(), and AST_STATE_UP.

Referenced by native_rtp_bridge_compatible_check().

native_rtp_bridge_channel_data_alloc()

static struct native_rtp_bridge_channel_data * native_rtp_bridge_channel_data_alloc ( void  )

static

Definition at line 150 of file bridge_native_rtp.c.

{
    struct native_rtp_bridge_channel_data *data;
 
    data = ast_calloc(1, sizeof(*data));
    if (data) {
        rtp_glue_data_init(&data->glue);
    }
    return data;
}

References ast_calloc, native_rtp_bridge_channel_data::glue, and rtp_glue_data_init().

Referenced by native_rtp_bridge_join().

native_rtp_bridge_channel_data_free()

static void native_rtp_bridge_channel_data_free ( struct native_rtp_bridge_channel_data *  data )

static

Definition at line 136 of file bridge_native_rtp.c.

{
    ast_debug(2, "Destroying channel tech_pvt data %p\n", data);
 
    /*
     * hook_data will probably already have been unreferenced by the framehook detach
     * and the pointer set to null.
     */
    ao2_cleanup(data->hook_data);
 
    rtp_glue_data_reset(&data->glue);
    ast_free(data);
}

References ao2_cleanup, ast_debug, ast_free, native_rtp_bridge_channel_data::glue, native_rtp_bridge_channel_data::hook_data, and rtp_glue_data_reset().

Referenced by native_rtp_bridge_join(), and native_rtp_bridge_leave().

native_rtp_bridge_compatible()

static int native_rtp_bridge_compatible ( struct ast_bridge *  bridge )

static

Definition at line 765 of file bridge_native_rtp.c.

{
    struct ast_bridge_channel *bc0;
    struct ast_bridge_channel *bc1;
    int is_compatible;
 
    /* We require two channels before even considering native bridging */
    if (bridge->num_channels != 2) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as two channels are required\n",
            bridge->uniqueid);
        return 0;
    }
 
    bc0 = AST_LIST_FIRST(&bridge->channels);
    bc1 = AST_LIST_LAST(&bridge->channels);
 
    ast_channel_lock_both(bc0->chan, bc1->chan);
    is_compatible = native_rtp_bridge_compatible_check(bridge, bc0, bc1);
    ast_channel_unlock(bc0->chan);
    ast_channel_unlock(bc1->chan);
 
    return is_compatible;
}

References ast_channel_lock_both, ast_channel_unlock, ast_debug, AST_LIST_FIRST, AST_LIST_LAST, ast_bridge_channel::bridge, ast_bridge_channel::chan, ast_bridge::channels, native_rtp_bridge_compatible_check(), ast_bridge::num_channels, and ast_bridge::uniqueid.

native_rtp_bridge_compatible_check()

static int native_rtp_bridge_compatible_check ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bc0, struct ast_bridge_channel *  bc1  )

static

Definition at line 632 of file bridge_native_rtp.c.

{
    enum ast_rtp_glue_result native_type;
    int read_ptime0;
    int read_ptime1;
    int write_ptime0;
    int write_ptime1;
    struct rtp_glue_data glue_a;
    struct rtp_glue_data glue_b;
    RAII_VAR(struct ast_format_cap *, cap0, NULL, ao2_cleanup);
    RAII_VAR(struct ast_format_cap *, cap1, NULL, ao2_cleanup);
    RAII_VAR(struct rtp_glue_data *, glue0, NULL, rtp_glue_data_destroy);
    RAII_VAR(struct rtp_glue_data *, glue1, NULL, rtp_glue_data_destroy);
 
    ast_debug(1, "Bridge '%s'.  Checking compatability for channels '%s' and '%s'\n",
        bridge->uniqueid, ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
 
    if (!native_rtp_bridge_capable(bc0->chan)) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has features which prevent it\n",
            bridge->uniqueid, ast_channel_name(bc0->chan));
        return 0;
    }
 
    if (!native_rtp_bridge_capable(bc1->chan)) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has features which prevent it\n",
            bridge->uniqueid, ast_channel_name(bc1->chan));
        return 0;
    }
 
    rtp_glue_data_init(&glue_a);
    glue0 = &glue_a;
    rtp_glue_data_init(&glue_b);
    glue1 = &glue_b;
    if (rtp_glue_data_get(bc0->chan, glue0, bc1->chan, glue1)) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as could not get details\n",
            bridge->uniqueid);
        return 0;
    }
    native_type = glue0->result;
 
    if (native_type == AST_RTP_GLUE_RESULT_FORBID) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as it was forbidden while getting details\n",
            bridge->uniqueid);
        return 0;
    }
 
    if (ao2_container_count(bc0->features->dtmf_hooks)
        && ast_rtp_instance_dtmf_mode_get(glue0->audio.instance)) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has DTMF hooks\n",
            bridge->uniqueid, ast_channel_name(bc0->chan));
        return 0;
    }
 
    if (ao2_container_count(bc1->features->dtmf_hooks)
        && ast_rtp_instance_dtmf_mode_get(glue1->audio.instance)) {
        ast_debug(1, "Bridge '%s' can not use native RTP bridge as channel '%s' has DTMF hooks\n",
            bridge->uniqueid, ast_channel_name(bc1->chan));
        return 0;
    }
 
    if (native_type == AST_RTP_GLUE_RESULT_LOCAL
        && (ast_rtp_instance_get_engine(glue0->audio.instance)->local_bridge
            != ast_rtp_instance_get_engine(glue1->audio.instance)->local_bridge
            || (ast_rtp_instance_get_engine(glue0->audio.instance)->dtmf_compatible
                && !ast_rtp_instance_get_engine(glue0->audio.instance)->dtmf_compatible(bc0->chan,
                    glue0->audio.instance, bc1->chan, glue1->audio.instance)))) {
        ast_debug(1, "Bridge '%s' can not use local native RTP bridge as local bridge or DTMF is not compatible\n",
            bridge->uniqueid);
        return 0;
    }
 
    cap0 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    cap1 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!cap0 || !cap1) {
        return 0;
    }
 
    /* Make sure that codecs match */
    if (glue0->cb->get_codec) {
        glue0->cb->get_codec(bc0->chan, cap0);
    }
    if (glue1->cb->get_codec) {
        glue1->cb->get_codec(bc1->chan, cap1);
    }
    if (ast_format_cap_count(cap0) != 0
        && ast_format_cap_count(cap1) != 0
        && !ast_format_cap_iscompatible(cap0, cap1)) {
        struct ast_str *codec_buf0 = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
        struct ast_str *codec_buf1 = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
        ast_debug(1, "Bridge '%s': Channel codec0 = %s is not codec1 = %s, cannot native bridge in RTP.\n",
            bridge->uniqueid,
            ast_format_cap_get_names(cap0, &codec_buf0),
            ast_format_cap_get_names(cap1, &codec_buf1));
        return 0;
    }
 
    if (glue0->audio.instance && glue1->audio.instance) {
        unsigned int framing_inst0, framing_inst1;
        framing_inst0 = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(glue0->audio.instance));
        framing_inst1 = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(glue1->audio.instance));
        if (framing_inst0 != framing_inst1) {
            /* ptimes are asymmetric on the two call legs so we can't use the native bridge */
            ast_debug(1, "Asymmetric ptimes on the two call legs (%u != %u). Cannot native bridge in RTP\n",
                framing_inst0, framing_inst1);
            return 0;
        }
        ast_debug(3, "Symmetric ptimes on the two call legs (%u). May be able to native bridge in RTP\n",
            framing_inst0);
    }
 
    read_ptime0 = ast_format_cap_get_format_framing(cap0, ast_channel_rawreadformat(bc0->chan));
    read_ptime1 = ast_format_cap_get_format_framing(cap1, ast_channel_rawreadformat(bc1->chan));
    write_ptime0 = ast_format_cap_get_format_framing(cap0, ast_channel_rawwriteformat(bc0->chan));
    write_ptime1 = ast_format_cap_get_format_framing(cap1, ast_channel_rawwriteformat(bc1->chan));
 
    if (read_ptime0 != write_ptime1 || read_ptime1 != write_ptime0) {
        ast_debug(1, "Bridge '%s': Packetization differs between RTP streams (%d != %d or %d != %d). Cannot native bridge in RTP\n",
            bridge->uniqueid,
            read_ptime0, write_ptime1, read_ptime1, write_ptime0);
        return 0;
    }
    ast_debug(3, "Bridge '%s': Packetization comparison success between RTP streams (read_ptime0:%d == write_ptime1:%d and read_ptime1:%d == write_ptime0:%d).\n",
        bridge->uniqueid,
        read_ptime0, write_ptime1, read_ptime1, write_ptime0);
 
    return 1;
}

References ao2_cleanup, ao2_container_count(), ast_channel_name(), ast_channel_rawreadformat(), ast_channel_rawwriteformat(), ast_debug, ast_format_cap_alloc, ast_format_cap_count(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_format_framing(), ast_format_cap_get_names(), ast_format_cap_iscompatible(), AST_FORMAT_CAP_NAMES_LEN, ast_rtp_codecs_get_framing(), AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, ast_rtp_instance_dtmf_mode_get(), ast_rtp_instance_get_codecs(), ast_rtp_instance_get_engine(), ast_str_alloca, ast_bridge_channel::chan, ast_rtp_engine::dtmf_compatible, ast_bridge_features::dtmf_hooks, ast_bridge_channel::features, ast_rtp_engine::local_bridge, native_rtp_bridge_capable(), NULL, RAII_VAR, rtp_glue_data_destroy(), rtp_glue_data_get(), rtp_glue_data_init(), and ast_bridge::uniqueid.

Referenced by native_rtp_bridge_compatible().

native_rtp_bridge_framehook_attach()

static int native_rtp_bridge_framehook_attach ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 793 of file bridge_native_rtp.c.

{
    struct native_rtp_bridge_channel_data *data = bridge_channel->tech_pvt;
    struct ast_framehook_interface hook = {
        .version = AST_FRAMEHOOK_INTERFACE_VERSION,
        .event_cb = native_rtp_framehook,
        .destroy_cb = __ao2_cleanup,
        .consume_cb = native_rtp_framehook_consume,
        .disable_inheritance = 1,
    };
 
    ast_assert(data->hook_data == NULL);
    data->hook_data = ao2_alloc_options(sizeof(*data->hook_data), NULL,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!data->hook_data) {
        return -1;
    }
 
    ast_debug(2, "Bridge '%s'.  Attaching hook data %p to '%s'\n",
        bridge_channel->bridge->uniqueid, data, ast_channel_name(bridge_channel->chan));
 
    /* We're giving 1 ref to the framehook and keeping the one from the alloc for ourselves */
    hook.data = ao2_bump(data->hook_data);
 
    ast_channel_lock(bridge_channel->chan);
    data->hook_data->id = ast_framehook_attach(bridge_channel->chan, &hook);
    ast_channel_unlock(bridge_channel->chan);
    if (data->hook_data->id < 0) {
        /*
         * We need to drop both the reference we hold in data,
         * and the one the framehook would hold.
         */
        ao2_ref(data->hook_data, -2);
        data->hook_data = NULL;
 
        return -1;
    }
 
    return 0;
}

References __ao2_cleanup(), AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_assert, ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_framehook_attach(), AST_FRAMEHOOK_INTERFACE_VERSION, ast_bridge_channel::bridge, ast_bridge_channel::chan, ast_framehook_interface::data, native_rtp_framehook(), native_rtp_framehook_consume(), NULL, ast_bridge_channel::tech_pvt, ast_bridge::uniqueid, and ast_framehook_interface::version.

Referenced by native_rtp_bridge_join().

native_rtp_bridge_framehook_detach()

static void native_rtp_bridge_framehook_detach ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 838 of file bridge_native_rtp.c.

{
    struct native_rtp_bridge_channel_data *data = bridge_channel->tech_pvt;
 
    if (!data || !data->hook_data) {
        return;
    }
 
    ast_debug(2, "Bridge '%s'.  Detaching hook data %p from '%s'\n",
        bridge_channel->bridge->uniqueid, data->hook_data, ast_channel_name(bridge_channel->chan));
 
    ast_channel_lock(bridge_channel->chan);
    ast_framehook_detach(bridge_channel->chan, data->hook_data->id);
    data->hook_data->detached = 1;
    ast_channel_unlock(bridge_channel->chan);
    ao2_cleanup(data->hook_data);
    data->hook_data = NULL;
}

References ao2_cleanup, ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_framehook_detach(), ast_bridge_channel::bridge, ast_bridge_channel::chan, native_rtp_framehook_data::detached, native_rtp_bridge_channel_data::hook_data, native_rtp_framehook_data::id, NULL, ast_bridge_channel::tech_pvt, and ast_bridge::uniqueid.

Referenced by native_rtp_bridge_leave().

native_rtp_bridge_join()

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

static

Forward declarations.

Definition at line 967 of file bridge_native_rtp.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;
 
    ast_debug(2, "Bridge '%s'.  Channel '%s' is joining bridge tech\n",
        bridge->uniqueid, ast_channel_name(bridge_channel->chan));
 
    ast_assert(bridge_channel->tech_pvt == NULL);
 
    if (bridge_channel->suspended) {
        /* The channel will rejoin when it is unsuspended */
        return 0;
    }
 
    bridge_channel->tech_pvt = native_rtp_bridge_channel_data_alloc();
    if (!bridge_channel->tech_pvt) {
        return -1;
    }
 
    if (native_rtp_bridge_framehook_attach(bridge_channel)) {
        native_rtp_bridge_channel_data_free(bridge_channel->tech_pvt);
        bridge_channel->tech_pvt = NULL;
        return -1;
    }
 
    if (c0 != c1) {
        /* 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 = native_rtp_request_stream_topology_update(existing_top, req_top);
        ast_channel_unlock(c0);
        ast_channel_unlock(c1);
 
        if (new_top) {
            ast_channel_request_stream_topology_change(c1, new_top, &native_rtp_bridge);
            ast_stream_topology_free(new_top);
        }
    }
 
    native_rtp_bridge_start(bridge, NULL);
    return 0;
}

References ast_assert, ast_channel_get_stream_topology(), ast_channel_lock_both, ast_channel_name(), ast_channel_request_stream_topology_change(), ast_channel_unlock, ast_debug, AST_LIST_FIRST, AST_LIST_LAST, ast_stream_topology_free(), ast_stream_topology_get_count(), ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, ast_bridge::channels, native_rtp_bridge, native_rtp_bridge_channel_data_alloc(), native_rtp_bridge_channel_data_free(), native_rtp_bridge_framehook_attach(), native_rtp_bridge_start(), native_rtp_request_stream_topology_update(), NULL, ast_bridge_channel::suspended, SWAP, ast_bridge_channel::tech_pvt, and ast_bridge::uniqueid.

Referenced by native_rtp_bridge_unsuspend().

native_rtp_bridge_leave()

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

static

Definition at line 1036 of file bridge_native_rtp.c.

{
    ast_debug(2, "Bridge '%s'.  Channel '%s' is leaving bridge tech\n",
        bridge->uniqueid, ast_channel_name(bridge_channel->chan));
 
    if (!bridge_channel->tech_pvt) {
        return;
    }
 
    native_rtp_bridge_framehook_detach(bridge_channel);
    native_rtp_bridge_stop(bridge, NULL);
 
    native_rtp_bridge_channel_data_free(bridge_channel->tech_pvt);
    bridge_channel->tech_pvt = NULL;
}

References ast_channel_name(), ast_debug, ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, native_rtp_bridge_channel_data_free(), native_rtp_bridge_framehook_detach(), native_rtp_bridge_stop(), NULL, ast_bridge_channel::tech_pvt, and ast_bridge::uniqueid.

Referenced by native_rtp_bridge_suspend().

native_rtp_bridge_start()

static void native_rtp_bridge_start ( struct ast_bridge *  bridge, struct ast_channel *  target  )

static

Definition at line 289 of file bridge_native_rtp.c.

{
    struct ast_bridge_channel *bc0 = AST_LIST_FIRST(&bridge->channels);
    struct ast_bridge_channel *bc1 = AST_LIST_LAST(&bridge->channels);
    struct native_rtp_bridge_channel_data *data0;
    struct native_rtp_bridge_channel_data *data1;
    struct rtp_glue_data *glue0;
    struct rtp_glue_data *glue1;
    struct ast_format_cap *cap0;
    struct ast_format_cap *cap1;
    enum ast_rtp_glue_result native_type;
 
    if (bc0 == bc1) {
        return;
    }
    data0 = bc0->tech_pvt;
    data1 = bc1->tech_pvt;
    if (!data0 || !data1) {
        /* Not all channels are joined with the bridge tech yet */
        return;
    }
    glue0 = &data0->glue;
    glue1 = &data1->glue;
 
    ast_channel_lock_both(bc0->chan, bc1->chan);
 
    if (!glue0->cb || !glue1->cb) {
        /*
         * Somebody doesn't have glue data so the bridge isn't running
         *
         * Actually neither side should have glue data.
         */
        ast_assert(!glue0->cb && !glue1->cb);
 
        if (rtp_glue_data_get(bc0->chan, glue0, bc1->chan, glue1)) {
            /*
             * This might happen if one of the channels got masqueraded
             * at a critical time.  It's a bit of a stretch even then
             * since the channel is in a bridge.
             */
            goto done;
        }
    }
 
    ast_debug(2, "Bridge '%s'.  Tech starting '%s' and '%s' with target '%s'\n",
        bridge->uniqueid, ast_channel_name(bc0->chan), ast_channel_name(bc1->chan),
        target ? ast_channel_name(target) : "none");
 
    native_type = glue0->result;
 
    switch (native_type) {
    case AST_RTP_GLUE_RESULT_LOCAL:
        if (ast_rtp_instance_get_engine(glue0->audio.instance)->local_bridge) {
            ast_rtp_instance_get_engine(glue0->audio.instance)->local_bridge(glue0->audio.instance, glue1->audio.instance);
        }
        if (ast_rtp_instance_get_engine(glue1->audio.instance)->local_bridge) {
            ast_rtp_instance_get_engine(glue1->audio.instance)->local_bridge(glue1->audio.instance, glue0->audio.instance);
        }
        ast_rtp_instance_set_bridged(glue0->audio.instance, glue1->audio.instance);
        ast_rtp_instance_set_bridged(glue1->audio.instance, glue0->audio.instance);
        ast_verb(4, "Locally RTP bridged '%s' and '%s' in stack\n",
            ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
        break;
    case AST_RTP_GLUE_RESULT_REMOTE:
        cap0 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        cap1 = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        if (!cap0 || !cap1) {
            ao2_cleanup(cap0);
            ao2_cleanup(cap1);
            break;
        }
 
        if (glue0->cb->get_codec) {
            glue0->cb->get_codec(bc0->chan, cap0);
        }
        if (glue1->cb->get_codec) {
            glue1->cb->get_codec(bc1->chan, cap1);
        }
 
        /*
         * If we have a target, it's the channel that received the UNHOLD or
         * UPDATE_RTP_PEER frame and was told to resume
         */
        if (!target) {
            /* Send both channels to remote */
            data0->remote_cb = glue0->cb;
            data1->remote_cb = glue1->cb;
            glue0->cb->update_peer(bc0->chan, glue1->audio.instance, glue1->video.instance, NULL, cap1, 0);
            glue1->cb->update_peer(bc1->chan, glue0->audio.instance, glue0->video.instance, NULL, cap0, 0);
            ast_verb(4, "Remotely bridged '%s' and '%s' - media will flow directly between them\n",
                ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
        } else {
            /*
             * If a target was provided, it is the recipient of an unhold or an update and needs to have
             * its media redirected to fit the current remote bridging needs. The other channel is either
             * already set up to handle the new media path or will have its own set of updates independent
             * of this pass.
             */
            ast_debug(2, "Bridge '%s'.  Sending '%s' back to remote\n",
                bridge->uniqueid, ast_channel_name(target));
            if (bc0->chan == target) {
                data0->remote_cb = glue0->cb;
                glue0->cb->update_peer(bc0->chan, glue1->audio.instance, glue1->video.instance, NULL, cap1, 0);
            } else {
                data1->remote_cb = glue1->cb;
                glue1->cb->update_peer(bc1->chan, glue0->audio.instance, glue0->video.instance, NULL, cap0, 0);
            }
        }
 
        ao2_cleanup(cap0);
        ao2_cleanup(cap1);
        break;
    case AST_RTP_GLUE_RESULT_FORBID:
        break;
    }
 
    if (native_type != AST_RTP_GLUE_RESULT_REMOTE) {
        /* Bring any remaining channels back to us. */
        if (data0->remote_cb) {
            ast_debug(2, "Bridge '%s'.  Bringing back '%s' to us\n",
                bridge->uniqueid, ast_channel_name(bc0->chan));
            data0->remote_cb->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
            data0->remote_cb = NULL;
        }
        if (data1->remote_cb) {
            ast_debug(2, "Bridge '%s'.  Bringing back '%s' to us\n",
                bridge->uniqueid, ast_channel_name(bc1->chan));
            data1->remote_cb->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
            data1->remote_cb = NULL;
        }
    }
 
done:
    ast_channel_unlock(bc0->chan);
    ast_channel_unlock(bc1->chan);
}

References ao2_cleanup, ast_assert, ast_channel_lock_both, ast_channel_name(), ast_channel_unlock, ast_debug, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, AST_LIST_FIRST, AST_LIST_LAST, AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, AST_RTP_GLUE_RESULT_REMOTE, ast_rtp_instance_get_engine(), ast_rtp_instance_set_bridged(), ast_verb, rtp_glue_data::audio, ast_bridge_channel::bridge, rtp_glue_data::cb, ast_bridge_channel::chan, ast_bridge::channels, done, ast_rtp_glue::get_codec, native_rtp_bridge_channel_data::glue, rtp_glue_stream::instance, ast_rtp_engine::local_bridge, NULL, native_rtp_bridge_channel_data::remote_cb, rtp_glue_data::result, rtp_glue_data_get(), ast_bridge_channel::tech_pvt, ast_bridge::uniqueid, ast_rtp_glue::update_peer, and rtp_glue_data::video.

Referenced by native_rtp_bridge_join(), and native_rtp_framehook().

native_rtp_bridge_stop()

static void native_rtp_bridge_stop ( struct ast_bridge *  bridge, struct ast_channel *  target  )

static

Definition at line 435 of file bridge_native_rtp.c.

{
    struct ast_bridge_channel *bc0 = AST_LIST_FIRST(&bridge->channels);
    struct ast_bridge_channel *bc1 = AST_LIST_LAST(&bridge->channels);
    struct native_rtp_bridge_channel_data *data0;
    struct native_rtp_bridge_channel_data *data1;
    struct rtp_glue_data *glue0;
    struct rtp_glue_data *glue1;
 
    if (bc0 == bc1) {
        return;
    }
    data0 = bc0->tech_pvt;
    data1 = bc1->tech_pvt;
    if (!data0 || !data1) {
        /* Not all channels are joined with the bridge tech */
        return;
    }
    glue0 = &data0->glue;
    glue1 = &data1->glue;
 
    ast_debug(2, "Bridge '%s'.  Tech stopping '%s' and '%s' with target '%s'\n",
        bridge->uniqueid, ast_channel_name(bc0->chan), ast_channel_name(bc1->chan),
        target ? ast_channel_name(target) : "none");
 
    if (!glue0->cb || !glue1->cb) {
        /*
         * Somebody doesn't have glue data so the bridge isn't running
         *
         * Actually neither side should have glue data.
         */
        ast_assert(!glue0->cb && !glue1->cb);
        /* At most one channel can be left at the remote endpoint here. */
        ast_assert(!data0->remote_cb || !data1->remote_cb);
 
        /* Bring selected channel streams back to us */
        if (data0->remote_cb && (!target || target == bc0->chan)) {
            ast_channel_lock(bc0->chan);
            ast_debug(2, "Bridge '%s'.  Bringing back '%s' to us\n",
                bridge->uniqueid, ast_channel_name(bc0->chan));
            data0->remote_cb->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
            data0->remote_cb = NULL;
            ast_channel_unlock(bc0->chan);
        }
        if (data1->remote_cb && (!target || target == bc1->chan)) {
            ast_channel_lock(bc1->chan);
            ast_debug(2, "Bridge '%s'.  Bringing back '%s' to us\n",
                bridge->uniqueid, ast_channel_name(bc1->chan));
            data1->remote_cb->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
            data1->remote_cb = NULL;
            ast_channel_unlock(bc1->chan);
        }
        return;
    }
 
    ast_channel_lock_both(bc0->chan, bc1->chan);
 
    switch (glue0->result) {
    case AST_RTP_GLUE_RESULT_LOCAL:
        if (ast_rtp_instance_get_engine(glue0->audio.instance)->local_bridge) {
            ast_rtp_instance_get_engine(glue0->audio.instance)->local_bridge(glue0->audio.instance, NULL);
        }
        if (ast_rtp_instance_get_engine(glue1->audio.instance)->local_bridge) {
            ast_rtp_instance_get_engine(glue1->audio.instance)->local_bridge(glue1->audio.instance, NULL);
        }
        ast_rtp_instance_set_bridged(glue0->audio.instance, NULL);
        ast_rtp_instance_set_bridged(glue1->audio.instance, NULL);
        break;
    case AST_RTP_GLUE_RESULT_REMOTE:
        if (target) {
            /*
             * If a target was provided, it is being put on hold and should expect to
             * receive media from Asterisk instead of what it was previously connected to.
             */
            ast_debug(2, "Bridge '%s'.  Bringing back '%s' to us\n",
                bridge->uniqueid, ast_channel_name(target));
            if (bc0->chan == target) {
                data0->remote_cb = NULL;
                glue0->cb->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
            } else {
                data1->remote_cb = NULL;
                glue1->cb->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
            }
        } else {
            data0->remote_cb = NULL;
            data1->remote_cb = NULL;
            /*
             * XXX We don't want to bring back the channels if we are
             * switching to T.38.  We have received a reinvite on one channel
             * and we will be sending a reinvite on the other to start T.38.
             * If we bring the streams back now we confuse the chan_pjsip
             * channel driver processing the incoming T.38 reinvite with
             * reinvite glare.  I think this is really a bug in chan_pjsip
             * that this exception case is working around.
             */
            if (rtp_glue_get_current_combined_result(bc0->chan, bc1->chan)
                != AST_RTP_GLUE_RESULT_FORBID) {
                ast_debug(2, "Bridge '%s'.  Bringing back '%s' and '%s' to us\n",
                    bridge->uniqueid, ast_channel_name(bc0->chan),
                    ast_channel_name(bc1->chan));
                glue0->cb->update_peer(bc0->chan, NULL, NULL, NULL, NULL, 0);
                glue1->cb->update_peer(bc1->chan, NULL, NULL, NULL, NULL, 0);
            } else {
                ast_debug(2, "Bridge '%s'.  Skip bringing back '%s' and '%s' to us\n",
                    bridge->uniqueid, ast_channel_name(bc0->chan),
                    ast_channel_name(bc1->chan));
            }
        }
        break;
    case AST_RTP_GLUE_RESULT_FORBID:
        break;
    }
 
    rtp_glue_data_reset(glue0);
    rtp_glue_data_reset(glue1);
 
    ast_debug(2, "Discontinued RTP bridging of '%s' and '%s' - media will flow through Asterisk core\n",
        ast_channel_name(bc0->chan), ast_channel_name(bc1->chan));
 
    ast_channel_unlock(bc0->chan);
    ast_channel_unlock(bc1->chan);
}

References ast_assert, ast_channel_lock, ast_channel_lock_both, ast_channel_name(), ast_channel_unlock, ast_debug, AST_LIST_FIRST, AST_LIST_LAST, AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, AST_RTP_GLUE_RESULT_REMOTE, ast_rtp_instance_get_engine(), ast_rtp_instance_set_bridged(), rtp_glue_data::audio, ast_bridge_channel::bridge, rtp_glue_data::cb, ast_bridge_channel::chan, ast_bridge::channels, native_rtp_bridge_channel_data::glue, rtp_glue_stream::instance, ast_rtp_engine::local_bridge, NULL, native_rtp_bridge_channel_data::remote_cb, rtp_glue_data::result, rtp_glue_data_reset(), rtp_glue_get_current_combined_result(), ast_bridge_channel::tech_pvt, ast_bridge::uniqueid, and ast_rtp_glue::update_peer.

Referenced by native_rtp_bridge_leave(), and native_rtp_framehook().

native_rtp_bridge_suspend()

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

static

Definition at line 1056 of file bridge_native_rtp.c.

{
    ast_debug(2, "Bridge '%s'.  Channel '%s' is suspending from bridge tech\n",
        bridge->uniqueid, ast_channel_name(bridge_channel->chan));
    native_rtp_bridge_leave(bridge, bridge_channel);
}

References ast_channel_name(), ast_debug, ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, native_rtp_bridge_leave(), and ast_bridge::uniqueid.

native_rtp_bridge_unsuspend()

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

static

Definition at line 1025 of file bridge_native_rtp.c.

{
    ast_debug(2, "Bridge '%s'.  Channel '%s' is unsuspended back to bridge tech\n",
        bridge->uniqueid, ast_channel_name(bridge_channel->chan));
    native_rtp_bridge_join(bridge, bridge_channel);
}

References ast_channel_name(), ast_debug, ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, native_rtp_bridge_join(), and ast_bridge::uniqueid.

native_rtp_bridge_write()

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

static

Definition at line 1063 of file bridge_native_rtp.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.

native_rtp_framehook()

static struct ast_frame * native_rtp_framehook ( struct ast_channel *  chan, struct ast_frame *  f, enum ast_framehook_event  event, void *  data  )

static

Definition at line 562 of file bridge_native_rtp.c.

{
    struct ast_bridge *bridge;
    struct native_rtp_framehook_data *native_data = data;
 
    if (!f
        || f->frametype != AST_FRAME_CONTROL
        || event != AST_FRAMEHOOK_EVENT_WRITE) {
        return f;
    }
 
    bridge = ast_channel_get_bridge(chan);
    if (bridge) {
        /* native_rtp_bridge_start/stop are not being called from bridging
           core so we need to lock the bridge prior to calling these functions
           Unfortunately that means unlocking the channel, but as it
           should not be modified this should be okay... hopefully...
           unless this channel is being moved around right now and is in
           the process of having this framehook removed (which is fine). To
           ensure we then don't stop or start when we shouldn't we consult
           the data provided. If this framehook has been detached then the
           detached variable will be set. This is safe to check as it is only
           manipulated with the bridge lock held. */
        ast_channel_unlock(chan);
        ast_bridge_lock(bridge);
        if (!native_data->detached) {
            switch (f->subclass.integer) {
            case AST_CONTROL_HOLD:
                native_rtp_bridge_stop(bridge, chan);
                break;
            case AST_CONTROL_UNHOLD:
            case AST_CONTROL_UPDATE_RTP_PEER:
                native_rtp_bridge_start(bridge, chan);
                break;
            default:
                break;
            }
        }
        ast_bridge_unlock(bridge);
        ao2_ref(bridge, -1);
        ast_channel_lock(chan);
    }
 
    return f;
}

References ao2_ref, ast_bridge_lock, ast_bridge_unlock, ast_channel_get_bridge(), ast_channel_lock, ast_channel_unlock, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_CONTROL_UPDATE_RTP_PEER, AST_FRAME_CONTROL, AST_FRAMEHOOK_EVENT_WRITE, native_rtp_framehook_data::detached, ast_frame::frametype, ast_frame_subclass::integer, native_rtp_bridge_start(), native_rtp_bridge_stop(), and ast_frame::subclass.

Referenced by native_rtp_bridge_framehook_attach().

native_rtp_framehook_consume()

static int native_rtp_framehook_consume ( void *  data, enum ast_frame_type  type  )

static

Definition at line 613 of file bridge_native_rtp.c.

{
    return (type == AST_FRAME_CONTROL ? 1 : 0);
}

References AST_FRAME_CONTROL, and type.

Referenced by native_rtp_bridge_framehook_attach().

native_rtp_request_stream_topology_update()

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

static

Definition at line 857 of file bridge_native_rtp.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 native_rtp_bridge_join(), and native_rtp_stream_topology_changed().

native_rtp_stream_topology_changed()

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

static

Definition at line 920 of file bridge_native_rtp.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)
        == &native_rtp_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 = native_rtp_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, &native_rtp_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, native_rtp_bridge, and native_rtp_request_stream_topology_update().

rtp_glue_data_destroy()

static void rtp_glue_data_destroy ( struct rtp_glue_data *  glue )

static

Definition at line 121 of file bridge_native_rtp.c.

{
    if (!glue) {
        return;
    }
    ao2_cleanup(glue->audio.instance);
    ao2_cleanup(glue->video.instance);
}

References ao2_cleanup, rtp_glue_data::audio, rtp_glue_stream::instance, and rtp_glue_data::video.

Referenced by native_rtp_bridge_compatible_check(), rtp_glue_data_reset(), and rtp_glue_get_current_combined_result().

rtp_glue_data_get()

static int rtp_glue_data_get ( struct ast_channel *  c0, struct rtp_glue_data *  glue0, struct ast_channel *  c1, struct rtp_glue_data *  glue1  )

static

Definition at line 168 of file bridge_native_rtp.c.

{
    struct ast_rtp_glue *cb0;
    struct ast_rtp_glue *cb1;
    enum ast_rtp_glue_result combined_result;
 
    cb0 = ast_rtp_instance_get_glue(ast_channel_tech(c0)->type);
    cb1 = ast_rtp_instance_get_glue(ast_channel_tech(c1)->type);
    if (!cb0 || !cb1) {
        /* One or both channels doesn't have any RTP glue registered. */
        return -1;
    }
 
    /* The glue callbacks bump the RTP instance refcounts for us. */
 
    glue0->cb = cb0;
    glue0->audio.result = cb0->get_rtp_info(c0, &glue0->audio.instance);
    glue0->video.result = cb0->get_vrtp_info
        ? cb0->get_vrtp_info(c0, &glue0->video.instance) : AST_RTP_GLUE_RESULT_FORBID;
 
    glue1->cb = cb1;
    glue1->audio.result = cb1->get_rtp_info(c1, &glue1->audio.instance);
    glue1->video.result = cb1->get_vrtp_info
        ? cb1->get_vrtp_info(c1, &glue1->video.instance) : AST_RTP_GLUE_RESULT_FORBID;
 
    /*
     * Now determine the combined glue result.
     */
 
    /* Apply any limitations on direct media bridging that may be present */
    if (glue0->audio.result == glue1->audio.result && glue1->audio.result == AST_RTP_GLUE_RESULT_REMOTE) {
        if (glue0->cb->allow_rtp_remote && !glue0->cb->allow_rtp_remote(c0, glue1->audio.instance)) {
            /* If the allow_rtp_remote indicates that remote isn't allowed, revert to local bridge */
            glue0->audio.result = glue1->audio.result = AST_RTP_GLUE_RESULT_LOCAL;
        } else if (glue1->cb->allow_rtp_remote && !glue1->cb->allow_rtp_remote(c1, glue0->audio.instance)) {
            glue0->audio.result = glue1->audio.result = AST_RTP_GLUE_RESULT_LOCAL;
        }
    }
    if (glue0->video.result == glue1->video.result && glue1->video.result == AST_RTP_GLUE_RESULT_REMOTE) {
        if (glue0->cb->allow_vrtp_remote && !glue0->cb->allow_vrtp_remote(c0, glue1->video.instance)) {
            /* If the allow_vrtp_remote indicates that remote isn't allowed, revert to local bridge */
            glue0->video.result = glue1->video.result = AST_RTP_GLUE_RESULT_LOCAL;
        } else if (glue1->cb->allow_vrtp_remote && !glue1->cb->allow_vrtp_remote(c1, glue0->video.instance)) {
            glue0->video.result = glue1->video.result = AST_RTP_GLUE_RESULT_LOCAL;
        }
    }
 
    /* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
    if (glue0->video.result != AST_RTP_GLUE_RESULT_FORBID
        && (glue0->audio.result != AST_RTP_GLUE_RESULT_REMOTE
            || glue0->video.result != AST_RTP_GLUE_RESULT_REMOTE)) {
        glue0->audio.result = AST_RTP_GLUE_RESULT_FORBID;
    }
    if (glue1->video.result != AST_RTP_GLUE_RESULT_FORBID
        && (glue1->audio.result != AST_RTP_GLUE_RESULT_REMOTE
            || glue1->video.result != AST_RTP_GLUE_RESULT_REMOTE)) {
        glue1->audio.result = AST_RTP_GLUE_RESULT_FORBID;
    }
 
    /* The order of preference is: forbid, local, and remote. */
    if (glue0->audio.result == AST_RTP_GLUE_RESULT_FORBID
        || glue1->audio.result == AST_RTP_GLUE_RESULT_FORBID) {
        /* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
        combined_result = AST_RTP_GLUE_RESULT_FORBID;
    } else if (glue0->audio.result == AST_RTP_GLUE_RESULT_LOCAL
        || glue1->audio.result == AST_RTP_GLUE_RESULT_LOCAL) {
        combined_result = AST_RTP_GLUE_RESULT_LOCAL;
    } else {
        combined_result = AST_RTP_GLUE_RESULT_REMOTE;
    }
    glue0->result = combined_result;
    glue1->result = combined_result;
 
    return 0;
}

References ast_rtp_glue::allow_rtp_remote, ast_rtp_glue::allow_vrtp_remote, AST_RTP_GLUE_RESULT_FORBID, AST_RTP_GLUE_RESULT_LOCAL, AST_RTP_GLUE_RESULT_REMOTE, ast_rtp_instance_get_glue(), rtp_glue_data::audio, rtp_glue_data::cb, ast_rtp_glue::get_rtp_info, ast_rtp_glue::get_vrtp_info, rtp_glue_stream::instance, rtp_glue_stream::result, rtp_glue_data::result, type, and rtp_glue_data::video.

Referenced by native_rtp_bridge_compatible_check(), native_rtp_bridge_start(), and rtp_glue_get_current_combined_result().

rtp_glue_data_init()

static void rtp_glue_data_init ( struct rtp_glue_data *  glue )

static

Definition at line 111 of file bridge_native_rtp.c.

{
    glue->cb = NULL;
    glue->audio.instance = NULL;
    glue->audio.result = AST_RTP_GLUE_RESULT_FORBID;
    glue->video.instance = NULL;
    glue->video.result = AST_RTP_GLUE_RESULT_FORBID;
    glue->result = AST_RTP_GLUE_RESULT_FORBID;
}

References AST_RTP_GLUE_RESULT_FORBID, rtp_glue_data::audio, rtp_glue_data::cb, rtp_glue_stream::instance, NULL, rtp_glue_stream::result, rtp_glue_data::result, and rtp_glue_data::video.

Referenced by native_rtp_bridge_channel_data_alloc(), native_rtp_bridge_compatible_check(), rtp_glue_data_reset(), and rtp_glue_get_current_combined_result().

rtp_glue_data_reset()

static void rtp_glue_data_reset ( struct rtp_glue_data *  glue )

static

Definition at line 130 of file bridge_native_rtp.c.

{
    rtp_glue_data_destroy(glue);
    rtp_glue_data_init(glue);
}

References rtp_glue_data_destroy(), and rtp_glue_data_init().

Referenced by native_rtp_bridge_channel_data_free(), and native_rtp_bridge_stop().

rtp_glue_get_current_combined_result()

static enum ast_rtp_glue_result rtp_glue_get_current_combined_result ( struct ast_channel *  c0, struct ast_channel *  c1  )

static

Definition at line 257 of file bridge_native_rtp.c.

{
    struct rtp_glue_data glue_a;
    struct rtp_glue_data glue_b;
    struct rtp_glue_data *glue0;
    struct rtp_glue_data *glue1;
    enum ast_rtp_glue_result combined_result;
 
    rtp_glue_data_init(&glue_a);
    glue0 = &glue_a;
    rtp_glue_data_init(&glue_b);
    glue1 = &glue_b;
    if (rtp_glue_data_get(c0, glue0, c1, glue1)) {
        return AST_RTP_GLUE_RESULT_FORBID;
    }
 
    combined_result = glue0->result;
    rtp_glue_data_destroy(glue0);
    rtp_glue_data_destroy(glue1);
    return combined_result;
}

References AST_RTP_GLUE_RESULT_FORBID, rtp_glue_data::result, rtp_glue_data_destroy(), rtp_glue_data_get(), and rtp_glue_data_init().

Referenced by native_rtp_bridge_stop().

unload_module()

static int unload_module ( void  )

static

Definition at line 1098 of file bridge_native_rtp.c.

{
    ast_bridge_technology_unregister(&native_rtp_bridge);
    return 0;
}

References ast_bridge_technology_unregister(), and native_rtp_bridge.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Native RTP 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 1113 of file bridge_native_rtp.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1113 of file bridge_native_rtp.c.

native_rtp_bridge

struct ast_bridge_technology native_rtp_bridge

static

Definition at line 98 of file bridge_native_rtp.c.

                                                        {
    .name = "native_rtp",
    .capabilities = AST_BRIDGE_CAPABILITY_NATIVE,
    .preference = AST_BRIDGE_PREFERENCE_BASE_NATIVE,
    .join = native_rtp_bridge_join,
    .unsuspend = native_rtp_bridge_unsuspend,
    .leave = native_rtp_bridge_leave,
    .suspend = native_rtp_bridge_suspend,
    .write = native_rtp_bridge_write,
    .compatible = native_rtp_bridge_compatible,
    .stream_topology_changed = native_rtp_stream_topology_changed,
};

Referenced by load_module(), native_rtp_bridge_join(), native_rtp_stream_topology_changed(), and unload_module().