abstract_jb.h File Reference

Common implementation-independent jitterbuffer stuff. More...

#include <sys/time.h>
#include "asterisk/format.h"

Include dependency graph for abstract_jb.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_jb
	General jitterbuffer state. More...
struct	ast_jb_conf
	General jitterbuffer configuration. More...
struct	ast_jb_impl
	Jitterbuffer implementation struct. More...

Macros
#define	AST_JB_CONF_ENABLE   "enable"
#define	AST_JB_CONF_FORCE   "force"
#define	AST_JB_CONF_IMPL   "impl"
#define	AST_JB_CONF_LOG   "log"
#define	AST_JB_CONF_MAX_SIZE   "maxsize"
#define	AST_JB_CONF_PREFIX   "jb"
#define	AST_JB_CONF_RESYNCH_THRESHOLD   "resyncthreshold"
#define	AST_JB_CONF_SYNC_VIDEO   "syncvideo"
#define	AST_JB_CONF_TARGET_EXTRA   "targetextra"
#define	AST_JB_IMPL_NAME_SIZE   12

Typedefs
typedef void *(*	jb_create_impl) (struct ast_jb_conf *general_config)
	Create. More...
typedef void(*	jb_destroy_impl) (void *jb)
	Destroy. More...
typedef void(*	jb_empty_and_reset_impl) (void *jb)
	Empty and reset jb. More...
typedef void(*	jb_force_resynch_impl) (void *jb)
	Force resynch. More...
typedef int(*	jb_get_impl) (void *jb, struct ast_frame **fout, long now, long interpl)
	Get frame for now. More...
typedef int(*	jb_is_late_impl) (void *jb, long ts)
	Check if late. More...
typedef long(*	jb_next_impl) (void *jb)
	Get next. More...
typedef int(*	jb_put_first_impl) (void *jb, struct ast_frame *fin, long now)
	Put first frame. More...
typedef int(*	jb_put_impl) (void *jb, struct ast_frame *fin, long now)
	Put frame. More...
typedef int(*	jb_remove_impl) (void *jb, struct ast_frame **fout)
	Remove first frame. More...

Enumerations
enum	{ AST_JB_ENABLED = (1 << 0) , AST_JB_FORCED = (1 << 1) , AST_JB_LOG = (1 << 2) , AST_JB_SYNC_VIDEO = (1 << 3) }
enum	{ AST_JB_IMPL_OK , AST_JB_IMPL_DROP , AST_JB_IMPL_INTERP , AST_JB_IMPL_NOFRAME }
enum	ast_jb_type { AST_JB_FIXED , AST_JB_ADAPTIVE }

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...

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.h.

Macro Definition Documentation

AST_JB_CONF_ENABLE

#define AST_JB_CONF_ENABLE   "enable"

Definition at line 86 of file abstract_jb.h.

AST_JB_CONF_FORCE

#define AST_JB_CONF_FORCE   "force"

Definition at line 87 of file abstract_jb.h.

AST_JB_CONF_IMPL

#define AST_JB_CONF_IMPL   "impl"

Definition at line 91 of file abstract_jb.h.

AST_JB_CONF_LOG

#define AST_JB_CONF_LOG   "log"

Definition at line 92 of file abstract_jb.h.

AST_JB_CONF_MAX_SIZE

#define AST_JB_CONF_MAX_SIZE   "maxsize"

Definition at line 88 of file abstract_jb.h.

AST_JB_CONF_PREFIX

#define AST_JB_CONF_PREFIX   "jb"

Definition at line 85 of file abstract_jb.h.

AST_JB_CONF_RESYNCH_THRESHOLD

#define AST_JB_CONF_RESYNCH_THRESHOLD   "resyncthreshold"

Definition at line 89 of file abstract_jb.h.

AST_JB_CONF_SYNC_VIDEO

#define AST_JB_CONF_SYNC_VIDEO   "syncvideo"

Definition at line 93 of file abstract_jb.h.

AST_JB_CONF_TARGET_EXTRA

#define AST_JB_CONF_TARGET_EXTRA   "targetextra"

Definition at line 90 of file abstract_jb.h.

AST_JB_IMPL_NAME_SIZE

#define AST_JB_IMPL_NAME_SIZE   12

Definition at line 64 of file abstract_jb.h.

Typedef Documentation

jb_create_impl

typedef void*(* jb_create_impl) (struct ast_jb_conf *general_config)

Create.

Definition at line 97 of file abstract_jb.h.

jb_destroy_impl

typedef void(* jb_destroy_impl) (void *jb)

Destroy.

Definition at line 99 of file abstract_jb.h.

jb_empty_and_reset_impl

typedef void(* jb_empty_and_reset_impl) (void *jb)

Empty and reset jb.

Definition at line 113 of file abstract_jb.h.

jb_force_resynch_impl

typedef void(* jb_force_resynch_impl) (void *jb)

Force resynch.

Definition at line 111 of file abstract_jb.h.

jb_get_impl

typedef int(* jb_get_impl) (void *jb, struct ast_frame **fout, long now, long interpl)

Get frame for now.

Definition at line 105 of file abstract_jb.h.

jb_is_late_impl

typedef int(* jb_is_late_impl) (void *jb, long ts)

Check if late.

Definition at line 115 of file abstract_jb.h.

jb_next_impl

typedef long(* jb_next_impl) (void *jb)

Get next.

Definition at line 107 of file abstract_jb.h.

jb_put_first_impl

typedef int(* jb_put_first_impl) (void *jb, struct ast_frame *fin, long now)

Put first frame.

Definition at line 101 of file abstract_jb.h.

jb_put_impl

typedef int(* jb_put_impl) (void *jb, struct ast_frame *fin, long now)

Put frame.

Definition at line 103 of file abstract_jb.h.

jb_remove_impl

typedef int(* jb_remove_impl) (void *jb, struct ast_frame **fout)

Remove first frame.

Definition at line 109 of file abstract_jb.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
AST_JB_ENABLED
AST_JB_FORCED
AST_JB_LOG
AST_JB_SYNC_VIDEO

Definition at line 44 of file abstract_jb.h.

     {
    AST_JB_ENABLED = (1 << 0),
    AST_JB_FORCED =  (1 << 1),
    AST_JB_LOG =     (1 << 2),
    AST_JB_SYNC_VIDEO =   (1 << 3)
};

anonymous enum

anonymous enum

Abstract return codes

Enumerator
AST_JB_IMPL_OK
AST_JB_IMPL_DROP
AST_JB_IMPL_INTERP
AST_JB_IMPL_NOFRAME

Definition at line 57 of file abstract_jb.h.

     {
    AST_JB_IMPL_OK,
    AST_JB_IMPL_DROP,
    AST_JB_IMPL_INTERP,
    AST_JB_IMPL_NOFRAME
};

ast_jb_type

enum ast_jb_type

Enumerator
AST_JB_FIXED
AST_JB_ADAPTIVE

Definition at line 51 of file abstract_jb.h.

                 {
    AST_JB_FIXED,
    AST_JB_ADAPTIVE,
};

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.

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 alsa_new(), ast_unreal_new_channels(), console_new(), dahdi_new(), mgcp_new(), ooh323_new(), sip_new(), skinny_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().

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 config_parse_variables(), process_dahdi(), reload_config(), and store_config_core().