switch_jitterbuffer.c File Reference

#include <switch.h>
#include <switch_jitterbuffer.h>
#include "private/switch_hashtable_private.h"

Include dependency graph for switch_jitterbuffer.c:

Go to the source code of this file.

Data Structures
struct	switch_jb_node_s
struct	switch_jb_s

Macros
#define	NACK_TIME   80000
#define	RENACK_TIME   100000
#define	PERIOD_LEN   250
#define	MAX_FRAME_PADDING   2
#define	MAX_MISSING_SEQ   20
#define	jb_debug(_jb, _level, _format,...)   if (_jb->debug_level >= _level) switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(_jb->session), SWITCH_LOG_ALERT, "JB:%p:%s lv:%d ln:%.4d sz:%.3u/%.3u/%.3u/%.3u c:%.3u %.3u/%.3u/%.3u/%.3u %.2f%% ->" _format, (void *) _jb, (jb->type == SJB_AUDIO ? "aud" : "vid"), _level, __LINE__, _jb->min_frame_len, _jb->max_frame_len, _jb->frame_len, _jb->complete_frames, _jb->period_count, _jb->consec_good_count, _jb->period_good_count, _jb->consec_miss_count, _jb->period_miss_count, _jb->period_miss_pct, __VA_ARGS__)
#define	jb_frame_inc(_jb, _i)   jb_frame_inc_line(_jb, _i, __LINE__)

Typedefs
typedef struct switch_jb_node_s	switch_jb_node_t

Functions
static int	node_cmp (const void *l, const void *r)
switch_jb_node_t *	sort_nodes (switch_jb_node_t *list, int(*cmp)(const void *, const void *))
static switch_jb_node_t *	new_node (switch_jb_t *jb)
static void	push_to_top (switch_jb_t *jb, switch_jb_node_t *node)
static void	hide_node (switch_jb_node_t *node, switch_bool_t pop)
static void	sort_free_nodes (switch_jb_t *jb)
static void	hide_nodes (switch_jb_t *jb)
static void	drop_ts (switch_jb_t *jb, uint32_t ts)
static switch_jb_node_t *	jb_find_lowest_seq (switch_jb_t *jb, uint32_t ts)
static switch_jb_node_t *	jb_find_lowest_node (switch_jb_t *jb)
static uint32_t	jb_find_lowest_ts (switch_jb_t *jb)
static void	thin_frames (switch_jb_t *jb, int freq, int max)
static void	jb_hit (switch_jb_t *jb)
static void	jb_frame_inc_line (switch_jb_t *jb, int i, int line)
static void	jb_miss (switch_jb_t *jb)
static void	drop_oldest_frame (switch_jb_t *jb)
static void	add_node (switch_jb_t *jb, switch_rtp_packet_t *packet, switch_size_t len)
static void	increment_ts (switch_jb_t *jb)
static void	set_read_ts (switch_jb_t *jb, uint32_t ts)
static void	increment_seq (switch_jb_t *jb)
static void	set_read_seq (switch_jb_t *jb, uint16_t seq)
static switch_status_t	jb_next_packet_by_seq (switch_jb_t *jb, switch_jb_node_t **nodep)
static switch_status_t	jb_next_packet_by_ts (switch_jb_t *jb, switch_jb_node_t **nodep)
static switch_status_t	jb_next_packet (switch_jb_t *jb, switch_jb_node_t **nodep)
static void	free_nodes (switch_jb_t *jb)
void	switch_jb_ts_mode (switch_jb_t *jb, uint32_t samples_per_frame, uint32_t samples_per_second)
void	switch_jb_set_session (switch_jb_t *jb, switch_core_session_t *session)
void	switch_jb_set_flag (switch_jb_t *jb, switch_jb_flag_t flag)
void	switch_jb_clear_flag (switch_jb_t *jb, switch_jb_flag_t flag)
int	switch_jb_poll (switch_jb_t *jb)
int	switch_jb_frame_count (switch_jb_t *jb)
void	switch_jb_debug_level (switch_jb_t *jb, uint8_t level)
void	switch_jb_reset (switch_jb_t *jb)
switch_status_t	switch_jb_peek_frame (switch_jb_t *jb, uint32_t ts, uint16_t seq, int peek, switch_frame_t *frame)
switch_status_t	switch_jb_get_frames (switch_jb_t *jb, uint32_t *min_frame_len, uint32_t *max_frame_len, uint32_t *cur_frame_len, uint32_t *highest_frame_len)
switch_status_t	switch_jb_set_frames (switch_jb_t *jb, uint32_t min_frame_len, uint32_t max_frame_len)
switch_status_t	switch_jb_create (switch_jb_t **jbp, switch_jb_type_t type, uint32_t min_frame_len, uint32_t max_frame_len, switch_memory_pool_t *pool)
switch_status_t	switch_jb_destroy (switch_jb_t **jbp)
uint32_t	switch_jb_pop_nack (switch_jb_t *jb)
switch_status_t	switch_jb_put_packet (switch_jb_t *jb, switch_rtp_packet_t *packet, switch_size_t len)
switch_status_t	switch_jb_get_packet_by_seq (switch_jb_t *jb, uint16_t seq, switch_rtp_packet_t *packet, switch_size_t *len)
switch_size_t	switch_jb_get_last_read_len (switch_jb_t *jb)
switch_status_t	switch_jb_get_packet (switch_jb_t *jb, switch_rtp_packet_t *packet, switch_size_t *len)

Macro Definition Documentation

#define jb_debug	(		_jb,
			_level,
			_format,
			...
	)		if (_jb->debug_level >= _level) switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(_jb->session), SWITCH_LOG_ALERT, "JB:%p:%s lv:%d ln:%.4d sz:%.3u/%.3u/%.3u/%.3u c:%.3u %.3u/%.3u/%.3u/%.3u %.2f%% ->" _format, (void *) _jb, (jb->type == SJB_AUDIO ? "aud" : "vid"), _level, __LINE__, _jb->min_frame_len, _jb->max_frame_len, _jb->frame_len, _jb->complete_frames, _jb->period_count, _jb->consec_good_count, _jb->period_good_count, _jb->consec_miss_count, _jb->period_miss_count, _jb->period_miss_pct, __VA_ARGS__)

Definition at line 40 of file switch_jitterbuffer.c.

Referenced by add_node(), drop_oldest_frame(), jb_frame_inc_line(), jb_next_packet_by_seq(), jb_next_packet_by_ts(), switch_jb_get_packet(), switch_jb_get_packet_by_seq(), switch_jb_pop_nack(), switch_jb_put_packet(), and switch_jb_reset().

#define jb_frame_inc	(		_jb,
			_i
	)		jb_frame_inc_line(_jb, _i, __LINE__)

Definition at line 491 of file switch_jitterbuffer.c.

Referenced by jb_next_packet_by_seq(), switch_jb_get_packet(), and switch_jb_put_packet().

#define MAX_FRAME_PADDING   2

Definition at line 38 of file switch_jitterbuffer.c.

#define MAX_MISSING_SEQ   20

Definition at line 39 of file switch_jitterbuffer.c.

#define NACK_TIME   80000

Definition at line 35 of file switch_jitterbuffer.c.

#define PERIOD_LEN   250

Definition at line 37 of file switch_jitterbuffer.c.

Referenced by switch_jb_get_packet().

#define RENACK_TIME   100000

Definition at line 36 of file switch_jitterbuffer.c.

Referenced by switch_jb_pop_nack().

Typedef Documentation

typedef struct switch_jb_node_s switch_jb_node_t

Function Documentation

static void add_node ( switch_jb_t *  jb, switch_rtp_packet_t *  packet, switch_size_t  len  )

inlinestatic

Definition at line 571 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::body, switch_jb_s::complete_frames, switch_jb_s::frame_len, switch_rtp_packet_t::header, switch_jb_s::highest_wrote_seq, switch_jb_s::highest_wrote_ts, jb_debug, switch_jb_node_s::len, switch_rtp_hdr_t::m, switch_jb_s::max_frame_len, new_node(), switch_jb_s::node_hash, switch_jb_s::node_hash_ts, switch_jb_node_s::packet, switch_rtp_hdr_t::seq, SJB_VIDEO, switch_core_inthash_insert(), switch_jb_reset(), switch_rtp_hdr_t::ts, switch_jb_s::type, switch_jb_s::visible_nodes, and switch_jb_s::write_init.

Referenced by switch_jb_put_packet().

{
        switch_jb_node_t *node = new_node(jb);

        node->packet = *packet;
        node->len = len;
        memcpy(node->packet.body, packet->body, len);

        switch_core_inthash_insert(jb->node_hash, node->packet.header.seq, node);

        if (jb->node_hash_ts) {
                switch_core_inthash_insert(jb->node_hash_ts, node->packet.header.ts, node);
        }

        jb_debug(jb, (packet->header.m ? 1 : 2), "PUT packet last_ts:%u ts:%u seq:%u%s\n", 
                         ntohl(jb->highest_wrote_ts), ntohl(node->packet.header.ts), ntohs(node->packet.header.seq), packet->header.m ? " <MARK>" : "");

        if (jb->write_init && jb->type == SJB_VIDEO) {
                int seq_diff = 0, ts_diff = 0;

                if (ntohs(jb->highest_wrote_seq) > (USHRT_MAX - 100) && ntohs(packet->header.seq) < 100) {
                        seq_diff = (USHRT_MAX - ntohs(jb->highest_wrote_seq)) + ntohs(packet->header.seq);
                } else {
                        seq_diff = abs(((int)ntohs(packet->header.seq) - ntohs(jb->highest_wrote_seq)));
                }
                
                if (ntohl(jb->highest_wrote_ts) > (UINT_MAX - 1000) && ntohl(node->packet.header.ts) < 1000) {
                        ts_diff = (UINT_MAX - ntohl(node->packet.header.ts)) + ntohl(node->packet.header.ts);
                } else {
                        ts_diff = abs((int)((int64_t)ntohl(node->packet.header.ts) - (int64_t)ntohl(jb->highest_wrote_ts)));
                }
                
                if (((seq_diff >= jb->max_frame_len) || (ts_diff > (900000 * 5)))) {
                        jb_debug(jb, 2, "CHANGE DETECTED, PUNT %u\n", abs(((int)ntohs(packet->header.seq) - ntohs(jb->highest_wrote_seq))));
                        switch_jb_reset(jb);
                }
        }
 
        if (!jb->write_init || ntohs(packet->header.seq) > ntohs(jb->highest_wrote_seq) || 
                (ntohs(jb->highest_wrote_seq) > USHRT_MAX - 100 && ntohs(packet->header.seq) < 100) ) {
                jb->highest_wrote_seq = packet->header.seq;
        }

        if (jb->type == SJB_VIDEO) {
                if (jb->write_init && ((htons(packet->header.seq) >= htons(jb->highest_wrote_seq) && (ntohl(node->packet.header.ts) > ntohl(jb->highest_wrote_ts))) ||
                                                           (ntohl(jb->highest_wrote_ts) > (UINT_MAX - 1000) && ntohl(node->packet.header.ts) < 1000))) {
                        jb->complete_frames++;
                        jb_debug(jb, 2, "WRITE frame ts: %u complete=%u/%u n:%u\n", ntohl(node->packet.header.ts), jb->complete_frames , jb->frame_len, jb->visible_nodes);
                        jb->highest_wrote_ts = packet->header.ts;
                        //verify_oldest_frame(jb);
                } else if (!jb->write_init) {
                        jb->highest_wrote_ts = packet->header.ts;
                }
        } else {
                if (jb->write_init) {
                        jb_debug(jb, 2, "WRITE frame ts: %u complete=%u/%u n:%u\n", ntohl(node->packet.header.ts), jb->complete_frames , jb->frame_len, jb->visible_nodes);
                        jb->complete_frames++;
                } else {
                        jb->highest_wrote_ts = packet->header.ts;
                }
        }
        
        if (!jb->write_init) jb->write_init = 1;
}

static void drop_oldest_frame ( switch_jb_t *  jb )

inlinestatic

Definition at line 543 of file switch_jitterbuffer.c.

References drop_ts(), jb_debug, and jb_find_lowest_ts().

Referenced by switch_jb_put_packet().

{
        uint32_t ts = jb_find_lowest_ts(jb);

        drop_ts(jb, ts);
        jb_debug(jb, 1, "Dropping oldest frame ts:%u\n", ntohl(ts));
}

static void drop_ts ( switch_jb_t *  jb, uint32_t  ts  )

inlinestatic

Definition at line 301 of file switch_jitterbuffer.c.

References switch_jb_s::complete_frames, switch_rtp_packet_t::header, hide_node(), switch_jb_s::list_mutex, switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::packet, sort_free_nodes(), SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_hdr_t::ts, and switch_jb_node_s::visible.

Referenced by drop_oldest_frame(), jb_next_packet_by_seq(), and thin_frames().

{
        switch_jb_node_t *np;
        int x = 0;

        switch_mutex_lock(jb->list_mutex);
        for (np = jb->node_list; np; np = np->next) {
                if (!np->visible) continue;

                if (ts == np->packet.header.ts) {
                        hide_node(np, SWITCH_FALSE);
                        x++;
                }
        }

        if (x) {
                sort_free_nodes(jb);
        }

        switch_mutex_unlock(jb->list_mutex);
        
        if (x) jb->complete_frames--;
}

static void free_nodes ( switch_jb_t *  jb )

inlinestatic

Definition at line 790 of file switch_jitterbuffer.c.

References switch_jb_s::list_mutex, switch_jb_s::node_list, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_jb_destroy().

{
        switch_mutex_lock(jb->list_mutex);
        jb->node_list = NULL;
        switch_mutex_unlock(jb->list_mutex);
}

static void hide_node ( switch_jb_node_t *  node, switch_bool_t  pop  )

inlinestatic

Definition at line 258 of file switch_jitterbuffer.c.

References switch_jb_node_s::bad_hits, switch_rtp_packet_t::header, switch_jb_s::list_mutex, switch_jb_s::node_hash, switch_jb_s::node_hash_ts, switch_jb_node_s::packet, switch_jb_node_s::parent, push_to_top(), switch_rtp_hdr_t::seq, switch_core_inthash_delete(), switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_hdr_t::ts, switch_jb_node_s::visible, and switch_jb_s::visible_nodes.

Referenced by drop_ts(), hide_nodes(), and switch_jb_get_packet().

{
        switch_jb_t *jb = node->parent;

        switch_mutex_lock(jb->list_mutex);

        if (node->visible) {
                node->visible = 0;
                node->bad_hits = 0;
                jb->visible_nodes--;

                if (pop) {
                        push_to_top(jb, node);
                }
        }

        if (jb->node_hash_ts) {
                switch_core_inthash_delete(jb->node_hash_ts, node->packet.header.ts);
        }

        switch_core_inthash_delete(jb->node_hash, node->packet.header.seq);

        switch_mutex_unlock(jb->list_mutex);
}

static void hide_nodes ( switch_jb_t *  jb )

inlinestatic

Definition at line 290 of file switch_jitterbuffer.c.

References hide_node(), switch_jb_s::list_mutex, switch_jb_node_s::next, switch_jb_s::node_list, SWITCH_FALSE, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_jb_reset().

{
        switch_jb_node_t *np;

        switch_mutex_lock(jb->list_mutex);
        for (np = jb->node_list; np; np = np->next) {
                hide_node(np, SWITCH_FALSE);
        }
        switch_mutex_unlock(jb->list_mutex);
}

static void increment_seq ( switch_jb_t *  jb )

inlinestatic

Definition at line 657 of file switch_jitterbuffer.c.

References switch_jb_s::last_target_seq, and switch_jb_s::target_seq.

Referenced by jb_next_packet_by_seq().

{
        jb->last_target_seq = jb->target_seq;
        jb->target_seq = htons((ntohs(jb->target_seq) + 1));
}

static void increment_ts ( switch_jb_t *  jb )

inlinestatic

Definition at line 636 of file switch_jitterbuffer.c.

References switch_jb_s::last_psuedo_seq, switch_jb_s::last_target_ts, switch_jb_s::psuedo_seq, switch_jb_s::samples_per_frame, and switch_jb_s::target_ts.

Referenced by jb_next_packet_by_ts().

{
        if (!jb->target_ts) return;

        jb->last_psuedo_seq = jb->psuedo_seq;
        jb->last_target_ts = jb->target_ts;
        jb->target_ts = htonl((ntohl(jb->target_ts) + jb->samples_per_frame));
        jb->psuedo_seq++;
}

static switch_jb_node_t* jb_find_lowest_node ( switch_jb_t *  jb )

inlinestatic

Definition at line 344 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, switch_jb_s::list_mutex, switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::packet, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_hdr_t::ts, and switch_jb_node_s::visible.

Referenced by jb_find_lowest_ts(), and jb_next_packet_by_ts().

{
        switch_jb_node_t *np, *lowest = NULL;

        switch_mutex_lock(jb->list_mutex);
        for (np = jb->node_list; np; np = np->next) {
                if (!np->visible) continue;

                if (!lowest || ntohl(lowest->packet.header.ts) > ntohl(np->packet.header.ts)) {
                        lowest = np;
                }
        }
        switch_mutex_unlock(jb->list_mutex);

        return lowest ? lowest : NULL;
}

static switch_jb_node_t* jb_find_lowest_seq ( switch_jb_t *  jb, uint32_t  ts  )

inlinestatic

Definition at line 325 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, switch_jb_s::list_mutex, switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::packet, switch_rtp_hdr_t::seq, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_hdr_t::ts, and switch_jb_node_s::visible.

Referenced by jb_next_packet_by_seq().

{
        switch_jb_node_t *np, *lowest = NULL;
        
        switch_mutex_lock(jb->list_mutex);
        for (np = jb->node_list; np; np = np->next) {
                if (!np->visible) continue;

                if (ts && ts != np->packet.header.ts) continue;

                if (!lowest || ntohs(lowest->packet.header.seq) > ntohs(np->packet.header.seq)) {
                        lowest = np;
                }
        }
        switch_mutex_unlock(jb->list_mutex);

        return lowest;
}

static uint32_t jb_find_lowest_ts ( switch_jb_t *  jb )

inlinestatic

Definition at line 361 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, jb_find_lowest_node(), switch_jb_node_s::packet, and switch_rtp_hdr_t::ts.

Referenced by drop_oldest_frame().

{
        switch_jb_node_t *lowest = jb_find_lowest_node(jb);

        return lowest ? lowest->packet.header.ts : 0;
}

static void jb_frame_inc_line ( switch_jb_t *  jb, int  i, int  line  )

static

Definition at line 449 of file switch_jitterbuffer.c.

References switch_jb_s::frame_len, switch_jb_s::highest_frame_len, jb_debug, switch_jb_s::max_frame_len, switch_jb_s::min_frame_len, switch_jb_s::session, and switch_core_session_request_video_refresh().

{
        uint32_t old_frame_len = jb->frame_len;
        
        if (i == 0) {
                jb->frame_len = jb->min_frame_len;
                goto end;
        }

        if (i > 0) {
                if ((jb->frame_len + i) < jb->max_frame_len) {
                        jb->frame_len += i;
                } else {
                        jb->frame_len = jb->max_frame_len;
                }

                goto end;
        }

        if (i < 0) {
                if ((jb->frame_len + i) > jb->min_frame_len) {
                        jb->frame_len += i;
                } else {
                        jb->frame_len = jb->min_frame_len;
                }
        }

 end:

        if (jb->frame_len > jb->highest_frame_len) {
                jb->highest_frame_len = jb->frame_len;
        }

        if (old_frame_len != jb->frame_len) {
                jb_debug(jb, 2, "%d Change framelen from %u to %u\n", line, old_frame_len, jb->frame_len);
                if (jb->session) {
                        switch_core_session_request_video_refresh(jb->session);
                }
        }

}

static void jb_hit ( switch_jb_t *  jb )

inlinestatic

Definition at line 442 of file switch_jitterbuffer.c.

References switch_jb_s::consec_good_count, switch_jb_s::consec_miss_count, and switch_jb_s::period_good_count.

Referenced by jb_next_packet_by_seq(), and jb_next_packet_by_ts().

{
        jb->period_good_count++;
        jb->consec_good_count++;
        jb->consec_miss_count = 0;
}

static void jb_miss ( switch_jb_t *  jb )

inlinestatic

Definition at line 494 of file switch_jitterbuffer.c.

References switch_jb_s::consec_good_count, switch_jb_s::consec_miss_count, and switch_jb_s::period_miss_count.

Referenced by jb_next_packet_by_seq(), and jb_next_packet_by_ts().

{
        jb->period_miss_count++;
        jb->consec_miss_count++;
        jb->consec_good_count = 0;
}

static switch_status_t jb_next_packet ( switch_jb_t *  jb, switch_jb_node_t **  nodep  )

inlinestatic

Definition at line 781 of file switch_jitterbuffer.c.

References jb_next_packet_by_seq(), jb_next_packet_by_ts(), and switch_jb_s::samples_per_frame.

Referenced by switch_jb_get_packet().

{
        if (jb->samples_per_frame) {
                return jb_next_packet_by_ts(jb, nodep);
        } else {
                return jb_next_packet_by_seq(jb, nodep);
        }
}

static switch_status_t jb_next_packet_by_seq ( switch_jb_t *  jb, switch_jb_node_t **  nodep  )

inlinestatic

Definition at line 669 of file switch_jitterbuffer.c.

References drop_ts(), switch_jb_s::dropped, switch_rtp_packet_t::header, switch_jb_s::highest_read_ts, increment_seq(), jb_debug, jb_find_lowest_seq(), jb_frame_inc, jb_hit(), jb_miss(), switch_rtp_hdr_t::m, switch_jb_s::node_hash, switch_jb_node_s::packet, switch_jb_s::period_miss_count, switch_jb_s::period_miss_inc, switch_rtp_hdr_t::seq, switch_jb_s::session, set_read_seq(), SJB_VIDEO, switch_core_inthash_find(), switch_core_session_request_video_refresh(), SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, switch_jb_s::target_seq, switch_rtp_hdr_t::ts, and switch_jb_s::type.

Referenced by jb_next_packet().

{
        switch_jb_node_t *node = NULL;

 top:

        if (jb->type == SJB_VIDEO) {
                if (jb->dropped) {
                        jb->dropped = 0;
                        jb_debug(jb, 2, "%s", "DROPPED FRAME DETECTED RESYNCING\n");
                        jb->target_seq = 0;
                        
                        if (jb->session) {
                                switch_core_session_request_video_refresh(jb->session);
                        }
                }
        }

        if (!jb->target_seq) {
                if ((node = switch_core_inthash_find(jb->node_hash, jb->target_seq))) {
                        jb_debug(jb, 2, "FOUND rollover seq: %u\n", ntohs(jb->target_seq));
                } else if ((node = jb_find_lowest_seq(jb, 0))) {
                        jb_debug(jb, 2, "No target seq using seq: %u as a starting point\n", ntohs(node->packet.header.seq));
                } else {
                        jb_debug(jb, 1, "%s", "No nodes available....\n");
                }
                jb_hit(jb);
        } else if ((node = switch_core_inthash_find(jb->node_hash, jb->target_seq))) {
                jb_debug(jb, 2, "FOUND desired seq: %u\n", ntohs(jb->target_seq));
                jb_hit(jb);
        } else {
                jb_debug(jb, 2, "MISSING desired seq: %u\n", ntohs(jb->target_seq));
                jb_miss(jb);

                if (jb->type == SJB_VIDEO) {
                        int x;

                        if (jb->period_miss_count > 1 && !jb->period_miss_inc) {
                                jb->period_miss_inc++;
                                jb_frame_inc(jb, 1);
                        }

                        //if (jb->session) {
                        //      switch_core_session_request_video_refresh(jb->session);
                        //}
                        
                        for (x = 0; x < 10; x++) {
                                increment_seq(jb);
                                if ((node = switch_core_inthash_find(jb->node_hash, jb->target_seq))) {
                                        jb_debug(jb, 2, "FOUND incremental seq: %u\n", ntohs(jb->target_seq));

                                        if (node->packet.header.m ||  node->packet.header.ts == jb->highest_read_ts) {
                                                jb_debug(jb, 2, "%s", "SAME FRAME DROPPING\n");
                                                jb->dropped++;
                                                drop_ts(jb, node->packet.header.ts);
                                                node = NULL;
                                                goto top;
                                        }
                                        break;
                                } else {
                                        jb_debug(jb, 2, "MISSING incremental seq: %u\n", ntohs(jb->target_seq));
                                }
                        }
                } else {
                        increment_seq(jb);
                }
        }

        *nodep = node;
        
        if (node) {
                set_read_seq(jb, node->packet.header.seq);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_NOTFOUND;
        
}

static switch_status_t jb_next_packet_by_ts ( switch_jb_t *  jb, switch_jb_node_t **  nodep  )

inlinestatic

Definition at line 749 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, increment_ts(), jb_debug, jb_find_lowest_node(), jb_hit(), jb_miss(), switch_jb_s::node_hash_ts, switch_jb_node_s::packet, switch_jb_s::psuedo_seq, switch_rtp_hdr_t::seq, set_read_ts(), switch_core_inthash_find(), SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, switch_jb_s::target_ts, and switch_rtp_hdr_t::ts.

Referenced by jb_next_packet().

{
        switch_jb_node_t *node = NULL;

        if (!jb->target_ts) {
                if ((node = jb_find_lowest_node(jb))) {
                        jb_debug(jb, 2, "No target ts using ts: %u as a starting point\n", ntohl(node->packet.header.ts));
                } else {
                        jb_debug(jb, 1, "%s", "No nodes available....\n");
                }
                jb_hit(jb);
        } else if ((node = switch_core_inthash_find(jb->node_hash_ts, jb->target_ts))) {
                jb_debug(jb, 2, "FOUND desired ts: %u\n", ntohl(jb->target_ts));
                jb_hit(jb);
        } else {
                jb_debug(jb, 2, "MISSING desired ts: %u\n", ntohl(jb->target_ts));
                jb_miss(jb);
                increment_ts(jb);
        }

        *nodep = node;
        
        if (node) {
                set_read_ts(jb, node->packet.header.ts);
                node->packet.header.seq = htons(jb->psuedo_seq);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_NOTFOUND;
        
}

static switch_jb_node_t* new_node ( switch_jb_t *  jb )

inlinestatic

Definition at line 198 of file switch_jitterbuffer.c.

References switch_jb_node_s::bad_hits, switch_jb_s::list_mutex, switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::parent, switch_jb_s::pool, switch_jb_node_s::prev, switch_assert, switch_core_alloc, switch_mutex_lock(), switch_mutex_unlock(), switch_jb_node_s::visible, and switch_jb_s::visible_nodes.

Referenced by add_node().

{
        switch_jb_node_t *np;

        switch_mutex_lock(jb->list_mutex);

        for (np = jb->node_list; np; np = np->next) {
                if (!np->visible) {
                        break;
                }
        }

        if (!np) {
                
                np = switch_core_alloc(jb->pool, sizeof(*np));
                
                np->next = jb->node_list;
                if (np->next) {
                        np->next->prev = np;
                }
                jb->node_list = np;
                
        }

        switch_assert(np);
        np->bad_hits = 0;
        np->visible = 1;
        jb->visible_nodes++;
        np->parent = jb;

        switch_mutex_unlock(jb->list_mutex);

        return np;
}

static int node_cmp ( const void *  l, const void *  r  )

static

Definition at line 107 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, switch_jb_node_s::packet, switch_rtp_hdr_t::seq, and switch_jb_node_s::visible.

Referenced by sort_free_nodes().

{
        switch_jb_node_t *a = (switch_jb_node_t *) l;
        switch_jb_node_t *b = (switch_jb_node_t *) r;
        
        if (!a->visible) return 0;
        if (!b->visible) return 1;

        return ntohs(a->packet.header.seq) - ntohs(b->packet.header.seq);
}

static void push_to_top ( switch_jb_t *  jb, switch_jb_node_t *  node  )

inlinestatic

Definition at line 233 of file switch_jitterbuffer.c.

References switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::prev, and switch_assert.

Referenced by hide_node().

{
        if (node == jb->node_list) {
                jb->node_list = node->next;
        } else if (node->prev) {
                node->prev->next = node->next;
        }
                        
        if (node->next) {
                node->next->prev = node->prev;
        }

        node->next = jb->node_list;
        node->prev = NULL;

        if (node->next) {
                node->next->prev = node;
        }

        jb->node_list = node;

        switch_assert(node->next != node);
        switch_assert(node->prev != node);
}

static void set_read_seq ( switch_jb_t *  jb, uint16_t  seq  )

inlinestatic

Definition at line 663 of file switch_jitterbuffer.c.

References switch_jb_s::last_target_seq, and switch_jb_s::target_seq.

Referenced by jb_next_packet_by_seq().

{
        jb->last_target_seq = seq;
        jb->target_seq = htons((ntohs(jb->last_target_seq) + 1));
}

static void set_read_ts ( switch_jb_t *  jb, uint32_t  ts  )

inlinestatic

Definition at line 646 of file switch_jitterbuffer.c.

References switch_jb_s::last_psuedo_seq, switch_jb_s::last_target_ts, switch_jb_s::psuedo_seq, switch_jb_s::samples_per_frame, and switch_jb_s::target_ts.

Referenced by jb_next_packet_by_ts().

{
        if (!ts) return;

        jb->last_psuedo_seq = jb->psuedo_seq;
        jb->last_target_ts = ts;
        jb->target_ts = htonl((ntohl(jb->last_target_ts) + jb->samples_per_frame));
        jb->psuedo_seq++;
}

static void sort_free_nodes ( switch_jb_t *  jb )

inlinestatic

Definition at line 283 of file switch_jitterbuffer.c.

References switch_jb_s::list_mutex, node_cmp(), switch_jb_s::node_list, sort_nodes(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by drop_ts(), and thin_frames().

{
        switch_mutex_lock(jb->list_mutex);
        jb->node_list = sort_nodes(jb->node_list, node_cmp);
        switch_mutex_unlock(jb->list_mutex);
}

switch_jb_node_t* sort_nodes	(	switch_jb_node_t *	list,
		int(*)(const void *, const void *)	cmp
	)

Definition at line 119 of file switch_jitterbuffer.c.

References switch_jb_node_s::next, and switch_jb_node_s::prev.

Referenced by sort_free_nodes().

                                                                                             {
        switch_jb_node_t *p, *q, *e, *tail;
        int insize, nmerges, psize, qsize, i;

        if (!list) {
                return NULL;
        }

        insize = 1;

        while (1) {
                p = list;
                list = NULL;
                tail = NULL;

                nmerges = 0;  /* count number of merges we do in this pass */

                while (p) {
                        nmerges++;  /* there exists a merge to be done */
                                    /* step `insize' places along from p */
                        q = p;
                        psize = 0;
                        for (i = 0; i < insize; i++) {
                                psize++;
                                q = q->next;
                                if (!q) break;
                        }

                        /* if q hasn't fallen off end, we have two lists to merge */
                        qsize = insize;

                        /* now we have two lists; merge them */
                        while (psize > 0 || (qsize > 0 && q)) {

                                /* decide whether next switch_jb_node_t of merge comes from p or q */
                                if (psize == 0) {
                                        /* p is empty; e must come from q. */
                                        e = q; q = q->next; qsize--;
                                } else if (qsize == 0 || !q) {
                                        /* q is empty; e must come from p. */
                                        e = p; p = p->next; psize--;
                                } else if (cmp(p,q) <= 0) {
                                        /* First switch_jb_node_t of p is lower (or same);
                                         * e must come from p. */
                                        e = p; p = p->next; psize--;
                                } else {
                                        /* First switch_jb_node_t of q is lower; e must come from q. */
                                        e = q; q = q->next; qsize--;
                                }

                                /* add the next switch_jb_node_t to the merged list */
                                if (tail) {
                                        tail->next = e;
                                } else {
                                        list = e;
                                }

                                /* Maintain reverse pointers in a doubly linked list. */
                                e->prev = tail;
                                
                                tail = e;
                        }

                        /* now p has stepped `insize' places along, and q has too */
                        p = q;
                }

                tail->next = NULL;

                /* If we have done only one merge, we're finished. */
                if (nmerges <= 1)   /* allow for nmerges==0, the empty list case */
                        return list;

                /* Otherwise repeat, merging lists twice the size */
                insize *= 2;
        }
}

void switch_jb_clear_flag	(	switch_jb_t *	jb,
		switch_jb_flag_t	flag
	)

Definition at line 826 of file switch_jitterbuffer.c.

References switch_clear_flag.

{
        switch_clear_flag(jb, flag);
}

switch_status_t switch_jb_create	(	switch_jb_t **	jbp,
		switch_jb_type_t	type,
		uint32_t	min_frame_len,
		uint32_t	max_frame_len,
		switch_memory_pool_t *	pool
	)

Definition at line 970 of file switch_jitterbuffer.c.

References switch_jb_s::frame_len, switch_jb_s::free_pool, switch_jb_s::highest_frame_len, switch_jb_s::list_mutex, switch_jb_s::max_frame_len, switch_jb_s::min_frame_len, switch_jb_s::missing_seq_hash, switch_jb_s::mutex, switch_jb_s::node_hash, pool, switch_jb_s::pool, SJB_VIDEO, switch_core_alloc, switch_core_inthash_init(), switch_core_new_memory_pool, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_SUCCESS, and switch_jb_s::type.

Referenced by rtp_common_write(), switch_ivr_delay_echo(), switch_rtp_activate_jitter_buffer(), and switch_rtp_set_video_buffer_size().

{
        switch_jb_t *jb;
        int free_pool = 0;

        if (!pool) {
                switch_core_new_memory_pool(&pool);
                free_pool = 1;
        }

        jb = switch_core_alloc(pool, sizeof(*jb));
        jb->free_pool = free_pool;
        jb->min_frame_len = jb->frame_len = min_frame_len;
        jb->max_frame_len = max_frame_len;
        jb->pool = pool;
        jb->type = type;
        jb->highest_frame_len = jb->frame_len;

        if (jb->type == SJB_VIDEO) {
                switch_core_inthash_init(&jb->missing_seq_hash);
        }
        switch_core_inthash_init(&jb->node_hash);
        switch_mutex_init(&jb->mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&jb->list_mutex, SWITCH_MUTEX_NESTED, pool);

        *jbp = jb;

        return SWITCH_STATUS_SUCCESS;
}

void switch_jb_debug_level	(	switch_jb_t *	jb,
		uint8_t	level
	)

Definition at line 841 of file switch_jitterbuffer.c.

Referenced by switch_ivr_delay_echo(), and switch_rtp_debug_jitter_buffer().

{
        jb->debug_level = level;
}

switch_status_t switch_jb_destroy

(

switch_jb_t **

jbp

)

Definition at line 1001 of file switch_jitterbuffer.c.

References free_nodes(), switch_jb_s::free_pool, switch_jb_s::missing_seq_hash, switch_jb_s::node_hash, switch_jb_s::node_hash_ts, switch_jb_s::pool, SJB_VIDEO, switch_core_destroy_memory_pool, switch_core_inthash_destroy(), SWITCH_STATUS_SUCCESS, and switch_jb_s::type.

Referenced by read_rtp_packet(), switch_ivr_delay_echo(), and switch_rtp_destroy().

{
        switch_jb_t *jb = *jbp;
        *jbp = NULL;
        
        if (jb->type == SJB_VIDEO) {
                switch_core_inthash_destroy(&jb->missing_seq_hash);
        }
        switch_core_inthash_destroy(&jb->node_hash);

        if (jb->node_hash_ts) {
                switch_core_inthash_destroy(&jb->node_hash_ts);
        }

        free_nodes(jb);

        if (jb->free_pool) {
                switch_core_destroy_memory_pool(&jb->pool);
        }

        return SWITCH_STATUS_SUCCESS;
}

int switch_jb_frame_count

(

switch_jb_t *

jb

)

Definition at line 836 of file switch_jitterbuffer.c.

{
        return jb->complete_frames;
}

switch_status_t switch_jb_get_frames	(	switch_jb_t *	jb,
		uint32_t *	min_frame_len,
		uint32_t *	max_frame_len,
		uint32_t *	cur_frame_len,
		uint32_t *	highest_frame_len
	)

Definition at line 916 of file switch_jitterbuffer.c.

References switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_rtp_get_stats(), and switch_rtp_get_video_buffer_size().

{

        switch_mutex_lock(jb->mutex);

        if (min_frame_len) {
                *min_frame_len = jb->min_frame_len;
        }

        if (max_frame_len) {
                *max_frame_len = jb->max_frame_len;
        }

        if (cur_frame_len) {
                *cur_frame_len = jb->frame_len;
        }

        switch_mutex_unlock(jb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_size_t switch_jb_get_last_read_len

(

switch_jb_t *

jb

)

Definition at line 1189 of file switch_jitterbuffer.c.

Referenced by read_rtp_packet().

{
        return jb->last_len;
}

switch_status_t switch_jb_get_packet	(	switch_jb_t *	jb,
		switch_rtp_packet_t *	packet,
		switch_size_t *	len
	)

Definition at line 1195 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::body, CF_VIDEO_BITRATE_UNMANAGABLE, switch_core_session_message::from, switch_rtp_packet_t::header, hide_node(), jb_debug, jb_frame_inc, jb_next_packet(), switch_jb_node_s::len, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, switch_jb_node_s::packet, PERIOD_LEN, switch_rtp_hdr_t::seq, SJB_VIDEO, switch_channel_clear_flag(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_receive_message, switch_core_session_request_video_refresh(), switch_goto_status, switch_jb_reset(), SWITCH_MESSAGE_INDICATE_BITRATE_REQ, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_BREAK, SWITCH_STATUS_MORE_DATA, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_RESTART, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, thin_frames(), and switch_rtp_hdr_t::ts.

Referenced by read_rtp_packet(), and switch_ivr_delay_echo().

{
        switch_jb_node_t *node = NULL;
        switch_status_t status;
        int plc = 0;

        switch_mutex_lock(jb->mutex);

        if (jb->complete_frames == 0) {
                switch_goto_status(SWITCH_STATUS_BREAK, end);
        }

        if (jb->complete_frames < jb->frame_len) {
                jb_debug(jb, 2, "BUFFERING %u/%u\n", jb->complete_frames , jb->frame_len);
                switch_goto_status(SWITCH_STATUS_MORE_DATA, end);
        }

        jb_debug(jb, 2, "GET PACKET %u/%u n:%d\n", jb->complete_frames , jb->frame_len, jb->visible_nodes);

        if (++jb->period_count >= PERIOD_LEN) {

                if (jb->consec_good_count >= (PERIOD_LEN - 5)) {
                        jb_frame_inc(jb, -1);
                }

                jb->period_count = 1;
                jb->period_miss_inc = 0;
                jb->period_miss_count = 0;
                jb->period_good_count = 0;
                jb->consec_miss_count = 0;
                jb->consec_good_count = 0;

                if (jb->type == SJB_VIDEO && jb->channel && jb->video_low_bitrate) {
                        //switch_time_t now = switch_time_now();
                        //int ok = (now - jb->last_bitrate_change) > 10000;
                        
                        if (switch_channel_test_flag(jb->channel, CF_VIDEO_BITRATE_UNMANAGABLE) && jb->frame_len == jb->min_frame_len) {
                                jb_debug(jb, 2, "%s", "Allow BITRATE changes\n");
                                switch_channel_clear_flag(jb->channel, CF_VIDEO_BITRATE_UNMANAGABLE);
                                jb->bitrate_control = 0;
                                if (jb->session) {
                                        switch_core_session_request_video_refresh(jb->session);
                                }
                        } else if (!switch_channel_test_flag(jb->channel, CF_VIDEO_BITRATE_UNMANAGABLE) && jb->frame_len > jb->min_frame_len * 2) {
                                switch_core_session_message_t msg = { 0 };

                                jb->bitrate_control = jb->video_low_bitrate;
                                
                                msg.message_id = SWITCH_MESSAGE_INDICATE_BITRATE_REQ;
                                msg.numeric_arg = jb->bitrate_control * 1024;
                                msg.from = __FILE__;
                                
                                jb_debug(jb, 2, "Force BITRATE to %d\n", jb->bitrate_control);
                                switch_core_session_receive_message(jb->session, &msg);
                                switch_channel_set_flag(jb->channel, CF_VIDEO_BITRATE_UNMANAGABLE);
                                if (jb->session) {
                                        switch_core_session_request_video_refresh(jb->session);
                                }
                        }
                }

        }

        jb->period_miss_pct = ((double)jb->period_miss_count / jb->period_count) * 100;

        if (jb->period_miss_pct > 60.0f) {
                jb_debug(jb, 2, "Miss percent %02f too high, resetting buffer.\n", jb->period_miss_pct);
                switch_jb_reset(jb);
        }

        if ((status = jb_next_packet(jb, &node)) == SWITCH_STATUS_SUCCESS) {
                jb_debug(jb, 2, "Found next frame cur ts: %u seq: %u\n", htonl(node->packet.header.ts), htons(node->packet.header.seq));

                if (!jb->read_init || ntohs(node->packet.header.seq) > ntohs(jb->highest_read_seq) || 
                        (ntohs(jb->highest_read_seq) > USHRT_MAX - 10 && ntohs(node->packet.header.seq) <= 10) ) {
                        jb->highest_read_seq = node->packet.header.seq;
                }
                
                if (jb->read_init && htons(node->packet.header.seq) >= htons(jb->highest_read_seq) && (ntohl(node->packet.header.ts) > ntohl(jb->highest_read_ts))) {
                        jb->complete_frames--;
                        jb_debug(jb, 2, "READ frame ts: %u complete=%u/%u n:%u\n", ntohl(node->packet.header.ts), jb->complete_frames , jb->frame_len, jb->visible_nodes);
                        jb->highest_read_ts = node->packet.header.ts;
                } else if (!jb->read_init) {
                        jb->highest_read_ts = node->packet.header.ts;
                }
                
                if (!jb->read_init) jb->read_init = 1;
        } else {
                if (jb->type == SJB_VIDEO) {
                        switch_jb_reset(jb);

                        switch(status) {
                        case SWITCH_STATUS_RESTART:
                                jb_debug(jb, 2, "%s", "Error encountered ask for new keyframe\n");
                                switch_goto_status(SWITCH_STATUS_RESTART, end);
                        case SWITCH_STATUS_NOTFOUND:
                        default:
                                jb_debug(jb, 2, "%s", "No frames found wait for more\n");
                                switch_goto_status(SWITCH_STATUS_MORE_DATA, end);
                        }
                } else {
                        switch(status) {
                        case SWITCH_STATUS_RESTART:
                                jb_debug(jb, 2, "%s", "Error encountered\n");
                                switch_jb_reset(jb);
                                switch_goto_status(SWITCH_STATUS_RESTART, end);
                        case SWITCH_STATUS_NOTFOUND:
                        default:                                                        
                                if (jb->consec_miss_count > jb->frame_len) {
                                        switch_jb_reset(jb);
                                        jb_frame_inc(jb, 1);
                                        jb_debug(jb, 2, "%s", "Too many frames not found, RESIZE\n");
                                        switch_goto_status(SWITCH_STATUS_RESTART, end);
                                } else {
                                        jb_debug(jb, 2, "%s", "Frame not found suggest PLC\n");
                                        plc = 1;
                                        switch_goto_status(SWITCH_STATUS_NOTFOUND, end);
                                }
                        }
                }
        }
        
        if (node) {
                status = SWITCH_STATUS_SUCCESS;
                
                *packet = node->packet;
                *len = node->len;
                jb->last_len = *len;
                memcpy(packet->body, node->packet.body, node->len);
                hide_node(node, SWITCH_TRUE);

                jb_debug(jb, 1, "GET packet ts:%u seq:%u %s\n", ntohl(packet->header.ts), ntohs(packet->header.seq), packet->header.m ? " <MARK>" : "");

        } else {
                status = SWITCH_STATUS_MORE_DATA;
        }

 end:

        if (plc) {
                uint16_t seq;
                uint32_t ts = 0;

                if (jb->samples_per_frame) {
                        seq = htons(jb->last_psuedo_seq);
                        ts = jb->last_target_ts;
                } else {
                        seq = jb->last_target_seq;
                }
                
                packet->header.seq = seq;
                packet->header.ts = ts;
        }

        switch_mutex_unlock(jb->mutex);
        
        if (jb->complete_frames > jb->max_frame_len) {
                thin_frames(jb, 8, 25);
        }

        return status;
}

switch_status_t switch_jb_get_packet_by_seq	(	switch_jb_t *	jb,
		uint16_t	seq,
		switch_rtp_packet_t *	packet,
		switch_size_t *	len
	)

Definition at line 1169 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::body, jb_debug, switch_jb_node_s::len, switch_jb_node_s::packet, switch_core_inthash_find(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_NOTFOUND, and SWITCH_STATUS_SUCCESS.

Referenced by handle_nack().

{
        switch_jb_node_t *node;
        switch_status_t status = SWITCH_STATUS_NOTFOUND;

        switch_mutex_lock(jb->mutex);
        if ((node = switch_core_inthash_find(jb->node_hash, seq))) {
                jb_debug(jb, 2, "Found buffered seq: %u\n", ntohs(seq));
                *packet = node->packet;
                *len = node->len;
                memcpy(packet->body, node->packet.body, node->len);
                status = SWITCH_STATUS_SUCCESS;
        } else {
                jb_debug(jb, 2, "Missing buffered seq: %u\n", ntohs(seq));
        }
        switch_mutex_unlock(jb->mutex);

        return status;
}

switch_status_t switch_jb_peek_frame	(	switch_jb_t *	jb,
		uint32_t	ts,
		uint16_t	seq,
		int	peek,
		switch_frame_t *	frame
	)

Definition at line 890 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::body, switch_rtp_packet_t::header, switch_jb_node_s::len, switch_rtp_hdr_t::m, switch_jb_node_s::packet, switch_rtp_hdr_t::seq, switch_core_inthash_find(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtp_hdr_t::ts.

{
        switch_jb_node_t *node = NULL;
        if (seq) {
                uint16_t want_seq = seq + peek;
                node = switch_core_inthash_find(jb->node_hash, htons(want_seq));
        } else if (ts && jb->samples_per_frame) {
                uint32_t want_ts = ts + (peek * jb->samples_per_frame); 
                node = switch_core_inthash_find(jb->node_hash_ts, htonl(want_ts));
        }

        if (node) {
                frame->seq = ntohs(node->packet.header.seq);
                frame->timestamp = ntohl(node->packet.header.ts);
                frame->m = node->packet.header.m;
                frame->datalen = node->len;

                if (frame->data && frame->buflen > node->len) {
                        memcpy(frame->data, node->packet.body, node->len);
                }
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

int switch_jb_poll

(

switch_jb_t *

jb

)

Definition at line 831 of file switch_jitterbuffer.c.

Referenced by rtp_common_read().

{
        return (jb->complete_frames >= jb->frame_len);
}

uint32_t switch_jb_pop_nack

(

switch_jb_t *

jb

)

Definition at line 1024 of file switch_jitterbuffer.c.

References jb_debug, RENACK_TIME, SJB_VIDEO, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_inthash_delete(), switch_core_inthash_insert(), switch_mutex_lock(), switch_mutex_unlock(), and switch_time_now().

Referenced by check_rtcp_and_ice().

{
        switch_hash_index_t *hi = NULL;
        uint32_t nack = 0;
        uint16_t blp = 0;
        uint16_t least = 0;
        int i = 0;
        void *val;
        const void *var;

        if (jb->type != SJB_VIDEO) {
                return 0;
        }

        switch_mutex_lock(jb->mutex);

 top:

        for (hi = switch_core_hash_first(jb->missing_seq_hash); hi; hi = switch_core_hash_next(&hi)) {
                uint16_t seq;
                //const char *token;
                switch_time_t then = 0;
                
                switch_core_hash_this(hi, &var, NULL, &val);
                //token = (const char *) val;

                //if (token == TOKEN_2) {
                        //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "SKIP %u %s\n", ntohs(*((uint16_t *) var)), token);
                        //printf("WTf\n");
                //      continue;
                //}
                
                seq = ntohs(*((uint16_t *) var));
                then = (intptr_t) val;

                if (then != 1 && switch_time_now() - then < RENACK_TIME) {
                        //jb_debug(jb, 3, "NACKABLE seq %u too soon to repeat\n", seq);
                        continue;
                }
                
                //if (then != 1) {
                //      jb_debug(jb, 3, "NACKABLE seq %u not too soon to repeat %lu\n", seq, switch_time_now() - then);
                //}

                if (seq < ntohs(jb->target_seq) - jb->frame_len) {
                        jb_debug(jb, 3, "NACKABLE seq %u expired\n", seq);
                        switch_core_inthash_delete(jb->missing_seq_hash, (uint32_t)htons(seq));
                        goto top;
                }

                if (!least || seq < least) {
                        least = seq;
                }
        }

        if (least && switch_core_inthash_delete(jb->missing_seq_hash, (uint32_t)htons(least))) {
                jb_debug(jb, 3, "Found NACKABLE seq %u\n", least);
                nack = (uint32_t) htons(least);
                switch_core_inthash_insert(jb->missing_seq_hash, nack, (void *) (intptr_t)switch_time_now());

                for(i = 0; i < 16; i++) {
                        if (switch_core_inthash_delete(jb->missing_seq_hash, (uint32_t)htons(least + i + 1))) {
                                switch_core_inthash_insert(jb->missing_seq_hash, (uint32_t)htons(least + i + 1), (void *)(intptr_t)switch_time_now());
                                jb_debug(jb, 3, "Found addtl NACKABLE seq %u\n", least + i + 1);
                                blp |= (1 << i);
                        }
                }

                blp = htons(blp);
                nack |= (uint32_t) blp << 16;

                //jb_frame_inc(jb, 1);
        }
        
        switch_mutex_unlock(jb->mutex);


        return nack;
}

switch_status_t switch_jb_put_packet	(	switch_jb_t *	jb,
		switch_rtp_packet_t *	packet,
		switch_size_t	len
	)

Definition at line 1104 of file switch_jitterbuffer.c.

References add_node(), drop_oldest_frame(), jb_debug, jb_frame_inc, SJB_AUDIO, SJB_QUEUE_ONLY, SWITCH_CHANNEL_LOG, switch_core_inthash_delete(), switch_core_inthash_insert(), switch_core_session_request_video_refresh(), switch_jb_reset(), switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_SIZE_T_FMT, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by read_rtp_packet(), rtp_common_write(), and switch_ivr_delay_echo().

{
        uint32_t i;
        uint16_t want = ntohs(jb->next_seq), got = ntohs(packet->header.seq);

        if (len >= sizeof(switch_rtp_packet_t)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "trying to put %" SWITCH_SIZE_T_FMT " bytes exceeding buffer, truncate to %" SWITCH_SIZE_T_FMT "\n", len, sizeof(switch_rtp_packet_t));
                len = sizeof(switch_rtp_packet_t);
        }

        switch_mutex_lock(jb->mutex);

        if (!want) want = got;

        if (switch_test_flag(jb, SJB_QUEUE_ONLY) || jb->type == SJB_AUDIO) {
                jb->next_seq = htons(got + 1);
        } else {

                if (switch_core_inthash_delete(jb->missing_seq_hash, (uint32_t)htons(got))) {
                        if (got < ntohs(jb->target_seq)) {
                                jb_debug(jb, 2, "got nacked seq %u too late\n", got);
                                jb_frame_inc(jb, 1);
                        } else {
                                jb_debug(jb, 2, "got nacked %u saved the day!\n", got);
                        }
                }

                if (got > want) {
                        if (got - want > jb->max_frame_len && got - want > 17) {
                                jb_debug(jb, 2, "Missing %u frames, Resetting\n", got - want);
                                switch_jb_reset(jb);
                                if (jb->session) {
                                        switch_core_session_request_video_refresh(jb->session);
                                }
                        } else {

                                if (jb->frame_len < got - want) {
                                        jb_frame_inc(jb, 1);
                                }

                                jb_debug(jb, 2, "GOT %u WANTED %u; MARK SEQS MISSING %u - %u\n", got, want, want, got - 1);
                        
                                for (i = want; i < got; i++) {
                                        jb_debug(jb, 2, "MARK MISSING %u ts:%u\n", i, ntohl(packet->header.ts));
                                        switch_core_inthash_insert(jb->missing_seq_hash, (uint32_t)htons(i), (void *)(intptr_t)1);
                                }
                        }
                }

                if (got >= want || (want - got) > 1000) {
                        jb->next_seq = htons(got + 1);
                }
        }

        add_node(jb, packet, len);

        if (switch_test_flag(jb, SJB_QUEUE_ONLY) && jb->complete_frames > jb->max_frame_len) {
                drop_oldest_frame(jb);
        }
        
        switch_mutex_unlock(jb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

void switch_jb_reset

(

switch_jb_t *

jb

)

Definition at line 846 of file switch_jitterbuffer.c.

References hide_nodes(), jb_debug, SJB_VIDEO, switch_core_inthash_destroy(), switch_core_inthash_init(), switch_core_session_request_video_refresh(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by add_node(), do_flush(), handle_rfc2833(), process_rtcp_report(), read_rtp_packet(), switch_jb_get_packet(), switch_jb_put_packet(), switch_rtp_del_dtls(), switch_rtp_pause_jitter_buffer(), switch_rtp_reset_jb(), switch_rtp_reset_vb(), and switch_rtp_set_flag().

{

        if (jb->type == SJB_VIDEO) {
                switch_mutex_lock(jb->mutex);
                switch_core_inthash_destroy(&jb->missing_seq_hash);
                switch_core_inthash_init(&jb->missing_seq_hash);
                switch_mutex_unlock(jb->mutex);

                if (jb->session) {
                        switch_core_session_request_video_refresh(jb->session);
                }
        }

        jb_debug(jb, 2, "%s", "RESET BUFFER\n");

        jb->drop_flag = 0;
        jb->last_target_seq = 0;
        jb->target_seq = 0;
        jb->write_init = 0;
        jb->highest_wrote_seq = 0;
        jb->highest_wrote_ts = 0;
        jb->next_seq = 0;
        jb->highest_read_ts = 0;
        jb->highest_read_seq = 0;
        jb->complete_frames = 0;
        jb->read_init = 0;
        jb->next_seq = 0;
        jb->complete_frames = 0;
        jb->period_miss_count = 0;
        jb->consec_miss_count = 0;
        jb->period_miss_pct = 0;
        jb->period_good_count = 0;
        jb->consec_good_count = 0;
        jb->period_count = 0;
        jb->period_miss_inc = 0;
        jb->target_ts = 0;
        jb->last_target_ts = 0;

        switch_mutex_lock(jb->mutex);
        hide_nodes(jb);
        switch_mutex_unlock(jb->mutex);
}

void switch_jb_set_flag	(	switch_jb_t *	jb,
		switch_jb_flag_t	flag
	)

Definition at line 821 of file switch_jitterbuffer.c.

References switch_set_flag.

Referenced by rtp_common_write().

{
        switch_set_flag(jb, flag);
}

switch_status_t switch_jb_set_frames	(	switch_jb_t *	jb,
		uint32_t	min_frame_len,
		uint32_t	max_frame_len
	)

Definition at line 938 of file switch_jitterbuffer.c.

References switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_rtp_activate_jitter_buffer(), and switch_rtp_set_video_buffer_size().

{
        int lowest = 0;

        switch_mutex_lock(jb->mutex);

        if (jb->frame_len == jb->min_frame_len) lowest = 1;

        jb->min_frame_len = min_frame_len;
        jb->max_frame_len = max_frame_len;

        if (jb->frame_len > jb->max_frame_len) {
                jb->frame_len = jb->max_frame_len;
        }

        if (jb->frame_len < jb->min_frame_len) {
                jb->frame_len = jb->min_frame_len;
        }
        
        if (jb->frame_len > jb->highest_frame_len) {
                jb->highest_frame_len = jb->frame_len;
        }

        if (lowest) {
                jb->frame_len = jb->min_frame_len;
        }

        switch_mutex_unlock(jb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

void switch_jb_set_session	(	switch_jb_t *	jb,
		switch_core_session_t *	session
	)

Definition at line 804 of file switch_jitterbuffer.c.

References SJB_VIDEO, switch_channel_get_variable_dup(), switch_core_session_get_channel(), and SWITCH_FALSE.

Referenced by switch_rtp_activate_jitter_buffer(), and switch_rtp_set_video_buffer_size().

{
        const char *var;

        jb->session = session;
        jb->channel = switch_core_session_get_channel(session);

        if (jb->type == SJB_VIDEO && (var = switch_channel_get_variable_dup(jb->channel, "jb_video_low_bitrate", SWITCH_FALSE, -1))) {
                int tmp = atoi(var);

                if (tmp > 128 && tmp < 10240) {
                        jb->video_low_bitrate = (uint32_t)tmp;
                }
        }

}

void switch_jb_ts_mode	(	switch_jb_t *	jb,
		uint32_t	samples_per_frame,
		uint32_t	samples_per_second
	)

Definition at line 797 of file switch_jitterbuffer.c.

References switch_core_inthash_init().

Referenced by switch_rtp_activate_jitter_buffer().

{
        jb->samples_per_frame = samples_per_frame;
        jb->samples_per_second = samples_per_second;
        switch_core_inthash_init(&jb->node_hash_ts);
}

static void thin_frames ( switch_jb_t *  jb, int  freq, int  max  )

inlinestatic

Definition at line 368 of file switch_jitterbuffer.c.

References switch_jb_s::complete_frames, drop_ts(), switch_rtp_packet_t::header, switch_jb_s::list_mutex, switch_jb_s::max_frame_len, switch_jb_node_s::next, switch_jb_s::node_list, switch_jb_node_s::packet, sort_free_nodes(), switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_hdr_t::ts, and switch_jb_node_s::visible.

Referenced by switch_jb_get_packet().

{
        switch_jb_node_t *node;
        int i = -1;
        int dropped = 0;

        switch_mutex_lock(jb->list_mutex);
        node = jb->node_list;

        for (node = jb->node_list; node && jb->complete_frames > jb->max_frame_len && dropped < max; node = node->next) {

                if (node->visible) {
                        i++;
                } else {
                        continue;
                }

                if ((i % freq) == 0) {
                        drop_ts(jb, node->packet.header.ts);
                        node = jb->node_list;
                        dropped++;
                }
        }

        sort_free_nodes(jb);
        switch_mutex_unlock(jb->list_mutex);    
}