func_volume.c File Reference

Technology independent volume control. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/utils.h"
#include "asterisk/audiohook.h"
#include "asterisk/app.h"

Include dependency graph for func_volume.c:

Go to the source code of this file.

Data Structures
struct	volume_information

Enumerations
enum	volume_flags { VOLUMEFLAG_CHANGE = (1 << 1) }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	destroy_callback (void *data)
static int	load_module (void)
static int	unload_module (void)
static int	volume_callback (struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
static int	volume_read (struct ast_channel *chan, const char *cmd, char *data, char *buffer, size_t buflen)
static int	volume_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Technology independent volume control" , .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 const struct ast_datastore_info	volume_datastore
	Static structure for datastore information.
static struct ast_custom_function	volume_function
static const struct ast_app_option	volume_opts [128] = { [ 'p' ] = { .flag = VOLUMEFLAG_CHANGE }, }

Detailed Description

Technology independent volume control.

Author

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

Definition in file func_volume.c.

Enumeration Type Documentation

volume_flags

enum volume_flags

Enumerator
VOLUMEFLAG_CHANGE

Definition at line 94 of file func_volume.c.

                  {
    VOLUMEFLAG_CHANGE = (1 << 1),
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 301 of file func_volume.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 301 of file func_volume.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 301 of file func_volume.c.

destroy_callback()

static void destroy_callback ( void *  data )

static

Definition at line 102 of file func_volume.c.

{
    struct volume_information *vi = data;
 
    /* Destroy the audiohook, and destroy ourselves */
    ast_audiohook_lock(&vi->audiohook);
    ast_audiohook_detach(&vi->audiohook);
    ast_audiohook_unlock(&vi->audiohook);
    ast_audiohook_destroy(&vi->audiohook);
    ast_free(vi);
 
    return;
}

References ast_audiohook_destroy(), ast_audiohook_detach(), ast_audiohook_lock, ast_audiohook_unlock, ast_free, and volume_information::audiohook.

load_module()

static int load_module ( void  )

static

Definition at line 296 of file func_volume.c.

{
    return ast_custom_function_register(&volume_function);
}

References ast_custom_function_register, and volume_function.

unload_module()

static int unload_module ( void  )

static

Definition at line 291 of file func_volume.c.

{
    return ast_custom_function_unregister(&volume_function);
}

References ast_custom_function_unregister(), and volume_function.

volume_callback()

static int volume_callback ( struct ast_audiohook *  audiohook, struct ast_channel *  chan, struct ast_frame *  frame, enum ast_audiohook_direction  direction  )

static

Definition at line 122 of file func_volume.c.

{
    struct ast_datastore *datastore = NULL;
    struct volume_information *vi = NULL;
    float *gain = NULL;
 
    /* If the audiohook is stopping it means the channel is shutting down.... but we let the datastore destroy take care of it */
    if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE)
        return 0;
 
    /* Grab datastore which contains our gain information */
    if (!(datastore = ast_channel_datastore_find(chan, &volume_datastore, NULL)))
        return 0;
 
    vi = datastore->data;
 
    /* If this is DTMF then allow them to increase/decrease the gains */
    if (ast_test_flag(vi, VOLUMEFLAG_CHANGE)) {
        if (frame->frametype == AST_FRAME_DTMF) {
            /* Only use DTMF coming from the source... not going to it */
            if (direction != AST_AUDIOHOOK_DIRECTION_READ)
                return 0;
            if (frame->subclass.integer == '*') {
                vi->tx_gain += 1;
                vi->rx_gain += 1;
            } else if (frame->subclass.integer == '#') {
                vi->tx_gain -= 1;
                vi->rx_gain -= 1;
            }
        }
    }
 
 
    if (frame->frametype == AST_FRAME_VOICE) {
        /* Based on direction of frame grab the gain, and confirm it is applicable */
        if (!(gain = (direction == AST_AUDIOHOOK_DIRECTION_READ) ? &vi->rx_gain : &vi->tx_gain) || !*gain)
            return 0;
        /* Apply gain to frame... easy as pi */
        ast_frame_adjust_volume_float(frame, *gain);
    }
 
    return 0;
}

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_STATUS_DONE, ast_channel_datastore_find(), ast_frame_adjust_volume_float(), AST_FRAME_DTMF, AST_FRAME_VOICE, ast_test_flag, volume_information::audiohook, ast_datastore::data, ast_frame::frametype, ast_frame_subclass::integer, NULL, volume_information::rx_gain, ast_audiohook::status, ast_frame::subclass, volume_information::tx_gain, volume_datastore, and VOLUMEFLAG_CHANGE.

Referenced by volume_write().

volume_read()

static int volume_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buffer, size_t  buflen  )

static

Definition at line 240 of file func_volume.c.

{
    struct ast_datastore *datastore = NULL;
    struct volume_information *vi = NULL;
 
    /* Separate options from argument */
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(direction);
        AST_APP_ARG(options);
    );
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    ast_channel_lock(chan);
    if (!(datastore = ast_channel_datastore_find(chan, &volume_datastore, NULL))) {
        ast_channel_unlock(chan);
        return -1; /* no active audiohook, nothing to read */
    } else {
        ast_channel_unlock(chan);
        vi = datastore->data;
    }
 
    /* Obtain current gain using volume information structure */
    if (ast_strlen_zero(args.direction)) {
        ast_log(LOG_ERROR, "Direction must be specified for VOLUME function\n");
        return -1;
    }
 
    if (!strcasecmp(args.direction, "tx")) {
        snprintf(buffer, buflen, "%f", vi->tx_gain);
    } else if (!strcasecmp(args.direction, "rx")) {
        snprintf(buffer, buflen, "%f", vi->rx_gain);
    } else {
        ast_log(LOG_ERROR, "Direction must be either RX or TX\n");
    }
 
    return 0;
}

References args, AST_APP_ARG, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), ast_datastore::data, LOG_ERROR, LOG_WARNING, NULL, options, volume_information::rx_gain, volume_information::tx_gain, and volume_datastore.

volume_write()

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

static

Definition at line 166 of file func_volume.c.

{
    struct ast_datastore *datastore = NULL;
    struct volume_information *vi = NULL;
    int is_new = 0;
 
    /* Separate options from argument */
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(direction);
        AST_APP_ARG(options);
    );
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    ast_channel_lock(chan);
    if (!(datastore = ast_channel_datastore_find(chan, &volume_datastore, NULL))) {
        ast_channel_unlock(chan);
        /* Allocate a new datastore to hold the reference to this volume and audiohook information */
        if (!(datastore = ast_datastore_alloc(&volume_datastore, NULL)))
            return 0;
        if (!(vi = ast_calloc(1, sizeof(*vi)))) {
            ast_datastore_free(datastore);
            return 0;
        }
        ast_audiohook_init(&vi->audiohook, AST_AUDIOHOOK_TYPE_MANIPULATE, "Volume", AST_AUDIOHOOK_MANIPULATE_ALL_RATES);
        vi->audiohook.manipulate_callback = volume_callback;
        ast_set_flag(&vi->audiohook, AST_AUDIOHOOK_WANTS_DTMF);
        is_new = 1;
    } else {
        ast_channel_unlock(chan);
        vi = datastore->data;
    }
 
    /* Adjust gain on volume information structure */
    if (ast_strlen_zero(args.direction)) {
        ast_log(LOG_ERROR, "Direction must be specified for VOLUME function\n");
        return -1;
    }
 
    if (!strcasecmp(args.direction, "tx")) {
        vi->tx_gain = atof(value);
    } else if (!strcasecmp(args.direction, "rx")) {
        vi->rx_gain = atof(value);
    } else {
        ast_log(LOG_ERROR, "Direction must be either RX or TX\n");
    }
 
    if (is_new) {
        datastore->data = vi;
        ast_channel_lock(chan);
        ast_channel_datastore_add(chan, datastore);
        ast_channel_unlock(chan);
        ast_audiohook_attach(chan, &vi->audiohook);
    }
 
    /* Add Option data to struct */
 
    if (!ast_strlen_zero(args.options)) {
        struct ast_flags flags = { 0 };
        ast_app_parse_options(volume_opts, &flags, NULL, args.options);
        vi->flags = flags.flags;
    } else {
        vi->flags = 0;
    }
 
    return 0;
}

References args, AST_APP_ARG, ast_app_parse_options(), ast_audiohook_attach(), ast_audiohook_init(), AST_AUDIOHOOK_MANIPULATE_ALL_RATES, AST_AUDIOHOOK_TYPE_MANIPULATE, AST_AUDIOHOOK_WANTS_DTMF, ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), AST_DECLARE_APP_ARGS, ast_log, ast_set_flag, AST_STANDARD_APP_ARGS, ast_strlen_zero(), volume_information::audiohook, ast_datastore::data, volume_information::flags, ast_flags::flags, LOG_ERROR, LOG_WARNING, ast_audiohook::manipulate_callback, NULL, options, volume_information::rx_gain, volume_information::tx_gain, value, volume_callback(), volume_datastore, and volume_opts.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Technology independent volume control" , .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 301 of file func_volume.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 301 of file func_volume.c.

volume_datastore

const struct ast_datastore_info volume_datastore

static

Initial value:

= {
    .type = "volume",
    .destroy = destroy_callback
}

Static structure for datastore information.

Definition at line 117 of file func_volume.c.

                                                          {
    .type = "volume",
    .destroy = destroy_callback
};

Referenced by volume_callback(), volume_read(), and volume_write().

volume_function

struct ast_custom_function volume_function

static

Initial value:

= {
    .name = "VOLUME",
    .write = volume_write,
    .read = volume_read,
}

Definition at line 285 of file func_volume.c.

                                                    {
    .name = "VOLUME",
    .write = volume_write,
    .read = volume_read,
};

Referenced by load_module(), and unload_module().

volume_opts

const struct ast_app_option volume_opts[128] = { [ 'p' ] = { .flag = VOLUMEFLAG_CHANGE }, }

static

Definition at line 100 of file func_volume.c.

Referenced by volume_write().