int ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1)
{
struct ast_jb *jb0 = ast_channel_jb(c0);
struct ast_jb *jb1 = ast_channel_jb(c1);
struct ast_jb_conf *conf0 = &jb0->conf;
struct ast_jb_conf *conf1 = &jb1->conf;
int c0_wants_jitter = ast_channel_tech(c0)->properties & AST_CHAN_TP_WANTSJITTER;
int c0_creates_jitter = ast_channel_tech(c0)->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 = ast_channel_tech(c1)->properties & AST_CHAN_TP_WANTSJITTER;
int c1_creates_jitter = ast_channel_tech(c1)->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);
}
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;
}
void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1)
{
struct ast_jb *jb0 = ast_channel_jb(c0);
struct ast_jb *jb1 = ast_channel_jb(c1);
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);
}
void ast_jb_destroy(struct ast_channel *chan)
{
struct ast_jb *jb = ast_channel_jb(chan);
const 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) == AST_JB_IMPL_OK) {
ast_frfree(f);
}
jbimpl->destroy(jbobj);
jb->jbobj = NULL;
ast_clear_flag(jb, JB_CREATED);
ast_verb(3, "%s jitterbuffer destroyed on channel %s\n", jbimpl->name, ast_channel_name(chan));
}
}
void ast_jb_enable_for_channel(struct ast_channel *chan)
{
struct ast_jb_conf conf = ast_channel_jb(chan)->conf;
if (ast_test_flag(&conf, AST_JB_ENABLED)) {
ast_jb_create_framehook(chan, &conf, 1);
}
}
void ast_jb_empty_and_reset(struct ast_channel *c0, struct ast_channel *c1)
{
struct ast_jb *jb0 = ast_channel_jb(c0);
struct ast_jb *jb1 = ast_channel_jb(c1);
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);
}
}
static void jb_get_and_deliver(struct ast_channel *chan)
{
struct ast_jb *jb = ast_channel_jb(chan);
const struct ast_jb_impl *jbimpl = jb->impl;
void *jbobj = jb->jbobj;
struct ast_frame *f, finterp = { .frametype = AST_FRAME_VOICE, };
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);
switch (res) {
case AST_JB_IMPL_OK:
/* deliver the frame */
ast_write(chan, f);
case AST_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);
ast_format_copy(&jb->last_format, &f->subclass.format);
ast_frfree(f);
break;
case AST_JB_IMPL_INTERP:
/* interpolate a frame */
f = &finterp;
ast_format_copy(&f->subclass.format, &jb->last_format);
f->samples = interpolation_len * 8;
f->src = "JB interpolation";
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 AST_JB_IMPL_NOFRAME:
ast_log(LOG_WARNING,
"AST_JB_IMPL_NOFRAME is returned from the %s jb when now=%ld >= next=%ld, jbnext=%ld!\n",
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");
ast_assert("JB type unknown" == NULL);
break;
}
jb->next = jbimpl->next(jbobj);
}
}
int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left)
{
struct ast_jb *jb0 = ast_channel_jb(c0);
struct ast_jb *jb1 = ast_channel_jb(c1);
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;
}
static void jb_choose_impl(struct ast_channel *chan)
{
struct ast_jb *jb = ast_channel_jb(chan);
struct ast_jb_conf *jbconf = &jb->conf;
const struct ast_jb_impl *test_impl;
int i, avail_impl_count = ARRAY_LEN(avail_impl);
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;
}
}
}
void ast_jb_get_config(const struct ast_channel *chan, struct ast_jb_conf *conf)
{
memcpy(conf, &ast_channel_jb((struct ast_channel *) chan)->conf, sizeof(*conf));
}
void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
{
memcpy(&ast_channel_jb(chan)->conf, conf, sizeof(*conf));
}
static int create_jb(struct ast_channel *chan, struct ast_frame *frr)
{
struct ast_jb *jb = ast_channel_jb(chan);
struct ast_jb_conf *jbconf = &jb->conf;
const 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", ast_channel_name(chan));
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
some implementations (i.e. adaptive's when resynch_threshold is specified) to drop it. */
if (res != AST_JB_IMPL_OK) {
ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", ast_channel_name(chan));
/*
jbimpl->destroy(jbobj);
return -1;
*/
}
/* Init next */
jb->next = jbimpl->next(jbobj);
/* Init last format for a first time. */
ast_format_copy(&jb->last_format, &frr->subclass.format);
/* Create a frame log file */
if (ast_test_flag(jbconf, AST_JB_LOG)) {
char safe_logfile[30] = "/tmp/logfile-XXXXXX";
int safe_fd;
snprintf(name2, sizeof(name2), "%s", ast_channel_name(chan));
if ((tmp = strchr(name2, '/'))) {
*tmp = '#';
}
bridged = ast_bridged_channel(chan);
/* We should always have bridged chan if a jitterbuffer is in use */
ast_assert(bridged != NULL);
snprintf(name1, sizeof(name1), "%s", ast_channel_name(bridged));
if ((tmp = strchr(name1, '/'))) {
*tmp = '#';
}
snprintf(logfile_pathname, sizeof(logfile_pathname),
"/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
unlink(logfile_pathname);
safe_fd = mkstemp(safe_logfile);
if (safe_fd < 0 || link(safe_logfile, logfile_pathname) || unlink(safe_logfile) || !(jb->logfile = fdopen(safe_fd, "w+b"))) {
ast_log(LOG_ERROR, "Failed to create frame log file with pathname '%s': %s\n", logfile_pathname, strerror(errno));
jb->logfile = NULL;
if (safe_fd > -1) {
close(safe_fd);
}
}
if (res == AST_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);
}
}
ast_verb(3, "%s jitterbuffer created on channel %s\n", jbimpl->name, ast_channel_name(chan));
/* Free the frame if it has not been queued in the jb */
if (res != AST_JB_IMPL_OK) {
ast_frfree(frr);
}
return 0;
}
int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
{
struct ast_jb *jb = ast_channel_jb(chan);
const 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. */
if (!ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO) || f->len < 2 || f->ts < 0) {
ast_log(LOG_WARNING, "%s received frame with invalid timing info: "
"has_timing_info=%d, len=%ld, ts=%ld, src=%s\n",
ast_channel_name(chan), ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO), f->len, f->ts, f->src);
return -1;
}
frr = ast_frdup(f);
if (!frr) {
ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", ast_channel_name(chan));
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) != AST_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;
}
}