app_broadcast.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2022, Naveen Albert
 *
 * 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 Channel audio broadcasting
 *
 * \author Naveen Albert <asterisk@phreaknet.org>
 *
 * \ingroup applications
 */
 
/*** MODULEINFO
    <support_level>extended</support_level>
 ***/
 
#include "asterisk.h"
 
#include <ctype.h>
#include <errno.h>
 
#include "asterisk/channel.h"
#include "asterisk/audiohook.h"
#include "asterisk/app.h"
#include "asterisk/utils.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/options.h"
#include "asterisk/autochan.h"
#include "asterisk/format_cache.h"
#include "asterisk/cli.h" /* use ESS macro */
 
/*** DOCUMENTATION
    <application name="Broadcast" language="en_US">
        <synopsis>
            Transmit or receive audio to or from multiple channels simultaneously
        </synopsis>
        <syntax>
            <parameter name="options">
                <optionlist>
                    <option name="b">
                        <para>In addition to broadcasting to target channels, also
                        broadcast to any channels to which target channels are bridged.</para>
                    </option>
                    <option name="l">
                        <para>Allow usage of a long queue to store audio frames.</para>
                        <note><para>This may introduce some delay in the received audio feed, but will improve the audio quality.</para></note>
                    </option>
                    <option name="o">
                        <para>Do not mix streams when combining audio from target channels (only applies with s option).</para>
                    </option>
                    <option name="r">
                        <para>Feed frames to barge channels in "reverse" by injecting them into the primary channel's read queue instead.</para>
                        <para>This option is required for barge to work in a n-party bridge (but not for 2-party bridges). Alternately, you
                        can add an intermediate channel by using a non-optimized Local channel, so that the target channel is bridged with
                        a single channel that is connected to the bridge, but it is recommended this option be used instead.</para>
                        <para>Note that this option will always feed injected audio to the other party, regardless of whether the target
                        channel is bridged or not.</para>
                    </option>
                    <option name="s">
                        <para>Rather than broadcast audio to a bunch of channels, receive the combined audio from the target channels.</para>
                    </option>
                    <option name="w">
                        <para>Broadcast audio received on this channel to other channels.</para>
                    </option>
                </optionlist>
            </parameter>
            <parameter name="channels" required="true" argsep=",">
                <para>List of channels for broadcast targets.</para>
                <para>Channel names must be the full channel names, not merely device names.</para>
                <para>Broadcasting will continue until the broadcasting channel hangs up or all target channels have hung up.</para>
            </parameter>
        </syntax>
        <description>
            <para>This application can be used to broadcast audio to multiple channels at once.
            Any audio received on this channel will be transmitted to all of the specified channels and, optionally, their bridged peers.</para>
            <para>It can also be used to aggregate audio from multiple channels at once.
            Any audio on any of the specified channels, and optionally their bridged peers, will be transmitted to this channel.</para>
            <para>Execution of the application continues until either the broadcasting channel hangs up
            or all specified channels have hung up.</para>
            <para>This application is used for one-to-many and many-to-one audio applications where
            bridge mixing cannot be done synchronously on all the involved channels.
            This is primarily useful for injecting the same audio stream into multiple channels at once,
            or doing the reverse, combining the audio from multiple channels into a single stream.
            This contrasts with using a separate injection channel for each target channel and/or
            using a conference bridge.</para>
            <para>The channel running the Broadcast application must do so synchronously. The specified channels,
            however, may be doing other things.</para>
            <example title="Broadcast received audio to three channels and their bridged peers">
            same => n,Broadcast(wb,DAHDI/1,DAHDI/3,PJSIP/doorphone)
            </example>
            <example title="Broadcast received audio to three channels, only">
            same => n,Broadcast(w,DAHDI/1,DAHDI/3,PJSIP/doorphone)
            </example>
            <example title="Combine audio from three channels and their bridged peers to us">
            same => n,Broadcast(s,DAHDI/1,DAHDI/3,PJSIP/doorphone)
            </example>
            <example title="Combine audio from three channels to us">
            same => n,Broadcast(so,DAHDI/1,DAHDI/3,PJSIP/doorphone)
            </example>
            <example title="Two-way audio with a bunch of channels">
            same => n,Broadcast(wbso,DAHDI/1,DAHDI/3,PJSIP/doorphone)
            </example>
            <para>Note that in the last example above, this is NOT the same as a conference bridge.
            The specified channels are not audible to each other, only to the channel running the
            Broadcast application. The two-way audio is only between the broadcasting channel and
            each of the specified channels, individually.</para>
        </description>
        <see-also>
            <ref type="application">ChanSpy</ref>
        </see-also>
    </application>
 ***/
 
static const char app_broadcast[] = "Broadcast";
 
enum {
    OPTION_READONLY          = (1 << 0),    /* Don't mix the two channels */
    OPTION_BARGE             = (1 << 1),    /* Barge mode (whisper to both channels) */
    OPTION_LONG_QUEUE        = (1 << 2),    /* Allow usage of a long queue to store audio frames. */
    OPTION_WHISPER           = (1 << 3),
    OPTION_SPY               = (1 << 4),
    OPTION_REVERSE_FEED      = (1 << 5),
    OPTION_ANSWER_WARN       = (1 << 6),    /* Internal flag, not set by user */
};
 
AST_APP_OPTIONS(spy_opts, {
    AST_APP_OPTION('b', OPTION_BARGE),
    AST_APP_OPTION('l', OPTION_LONG_QUEUE),
    AST_APP_OPTION('o', OPTION_READONLY),
    AST_APP_OPTION('r', OPTION_REVERSE_FEED),
    AST_APP_OPTION('s', OPTION_SPY),
    AST_APP_OPTION('w', OPTION_WHISPER),
});
 
struct multi_autochan {
    char *name;
    struct ast_autochan *autochan;
    struct ast_autochan *bridge_autochan;
    struct ast_audiohook whisper_audiohook;
    struct ast_audiohook bridge_whisper_audiohook;
    struct ast_audiohook spy_audiohook;
    unsigned int connected:1;
    unsigned int bridge_connected:1;
    unsigned int spying:1;
    AST_LIST_ENTRY(multi_autochan) entry;   /*!< Next record */
};
 
AST_RWLIST_HEAD(multi_autochan_list, multi_autochan);
 
struct multi_spy {
    struct multi_autochan_list *chanlist;
    unsigned int readonly:1;
};
 
static void *spy_alloc(struct ast_channel *chan, void *data)
{
    return data; /* just store the data pointer in the channel structure */
}
 
static void spy_release(struct ast_channel *chan, void *data)
{
    return; /* nothing to do */
}
 
static int spy_generate(struct ast_channel *chan, void *data, int len, int samples)
{
    struct multi_spy *multispy = data;
    struct multi_autochan_list *chanlist = multispy->chanlist;
    struct multi_autochan *mac;
    struct ast_frame *f;
    short *data1, *data2;
    int res, i;
 
    /* All the frames we get are slin, so they will all have the same number of samples. */
    static const int num_samples = 160;
    short combine_buf[num_samples];
    struct ast_frame wf = {
        .frametype = AST_FRAME_VOICE,
        .offset = 0,
        .subclass.format = ast_format_slin,
        .datalen = num_samples * 2,
        .samples = num_samples,
        .src = __FUNCTION__,
    };
 
    memset(&combine_buf, 0, sizeof(combine_buf));
    wf.data.ptr = combine_buf;
 
    AST_RWLIST_WRLOCK(chanlist);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(chanlist, mac, entry) {
        ast_audiohook_lock(&mac->spy_audiohook);
        if (mac->spy_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
            ast_audiohook_unlock(&mac->spy_audiohook); /* Channel is already gone more than likely, the broadcasting channel will clean this up. */
            continue;
        }
 
        if (multispy->readonly) { /* Option 'o' was set, so don't mix channel audio */
            f = ast_audiohook_read_frame(&mac->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_READ, ast_format_slin);
        } else {
            f = ast_audiohook_read_frame(&mac->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_BOTH, ast_format_slin);
        }
        ast_audiohook_unlock(&mac->spy_audiohook);
 
        if (!f) {
            continue; /* No frame? No problem. */
        }
 
        /* Mix the samples. */
        for (i = 0, data1 = combine_buf, data2 = f->data.ptr; i < num_samples; i++, data1++, data2++) {
            ast_slinear_saturated_add(data1, data2);
        }
        ast_frfree(f);
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(chanlist);
 
    res = ast_write(chan, &wf);
    ast_frfree(&wf);
 
    return res;
}
 
static struct ast_generator spygen = {
    .alloc = spy_alloc,
    .release = spy_release,
    .generate = spy_generate,
};
 
static int start_spying(struct ast_autochan *autochan, const char *spychan_name, struct ast_audiohook *audiohook, struct ast_flags *flags)
{
    int res;
 
    ast_autochan_channel_lock(autochan);
    ast_debug(1, "Attaching spy channel %s to %s\n", spychan_name, ast_channel_name(autochan->chan));
 
    if (ast_test_flag(flags, OPTION_READONLY)) {
        ast_set_flag(audiohook, AST_AUDIOHOOK_MUTE_WRITE);
    } else {
        ast_set_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC);
    }
    if (ast_test_flag(flags, OPTION_LONG_QUEUE)) {
        ast_debug(2, "Using a long queue to store audio frames in spy audiohook\n");
    } else {
        ast_set_flag(audiohook, AST_AUDIOHOOK_SMALL_QUEUE);
    }
    res = ast_audiohook_attach(autochan->chan, audiohook);
    ast_autochan_channel_unlock(autochan);
    return res;
}
 
static int attach_barge(struct ast_autochan *spyee_autochan, struct ast_autochan **spyee_bridge_autochan,
    struct ast_audiohook *bridge_whisper_audiohook, const char *spyer_name, const char *name, struct ast_flags *flags)
{
    int retval = 0;
    struct ast_autochan *internal_bridge_autochan;
    struct ast_channel *spyee_chan;
    RAII_VAR(struct ast_channel *, bridged, NULL, ast_channel_cleanup);
 
    ast_autochan_channel_lock(spyee_autochan);
    spyee_chan = ast_channel_ref(spyee_autochan->chan);
    ast_autochan_channel_unlock(spyee_autochan);
 
    /* Note that ast_channel_bridge_peer only returns non-NULL for 2-party bridges, not n-party bridges (e.g. ConfBridge) */
    bridged = ast_channel_bridge_peer(spyee_chan);
    ast_channel_unref(spyee_chan);
    if (!bridged) {
        ast_debug(9, "Channel %s is not yet bridged, unable to setup barge\n", ast_channel_name(spyee_chan));
        /* If we're bridged, but it's not a 2-party bridge, then we probably should have used OPTION_REVERSE_FEED. */
        if (ast_test_flag(flags, OPTION_ANSWER_WARN) && ast_channel_is_bridged(spyee_chan)) {
            ast_clear_flag(flags, OPTION_ANSWER_WARN); /* Don't warn more than once. */
            ast_log(LOG_WARNING, "Barge failed: channel is bridged, but not to a 2-party bridge. Use the 'r' option.\n");
        }
        return -1;
    }
 
    ast_audiohook_init(bridge_whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "Broadcast", 0);
    internal_bridge_autochan = ast_autochan_setup(bridged);
    if (!internal_bridge_autochan) {
        return -1;
    }
 
    if (start_spying(internal_bridge_autochan, spyer_name, bridge_whisper_audiohook, flags)) {
        ast_log(LOG_WARNING, "Unable to attach barge audiohook on spyee '%s'. Barge mode disabled.\n", name);
        retval = -1;
    }
 
    *spyee_bridge_autochan = internal_bridge_autochan;
    return retval;
}
 
static void multi_autochan_free(struct multi_autochan *mac)
{
    if (mac->connected) {
        if (mac->whisper_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
            ast_debug(2, "Whisper audiohook no longer running\n");
        }
        ast_audiohook_lock(&mac->whisper_audiohook);
        ast_audiohook_detach(&mac->whisper_audiohook);
        ast_audiohook_unlock(&mac->whisper_audiohook);
        ast_audiohook_destroy(&mac->whisper_audiohook);
    }
    if (mac->bridge_connected) {
        if (mac->bridge_whisper_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
            ast_debug(2, "Whisper (bridged) audiohook no longer running\n");
        }
        ast_audiohook_lock(&mac->bridge_whisper_audiohook);
        ast_audiohook_detach(&mac->bridge_whisper_audiohook);
        ast_audiohook_unlock(&mac->bridge_whisper_audiohook);
        ast_audiohook_destroy(&mac->bridge_whisper_audiohook);
    }
    if (mac->spying) {
        if (mac->spy_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
            ast_debug(2, "Spy audiohook no longer running\n");
        }
        ast_audiohook_lock(&mac->spy_audiohook);
        ast_audiohook_detach(&mac->spy_audiohook);
        ast_audiohook_unlock(&mac->spy_audiohook);
        ast_audiohook_destroy(&mac->spy_audiohook);
    }
    if (mac->name) {
        int total = mac->connected + mac->bridge_connected + mac->spying;
        ast_debug(1, "Removing channel %s from target list (%d hook%s)\n", mac->name, total, ESS(total));
        ast_free(mac->name);
    }
    if (mac->autochan) {
        ast_autochan_destroy(mac->autochan);
    }
    if (mac->bridge_autochan) {
        ast_autochan_destroy(mac->bridge_autochan);
    }
    ast_free(mac);
}
 
static int do_broadcast(struct ast_channel *chan, struct ast_flags *flags, const char *channels)
{
    int res = 0;
    struct ast_frame *f;
    struct ast_silence_generator *silgen = NULL;
    struct multi_spy multispy;
    struct multi_autochan_list chanlist;
    struct multi_autochan *mac;
    int numchans = 0;
    int readonly = ast_test_flag(flags, OPTION_READONLY) ? 1 : 0;
    char *next, *chansdup = ast_strdupa(channels);
 
    AST_RWLIST_HEAD_INIT(&chanlist);
    ast_channel_set_flag(chan, AST_FLAG_SPYING);
 
    ast_set_flag(flags, OPTION_ANSWER_WARN); /* Initialize answer warn to 1 */
 
    /* Hey, look ma, no list lock needed! Sometimes, it's nice to not have to share... */
 
    /* Build a list of targets */
    while ((next = strsep(&chansdup, ","))) {
        struct ast_channel *ochan;
        if (ast_strlen_zero(next)) {
            continue;
        }
        if (!strcmp(next, ast_channel_name(chan))) {
            ast_log(LOG_WARNING, "Refusing to broadcast to ourself: %s\n", next);
            continue;
        }
        ochan = ast_channel_get_by_name(next);
        if (!ochan) {
            ast_log(LOG_WARNING, "No such channel: %s\n", next);
            continue;
        }
        /* Append to end of list. */
        if (!(mac = ast_calloc(1, sizeof(*mac)))) {
            ast_log(LOG_WARNING, "Multi autochan allocation failure\n");
            continue;
        }
        mac->name = ast_strdup(next);
        mac->autochan = ast_autochan_setup(ochan);
        if (!mac->name || !mac->autochan) {
            multi_autochan_free(mac);
            continue;
        }
        if (ast_test_flag(flags, OPTION_WHISPER)) {
            mac->connected = 1;
            ast_audiohook_init(&mac->whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "Broadcast", 0);
            /* Inject audio from our channel to this target. */
            if (start_spying(mac->autochan, next, &mac->whisper_audiohook, flags)) {
                ast_log(LOG_WARNING, "Unable to attach whisper audiohook to %s\n", next);
                multi_autochan_free(mac);
                continue;
            }
        }
        if (ast_test_flag(flags, OPTION_SPY)) {
            mac->spying = 1;
            ast_audiohook_init(&mac->spy_audiohook, AST_AUDIOHOOK_TYPE_SPY, "Broadcast", 0);
            if (start_spying(mac->autochan, next, &mac->spy_audiohook, flags)) {
                ast_log(LOG_WARNING, "Unable to attach spy audiohook to %s\n", next);
                multi_autochan_free(mac);
                continue;
            }
        }
        AST_RWLIST_INSERT_TAIL(&chanlist, mac, entry);
        numchans++;
        ochan = ast_channel_unref(ochan);
    }
 
    ast_verb(4, "Broadcasting to %d channel%s on %s\n", numchans, ESS(numchans), ast_channel_name(chan));
    ast_debug(1, "Broadcasting: (TX->1) whisper=%d, (TX->2) barge=%d, (RX<-%d) spy=%d (%s)\n",
        ast_test_flag(flags, OPTION_WHISPER) ? 1 : 0,
        ast_test_flag(flags, OPTION_BARGE) ? 1 : 0,
        readonly ? 1 : 2,
        ast_test_flag(flags, OPTION_SPY) ? 1 : 0,
        readonly ? "single" : "both");
 
    if (ast_test_flag(flags, OPTION_SPY)) {
        multispy.chanlist = &chanlist;
        multispy.readonly = readonly;
        ast_activate_generator(chan, &spygen, &multispy);
    } else {
        /* We're not expecting to read any audio, just broadcast audio to a bunch of other channels. */
        silgen = ast_channel_start_silence_generator(chan);
    }
 
    while (numchans && ast_waitfor(chan, -1) > 0) {
        int fres = 0;
        f = ast_read(chan);
        if (!f) {
            ast_debug(1, "Channel %s must have hung up\n", ast_channel_name(chan));
            res = -1;
            break;
        }
        if (f->frametype != AST_FRAME_VOICE) { /* Ignore any non-voice frames */
            ast_frfree(f);
            continue;
        }
        /* Write the frame to all our targets. */
        AST_RWLIST_WRLOCK(&chanlist);
        AST_RWLIST_TRAVERSE_SAFE_BEGIN(&chanlist, mac, entry) {
            /* Note that if no media is received, execution is suspended, but assuming continuous or
             * or frequent audio on the broadcasting channel, we'll quickly enough detect hung up targets.
             * This isn't really an issue, just something that might be confusing at first, but this is
             * due to the limitation with audiohooks of using the channel for timing. */
            if ((ast_test_flag(flags, OPTION_WHISPER) && mac->whisper_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING)
                || (ast_test_flag(flags, OPTION_SPY) && mac->spy_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING)
                || (mac->bridge_connected && ast_test_flag(flags, OPTION_BARGE) && mac->bridge_whisper_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING)) {
                /* Even if we're spying only and not actually broadcasting audio, we need to detect channel hangup. */
                AST_RWLIST_REMOVE_CURRENT(entry);
                ast_debug(2, "Looks like %s has hung up\n", mac->name);
                multi_autochan_free(mac);
                numchans--;
                ast_debug(2, "%d channel%s remaining in broadcast on %s\n", numchans, ESS(numchans), ast_channel_name(chan));
                continue;
            }
 
            if (ast_test_flag(flags, OPTION_WHISPER)) {
                ast_audiohook_lock(&mac->whisper_audiohook);
                fres |= ast_audiohook_write_frame(&mac->whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
                ast_audiohook_unlock(&mac->whisper_audiohook);
            }
 
            if (ast_test_flag(flags, OPTION_BARGE)) {
                /* This hook lets us inject audio into the channel that the spyee is currently
                 * bridged with. If the spyee isn't bridged with anything yet, nothing will
                 * be attached and we'll need to continue attempting to attach the barge
                 * audio hook.
                 * The exception to this is if we are emulating barge by doing it "directly",
                 * that is injecting the frames onto this channel's read queue, rather than
                 * its bridged peer's write queue, then skip this. We only do one or the other. */
                if (!ast_test_flag(flags, OPTION_REVERSE_FEED) && !mac->bridge_connected && !attach_barge(mac->autochan, &mac->bridge_autochan,
                        &mac->bridge_whisper_audiohook, ast_channel_name(chan), mac->name, flags)) {
                    ast_debug(2, "Attached barge channel for %s\n", mac->name);
                    mac->bridge_connected = 1;
                }
 
                if (mac->bridge_connected) {
                    ast_audiohook_lock(&mac->bridge_whisper_audiohook);
                    fres |= ast_audiohook_write_frame(&mac->bridge_whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
                    ast_audiohook_unlock(&mac->bridge_whisper_audiohook);
                } else if (ast_test_flag(flags, OPTION_REVERSE_FEED)) {
                    /* So, this is really clever...
                     * If we're connected to an n-party bridge instead of a 2-party bridge,
                     * attach_barge will ALWAYS fail because we're connected to a bridge, not
                     * a single peer channel.
                     * Recall that the objective is for injected audio to be audible to both
                     * sides of the channel. So really, the typical way of doing this by
                     * directly injecting frames separately onto both channels is kind of
                     * bizarre to begin with, when you think about it.
                     *
                     * In other words, this is how ChanSpy and this module by default work:
                     * We have audio F to inject onto channels A and B, which are <= bridged =>:
                     * READ <- A -> WRITE <==> READ <- B -> WRITE
                     *            F --^                  F --^
                     *
                     * So that makes the same audio audible to both channels A and B, but
                     * in kind of a roundabout way. What if the bridged peer changes at
                     * some point, for example?
                     *
                     * While that method works for 2-party bridges, it doesn't work at all
                     * for an n-party bridge, so we do the thing that seems obvious to begin with:
                     * dump the frames onto THIS channel's read queue, and the channels will
                     * make their way into the bridge like any other audio from this channel,
                     * and everything just works perfectly, no matter what kind of bridging
                     * scenario is being used. At that point, we don't even care if we're
                     * bridged or not, and really, why should we?
                     *
                     * In other words, we do this:
                     * READ <- A -> WRITE <==> READ <- B -> WRITE
                     *                       F --^       F --^
                     */
                    ast_audiohook_lock(&mac->whisper_audiohook);
                    fres |= ast_audiohook_write_frame(&mac->whisper_audiohook, AST_AUDIOHOOK_DIRECTION_READ, f);
                    ast_audiohook_unlock(&mac->whisper_audiohook);
                }
            }
            if (fres) {
                ast_log(LOG_WARNING, "Failed to write to audiohook for %s\n", mac->name);
                fres = 0;
            }
        }
        AST_RWLIST_TRAVERSE_SAFE_END;
        AST_RWLIST_UNLOCK(&chanlist);
        ast_frfree(f);
    }
 
    if (!numchans) {
        ast_debug(1, "Exiting due to all target channels having left the broadcast\n");
    }
 
    if (ast_test_flag(flags, OPTION_SPY)) {
        ast_deactivate_generator(chan);
    } else {
        ast_channel_stop_silence_generator(chan, silgen);
    }
 
    /* Cleanup any remaining targets */
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&chanlist, mac, entry) {
        AST_RWLIST_REMOVE_CURRENT(entry);
        multi_autochan_free(mac);
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    ast_channel_clear_flag(chan, AST_FLAG_SPYING);
    return res;
}
 
static int broadcast_exec(struct ast_channel *chan, const char *data)
{
    struct ast_flags flags;
    struct ast_format *write_format;
    int res = -1;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(options);
        AST_APP_ARG(channels); /* Channel list last, so we can have multiple */
    );
    char *parse = NULL;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "Broadcast requires at least one channel\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.channels)) {
        ast_log(LOG_WARNING, "Must specify at least one channel for broadcast\n");
        return -1;
    }
    if (args.options) {
        ast_app_parse_options(spy_opts, &flags, NULL, args.options);
    } else {
        ast_clear_flag(&flags, AST_FLAGS_ALL);
    }
 
    if (!ast_test_flag(&flags, OPTION_BARGE) && !ast_test_flag(&flags, OPTION_SPY) && !ast_test_flag(&flags, OPTION_WHISPER)) {
        ast_log(LOG_WARNING, "At least one of the b, s, or w option must be specified (provided options have no effect)\n");
        return -1;
    }
 
    write_format = ao2_bump(ast_channel_writeformat(chan));
    if (ast_set_write_format(chan, ast_format_slin) < 0) {
        ast_log(LOG_ERROR, "Failed to set write format to slin.\n");
        goto cleanup;
    }
 
    res = do_broadcast(chan, &flags, args.channels);
 
    /* Restore previous write format */
    if (ast_set_write_format(chan, write_format)) {
        ast_log(LOG_ERROR, "Failed to restore write format for channel %s\n", ast_channel_name(chan));
    }
 
cleanup:
    ao2_ref(write_format, -1);
    return res;
}
 
static int unload_module(void)
{
    return ast_unregister_application(app_broadcast);
}
 
static int load_module(void)
{
    return ast_register_application_xml(app_broadcast, broadcast_exec);
}
 
AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Channel Audio Broadcasting");