rtcp.h

Go to the documentation of this file.

#ifndef JANUS_RTCP_H
#define JANUS_RTCP_H

#include <arpa/inet.h>
#ifdef __MACH__
#include <machine/endian.h>
#else
#include <endian.h>
#endif
#include <inttypes.h>
#include <string.h>

typedef enum {
    RTCP_FIR = 192,
    RTCP_SR = 200,
    RTCP_RR = 201,
    RTCP_SDES = 202,
    RTCP_BYE = 203,
    RTCP_APP = 204,
    RTCP_RTPFB = 205,
    RTCP_PSFB = 206,
    RTCP_XR = 207,
} rtcp_type;
typedef rtcp_type janus_rtcp_type;


typedef struct rtcp_header
{
#if __BYTE_ORDER == __BIG_ENDIAN
        uint16_t version:2;
        uint16_t padding:1;
        uint16_t rc:5;
        uint16_t type:8;
#elif __BYTE_ORDER == __LITTLE_ENDIAN
        uint16_t rc:5;
        uint16_t padding:1;
        uint16_t version:2;
        uint16_t type:8;
#endif
        uint16_t length:16;
} rtcp_header;
typedef rtcp_header janus_rtcp_header;

typedef struct sender_info
{
        uint32_t ntp_ts_msw;
        uint32_t ntp_ts_lsw;
        uint32_t rtp_ts;
        uint32_t s_packets;
        uint32_t s_octets;
} sender_info;
typedef sender_info janus_sender_info;

typedef struct report_block
{
        uint32_t ssrc;
        uint32_t flcnpl;
        uint32_t ehsnr;
        uint32_t jitter;
        uint32_t lsr;
        uint32_t delay;
} report_block;
typedef report_block janus_report_block;

typedef struct rtcp_sr
{
        rtcp_header header;
        uint32_t ssrc;
        sender_info si;
        report_block rb[1];
} rtcp_sr;
typedef rtcp_sr janus_rtcp_sr;

typedef struct rtcp_rr
{
        rtcp_header header;
        uint32_t ssrc;
        report_block rb[1];
} rtcp_rr;
typedef rtcp_rr janus_rtcp_rr;

typedef struct rtcp_sdes_chunk
{
        uint32_t ssrc;
} rtcp_sdes_chunk;
typedef rtcp_sdes_chunk janus_rtcp_sdes_chunk;

typedef struct rtcp_sdes_item
{
        uint8_t type;
        uint8_t len;
        char content[1];
} rtcp_sdes_item;
typedef rtcp_sdes_item janus_rtcp_sdes_item;

typedef struct rtcp_sdes
{
        rtcp_header header;
        rtcp_sdes_chunk chunk;
        rtcp_sdes_item item;
} rtcp_sdes;
typedef rtcp_sdes janus_rtcp_sdes;

typedef struct rtcp_bye
{
        rtcp_header header;
        uint32_t ssrc[1];
} rtcp_bye;
typedef rtcp_bye janus_rtcp_bye;

typedef struct rtcp_app
{
        rtcp_header header;
        uint32_t ssrc;
        char name[4];
} rtcp_app;
typedef rtcp_app janus_rtcp_app;

typedef struct rtcp_nack
{
        uint16_t pid;
        uint16_t blp;
} rtcp_nack;
typedef rtcp_nack janus_rtcp_nack;

typedef struct janus_nack {
        uint16_t seq_no;
        struct janus_nack *next;
} janus_nack;


typedef struct rtcp_remb
{
        char id[4];
        uint32_t bitrate;
        uint32_t ssrc[3];
} rtcp_remb;
typedef rtcp_remb janus_rtcp_fb_remb;


typedef struct rtcp_fir
{
        uint32_t ssrc;
        uint32_t seqnr;
} rtcp_fir;
typedef rtcp_fir janus_rtcp_fb_fir;


typedef struct rtcp_fb
{
        rtcp_header header;
        uint32_t ssrc;
        uint32_t media;
        char fci[1];
} rtcp_fb;
typedef rtcp_fb janus_rtcp_fb;

typedef struct extended_report_block
{
        uint8_t blocktype;
        uint8_t typesp;
        uint16_t length;
        char content[1];

} extended_report_block;
typedef extended_report_block janus_extended_report_block;

typedef struct rtcp_xr
{
        rtcp_header header;
        uint32_t ssrc;
        extended_report_block erb[1];
} rtcp_xr;
typedef rtcp_xr janus_rtcp_xr;


typedef struct rtcp_context
{
        /* Whether we received any RTP packet at all (don't send RR otherwise) */
        uint8_t rtp_recvd:1;
        uint32_t rtp_last_inorder_ts;
        int64_t rtp_last_inorder_time;

        uint16_t max_seq_nr;
        uint16_t seq_cycle;
        uint16_t base_seq;
        /* Payload type */
        uint16_t pt;

        /* RFC 3550 A.8 Interarrival Jitter */
        int64_t transit;
        double jitter, jitter_remote;
        /* Timestamp base (e.g., 48000 for opus audio, or 90000 for video) */
        uint32_t tb;

        /* Last SR received */
        uint32_t lsr;
        /* Monotonic time of last SR received */
        int64_t lsr_ts;

        /* Last RR/SR we sent */
        int64_t last_sent;

        /* Estimated round-trip time */
        uint32_t rtt;

        /* RFC 3550 A.3 */
        uint32_t received;
        uint32_t received_prior;
        uint32_t expected;
        uint32_t expected_prior;
        uint32_t lost, lost_remote;

        uint32_t retransmitted;
        uint32_t retransmitted_prior;

        /* Inbound RR process */
        int64_t rr_last_ts;
        uint32_t rr_last_ehsnr;
        uint32_t rr_last_lost;
        uint32_t rr_last_nack_count;
        gint sent_packets_since_last_rr;
        gint nack_count;

        /* Link quality estimations */
        double in_link_quality;
        double in_media_link_quality;
        double out_link_quality;
        double out_media_link_quality;

        /* TODO Incoming transport-wide CC feedback*/

} rtcp_context;
typedef rtcp_context janus_rtcp_context;

typedef struct rtcp_transport_wide_cc_stats
{
        guint32 transport_seq_num;
        guint64 timestamp;
} rtcp_transport_wide_cc_stats;
typedef rtcp_transport_wide_cc_stats janus_rtcp_transport_wide_cc_stats;

uint32_t janus_rtcp_context_get_rtt(janus_rtcp_context *ctx);
uint32_t janus_rtcp_context_get_lost_all(janus_rtcp_context *ctx, gboolean remote);
uint32_t janus_rtcp_context_get_jitter(janus_rtcp_context *ctx, gboolean remote);
uint32_t janus_rtcp_context_get_in_link_quality(janus_rtcp_context *ctx);
uint32_t janus_rtcp_context_get_in_media_link_quality(janus_rtcp_context *ctx);
uint32_t janus_rtcp_context_get_out_link_quality(janus_rtcp_context *ctx);
uint32_t janus_rtcp_context_get_out_media_link_quality(janus_rtcp_context *ctx);
void janus_rtcp_swap_report_blocks(char *packet, int len, uint32_t rtx_ssrc);
guint32 janus_rtcp_get_sender_ssrc(char *packet, int len);
guint32 janus_rtcp_get_receiver_ssrc(char *packet, int len);

gboolean janus_rtcp_check_len(janus_rtcp_header *rtcp, int len);
gboolean janus_rtcp_check_rr(janus_rtcp_header *rtcp, int len);
gboolean janus_rtcp_check_sr(janus_rtcp_header *rtcp, int len);
gboolean janus_rtcp_check_fci(janus_rtcp_header *rtcp, int len, int sizeof_fci);
gboolean janus_rtcp_check_remb(janus_rtcp_header *rtcp, int len);

gboolean janus_is_rtcp(char *buf, guint len);

int janus_rtcp_parse(janus_rtcp_context *ctx, char *packet, int len);

int janus_rtcp_fix_report_data(char *packet, int len, uint32_t base_ts, uint32_t base_ts_prev, uint32_t ssrc_peer, uint32_t ssrc_local, uint32_t ssrc_expected, gboolean video);

int janus_rtcp_fix_ssrc(janus_rtcp_context *ctx, char *packet, int len, int fixssrc, uint32_t newssrcl, uint32_t newssrcr);

char *janus_rtcp_filter(char *packet, int len, int *newlen);

int janus_rtcp_process_incoming_rtp(janus_rtcp_context *ctx, char *packet, int len,
        gboolean rfc4588_pkt, gboolean rfc4588_enabled, gboolean retransmissions_disabled,
        GHashTable *clock_rates);

int janus_rtcp_report_block(janus_rtcp_context *ctx, janus_report_block *rb);

gboolean janus_rtcp_parse_lost_info(char *packet, int len, uint32_t *lost, int *fraction);

gboolean janus_rtcp_has_bye(char *packet, int len);

gboolean janus_rtcp_has_fir(char *packet, int len);

gboolean janus_rtcp_has_pli(char *packet, int len);

GSList *janus_rtcp_get_nacks(char *packet, int len);

int janus_rtcp_remove_nacks(char *packet, int len);

uint32_t janus_rtcp_get_remb(char *packet, int len);

int janus_rtcp_cap_remb(char *packet, int len, uint32_t bitrate);

int janus_rtcp_sdes_cname(char *packet, int len, const char *cname, int cnamelen);

int janus_rtcp_remb(char *packet, int len, uint32_t bitrate);

int janus_rtcp_remb_ssrcs(char *packet, int len, uint32_t bitrate, uint8_t numssrc);

int janus_rtcp_fir(char *packet, int len, int *seqnr);

int janus_rtcp_fir_legacy(char *packet, int len, int *seqnr);

int janus_rtcp_pli(char *packet, int len);

int janus_rtcp_nacks(char *packet, int len, GSList *nacks);

int janus_rtcp_transport_wide_cc_feedback(char *packet, size_t len, guint32 ssrc, guint32 media, guint8 feedback_packet_count, GQueue *transport_wide_cc_stats);

#endif