rtp.h

Go to the documentation of this file.

 
#ifndef JANUS_RTP_H
#define JANUS_RTP_H
 
#include <arpa/inet.h>
#if defined (__MACH__) || defined(__FreeBSD__)
#include <machine/endian.h>
#define __BYTE_ORDER BYTE_ORDER
#define __BIG_ENDIAN BIG_ENDIAN
#define __LITTLE_ENDIAN LITTLE_ENDIAN
#else
#include <endian.h>
#endif
#include <inttypes.h>
#include <string.h>
#include <glib.h>
#include <jansson.h>
 
#include "plugins/plugin.h"
#include "utils.h"
 
#define RTP_HEADER_SIZE 12
 
typedef struct rtp_header
{
#if __BYTE_ORDER == __BIG_ENDIAN
        uint16_t version:2;
        uint16_t padding:1;
        uint16_t extension:1;
        uint16_t csrccount:4;
        uint16_t markerbit:1;
        uint16_t type:7;
#elif __BYTE_ORDER == __LITTLE_ENDIAN
        uint16_t csrccount:4;
        uint16_t extension:1;
        uint16_t padding:1;
        uint16_t version:2;
        uint16_t type:7;
        uint16_t markerbit:1;
#endif
        uint16_t seq_number;
        uint32_t timestamp;
        uint32_t ssrc;
        uint32_t csrc[0];
} rtp_header;
typedef rtp_header janus_rtp_header;
 
typedef struct janus_rtp_packet {
        char *data;
        gint length;
        gint64 created;
        gint64 last_retransmit;
        gint64 current_backoff;
        janus_plugin_rtp_extensions extensions;
} janus_rtp_packet;
 
typedef struct janus_rtp_header_extension {
        uint16_t type;
        uint16_t length;
} janus_rtp_header_extension;
 
typedef struct janus_rtp_rfc2833_payload {
#if __BYTE_ORDER == __BIG_ENDIAN
        uint8_t event;
        uint8_t end:1;
        uint8_t reserved:1;
        uint8_t volume:6;
        uint16_t duration;
#elif __BYTE_ORDER == __LITTLE_ENDIAN
        uint8_t event;
        uint8_t volume:6;
        uint8_t reserved:1;
        uint8_t end:1;
        uint16_t duration;
#endif
} janus_rtp_rfc2833_payload;
 
#define JANUS_RTP_EXTMAP_AUDIO_LEVEL            "urn:ietf:params:rtp-hdrext:ssrc-audio-level"
#define JANUS_RTP_EXTMAP_TOFFSET                        "urn:ietf:params:rtp-hdrext:toffset"
#define JANUS_RTP_EXTMAP_ABS_SEND_TIME          "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
#define JANUS_RTP_EXTMAP_ABS_CAPTURE_TIME       "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time"
#define JANUS_RTP_EXTMAP_VIDEO_ORIENTATION      "urn:3gpp:video-orientation"
#define JANUS_RTP_EXTMAP_TRANSPORT_WIDE_CC      "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01"
#define JANUS_RTP_EXTMAP_PLAYOUT_DELAY          "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay"
#define JANUS_RTP_EXTMAP_MID                            "urn:ietf:params:rtp-hdrext:sdes:mid"
#define JANUS_RTP_EXTMAP_RID                            "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id"
#define JANUS_RTP_EXTMAP_REPAIRED_RID           "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id"
#define JANUS_RTP_EXTMAP_DEPENDENCY_DESC        "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension"
#define JANUS_RTP_EXTMAP_VIDEO_LAYERS           "http://www.webrtc.org/experiments/rtp-hdrext/video-layers-allocation00"
#define JANUS_RTP_EXTMAP_ENCRYPTED                      "urn:ietf:params:rtp-hdrext:encrypt"
int janus_rtp_extension_id(const char *type);
 
 
typedef enum janus_audiocodec {
        JANUS_AUDIOCODEC_NONE,
        JANUS_AUDIOCODEC_OPUS,
        JANUS_AUDIOCODEC_MULTIOPUS,
        JANUS_AUDIOCODEC_OPUSRED,
        JANUS_AUDIOCODEC_PCMU,
        JANUS_AUDIOCODEC_PCMA,
        JANUS_AUDIOCODEC_G722,
        JANUS_AUDIOCODEC_ISAC_32K,
        JANUS_AUDIOCODEC_ISAC_16K,
        JANUS_AUDIOCODEC_L16_48K,
        JANUS_AUDIOCODEC_L16_16K
} janus_audiocodec;
const char *janus_audiocodec_name(janus_audiocodec acodec);
janus_audiocodec janus_audiocodec_from_name(const char *name);
int janus_audiocodec_pt(janus_audiocodec acodec);
 
typedef enum janus_videocodec {
        JANUS_VIDEOCODEC_NONE,
        JANUS_VIDEOCODEC_VP8,
        JANUS_VIDEOCODEC_VP9,
        JANUS_VIDEOCODEC_H264,
        JANUS_VIDEOCODEC_AV1,
        JANUS_VIDEOCODEC_H265
} janus_videocodec;
const char *janus_videocodec_name(janus_videocodec vcodec);
janus_videocodec janus_videocodec_from_name(const char *name);
int janus_videocodec_pt(janus_videocodec vcodec);
 
 
gboolean janus_is_rtp(char *buf, guint len);
 
char *janus_rtp_payload(char *buf, int len, int *plen);
 
int janus_rtp_header_extension_get_id(const char *sdp, const char *extension);
 
const char *janus_rtp_header_extension_get_from_id(const char *sdp, int id);
 
int janus_rtp_header_extension_parse_audio_level(char *buf, int len, int id, gboolean *vad, int *level);
 
int janus_rtp_header_extension_parse_video_orientation(char *buf, int len, int id,
        gboolean *c, gboolean *f, gboolean *r1, gboolean *r0);
 
int janus_rtp_header_extension_parse_playout_delay(char *buf, int len, int id,
        uint16_t *min_delay, uint16_t *max_delay);
 
int janus_rtp_header_extension_parse_mid(char *buf, int len, int id,
        char *sdes_item, int sdes_len);
 
int janus_rtp_header_extension_parse_rid(char *buf, int len, int id,
        char *sdes_item, int sdes_len);
 
int janus_rtp_header_extension_parse_dependency_desc(char *buf, int len, int id,
        uint8_t *dd_item, int *dd_len);
 
int janus_rtp_header_extension_parse_abs_send_time(char *buf, int len, int id, uint32_t *abs_ts);
 
int janus_rtp_header_extension_set_abs_send_time(char *buf, int len, int id, uint32_t abs_ts);
 
int janus_rtp_header_extension_parse_abs_capture_time(char *buf, int len, int id, uint64_t *abs_ts);
 
int janus_rtp_header_extension_set_abs_capture_time(char *buf, int len, int id, uint64_t abs_ts);
 
int janus_rtp_header_extension_parse_transport_wide_cc(char *buf, int len, int id, uint16_t *transSeqNum);
 
int janus_rtp_header_extension_set_transport_wide_cc(char *buf, int len, int id, uint16_t transSeqNum);
 
int janus_rtp_header_extension_parse_video_layers_allocation(char *buf, int len, int id,
        int8_t *spatial_layers, int8_t *temporal_layers);
 
int janus_rtp_header_extension_replace_id(char *buf, int len, int id, int new_id);
 
typedef struct janus_rtp_switching_context {
        uint32_t last_ssrc, last_ts, base_ts, base_ts_prev, prev_ts, target_ts, start_ts;
        uint16_t last_seq, prev_seq, base_seq, base_seq_prev;
        gboolean ts_reset, seq_reset, new_ssrc;
        gint16 seq_offset;
        gint32 prev_delay, active_delay, ts_offset;
        gint64 last_time, reference_time, start_time, evaluating_start_time;
} janus_rtp_switching_context;
 
void janus_rtp_switching_context_reset(janus_rtp_switching_context *context);
 
void janus_rtp_header_update(janus_rtp_header *header, janus_rtp_switching_context *context, gboolean video, int step);
 
#define RTP_AUDIO_SKEW_TH_MS 120
#define RTP_VIDEO_SKEW_TH_MS 120
#define SKEW_DETECTION_WAIT_TIME_SECS 10
 
int janus_rtp_skew_compensate_audio(janus_rtp_header *header, janus_rtp_switching_context *context, gint64 now);
int janus_rtp_skew_compensate_video(janus_rtp_header *header, janus_rtp_switching_context *context, gint64 now);
 
 
 
typedef struct janus_av1_svc_context {
        uint8_t tcnt;
        uint8_t tioff;
        GHashTable *templates;
        int spatial_layers, temporal_layers;
        gboolean updated;
} janus_av1_svc_context;
 
typedef struct janus_av1_svc_template {
        uint8_t id;
        int spatial;
        int temporal;
} janus_av1_svc_template;
 
void janus_av1_svc_context_reset(janus_av1_svc_context *context);
 
gboolean janus_av1_svc_context_process_dd(janus_av1_svc_context *context,
        uint8_t *dd, int dd_len, uint8_t *template_id, uint8_t *ebit);
 
 
typedef struct janus_rtp_simulcasting_context {
        gint rid_ext_id;
        janus_av1_svc_context av1_context[3];
        int substream;
        int substream_target, substream_target_temp;
        int templayer;
        int templayer_target;
        guint32 drop_trigger;
        gint64 last_relayed;
        gboolean changed_substream;
        gboolean changed_temporal;
        gboolean need_pli;
} janus_rtp_simulcasting_context;
 
void janus_rtp_simulcasting_context_reset(janus_rtp_simulcasting_context *context);
 
void janus_rtp_simulcasting_prepare(json_t *simulcast, int *rid_ext_id, uint32_t *ssrcs, char **rids);
 
void janus_rtp_simulcasting_cleanup(int *rid_ext_id, uint32_t *ssrcs, char **rids, janus_mutex *rid_mutex);
 
gboolean janus_rtp_simulcasting_context_process_rtp(janus_rtp_simulcasting_context *context,
        char *buf, int len, uint8_t *dd_content, int dd_len, uint32_t *ssrcs, char **rids,
        janus_videocodec vcodec, janus_rtp_switching_context *sc, janus_mutex *rid_mutex);
 
 
typedef struct janus_rtp_svc_context {
        struct janus_av1_svc_context dd_context;
        int spatial;
        int spatial_target;
        int temporal;
        int temporal_target;
        guint32 drop_trigger;
        gint64 last_spatial_layer[3];
        gboolean changed_spatial;
        gboolean changed_temporal;
        gboolean need_pli;
} janus_rtp_svc_context;
 
void janus_rtp_svc_context_reset(janus_rtp_svc_context *context);
 
gboolean janus_rtp_svc_context_process_rtp(janus_rtp_svc_context *context,
        char *buf, int len, uint8_t *dd_content, int dd_len,
        janus_videocodec vcodec, janus_vp9_svc_info *info, janus_rtp_switching_context *sc);
 
#endif