abstract_jb.c File Reference

Common implementation-independent jitterbuffer stuff. More...

#include "asterisk.h"
#include "asterisk/frame.h"
#include "asterisk/channel.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/pbx.h"
#include "asterisk/timing.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/format_cache.h"
#include "asterisk/abstract_jb.h"
#include "fixedjitterbuf.h"
#include "jitterbuf.h"

Include dependency graph for abstract_jb.c:

Go to the source code of this file.

Data Structures
struct	jb_framedata
struct	jb_stream_sync

Macros
#define	DEFAULT_RESYNC   1000
#define	DEFAULT_SIZE   200
#define	DEFAULT_TARGET_EXTRA   40
#define	DEFAULT_TIMER_INTERVAL   20
#define	DEFAULT_TYPE   AST_JB_FIXED
#define	jb_framelog(...)
	Macros for the frame log files. More...
#define	MAXIMUM_EARLY_FRAME_COUNT   200

Enumerations
enum	{ JB_USE = (1 << 0) , JB_TIMEBASE_INITIALIZED = (1 << 1) , JB_CREATED = (1 << 2) }

Functions
void	ast_jb_conf_default (struct ast_jb_conf *conf)
	Sets the contents of an ast_jb_conf struct to the default jitterbuffer settings. More...
void	ast_jb_configure (struct ast_channel *chan, const struct ast_jb_conf *conf)
	Configures a jitterbuffer on a channel. More...
void	ast_jb_create_framehook (struct ast_channel *chan, struct ast_jb_conf *jb_conf, int prefer_existing)
	Applies a jitterbuffer framehook to a channel based on a provided jitterbuffer config. More...
void	ast_jb_destroy (struct ast_channel *chan)
	Destroys jitterbuffer on a channel. More...
int	ast_jb_do_usecheck (struct ast_channel *c0, struct ast_channel *c1)
	Checks the need of a jb use in a generic bridge. More...
void	ast_jb_empty_and_reset (struct ast_channel *c0, struct ast_channel *c1)
	drops all frames from a jitterbuffer and resets it More...
void	ast_jb_enable_for_channel (struct ast_channel *chan)
	Sets a jitterbuffer frame hook on the channel based on the channel's stored jitterbuffer configuration. More...
void	ast_jb_get_and_deliver (struct ast_channel *c0, struct ast_channel *c1)
	Deliver the queued frames that should be delivered now for both channels. More...
void	ast_jb_get_config (const struct ast_channel *chan, struct ast_jb_conf *conf)
	Copies a channel's jitterbuffer configuration. More...
const struct ast_jb_impl *	ast_jb_get_impl (enum ast_jb_type type)
int	ast_jb_get_when_to_wakeup (struct ast_channel *c0, struct ast_channel *c1, int time_left)
	Calculates the time, left to the closest delivery moment in a bridge. More...
int	ast_jb_put (struct ast_channel *chan, struct ast_frame *f)
	Puts a frame into a channel jitterbuffer. More...
int	ast_jb_read_conf (struct ast_jb_conf *conf, const char *varname, const char *value)
	Sets jitterbuffer configuration property. More...
static int	create_jb (struct ast_channel *chan, struct ast_frame *first_frame)
static void	datastore_destroy_cb (void *data)
static long	get_now (struct ast_jb *jb, struct timeval *tv)
static void	hook_destroy_cb (void *framedata)
static struct ast_frame *	hook_event_cb (struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
static void	jb_choose_impl (struct ast_channel *chan)
static void *	jb_create_adaptive (struct ast_jb_conf *general_config)
static void *	jb_create_fixed (struct ast_jb_conf *general_config)
static void	jb_destroy_adaptive (void *jb)
static void	jb_destroy_fixed (void *jb)
static void	jb_empty_and_reset_adaptive (void *jb)
static void	jb_empty_and_reset_fixed (void *jb)
static void	jb_force_resynch_adaptive (void *jb)
static void	jb_force_resynch_fixed (void *jb)
static void	jb_framedata_destroy (struct jb_framedata *framedata)
static int	jb_framedata_init (struct jb_framedata *framedata, struct ast_jb_conf *jb_conf)
static int	jb_get_adaptive (void *jb, struct ast_frame **fout, long now, long interpl)
static void	jb_get_and_deliver (struct ast_channel *chan)
static int	jb_get_fixed (void *jb, struct ast_frame **fout, long now, long interpl)
static int	jb_is_late_adaptive (void *jb, long ts)
static int	jb_is_late_fixed (void *jb, long ts)
static long	jb_next_adaptive (void *jb)
static long	jb_next_fixed (void *jb)
static int	jb_put_adaptive (void *jb, struct ast_frame *fin, long now)
static int	jb_put_first_adaptive (void *jb, struct ast_frame *fin, long now)
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_remove_adaptive (void *jb, struct ast_frame **fout)
static int	jb_remove_fixed (void *jb, struct ast_frame **fout)
static struct timeval	jitterbuffer_frame_get_ntp_timestamp (const struct jb_stream_sync *stream_sync, const struct ast_frame *frame)

Variables
static const int	adaptive_to_abstract_code []
static const struct ast_jb_impl	avail_impl []
static int	default_impl = 0
static const int	fixed_to_abstract_code []
static const struct ast_datastore_info	jb_datastore
static const char *const	jb_get_actions [] = {"Delivered", "Dropped", "Interpolated", "No"}

Detailed Description

Common implementation-independent jitterbuffer stuff.

Author

Slav Klenov slav@.nosp@m.secu.nosp@m.rax.o.nosp@m.rg

Definition in file abstract_jb.c.

Macro Definition Documentation

DEFAULT_RESYNC

#define DEFAULT_RESYNC   1000

Definition at line 839 of file abstract_jb.c.

DEFAULT_SIZE

#define DEFAULT_SIZE   200

Definition at line 837 of file abstract_jb.c.

DEFAULT_TARGET_EXTRA

#define DEFAULT_TARGET_EXTRA   40

Definition at line 838 of file abstract_jb.c.

DEFAULT_TIMER_INTERVAL

#define DEFAULT_TIMER_INTERVAL   20

Definition at line 836 of file abstract_jb.c.

DEFAULT_TYPE

#define DEFAULT_TYPE   AST_JB_FIXED

Definition at line 840 of file abstract_jb.c.

jb_framelog

#define jb_framelog

(

...

)

Macros for the frame log files.

Definition at line 130 of file abstract_jb.c.

MAXIMUM_EARLY_FRAME_COUNT

#define MAXIMUM_EARLY_FRAME_COUNT   200

The maximum size we allow the early frame buffer to get

Definition at line 59 of file abstract_jb.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Internal jb flags

Enumerator
JB_USE
JB_TIMEBASE_INITIALIZED
JB_CREATED

Definition at line 52 of file abstract_jb.c.

     {
    JB_USE =                  (1 << 0),
    JB_TIMEBASE_INITIALIZED = (1 << 1),
    JB_CREATED =              (1 << 2)
};

Function Documentation

ast_jb_conf_default()

void ast_jb_conf_default

(

struct ast_jb_conf *

conf

)

Sets the contents of an ast_jb_conf struct to the default jitterbuffer settings.

Since

12

Parameters

conf	Which jitterbuffer is being set

Definition at line 890 of file abstract_jb.c.

{
    ast_clear_flag(conf, AST_FLAGS_ALL);
    conf->max_size = DEFAULT_SIZE;
    conf->resync_threshold = DEFAULT_RESYNC;
    ast_copy_string(conf->impl, "fixed", sizeof(conf->impl));
    conf->target_extra = DEFAULT_TARGET_EXTRA;
}

References ast_clear_flag, ast_copy_string(), AST_FLAGS_ALL, DEFAULT_RESYNC, DEFAULT_SIZE, and DEFAULT_TARGET_EXTRA.

Referenced by jb_helper().

ast_jb_configure()

void ast_jb_configure	(	struct ast_channel *	chan,
		const struct ast_jb_conf *	conf
	)

Configures a jitterbuffer on a channel.

Parameters

chan	channel to configure.
conf	configuration to apply.

Called from a channel driver when a channel is created and its jitterbuffer needs to be configured.

Definition at line 593 of file abstract_jb.c.

{
    memcpy(&ast_channel_jb(chan)->conf, conf, sizeof(*conf));
}

References ast_channel_jb().

Referenced by ast_unreal_new_channels(), console_new(), dahdi_new(), ooh323_new(), and unistim_new().

ast_jb_create_framehook()

void ast_jb_create_framehook	(	struct ast_channel *	chan,
		struct ast_jb_conf *	jb_conf,
		int	prefer_existing
	)

Applies a jitterbuffer framehook to a channel based on a provided jitterbuffer config.

Since

12

Parameters

chan	Which channel the jitterbuffer is being set on
jb_conf	Configuration to use for the jitterbuffer
prefer_existing	If this is true and a jitterbuffer already exists for the channel, use the existing jitterbuffer

Definition at line 1267 of file abstract_jb.c.

{
    struct jb_framedata *framedata;
    struct ast_datastore *datastore = NULL;
    struct ast_framehook_interface interface = {
        .version = AST_FRAMEHOOK_INTERFACE_VERSION,
        .event_cb = hook_event_cb,
        .destroy_cb = hook_destroy_cb,
    };
    int i = 0;
 
    /* If disabled, strip any existing jitterbuffer and don't replace it. */
    if (!strcasecmp(jb_conf->impl, "disabled")) {
        int *id;
        ast_channel_lock(chan);
        if ((datastore = ast_channel_datastore_find(chan, &jb_datastore, NULL))) {
            id = datastore->data;
            ast_framehook_detach(chan, *id);
            ast_channel_datastore_remove(chan, datastore);
            ast_datastore_free(datastore);
        }
        ast_channel_unlock(chan);
        return;
    }
 
    if (!(framedata = ast_calloc(1, sizeof(*framedata)))) {
        return;
    }
 
    if (jb_framedata_init(framedata, jb_conf)) {
        jb_framedata_destroy(framedata);
        return;
    }
 
    interface.data = framedata;
 
    ast_channel_lock(chan);
    i = ast_framehook_attach(chan, &interface);
    if (i >= 0) {
        int *id;
        if ((datastore = ast_channel_datastore_find(chan, &jb_datastore, NULL))) {
            /* There is already a jitterbuffer on the channel. */
            if (prefer_existing) {
                /* We prefer the existing jitterbuffer, so remove the new one and keep the old one. */
                ast_framehook_detach(chan, i);
                ast_channel_unlock(chan);
                return;
            }
            /* We prefer the new jitterbuffer, so strip the old one. */
            id = datastore->data;
            ast_framehook_detach(chan, *id);
            ast_channel_datastore_remove(chan, datastore);
            ast_datastore_free(datastore);
        }
 
        if (!(datastore = ast_datastore_alloc(&jb_datastore, NULL))) {
            ast_framehook_detach(chan, i);
            ast_channel_unlock(chan);
            return;
        }
 
        if (!(id = ast_calloc(1, sizeof(int)))) {
            ast_datastore_free(datastore);
            ast_framehook_detach(chan, i);
            ast_channel_unlock(chan);
            return;
        }
 
        *id = i; /* Store off the id. The channel is still locked so it is safe to access this ptr. */
        datastore->data = id;
        ast_channel_datastore_add(chan, datastore);
 
        ast_channel_set_fd(chan, AST_JITTERBUFFER_FD, framedata->timer_fd);
    } else {
        jb_framedata_destroy(framedata);
        framedata = NULL;
    }
    ast_channel_unlock(chan);
}

References ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_set_fd(), ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), ast_framehook_attach(), ast_framehook_detach(), AST_FRAMEHOOK_INTERFACE_VERSION, AST_JITTERBUFFER_FD, ast_datastore::data, ast_framehook_interface::data, hook_destroy_cb(), hook_event_cb(), id, jb_datastore, jb_framedata_destroy(), jb_framedata_init(), NULL, jb_framedata::timer_fd, and ast_framehook_interface::version.

Referenced by ast_jb_enable_for_channel(), and jb_helper().

ast_jb_destroy()

void ast_jb_destroy

(

struct ast_channel *

chan

)

Destroys jitterbuffer on a channel.

Parameters

chan

channel.

Called from ast_channel_free() when a channel is destroyed.

Definition at line 502 of file abstract_jb.c.

{
    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;
    }
 
    ao2_cleanup(jb->last_format);
 
    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));
    }
}

References ao2_cleanup, ast_channel_jb(), ast_channel_name(), ast_clear_flag, ast_frfree, AST_JB_IMPL_OK, ast_test_flag, ast_verb, ast_jb_impl::destroy, ast_jb::impl, JB_CREATED, ast_jb::jbobj, ast_jb::last_format, ast_jb::logfile, ast_jb_impl::name, NULL, and ast_jb_impl::remove.

Referenced by ast_channel_destructor().

ast_jb_do_usecheck()

int ast_jb_do_usecheck	(	struct ast_channel *	c0,
		struct ast_channel *	c1
	)

Checks the need of a jb use in a generic bridge.

Parameters

c0	first bridged channel.
c1	second bridged channel.

Called from ast_generic_bridge() when two channels are entering in a bridge. The function checks the need of a jitterbuffer, depending on both channel's configuration and technology properties. As a result, this function sets appropriate internal jb flags to the channels, determining further behaviour of the bridged jitterbuffers.

Return values

zero	if there are no jitter buffers in use
non-zero	if there are

Definition at line 170 of file abstract_jb.c.

{
    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;
}

References AST_CHAN_TP_CREATESJITTER, AST_CHAN_TP_WANTSJITTER, ast_channel_jb(), ast_channel_tech(), AST_JB_ENABLED, AST_JB_FORCED, ast_set_flag, ast_test_flag, ast_jb::conf, jb_choose_impl(), JB_CREATED, JB_TIMEBASE_INITIALIZED, JB_USE, NULL, ast_channel_tech::properties, and ast_jb::timebase.

ast_jb_empty_and_reset()

void ast_jb_empty_and_reset	(	struct ast_channel *	c0,
		struct ast_channel *	c1
	)

drops all frames from a jitterbuffer and resets it

Parameters

c0	one channel of a bridge
c1	the other channel of the bridge

Definition at line 604 of file abstract_jb.c.

{
    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);
    }
}

References ast_channel_jb(), ast_test_flag, ast_jb_impl::empty_and_reset, ast_jb::impl, JB_CREATED, JB_USE, and ast_jb::jbobj.

ast_jb_enable_for_channel()

void ast_jb_enable_for_channel

(

struct ast_channel *

chan

)

Sets a jitterbuffer frame hook on the channel based on the channel's stored jitterbuffer configuration.

Since

12.0

Parameters

chan	Which channel is being set up

Definition at line 585 of file abstract_jb.c.

{
    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);
    }
}

References ast_channel_jb(), ast_jb_create_framehook(), AST_JB_ENABLED, ast_test_flag, and ast_jb::conf.

Referenced by bridge_channel_internal_join().

ast_jb_get_and_deliver()

void ast_jb_get_and_deliver	(	struct ast_channel *	c0,
		struct ast_channel *	c1
	)

Deliver the queued frames that should be delivered now for both channels.

Parameters

c0	first bridged channel.
c1	second bridged channel.

Called from ast_generic_bridge() to deliver any frames, that should be delivered for the moment of invocation. Does nothing if neihter of the channels is using jb or has any frames currently queued in. The function delivers frames using ast_write() each of the channels.

Definition at line 336 of file abstract_jb.c.

{
    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);
}

References ast_channel_jb(), ast_test_flag, JB_CREATED, jb_get_and_deliver(), and JB_USE.

ast_jb_get_config()

void ast_jb_get_config	(	const struct ast_channel *	chan,
		struct ast_jb_conf *	conf
	)

Copies a channel's jitterbuffer configuration.

Parameters

chan	channel.
conf	destination.

Definition at line 599 of file abstract_jb.c.

{
    memcpy(conf, &ast_channel_jb((struct ast_channel *) chan)->conf, sizeof(*conf));
}

References ast_channel_jb().

ast_jb_get_impl()

const struct ast_jb_impl * ast_jb_get_impl

(

enum ast_jb_type

type

)

Definition at line 820 of file abstract_jb.c.

{
    int i;
    for (i = 0; i < ARRAY_LEN(avail_impl); i++) {
        if (avail_impl[i].type == type) {
            return &avail_impl[i];
        }
    }
    return NULL;
}

References ARRAY_LEN, avail_impl, NULL, and type.

Referenced by jb_framedata_init().

ast_jb_get_when_to_wakeup()

int ast_jb_get_when_to_wakeup	(	struct ast_channel *	c0,
		struct ast_channel *	c1,
		int	time_left
	)

Calculates the time, left to the closest delivery moment in a bridge.

Parameters

c0	first bridged channel.
c1	second bridged channel.
time_left	bridge time limit, or -1 if not set.

Called from ast_generic_bridge() to determine the maximum time to wait for activity in ast_waitfor_n() call. If neihter of the channels is using jb, this function returns the time limit passed.

Returns

maximum time to wait.

Definition at line 231 of file abstract_jb.c.

{
    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;
}

References ast_channel_jb(), ast_test_flag, get_now(), JB_CREATED, JB_USE, ast_jb::next, and NULL.

ast_jb_put()

int ast_jb_put	(	struct ast_channel *	chan,
		struct ast_frame *	f
	)

Puts a frame into a channel jitterbuffer.

Parameters

chan	channel.
f	frame.

Called from ast_generic_bridge() to put a frame into a channel's jitterbuffer. The function will successfuly enqueue a frame if and only if:

1. the channel is using a jitterbuffer (as determined by ast_jb_do_usecheck()),
2. the frame's type is AST_FRAME_VOICE,
3. the frame has timing info set and has length >= 2 ms,
4. there is no some internal error happened (like failed memory allocation). Frames, successfuly queued, should be delivered by the channel's jitterbuffer, when their delivery time has came. Frames, not successfuly queued, should be delivered immediately. Dropped by the jb implementation frames are considered successfuly enqueued as far as they should not be delivered at all.

Return values

0	if the frame was queued
-1	if not

Definition at line 271 of file abstract_jb.c.

{
    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=%u, 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;
    }
}

References ast_channel_jb(), ast_channel_name(), ast_clear_flag, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frdup, AST_FRFLAG_HAS_TIMING_INFO, ast_frfree, AST_JB_IMPL_OK, ast_log, ast_set_flag, ast_test_flag, create_jb(), ast_jb_impl::force_resync, ast_frame::frametype, get_now(), ast_jb::impl, JB_CREATED, jb_framelog, JB_USE, ast_jb::jbobj, ast_frame::len, LOG_ERROR, LOG_WARNING, ast_jb_impl::next, ast_jb::next, NULL, ast_jb_impl::put, ast_frame::src, and ast_frame::ts.

ast_jb_read_conf()

int ast_jb_read_conf	(	struct ast_jb_conf *	conf,
		const char *	varname,
		const char *	value
	)

Sets jitterbuffer configuration property.

Parameters

conf	configuration to store the property in.
varname	property name.
value	property value.

Called from a channel driver to build a jitterbuffer configuration typically when reading a configuration file. It is not necessary for a channel driver to know each of the jb configuration property names. The jitterbuffer itself knows them. The channel driver can pass each config var it reads through this function. It will return 0 if the variable was consumed from the jb conf.

Returns

zero if the property was set to the configuration, -1 if not.

Definition at line 545 of file abstract_jb.c.

{
    int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
    const char *name;
    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_TARGET_EXTRA)) {
        if (sscanf(value, "%30d", &tmp) == 1) {
            conf->target_extra = tmp;
        }
    } else if (!strcasecmp(name, AST_JB_CONF_LOG)) {
        ast_set2_flag(conf, ast_true(value), AST_JB_LOG);
    } else if (!strcasecmp(name, AST_JB_CONF_SYNC_VIDEO)) {
        ast_set2_flag(conf, ast_true(value), AST_JB_SYNC_VIDEO);
    } else {
        return -1;
    }
 
    return 0;
}

References AST_JB_CONF_ENABLE, AST_JB_CONF_FORCE, AST_JB_CONF_IMPL, AST_JB_CONF_LOG, AST_JB_CONF_MAX_SIZE, AST_JB_CONF_PREFIX, AST_JB_CONF_RESYNCH_THRESHOLD, AST_JB_CONF_SYNC_VIDEO, AST_JB_CONF_TARGET_EXTRA, AST_JB_ENABLED, AST_JB_FORCED, AST_JB_LOG, AST_JB_SYNC_VIDEO, ast_set2_flag, ast_strlen_zero(), ast_true(), name, tmp(), and value.

Referenced by jb_helper(), process_dahdi(), reload_config(), and store_config_core().

create_jb()

static int create_jb ( struct ast_channel *  chan, struct ast_frame *  first_frame  )

static

Definition at line 413 of file abstract_jb.c.

{
    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;
    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);
    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. */
    jb->last_format = ao2_bump(frr->subclass.format);
 
    /* Create a frame log file */
    if (ast_test_flag(jbconf, AST_JB_LOG)) {
        struct ast_channel *bridged = ast_channel_bridge_peer(chan);
        char safe_logfile[30] = "/tmp/logfile-XXXXXX";
        int safe_fd;
 
        snprintf(name2, sizeof(name2), "%s", ast_channel_name(chan));
        while ((tmp = strchr(name2, '/'))) {
            *tmp = '#';
        }
 
        /* 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));
        while ((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_channel_cleanup(bridged);
    }
 
    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;
}

References ao2_bump, ast_assert, ast_channel_bridge_peer(), ast_channel_cleanup, ast_channel_jb(), AST_CHANNEL_NAME, ast_channel_name(), ast_frfree, AST_JB_IMPL_NAME_SIZE, AST_JB_IMPL_OK, AST_JB_LOG, ast_log, ast_test_flag, ast_verb, ast_jb::conf, ast_jb_impl::create, errno, ast_frame_subclass::format, get_now(), ast_jb::impl, ast_channel::jb, jb_framelog, ast_jb::jbobj, ast_jb::last_format, ast_frame::len, LOG_ERROR, LOG_WARNING, ast_jb::logfile, ast_jb_impl::name, ast_jb_impl::next, ast_jb::next, NULL, ast_jb_impl::put_first, ast_frame::subclass, tmp(), and ast_frame::ts.

Referenced by ast_jb_put().

datastore_destroy_cb()

static void datastore_destroy_cb ( void *  data )

static

Definition at line 899 of file abstract_jb.c.

                                             {
    ast_free(data);
    ast_debug(1, "JITTERBUFFER datastore destroyed\n");
}

References ast_debug, ast_free, and ast_frame::data.

get_now()

static long get_now ( struct ast_jb *  jb, struct timeval *  tv  )

static

Definition at line 532 of file abstract_jb.c.

{
    struct timeval now;
 
    if (!when) {
        when = &now;
        gettimeofday(when, NULL);
    }
 
    return ast_tvdiff_ms(*when, jb->timebase);
}

References ast_tvdiff_ms(), NULL, and ast_jb::timebase.

Referenced by ast_jb_get_when_to_wakeup(), ast_jb_put(), create_jb(), and jb_get_and_deliver().

hook_destroy_cb()

static void hook_destroy_cb ( void *  framedata )

static

Definition at line 909 of file abstract_jb.c.

{
    ast_debug(1, "JITTERBUFFER hook destroyed\n");
    jb_framedata_destroy((struct jb_framedata *) framedata);
}

References ast_debug, and jb_framedata_destroy().

Referenced by ast_jb_create_framehook().

hook_event_cb()

static struct ast_frame * hook_event_cb ( struct ast_channel *  chan, struct ast_frame *  frame, enum ast_framehook_event  event, void *  data  )

static

Definition at line 953 of file abstract_jb.c.

{
    struct jb_framedata *framedata = data;
    struct timeval now_tv;
    int64_t relative_frame_start;
    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 the frame has been requeued (for instance when the translate core returns
     * more than one frame) then if the frame is late we want to immediately return
     * it. Otherwise attempt to insert it into the jitterbuffer.
     *
     * If the frame is requeued and late then in all likely hood it's a frame that
     * that was previously retrieved from the jitterbuffer, passed to the translate
     * core, and then put back into the channel read queue. Even if it had not been
     * in the jitterbuffer prior to now it needs to be the next frame "out".
     *
     * However late arriving frames that have not been requeued (i.e. regular frames)
     * need to be passed to the jitterbuffer so they can be appropriately dropped. As
     * well any requeued frames that are not late should be put into the jitterbuffer.
     */
    if (!frame || (ast_test_flag(frame, AST_FRFLAG_REQUEUED) &&
               framedata->jb_impl->is_late(framedata->jb_obj, frame->ts))) {
        return frame;
    }
 
    if (ast_test_flag(&framedata->jb_conf, AST_JB_SYNC_VIDEO)) {
        if (frame->frametype == AST_FRAME_VOICE) {
            /* Store the stream identifier for the audio stream so we can associate the incoming RTCP SR
             * with the correct stream sync structure.
             */
            framedata->audio_stream_id = frame->stream_num;
        } else if (frame->frametype == AST_FRAME_RTCP && frame->subclass.integer == AST_RTP_RTCP_SR) {
            struct ast_rtp_rtcp_report *rtcp_report = frame->data.ptr;
            struct jb_stream_sync *stream_sync = NULL;
 
            /* Determine which stream this RTCP is in regards to */
            if (framedata->audio_stream_id == frame->stream_num) {
                stream_sync = &framedata->audio_stream_sync;
            } else if (framedata->video_stream_id == frame->stream_num) {
                stream_sync = &framedata->video_stream_sync;
            }
 
            if (stream_sync) {
                /* Store the RTP and NTP timestamp mapping so we can derive an NTP timestamp for each frame */
                stream_sync->timestamp = rtcp_report->sender_information.rtp_timestamp;
                stream_sync->ntp = rtcp_report->sender_information.ntp_timestamp;
            }
        } else if (frame->frametype == AST_FRAME_VIDEO) {
            /* If a video frame is late according to the audio timestamp don't stash it away, just return it.
             * If however it is ahead then we keep it until such time as the audio catches up.
             */
            struct ast_frame *jbframe;
 
            framedata->video_stream_id = frame->stream_num;
 
            /* If no timing information is available we can't store this away, so just let it through now */
            if (!ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
                return frame;
            }
 
            /* To ensure that the video starts when the audio starts we only start allowing frames through once
             * audio starts flowing.
             */
            if (framedata->audio_flowing) {
                struct timeval video_timestamp;
 
                video_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->video_stream_sync, frame);
                if (ast_tvdiff_ms(framedata->last_audio_ntp_timestamp, video_timestamp) >= 0) {
                    return frame;
                }
            }
 
            /* To prevent the early frame buffer from growing uncontrolled we impose a maximum count that it can
             * get to. If this is reached then we drop a video frame, which should cause the receiver to ask for a
             * new key frame.
             */
            if (framedata->early_frame_count == MAXIMUM_EARLY_FRAME_COUNT) {
                jbframe = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list);
                framedata->early_frame_count--;
                ast_frfree(jbframe);
            }
 
            jbframe = ast_frisolate(frame);
            if (!jbframe) {
                /* If we can't isolate the frame the safest thing we can do is return it, even if the A/V sync
                 * may be off.
                 */
                return frame;
            }
 
            AST_LIST_INSERT_TAIL(&framedata->early_frames, jbframe, frame_list);
            framedata->early_frame_count++;
            return &ast_null_frame;
        }
    }
 
    now_tv = ast_tvnow();
    relative_frame_start = ast_tvdiff_ms(now_tv, framedata->start_tv);
    if (relative_frame_start < 0) {
        /*
         * The only way for this to happen is if the system time has
         * stepped backwards between the time framedata->start_tv was
         * set and now.  Think an ntpd or systemd-timesyncd adjustment.
         *
         * Just pass the frame through.
         */
        return frame;
    }
 
    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, relative_frame_start);
        } else {
            res = framedata->jb_impl->put(framedata->jb_obj, jbframe, relative_frame_start);
        }
 
        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 relative_frame_start 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 (relative_frame_start < next) {
            long int diff = next - relative_frame_start;
            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, relative_frame_start, 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) {
        struct ast_frame *early_frame;
 
        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);
            /* Since we are resyncing go ahead and clear out the video frames too */
            while ((early_frame = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list))) {
                ast_frfree(early_frame);
            }
            framedata->audio_flowing = 0;
            framedata->early_frame_count = 0;
            break;
        default:
            break;
        }
    }
 
    /* If a voice frame is being passed through see if we need to add any additional frames to it */
    if (ast_test_flag(&framedata->jb_conf, AST_JB_SYNC_VIDEO) && frame->frametype == AST_FRAME_VOICE) {
        AST_LIST_HEAD_NOLOCK(, ast_frame) additional_frames;
        struct ast_frame *early_frame;
 
        /* We store the last NTP timestamp for the audio given to the core so that subsequents frames which
         * are late can be passed immediately through (this will occur for video frames which are returned here)
         */
        framedata->last_audio_ntp_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->audio_stream_sync, frame);
        framedata->audio_flowing = 1;
 
        AST_LIST_HEAD_INIT_NOLOCK(&additional_frames);
 
        AST_LIST_TRAVERSE_SAFE_BEGIN(&framedata->early_frames, early_frame, frame_list) {
            struct timeval early_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->video_stream_sync, early_frame);
            int diff = ast_tvdiff_ms(framedata->last_audio_ntp_timestamp, early_timestamp);
 
            /* If this frame is from the past we need to include it with the audio frame that is going
             * out.
             */
            if (diff >= 0) {
                AST_LIST_REMOVE_CURRENT(frame_list);
                framedata->early_frame_count--;
                AST_LIST_INSERT_TAIL(&additional_frames, early_frame, frame_list);
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
 
        /* Append any additional frames we may want to include (such as video) */
        AST_LIST_NEXT(frame, frame_list) = AST_LIST_FIRST(&additional_frames);
    }
 
    return frame;
}

References ao2_replace, ast_channel_fdno(), AST_CONTROL_HOLD, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_UNHOLD, ast_format_get_sample_rate(), AST_FRAME_CONTROL, AST_FRAME_NULL, AST_FRAME_RTCP, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_FRAMEHOOK_EVENT_ATTACHED, AST_FRAMEHOOK_EVENT_DETACHED, AST_FRAMEHOOK_EVENT_READ, AST_FRAMEHOOK_EVENT_WRITE, ast_frdup, AST_FRFLAG_HAS_TIMING_INFO, AST_FRFLAG_REQUEUED, ast_frfree, AST_FRIENDLY_OFFSET, ast_frisolate, AST_JB_IMPL_DROP, AST_JB_IMPL_INTERP, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_OK, AST_JB_SYNC_VIDEO, AST_JITTERBUFFER_FD, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_HEAD_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_NEXT, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, ast_null_frame, AST_RTP_RTCP_SR, ast_samp2tv(), ast_test_flag, ast_timer_ack(), ast_timer_set_rate(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), jb_framedata::audio_flowing, jb_framedata::audio_stream_id, jb_framedata::audio_stream_sync, ast_frame::data, jb_framedata::early_frame_count, jb_framedata::early_frames, jb_framedata::first, ast_jb_impl::force_resync, ast_frame_subclass::format, ast_frame::frametype, ast_jb_impl::get, ast_frame_subclass::integer, ast_jb_impl::is_late, jb_framedata::jb_conf, jb_framedata::jb_impl, jb_framedata::jb_obj, jitterbuffer_frame_get_ntp_timestamp(), jb_framedata::last_audio_ntp_timestamp, jb_framedata::last_format, ast_frame::len, LOG_ERROR, MAXIMUM_EARLY_FRAME_COUNT, ast_jb_impl::next, ast_frame::next, jb_stream_sync::ntp, ast_rtp_rtcp_report::ntp_timestamp, NULL, ast_frame::ptr, ast_jb_impl::put, ast_jb_impl::put_first, ast_rtp_rtcp_report::rtp_timestamp, ast_rtp_rtcp_report::sender_information, jb_framedata::start_tv, ast_frame::stream_num, ast_frame::subclass, jb_framedata::timer, jb_framedata::timer_interval, jb_stream_sync::timestamp, tmp(), ast_frame::ts, jb_framedata::video_stream_id, and jb_framedata::video_stream_sync.

Referenced by ast_jb_create_framehook().

jb_choose_impl()

static void jb_choose_impl ( struct ast_channel *  chan )

static

Definition at line 148 of file abstract_jb.c.

{
    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;
        }
    }
}

References ARRAY_LEN, ast_channel_jb(), ast_strlen_zero(), avail_impl, ast_jb::conf, default_impl, ast_jb_conf::impl, ast_jb::impl, and ast_jb_impl::name.

Referenced by ast_jb_do_usecheck().

jb_create_adaptive()

static void * jb_create_adaptive ( struct ast_jb_conf *  general_config )

static

Definition at line 727 of file abstract_jb.c.

{
    jb_conf jbconf;
    jitterbuf *adaptivejb;
 
    adaptivejb = jb_new();
    if (adaptivejb) {
        jbconf.max_jitterbuf = general_config->max_size;
        jbconf.resync_threshold = general_config->resync_threshold;
        jbconf.max_contig_interp = 10;
        jbconf.target_extra = general_config->target_extra;
        jb_setconf(adaptivejb, &jbconf);
    }
 
    return adaptivejb;
}

References jb_new(), jb_setconf(), jb_conf::max_contig_interp, jb_conf::max_jitterbuf, ast_jb_conf::max_size, ast_jb_conf::resync_threshold, jb_conf::resync_threshold, ast_jb_conf::target_extra, and jb_conf::target_extra.

jb_create_fixed()

static void * jb_create_fixed ( struct ast_jb_conf *  general_config )

static

Definition at line 625 of file abstract_jb.c.

{
    struct fixed_jb_conf conf;
 
    conf.jbsize = general_config->max_size;
    conf.resync_threshold = general_config->resync_threshold;
 
    return fixed_jb_new(&conf);
}

References fixed_jb_new(), ast_jb_conf::max_size, and ast_jb_conf::resync_threshold.

jb_destroy_adaptive()

static void jb_destroy_adaptive ( void *  jb )

static

Definition at line 745 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = (jitterbuf *) jb;
 
    jb_destroy(adaptivejb);
}

References jb_destroy().

jb_destroy_fixed()

static void jb_destroy_fixed ( void *  jb )

static

Definition at line 635 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 
    /* Ensure the fixed jb is empty - otherwise it will raise an ASSERT */
    jb_empty_and_reset_fixed(jb);
 
    /* destroy the jb */
    fixed_jb_destroy(fixedjb);
}

References fixed_jb_destroy(), and jb_empty_and_reset_fixed().

jb_empty_and_reset_adaptive()

static void jb_empty_and_reset_adaptive ( void *  jb )

static

Definition at line 808 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = jb;
    jb_frame f;
 
    while (jb_getall(adaptivejb, &f) == JB_OK) {
        ast_frfree(f.data);
    }
 
    jb_reset(adaptivejb);
}

References ast_frfree, jb_frame::data, jb_getall(), JB_OK, and jb_reset().

jb_empty_and_reset_fixed()

static void jb_empty_and_reset_fixed ( void *  jb )

static

Definition at line 710 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = jb;
    struct fixed_jb_frame f;
 
    while (fixed_jb_remove(fixedjb, &f) == FIXED_JB_OK) {
        ast_frfree(f.data);
    }
}

References ast_frfree, fixed_jb_frame::data, FIXED_JB_OK, and fixed_jb_remove().

Referenced by jb_destroy_fixed().

jb_force_resynch_adaptive()

static void jb_force_resynch_adaptive ( void *  jb )

static

Definition at line 804 of file abstract_jb.c.

{
}

jb_force_resynch_fixed()

static void jb_force_resynch_fixed ( void *  jb )

static

Definition at line 703 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 
    fixed_jb_set_force_resynch(fixedjb);
}

References fixed_jb_set_force_resynch().

jb_framedata_destroy()

static void jb_framedata_destroy ( struct jb_framedata *  framedata )

static

Definition at line 867 of file abstract_jb.c.

{
    struct ast_frame *frame;
 
    if (framedata->timer) {
        ast_timer_close(framedata->timer);
        framedata->timer = NULL;
    }
    if (framedata->jb_impl && framedata->jb_obj) {
        struct ast_frame *f;
        while (framedata->jb_impl->remove(framedata->jb_obj, &f) == AST_JB_IMPL_OK) {
            ast_frfree(f);
        }
        framedata->jb_impl->destroy(framedata->jb_obj);
        framedata->jb_obj = NULL;
    }
    ao2_cleanup(framedata->last_format);
    while ((frame = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list))) {
        ast_frfree(frame);
    }
    ast_free(framedata);
}

References ao2_cleanup, ast_free, ast_frfree, AST_JB_IMPL_OK, AST_LIST_REMOVE_HEAD, ast_timer_close(), ast_jb_impl::destroy, jb_framedata::early_frames, jb_framedata::jb_impl, jb_framedata::jb_obj, jb_framedata::last_format, NULL, ast_jb_impl::remove, and jb_framedata::timer.

Referenced by ast_jb_create_framehook(), and hook_destroy_cb().

jb_framedata_init()

static int jb_framedata_init ( struct jb_framedata *  framedata, struct ast_jb_conf *  jb_conf  )

static

Definition at line 1227 of file abstract_jb.c.

{
    int jb_impl_type = DEFAULT_TYPE;
    /* Initialize defaults */
    framedata->timer_fd = -1;
    memcpy(&framedata->jb_conf, jb_conf, sizeof(*jb_conf));
 
    /* Figure out implementation type from the configuration implementation string */
    if (!ast_strlen_zero(jb_conf->impl)) {
        if (!strcasecmp(jb_conf->impl, "fixed")) {
            jb_impl_type = AST_JB_FIXED;
        } else if (!strcasecmp(jb_conf->impl, "adaptive")) {
            jb_impl_type = AST_JB_ADAPTIVE;
        } else {
            ast_log(LOG_WARNING, "Unknown Jitterbuffer type %s. Failed to create jitterbuffer.\n", jb_conf->impl);
            return -1;
        }
    }
 
    if (!(framedata->jb_impl = ast_jb_get_impl(jb_impl_type))) {
        return -1;
    }
 
    if (!(framedata->timer = ast_timer_open())) {
        return -1;
    }
 
    framedata->audio_stream_id = -1;
    framedata->video_stream_id = -1;
    AST_LIST_HEAD_INIT_NOLOCK(&framedata->early_frames);
    framedata->timer_fd = ast_timer_fd(framedata->timer);
    framedata->timer_interval = DEFAULT_TIMER_INTERVAL;
    ast_timer_set_rate(framedata->timer, 1000 / framedata->timer_interval);
    framedata->start_tv = ast_tvnow();
 
    framedata->jb_obj = framedata->jb_impl->create(&framedata->jb_conf);
    return 0;
}

References AST_JB_ADAPTIVE, AST_JB_FIXED, ast_jb_get_impl(), AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_strlen_zero(), ast_timer_fd(), ast_timer_open(), ast_timer_set_rate(), ast_tvnow(), jb_framedata::audio_stream_id, ast_jb_impl::create, DEFAULT_TIMER_INTERVAL, DEFAULT_TYPE, jb_framedata::early_frames, jb_framedata::jb_conf, jb_framedata::jb_impl, jb_framedata::jb_obj, LOG_WARNING, jb_framedata::start_tv, jb_framedata::timer, jb_framedata::timer_fd, jb_framedata::timer_interval, and jb_framedata::video_stream_id.

Referenced by ast_jb_create_framehook().

jb_get_adaptive()

static int jb_get_adaptive ( void *  jb, struct ast_frame **  fout, long  now, long  interpl  )

static

Definition at line 770 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = (jitterbuf *) jb;
    jb_frame frame = { .data = &ast_null_frame };
    int res;
 
    res = jb_get(adaptivejb, &frame, now, interpl);
    *fout = frame.data;
 
    return adaptive_to_abstract_code[res];
}

References adaptive_to_abstract_code, ast_null_frame, jb_frame::data, and jb_get().

jb_get_and_deliver()

static void jb_get_and_deliver ( struct ast_channel *  chan )

static

Definition at line 353 of file abstract_jb.c.

{
    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_format_get_default_ms(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);
            ao2_replace(jb->last_format, f->subclass.format);
            ast_frfree(f);
            break;
        case AST_JB_IMPL_INTERP:
            /* interpolate a frame */
            f = &finterp;
            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);
    }
}

References ao2_replace, ast_assert, ast_channel_jb(), ast_format_get_default_ms(), AST_FRAME_VOICE, ast_frfree, AST_FRIENDLY_OFFSET, AST_JB_IMPL_DROP, AST_JB_IMPL_INTERP, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_OK, ast_log, ast_samp2tv(), ast_tvadd(), ast_write(), ast_frame::delivery, ast_frame_subclass::format, ast_frame::frametype, ast_jb_impl::get, get_now(), ast_jb::impl, jb_framelog, jb_get_actions, ast_jb::jbobj, ast_jb::last_format, ast_frame::len, LOG_ERROR, LOG_WARNING, ast_jb_impl::name, ast_jb_impl::next, ast_jb::next, ast_frame::next, NULL, ast_frame::offset, ast_frame::samples, ast_frame::src, ast_frame::subclass, ast_jb::timebase, and ast_frame::ts.

Referenced by ast_jb_get_and_deliver().

jb_get_fixed()

static int jb_get_fixed ( void *  jb, struct ast_frame **  fout, long  now, long  interpl  )

static

Definition at line 669 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
    struct fixed_jb_frame frame = { .data = &ast_null_frame };
    int res;
 
    res = fixed_jb_get(fixedjb, &frame, now, interpl);
    *fout = frame.data;
 
    return fixed_to_abstract_code[res];
}

References ast_null_frame, fixed_jb_frame::data, fixed_jb_get(), and fixed_to_abstract_code.

jb_is_late_adaptive()

static int jb_is_late_adaptive ( void *  jb, long  ts  )

static

Definition at line 831 of file abstract_jb.c.

{
    return jb_is_late(jb, ts);
}

References jb_is_late().

jb_is_late_fixed()

static int jb_is_late_fixed ( void *  jb, long  ts  )

static

Definition at line 720 of file abstract_jb.c.

{
    return fixed_jb_is_late(jb, ts);
}

References fixed_jb_is_late(), and fixed_jb_frame::ts.

jb_next_adaptive()

static long jb_next_adaptive ( void *  jb )

static

Definition at line 783 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = (jitterbuf *) jb;
 
    return jb_next(adaptivejb);
}

References jb_next().

jb_next_fixed()

static long jb_next_fixed ( void *  jb )

static

Definition at line 682 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 
    return fixed_jb_next(fixedjb);
}

References fixed_jb_next().

jb_put_adaptive()

static int jb_put_adaptive ( void *  jb, struct ast_frame *  fin, long  now  )

static

Definition at line 759 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = (jitterbuf *) jb;
    int res;
 
    res = jb_put(adaptivejb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
 
    return adaptive_to_abstract_code[res];
}

References adaptive_to_abstract_code, jb_put(), JB_TYPE_VOICE, ast_frame::len, and ast_frame::ts.

Referenced by jb_put_first_adaptive().

jb_put_first_adaptive()

static int jb_put_first_adaptive ( void *  jb, struct ast_frame *  fin, long  now  )

static

Definition at line 753 of file abstract_jb.c.

{
    return jb_put_adaptive(jb, fin, now);
}

References jb_put_adaptive().

jb_put_first_fixed()

static int jb_put_first_fixed ( void *  jb, struct ast_frame *  fin, long  now  )

static

Definition at line 647 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
    int res;
 
    res = fixed_jb_put_first(fixedjb, fin, fin->len, fin->ts, now);
 
    return fixed_to_abstract_code[res];
}

References fixed_jb_put_first(), fixed_to_abstract_code, ast_frame::len, and ast_frame::ts.

jb_put_fixed()

static int jb_put_fixed ( void *  jb, struct ast_frame *  fin, long  now  )

static

Definition at line 658 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
    int res;
 
    res = fixed_jb_put(fixedjb, fin, fin->len, fin->ts, now);
 
    return fixed_to_abstract_code[res];
}

References fixed_jb_put(), fixed_to_abstract_code, ast_frame::len, and ast_frame::ts.

jb_remove_adaptive()

static int jb_remove_adaptive ( void *  jb, struct ast_frame **  fout  )

static

Definition at line 791 of file abstract_jb.c.

{
    jitterbuf *adaptivejb = (jitterbuf *) jb;
    jb_frame frame;
    int res;
 
    res = jb_getall(adaptivejb, &frame);
    *fout = frame.data;
 
    return adaptive_to_abstract_code[res];
}

References adaptive_to_abstract_code, jb_frame::data, and jb_getall().

jb_remove_fixed()

static int jb_remove_fixed ( void *  jb, struct ast_frame **  fout  )

static

Definition at line 690 of file abstract_jb.c.

{
    struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
    struct fixed_jb_frame frame;
    int res;
 
    res = fixed_jb_remove(fixedjb, &frame);
    *fout = frame.data;
 
    return fixed_to_abstract_code[res];
}

References fixed_jb_frame::data, fixed_jb_remove(), and fixed_to_abstract_code.

jitterbuffer_frame_get_ntp_timestamp()

static struct timeval jitterbuffer_frame_get_ntp_timestamp ( const struct jb_stream_sync *  stream_sync, const struct ast_frame *  frame  )

static

Definition at line 915 of file abstract_jb.c.

{
    int timestamp_diff;
    unsigned int rate;
 
    /* It's possible for us to receive frames before we receive the information allowing
     * us to do NTP/RTP timestamp calculations. Since the information isn't available we
     * can't generate one and give an empty timestamp.
     */
    if (ast_tvzero(stream_sync->ntp)) {
        return ast_tv(0, 0);
    }
 
    /* Convert the Asterisk timestamp into an RTP timestamp, and then based on the difference we can
     * determine how many samples are in the frame and how long has elapsed since the synchronization
     * RTP and NTP timestamps were received giving us the NTP timestamp for this frame.
     */
    if (frame->frametype == AST_FRAME_VOICE) {
        rate = ast_rtp_get_rate(frame->subclass.format);
        timestamp_diff = (frame->ts * (rate / 1000)) - stream_sync->timestamp;
    } else {
        /* Video is special - internally we reference it as 1000 to preserve the RTP timestamp but
         * it is actually 90000, this is why we can just directly subtract the timestamp.
         */
        rate = 90000;
        timestamp_diff = frame->ts - stream_sync->timestamp;
    }
 
    if (timestamp_diff < 0) {
        /* It's possible for us to be asked for an NTP timestamp from before our latest
         * RTCP SR report. To handle this we subtract so we go back in time.
         */
        return ast_tvsub(stream_sync->ntp, ast_samp2tv(abs(timestamp_diff), rate));
    } else {
        return ast_tvadd(stream_sync->ntp, ast_samp2tv(timestamp_diff, rate));
    }
}

References abs, AST_FRAME_VOICE, ast_rtp_get_rate(), ast_samp2tv(), ast_tv(), ast_tvadd(), ast_tvsub(), and ast_tvzero().

Referenced by hook_event_cb().

Variable Documentation

adaptive_to_abstract_code

const int adaptive_to_abstract_code[]

static

Initial value:

=
    {AST_JB_IMPL_OK, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_INTERP, AST_JB_IMPL_DROP, AST_JB_IMPL_OK}

Definition at line 123 of file abstract_jb.c.

Referenced by jb_get_adaptive(), jb_put_adaptive(), and jb_remove_adaptive().

avail_impl

const struct ast_jb_impl avail_impl[]

static

Definition at line 87 of file abstract_jb.c.

Referenced by ast_jb_get_impl(), and jb_choose_impl().

default_impl

int default_impl = 0

static

Definition at line 118 of file abstract_jb.c.

Referenced by jb_choose_impl().

fixed_to_abstract_code

const int fixed_to_abstract_code[]

static

Initial value:

=
    {AST_JB_IMPL_OK, AST_JB_IMPL_DROP, AST_JB_IMPL_INTERP, AST_JB_IMPL_NOFRAME}

Definition at line 121 of file abstract_jb.c.

Referenced by jb_get_fixed(), jb_put_first_fixed(), jb_put_fixed(), and jb_remove_fixed().

jb_datastore

const struct ast_datastore_info jb_datastore

static

Initial value:

= {
    .type = "jitterbuffer",
    .destroy = datastore_destroy_cb
}

Definition at line 904 of file abstract_jb.c.

Referenced by ast_jb_create_framehook().

jb_get_actions

const char* const jb_get_actions[] = {"Delivered", "Dropped", "Interpolated", "No"}

static

Definition at line 127 of file abstract_jb.c.

Referenced by jb_get_and_deliver().