2006-05-31 18:09:52 +00:00
|
|
|
/*
|
|
|
|
* abstract_jb: common implementation-independent jitterbuffer stuff
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005, Attractel OOD
|
|
|
|
*
|
|
|
|
* Contributors:
|
|
|
|
* Slav Klenov <slav@securax.org>
|
|
|
|
*
|
|
|
|
* 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.
|
2006-06-14 14:12:56 +00:00
|
|
|
*
|
|
|
|
* A license has been granted to Digium (via disclaimer) for the use of
|
|
|
|
* this code.
|
2006-05-31 18:09:52 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*! \file
|
|
|
|
*
|
|
|
|
* \brief Common implementation-independent jitterbuffer stuff.
|
|
|
|
*
|
|
|
|
* \author Slav Klenov <slav@securax.org>
|
2008-01-22 08:58:46 +00:00
|
|
|
*
|
|
|
|
*
|
2006-05-31 18:09:52 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
|
|
|
#include "asterisk/frame.h"
|
|
|
|
#include "asterisk/channel.h"
|
|
|
|
#include "asterisk/term.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
|
|
|
|
#include "asterisk/abstract_jb.h"
|
2006-06-01 14:07:03 +00:00
|
|
|
#include "fixedjitterbuf.h"
|
2006-05-31 18:09:52 +00:00
|
|
|
#include "jitterbuf.h"
|
|
|
|
|
|
|
|
/*! Internal jb flags */
|
|
|
|
enum {
|
|
|
|
JB_USE = (1 << 0),
|
|
|
|
JB_TIMEBASE_INITIALIZED = (1 << 1),
|
|
|
|
JB_CREATED = (1 << 2)
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Hooks for the abstract jb implementation */
|
|
|
|
|
|
|
|
/*! \brief Create */
|
|
|
|
typedef void * (*jb_create_impl)(struct ast_jb_conf *general_config, long resynch_threshold);
|
|
|
|
/*! \brief Destroy */
|
|
|
|
typedef void (*jb_destroy_impl)(void *jb);
|
|
|
|
/*! \brief Put first frame */
|
|
|
|
typedef int (*jb_put_first_impl)(void *jb, struct ast_frame *fin, long now);
|
|
|
|
/*! \brief Put frame */
|
|
|
|
typedef int (*jb_put_impl)(void *jb, struct ast_frame *fin, long now);
|
|
|
|
/*! \brief Get frame for now */
|
|
|
|
typedef int (*jb_get_impl)(void *jb, struct ast_frame **fout, long now, long interpl);
|
|
|
|
/*! \brief Get next */
|
|
|
|
typedef long (*jb_next_impl)(void *jb);
|
|
|
|
/*! \brief Remove first frame */
|
|
|
|
typedef int (*jb_remove_impl)(void *jb, struct ast_frame **fout);
|
|
|
|
/*! \brief Force resynch */
|
|
|
|
typedef void (*jb_force_resynch_impl)(void *jb);
|
2008-08-06 00:30:53 +00:00
|
|
|
/*! \brief Empty and reset jb */
|
|
|
|
typedef void (*jb_empty_and_reset_impl)(void *jb);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Jitterbuffer implementation private struct.
|
|
|
|
*/
|
|
|
|
struct ast_jb_impl
|
|
|
|
{
|
|
|
|
char name[AST_JB_IMPL_NAME_SIZE];
|
|
|
|
jb_create_impl create;
|
|
|
|
jb_destroy_impl destroy;
|
|
|
|
jb_put_first_impl put_first;
|
|
|
|
jb_put_impl put;
|
|
|
|
jb_get_impl get;
|
|
|
|
jb_next_impl next;
|
|
|
|
jb_remove_impl remove;
|
|
|
|
jb_force_resynch_impl force_resync;
|
2008-08-06 00:30:53 +00:00
|
|
|
jb_empty_and_reset_impl empty_and_reset;
|
2006-05-31 18:09:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Implementation functions */
|
2006-06-01 14:07:03 +00:00
|
|
|
/* fixed */
|
2008-01-22 08:58:46 +00:00
|
|
|
static void *jb_create_fixed(struct ast_jb_conf *general_config, long resynch_threshold);
|
2006-06-01 14:07:03 +00:00
|
|
|
static void jb_destroy_fixed(void *jb);
|
|
|
|
static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now);
|
|
|
|
static int jb_put_fixed(void *jb, struct ast_frame *fin, long now);
|
|
|
|
static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl);
|
|
|
|
static long jb_next_fixed(void *jb);
|
|
|
|
static int jb_remove_fixed(void *jb, struct ast_frame **fout);
|
|
|
|
static void jb_force_resynch_fixed(void *jb);
|
2008-08-06 00:30:53 +00:00
|
|
|
static void jb_empty_and_reset_fixed(void *jb);
|
2006-06-01 14:07:03 +00:00
|
|
|
/* adaptive */
|
|
|
|
static void * jb_create_adaptive(struct ast_jb_conf *general_config, long resynch_threshold);
|
|
|
|
static void jb_destroy_adaptive(void *jb);
|
|
|
|
static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now);
|
|
|
|
static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now);
|
|
|
|
static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl);
|
|
|
|
static long jb_next_adaptive(void *jb);
|
|
|
|
static int jb_remove_adaptive(void *jb, struct ast_frame **fout);
|
|
|
|
static void jb_force_resynch_adaptive(void *jb);
|
2008-08-06 00:30:53 +00:00
|
|
|
static void jb_empty_and_reset_adaptive(void *jb);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
/* Available jb implementations */
|
|
|
|
static struct ast_jb_impl avail_impl[] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
.name = "fixed",
|
2006-06-01 14:07:03 +00:00
|
|
|
.create = jb_create_fixed,
|
|
|
|
.destroy = jb_destroy_fixed,
|
|
|
|
.put_first = jb_put_first_fixed,
|
|
|
|
.put = jb_put_fixed,
|
|
|
|
.get = jb_get_fixed,
|
|
|
|
.next = jb_next_fixed,
|
|
|
|
.remove = jb_remove_fixed,
|
2008-08-06 00:30:53 +00:00
|
|
|
.force_resync = jb_force_resynch_fixed,
|
|
|
|
.empty_and_reset = jb_empty_and_reset_fixed,
|
2006-05-31 18:09:52 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "adaptive",
|
2006-06-01 14:07:03 +00:00
|
|
|
.create = jb_create_adaptive,
|
|
|
|
.destroy = jb_destroy_adaptive,
|
|
|
|
.put_first = jb_put_first_adaptive,
|
|
|
|
.put = jb_put_adaptive,
|
|
|
|
.get = jb_get_adaptive,
|
|
|
|
.next = jb_next_adaptive,
|
|
|
|
.remove = jb_remove_adaptive,
|
2008-08-06 00:30:53 +00:00
|
|
|
.force_resync = jb_force_resynch_adaptive,
|
|
|
|
.empty_and_reset = jb_empty_and_reset_adaptive,
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int default_impl = 0;
|
|
|
|
|
|
|
|
|
|
|
|
/*! Abstract return codes */
|
|
|
|
enum {
|
|
|
|
JB_IMPL_OK,
|
|
|
|
JB_IMPL_DROP,
|
|
|
|
JB_IMPL_INTERP,
|
|
|
|
JB_IMPL_NOFRAME
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Translations between impl and abstract return codes */
|
2006-06-01 14:07:03 +00:00
|
|
|
static int fixed_to_abstract_code[] =
|
2006-05-31 18:09:52 +00:00
|
|
|
{JB_IMPL_OK, JB_IMPL_DROP, JB_IMPL_INTERP, JB_IMPL_NOFRAME};
|
2006-06-01 14:07:03 +00:00
|
|
|
static int adaptive_to_abstract_code[] =
|
2006-05-31 18:09:52 +00:00
|
|
|
{JB_IMPL_OK, JB_IMPL_NOFRAME, JB_IMPL_NOFRAME, JB_IMPL_INTERP, JB_IMPL_DROP, JB_IMPL_OK};
|
|
|
|
|
|
|
|
/* JB_GET actions (used only for the frames log) */
|
|
|
|
static char *jb_get_actions[] = {"Delivered", "Dropped", "Interpolated", "No"};
|
|
|
|
|
|
|
|
/*! \brief Macros for the frame log files */
|
|
|
|
#define jb_framelog(...) do { \
|
|
|
|
if (jb->logfile) { \
|
|
|
|
fprintf(jb->logfile, __VA_ARGS__); \
|
|
|
|
fflush(jb->logfile); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
|
|
/* Internal utility functions */
|
|
|
|
static void jb_choose_impl(struct ast_channel *chan);
|
|
|
|
static void jb_get_and_deliver(struct ast_channel *chan);
|
|
|
|
static int create_jb(struct ast_channel *chan, struct ast_frame *first_frame);
|
|
|
|
static long get_now(struct ast_jb *jb, struct timeval *tv);
|
|
|
|
|
|
|
|
|
|
|
|
/* Interface ast jb functions impl */
|
|
|
|
|
|
|
|
|
|
|
|
static void jb_choose_impl(struct ast_channel *chan)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb = &chan->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_conf *jbconf = &jb->conf;
|
|
|
|
struct ast_jb_impl *test_impl;
|
2008-07-11 18:09:35 +00:00
|
|
|
int i, avail_impl_count = ARRAY_LEN(avail_impl);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
jb->impl = &avail_impl[default_impl];
|
|
|
|
|
|
|
|
if (ast_strlen_zero(jbconf->impl))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < avail_impl_count; i++) {
|
|
|
|
test_impl = &avail_impl[i];
|
|
|
|
if (!strcasecmp(jbconf->impl, test_impl->name)) {
|
|
|
|
jb->impl = test_impl;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb0 = &c0->jb;
|
|
|
|
struct ast_jb *jb1 = &c1->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_conf *conf0 = &jb0->conf;
|
|
|
|
struct ast_jb_conf *conf1 = &jb1->conf;
|
|
|
|
int c0_wants_jitter = c0->tech->properties & AST_CHAN_TP_WANTSJITTER;
|
|
|
|
int c0_creates_jitter = c0->tech->properties & AST_CHAN_TP_CREATESJITTER;
|
|
|
|
int c0_jb_enabled = ast_test_flag(conf0, AST_JB_ENABLED);
|
|
|
|
int c0_force_jb = ast_test_flag(conf0, AST_JB_FORCED);
|
|
|
|
int c0_jb_timebase_initialized = ast_test_flag(jb0, JB_TIMEBASE_INITIALIZED);
|
|
|
|
int c0_jb_created = ast_test_flag(jb0, JB_CREATED);
|
|
|
|
int c1_wants_jitter = c1->tech->properties & AST_CHAN_TP_WANTSJITTER;
|
|
|
|
int c1_creates_jitter = c1->tech->properties & AST_CHAN_TP_CREATESJITTER;
|
|
|
|
int c1_jb_enabled = ast_test_flag(conf1, AST_JB_ENABLED);
|
|
|
|
int c1_force_jb = ast_test_flag(conf1, AST_JB_FORCED);
|
|
|
|
int c1_jb_timebase_initialized = ast_test_flag(jb1, JB_TIMEBASE_INITIALIZED);
|
|
|
|
int c1_jb_created = ast_test_flag(jb1, JB_CREATED);
|
|
|
|
int inuse = 0;
|
|
|
|
|
|
|
|
/* Determine whether audio going to c0 needs a jitter buffer */
|
|
|
|
if (((!c0_wants_jitter && c1_creates_jitter) || (c0_force_jb && c1_creates_jitter)) && c0_jb_enabled) {
|
|
|
|
ast_set_flag(jb0, JB_USE);
|
|
|
|
if (!c0_jb_timebase_initialized) {
|
|
|
|
if (c1_jb_timebase_initialized) {
|
|
|
|
memcpy(&jb0->timebase, &jb1->timebase, sizeof(struct timeval));
|
|
|
|
} else {
|
|
|
|
gettimeofday(&jb0->timebase, NULL);
|
|
|
|
}
|
|
|
|
ast_set_flag(jb0, JB_TIMEBASE_INITIALIZED);
|
|
|
|
}
|
2008-08-06 00:30:53 +00:00
|
|
|
|
2006-05-31 18:09:52 +00:00
|
|
|
if (!c0_jb_created) {
|
|
|
|
jb_choose_impl(c0);
|
|
|
|
}
|
|
|
|
|
|
|
|
inuse = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine whether audio going to c1 needs a jitter buffer */
|
|
|
|
if (((!c1_wants_jitter && c0_creates_jitter) || (c1_force_jb && c0_creates_jitter)) && c1_jb_enabled) {
|
|
|
|
ast_set_flag(jb1, JB_USE);
|
|
|
|
if (!c1_jb_timebase_initialized) {
|
|
|
|
if (c0_jb_timebase_initialized) {
|
|
|
|
memcpy(&jb1->timebase, &jb0->timebase, sizeof(struct timeval));
|
|
|
|
} else {
|
|
|
|
gettimeofday(&jb1->timebase, NULL);
|
|
|
|
}
|
|
|
|
ast_set_flag(jb1, JB_TIMEBASE_INITIALIZED);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!c1_jb_created) {
|
|
|
|
jb_choose_impl(c1);
|
|
|
|
}
|
|
|
|
|
|
|
|
inuse = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return inuse;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb0 = &c0->jb;
|
|
|
|
struct ast_jb *jb1 = &c1->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
int c0_use_jb = ast_test_flag(jb0, JB_USE);
|
|
|
|
int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
|
|
|
|
int c1_use_jb = ast_test_flag(jb1, JB_USE);
|
|
|
|
int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
|
|
|
|
int wait, wait0, wait1;
|
|
|
|
struct timeval tv_now;
|
|
|
|
|
|
|
|
if (time_left == 0) {
|
|
|
|
/* No time left - the bridge will be retried */
|
|
|
|
/* TODO: Test disable this */
|
|
|
|
/*return 0;*/
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_left < 0) {
|
|
|
|
time_left = INT_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
gettimeofday(&tv_now, NULL);
|
|
|
|
|
|
|
|
wait0 = (c0_use_jb && c0_jb_is_created) ? jb0->next - get_now(jb0, &tv_now) : time_left;
|
|
|
|
wait1 = (c1_use_jb && c1_jb_is_created) ? jb1->next - get_now(jb1, &tv_now) : time_left;
|
|
|
|
|
|
|
|
wait = wait0 < wait1 ? wait0 : wait1;
|
|
|
|
wait = wait < time_left ? wait : time_left;
|
|
|
|
|
|
|
|
if (wait == INT_MAX) {
|
|
|
|
wait = -1;
|
|
|
|
} else if (wait < 1) {
|
|
|
|
/* don't let wait=0, because this can cause the pbx thread to loop without any sleeping at all */
|
|
|
|
wait = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return wait;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb = &chan->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_impl *jbimpl = jb->impl;
|
|
|
|
void *jbobj = jb->jbobj;
|
|
|
|
struct ast_frame *frr;
|
|
|
|
long now = 0;
|
|
|
|
|
|
|
|
if (!ast_test_flag(jb, JB_USE))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (f->frametype != AST_FRAME_VOICE) {
|
|
|
|
if (f->frametype == AST_FRAME_DTMF && ast_test_flag(jb, JB_CREATED)) {
|
|
|
|
jb_framelog("JB_PUT {now=%ld}: Received DTMF frame. Force resynching jb...\n", now);
|
|
|
|
jbimpl->force_resync(jbobj);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We consider an enabled jitterbuffer should receive frames with valid timing info. */
|
Merged revisions 98943 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r98943 | russell | 2008-01-15 17:26:52 -0600 (Tue, 15 Jan 2008) | 25 lines
Commit a fix for some memory access errors pointed out by the valgrind2.txt
output on issue #11698.
The issue here is that it is possible for an instance of a translator to get
destroyed while the frame allocated as a part of the translator is still being
processed. Specifically, this is possible anywhere between a call to ast_read()
and ast_frame_free(), which is _a lot_ of places in the code. The reason this
happens is that the channel might get masqueraded during this time. During a
masquerade, existing translation paths get destroyed.
So, this patch fixes the issue in an API and ABI compatible way. (This one is
for you, paravoid!)
It changes an int in ast_frame to be used as flag bits. The 1 bit is still used
to indicate that the frame contains timing information. Also, a second flag has
been added to indicate that the frame came from a translator. When a frame with
this flag gets released and has this flag, a function is called in translate.c to
let it know that this frame is doing being processed. At this point, the flag gets
cleared. Also, if the translator was requested to be destroyed while its internal
frame still had this flag set, its destruction has been deffered until it finds out
that the frame is no longer being processed.
Admittedly, this feels like a hack. But, it does fix the issue, and I was not able
to think of a better solution ...
........
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@98944 f38db490-d61c-443f-a65b-d21fe96a405b
2008-01-15 23:31:53 +00:00
|
|
|
if (!ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO) || f->len < 2 || f->ts < 0) {
|
2007-11-28 15:38:03 +00:00
|
|
|
ast_log(LOG_WARNING, "%s received frame with invalid timing info: "
|
2006-05-31 18:09:52 +00:00
|
|
|
"has_timing_info=%d, len=%ld, ts=%ld, src=%s\n",
|
Merged revisions 98943 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4
........
r98943 | russell | 2008-01-15 17:26:52 -0600 (Tue, 15 Jan 2008) | 25 lines
Commit a fix for some memory access errors pointed out by the valgrind2.txt
output on issue #11698.
The issue here is that it is possible for an instance of a translator to get
destroyed while the frame allocated as a part of the translator is still being
processed. Specifically, this is possible anywhere between a call to ast_read()
and ast_frame_free(), which is _a lot_ of places in the code. The reason this
happens is that the channel might get masqueraded during this time. During a
masquerade, existing translation paths get destroyed.
So, this patch fixes the issue in an API and ABI compatible way. (This one is
for you, paravoid!)
It changes an int in ast_frame to be used as flag bits. The 1 bit is still used
to indicate that the frame contains timing information. Also, a second flag has
been added to indicate that the frame came from a translator. When a frame with
this flag gets released and has this flag, a function is called in translate.c to
let it know that this frame is doing being processed. At this point, the flag gets
cleared. Also, if the translator was requested to be destroyed while its internal
frame still had this flag set, its destruction has been deffered until it finds out
that the frame is no longer being processed.
Admittedly, this feels like a hack. But, it does fix the issue, and I was not able
to think of a better solution ...
........
git-svn-id: http://svn.digium.com/svn/asterisk/trunk@98944 f38db490-d61c-443f-a65b-d21fe96a405b
2008-01-15 23:31:53 +00:00
|
|
|
chan->name, ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO), f->len, f->ts, f->src);
|
2006-05-31 18:09:52 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-08-29 20:50:36 +00:00
|
|
|
frr = ast_frdup(f);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
if (!frr) {
|
|
|
|
ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", chan->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_test_flag(jb, JB_CREATED)) {
|
|
|
|
if (create_jb(chan, frr)) {
|
|
|
|
ast_frfree(frr);
|
|
|
|
/* Disable the jitterbuffer */
|
|
|
|
ast_clear_flag(jb, JB_USE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_set_flag(jb, JB_CREATED);
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
now = get_now(jb, NULL);
|
|
|
|
if (jbimpl->put(jbobj, frr, now) != JB_IMPL_OK) {
|
|
|
|
jb_framelog("JB_PUT {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
|
|
|
|
ast_frfree(frr);
|
|
|
|
/*return -1;*/
|
|
|
|
/* TODO: Check this fix - should return 0 here, because the dropped frame shouldn't
|
|
|
|
be delivered at all */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
jb->next = jbimpl->next(jbobj);
|
|
|
|
|
|
|
|
jb_framelog("JB_PUT {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb0 = &c0->jb;
|
|
|
|
struct ast_jb *jb1 = &c1->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
int c0_use_jb = ast_test_flag(jb0, JB_USE);
|
|
|
|
int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
|
|
|
|
int c1_use_jb = ast_test_flag(jb1, JB_USE);
|
|
|
|
int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
|
|
|
|
|
|
|
|
if (c0_use_jb && c0_jb_is_created)
|
|
|
|
jb_get_and_deliver(c0);
|
|
|
|
|
|
|
|
if (c1_use_jb && c1_jb_is_created)
|
|
|
|
jb_get_and_deliver(c1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void jb_get_and_deliver(struct ast_channel *chan)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb = &chan->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_impl *jbimpl = jb->impl;
|
|
|
|
void *jbobj = jb->jbobj;
|
|
|
|
struct ast_frame *f, finterp;
|
|
|
|
long now;
|
|
|
|
int interpolation_len, res;
|
|
|
|
|
|
|
|
now = get_now(jb, NULL);
|
|
|
|
jb->next = jbimpl->next(jbobj);
|
|
|
|
if (now < jb->next) {
|
|
|
|
jb_framelog("\tJB_GET {now=%ld}: now < next=%ld\n", now, jb->next);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (now >= jb->next) {
|
|
|
|
interpolation_len = ast_codec_interp_len(jb->last_format);
|
|
|
|
|
|
|
|
res = jbimpl->get(jbobj, &f, now, interpolation_len);
|
|
|
|
|
2007-01-23 00:11:32 +00:00
|
|
|
switch (res) {
|
2006-05-31 18:09:52 +00:00
|
|
|
case JB_IMPL_OK:
|
|
|
|
/* deliver the frame */
|
|
|
|
ast_write(chan, f);
|
|
|
|
case JB_IMPL_DROP:
|
|
|
|
jb_framelog("\tJB_GET {now=%ld}: %s frame with ts=%ld and len=%ld\n",
|
|
|
|
now, jb_get_actions[res], f->ts, f->len);
|
|
|
|
jb->last_format = f->subclass;
|
|
|
|
ast_frfree(f);
|
|
|
|
break;
|
|
|
|
case JB_IMPL_INTERP:
|
|
|
|
/* interpolate a frame */
|
|
|
|
f = &finterp;
|
|
|
|
f->frametype = AST_FRAME_VOICE;
|
|
|
|
f->subclass = jb->last_format;
|
|
|
|
f->datalen = 0;
|
|
|
|
f->samples = interpolation_len * 8;
|
|
|
|
f->mallocd = 0;
|
|
|
|
f->src = "JB interpolation";
|
2008-05-22 16:29:54 +00:00
|
|
|
f->data.ptr = NULL;
|
2006-05-31 18:09:52 +00:00
|
|
|
f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
|
|
|
|
f->offset = AST_FRIENDLY_OFFSET;
|
|
|
|
/* deliver the interpolated frame */
|
|
|
|
ast_write(chan, f);
|
|
|
|
jb_framelog("\tJB_GET {now=%ld}: Interpolated frame with len=%d\n", now, interpolation_len);
|
|
|
|
break;
|
|
|
|
case JB_IMPL_NOFRAME:
|
|
|
|
ast_log(LOG_WARNING,
|
2008-01-22 08:58:46 +00:00
|
|
|
"JB_IMPL_NOFRAME is returned from the %s jb when now=%ld >= next=%ld, jbnext=%ld!\n",
|
2006-05-31 18:09:52 +00:00
|
|
|
jbimpl->name, now, jb->next, jbimpl->next(jbobj));
|
|
|
|
jb_framelog("\tJB_GET {now=%ld}: No frame for now!?\n", now);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
ast_log(LOG_ERROR, "This should never happen!\n");
|
2008-06-11 18:19:24 +00:00
|
|
|
ast_assert("JB type unknown" == NULL);
|
2006-05-31 18:09:52 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
jb->next = jbimpl->next(jbobj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int create_jb(struct ast_channel *chan, struct ast_frame *frr)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb = &chan->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_conf *jbconf = &jb->conf;
|
|
|
|
struct ast_jb_impl *jbimpl = jb->impl;
|
|
|
|
void *jbobj;
|
|
|
|
struct ast_channel *bridged;
|
|
|
|
long now;
|
|
|
|
char logfile_pathname[20 + AST_JB_IMPL_NAME_SIZE + 2*AST_CHANNEL_NAME + 1];
|
|
|
|
char name1[AST_CHANNEL_NAME], name2[AST_CHANNEL_NAME], *tmp;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
jbobj = jb->jbobj = jbimpl->create(jbconf, jbconf->resync_threshold);
|
|
|
|
if (!jbobj) {
|
|
|
|
ast_log(LOG_WARNING, "Failed to create jitterbuffer on channel '%s'\n", chan->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
now = get_now(jb, NULL);
|
|
|
|
res = jbimpl->put_first(jbobj, frr, now);
|
|
|
|
|
|
|
|
/* The result of putting the first frame should not differ from OK. However, its possible
|
2006-06-01 14:07:03 +00:00
|
|
|
some implementations (i.e. adaptive's when resynch_threshold is specified) to drop it. */
|
2006-05-31 18:09:52 +00:00
|
|
|
if (res != JB_IMPL_OK) {
|
|
|
|
ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", chan->name);
|
|
|
|
/*
|
|
|
|
jbimpl->destroy(jbobj);
|
|
|
|
return -1;
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init next */
|
|
|
|
jb->next = jbimpl->next(jbobj);
|
|
|
|
|
|
|
|
/* Init last format for a first time. */
|
|
|
|
jb->last_format = frr->subclass;
|
|
|
|
|
|
|
|
/* Create a frame log file */
|
|
|
|
if (ast_test_flag(jbconf, AST_JB_LOG)) {
|
|
|
|
snprintf(name2, sizeof(name2), "%s", chan->name);
|
|
|
|
tmp = strchr(name2, '/');
|
|
|
|
if (tmp)
|
|
|
|
*tmp = '#';
|
|
|
|
|
|
|
|
bridged = ast_bridged_channel(chan);
|
2008-06-11 18:19:24 +00:00
|
|
|
/* We should always have bridged chan if a jitterbuffer is in use */
|
|
|
|
ast_assert(bridged != NULL);
|
|
|
|
|
2006-05-31 18:09:52 +00:00
|
|
|
snprintf(name1, sizeof(name1), "%s", bridged->name);
|
|
|
|
tmp = strchr(name1, '/');
|
|
|
|
if (tmp)
|
|
|
|
*tmp = '#';
|
|
|
|
|
|
|
|
snprintf(logfile_pathname, sizeof(logfile_pathname),
|
|
|
|
"/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
|
|
|
|
jb->logfile = fopen(logfile_pathname, "w+b");
|
|
|
|
|
|
|
|
if (!jb->logfile)
|
2008-01-22 08:58:46 +00:00
|
|
|
ast_log(LOG_ERROR, "Failed to create frame log file with pathname '%s'\n", logfile_pathname);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
if (res == JB_IMPL_OK)
|
|
|
|
jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n",
|
|
|
|
now, frr->ts, frr->len);
|
|
|
|
else
|
|
|
|
jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n",
|
|
|
|
now, frr->ts, frr->len);
|
|
|
|
}
|
|
|
|
|
2007-07-26 15:49:18 +00:00
|
|
|
ast_verb(3, "%s jitterbuffer created on channel %s\n", jbimpl->name, chan->name);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
/* Free the frame if it has not been queued in the jb */
|
|
|
|
if (res != JB_IMPL_OK)
|
|
|
|
ast_frfree(frr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ast_jb_destroy(struct ast_channel *chan)
|
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
struct ast_jb *jb = &chan->jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
struct ast_jb_impl *jbimpl = jb->impl;
|
|
|
|
void *jbobj = jb->jbobj;
|
|
|
|
struct ast_frame *f;
|
|
|
|
|
|
|
|
if (jb->logfile) {
|
|
|
|
fclose(jb->logfile);
|
|
|
|
jb->logfile = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(jb, JB_CREATED)) {
|
|
|
|
/* Remove and free all frames still queued in jb */
|
|
|
|
while (jbimpl->remove(jbobj, &f) == JB_IMPL_OK) {
|
|
|
|
ast_frfree(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
jbimpl->destroy(jbobj);
|
|
|
|
jb->jbobj = NULL;
|
|
|
|
|
|
|
|
ast_clear_flag(jb, JB_CREATED);
|
|
|
|
|
2007-07-26 15:49:18 +00:00
|
|
|
ast_verb(3, "%s jitterbuffer destroyed on channel %s\n", jbimpl->name, chan->name);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-08-10 19:35:50 +00:00
|
|
|
static long get_now(struct ast_jb *jb, struct timeval *when)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
|
|
|
struct timeval now;
|
|
|
|
|
2008-08-10 19:35:50 +00:00
|
|
|
if (!when) {
|
|
|
|
when = &now;
|
|
|
|
gettimeofday(when, NULL);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
2008-08-10 19:35:50 +00:00
|
|
|
return ast_tvdiff_ms(*when, jb->timebase);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-11-14 13:18:40 +00:00
|
|
|
int ast_jb_read_conf(struct ast_jb_conf *conf, const char *varname, const char *value)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
|
|
|
int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
|
2007-11-14 13:18:40 +00:00
|
|
|
const char *name;
|
2006-05-31 18:09:52 +00:00
|
|
|
int tmp;
|
|
|
|
|
|
|
|
if (strncasecmp(AST_JB_CONF_PREFIX, varname, prefixlen))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
name = varname + prefixlen;
|
|
|
|
|
|
|
|
if (!strcasecmp(name, AST_JB_CONF_ENABLE)) {
|
|
|
|
ast_set2_flag(conf, ast_true(value), AST_JB_ENABLED);
|
|
|
|
} else if (!strcasecmp(name, AST_JB_CONF_FORCE)) {
|
|
|
|
ast_set2_flag(conf, ast_true(value), AST_JB_FORCED);
|
|
|
|
} else if (!strcasecmp(name, AST_JB_CONF_MAX_SIZE)) {
|
|
|
|
if ((tmp = atoi(value)) > 0)
|
|
|
|
conf->max_size = tmp;
|
|
|
|
} else if (!strcasecmp(name, AST_JB_CONF_RESYNCH_THRESHOLD)) {
|
|
|
|
if ((tmp = atoi(value)) > 0)
|
|
|
|
conf->resync_threshold = tmp;
|
|
|
|
} else if (!strcasecmp(name, AST_JB_CONF_IMPL)) {
|
|
|
|
if (!ast_strlen_zero(value))
|
|
|
|
snprintf(conf->impl, sizeof(conf->impl), "%s", value);
|
|
|
|
} else if (!strcasecmp(name, AST_JB_CONF_LOG)) {
|
|
|
|
ast_set2_flag(conf, ast_true(value), AST_JB_LOG);
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-23 16:49:12 +00:00
|
|
|
void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
memcpy(&chan->jb.conf, conf, sizeof(*conf));
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-23 16:49:12 +00:00
|
|
|
void ast_jb_get_config(const struct ast_channel *chan, struct ast_jb_conf *conf)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-23 16:49:12 +00:00
|
|
|
memcpy(conf, &chan->jb.conf, sizeof(*conf));
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
2008-08-06 00:30:53 +00:00
|
|
|
void ast_jb_empty_and_reset(struct ast_channel *c0, struct ast_channel *c1)
|
|
|
|
{
|
|
|
|
struct ast_jb *jb0 = &c0->jb;
|
|
|
|
struct ast_jb *jb1 = &c1->jb;
|
|
|
|
int c0_use_jb = ast_test_flag(jb0, JB_USE);
|
|
|
|
int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
|
|
|
|
int c1_use_jb = ast_test_flag(jb1, JB_USE);
|
|
|
|
int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
|
|
|
|
|
|
|
|
if (c0_use_jb && c0_jb_is_created && jb0->impl->empty_and_reset) {
|
|
|
|
jb0->impl->empty_and_reset(jb0->jbobj);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c1_use_jb && c1_jb_is_created && jb1->impl->empty_and_reset) {
|
|
|
|
jb1->impl->empty_and_reset(jb1->jbobj);
|
|
|
|
}
|
|
|
|
}
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
/* Implementation functions */
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
/* fixed */
|
|
|
|
static void * jb_create_fixed(struct ast_jb_conf *general_config, long resynch_threshold)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb_conf conf;
|
2008-08-06 00:30:53 +00:00
|
|
|
|
2006-05-31 18:09:52 +00:00
|
|
|
conf.jbsize = general_config->max_size;
|
|
|
|
conf.resync_threshold = resynch_threshold;
|
2008-08-06 00:30:53 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_jb_new(&conf);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static void jb_destroy_fixed(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
|
|
|
/* destroy the jb */
|
2006-06-01 14:07:03 +00:00
|
|
|
fixed_jb_destroy(fixedjb);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = fixed_jb_put_first(fixedjb, fin, fin->len, fin->ts, now);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_put_fixed(void *jb, struct ast_frame *fin, long now)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = fixed_jb_put(fixedjb, fin, fin->len, fin->ts, now);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
|
|
|
struct fixed_jb_frame frame;
|
2006-05-31 18:09:52 +00:00
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = fixed_jb_get(fixedjb, &frame, now, interpl);
|
2006-05-31 18:09:52 +00:00
|
|
|
*fout = frame.data;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static long jb_next_fixed(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_jb_next(fixedjb);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_remove_fixed(void *jb, struct ast_frame **fout)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
|
|
|
struct fixed_jb_frame frame;
|
2006-05-31 18:09:52 +00:00
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = fixed_jb_remove(fixedjb, &frame);
|
2006-05-31 18:09:52 +00:00
|
|
|
*fout = frame.data;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return fixed_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static void jb_force_resynch_fixed(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
fixed_jb_set_force_resynch(fixedjb);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
2008-08-06 00:30:53 +00:00
|
|
|
static void jb_empty_and_reset_fixed(void *jb)
|
|
|
|
{
|
|
|
|
struct fixed_jb *fixedjb = jb;
|
|
|
|
struct fixed_jb_frame f;
|
|
|
|
|
|
|
|
while (fixed_jb_remove(fixedjb, &f) == FIXED_JB_OK) {
|
|
|
|
ast_frfree(f.data);
|
|
|
|
}
|
|
|
|
}
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
/* adaptive */
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static void *jb_create_adaptive(struct ast_jb_conf *general_config, long resynch_threshold)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
|
|
|
jb_conf jbconf;
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
adaptivejb = jb_new();
|
|
|
|
if (adaptivejb) {
|
2006-05-31 18:09:52 +00:00
|
|
|
jbconf.max_jitterbuf = general_config->max_size;
|
|
|
|
jbconf.resync_threshold = general_config->resync_threshold;
|
|
|
|
jbconf.max_contig_interp = 10;
|
2006-06-01 14:07:03 +00:00
|
|
|
jb_setconf(adaptivejb, &jbconf);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return adaptivejb;
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static void jb_destroy_adaptive(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb = (jitterbuf *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
jb_destroy(adaptivejb);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
return jb_put_adaptive(jb, fin, now);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb = (jitterbuf *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = jb_put(adaptivejb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return adaptive_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb = (jitterbuf *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
jb_frame frame;
|
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = jb_get(adaptivejb, &frame, now, interpl);
|
2006-05-31 18:09:52 +00:00
|
|
|
*fout = frame.data;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return adaptive_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static long jb_next_adaptive(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb = (jitterbuf *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return jb_next(adaptivejb);
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static int jb_remove_adaptive(void *jb, struct ast_frame **fout)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
2006-06-01 14:07:03 +00:00
|
|
|
jitterbuf *adaptivejb = (jitterbuf *) jb;
|
2006-05-31 18:09:52 +00:00
|
|
|
jb_frame frame;
|
|
|
|
int res;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
res = jb_getall(adaptivejb, &frame);
|
2006-05-31 18:09:52 +00:00
|
|
|
*fout = frame.data;
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
return adaptive_to_abstract_code[res];
|
2006-05-31 18:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-01 14:07:03 +00:00
|
|
|
static void jb_force_resynch_adaptive(void *jb)
|
2006-05-31 18:09:52 +00:00
|
|
|
{
|
|
|
|
}
|
2008-08-06 00:30:53 +00:00
|
|
|
|
|
|
|
static void jb_empty_and_reset_adaptive(void *jb)
|
|
|
|
{
|
|
|
|
jitterbuf *adaptivejb = jb;
|
|
|
|
jb_frame f;
|
|
|
|
|
|
|
|
while (jb_getall(adaptivejb, &f) == JB_OK) {
|
|
|
|
ast_frfree(f.data);
|
|
|
|
}
|
|
|
|
|
|
|
|
jb_reset(adaptivejb);
|
|
|
|
}
|