app_stream_echo.c File Reference

Stream echo application. More...

#include "asterisk.h"
#include "asterisk/app.h"
#include "asterisk/conversions.h"
#include "asterisk/file.h"
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/stream.h"

Include dependency graph for app_stream_echo.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	stream_echo_exec (struct ast_channel *chan, const char *data)
static int	stream_echo_perform (struct ast_channel *chan, struct ast_stream_topology *topology, enum ast_media_type type)
static struct ast_stream_topology *	stream_echo_topology_alloc (struct ast_stream_topology *original, unsigned int num, enum ast_media_type type)
static int	stream_echo_write (struct ast_channel *chan, struct ast_frame *frame, enum ast_media_type type, int one_to_one)
static int	stream_echo_write_error (struct ast_channel *chan, struct ast_frame *frame, int pos)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Stream Echo Application" , .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 char	app [] = "StreamEcho"
static const struct ast_module_info *	ast_module_info = &__mod_info

Detailed Description

Stream echo application.

Author

Kevin Harwell kharw.nosp@m.ell@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file app_stream_echo.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 348 of file app_stream_echo.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 348 of file app_stream_echo.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 348 of file app_stream_echo.c.

load_module()

static int load_module ( void  )

static

Definition at line 343 of file app_stream_echo.c.

{
    return ast_register_application_xml(app, stream_echo_exec);
}

References app, ast_register_application_xml, and stream_echo_exec().

stream_echo_exec()

static int stream_echo_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 287 of file app_stream_echo.c.

{
    int res;
    unsigned int num = 0;
    enum ast_media_type type;
    char *parse;
    struct ast_stream_topology *topology;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(num);
        AST_APP_ARG(type);
    );
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.num)) {
        /*
         * If a number is not given then no topology is to be created
         * and renegotiated. The app will just echo back each stream
         * received to itself.
         */
        return stream_echo_perform(chan, NULL, AST_MEDIA_TYPE_UNKNOWN);
    }
 
    if (ast_str_to_uint(args.num, &num)) {
        ast_log(LOG_ERROR, "Failed to parse the first parameter '%s' into a"
            " greater than or equal to zero\n", args.num);
        return -1;
    }
 
    type = ast_strlen_zero(args.type) ? AST_MEDIA_TYPE_VIDEO :
        ast_media_type_from_str(args.type);
 
    topology = stream_echo_topology_alloc(
        ast_channel_get_stream_topology(chan), num, type);
    if (!topology) {
        ast_log(LOG_ERROR, "Unable to create '%u' streams of type '%s' to"
            " the topology\n", num, ast_codec_media_type2str(type));
        return -1;
    }
 
    res = stream_echo_perform(chan, topology, type);
 
    if (ast_channel_get_stream_topology(chan) != topology) {
        ast_stream_topology_free(topology);
    }
 
    return res;
}

References args, AST_APP_ARG, ast_channel_get_stream_topology(), ast_codec_media_type2str(), AST_DECLARE_APP_ARGS, ast_log, ast_media_type_from_str(), AST_MEDIA_TYPE_UNKNOWN, AST_MEDIA_TYPE_VIDEO, AST_STANDARD_APP_ARGS, ast_str_to_uint(), ast_strdupa, ast_stream_topology_free(), ast_strlen_zero(), LOG_ERROR, NULL, stream_echo_perform(), stream_echo_topology_alloc(), and type.

Referenced by load_module().

stream_echo_perform()

static int stream_echo_perform ( struct ast_channel *  chan, struct ast_stream_topology *  topology, enum ast_media_type  type  )

static

Definition at line 157 of file app_stream_echo.c.

{
    int update_sent = 0;
    int request_change = topology != NULL;
    int one_to_one = 1;
 
    while (ast_waitfor(chan, -1) > -1) {
        struct ast_frame *f;
 
        if (request_change) {
            /* Request a change to the new topology */
            if (ast_channel_request_stream_topology_change(chan, topology, NULL)) {
                ast_log(LOG_WARNING, "Request stream topology change not supported "
                    "by channel '%s'\n", ast_channel_name(chan));
            }
            request_change = 0;
        }
 
        f = ast_read_stream(chan);
        if (!f) {
            return -1;
        }
 
        if ((f->frametype == AST_FRAME_DTMF) && (f->subclass.integer == '#')) {
            ast_frfree(f);
            break;
        }
 
        f->delivery.tv_sec = 0;
        f->delivery.tv_usec = 0;
 
        if (f->frametype == AST_FRAME_CONTROL) {
            if (f->subclass.integer == AST_CONTROL_VIDUPDATE && !update_sent) {
                if (stream_echo_write(chan, f, type, one_to_one)) {
                    ast_frfree(f);
                    return -1;
                }
                update_sent = 1;
            } else if (f->subclass.integer == AST_CONTROL_SRCCHANGE) {
                update_sent = 0;
            } else if (f->subclass.integer == AST_CONTROL_STREAM_TOPOLOGY_CHANGED) {
                update_sent = 0;
                one_to_one = 0; /* Switch writing to one to many */
            }
        } else if (f->frametype == AST_FRAME_VIDEO && !update_sent){
            struct ast_frame frame = {
                .frametype = AST_FRAME_CONTROL,
                .subclass.integer = AST_CONTROL_VIDUPDATE,
            };
            stream_echo_write(chan, &frame, type, one_to_one);
            update_sent = 1;
        }
 
        if (f->frametype != AST_FRAME_CONTROL &&
            f->frametype != AST_FRAME_MODEM &&
            f->frametype != AST_FRAME_NULL &&
            stream_echo_write(chan, f, type, one_to_one)) {
            ast_frfree(f);
            return -1;
        }
 
        ast_frfree(f);
    }
 
    return 0;
}

References ast_channel_name(), ast_channel_request_stream_topology_change(), AST_CONTROL_SRCCHANGE, AST_CONTROL_STREAM_TOPOLOGY_CHANGED, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_MODEM, AST_FRAME_NULL, AST_FRAME_VIDEO, ast_frfree, ast_log, ast_read_stream(), ast_waitfor(), ast_frame::delivery, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, NULL, stream_echo_write(), ast_frame::subclass, and type.

Referenced by stream_echo_exec().

stream_echo_topology_alloc()

static struct ast_stream_topology * stream_echo_topology_alloc ( struct ast_stream_topology *  original, unsigned int  num, enum ast_media_type  type  )

static

Definition at line 225 of file app_stream_echo.c.

{
    int i, n = num;
    struct ast_stream_topology *res = ast_stream_topology_alloc();
 
    if (!res) {
        return NULL;
    }
 
    /*
     * Clone every stream of a type not matching the given one. If the type
     * matches clone only the first stream found for the given type. Then for
     * that stream clone it again up to num - 1 times. Ignore any other streams
     * of the same matched type in the original topology.
     *
     * So for instance if the original stream contains 1 audio stream and 2 video
     * streams (video stream 'A' and video stream 'B'), num is '3', and the given
     * type is 'video' then the resulting topology will contain a clone of the
     * audio stream along with 3 clones of video stream 'A'. Video stream 'B' is
     * not copied over.
     */
    for (i = 0; i < ast_stream_topology_get_count(original); ++i) {
        struct ast_stream *stream = ast_stream_topology_get_stream(original, i);
 
        if (!n && ast_stream_get_type(stream) == type) {
            /* Don't copy any[more] of the given type */
            continue;
        }
 
        if (ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
            /* Don't copy removed/declined streams */
            continue;
        }
 
        do {
            stream = ast_stream_clone(stream, NULL);
 
            if (!stream || ast_stream_topology_append_stream(res, stream) < 0) {
                ast_stream_free(stream);
                ast_stream_topology_free(res);
                return NULL;
            }
 
            if (ast_stream_get_type(stream) != type) {
                /* Do not multiply non matching streams */
                break;
            }
 
            /*
             * Since num is not zero yet (i.e. this is first stream found to
             * match on the type) and the types match then loop num - 1 times
             * cloning the same stream.
             */
            ast_stream_set_state(stream, n == num ?
                 AST_STREAM_STATE_SENDRECV : AST_STREAM_STATE_SENDONLY);
        } while (--n);
    }
 
    return res;
}

References ast_stream_clone(), ast_stream_free(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_set_state(), AST_STREAM_STATE_REMOVED, AST_STREAM_STATE_SENDONLY, AST_STREAM_STATE_SENDRECV, ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), NULL, and type.

Referenced by stream_echo_exec().

stream_echo_write()

static int stream_echo_write ( struct ast_channel *  chan, struct ast_frame *  frame, enum ast_media_type  type, int  one_to_one  )

static

Definition at line 102 of file app_stream_echo.c.

{
    int i;
    int num;
    struct ast_stream_topology *topology;
 
    /*
     * Since this is an echo application if we get a frame in on a stream
     * we simply want to echo it back out onto the same stream number.
     */
    num = ast_channel_is_multistream(chan) ? frame->stream_num : -1;
    if (ast_write_stream(chan, num, frame)) {
        return stream_echo_write_error(chan, frame, num);
    }
 
    /*
     * If the frame's type and given type don't match, or we are operating in
     * a one to one stream echo mode then there is nothing left to do.
     *
     * Note, if the channel is not multi-stream capable then one_to_one will
     * always be true, so it is safe to also not check for that here too.
     */
    if (one_to_one || !frame->subclass.format ||
        ast_format_get_type(frame->subclass.format) != type) {
        return 0;
    }
 
    /*
     * However, if we are operating in a single stream echoed to many stream
     * mode, and the frame's type matches the given type then we also need to
     * find the other streams of the same type and write out to those streams
     * as well.
     *
     * If we are here, then it's accepted that whatever stream number the frame
     * was read from for the given type is the only one set to send/receive,
     * while the others of the same type are set to receive only. Since we
     * shouldn't assume any order to the streams, we'll loop back through all
     * streams in the channel's topology writing only to those of the same type.
     * And, of course also not the stream which has already been written to.
     */
    topology = ast_channel_get_stream_topology(chan);
 
    for (i = 0; i < ast_stream_topology_get_count(topology); ++i) {
        struct ast_stream *stream = ast_stream_topology_get_stream(topology, i);
        if (num != i && ast_stream_get_type(stream) == type) {
            if (ast_write_stream(chan, i, frame)) {
                return stream_echo_write_error(chan, frame, i);
            }
        }
    }
 
    return 0;
}

References ast_channel_get_stream_topology(), ast_channel_is_multistream(), ast_format_get_type(), ast_stream_get_type(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_write_stream(), ast_frame_subclass::format, stream_echo_write_error(), ast_frame::stream_num, ast_frame::subclass, and type.

Referenced by stream_echo_perform().

stream_echo_write_error()

static int stream_echo_write_error ( struct ast_channel *  chan, struct ast_frame *  frame, int  pos  )

static

Definition at line 81 of file app_stream_echo.c.

{
    char frame_type[32];
    const char *media_type;
    struct ast_stream *stream;
 
    ast_frame_type2str(frame->frametype, frame_type, sizeof(frame_type));
 
    stream = pos < 0 ?
        ast_channel_get_default_stream(chan, ast_format_get_type(frame->subclass.format)) :
        ast_stream_topology_get_stream(ast_channel_get_stream_topology(chan), pos);
 
    media_type = ast_codec_media_type2str(ast_stream_get_type(stream));
 
    ast_log(LOG_ERROR, "%s - unable to write frame type '%s' to stream type '%s' at "
        "position '%d'\n", ast_channel_name(chan), frame_type, media_type,
        ast_stream_get_position(stream));
 
    return -1;
}

References ast_channel_get_default_stream(), ast_channel_get_stream_topology(), ast_channel_name(), ast_codec_media_type2str(), ast_format_get_type(), ast_frame_type2str(), ast_log, ast_stream_get_position(), ast_stream_get_type(), ast_stream_topology_get_stream(), ast_frame_subclass::format, ast_frame::frametype, LOG_ERROR, and ast_frame::subclass.

Referenced by stream_echo_write().

unload_module()

static int unload_module ( void  )

static

Definition at line 338 of file app_stream_echo.c.

{
    return ast_unregister_application(app);
}

References app, and ast_unregister_application().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Stream Echo Application" , .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 348 of file app_stream_echo.c.

app

const char app[] = "StreamEcho"

static

Definition at line 79 of file app_stream_echo.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 348 of file app_stream_echo.c.