kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-30 02:26:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged revisions 33724 via svnmerge from

Browse Source 
https://origsvn.digium.com/svn/asterisk/branches/1.2

........
r33724 | file | 2006-06-12 18:34:38 -0300 (Mon, 12 Jun 2006) | 2 lines

Greatly simply the mixmonitor thread, and move channel reference directly to spy structure so that the core can modify it.

........


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@33725 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Joshua Colp
2006-06-12 21:37:29 +00:00
parent 55ffe394a5
commit c311827dc9
3 changed files with 124 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
apps/app_mixmonitor.c
View File

@@ -92,12 +92,11 @@ struct module_symbols *me;
static const char *mixmonitor_spy_type = "MixMonitor"; static const char *mixmonitor_spy_type = "MixMonitor";
struct mixmonitor { struct mixmonitor {
struct ast_channel *chan; struct ast_channel_spy *spy;
char *filename; struct ast_filestream *fs;
char *post_process; char *post_process;
char *name;
unsigned int flags; unsigned int flags;
int readvol;
int writevol;
}; };
enum { enum {
@@ -123,8 +122,10 @@ AST_APP_OPTIONS(mixmonitor_opts, {
AST_APP_OPTION_ARG('W', MUXFLAG_VOLUME, OPT_ARG_VOLUME), AST_APP_OPTION_ARG('W', MUXFLAG_VOLUME, OPT_ARG_VOLUME),
}); });
static void stopmon(struct ast_channel *chan, struct ast_channel_spy *spy) static void stopmon(struct ast_channel_spy *spy)
{ {
struct ast_channel *chan = spy->chan;
/* If our status has changed to DONE, then the channel we're spying on is gone.... /* If our status has changed to DONE, then the channel we're spying on is gone....
DON'T TOUCH IT!!! RUN AWAY!!! */ DON'T TOUCH IT!!! RUN AWAY!!! */
if (spy->status == CHANSPY_DONE) if (spy->status == CHANSPY_DONE)
@@ -134,7 +135,7 @@ static void stopmon(struct ast_channel *chan, struct ast_channel_spy *spy)
return; return;
ast_channel_lock(chan); ast_channel_lock(chan);
ast_channel_spy_remove(chan, spy); ast_channel_spy_remove(spy->chan, spy);
ast_channel_unlock(chan); ast_channel_unlock(chan);
} }
@@ -161,91 +162,31 @@ static int startmon(struct ast_channel *chan, struct ast_channel_spy *spy)
static void *mixmonitor_thread(void *obj) static void *mixmonitor_thread(void *obj)
{ {
struct mixmonitor *mixmonitor = obj; struct mixmonitor *mixmonitor = obj;
struct ast_channel_spy spy; struct ast_frame *f = NULL;
struct ast_filestream *fs = NULL;
char *ext, *name;
unsigned int oflags;
struct ast_frame *f;
char post_process[1024] = "";
ast_atomic_fetchadd_int(&__mod_desc->usecnt, +1); ast_atomic_fetchadd_int(&__mod_desc->usecnt, +1);
name = ast_strdupa(mixmonitor->chan->name);
oflags = O_CREAT|O_WRONLY;
oflags |= ast_test_flag(mixmonitor, MUXFLAG_APPEND) ? O_APPEND : O_TRUNC;
if ((ext = strrchr(mixmonitor->filename, '.'))) {
*(ext++) = '\0';
} else {
ext = "raw";
}
fs = ast_writefile(mixmonitor->filename, ext, NULL, oflags, 0, 0644);
if (!fs) {
ast_log(LOG_ERROR, "Cannot open %s.%s\n", mixmonitor->filename, ext);
goto out;
}
if (ast_test_flag(mixmonitor, MUXFLAG_APPEND))
ast_seekstream(fs, 0, SEEK_END);
memset(&spy, 0, sizeof(spy));
ast_set_flag(&spy, CHANSPY_FORMAT_AUDIO);
ast_set_flag(&spy, CHANSPY_MIXAUDIO);
spy.type = mixmonitor_spy_type;
spy.status = CHANSPY_RUNNING;
spy.read_queue.format = AST_FORMAT_SLINEAR;
spy.write_queue.format = AST_FORMAT_SLINEAR;
if (mixmonitor->readvol) {
ast_set_flag(&spy, CHANSPY_READ_VOLADJUST);
spy.read_vol_adjustment = mixmonitor->readvol;
}
if (mixmonitor->writevol) {
ast_set_flag(&spy, CHANSPY_WRITE_VOLADJUST);
spy.write_vol_adjustment = mixmonitor->writevol;
}
ast_mutex_init(&spy.lock);
if (startmon(mixmonitor->chan, &spy)) {
ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
spy.type, mixmonitor->chan->name);
goto out2;
}
if (option_verbose > 1) if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "Begin MixMonitor Recording %s\n", name); ast_verbose(VERBOSE_PREFIX_2 "Begin MixMonitor Recording %s\n", mixmonitor->name);
if (mixmonitor->post_process) { ast_mutex_lock(&mixmonitor->spy->lock);
char *p;
for (p = mixmonitor->post_process; *p ; p++) { while (mixmonitor->spy->chan) {
if (*p == '^' && *(p+1) == '{') { struct ast_frame *next = NULL;
*p = '$';
}
}
pbx_substitute_variables_helper(mixmonitor->chan, mixmonitor->post_process, post_process, sizeof(post_process) - 1);
}
while (1) {
struct ast_frame *next;
int write; int write;
ast_mutex_lock(&spy.lock); ast_channel_spy_trigger_wait(mixmonitor->spy);
ast_channel_spy_trigger_wait(&spy); if (!mixmonitor->spy->chan || mixmonitor->spy->status != CHANSPY_RUNNING) {
if (ast_check_hangup(mixmonitor->chan) || spy.status != CHANSPY_RUNNING) {
ast_mutex_unlock(&spy.lock);
break; break;
} }
while (1) { while (1) {
if (!(f = ast_channel_spy_read_frame(&spy, SAMPLES_PER_FRAME))) if (!(f = ast_channel_spy_read_frame(mixmonitor->spy, SAMPLES_PER_FRAME)))
break; break;
write = (!ast_test_flag(mixmonitor, MUXFLAG_BRIDGED) || write = (!ast_test_flag(mixmonitor, MUXFLAG_BRIDGED) ||
ast_bridged_channel(mixmonitor->chan)); ast_bridged_channel(mixmonitor->spy->chan));
/* it is possible for ast_channel_spy_read_frame() to return a chain /* it is possible for ast_channel_spy_read_frame() to return a chain
of frames if a queue flush was necessary, so process them of frames if a queue flush was necessary, so process them
@@ -253,32 +194,33 @@ static void *mixmonitor_thread(void *obj)
for (; f; f = next) { for (; f; f = next) {
next = f->next; next = f->next;
if (write) if (write)
ast_writestream(fs, f); ast_writestream(mixmonitor->fs, f);
ast_frfree(f); ast_frfree(f);
} }
} }
ast_mutex_unlock(&spy.lock);
} }
stopmon(mixmonitor->chan, &spy); ast_mutex_unlock(&mixmonitor->spy->lock);
stopmon(mixmonitor->spy);
if (option_verbose > 1) if (option_verbose > 1)
ast_verbose(VERBOSE_PREFIX_2 "End MixMonitor Recording %s\n", name); ast_verbose(VERBOSE_PREFIX_2 "End MixMonitor Recording %s\n", mixmonitor->name);
if (!ast_strlen_zero(post_process)) { if (!ast_strlen_zero(mixmonitor->post_process)) {
if (option_verbose > 2) if (option_verbose > 2)
ast_verbose(VERBOSE_PREFIX_2 "Executing [%s]\n", post_process); ast_verbose(VERBOSE_PREFIX_2 "Executing [%s]\n", mixmonitor->post_process);
ast_safe_system(post_process); ast_safe_system(mixmonitor->post_process);
} }
out2: ast_mutex_destroy(&mixmonitor->spy->lock);
ast_mutex_destroy(&spy.lock);
if (fs) ast_closestream(mixmonitor->fs);
ast_closestream(fs);
out: /* Deallocate everything */
free(mixmonitor->spy);
free(mixmonitor->post_process);
free(mixmonitor->name);
free(mixmonitor); free(mixmonitor);
ast_atomic_fetchadd_int(&__mod_desc->usecnt, -1); ast_atomic_fetchadd_int(&__mod_desc->usecnt, -1);
@@ -292,31 +234,92 @@ static void launch_monitor_thread(struct ast_channel *chan, const char *filename
pthread_attr_t attr; pthread_attr_t attr;
pthread_t thread; pthread_t thread;
struct mixmonitor *mixmonitor; struct mixmonitor *mixmonitor;
int len; char *file_name, *postprocess, *ext, postprocess2[1024] = "";
unsigned int oflags;
len = sizeof(*mixmonitor) + strlen(filename) + 1; if (!(mixmonitor = ast_calloc(1, sizeof(*mixmonitor)))) {
if (!ast_strlen_zero(post_process)) ast_log(LOG_ERROR, "Memory Error!\n");
len += strlen(post_process) + 1;
if (!(mixmonitor = ast_calloc(1, len))) {
return; return;
} }
mixmonitor->chan = chan; if (!(mixmonitor->spy = ast_calloc(1, sizeof(*mixmonitor->spy)))) {
mixmonitor->filename = (char *) mixmonitor + sizeof(*mixmonitor); ast_log(LOG_ERROR, "Memory Error!\n");
strcpy(mixmonitor->filename, filename); free(mixmonitor);
if (!ast_strlen_zero(post_process)) { return;
mixmonitor->post_process = mixmonitor->filename + strlen(filename) + 1;
strcpy(mixmonitor->post_process, post_process);
} }
mixmonitor->readvol = readvol;
mixmonitor->writevol = writevol; /* Copy over flags and channel name */
mixmonitor->flags = flags; mixmonitor->flags = flags;
mixmonitor->name = ast_strdup(chan->name);
/* Determine creation flags and filename plus extension for filestream */
oflags = O_CREAT | O_WRONLY;
oflags |= ast_test_flag(mixmonitor, MUXFLAG_APPEND) ? O_APPEND : O_TRUNC;
file_name = ast_strdupa(filename);
if ((ext = strrchr(file_name, '.'))) {
*(ext++) = '\0';
} else {
ext = "raw";
}
/* Move onto actually creating the filestream */
mixmonitor->fs = ast_writefile(file_name, ext, NULL, oflags, 0, 0644);
if (!mixmonitor->fs) {
ast_log(LOG_ERROR, "Cannot open %s.%s\n", file_name, ext);
free(mixmonitor->name);
free(mixmonitor->spy);
free(mixmonitor);
return;
}
/* If a post process system command is given attach it to the structure */
if (!ast_strlen_zero(post_process)) {
char *p = NULL;
postprocess = ast_strdupa(post_process);
for (p = postprocess; *p ; p++) {
if (*p == '^' && *(p+1) == '{') {
*p = '$';
}
}
pbx_substitute_variables_helper(chan, postprocess, postprocess2, sizeof(postprocess2) - 1);
mixmonitor->post_process = strdup(postprocess2);
}
/* Setup the actual spy before creating our thread */
ast_set_flag(mixmonitor->spy, CHANSPY_FORMAT_AUDIO);
ast_set_flag(mixmonitor->spy, CHANSPY_MIXAUDIO);
mixmonitor->spy->type = mixmonitor_spy_type;
mixmonitor->spy->status = CHANSPY_RUNNING;
mixmonitor->spy->read_queue.format = AST_FORMAT_SLINEAR;
mixmonitor->spy->write_queue.format = AST_FORMAT_SLINEAR;
if (readvol) {
ast_set_flag(mixmonitor->spy, CHANSPY_READ_VOLADJUST);
mixmonitor->spy->read_vol_adjustment = readvol;
}
if (writevol) {
ast_set_flag(mixmonitor->spy, CHANSPY_WRITE_VOLADJUST);
mixmonitor->spy->write_vol_adjustment = writevol;
}
ast_mutex_init(&mixmonitor->spy->lock);
if (startmon(chan, mixmonitor->spy)) {
ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
mixmonitor->spy->type, chan->name);
/* Since we couldn't add ourselves - bail out! */
ast_mutex_destroy(&mixmonitor->spy->lock);
free(mixmonitor->post_process);
ast_closestream(mixmonitor->fs);
free(mixmonitor->name);
free(mixmonitor->spy);
free(mixmonitor);
return;
}
pthread_attr_init(&attr); pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ast_pthread_create(&thread, &attr, mixmonitor_thread, mixmonitor); ast_pthread_create(&thread, &attr, mixmonitor_thread, mixmonitor);
pthread_attr_destroy(&attr); pthread_attr_destroy(&attr);
} }
static int mixmonitor_exec(struct ast_channel *chan, void *data) static int mixmonitor_exec(struct ast_channel *chan, void *data)

15
channel.c
View File

@@ -1122,6 +1122,9 @@ struct ast_datastore *ast_channel_datastore_find(struct ast_channel *chan, const
int ast_channel_spy_add(struct ast_channel *chan, struct ast_channel_spy *spy) int ast_channel_spy_add(struct ast_channel *chan, struct ast_channel_spy *spy)
{ {
/* Link the owner channel to the spy */
spy->chan = chan;
if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) { if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) {
ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n", ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n",
spy->type, chan->name); spy->type, chan->name);
@@ -1191,7 +1194,14 @@ void ast_channel_spy_stop_by_type(struct ast_channel *chan, const char *type)
void ast_channel_spy_trigger_wait(struct ast_channel_spy *spy) void ast_channel_spy_trigger_wait(struct ast_channel_spy *spy)
{ {
ast_cond_wait(&spy->trigger, &spy->lock); 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(&spy->trigger, &spy->lock, &ts);
} }
void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *spy) void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *spy)
@@ -1205,6 +1215,8 @@ void ast_channel_spy_remove(struct ast_channel *chan, struct ast_channel_spy *sp
ast_mutex_lock(&spy->lock); ast_mutex_lock(&spy->lock);
spy->chan = NULL;
for (f = spy->read_queue.head; f; f = spy->read_queue.head) { for (f = spy->read_queue.head; f; f = spy->read_queue.head) {
spy->read_queue.head = f->next; spy->read_queue.head = f->next;
ast_frfree(f); ast_frfree(f);
@@ -1242,6 +1254,7 @@ static void detach_spies(struct ast_channel *chan)
/* Marking the spies as done is sufficient. Chanspy or spy users will get the picture. */ /* Marking the spies as done is sufficient. Chanspy or spy users will get the picture. */
AST_LIST_TRAVERSE(&chan->spies->list, spy, list) { AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
ast_mutex_lock(&spy->lock); ast_mutex_lock(&spy->lock);
spy->chan = NULL;
if (spy->status == CHANSPY_RUNNING) if (spy->status == CHANSPY_RUNNING)
spy->status = CHANSPY_DONE; spy->status = CHANSPY_DONE;
if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)

1
include/asterisk/chanspy.h
View File

@@ -58,6 +58,7 @@ struct ast_channel_spy {
AST_LIST_ENTRY(ast_channel_spy) list; AST_LIST_ENTRY(ast_channel_spy) list;
ast_mutex_t lock; ast_mutex_t lock;
ast_cond_t trigger; ast_cond_t trigger;
struct ast_channel *chan;
struct ast_channel_spy_queue read_queue; struct ast_channel_spy_queue read_queue;
struct ast_channel_spy_queue write_queue; struct ast_channel_spy_queue write_queue;
unsigned int flags; unsigned int flags;