/*! \brief Frame hook callback for reading */
static struct ast_frame *t38_framehook_read(struct ast_sip_session *session, struct ast_frame *f)
{
if (ast_channel_fdno(session->channel) == 5) {
RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
session_media->udptl) {
f = ast_udptl_read(session_media->udptl);
}
}
return f;
}
static struct ast_frame *hook_event_cb(struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
{
struct jb_framedata *framedata = data;
struct timeval now_tv;
unsigned long now;
int putframe = 0; /* signifies if audio frame was placed into the buffer or not */
switch (event) {
case AST_FRAMEHOOK_EVENT_READ:
break;
case AST_FRAMEHOOK_EVENT_ATTACHED:
case AST_FRAMEHOOK_EVENT_DETACHED:
case AST_FRAMEHOOK_EVENT_WRITE:
return frame;
}
if (ast_channel_fdno(chan) == AST_JITTERBUFFER_FD && framedata->timer) {
if (ast_timer_ack(framedata->timer, 1) < 0) {
ast_log(LOG_ERROR, "Failed to acknowledge timer in jitter buffer\n");
return frame;
}
}
if (!frame) {
return frame;
}
now_tv = ast_tvnow();
now = ast_tvdiff_ms(now_tv, framedata->start_tv);
if (frame->frametype == AST_FRAME_VOICE) {
int res;
struct ast_frame *jbframe;
if (!ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO) || frame->len < 2 || frame->ts < 0) {
/* only frames with timing info can enter the jitterbuffer */
return frame;
}
jbframe = ast_frisolate(frame);
ao2_replace(framedata->last_format, frame->subclass.format);
if (frame->len && (frame->len != framedata->timer_interval)) {
framedata->timer_interval = frame->len;
ast_timer_set_rate(framedata->timer, 1000 / framedata->timer_interval);
}
if (!framedata->first) {
framedata->first = 1;
res = framedata->jb_impl->put_first(framedata->jb_obj, jbframe, now);
} else {
res = framedata->jb_impl->put(framedata->jb_obj, jbframe, now);
}
if (res == AST_JB_IMPL_OK) {
if (jbframe != frame) {
ast_frfree(frame);
}
frame = &ast_null_frame;
} else if (jbframe != frame) {
ast_frfree(jbframe);
}
putframe = 1;
}
if (frame->frametype == AST_FRAME_NULL) {
int res;
long next = framedata->jb_impl->next(framedata->jb_obj);
/* If now is earlier than the next expected output frame
* from the jitterbuffer we may choose to pass on retrieving
* a frame during this read iteration. The only exception
* to this rule is when an audio frame is placed into the buffer
* and the time for the next frame to come out of the buffer is
* at least within the timer_interval of the next output frame. By
* doing this we are able to feed off the timing of the input frames
* and only rely on our jitterbuffer timer when frames are dropped.
* During testing, this hybrid form of timing gave more reliable results. */
if (now < next) {
long int diff = next - now;
if (!putframe) {
return frame;
} else if (diff >= framedata->timer_interval) {
return frame;
}
}
ast_frfree(frame);
frame = &ast_null_frame;
res = framedata->jb_impl->get(framedata->jb_obj, &frame, now, framedata->timer_interval);
switch (res) {
case AST_JB_IMPL_OK:
/* got it, and pass it through */
break;
case AST_JB_IMPL_DROP:
ast_frfree(frame);
frame = &ast_null_frame;
break;
case AST_JB_IMPL_INTERP:
if (framedata->last_format) {
struct ast_frame tmp = { 0, };
tmp.frametype = AST_FRAME_VOICE;
tmp.subclass.format = framedata->last_format;
/* example: 8000hz / (1000 / 20ms) = 160 samples */
tmp.samples = ast_format_get_sample_rate(framedata->last_format) / (1000 / framedata->timer_interval);
tmp.delivery = ast_tvadd(framedata->start_tv, ast_samp2tv(next, 1000));
tmp.offset = AST_FRIENDLY_OFFSET;
tmp.src = "func_jitterbuffer interpolation";
ast_frfree(frame);
frame = ast_frdup(&tmp);
break;
}
/* else fall through */
case AST_JB_IMPL_NOFRAME:
ast_frfree(frame);
frame = &ast_null_frame;
break;
}
}
if (frame->frametype == AST_FRAME_CONTROL) {
switch(frame->subclass.integer) {
case AST_CONTROL_HOLD:
case AST_CONTROL_UNHOLD:
case AST_CONTROL_T38_PARAMETERS:
case AST_CONTROL_SRCUPDATE:
case AST_CONTROL_SRCCHANGE:
framedata->jb_impl->force_resync(framedata->jb_obj);
break;
default:
break;
}
}
return frame;
}
