switch_jitterbuffer.h File Reference

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

Go to the source code of this file.

Enumerations
enum	switch_jb_flag_t { SJB_QUEUE_ONLY = (1 << 0) }
enum	switch_jb_type_t { SJB_VIDEO = 0, SJB_AUDIO, SJB_TEXT }

Functions
SWITCH_BEGIN_EXTERN_C 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_set_frames (switch_jb_t *jb, uint32_t min_frame_len, uint32_t max_frame_len)
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_destroy (switch_jb_t **jbp)
void	switch_jb_reset (switch_jb_t *jb)
void	switch_jb_debug_level (switch_jb_t *jb, uint8_t level)
int	switch_jb_frame_count (switch_jb_t *jb)
int	switch_jb_poll (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_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)
uint32_t	switch_jb_pop_nack (switch_jb_t *jb)
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)
void	switch_jb_set_session (switch_jb_t *jb, switch_core_session_t *session)
void	switch_jb_set_jitter_estimator (switch_jb_t *jb, double *jitter, uint32_t samples_per_frame, uint32_t samples_per_second)
void	switch_jb_ts_mode (switch_jb_t *jb, uint32_t samples_per_frame, uint32_t samples_per_second)
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)
uint32_t	switch_jb_get_nack_success (switch_jb_t *jb)
uint32_t	switch_jb_get_packets_per_frame (switch_jb_t *jb)

Enumeration Type Documentation

switch_jb_flag_t

enum switch_jb_flag_t

Enumerator
SJB_QUEUE_ONLY

Definition at line 36 of file switch_jitterbuffer.h.

             {
        SJB_QUEUE_ONLY = (1 << 0)
} switch_jb_flag_t;

switch_jb_type_t

enum switch_jb_type_t

Enumerator
SJB_VIDEO
SJB_AUDIO
SJB_TEXT

Definition at line 40 of file switch_jitterbuffer.h.

             {
        SJB_VIDEO = 0,
        SJB_AUDIO,
        SJB_TEXT
} switch_jb_type_t;

Function Documentation

switch_jb_clear_flag()

void switch_jb_clear_flag	(	switch_jb_t *	jb,
		switch_jb_flag_t	flag
	)

Definition at line 1143 of file switch_jitterbuffer.c.

References switch_clear_flag.

{
        switch_clear_flag(jb, flag);
}

switch_jb_create()

SWITCH_BEGIN_EXTERN_C 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 1322 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, switch_jb_s::period_len, 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);
                jb->period_len = 2500;
        } else {
                jb->period_len = 250;
        }
        
        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;
}

switch_jb_debug_level()

void switch_jb_debug_level	(	switch_jb_t *	jb,
		uint8_t	level
	)

Definition at line 1169 of file switch_jitterbuffer.c.

References switch_jb_s::debug_level.

Referenced by switch_ivr_delay_echo(), and switch_rtp_debug_jitter_buffer().

{
        jb->debug_level = level;
}

switch_jb_destroy()

switch_status_t switch_jb_destroy

(

switch_jb_t **

jbp

)

Definition at line 1357 of file switch_jitterbuffer.c.

References free_nodes(), switch_jb_s::free_pool, jb_debug, switch_jb_s::missing_seq_hash, switch_jb_s::nack_didnt_save_the_day, switch_jb_s::nack_saved_the_day, switch_jb_s::node_hash, switch_jb_s::node_hash_ts, switch_jb_s::pool, SJB_QUEUE_ONLY, SJB_VIDEO, switch_core_destroy_memory_pool, switch_core_inthash_destroy(), switch_hashtable_count(), SWITCH_STATUS_SUCCESS, switch_test_flag, 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_test_flag(jb, SJB_QUEUE_ONLY)) {
                jb_debug(jb, 3, "Stats: NACK saved the day: %u\n", jb->nack_saved_the_day);
                jb_debug(jb, 3, "Stats: NACK was late: %u\n", jb->nack_didnt_save_the_day);
                jb_debug(jb, 3, "Stats: Hash entrycount: missing_seq_hash %u\n", switch_hashtable_count(jb->missing_seq_hash));
        }
        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;
}

switch_jb_frame_count()

int switch_jb_frame_count

(

switch_jb_t *

jb

)

Definition at line 1164 of file switch_jitterbuffer.c.

References switch_jb_s::complete_frames.

{
        return jb->complete_frames;
}

switch_jb_get_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 1268 of file switch_jitterbuffer.c.

References switch_jb_s::frame_len, switch_jb_s::max_frame_len, switch_jb_s::min_frame_len, switch_jb_s::mutex, 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_jb_get_last_read_len()

switch_size_t switch_jb_get_last_read_len

(

switch_jb_t *

jb

)

Definition at line 1567 of file switch_jitterbuffer.c.

References switch_jb_s::last_len.

Referenced by read_rtp_packet().

{
        return jb->last_len;
}

switch_jb_get_nack_success()

uint32_t switch_jb_get_nack_success

(

switch_jb_t *

jb

)

Definition at line 1224 of file switch_jitterbuffer.c.

References switch_jb_s::mutex, switch_jb_s::nack_didnt_save_the_day, switch_jb_s::nack_saved_the_day, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_rtp_destroy().

{
        uint32_t nack_recovered; /*count*/
        switch_mutex_lock(jb->mutex);
        nack_recovered = jb->nack_saved_the_day + jb->nack_didnt_save_the_day;
        switch_mutex_unlock(jb->mutex);
        return nack_recovered;
}

switch_jb_get_packet()

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

Definition at line 1572 of file switch_jitterbuffer.c.

References switch_jb_s::bitrate_control, switch_jb_stats_s::buffer_size_ms, CF_VIDEO_BITRATE_UNMANAGABLE, switch_jb_s::channel, check_jb_size(), check_seq(), check_ts(), switch_jb_s::complete_frames, switch_jb_s::consec_good_count, switch_jb_s::consec_miss_count, decrement_seq(), switch_jb_s::elastic, switch_jb_jitter_s::estimate, switch_jb_stats_s::estimate_ms, switch_jb_stats_s::expand, switch_jb_s::flush, switch_jb_s::frame_len, switch_core_session_message::from, switch_rtp_packet_t::header, hide_node(), switch_jb_s::highest_read_seq, switch_jb_s::highest_read_ts, jb_debug, jb_frame_inc, jb_next_packet(), switch_jb_s::jitter, switch_jb_s::last_len, switch_jb_s::last_psuedo_seq, switch_jb_s::last_target_seq, switch_jb_s::last_target_ts, switch_jb_node_s::len, switch_rtp_hdr_t::m, switch_jb_s::max_frame_len, switch_core_session_message::message_id, switch_jb_s::min_frame_len, switch_jb_s::mutex, switch_core_session_message::numeric_arg, switch_jb_node_s::packet, switch_jb_s::period_count, switch_jb_s::period_good_count, switch_jb_s::period_len, switch_jb_s::period_miss_count, switch_jb_s::period_miss_inc, switch_jb_s::period_miss_pct, switch_jb_s::read_init, switch_jb_stats_s::reset_error, switch_jb_jitter_s::samples_per_frame, switch_jb_s::samples_per_frame, switch_jb_jitter_s::samples_per_second, switch_rtp_hdr_t::seq, switch_jb_s::session, SJB_VIDEO, switch_jb_jitter_s::stats, switch_channel_clear_flag_recursive(), switch_channel_set_flag_recursive(), switch_channel_test_flag(), switch_core_session_receive_message, switch_core_session_request_video_refresh, switch_goto_status, switch_jb_poll(), switch_jb_reset(), SWITCH_LOG_INFO, 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_STATUS_TIMEOUT, SWITCH_TRUE, switch_rtp_hdr_t::ts, switch_jb_s::type, switch_rtp_hdr_t::version, switch_jb_s::video_low_bitrate, and switch_jb_s::visible_nodes.

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) {
                jb->flush = 0;
                switch_goto_status(SWITCH_STATUS_BREAK, end);
        }

        if (jb->complete_frames < jb->frame_len) {

                switch_jb_poll(jb);

                if (!jb->flush) {
                        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 >= jb->period_len) {

                if (jb->consec_good_count >= (jb->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_recursive(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->max_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_recursive(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 || check_seq(node->packet.header.seq, jb->highest_read_seq)) {
                        jb->highest_read_seq = node->packet.header.seq;
                }

                if (jb->type != SJB_VIDEO ||
                        (jb->read_init && check_seq(node->packet.header.seq, jb->highest_read_seq) && check_ts(node->packet.header.ts, jb->highest_read_ts))) {

                        if (jb->type != SJB_VIDEO) {
                                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");
                                jb->jitter.stats.reset_error++;
                                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 {
                                        if (jb->elastic) {
                                                int visible_not_old = check_jb_size(jb);

                                                jb->jitter.stats.estimate_ms = (int)((*jb->jitter.estimate) / ((jb->jitter.samples_per_second)) * 1000);
                                                jb->jitter.stats.buffer_size_ms = (int)((visible_not_old * jb->jitter.samples_per_frame) / (jb->jitter.samples_per_second / 1000));
                                                /* When playing PLC, we take the oportunity to expand the buffer if the jitter buffer is smaller than the 3x the estimated jitter. */
                                                if (jb->jitter.stats.buffer_size_ms < (3 * jb->jitter.stats.estimate_ms)) {
                                                        jb_debug(jb, SWITCH_LOG_INFO, "JITTER estimation %dms buffersize %d/%d %dms EXPAND [plc]\n",
                                                                         jb->jitter.stats.estimate_ms, jb->complete_frames, jb->frame_len, jb->jitter.stats.buffer_size_ms);
                                                        jb->jitter.stats.expand++;
                                                        decrement_seq(jb);
                                                } else {
                                                        jb_debug(jb, 2, "%s", "Frame not found suggest PLC\n");
                                                }
                                        } else {
                                                jb_debug(jb, 2, "%s", "Frame not found suggest PLC\n");
                                        }

                                        plc = 1;
                                        switch_goto_status(SWITCH_STATUS_NOTFOUND, end);
                                }
                        }
                }
        }

        *packet = node->packet;
        *len = node->len;
        jb->last_len = *len;
        packet->header.version = 2;
        hide_node(node, SWITCH_TRUE);

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

 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->type == SJB_VIDEO) {
                if (jb->complete_frames > jb->max_frame_len * 2) {
                        jb_debug(jb, 2, "JB TOO BIG (%d), RESET\n", jb->complete_frames);
                        switch_jb_reset(jb);
                }
        } else {
                int too_big = (int)(jb->max_frame_len * 1.5);
                if (jb->visible_nodes > too_big && status == SWITCH_STATUS_SUCCESS) {
                        status = SWITCH_STATUS_TIMEOUT;
                }
        }
        
        return status;
}

switch_jb_get_packet_by_seq()

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 1547 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::header, jb_debug, switch_jb_node_s::len, switch_jb_s::mutex, switch_jb_s::node_hash, switch_jb_node_s::packet, switch_core_inthash_find(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, and switch_rtp_hdr_t::version.

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;
                packet->header.version = 2;
                status = SWITCH_STATUS_SUCCESS;
        } else {
                jb_debug(jb, 2, "Missing buffered seq: %u\n", ntohs(seq));
        }
        switch_mutex_unlock(jb->mutex);

        return status;
}

switch_jb_get_packets_per_frame()

uint32_t switch_jb_get_packets_per_frame

(

switch_jb_t *

jb

)

Definition at line 1233 of file switch_jitterbuffer.c.

References switch_jb_s::mutex, switch_jb_s::packet_count, switch_mutex_lock(), and switch_mutex_unlock().

{
        uint32_t ppf;
        switch_mutex_lock(jb->mutex);
        ppf = jb->packet_count; /* get current packets per frame */
        switch_mutex_unlock(jb->mutex);
        return ppf;
}

switch_jb_peek_frame()

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 1242 of file switch_jitterbuffer.c.

References switch_rtp_packet_t::body, switch_frame::buflen, switch_frame::data, switch_frame::datalen, switch_rtp_packet_t::header, switch_jb_node_s::len, switch_frame::m, switch_rtp_hdr_t::m, switch_jb_s::node_hash, switch_jb_s::node_hash_ts, switch_jb_node_s::packet, switch_jb_s::samples_per_frame, switch_frame::seq, switch_rtp_hdr_t::seq, switch_core_inthash_find(), SWITCH_RTP_HEADER_LEN, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_frame::timestamp, and switch_rtp_hdr_t::ts.

Referenced by switch_core_media_read_frame().

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

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

        return SWITCH_STATUS_FALSE;
}

switch_jb_poll()

int switch_jb_poll

(

switch_jb_t *

jb

)

Definition at line 1148 of file switch_jitterbuffer.c.

References switch_jb_s::buffer_lag, switch_jb_s::complete_frames, switch_jb_s::flush, switch_jb_s::frame_len, SJB_TEXT, and switch_jb_s::type.

Referenced by rtp_common_read(), and switch_jb_get_packet().

{
        if (jb->type == SJB_TEXT) {
                if (jb->complete_frames < jb->frame_len) {
                        if (jb->complete_frames && !jb->buffer_lag) {
                                jb->buffer_lag = 10;
                        }
                        if (jb->buffer_lag && --jb->buffer_lag == 0) {
                                jb->flush = 1;
                        }
                }
        }

        return (jb->complete_frames >= jb->frame_len) || jb->flush;
}

switch_jb_pop_nack()

uint32_t switch_jb_pop_nack

(

switch_jb_t *

jb

)

Definition at line 1385 of file switch_jitterbuffer.c.

References switch_jb_s::frame_len, jb_debug, switch_jb_s::missing_seq_hash, switch_jb_s::mutex, RENACK_TIME, SJB_VIDEO, switch_core_hash_first_iter(), switch_core_hash_next(), switch_core_hash_this(), switch_core_inthash_delete(), switch_core_inthash_insert(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_time_now(), switch_jb_s::target_seq, and switch_jb_s::type.

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_iter(jb->missing_seq_hash, hi); 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 && ((uint32_t)(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;
                }
        }

        switch_safe_free(hi);

        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_jb_put_packet()

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

Definition at line 1467 of file switch_jitterbuffer.c.

References add_node(), switch_jb_s::allocated_nodes, drop_oldest_frame(), switch_jb_s::frame_len, switch_rtp_packet_t::header, switch_jb_s::highest_dropped_ts, jb_debug, jb_frame_inc, switch_jb_s::jitter, switch_jb_s::max_frame_len, switch_jb_s::max_packet_len, switch_jb_s::missing_seq_hash, switch_jb_s::mutex, switch_jb_s::nack_didnt_save_the_day, switch_jb_s::nack_saved_the_day, switch_jb_s::next_seq, switch_jb_stats_s::reset_missing_frames, switch_rtp_hdr_t::seq, SJB_AUDIO, SJB_QUEUE_ONLY, SJB_TEXT, SJB_VIDEO, switch_jb_jitter_s::stats, SWITCH_CHANNEL_LOG, switch_core_inthash_delete(), switch_core_inthash_insert(), switch_jb_reset(), switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RTP_MAX_PACKET_LEN, SWITCH_SIZE_T_FMT, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_jb_s::target_seq, switch_rtp_hdr_t::ts, switch_jb_s::type, and switch_jb_s::visible_nodes.

Referenced by read_bundle_rtp_packet(), 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 >= SWITCH_RTP_MAX_PACKET_LEN) {
                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, SWITCH_RTP_MAX_PACKET_LEN);
                len = SWITCH_RTP_MAX_PACKET_LEN;
        }

        switch_mutex_lock(jb->mutex);

        if (jb->highest_dropped_ts) {
                if (ntohl(packet->header.ts) < jb->highest_dropped_ts) {
                        jb_debug(jb, 2, "%s", "TS ALREADY DROPPED, DROPPING PACKET\n");
                        switch_mutex_unlock(jb->mutex);
                        return SWITCH_STATUS_SUCCESS;
                }
                jb->highest_dropped_ts = 0;
        }


        if (!want) want = got;

        if (switch_test_flag(jb, SJB_QUEUE_ONLY) || jb->type == SJB_AUDIO || jb->type == SJB_TEXT) {
                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);
                                jb->nack_didnt_save_the_day++;
                        } else {
                                jb_debug(jb, 2, "got nacked %u saved the day!\n", got);
                                jb->nack_saved_the_day++;
                        }
                }

                if (got > want) {
                        if (got - want > jb->max_frame_len && got - want > 17) {
                                jb_debug(jb, 2, "Missing %u frames, Resetting\n", got - want);
                                jb->jitter.stats.reset_missing_frames++;
                                switch_jb_reset(jb);
                        } else {
                                if (jb->type != SJB_VIDEO && 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->max_packet_len && jb->max_frame_len * 2 > jb->max_packet_len &&
                        jb->allocated_nodes > jb->max_frame_len * 2 - 1) {
                while ((jb->max_frame_len * 2 - jb->visible_nodes) < jb->max_packet_len) {
                        drop_oldest_frame(jb);
                }
        } else if (switch_test_flag(jb, SJB_QUEUE_ONLY) && jb->max_packet_len && jb->max_frame_len * 2 < jb->max_packet_len) {
                /* rtp_nack_buffer_size less than initial max_packet_len */
                drop_oldest_frame(jb);
        }

        switch_mutex_unlock(jb->mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_jb_reset()

void switch_jb_reset

(

switch_jb_t *

jb

)

Definition at line 1174 of file switch_jitterbuffer.c.

References switch_jb_s::channel, switch_jb_s::complete_frames, switch_jb_s::consec_good_count, switch_jb_s::consec_miss_count, switch_jb_s::drop_flag, hide_nodes(), switch_jb_s::highest_read_seq, switch_jb_s::highest_read_ts, switch_jb_s::highest_wrote_seq, switch_jb_s::highest_wrote_ts, jb_debug, switch_jb_s::jitter, switch_jb_s::last_target_seq, switch_jb_s::last_target_ts, switch_jb_s::missing_seq_hash, switch_jb_s::mutex, switch_jb_s::next_seq, switch_jb_s::period_count, switch_jb_s::period_good_count, switch_jb_s::period_miss_count, switch_jb_s::period_miss_inc, switch_jb_s::period_miss_pct, switch_jb_s::read_init, switch_jb_stats_s::reset, switch_jb_stats_s::reset_error, switch_jb_stats_s::reset_missing_frames, switch_jb_stats_s::reset_too_big, switch_jb_stats_s::reset_ts_jump, switch_jb_s::session, SJB_VIDEO, switch_jb_jitter_s::stats, switch_channel_set_variable_printf(), switch_core_inthash_destroy(), switch_core_inthash_init(), switch_core_session_request_video_refresh, switch_mutex_lock(), switch_mutex_unlock(), switch_jb_s::target_seq, switch_jb_s::target_ts, switch_jb_s::type, and switch_jb_s::write_init.

Referenced by add_node(), do_flush(), handle_rfc2833(), new_node(), 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().

{
        jb->jitter.stats.reset++;
        if (jb->channel) {
                switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_count", "%u", jb->jitter.stats.reset);
                switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_too_big", "%u", jb->jitter.stats.reset_too_big);
                switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_missing_frames", "%u", jb->jitter.stats.reset_missing_frames);
                switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_ts_jump", "%u", jb->jitter.stats.reset_ts_jump);
                switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_error", "%u", jb->jitter.stats.reset_error);
        }

        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");

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

        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->read_init = 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_jb_set_flag()

void switch_jb_set_flag	(	switch_jb_t *	jb,
		switch_jb_flag_t	flag
	)

Definition at line 1138 of file switch_jitterbuffer.c.

References switch_set_flag.

Referenced by rtp_common_write().

{
        switch_set_flag(jb, flag);
}

switch_jb_set_frames()

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

Definition at line 1290 of file switch_jitterbuffer.c.

References switch_jb_s::frame_len, switch_jb_s::highest_frame_len, switch_jb_s::max_frame_len, switch_jb_s::min_frame_len, switch_jb_s::mutex, 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;
}

switch_jb_set_jitter_estimator()

void switch_jb_set_jitter_estimator	(	switch_jb_t *	jb,
		double *	jitter,
		uint32_t	samples_per_frame,
		uint32_t	samples_per_second
	)

Definition at line 1079 of file switch_jitterbuffer.c.

References switch_jb_s::channel, switch_jb_jitter_s::drop_gap, switch_jb_jitter_s::estimate, switch_jb_s::jitter, memset(), switch_jb_jitter_s::samples_per_frame, switch_jb_jitter_s::samples_per_second, and switch_channel_set_variable_printf().

Referenced by switch_rtp_activate_jitter_buffer().

{
        if (jb && jitter) {
                memset(&jb->jitter, 0, sizeof(switch_jb_jitter_t));
                if (jb->channel) {
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_max_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_size_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_acceleration_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_expand_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_jitter_max_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_jitter_ms", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_count", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_too_big", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_missing_frames", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_ts_jump", "%u", 0);
                        switch_channel_set_variable_printf(jb->channel, "rtp_jb_reset_error", "%u", 0);
                }

                jb->jitter.estimate = jitter;
                jb->jitter.samples_per_frame = samples_per_frame;
                jb->jitter.samples_per_second = samples_per_second;
                jb->jitter.drop_gap = 5;
        }
}

switch_jb_set_session()

void switch_jb_set_session	(	switch_jb_t *	jb,
		switch_core_session_t *	session
	)

Definition at line 1104 of file switch_jitterbuffer.c.

References switch_jb_s::channel, switch_jb_s::codec, switch_jb_s::elastic, switch_codec_implementation::iananame, switch_codec::implementation, switch_jb_s::session, SJB_AUDIO, SJB_QUEUE_ONLY, SJB_VIDEO, switch_channel_get_variable_dup(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_var_true(), switch_core_session_get_channel(), switch_core_session_get_read_codec(), SWITCH_FALSE, SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, switch_log_printf(), switch_test_flag, SWITCH_TRUE, switch_jb_s::type, and switch_jb_s::video_low_bitrate.

Referenced by switch_rtp_activate_jitter_buffer(), and switch_rtp_set_video_buffer_size().

{
        const char *var;

        if (session) {
                jb->codec = switch_core_session_get_read_codec(session);
                jb->session = session;
                jb->channel = switch_core_session_get_channel(session);
                if (jb->type == SJB_AUDIO) {
                        if (!strcmp(jb->codec->implementation->iananame, "opus")) {
                                if (switch_channel_var_true(jb->channel, "rtp_jitter_buffer_accelerate")) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "audio codec is %s, accelerate on\n", jb->codec->implementation->iananame);
                                        jb->elastic = SWITCH_TRUE;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "audio codec is %s, accelerate off\n", jb->codec->implementation->iananame);
                                        jb->elastic = SWITCH_FALSE;
                                }
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "audio codec is not Opus: %s\n", jb->codec->implementation->iananame);
                                jb->elastic = SWITCH_FALSE;
                        }
                }

                if (jb->type == SJB_VIDEO && !switch_test_flag(jb, SJB_QUEUE_ONLY) &&
                        (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;
                        }
                }
        }
}

switch_jb_ts_mode()

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

Definition at line 1072 of file switch_jitterbuffer.c.

References switch_jb_s::node_hash_ts, switch_jb_s::samples_per_frame, switch_jb_s::samples_per_second, and 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);
}