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.

Data Structures
struct	mute_information
Defines
#define	FALSE 0
#define	TRUE 1
Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	destroy_callback (void *data)
static int	func_mute_write (struct ast_channel chan, const char cmd, char data, const char value)
	Mute dialplan function.
static struct ast_datastore *	initialize_mutehook (struct ast_channel *chan)
	Initialize mute hook on channel, but don't activate it.
static int	load_module (void)
static int	manager_mutestream (struct mansession s, const struct message m)
static int	mute_add_audiohook (struct ast_channel chan, struct mute_information mute, struct ast_datastore *datastore)
	Add or activate mute audiohook on channel Assumes channel is locked.
static int	mute_callback (struct ast_audiohook audiohook, struct ast_channel chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
	The callback from the audiohook subsystem. We basically get a frame to have fun with.
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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, }
static struct ast_module_info *	ast_module_info = &__mod_info
static const char	mandescr_mutestream [] = " ActionID: <id> Optional action ID for this AMI transaction.\n"
static struct ast_datastore_info	mute_datastore
	Static structure for datastore information.
static struct ast_custom_function	mute_function

Detailed Description

MUTESTREAM audiohooks.

Author:: Olle E. Johansson <oej@edvina.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 understands what happens if we zero out video, we can do that too.

Definition in file res_mutestream.c.

Define Documentation

#define FALSE 0

Definition at line 102 of file res_mutestream.c.

#define TRUE 1

Definition at line 101 of file res_mutestream.c.

Referenced by manager_mutestream().

Function Documentation

static void __reg_module ( void ) [static]

Definition at line 351 of file res_mutestream.c.

static void __unreg_module ( void ) [static]

Definition at line 351 of file res_mutestream.c.

static void destroy_callback ( void * data ) [static]

Datastore destroy audiohook callback

Definition at line 105 of file res_mutestream.c.

References ast_audiohook_destroy(), ast_free, ast_module_unref(), mute_information::audiohook, mute, and ast_module_info::self.

{
   struct mute_information *mute = data;

   /* Destroy the audiohook, and destroy ourselves */
   ast_audiohook_destroy(&mute->audiohook);
   ast_free(mute);
   ast_module_unref(ast_module_info->self);

   return;
}

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

Mute dialplan function.

Definition at line 203 of file res_mutestream.c.

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_datastore_free(), ast_debug, ast_free, ast_true(), ast_datastore::data, initialize_mutehook(), mute, mute_add_audiohook(), mute_information::mute_read, and mute_information::mute_write.

{
   struct ast_datastore *datastore = NULL;
   struct mute_information *mute = NULL;
   int is_new = 0;

   ast_channel_lock(chan);
   if (!(datastore = ast_channel_datastore_find(chan, &mute_datastore, NULL))) {
      if (!(datastore = initialize_mutehook(chan))) {
         ast_channel_unlock(chan);
         return 0;
      }
      is_new = 1;
   }

   mute = datastore->data;

   if (!strcasecmp(data, "out")) {
      mute->mute_write = ast_true(value);
      ast_debug(1, "%s channel - outbound \n", ast_true(value) ? "Muting" : "Unmuting");
   } else if (!strcasecmp(data, "in")) {
      mute->mute_read = ast_true(value);
      ast_debug(1, "%s channel - inbound  \n", ast_true(value) ? "Muting" : "Unmuting");
   } else if (!strcasecmp(data,"all")) {
      mute->mute_write = mute->mute_read = ast_true(value);
   }

   if (is_new) {
      if (mute_add_audiohook(chan, mute, datastore)) {
         /* Can't add audiohook - already printed error message */
         ast_datastore_free(datastore);
         ast_free(mute);
      }
   }
   ast_channel_unlock(chan);

   return 0;
}

static struct ast_datastore* initialize_mutehook ( struct ast_channel * chan ) [static, read]

Initialize mute hook on channel, but don't activate it.

Precondition:: Assumes that the channel is locked

Definition at line 164 of file res_mutestream.c.

References ast_audiohook_init(), AST_AUDIOHOOK_TYPE_MANIPULATE, ast_calloc, ast_datastore_alloc(), ast_datastore_free(), ast_debug, mute_information::audiohook, ast_datastore::data, ast_audiohook::manipulate_callback, mute, and mute_callback().

Referenced by func_mute_write(), and manager_mutestream().

{
   struct ast_datastore *datastore = NULL;
   struct mute_information *mute = NULL;

   ast_debug(2, "Initializing new Mute Audiohook \n");

   /* Allocate a new datastore to hold the reference to this mute_datastore and audiohook information */
   if (!(datastore = ast_datastore_alloc(&mute_datastore, NULL))) {
      return NULL;
   }

   if (!(mute = ast_calloc(1, sizeof(*mute)))) {
      ast_datastore_free(datastore);
      return NULL;
   }
   ast_audiohook_init(&mute->audiohook, AST_AUDIOHOOK_TYPE_MANIPULATE, "Mute");
   mute->audiohook.manipulate_callback = mute_callback;
   datastore->data = mute;
   return datastore;
}

static int load_module ( void ) [static]

Definition at line 331 of file res_mutestream.c.

References ast_custom_function_register, ast_manager_register2(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, EVENT_FLAG_SYSTEM, and manager_mutestream().

{
   int res;
   res = ast_custom_function_register(&mute_function);

   res |= ast_manager_register2("MuteAudio", EVENT_FLAG_SYSTEM, manager_mutestream,
                        "Mute an audio stream", mandescr_mutestream);

   return (res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS);
}

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

Definition at line 248 of file res_mutestream.c.

References ast_channel_datastore_find(), ast_channel_get_by_name(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_datastore_free(), ast_free, ast_strlen_zero(), ast_true(), astman_append(), astman_get_header(), astman_send_error(), ast_datastore::data, initialize_mutehook(), mute, mute_add_audiohook(), mute_information::mute_read, mute_information::mute_write, and TRUE.

Referenced by load_module().

{
   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;
   struct ast_datastore *datastore = NULL;
   struct mute_information *mute = NULL;
   int is_new = 0;
   int turnon = TRUE;

   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 */
   if (!ast_strlen_zero(id)) {
      snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
   }

   c = ast_channel_get_by_name(channel);
   if (!c) {
      astman_send_error(s, m, "No such channel");
      return 0;
   }

   ast_channel_lock(c);

   if (!(datastore = ast_channel_datastore_find(c, &mute_datastore, NULL))) {
      if (!(datastore = initialize_mutehook(c))) {
         ast_channel_unlock(c);
         ast_channel_unref(c);
         return 0;
      }
      is_new = 1;
   }
   mute = datastore->data;
   turnon = ast_true(state);

   if (!strcasecmp(direction, "in")) {
      mute->mute_read = turnon;
   } else if (!strcasecmp(direction, "out")) {
      mute->mute_write = turnon;
   } else if (!strcasecmp(direction, "all")) {
      mute->mute_read = mute->mute_write = turnon;
   }

   if (is_new) {
      if (mute_add_audiohook(c, mute, datastore)) {
         /* Can't add audiohook - already printed error message */
         ast_datastore_free(datastore);
         ast_free(mute);
      }
   }
   ast_channel_unlock(c);
   ast_channel_unref(c);

   astman_append(s, "Response: Success\r\n"
               "%s"
               "\r\n\r\n", id_text);
   return 0;
}

static int mute_add_audiohook	(	struct ast_channel *	chan,
		struct mute_information *	mute,
		struct ast_datastore *	datastore
	)		`[static]`

Add or activate mute audiohook on channel Assumes channel is locked.

Definition at line 189 of file res_mutestream.c.

References ast_audiohook_attach(), ast_channel_datastore_add(), ast_debug, ast_log(), ast_module_ref(), mute_information::audiohook, LOG_ERROR, ast_channel::name, and ast_module_info::self.

Referenced by func_mute_write(), and manager_mutestream().

{
   /* Activate the settings */
   ast_channel_datastore_add(chan, datastore);
   if (ast_audiohook_attach(chan, &mute->audiohook)) {
      ast_log(LOG_ERROR, "Failed to attach audiohook for muting channel %s\n", chan->name);
      return -1;
   }
   ast_module_ref(ast_module_info->self);
   ast_debug(2, "Initialized audiohook on channel %s\n", chan->name);
   return 0;
}

static int mute_callback	(	struct ast_audiohook *	audiohook,
		struct ast_channel *	chan,
		struct ast_frame *	frame,
		enum ast_audiohook_direction	direction
	)		`[static]`

The callback from the audiohook subsystem. We basically get a frame to have fun with.

Definition at line 124 of file res_mutestream.c.

References AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, AST_AUDIOHOOK_STATUS_DONE, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_debug, ast_frame_clear(), AST_FRAME_VOICE, ast_datastore::data, ast_frame::frametype, mute, mute_information::mute_read, mute_information::mute_write, and ast_audiohook::status.

Referenced by initialize_mutehook().

{
   struct ast_datastore *datastore = NULL;
   struct mute_information *mute = 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;
   }

   ast_channel_lock(chan);
   /* Grab datastore which contains our mute information */
   if (!(datastore = ast_channel_datastore_find(chan, &mute_datastore, NULL))) {
      ast_channel_unlock(chan);
      ast_debug(2, "Can't find any datastore to use. Bad. \n");
      return 0;
   }

   mute = datastore->data;


   /* If this is audio then allow them to increase/decrease the gains */
   if (frame->frametype == AST_FRAME_VOICE) {
      ast_debug(2, "Audio frame - direction %s  mute READ %s WRITE %s\n", direction == AST_AUDIOHOOK_DIRECTION_READ ? "read" : "write", mute->mute_read ? "on" : "off", mute->mute_write ? "on" : "off");

      /* Based on direction of frame grab the gain, and confirm it is applicable */
      if ((direction == AST_AUDIOHOOK_DIRECTION_READ && mute->mute_read) || (direction == AST_AUDIOHOOK_DIRECTION_WRITE && mute->mute_write)) {
         /* Ok, we just want to reset all audio in this frame. Keep NOTHING, thanks. */
         ast_frame_clear(frame);
      }
   }
   ast_channel_unlock(chan);

   return 0;
}

static int unload_module ( void ) [static]

Definition at line 342 of file res_mutestream.c.

References ast_custom_function_unregister(), and ast_manager_unregister().

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

   return 0;
}

Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Mute audio stream resources" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, } [static]

Definition at line 351 of file res_mutestream.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 351 of file res_mutestream.c.

const char mandescr_mutestream[] = " ActionID: <id> Optional action ID for this AMI transaction.\n" [static]

Definition at line 322 of file res_mutestream.c.

struct ast_datastore_info mute_datastore [static]

Initial value:

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

Static structure for datastore information.

Definition at line 118 of file res_mutestream.c.

struct ast_custom_function mute_function [static]

Initial value:

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

Definition at line 243 of file res_mutestream.c.

Asterisk developer's documentation

Data Structures

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation