pbuf.h File Reference

#include "audio/types.h"
#include "rtp/rtp.h"
#include "tv.h"

Include dependency graph for pbuf.h:

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

Go to the source code of this file.

Classes
struct	coded_data
struct	pbuf_audio_data
struct	pbuf_stats
struct	vcodec_state

Typedefs
typedef int	decode_frame_t(struct coded_data *cdata, void *decode_data, struct pbuf_stats *stats)

Functions
int	pbuf_decode (struct pbuf *playout_buf, time_ns_t curr_time, decode_frame_t decode_func, void *data)
void	pbuf_destroy (struct pbuf *)
struct pbuf *	pbuf_init (volatile int *delay_ms)
void	pbuf_insert (struct pbuf *playout_buf, rtp_packet *r)
int	pbuf_is_empty (struct pbuf *playout_buf)
void	pbuf_remove (struct pbuf *playout_buf, time_ns_t curr_time)
void	pbuf_set_playout_delay (struct pbuf *playout_buf, double playout_delay)

Typedef Documentation

decode_frame_t

typedef int decode_frame_t(struct coded_data *cdata, void *decode_data, struct pbuf_stats *stats)

Parameters

decode_data

Definition at line 110 of file pbuf.h.

Function Documentation

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 *	r )

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_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().