00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "asterisk.h"
00037
00038 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 411313 $")
00039
00040
00041
00042
00043
00044
00045
00046
00047 #include "asterisk/options.h"
00048 #include "asterisk/logger.h"
00049 #include "asterisk/channel.h"
00050 #include "asterisk/module.h"
00051 #include "asterisk/config.h"
00052 #include "asterisk/file.h"
00053 #include "asterisk/pbx.h"
00054 #include "asterisk/frame.h"
00055 #include "asterisk/utils.h"
00056 #include "asterisk/audiohook.h"
00057 #include "asterisk/manager.h"
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094 struct mute_information {
00095 struct ast_audiohook audiohook;
00096 int mute_write;
00097 int mute_read;
00098 };
00099
00100
00101 #define TRUE 1
00102 #define FALSE 0
00103
00104
00105 static void destroy_callback(void *data)
00106 {
00107 struct mute_information *mute = data;
00108
00109
00110 ast_audiohook_destroy(&mute->audiohook);
00111 ast_free(mute);
00112 ast_module_unref(ast_module_info->self);
00113
00114 return;
00115 }
00116
00117
00118 static const struct ast_datastore_info mute_datastore = {
00119 .type = "mute",
00120 .destroy = destroy_callback
00121 };
00122
00123
00124 static int mute_callback(struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
00125 {
00126 struct ast_datastore *datastore = NULL;
00127 struct mute_information *mute = NULL;
00128
00129
00130
00131 if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE) {
00132 return 0;
00133 }
00134
00135 ast_channel_lock(chan);
00136
00137 if (!(datastore = ast_channel_datastore_find(chan, &mute_datastore, NULL))) {
00138 ast_channel_unlock(chan);
00139 ast_debug(2, "Can't find any datastore to use. Bad. \n");
00140 return 0;
00141 }
00142
00143 mute = datastore->data;
00144
00145
00146
00147 if (frame->frametype == AST_FRAME_VOICE) {
00148 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");
00149
00150
00151 if ((direction == AST_AUDIOHOOK_DIRECTION_READ && mute->mute_read) || (direction == AST_AUDIOHOOK_DIRECTION_WRITE && mute->mute_write)) {
00152
00153 ast_frame_clear(frame);
00154 }
00155 }
00156 ast_channel_unlock(chan);
00157
00158 return 0;
00159 }
00160
00161
00162
00163
00164 static struct ast_datastore *initialize_mutehook(struct ast_channel *chan)
00165 {
00166 struct ast_datastore *datastore = NULL;
00167 struct mute_information *mute = NULL;
00168
00169 ast_debug(2, "Initializing new Mute Audiohook \n");
00170
00171
00172 if (!(datastore = ast_datastore_alloc(&mute_datastore, NULL))) {
00173 return NULL;
00174 }
00175
00176 if (!(mute = ast_calloc(1, sizeof(*mute)))) {
00177 ast_datastore_free(datastore);
00178 return NULL;
00179 }
00180 ast_audiohook_init(&mute->audiohook, AST_AUDIOHOOK_TYPE_MANIPULATE, "Mute");
00181 mute->audiohook.manipulate_callback = mute_callback;
00182 datastore->data = mute;
00183 return datastore;
00184 }
00185
00186
00187
00188
00189 static int mute_add_audiohook(struct ast_channel *chan, struct mute_information *mute, struct ast_datastore *datastore)
00190 {
00191
00192 ast_channel_datastore_add(chan, datastore);
00193 if (ast_audiohook_attach(chan, &mute->audiohook)) {
00194 ast_log(LOG_ERROR, "Failed to attach audiohook for muting channel %s\n", chan->name);
00195 return -1;
00196 }
00197 ast_module_ref(ast_module_info->self);
00198 ast_debug(2, "Initialized audiohook on channel %s\n", chan->name);
00199 return 0;
00200 }
00201
00202
00203 static int func_mute_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
00204 {
00205 struct ast_datastore *datastore = NULL;
00206 struct mute_information *mute = NULL;
00207 int is_new = 0;
00208
00209 if (!chan) {
00210 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
00211 return -1;
00212 }
00213
00214 ast_channel_lock(chan);
00215 if (!(datastore = ast_channel_datastore_find(chan, &mute_datastore, NULL))) {
00216 if (!(datastore = initialize_mutehook(chan))) {
00217 ast_channel_unlock(chan);
00218 return 0;
00219 }
00220 is_new = 1;
00221 }
00222
00223 mute = datastore->data;
00224
00225 if (!strcasecmp(data, "out")) {
00226 mute->mute_write = ast_true(value);
00227 ast_debug(1, "%s channel - outbound \n", ast_true(value) ? "Muting" : "Unmuting");
00228 } else if (!strcasecmp(data, "in")) {
00229 mute->mute_read = ast_true(value);
00230 ast_debug(1, "%s channel - inbound \n", ast_true(value) ? "Muting" : "Unmuting");
00231 } else if (!strcasecmp(data,"all")) {
00232 mute->mute_write = mute->mute_read = ast_true(value);
00233 }
00234
00235 if (is_new) {
00236 if (mute_add_audiohook(chan, mute, datastore)) {
00237
00238 ast_datastore_free(datastore);
00239 ast_free(mute);
00240 }
00241 }
00242 ast_channel_unlock(chan);
00243
00244 return 0;
00245 }
00246
00247
00248 static struct ast_custom_function mute_function = {
00249 .name = "MUTEAUDIO",
00250 .write = func_mute_write,
00251 };
00252
00253 static int manager_mutestream(struct mansession *s, const struct message *m)
00254 {
00255 const char *channel = astman_get_header(m, "Channel");
00256 const char *id = astman_get_header(m,"ActionID");
00257 const char *state = astman_get_header(m,"State");
00258 const char *direction = astman_get_header(m,"Direction");
00259 char id_text[256] = "";
00260 struct ast_channel *c = NULL;
00261 struct ast_datastore *datastore = NULL;
00262 struct mute_information *mute = NULL;
00263 int is_new = 0;
00264 int turnon = TRUE;
00265
00266 if (ast_strlen_zero(channel)) {
00267 astman_send_error(s, m, "Channel not specified");
00268 return 0;
00269 }
00270 if (ast_strlen_zero(state)) {
00271 astman_send_error(s, m, "State not specified");
00272 return 0;
00273 }
00274 if (ast_strlen_zero(direction)) {
00275 astman_send_error(s, m, "Direction not specified");
00276 return 0;
00277 }
00278
00279 if (!ast_strlen_zero(id)) {
00280 snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
00281 }
00282
00283 c = ast_channel_get_by_name(channel);
00284 if (!c) {
00285 astman_send_error(s, m, "No such channel");
00286 return 0;
00287 }
00288
00289 ast_channel_lock(c);
00290
00291 if (!(datastore = ast_channel_datastore_find(c, &mute_datastore, NULL))) {
00292 if (!(datastore = initialize_mutehook(c))) {
00293 ast_channel_unlock(c);
00294 ast_channel_unref(c);
00295 return 0;
00296 }
00297 is_new = 1;
00298 }
00299 mute = datastore->data;
00300 turnon = ast_true(state);
00301
00302 if (!strcasecmp(direction, "in")) {
00303 mute->mute_read = turnon;
00304 } else if (!strcasecmp(direction, "out")) {
00305 mute->mute_write = turnon;
00306 } else if (!strcasecmp(direction, "all")) {
00307 mute->mute_read = mute->mute_write = turnon;
00308 }
00309
00310 if (is_new) {
00311 if (mute_add_audiohook(c, mute, datastore)) {
00312
00313 ast_datastore_free(datastore);
00314 ast_free(mute);
00315 }
00316 }
00317 ast_channel_unlock(c);
00318 ast_channel_unref(c);
00319
00320 astman_append(s, "Response: Success\r\n"
00321 "%s"
00322 "\r\n\r\n", id_text);
00323 return 0;
00324 }
00325
00326
00327 static const char mandescr_mutestream[] =
00328 "Description: Mute an incoming or outbound audio stream in a channel.\n"
00329 "Variables: \n"
00330 " Channel: <name> The channel you want to mute.\n"
00331 " Direction: in | out |all The stream you want to mute.\n"
00332 " State: on | off Whether to turn mute on or off.\n"
00333 " ActionID: <id> Optional action ID for this AMI transaction.\n";
00334
00335
00336 static int load_module(void)
00337 {
00338 int res;
00339 res = ast_custom_function_register(&mute_function);
00340
00341 res |= ast_manager_register2("MuteAudio", EVENT_FLAG_SYSTEM, manager_mutestream,
00342 "Mute an audio stream", mandescr_mutestream);
00343
00344 return (res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS);
00345 }
00346
00347 static int unload_module(void)
00348 {
00349 ast_custom_function_unregister(&mute_function);
00350
00351 ast_manager_unregister("MuteAudio");
00352
00353 return 0;
00354 }
00355
00356 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Mute audio stream resources");