pbuf.c File Reference

#include "config.h"
#include "config_unix.h"
#include "config_win32.h"
#include <inttypes.h>
#include "debug.h"
#include "rtp/rtp.h"
#include "rtp/rtp_callback.h"
#include "rtp/ptime.h"
#include "rtp/pbuf.h"
#include "tv.h"
#include "utils/color_out.h"
#include "utils/macros.h"

Include dependency graph for pbuf.c:

Go to the source code of this file.

Classes
struct	pbuf
struct	pbuf_node

Macros
#define	MOD_NAME   "[Pbuf] "
#define	PBUF_MAGIC   0xcafebabe

Enumerations
enum	{ DEFAULT_STATS_INTERVAL = 128 , STAT_INT_MIN_DIVISOR = sizeof(unsigned long long) * CHAR_BIT , WRAPAROUND_THRESHOLD = 900000 }
enum	{ NUMBER_WORD_BYTES = sizeof(unsigned long long) , NUMBER_WORD_BITS = NUMBER_WORD_BYTES * CHAR_BIT }

Functions
static void	add_coded_unit (struct pbuf_node *node, rtp_packet *pkt)
static void	compute_longest_gap (int *longest_gap, int *accumulated_loss, unsigned long long int packets)
static struct pbuf_node *	create_new_pnode (rtp_packet *pkt, long long playout_delay_us)
static int	frame_complete (struct pbuf_node *frame)
static void	free_cdata (struct coded_data *head)
static int	get_consecutive_zeros (unsigned long long int packets) __attribute__((const))
int	pbuf_decode (struct pbuf *playout_buf, time_ns_t curr_time, decode_frame_t decode_func, void *data)
void	pbuf_destroy (struct pbuf *playout_buf)
struct pbuf *	pbuf_init (volatile int *delay_ms)
void	pbuf_insert (struct pbuf *playout_buf, rtp_packet *pkt)
int	pbuf_is_empty (struct pbuf *playout_buf)
static void	pbuf_process_stats (struct pbuf *playout_buf, rtp_packet *pkt)
void	pbuf_remove (struct pbuf *playout_buf, time_ns_t curr_time)
void	pbuf_set_playout_delay (struct pbuf *playout_buf, double playout_delay)
static void	pbuf_validate (struct pbuf *playout_buf)

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[Pbuf] "

Definition at line 80 of file pbuf.c.

Referenced by pbuf_insert(), and pbuf_process_stats().

PBUF_MAGIC

#define PBUF_MAGIC   0xcafebabe

Definition at line 71 of file pbuf.c.

Referenced by create_new_pnode(), and pbuf_validate().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
DEFAULT_STATS_INTERVAL
STAT_INT_MIN_DIVISOR
WRAPAROUND_THRESHOLD

Definition at line 73 of file pbuf.c.

     {
        DEFAULT_STATS_INTERVAL = 128,
        STAT_INT_MIN_DIVISOR   = sizeof(unsigned long long) * CHAR_BIT,
        WRAPAROUND_THRESHOLD   = 900000, // 10 sec with 90 kHz clock
};

anonymous enum

anonymous enum

Enumerator
NUMBER_WORD_BYTES
NUMBER_WORD_BITS

Definition at line 309 of file pbuf.c.

     {
        NUMBER_WORD_BYTES = sizeof(unsigned long long),
        NUMBER_WORD_BITS = NUMBER_WORD_BYTES * CHAR_BIT
};

Function Documentation

add_coded_unit()

static void add_coded_unit ( struct pbuf_node * node, rtp_packet * pkt )

static

Add "pkt" to the frame represented by "node". The "node" has previously been created, and has some coded data already...

New arrivals are filed to the list in descending sequence number order

Definition at line 236 of file pbuf.c.

{
        assert(node->rtp_timestamp == pkt->ts);
        assert(node->cdata != NULL);
 
        struct coded_data *tmp = (struct coded_data *) malloc(sizeof(struct coded_data));
        if (tmp == NULL) {
                /* this is bad, out of memory, drop the packet... */
                free(pkt);
                return;
        }
 
        tmp->seqno = pkt->seq;
        tmp->data = pkt;
        node->mbit |= pkt->m;
        if((int16_t)(tmp->seqno - node->cdata->seqno) > 0){
                tmp->prv = NULL;
                tmp->nxt = node->cdata;
                node->cdata->prv = tmp;
                node->cdata = tmp;
        } else {
                struct coded_data *curr = node->cdata;
                struct coded_data *prv = NULL;
                while (curr != NULL &&  ((int16_t)(tmp->seqno - curr->seqno) < 0)){
                        prv = curr;
                        curr = curr->nxt;
                }
                if (curr == NULL) {
                        tmp->nxt = NULL;
                        tmp->prv = prv;
                        prv->nxt = tmp;
                }else if ((int16_t)(tmp->seqno - curr->seqno) > 0){
                        tmp->nxt = curr;
                        tmp->prv = curr->prv;
                        tmp->prv->nxt = tmp;
                        curr->prv = tmp;
                } else {
                        /* this is bad, something went terribly wrong... */
                        free(pkt);
                        free(tmp);
                }
        }
}

References pbuf_node::cdata, coded_data::data, pbuf_node::mbit, coded_data::nxt, coded_data::prv, pbuf_node::rtp_timestamp, and coded_data::seqno.

Referenced by pbuf_insert().

compute_longest_gap()

static void compute_longest_gap ( int * longest_gap, int * accumulated_loss, unsigned long long int packets )

static

Definition at line 332 of file pbuf.c.

{
        *longest_gap = MAX(*longest_gap, get_consecutive_zeros(packets));
        // trailing_zeros counts pkts missing on the beginning of pkt group, leading the opposite
        int leading_zeros = packets == 0 ? NUMBER_WORD_BITS : __builtin_clzll(packets);
        int trailing_zeros = packets == 0 ? NUMBER_WORD_BITS : __builtin_ctzll(packets);
        *accumulated_loss += trailing_zeros;
        *longest_gap = MAX(*longest_gap, *accumulated_loss);
        if (leading_zeros < NUMBER_WORD_BITS) { // at least one packet present, reset the counter
                *accumulated_loss = leading_zeros;
        }
}

References get_consecutive_zeros(), MAX, and NUMBER_WORD_BITS.

Referenced by pbuf_process_stats().

Here is the call graph for this function:

create_new_pnode()

static struct pbuf_node * create_new_pnode ( rtp_packet * pkt, long long playout_delay_us )

static

Definition at line 280 of file pbuf.c.

{
        struct pbuf_node *tmp = calloc(1, sizeof(struct pbuf_node));
        if (tmp != NULL) {
                tmp->magic = PBUF_MAGIC;
                tmp->rtp_timestamp = pkt->ts;
                tmp->mbit = pkt->m;
                tmp->playout_time =
                        tmp->arrival_time = get_time_in_ns();
                tmp->playout_time += playout_delay_us * 1000;
                tmp->deletion_time = tmp->playout_time + playout_delay_us * 1000;
 
                tmp->cdata = (struct coded_data *) malloc(sizeof(struct coded_data));
                if (tmp->cdata != NULL) {
                        tmp->cdata->nxt = NULL;
                        tmp->cdata->prv = NULL;
                        tmp->cdata->seqno = pkt->seq;
                        tmp->cdata->data = pkt;
                } else {
                        free(pkt);
                        free(tmp);
                        return NULL;
                }
        } else {
                free(pkt);
        }
        return tmp;
}

References pbuf_node::arrival_time, pbuf_node::cdata, coded_data::data, pbuf_node::deletion_time, get_time_in_ns(), pbuf_node::magic, pbuf_node::mbit, coded_data::nxt, PBUF_MAGIC, pbuf_node::playout_time, coded_data::prv, pbuf_node::rtp_timestamp, and coded_data::seqno.

Referenced by pbuf_insert().

Here is the call graph for this function:

frame_complete()

static int frame_complete ( struct pbuf_node * frame )

static

Definition at line 540 of file pbuf.c.

{
        /* Return non-zero if the list of coded_data represents a    */
        /* complete frame of video. This might have to be passed the */
        /* seqnum of the last packet in the previous frame, too?     */
        /* i dont think that would reflect correctly of weather this */
        /* frame is complete or not - however we should check for all */
        /* the packtes of a frame being present - perhaps we should  */
        /* keep a bit vector in pbuf_node? LG.  */
 
        return (frame->mbit == 1 || frame->completed == true);
}

References frame.

Referenced by pbuf_decode(), and pbuf_remove().

free_cdata()

static void free_cdata ( struct coded_data * head )

static

Definition at line 486 of file pbuf.c.

{
        struct coded_data *tmp;
 
        while (head != NULL) {
                free(head->data);
                tmp = head;
                head = head->nxt;
                free(tmp);
        }
}

References coded_data::data, and coded_data::nxt.

Referenced by pbuf_destroy(), and pbuf_remove().

get_consecutive_zeros()

static int get_consecutive_zeros ( unsigned long long int packets ) const

static

Definition at line 315 of file pbuf.c.

{
        if (packets == 0) {
                return NUMBER_WORD_BITS;
        }
        if (packets == ULLONG_MAX) {
                return 0;
        }
 
        int longest_gap = __builtin_clzll(packets);
        while (packets != 0) {
                longest_gap = MAX(longest_gap, __builtin_ctzll(packets));
                packets >>= 1;
        }
        return longest_gap;
}

References MAX, and NUMBER_WORD_BITS.

Referenced by compute_longest_gap().

pbuf_decode()

int pbuf_decode	(	struct pbuf *	playout_buf,
		time_ns_t	curr_time,
		decode_frame_t	decode_func,
		void *	data )

Definition at line 562 of file pbuf.c.

{
        /* Find the first complete frame that has reached it's playout */
        /* time, and decode it into the framebuffer. Mark the frame as */
        /* decoded, but otherwise leave it in the playout buffer.      */
        struct pbuf_node *curr;
 
        pbuf_validate(playout_buf);
 
        curr = playout_buf->frst;
        while (curr != NULL) {
                if (!curr->decoded 
                                && curr_time > curr->playout_time
                   ) {
                        if (frame_complete(curr)) {
                                struct pbuf_stats stats = { playout_buf->received_pkts_cum,
                                        playout_buf->expected_pkts_cum };
                                int ret = decode_func(curr->cdata, data, &stats);
                                curr->decoded = 1;
                                return ret;
                        } else {
                                if (curr_time > curr->playout_time + 1 * NS_IN_SEC) {
                                        curr->completed = true;
                                }
                                debug_msg
                                    ("Unable to decode frame due to missing data (RTP TS=%u)\n",
                                     curr->rtp_timestamp);
                        }
                }
                curr = curr->nxt;
        }
        return 0;
}

References pbuf_node::cdata, pbuf_node::completed, debug_msg, pbuf_node::decoded, pbuf::expected_pkts_cum, frame_complete(), pbuf::frst, NS_IN_SEC, pbuf_node::nxt, pbuf_validate(), pbuf_node::playout_time, pbuf::received_pkts_cum, and pbuf_node::rtp_timestamp.

Referenced by audio_receiver_thread(), ultragrid_rtp_video_rxtx::receiver_loop(), and vidcap_rtsp_thread().

Here is the call graph for this function:

pbuf_destroy()

void pbuf_destroy

(

struct pbuf *

playout_buf

)

Definition at line 195 of file pbuf.c.

                                            {
        if (playout_buf) {
                pbuf_validate(playout_buf);
 
                if (playout_buf->received_pkts_cum) { // print only if relevant
                        log_msg(LOG_LEVEL_INFO, "Pbuf: total %lld/%lld packets received "
                                        "(%.5lf%%).\n",
                                        playout_buf->received_pkts_cum,
                                        playout_buf->expected_pkts_cum,
                                        (double) playout_buf->received_pkts_cum /
                                        playout_buf->expected_pkts_cum * 100.0);
                }
 
                struct pbuf_node *curr = playout_buf->frst;
                while (curr != NULL) {
                        struct pbuf_node *temp = curr->nxt;
                        if (curr == playout_buf->frst) {
                                playout_buf->frst = curr->nxt;
                        }
                        if (curr == playout_buf->last) {
                                playout_buf->last = curr->prv;
                        }
                        if (curr->nxt != NULL) {
                                curr->nxt->prv = curr->prv;
                        }
                        if (curr->prv != NULL) {
                                curr->prv->nxt = curr->nxt;
                        }
                        free_cdata(curr->cdata);
                        free(curr);
                        curr = temp;
                }
                free(playout_buf);
        }
}

References pbuf_node::cdata, pbuf::expected_pkts_cum, free_cdata(), pbuf::frst, pbuf::last, LOG_LEVEL_INFO, log_msg(), pbuf_node::nxt, pbuf_validate(), pbuf_node::prv, and pbuf::received_pkts_cum.

Referenced by pdb_destroy_item().

Here is the call graph for this function:

pbuf_init()

struct pbuf * pbuf_init

(

volatile int *

delay_ms

)

Definition at line 174 of file pbuf.c.

{
        struct pbuf *playout_buf = NULL;
 
        playout_buf = (struct pbuf *) calloc(1, sizeof(struct pbuf));
        if (playout_buf != NULL) {
                playout_buf->frst = NULL;
                playout_buf->last = NULL;
                /* Playout delay... should really be adaptive, based on the */
                /* jitter, but we use a (conservative) fixed 32ms delay for */
                /* now (2 video frames at 60fps).                           */
                playout_buf->offset_ms = delay_ms;
                playout_buf->playout_delay_us = 0.032 * 1000 * 1000;
                playout_buf->last_report_seq = -1;
                playout_buf->stats_interval = DEFAULT_STATS_INTERVAL;
        } else {
                debug_msg("Failed to allocate memory for playout buffer\n");
        }
        return playout_buf;
}

References debug_msg, DEFAULT_STATS_INTERVAL, pbuf::frst, pbuf::last, pbuf::last_report_seq, pbuf::offset_ms, pbuf::playout_delay_us, and pbuf::stats_interval.

Referenced by pdb_create_item().

pbuf_insert()

void pbuf_insert	(	struct pbuf *	playout_buf,
		rtp_packet *	pkt )

Definition at line 420 of file pbuf.c.

{
        struct pbuf_node *tmp;
 
        pbuf_validate(playout_buf);
        pbuf_process_stats(playout_buf, pkt);
 
        if (playout_buf->frst == NULL && playout_buf->last == NULL) {
                /* playout buffer is empty - add new frame */
                playout_buf->frst = create_new_pnode(pkt, playout_buf->playout_delay_us + 1000 * (playout_buf->offset_ms ? *playout_buf->offset_ms : 0));
                playout_buf->last = playout_buf->frst;
                return;
        }
 
        if (playout_buf->last->rtp_timestamp == pkt->ts) {
                if (playout_buf->last->decoded) {
                        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Late data for already decoded frame!\n");
                }
                /* Packet belongs to last frame in playout_buf this is the */
                /* most likely scenario - although...                      */
                add_coded_unit(playout_buf->last, pkt);
        } else {
                if (playout_buf->last->rtp_timestamp < pkt->ts ||
                    playout_buf->last->rtp_timestamp - pkt->ts >
                        UINT32_MAX - WRAPAROUND_THRESHOLD) {
                        /* Packet belongs to a new frame... */
                        tmp = create_new_pnode(pkt, playout_buf->playout_delay_us + 1000 * (playout_buf->offset_ms ? *playout_buf->offset_ms : 0));
                        playout_buf->last->nxt = tmp;
                        playout_buf->last->completed = true;
                        tmp->prv = playout_buf->last;
                        playout_buf->last = tmp;
                } else {
                        bool discard_pkt = false;
                        /* Packet belongs to a previous frame... */
                        if (playout_buf->frst->rtp_timestamp > pkt->ts ||
                            pkt->ts - playout_buf->frst->rtp_timestamp >
                                UINT32_MAX - WRAPAROUND_THRESHOLD) {
                                debug_msg("A very old packet - discarded\n");
                                discard_pkt = true;
                        } else {
                                debug_msg
                                    ("A packet for a previous frame, but might still be useful\n");
                                struct pbuf_node *curr = playout_buf->last;
                                while(curr != playout_buf->frst && curr->rtp_timestamp > pkt->ts){
                                        curr = curr->prv;
                                }
                                if (curr->rtp_timestamp == pkt->ts) {
                                        /* Packet belongs to a previous existing frame... */
                                        add_coded_unit(curr, pkt);
                                } else {
                                        /* Packet belongs to a frame that is not present */
                                        discard_pkt = true;
                                }
                        }
                        if (discard_pkt) {
                                if (pkt->m) {
                                        debug_msg
                                                ("Oops... dropped packet with M bit set\n");
                                }
                                free(pkt);
                        }
                }
        }
        pbuf_validate(playout_buf);
}

References add_coded_unit(), pbuf_node::completed, create_new_pnode(), debug_msg, pbuf_node::decoded, pbuf::frst, pbuf::last, LOG_LEVEL_VERBOSE, log_msg(), MOD_NAME, pbuf_node::nxt, pbuf::offset_ms, pbuf_process_stats(), pbuf_validate(), pbuf::playout_delay_us, pbuf_node::prv, pbuf_node::rtp_timestamp, and WRAPAROUND_THRESHOLD.

Referenced by rtp_recv_callback().

Here is the call graph for this function:

pbuf_is_empty()

int pbuf_is_empty

(

struct pbuf *

playout_buf

)

Definition at line 553 of file pbuf.c.

{
        if (playout_buf->frst == NULL)
                return TRUE;
        else
                return FALSE;
}

References FALSE, pbuf::frst, and TRUE.

Referenced by audio_receiver_thread(), and ultragrid_rtp_video_rxtx::receiver_loop().

pbuf_process_stats()

static void pbuf_process_stats ( struct pbuf * playout_buf, rtp_packet * pkt )

inlinestatic

Definition at line 345 of file pbuf.c.

{
        // collect statistics
        if (playout_buf->last_report_seq == -1) { // init
                playout_buf->last_seq = pkt->seq - 1;
                playout_buf->last_report_seq = pkt->seq / playout_buf->stats_interval * playout_buf->stats_interval;
                for (uint16_t i = playout_buf->last_report_seq; i != pkt->seq; ++i) {
                        unsigned long long current_bit = 1ull << (i % NUMBER_WORD_BITS);
                        playout_buf->packets[i / NUMBER_WORD_BITS] |= current_bit;
                }
        }
        unsigned long long current_bit = 1ull << (pkt->seq % NUMBER_WORD_BITS);
        if ((playout_buf->packets[pkt->seq / NUMBER_WORD_BITS] & ~current_bit) > current_bit) {
                playout_buf->out_of_order_pkts += 1;
                int dist = ((pkt->seq + (1<<16U)) - playout_buf->last_seq) % (1<<16U);
                dist = dist < 1<<15U ? dist : abs(dist - (1<<16U));
                playout_buf->max_out_of_order_dist = MAX(playout_buf->max_out_of_order_dist, dist);
        }
        playout_buf->last_seq = pkt->seq;
        if (playout_buf->packets[pkt->seq / NUMBER_WORD_BITS] & current_bit) {
                playout_buf->dups += 1;
        }
        playout_buf->packets[pkt->seq / NUMBER_WORD_BITS] |= current_bit;
        uint16_t dist = (uint16_t) (pkt->seq - playout_buf->last_report_seq);
        if (dist >= playout_buf->stats_interval * 2 && dist < 1U<<15U) {
                uint16_t report_seq_until = (uint16_t) ((pkt->seq / playout_buf->stats_interval * playout_buf->stats_interval) - playout_buf->stats_interval); // sum up only up to current-playout_buf->stats_interval to be able to catch out-of-order packets
                int accumulated_loss = 0;
                for (uint16_t i = playout_buf->last_report_seq;
                                i != report_seq_until; i += NUMBER_WORD_BITS) {
                        playout_buf->expected_pkts += NUMBER_WORD_BITS;
                        playout_buf->received_pkts += __builtin_popcountll(playout_buf->packets[i / NUMBER_WORD_BITS]);
                        compute_longest_gap(&playout_buf->longest_gap, &accumulated_loss,  playout_buf->packets[i / NUMBER_WORD_BITS]);
                        playout_buf->packets[i / NUMBER_WORD_BITS] = 0;
                }
 
                playout_buf->received_pkts_cum += playout_buf->received_pkts;
                playout_buf->expected_pkts_cum += playout_buf->expected_pkts;
 
                playout_buf->last_report_seq = report_seq_until;
        }
 
        // print statistics after 5 seconds
        if ((pkt->ts - playout_buf->last_display_ts) > 90000 * 5 &&
                        playout_buf->expected_pkts > 0) {
                // print stats
                double loss_pct = (double) playout_buf->received_pkts /
                        playout_buf->expected_pkts * 100.0;
                char oo_dups_str[1024];
                oo_dups_str[0] = '\0';
                if (playout_buf->out_of_order_pkts > 0) {
                        snprintf(oo_dups_str, sizeof oo_dups_str, ", reordered %d pkts (max dist %d)", playout_buf->out_of_order_pkts, playout_buf->max_out_of_order_dist);
                }
                if (playout_buf->dups > 0) {
                        snprintf(oo_dups_str + strlen(oo_dups_str), sizeof oo_dups_str - strlen(oo_dups_str), ", %d dups", playout_buf->dups);
                }
                log_msg(LOG_LEVEL_INFO, "SSRC 0x%08" PRIx32 ": %d/%d packets received (%s%.4f%%" TERM_FG_RESET "), %d lost, max loss %d%s\n",
                                pkt->ssrc, playout_buf->received_pkts, playout_buf->expected_pkts, (loss_pct < 100.0 ? TERM_FG_RED : ""), loss_pct,
                                playout_buf->expected_pkts - playout_buf->received_pkts, playout_buf->longest_gap, oo_dups_str);
 
                if (playout_buf->max_out_of_order_dist >= playout_buf->stats_interval) {
                        size_t new_val = (playout_buf->max_out_of_order_dist + STAT_INT_MIN_DIVISOR - 1) / STAT_INT_MIN_DIVISOR * STAT_INT_MIN_DIVISOR;
                        if (new_val < 1U<<14U) {
                                playout_buf->stats_interval = new_val;
                                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Adjusting stats interval to %zu\n", new_val);
                        }
                }
                playout_buf->expected_pkts = playout_buf->received_pkts = 0;
                playout_buf->last_display_ts = pkt->ts;
                playout_buf->longest_gap = 0;
                playout_buf->out_of_order_pkts = 0;
                playout_buf->max_out_of_order_dist = 0;
                playout_buf->dups = 0;
        }
}

References abs(), compute_longest_gap(), pbuf::dups, pbuf::expected_pkts, pbuf::expected_pkts_cum, pbuf::last_display_ts, pbuf::last_report_seq, pbuf::last_seq, LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, log_msg(), pbuf::longest_gap, MAX, pbuf::max_out_of_order_dist, MOD_NAME, NUMBER_WORD_BITS, pbuf::out_of_order_pkts, pbuf::packets, pbuf::received_pkts, pbuf::received_pkts_cum, STAT_INT_MIN_DIVISOR, pbuf::stats_interval, TERM_FG_RED, and TERM_FG_RESET.

Referenced by pbuf_insert().

Here is the call graph for this function:

pbuf_remove()

void pbuf_remove	(	struct pbuf *	playout_buf,
		time_ns_t	curr_time )

Definition at line 498 of file pbuf.c.

{
        /* Remove previously decoded frames that have passed their playout  */
        /* time from the playout buffer. Incomplete frames that have passed */
        /* their playout time are also discarded.                           */
 
        struct pbuf_node *curr, *temp;
 
        pbuf_validate(playout_buf);
 
        curr = playout_buf->frst;
        while (curr != NULL) {
                temp = curr->nxt;
                if (curr_time > curr->deletion_time && frame_complete(curr)) {
                        if (curr == playout_buf->frst) {
                                playout_buf->frst = curr->nxt;
                        }
                        if (curr == playout_buf->last) {
                                playout_buf->last = curr->prv;
                        }
                        if (curr->nxt != NULL) {
                                curr->nxt->prv = curr->prv;
                        }
                        if (curr->prv != NULL) {
                                curr->prv->nxt = curr->nxt;
                        }
                        free_cdata(curr->cdata);
                        free(curr);
                } else {
                        /* The playout buffer is stored in order, so once  */
                        /* we see one packet that has not yet reached it's */
                        /* playout time, we can be sure none of the others */
                        /* will have done so...                            */
                        break;
                }
                curr = temp;
        }
 
        pbuf_validate(playout_buf);
        return;
}

References pbuf_node::cdata, pbuf_node::deletion_time, frame_complete(), free_cdata(), pbuf::frst, pbuf::last, pbuf_node::nxt, pbuf_validate(), and pbuf_node::prv.

Referenced by audio_receiver_thread(), ultragrid_rtp_video_rxtx::receiver_loop(), and vidcap_rtsp_thread().

Here is the call graph for this function:

pbuf_set_playout_delay()

void pbuf_set_playout_delay	(	struct pbuf *	playout_buf,
		double	playout_delay )

Definition at line 597 of file pbuf.c.

{
        playout_buf->playout_delay_us = playout_delay * 1000 * 1000;
}

References pbuf::playout_delay_us.

Referenced by audio_receiver_thread(), and ultragrid_rtp_video_rxtx::receiver_process_messages().

pbuf_validate()

static void pbuf_validate ( struct pbuf * playout_buf )

static

Definition at line 121 of file pbuf.c.

{
        /* Run through the entire playout buffer, checking pointers, etc.  */
        /* Only used in debugging mode, since it's a lot of overhead [csp] */
#ifdef NDEF
        struct pbuf_node *cpb, *ppb;
        struct coded_data *ccd, *pcd;
 
        cpb = playout_buf->frst;
        ppb = NULL;
        while (cpb != NULL) {
                assert(cpb->magic == PBUF_MAGIC);
                assert(cpb->prv == ppb);
                if (cpb->prv != NULL) {
                        assert(cpb->prv->nxt == cpb);
                        /* stored in RTP timestamp order */
                        assert(cpb->rtp_timestamp > ppb->rtp_timestamp);
                        /* stored in playout time order  */
                        /* TODO: eventually check why is this assert always failng */
                        // assert(tv_gt(cpb->ptime, ppb->ptime));  
                }
                if (cpb->nxt != NULL) {
                        assert(cpb->nxt->prv == cpb);
                } else {
                        assert(cpb = playout_buf->last);
                }
                if (cpb->cdata != NULL) {
                        /* We have coded data... check all the pointers on that list too */
                        ccd = cpb->cdata;
                        pcd = NULL;
                        while (ccd != NULL) {
                                assert(ccd->prv == pcd);
                                if (ccd->prv != NULL) {
                                        assert(ccd->prv->nxt == ccd);
                                        /* list is descending - cant really check this now */
                                        //assert(ccd->seqno < pcd->seqno); 
                                        assert(ccd->data != NULL);
                                }
                                if (ccd->nxt != NULL) {
                                        assert(ccd->nxt->prv == ccd);
                                }
                                pcd = ccd;
                                ccd = ccd->nxt;
                        }
                }
                ppb = cpb;
                cpb = cpb->nxt;
        }
#else
        UNUSED(playout_buf);
#endif
}

References pbuf_node::cdata, coded_data::data, pbuf::frst, pbuf::last, pbuf_node::magic, coded_data::nxt, pbuf_node::nxt, PBUF_MAGIC, coded_data::prv, pbuf_node::prv, pbuf_node::rtp_timestamp, and UNUSED.

Referenced by pbuf_decode(), pbuf_destroy(), pbuf_insert(), and pbuf_remove().