aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rwxr-xr-xMakefile2
-rwxr-xr-xapps/app_chanspy.c365
-rwxr-xr-xinclude/asterisk/slinfactory.h47
-rwxr-xr-xslinfactory.c152
4 files changed, 315 insertions, 251 deletions
diff --git a/Makefile b/Makefile
index 2efea26d0..5da4ff739 100755
--- a/Makefile
+++ b/Makefile
@@ -276,7 +276,7 @@ OBJS=io.o sched.o logger.o frame.o loader.o config.o channel.o \
dsp.o chanvars.o indications.o autoservice.o db.o privacy.o \
astmm.o enum.o srv.o dns.o aescrypt.o aestab.o aeskey.o \
utils.o config_old.o plc.o jitterbuf.o dnsmgr.o devicestate.o \
- netsock.o
+ netsock.o slinfactory.o
ifeq (${OSARCH},Darwin)
OBJS+=poll.o dlfcn.o
ASTLINK=-Wl,-dynamic
diff --git a/apps/app_chanspy.c b/apps/app_chanspy.c
index 7ed00cd31..5bc8c79d7 100755
--- a/apps/app_chanspy.c
+++ b/apps/app_chanspy.c
@@ -25,6 +25,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/channel.h"
#include "asterisk/features.h"
#include "asterisk/options.h"
+#include "asterisk/slinfactory.h"
#include "asterisk/app.h"
#include "asterisk/utils.h"
#include "asterisk/say.h"
@@ -35,7 +36,6 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
AST_MUTEX_DEFINE_STATIC(modlock);
-#define ast_fit_in_short(in) (in < -32768 ? -32768 : in > 32767 ? 32767 : in)
#define AST_NAME_STRLEN 256
#define ALL_DONE(u, ret) LOCAL_USER_REMOVE(u); return ret;
#define get_volfactor(x) x ? ((x > 0) ? (1 << x) : ((1 << abs(x)) * -1)) : 0
@@ -80,28 +80,9 @@ LOCAL_USER_DECL;
struct chanspy_translation_helper {
/* spy data */
struct ast_channel_spy spy;
-
- /* read frame */
- int fmt0;
- short *buf0;
- int len0;
- struct ast_trans_pvt *trans0;
-
- /* write frame */
- int fmt1;
- struct ast_trans_pvt *trans1;
- short *buf1;
- int len1;
-
- /* muxed frame */
- struct ast_frame frame;
- short *buf;
- int len;
-
- int samples;
- int rsamples;
int volfactor;
int fd;
+ struct ast_slinfactory slinfactory[2];
};
/* Prototypes */
@@ -165,33 +146,17 @@ static void spy_release(struct ast_channel *chan, void *data)
{
struct chanspy_translation_helper *csth = data;
+ ast_slinfactory_destroy(&csth->slinfactory[0]);
+ ast_slinfactory_destroy(&csth->slinfactory[1]);
- if (csth->trans0) {
- ast_translator_free_path(csth->trans0);
- csth->trans0 = NULL;
- }
- if (csth->trans1) {
- ast_translator_free_path(csth->trans1);
- csth->trans1 = NULL;
- }
-
- if (csth->buf0) {
- free(csth->buf0);
- csth->buf0 = NULL;
- }
- if (csth->buf1) {
- free(csth->buf1);
- csth->buf1 = NULL;
- }
- if (csth->buf) {
- free(csth->buf);
- csth->buf = NULL;
- }
return;
}
static void *spy_alloc(struct ast_channel *chan, void *params)
{
+ struct chanspy_translation_helper *csth = params;
+ ast_slinfactory_init(&csth->slinfactory[0]);
+ ast_slinfactory_init(&csth->slinfactory[1]);
return params;
}
@@ -224,245 +189,148 @@ static void ast_flush_spy_queue(struct ast_channel_spy *spy)
ast_mutex_unlock(&spy->lock);
}
-static int spy_generate(struct ast_channel *chan, void *data, int len, int samples)
-{
- struct ast_frame *f, *f0, *f1;
- int x, vf, dlen, maxsamp, loops;
- struct chanspy_translation_helper *csth = data;
- if (csth->rsamples < csth->samples) {
- csth->rsamples += samples;
- return 0;
- }
- csth->rsamples += samples;
- loops = 0;
- do {
- loops++;
- f = f0 = f1 = NULL;
- x = vf = dlen = maxsamp = 0;
- if (csth->rsamples == csth->samples) {
- csth->rsamples = csth->samples = 0;
+#if 0
+static int extract_audio(short *buf, size_t len, struct ast_trans_pvt *trans, struct ast_frame *fr, int *maxsamp)
+{
+ struct ast_frame *f;
+ int size, retlen = 0;
+
+ if (trans) {
+ if ((f = ast_translate(trans, fr, 0))) {
+ size = (f->datalen > len) ? len : f->datalen;
+ memcpy(buf, f->data, size);
+ retlen = f->datalen;
+ ast_frfree(f);
+ } else {
+ /* your guess is as good as mine why this will happen but it seems to only happen on iax and appears harmless */
+ ast_log(LOG_DEBUG, "Failed to translate frame from %s\n", ast_getformatname(fr->subclass));
}
+ } else {
+ size = (fr->datalen > len) ? len : fr->datalen;
+ memcpy(buf, fr->data, size);
+ retlen = fr->datalen;
+ }
- ast_mutex_lock(&csth->spy.lock);
- f0 = spy_queue_shift(&csth->spy, 0);
- f1 = spy_queue_shift(&csth->spy, 1);
- ast_mutex_unlock(&csth->spy.lock);
-
- if (csth->spy.status == CHANSPY_DONE) {
- return -1;
+ if (retlen > 0 && (size = retlen / 2)) {
+ if (size > *maxsamp) {
+ *maxsamp = size;
}
+ }
- if (!f0 && !f1) {
- return 0;
- }
+ return retlen;
+}
- if (f0 && csth->fmt0 && csth->fmt0 != f0->subclass) {
- ast_translator_free_path(csth->trans0);
- csth->trans0 = NULL;
- csth->fmt0 = f0->subclass;
- }
- if (f1 && csth->fmt1 && csth->fmt1 != f1->subclass) {
- ast_translator_free_path(csth->trans1);
- csth->trans1 = NULL;
- csth->fmt1 = f1->subclass;
- }
-
- if (!csth->fmt0 && f0) {
- csth->fmt0 = f0->subclass;
- }
+static int spy_queue_ready(struct ast_channel_spy *spy)
+{
+ int res = 0;
- if (!csth->fmt1 && f1) {
- csth->fmt1 = f1->subclass;
- }
+ ast_mutex_lock(&spy->lock);
+ if (spy->status == CHANSPY_RUNNING) {
+ res = (spy->queue[0] && spy->queue[1]) ? 1 : 0;
+ } else {
+ res = (spy->queue[0] || spy->queue[1]) ? 1 : -1;
+ }
+ ast_mutex_unlock(&spy->lock);
+ return res;
+}
+#endif
- if (csth->fmt0 && csth->fmt0 != AST_FORMAT_SLINEAR && !csth->trans0) {
- if ((csth->trans0 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt0)) == NULL) {
- ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt0));
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
+
+static int spy_generate(struct ast_channel *chan, void *data, int len, int samples)
+{
+
+ struct chanspy_translation_helper *csth = data;
+ struct ast_frame frame, *f;
+ int len0 = 0, len1 = 0, samp0 = 0, samp1 = 0, x, vf, maxsamp;
+ short buf0[1280], buf1[1280], buf[1280];
+
+ if (csth->spy.status == CHANSPY_DONE) {
+ return -1;
+ }
+
+ ast_mutex_lock(&csth->spy.lock);
+ while((f = csth->spy.queue[0])) {
+ csth->spy.queue[0] = f->next;
+ ast_slinfactory_feed(&csth->slinfactory[0], f);
+ ast_frfree(f);
}
- if (csth->fmt1 && csth->fmt1 != AST_FORMAT_SLINEAR && !csth->trans1) {
- if ((csth->trans1 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt1)) == NULL) {
- ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt1));
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
+ ast_mutex_unlock(&csth->spy.lock);
+ ast_mutex_lock(&csth->spy.lock);
+ while((f = csth->spy.queue[1])) {
+ csth->spy.queue[1] = f->next;
+ ast_slinfactory_feed(&csth->slinfactory[1], f);
+ ast_frfree(f);
}
-
- if (f0) {
- if (csth->trans0) {
- if ((f = ast_translate(csth->trans0, f0, 0))) {
- if (csth->len0 < f->datalen) {
- if (!csth->len0) {
- if (!(csth->buf0 = malloc(f->datalen * 2))) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- } else {
- if (!realloc(csth->buf0, f->datalen * 2)) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- }
- csth->len0 = f->datalen;
- }
- memcpy(csth->buf0, f->data, f->datalen);
- maxsamp = f->samples;
- ast_frfree(f);
- } else {
- return 0;
- }
- } else {
- if (csth->len0 < f0->datalen) {
- if (!csth->len0) {
- if (!(csth->buf0 = malloc(f0->datalen * 2))) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- } else {
- if (!realloc(csth->buf0, f0->datalen * 2)) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- }
- csth->len0 = f0->datalen;
- }
- memcpy(csth->buf0, f0->data, f0->datalen);
- maxsamp = f0->samples;
- }
+ ast_mutex_unlock(&csth->spy.lock);
+
+ if (csth->slinfactory[0].size < len || csth->slinfactory[1].size < len) {
+ return 0;
}
-
- if (f1) {
- if (csth->trans1) {
- if ((f = ast_translate(csth->trans1, f1, 0))) {
- if (csth->len1 < f->datalen) {
- if (!csth->len1) {
- if (!(csth->buf1 = malloc(f->datalen * 2))) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- } else {
- if (!realloc(csth->buf1, f->datalen * 2)) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- }
- csth->len1 = f->datalen;
- }
- memcpy(csth->buf1, f->data, f->datalen);
- if (f->samples > maxsamp) {
- maxsamp = f->samples;
- }
- ast_frfree(f);
-
- } else {
- return 0;
- }
- } else {
- if (csth->len1 < f1->datalen) {
- if (!csth->len1) {
- if (!(csth->buf1 = malloc(f1->datalen * 2))) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- } else {
- if (!realloc(csth->buf1, f1->datalen * 2)) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- }
- csth->len1 = f1->datalen;
- }
- memcpy(csth->buf1, f1->data, f1->datalen);
- if (f1->samples > maxsamp) {
- maxsamp = f1->samples;
- }
- }
+
+ if ((len0 = ast_slinfactory_read(&csth->slinfactory[0], buf0, len))) {
+ samp0 = len0 / 2;
+ }
+ if((len1 = ast_slinfactory_read(&csth->slinfactory[1], buf1, len))) {
+ samp1 = len1 / 2;
}
+ maxsamp = (samp0 > samp1) ? samp0 : samp1;
vf = get_volfactor(csth->volfactor);
- vf = minmax(vf, 16);
-
- dlen = (csth->len0 > csth->len1) ? csth->len0 : csth->len1;
-
- if (csth->len < dlen) {
- if (!csth->len) {
- if (!(csth->buf = malloc(dlen*2))) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- } else {
- if (!realloc(csth->buf, dlen * 2)) {
- csth->spy.status = CHANSPY_DONE;
- return -1;
- }
- }
- csth->len = dlen;
- }
-
+ vf = minmax(vf, 16);
+
for(x=0; x < maxsamp; x++) {
if (vf < 0) {
- if (f0) {
- csth->buf0[x] /= abs(vf);
+ if (samp0) {
+ buf0[x] /= abs(vf);
}
- if (f1) {
- csth->buf1[x] /= abs(vf);
+ if (samp1) {
+ buf1[x] /= abs(vf);
}
} else if (vf > 0) {
- if (f0) {
- csth->buf0[x] *= vf;
+ if (samp0) {
+ buf0[x] *= vf;
}
- if (f1) {
- csth->buf1[x] *= vf;
+ if (samp1) {
+ buf1[x] *= vf;
}
}
- if (f0 && f1) {
- if (x < csth->len0 && x < csth->len1) {
- csth->buf[x] = ast_fit_in_short(csth->buf0[x] + csth->buf1[x]);
- } else if (x < csth->len0) {
- csth->buf[x] = csth->buf0[x];
- } else if (x < csth->len1) {
- csth->buf[x] = csth->buf1[x];
+ if (samp0 && samp1) {
+ if (x < samp0 && x < samp1) {
+ buf[x] = buf0[x] + buf1[x];
+ } else if (x < samp0) {
+ buf[x] = buf0[x];
+ } else if (x < samp1) {
+ buf[x] = buf1[x];
}
- } else if (f0 && x < csth->len0) {
- csth->buf[x] = csth->buf0[x];
- } else if (f1 && x < csth->len1) {
- csth->buf[x] = csth->buf1[x];
+ } else if (x < samp0) {
+ buf[x] = buf0[x];
+ } else if (x < samp1) {
+ buf[x] = buf1[x];
}
}
-
- csth->frame.data = csth->buf;
- csth->frame.samples = maxsamp;
- csth->frame.datalen = csth->frame.samples * 2;
- csth->samples += csth->frame.samples;
- if (ast_write(chan, &csth->frame)) {
+ memset(&frame, 0, sizeof(frame));
+ frame.frametype = AST_FRAME_VOICE;
+ frame.subclass = AST_FORMAT_SLINEAR;
+ frame.data = buf;
+ frame.samples = x;
+ frame.datalen = x * 2;
+
+ if (ast_write(chan, &frame)) {
csth->spy.status = CHANSPY_DONE;
return -1;
}
- if (csth->fd) {
- write(csth->fd, csth->frame.data, csth->frame.datalen);
- }
- if (f0) {
- ast_frfree(f0);
- }
- if (f1) {
- ast_frfree(f1);
- }
-
- if (loops > 10) {
- ast_log(LOG_WARNING, "Too Many Loops Bailing Out....");
- break;
+ if (csth->fd) {
+ write(csth->fd, buf1, len1);
}
- } while (csth->samples < csth->rsamples);
- return 0;
+ return 0;
}
+
static struct ast_generator spygen = {
alloc: spy_alloc,
release: spy_release,
@@ -548,10 +416,7 @@ static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int
csth.spy.status = CHANSPY_RUNNING;
ast_mutex_init(&csth.spy.lock);
csth.volfactor = *volfactor;
- csth.frame.frametype = AST_FRAME_VOICE;
- csth.frame.subclass = AST_FORMAT_SLINEAR;
- csth.frame.datalen = 320;
- csth.frame.samples = 160;
+
if (fd) {
csth.fd = fd;
}
diff --git a/include/asterisk/slinfactory.h b/include/asterisk/slinfactory.h
new file mode 100755
index 000000000..95c655cb2
--- /dev/null
+++ b/include/asterisk/slinfactory.h
@@ -0,0 +1,47 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * A machine to gather up arbitrary frames and convert them
+ * to raw slinear on demand.
+ *
+ * Copyright (C) 2005, Anthony Minessale II.
+ *
+ * Anthony Minessale <anthmct@yahoo.com>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#ifndef _ASTERISK_SLINFACTORY_H
+#define _ASTERISK_SLINFACTORY_H
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+struct ast_slinfactory {
+ struct ast_frame *queue;
+ struct ast_trans_pvt *trans;
+ short hold[1280];
+ short *offset;
+ size_t holdlen;
+ int size;
+ int format;
+};
+
+void ast_slinfactory_init(struct ast_slinfactory *sf);
+void ast_slinfactory_destroy(struct ast_slinfactory *sf);
+int ast_slinfactory_feed(struct ast_slinfactory *sf, struct ast_frame *f);
+int ast_slinfactory_read(struct ast_slinfactory *sf, short *buf, size_t bytes);
+
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif
diff --git a/slinfactory.c b/slinfactory.c
new file mode 100755
index 000000000..f6abe7bb1
--- /dev/null
+++ b/slinfactory.c
@@ -0,0 +1,152 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * A machine to gather up arbitrary frames and convert them
+ * to raw slinear on demand.
+ *
+ * Copyright (C) 2005, Anthony Minessale II.
+ *
+ * Anthony Minessale <anthmct@yahoo.com>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#include "asterisk/slinfactory.h"
+#include "asterisk/file.h"
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/lock.h"
+#include "asterisk/cli.h"
+#include "asterisk/options.h"
+#include "asterisk/app.h"
+#include "asterisk/translate.h"
+
+
+void ast_slinfactory_init(struct ast_slinfactory *sf)
+{
+ memset(sf, 0, sizeof(struct ast_slinfactory));
+ sf->offset = sf->hold;
+ sf->queue = NULL;
+}
+
+void ast_slinfactory_destroy(struct ast_slinfactory *sf)
+{
+ struct ast_frame *f;
+
+ if (sf->trans) {
+ ast_translator_free_path(sf->trans);
+ sf->trans = NULL;
+ }
+
+ while((f = sf->queue)) {
+ sf->queue = f->next;
+ ast_frfree(f);
+ }
+}
+
+int ast_slinfactory_feed(struct ast_slinfactory *sf, struct ast_frame *f)
+{
+ struct ast_frame *frame, *frame_ptr;
+
+ if (!f) {
+ return 0;
+ }
+
+ if (f->subclass != AST_FORMAT_SLINEAR) {
+ if (sf->trans && f->subclass != sf->format) {
+ ast_translator_free_path(sf->trans);
+ sf->trans = NULL;
+ }
+ if (!sf->trans) {
+ if ((sf->trans = ast_translator_build_path(AST_FORMAT_SLINEAR, f->subclass)) == NULL) {
+ ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(f->subclass));
+ return 0;
+ } else {
+ sf->format = f->subclass;
+ }
+ }
+ }
+
+ if (sf->trans) {
+ frame = ast_translate(sf->trans, f, 0);
+ } else {
+ frame = ast_frdup(f);
+ }
+
+ if (frame) {
+ int x = 0;
+ for (frame_ptr = sf->queue; frame_ptr && frame_ptr->next; frame_ptr=frame_ptr->next) {
+ x++;
+ }
+ if (frame_ptr) {
+ frame_ptr->next = frame;
+ } else {
+ sf->queue = frame;
+ }
+ frame->next = NULL;
+ sf->size += frame->datalen;
+ return x;
+ }
+
+ return 0;
+
+}
+
+int ast_slinfactory_read(struct ast_slinfactory *sf, short *buf, size_t bytes)
+{
+ struct ast_frame *frame_ptr;
+ int sofar = 0, ineed, remain;
+ short *frame_data, *offset = buf;
+
+ while (sofar < bytes) {
+ ineed = bytes - sofar;
+
+ if (sf->holdlen) {
+ if ((sofar + sf->holdlen) <= ineed) {
+ memcpy(offset, sf->hold, sf->holdlen);
+ sofar += sf->holdlen;
+ offset += (sf->holdlen / sizeof(short));
+ sf->holdlen = 0;
+ sf->offset = sf->hold;
+ } else {
+ remain = sf->holdlen - ineed;
+ memcpy(offset, sf->offset, ineed);
+ sofar += ineed;
+ sf->offset += (ineed / sizeof(short));
+ sf->holdlen = remain;
+ }
+ continue;
+ }
+
+ if ((frame_ptr = sf->queue)) {
+ sf->queue = frame_ptr->next;
+ frame_data = frame_ptr->data;
+
+ if ((sofar + frame_ptr->datalen) <= ineed) {
+ memcpy(offset, frame_data, frame_ptr->datalen);
+ sofar += frame_ptr->datalen;
+ offset += (frame_ptr->datalen / sizeof(short));
+ } else {
+ remain = frame_ptr->datalen - ineed;
+ memcpy(offset, frame_data, ineed);
+ sofar += ineed;
+ frame_data += (ineed / sizeof(short));
+ memcpy(sf->hold, frame_data, remain);
+ sf->holdlen = remain;
+ }
+ ast_frfree(frame_ptr);
+ } else {
+ break;
+ }
+ }
+
+ sf->size -= sofar;
+ return sofar;
+}
+
+
+
+