6b08c442c7
This works in much the same way as the automonitor, except that instead of using the monitor app, it uses the mixmonitor app. By providing an 'x' or 'X' as a dial or queue option, a DTMF sequence may be entered (as defined in features.conf) to start the one-touch mixmonitor. This patch also introduces some new API calls to the audiohooks code for searching for an audiohook by type and for searching for a running audiohook by type. Big thanks to joetester for writing the initial patch, testing it and patiently waiting for it to be committed. (closes issue #10185, reported and patched by xmarksthespot) git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@90388 65c4cc65-6c06-0410-ace0-fbb531ad65f3
695 lines
23 KiB
C
695 lines
23 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 1999 - 2007, Digium, Inc.
|
|
*
|
|
* Joshua Colp <jcolp@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*! \file
|
|
*
|
|
* \brief Audiohooks Architecture
|
|
*
|
|
* \author Joshua Colp <jcolp@digium.com>
|
|
*/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
#include <signal.h>
|
|
|
|
#include "asterisk/channel.h"
|
|
#include "asterisk/utils.h"
|
|
#include "asterisk/lock.h"
|
|
#include "asterisk/linkedlists.h"
|
|
#include "asterisk/audiohook.h"
|
|
#include "asterisk/slinfactory.h"
|
|
#include "asterisk/frame.h"
|
|
#include "asterisk/translate.h"
|
|
|
|
struct ast_audiohook_translate {
|
|
struct ast_trans_pvt *trans_pvt;
|
|
int format;
|
|
};
|
|
|
|
struct ast_audiohook_list {
|
|
struct ast_audiohook_translate in_translate[2];
|
|
struct ast_audiohook_translate out_translate[2];
|
|
AST_LIST_HEAD_NOLOCK(, ast_audiohook) spy_list;
|
|
AST_LIST_HEAD_NOLOCK(, ast_audiohook) whisper_list;
|
|
AST_LIST_HEAD_NOLOCK(, ast_audiohook) manipulate_list;
|
|
};
|
|
|
|
/*! \brief Initialize an audiohook structure
|
|
* \param audiohook Audiohook structure
|
|
* \param type
|
|
* \param source
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_init(struct ast_audiohook *audiohook, enum ast_audiohook_type type, const char *source)
|
|
{
|
|
/* Need to keep the type and source */
|
|
audiohook->type = type;
|
|
audiohook->source = source;
|
|
|
|
/* Initialize lock that protects our audiohook */
|
|
ast_mutex_init(&audiohook->lock);
|
|
ast_cond_init(&audiohook->trigger, NULL);
|
|
|
|
/* Setup the factories that are needed for this audiohook type */
|
|
switch (type) {
|
|
case AST_AUDIOHOOK_TYPE_SPY:
|
|
ast_slinfactory_init(&audiohook->read_factory);
|
|
case AST_AUDIOHOOK_TYPE_WHISPER:
|
|
ast_slinfactory_init(&audiohook->write_factory);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Since we are just starting out... this audiohook is new */
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_NEW;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Destroys an audiohook structure
|
|
* \param audiohook Audiohook structure
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_destroy(struct ast_audiohook *audiohook)
|
|
{
|
|
/* Drop the factories used by this audiohook type */
|
|
switch (audiohook->type) {
|
|
case AST_AUDIOHOOK_TYPE_SPY:
|
|
ast_slinfactory_destroy(&audiohook->read_factory);
|
|
case AST_AUDIOHOOK_TYPE_WHISPER:
|
|
ast_slinfactory_destroy(&audiohook->write_factory);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Destroy translation path if present */
|
|
if (audiohook->trans_pvt)
|
|
ast_translator_free_path(audiohook->trans_pvt);
|
|
|
|
/* Lock and trigger be gone! */
|
|
ast_cond_destroy(&audiohook->trigger);
|
|
ast_mutex_destroy(&audiohook->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Writes a frame into the audiohook structure
|
|
* \param audiohook Audiohook structure
|
|
* \param direction Direction the audio frame came from
|
|
* \param frame Frame to write in
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_write_frame(struct ast_audiohook *audiohook, enum ast_audiohook_direction direction, struct ast_frame *frame)
|
|
{
|
|
struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
|
|
|
|
/* Write frame out to respective factory */
|
|
ast_slinfactory_feed(factory, frame);
|
|
|
|
/* If we need to notify the respective handler of this audiohook, do so */
|
|
switch (ast_test_flag(audiohook, AST_AUDIOHOOK_TRIGGER_MODE)) {
|
|
case AST_AUDIOHOOK_TRIGGER_READ:
|
|
if (direction == AST_AUDIOHOOK_DIRECTION_READ)
|
|
ast_cond_signal(&audiohook->trigger);
|
|
break;
|
|
case AST_AUDIOHOOK_TRIGGER_WRITE:
|
|
if (direction == AST_AUDIOHOOK_DIRECTION_WRITE)
|
|
ast_cond_signal(&audiohook->trigger);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct ast_frame *audiohook_read_frame_single(struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction)
|
|
{
|
|
struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory);
|
|
int vol = (direction == AST_AUDIOHOOK_DIRECTION_READ ? audiohook->options.read_volume : audiohook->options.write_volume);
|
|
short buf[samples];
|
|
struct ast_frame frame = {
|
|
.frametype = AST_FRAME_VOICE,
|
|
.subclass = AST_FORMAT_SLINEAR,
|
|
.data = buf,
|
|
.datalen = sizeof(buf),
|
|
.samples = samples,
|
|
};
|
|
|
|
/* Ensure the factory is able to give us the samples we want */
|
|
if (samples > ast_slinfactory_available(factory))
|
|
return NULL;
|
|
|
|
/* Read data in from factory */
|
|
if (!ast_slinfactory_read(factory, buf, samples))
|
|
return NULL;
|
|
|
|
/* If a volume adjustment needs to be applied apply it */
|
|
if (vol)
|
|
ast_frame_adjust_volume(&frame, vol);
|
|
|
|
return ast_frdup(&frame);
|
|
}
|
|
|
|
static struct ast_frame *audiohook_read_frame_both(struct ast_audiohook *audiohook, size_t samples)
|
|
{
|
|
int i = 0;
|
|
short buf1[samples], buf2[samples], *read_buf = NULL, *write_buf = NULL, *final_buf = NULL, *data1 = NULL, *data2 = NULL;
|
|
struct ast_frame frame = {
|
|
.frametype = AST_FRAME_VOICE,
|
|
.subclass = AST_FORMAT_SLINEAR,
|
|
.data = NULL,
|
|
.datalen = sizeof(buf1),
|
|
.samples = samples,
|
|
};
|
|
|
|
/* Start with the read factory... if there are enough samples, read them in */
|
|
if (ast_slinfactory_available(&audiohook->read_factory) >= samples) {
|
|
if (ast_slinfactory_read(&audiohook->read_factory, buf1, samples)) {
|
|
read_buf = buf1;
|
|
/* Adjust read volume if need be */
|
|
if (audiohook->options.read_volume) {
|
|
int count = 0;
|
|
short adjust_value = abs(audiohook->options.read_volume);
|
|
for (count = 0; count < samples; count++) {
|
|
if (audiohook->options.read_volume > 0)
|
|
ast_slinear_saturated_multiply(&buf1[count], &adjust_value);
|
|
else if (audiohook->options.read_volume < 0)
|
|
ast_slinear_saturated_divide(&buf1[count], &adjust_value);
|
|
}
|
|
}
|
|
}
|
|
} else if (option_debug)
|
|
ast_log(LOG_DEBUG, "Failed to get %d samples from read factory %p\n", (int)samples, &audiohook->read_factory);
|
|
|
|
/* Move on to the write factory... if there are enough samples, read them in */
|
|
if (ast_slinfactory_available(&audiohook->write_factory) >= samples) {
|
|
if (ast_slinfactory_read(&audiohook->write_factory, buf2, samples)) {
|
|
write_buf = buf2;
|
|
/* Adjust write volume if need be */
|
|
if (audiohook->options.write_volume) {
|
|
int count = 0;
|
|
short adjust_value = abs(audiohook->options.write_volume);
|
|
for (count = 0; count < samples; count++) {
|
|
if (audiohook->options.write_volume > 0)
|
|
ast_slinear_saturated_multiply(&buf2[count], &adjust_value);
|
|
else if (audiohook->options.write_volume < 0)
|
|
ast_slinear_saturated_divide(&buf2[count], &adjust_value);
|
|
}
|
|
}
|
|
}
|
|
} else if (option_debug)
|
|
ast_log(LOG_DEBUG, "Failed to get %d samples from write factory %p\n", (int)samples, &audiohook->write_factory);
|
|
|
|
/* Basically we figure out which buffer to use... and if mixing can be done here */
|
|
if (!read_buf && !write_buf)
|
|
return NULL;
|
|
else if (read_buf && write_buf) {
|
|
for (i = 0, data1 = read_buf, data2 = write_buf; i < samples; i++, data1++, data2++)
|
|
ast_slinear_saturated_add(data1, data2);
|
|
final_buf = buf1;
|
|
} else if (read_buf)
|
|
final_buf = buf1;
|
|
else if (write_buf)
|
|
final_buf = buf2;
|
|
|
|
/* Make the final buffer part of the frame, so it gets duplicated fine */
|
|
frame.data = final_buf;
|
|
|
|
/* Yahoo, a combined copy of the audio! */
|
|
return ast_frdup(&frame);
|
|
}
|
|
|
|
/*! \brief Reads a frame in from the audiohook structure
|
|
* \param audiohook Audiohook structure
|
|
* \param samples Number of samples wanted
|
|
* \param direction Direction the audio frame came from
|
|
* \param format Format of frame remote side wants back
|
|
* \return Returns frame on success, NULL on failure
|
|
*/
|
|
struct ast_frame *ast_audiohook_read_frame(struct ast_audiohook *audiohook, size_t samples, enum ast_audiohook_direction direction, int format)
|
|
{
|
|
struct ast_frame *read_frame = NULL, *final_frame = NULL;
|
|
|
|
if (!(read_frame = (direction == AST_AUDIOHOOK_DIRECTION_BOTH ? audiohook_read_frame_both(audiohook, samples) : audiohook_read_frame_single(audiohook, samples, direction))))
|
|
return NULL;
|
|
|
|
/* If they don't want signed linear back out, we'll have to send it through the translation path */
|
|
if (format != AST_FORMAT_SLINEAR) {
|
|
/* Rebuild translation path if different format then previously */
|
|
if (audiohook->format != format) {
|
|
if (audiohook->trans_pvt) {
|
|
ast_translator_free_path(audiohook->trans_pvt);
|
|
audiohook->trans_pvt = NULL;
|
|
}
|
|
/* Setup new translation path for this format... if we fail we can't very well return signed linear so free the frame and return nothing */
|
|
if (!(audiohook->trans_pvt = ast_translator_build_path(format, AST_FORMAT_SLINEAR))) {
|
|
ast_frfree(read_frame);
|
|
return NULL;
|
|
}
|
|
}
|
|
/* Convert to requested format, and allow the read in frame to be freed */
|
|
final_frame = ast_translate(audiohook->trans_pvt, read_frame, 1);
|
|
} else {
|
|
final_frame = read_frame;
|
|
}
|
|
|
|
return final_frame;
|
|
}
|
|
|
|
/*! \brief Attach audiohook to channel
|
|
* \param chan Channel
|
|
* \param audiohook Audiohook structure
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_attach(struct ast_channel *chan, struct ast_audiohook *audiohook)
|
|
{
|
|
ast_channel_lock(chan);
|
|
|
|
if (!chan->audiohooks) {
|
|
/* Whoops... allocate a new structure */
|
|
if (!(chan->audiohooks = ast_calloc(1, sizeof(*chan->audiohooks)))) {
|
|
ast_channel_unlock(chan);
|
|
return -1;
|
|
}
|
|
AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->spy_list);
|
|
AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->whisper_list);
|
|
AST_LIST_HEAD_INIT_NOLOCK(&chan->audiohooks->manipulate_list);
|
|
}
|
|
|
|
/* Drop into respective list */
|
|
if (audiohook->type == AST_AUDIOHOOK_TYPE_SPY)
|
|
AST_LIST_INSERT_TAIL(&chan->audiohooks->spy_list, audiohook, list);
|
|
else if (audiohook->type == AST_AUDIOHOOK_TYPE_WHISPER)
|
|
AST_LIST_INSERT_TAIL(&chan->audiohooks->whisper_list, audiohook, list);
|
|
else if (audiohook->type == AST_AUDIOHOOK_TYPE_MANIPULATE)
|
|
AST_LIST_INSERT_TAIL(&chan->audiohooks->manipulate_list, audiohook, list);
|
|
|
|
/* Change status over to running since it is now attached */
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_RUNNING;
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Detach audiohook from channel
|
|
* \param audiohook Audiohook structure
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_detach(struct ast_audiohook *audiohook)
|
|
{
|
|
if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE)
|
|
return 0;
|
|
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_SHUTDOWN;
|
|
|
|
while (audiohook->status != AST_AUDIOHOOK_STATUS_DONE)
|
|
ast_audiohook_trigger_wait(audiohook);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Detach audiohooks from list and destroy said list
|
|
* \param audiohook_list List of audiohooks
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_detach_list(struct ast_audiohook_list *audiohook_list)
|
|
{
|
|
int i = 0;
|
|
struct ast_audiohook *audiohook = NULL;
|
|
|
|
/* Drop any spies */
|
|
while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->spy_list, list))) {
|
|
ast_audiohook_lock(audiohook);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_cond_signal(&audiohook->trigger);
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
|
|
/* Drop any whispering sources */
|
|
while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->whisper_list, list))) {
|
|
ast_audiohook_lock(audiohook);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_cond_signal(&audiohook->trigger);
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
|
|
/* Drop any manipulaters */
|
|
while ((audiohook = AST_LIST_REMOVE_HEAD(&audiohook_list->manipulate_list, list))) {
|
|
ast_audiohook_lock(audiohook);
|
|
ast_mutex_lock(&audiohook->lock);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_audiohook_unlock(audiohook);
|
|
audiohook->manipulate_callback(audiohook, NULL, NULL, 0);
|
|
}
|
|
|
|
/* Drop translation paths if present */
|
|
for (i = 0; i < 2; i++) {
|
|
if (audiohook_list->in_translate[i].trans_pvt)
|
|
ast_translator_free_path(audiohook_list->in_translate[i].trans_pvt);
|
|
if (audiohook_list->out_translate[i].trans_pvt)
|
|
ast_translator_free_path(audiohook_list->out_translate[i].trans_pvt);
|
|
}
|
|
|
|
/* Free ourselves */
|
|
ast_free(audiohook_list);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct ast_audiohook *find_audiohook_by_source(struct ast_audiohook_list *audiohook_list, const char *source)
|
|
{
|
|
struct ast_audiohook *audiohook = NULL;
|
|
|
|
AST_LIST_TRAVERSE(&audiohook_list->spy_list, audiohook, list) {
|
|
if (!strcasecmp(audiohook->source, source))
|
|
return audiohook;
|
|
}
|
|
|
|
AST_LIST_TRAVERSE(&audiohook_list->whisper_list, audiohook, list) {
|
|
if (!strcasecmp(audiohook->source, source))
|
|
return audiohook;
|
|
}
|
|
|
|
AST_LIST_TRAVERSE(&audiohook_list->manipulate_list, audiohook, list) {
|
|
if (!strcasecmp(audiohook->source, source))
|
|
return audiohook;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*! \brief Detach specified source audiohook from channel
|
|
* \param chan Channel to detach from
|
|
* \param source Name of source to detach
|
|
* \return Returns 0 on success, -1 on failure
|
|
*/
|
|
int ast_audiohook_detach_source(struct ast_channel *chan, const char *source)
|
|
{
|
|
struct ast_audiohook *audiohook = NULL;
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
/* Ensure the channel has audiohooks on it */
|
|
if (!chan->audiohooks) {
|
|
ast_channel_unlock(chan);
|
|
return -1;
|
|
}
|
|
|
|
audiohook = find_audiohook_by_source(chan->audiohooks, source);
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
if (audiohook && audiohook->status != AST_AUDIOHOOK_STATUS_DONE)
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_SHUTDOWN;
|
|
|
|
return (audiohook ? 0 : -1);
|
|
}
|
|
|
|
/*! \brief Pass a DTMF frame off to be handled by the audiohook core
|
|
* \param chan Channel that the list is coming off of
|
|
* \param audiohook_list List of audiohooks
|
|
* \param direction Direction frame is coming in from
|
|
* \param frame The frame itself
|
|
* \return Return frame on success, NULL on failure
|
|
*/
|
|
static struct ast_frame *dtmf_audiohook_write_list(struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
|
|
{
|
|
struct ast_audiohook *audiohook = NULL;
|
|
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->manipulate_list, audiohook, list) {
|
|
ast_audiohook_lock(audiohook);
|
|
if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
|
|
AST_LIST_REMOVE_CURRENT(list);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_audiohook_unlock(audiohook);
|
|
audiohook->manipulate_callback(audiohook, NULL, NULL, 0);
|
|
continue;
|
|
}
|
|
if (ast_test_flag(audiohook, AST_AUDIOHOOK_WANTS_DTMF))
|
|
audiohook->manipulate_callback(audiohook, chan, frame, direction);
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
|
|
return frame;
|
|
}
|
|
|
|
/*! \brief Pass an AUDIO frame off to be handled by the audiohook core
|
|
* \param chan Channel that the list is coming off of
|
|
* \param audiohook_list List of audiohooks
|
|
* \param direction Direction frame is coming in from
|
|
* \param frame The frame itself
|
|
* \return Return frame on success, NULL on failure
|
|
*/
|
|
static struct ast_frame *audio_audiohook_write_list(struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
|
|
{
|
|
struct ast_audiohook_translate *in_translate = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook_list->in_translate[0] : &audiohook_list->in_translate[1]);
|
|
struct ast_audiohook_translate *out_translate = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook_list->out_translate[0] : &audiohook_list->out_translate[1]);
|
|
struct ast_frame *start_frame = frame, *middle_frame = frame, *end_frame = frame;
|
|
struct ast_audiohook *audiohook = NULL;
|
|
int samples = frame->samples;
|
|
|
|
/* If the frame coming in is not signed linear we have to send it through the in_translate path */
|
|
if (frame->subclass != AST_FORMAT_SLINEAR) {
|
|
if (in_translate->format != frame->subclass) {
|
|
if (in_translate->trans_pvt)
|
|
ast_translator_free_path(in_translate->trans_pvt);
|
|
if (!(in_translate->trans_pvt = ast_translator_build_path(AST_FORMAT_SLINEAR, frame->subclass)))
|
|
return frame;
|
|
in_translate->format = frame->subclass;
|
|
}
|
|
if (!(middle_frame = ast_translate(in_translate->trans_pvt, frame, 0)))
|
|
return frame;
|
|
}
|
|
|
|
/* Queue up signed linear frame to each spy */
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->spy_list, audiohook, list) {
|
|
ast_audiohook_lock(audiohook);
|
|
if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
|
|
AST_LIST_REMOVE_CURRENT(list);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_cond_signal(&audiohook->trigger);
|
|
ast_audiohook_unlock(audiohook);
|
|
continue;
|
|
}
|
|
ast_audiohook_write_frame(audiohook, direction, middle_frame);
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END
|
|
|
|
/* If this frame is being written out to the channel then we need to use whisper sources */
|
|
if (direction == AST_AUDIOHOOK_DIRECTION_WRITE && !AST_LIST_EMPTY(&audiohook_list->whisper_list)) {
|
|
int i = 0;
|
|
short read_buf[samples], combine_buf[samples], *data1 = NULL, *data2 = NULL;
|
|
memset(&combine_buf, 0, sizeof(combine_buf));
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->whisper_list, audiohook, list) {
|
|
ast_audiohook_lock(audiohook);
|
|
if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
|
|
AST_LIST_REMOVE_CURRENT(list);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_cond_signal(&audiohook->trigger);
|
|
ast_audiohook_unlock(audiohook);
|
|
continue;
|
|
}
|
|
if (ast_slinfactory_available(&audiohook->write_factory) >= samples && ast_slinfactory_read(&audiohook->write_factory, read_buf, samples)) {
|
|
/* Take audio from this whisper source and combine it into our main buffer */
|
|
for (i = 0, data1 = combine_buf, data2 = read_buf; i < samples; i++, data1++, data2++)
|
|
ast_slinear_saturated_add(data1, data2);
|
|
}
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END
|
|
/* We take all of the combined whisper sources and combine them into the audio being written out */
|
|
for (i = 0, data1 = middle_frame->data, data2 = combine_buf; i < samples; i++, data1++, data2++)
|
|
ast_slinear_saturated_add(data1, data2);
|
|
end_frame = middle_frame;
|
|
}
|
|
|
|
/* Pass off frame to manipulate audiohooks */
|
|
if (!AST_LIST_EMPTY(&audiohook_list->manipulate_list)) {
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->manipulate_list, audiohook, list) {
|
|
ast_audiohook_lock(audiohook);
|
|
if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) {
|
|
AST_LIST_REMOVE_CURRENT(list);
|
|
audiohook->status = AST_AUDIOHOOK_STATUS_DONE;
|
|
ast_audiohook_unlock(audiohook);
|
|
/* We basically drop all of our links to the manipulate audiohook and prod it to do it's own destructive things */
|
|
audiohook->manipulate_callback(audiohook, chan, NULL, direction);
|
|
continue;
|
|
}
|
|
/* Feed in frame to manipulation */
|
|
audiohook->manipulate_callback(audiohook, chan, middle_frame, direction);
|
|
ast_audiohook_unlock(audiohook);
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END
|
|
end_frame = middle_frame;
|
|
}
|
|
|
|
/* Now we figure out what to do with our end frame (whether to transcode or not) */
|
|
if (middle_frame == end_frame) {
|
|
/* Middle frame was modified and became the end frame... let's see if we need to transcode */
|
|
if (end_frame->subclass != start_frame->subclass) {
|
|
if (out_translate->format != start_frame->subclass) {
|
|
if (out_translate->trans_pvt)
|
|
ast_translator_free_path(out_translate->trans_pvt);
|
|
if (!(out_translate->trans_pvt = ast_translator_build_path(start_frame->subclass, AST_FORMAT_SLINEAR))) {
|
|
/* We can't transcode this... drop our middle frame and return the original */
|
|
ast_frfree(middle_frame);
|
|
return start_frame;
|
|
}
|
|
out_translate->format = start_frame->subclass;
|
|
}
|
|
/* Transcode from our middle (signed linear) frame to new format of the frame that came in */
|
|
if (!(end_frame = ast_translate(out_translate->trans_pvt, middle_frame, 0))) {
|
|
/* Failed to transcode the frame... drop it and return the original */
|
|
ast_frfree(middle_frame);
|
|
return start_frame;
|
|
}
|
|
/* Here's the scoop... middle frame is no longer of use to us */
|
|
ast_frfree(middle_frame);
|
|
}
|
|
} else {
|
|
/* No frame was modified, we can just drop our middle frame and pass the frame we got in out */
|
|
ast_frfree(middle_frame);
|
|
}
|
|
|
|
return end_frame;
|
|
}
|
|
|
|
/*! \brief Pass a frame off to be handled by the audiohook core
|
|
* \param chan Channel that the list is coming off of
|
|
* \param audiohook_list List of audiohooks
|
|
* \param direction Direction frame is coming in from
|
|
* \param frame The frame itself
|
|
* \return Return frame on success, NULL on failure
|
|
*/
|
|
struct ast_frame *ast_audiohook_write_list(struct ast_channel *chan, struct ast_audiohook_list *audiohook_list, enum ast_audiohook_direction direction, struct ast_frame *frame)
|
|
{
|
|
/* Pass off frame to it's respective list write function */
|
|
if (frame->frametype == AST_FRAME_VOICE)
|
|
return audio_audiohook_write_list(chan, audiohook_list, direction, frame);
|
|
else if (frame->frametype == AST_FRAME_DTMF)
|
|
return dtmf_audiohook_write_list(chan, audiohook_list, direction, frame);
|
|
else
|
|
return frame;
|
|
}
|
|
|
|
|
|
/*! \brief Wait for audiohook trigger to be triggered
|
|
* \param audiohook Audiohook to wait on
|
|
*/
|
|
void ast_audiohook_trigger_wait(struct ast_audiohook *audiohook)
|
|
{
|
|
struct timeval tv;
|
|
struct timespec ts;
|
|
|
|
tv = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
|
|
ts.tv_sec = tv.tv_sec;
|
|
ts.tv_nsec = tv.tv_usec * 1000;
|
|
|
|
ast_cond_timedwait(&audiohook->trigger, &audiohook->lock, &ts);
|
|
|
|
return;
|
|
}
|
|
|
|
/* Count number of channel audiohooks by type, regardless of type */
|
|
int ast_channel_audiohook_count_by_source(struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
|
|
{
|
|
int count = 0;
|
|
struct ast_audiohook *ah = NULL;
|
|
|
|
if (!chan->audiohooks)
|
|
return -1;
|
|
|
|
switch (type) {
|
|
case AST_AUDIOHOOK_TYPE_SPY:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->spy_list, ah, list) {
|
|
if (!strcmp(ah->source, source)) {
|
|
count++;
|
|
}
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
case AST_AUDIOHOOK_TYPE_WHISPER:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->whisper_list, ah, list) {
|
|
if (!strcmp(ah->source, source)) {
|
|
count++;
|
|
}
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
case AST_AUDIOHOOK_TYPE_MANIPULATE:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->manipulate_list, ah, list) {
|
|
if (!strcmp(ah->source, source)) {
|
|
count++;
|
|
}
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
default:
|
|
ast_log(LOG_DEBUG, "Invalid audiohook type supplied, (%d)\n", type);
|
|
return -1;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/* Count number of channel audiohooks by type that are running */
|
|
int ast_channel_audiohook_count_by_source_running(struct ast_channel *chan, const char *source, enum ast_audiohook_type type)
|
|
{
|
|
int count = 0;
|
|
struct ast_audiohook *ah = NULL;
|
|
if (!chan->audiohooks)
|
|
return -1;
|
|
|
|
switch (type) {
|
|
case AST_AUDIOHOOK_TYPE_SPY:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->spy_list, ah, list) {
|
|
if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
|
|
count++;
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
case AST_AUDIOHOOK_TYPE_WHISPER:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->whisper_list, ah, list) {
|
|
if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
|
|
count++;
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
case AST_AUDIOHOOK_TYPE_MANIPULATE:
|
|
AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->audiohooks->manipulate_list, ah, list) {
|
|
if ((!strcmp(ah->source, source)) && (ah->status == AST_AUDIOHOOK_STATUS_RUNNING))
|
|
count++;
|
|
}
|
|
AST_LIST_TRAVERSE_SAFE_END;
|
|
break;
|
|
default:
|
|
ast_log(LOG_DEBUG, "Invalid audiohook type supplied, (%d)\n", type);
|
|
return -1;
|
|
}
|
|
return count;
|
|
}
|
|
|