res_mutestream.c File Reference

MUTESTREAM audiohooks. More...

#include "asterisk.h"
#include "asterisk/options.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/file.h"
#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/utils.h"
#include "asterisk/audiohook.h"
#include "asterisk/manager.h"

Include dependency graph for res_mutestream.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	func_mute_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Mute dialplan function.
static int	load_module (void)
static int	manager_mutestream (struct mansession *s, const struct message *m)
static int	mute_channel (struct ast_channel *chan, const char *direction, int mute)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Mute audio stream resources" , .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_custom_function	mute_function

Detailed Description

MUTESTREAM audiohooks.

Author

Olle E. Johansson oej@e.nosp@m.dvin.nosp@m.a.net

Note

This module only handles audio streams today, but can easily be appended to also zero out text streams if there's an application for it. When we know and understand what happens if we zero out video, we can do that too.

Definition in file res_mutestream.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 241 of file res_mutestream.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 241 of file res_mutestream.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 241 of file res_mutestream.c.

func_mute_write()

static int func_mute_write ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Mute dialplan function.

Definition at line 157 of file res_mutestream.c.

{
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    return mute_channel(chan, data, ast_true(value));
}

References ast_log, ast_true(), LOG_WARNING, mute_channel(), and value.

load_module()

static int load_module ( void  )

static

Definition at line 222 of file res_mutestream.c.

{
    int res;
 
    res = ast_custom_function_register(&mute_function);
    res |= ast_manager_register_xml("MuteAudio", EVENT_FLAG_SYSTEM, manager_mutestream);
 
    return (res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS);
}

References ast_custom_function_register, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, EVENT_FLAG_SYSTEM, manager_mutestream(), and mute_function.

manager_mutestream()

static int manager_mutestream ( struct mansession *  s, const struct message *  m  )

static

Definition at line 173 of file res_mutestream.c.

{
    const char *channel = astman_get_header(m, "Channel");
    const char *id = astman_get_header(m,"ActionID");
    const char *state = astman_get_header(m,"State");
    const char *direction = astman_get_header(m,"Direction");
    char id_text[256];
    struct ast_channel *c = NULL;
 
    if (ast_strlen_zero(channel)) {
        astman_send_error(s, m, "Channel not specified");
        return 0;
    }
    if (ast_strlen_zero(state)) {
        astman_send_error(s, m, "State not specified");
        return 0;
    }
    if (ast_strlen_zero(direction)) {
        astman_send_error(s, m, "Direction not specified");
        return 0;
    }
    /* Ok, we have everything */
 
    c = ast_channel_get_by_name(channel);
    if (!c) {
        astman_send_error(s, m, "No such channel");
        return 0;
    }
 
    if (mute_channel(c, direction, ast_true(state))) {
        astman_send_error(s, m, "Failed to mute/unmute stream");
        ast_channel_unref(c);
        return 0;
    }
 
    ast_channel_unref(c);
 
    if (!ast_strlen_zero(id)) {
        snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
    } else {
        id_text[0] = '\0';
    }
    astman_append(s, "Response: Success\r\n"
        "%s"
        "\r\n", id_text);
    return 0;
}

References ast_channel_get_by_name(), ast_channel_unref, ast_strlen_zero(), ast_true(), astman_append(), astman_get_header(), astman_send_error(), c, mute_channel(), and NULL.

Referenced by load_module().

mute_channel()

static int mute_channel ( struct ast_channel *  chan, const char *  direction, int  mute  )

static

Definition at line 127 of file res_mutestream.c.

{
    unsigned int mute_direction = 0;
    enum ast_frame_type frametype = AST_FRAME_VOICE;
    int ret = 0;
 
    if (!strcmp(direction, "in")) {
        mute_direction = AST_MUTE_DIRECTION_READ;
    } else if (!strcmp(direction, "out")) {
        mute_direction = AST_MUTE_DIRECTION_WRITE;
    } else if (!strcmp(direction, "all")) {
        mute_direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
    } else {
        return -1;
    }
 
    ast_channel_lock(chan);
 
    if (mute) {
        ret = ast_channel_suppress(chan, mute_direction, frametype);
    } else {
        ret = ast_channel_unsuppress(chan, mute_direction, frametype);
    }
 
    ast_channel_unlock(chan);
 
    return ret;
}

References ast_channel_lock, ast_channel_suppress(), ast_channel_unlock, ast_channel_unsuppress(), AST_FRAME_VOICE, AST_MUTE_DIRECTION_READ, and AST_MUTE_DIRECTION_WRITE.

Referenced by func_mute_write(), and manager_mutestream().

unload_module()

static int unload_module ( void  )

static

Definition at line 232 of file res_mutestream.c.

{
    ast_custom_function_unregister(&mute_function);
    /* Unregister AMI actions */
    ast_manager_unregister("MuteAudio");
 
    return 0;
}

References ast_custom_function_unregister(), ast_manager_unregister(), and mute_function.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Mute audio stream resources" , .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 241 of file res_mutestream.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 241 of file res_mutestream.c.

mute_function

struct ast_custom_function mute_function

static

Initial value:

= {
    .name = "MUTEAUDIO",
    .write = func_mute_write,
}

Definition at line 168 of file res_mutestream.c.

                                                  {
    .name = "MUTEAUDIO",
    .write = func_mute_write,
};

Referenced by load_module(), and unload_module().