rtp.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2026 Basalte bv
 *
 *  SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_NET_RTP_H_
#define ZEPHYR_INCLUDE_NET_RTP_H_
 
#include <zephyr/kernel.h>
#include <zephyr/logging/log_core.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/socket.h>
#ifdef CONFIG_NET_PKT_TIMESTAMP
#include <zephyr/net/ptp_time.h>
#endif
#include <zephyr/net/net_context.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
 
#ifdef __cplusplus
extern "C" {
#endif


#define RTP_VERSION 2

#define RTP_MIN_HEADER_LEN 12

#define RTP_PAYLOAD_TYPE_MAX 127

#define RTP_MARKER 1

#define RTP_HDR_V_MASK  GENMASK(7, 6)
#define RTP_HDR_P_MASK  BIT(5)
#define RTP_HDR_X_MASK  BIT(4)
#define RTP_HDR_CC_MASK GENMASK(3, 0)
#define RTP_HDR_M_MASK  BIT(7)
#define RTP_HDR_PT_MASK GENMASK(6, 0)
 
#if defined(CONFIG_RTP_MAX_CSRC_COUNT) || defined(__DOXYGEN__)
#define RTP_MAX_CSRC_COUNT CONFIG_RTP_MAX_CSRC_COUNT
#else
#define RTP_MAX_CSRC_COUNT 0
#endif

struct rtp_header_extension {
        uint16_t definition;
        uint16_t length;
        uint8_t *data;
};

struct rtp_header {
        uint8_t vpxcc;
        uint8_t mpt;
        uint16_t seq;
        uint32_t ts;
        uint32_t ssrc;
        uint32_t csrc[RTP_MAX_CSRC_COUNT];
        struct rtp_header_extension header_extension;
};

struct rtp_packet {
        struct rtp_header header;
        uint8_t *payload;
        size_t payload_len;
 
#ifdef CONFIG_NET_PKT_TIMESTAMP
        struct net_ptp_time timestamp;
#endif
};
 
struct rtp_session;

typedef void (*rtp_rx_cb_t)(struct rtp_session *session, struct rtp_packet *packet,
                            void *user_data);

enum rtp_role {
        RTP_ROLE_SINK,
        RTP_ROLE_SOURCE,
        RTP_ROLE_BOTH,
};

struct rtp_session_context {
        struct net_if *iface;

        struct net_sockaddr_storage sock_addr;
        enum rtp_role role;

        uint8_t payload_type;

        rtp_rx_cb_t callback;
        void *user_data;
};

enum rtp_transport_type {
#ifdef CONFIG_RTP_TRANSPORT_SOCKET
        RTP_TRANSPORT_SOCKET,
#endif /* CONFIG_RTP_TRANSPORT_SOCKET */
#ifdef CONFIG_RTP_TRANSPORT_NET_PKT
        RTP_TRANSPORT_NET_PKT,
#endif /* CONFIG_RTP_TRANSPORT_NET_PKT */

        RTP_TRANSPORT_NUM,
};
 
BUILD_ASSERT(RTP_TRANSPORT_NUM > 0, "Please select at least 1 RTP transport backend");

struct rtp_transport {
        enum rtp_transport_type type;

        union {
#ifdef CONFIG_RTP_TRANSPORT_SOCKET
                struct {
                        int socket_rx_fd;
                        int socket_tx_fd;
                };
#endif /* CONFIG_RTP_TRANSPORT_SOCKET */
#ifdef CONFIG_RTP_TRANSPORT_NET_PKT
                struct {
                        struct net_conn_handle *net_handle_rtp;
                };
#endif /* CONFIG_RTP_TRANSPORT_NET_PKT */
        };
};

struct rtp_session {
        struct rtp_transport transport;
        struct rtp_session_context rtp_context;

        struct k_mutex lock;

        uint32_t ssrc;
        uint32_t timestamp;
        uint16_t sequence_number;

        uint16_t local_port;

        uint32_t csrc[RTP_MAX_CSRC_COUNT];
        size_t csrc_len;
 
#if CONFIG_RTP_LOG_LEVEL >= LOG_LEVEL_DBG
        const char *name;
#endif
};

#if CONFIG_RTP_LOG_LEVEL >= LOG_LEVEL_DBG
#define RTP_SESSION_NAME(_name) .name = STRINGIFY(_name),
#else
#define RTP_SESSION_NAME(_name)
#endif

#define RTP_SESSION_DEFINE(_name, _local_port)                                                     \
        struct rtp_session _name = {.local_port = _local_port, RTP_SESSION_NAME(_name)}

int rtp_init_header_extension(struct rtp_header_extension *hdr_x, uint16_t definition,
                              uint8_t *data, size_t len);

int rtp_session_init(struct rtp_session *session, struct net_if *iface,
                     struct net_sockaddr *sock_addr, enum rtp_role role, uint8_t payload_type,
                     rtp_rx_cb_t callback, void *user_data, enum rtp_transport_type transport_type);

static inline int rtp_session_init_rx(struct rtp_session *session, struct net_if *iface,
                                      struct net_sockaddr *sock_addr, rtp_rx_cb_t callback,
                                      void *user_data, enum rtp_transport_type transport_type)
{
        return rtp_session_init(session, iface, sock_addr, RTP_ROLE_SINK, 0, callback, user_data,
                                transport_type);
}

static inline int rtp_session_init_tx(struct rtp_session *session, struct net_if *iface,
                                      struct net_sockaddr *sock_addr, uint8_t payload_type,
                                      enum rtp_transport_type transport_type)
{
        return rtp_session_init(session, iface, sock_addr, RTP_ROLE_SOURCE, payload_type, NULL,
                                NULL, transport_type);
}

int rtp_session_start(struct rtp_session *session);

int rtp_session_stop(struct rtp_session *session);

int rtp_session_add_csrc(struct rtp_session *session, uint32_t csrc);

int rtp_session_remove_csrc(struct rtp_session *session, uint32_t csrc);

int rtp_session_send(struct rtp_session *session, void *data, size_t len, uint32_t delta_ts,
                     uint8_t padding, uint8_t marker, struct rtp_header_extension *hdr_x,
                     uint32_t *timestamp);

static inline int rtp_session_send_simple(struct rtp_session *session, void *data, size_t len,
                                          uint32_t delta_ts)
{
        return rtp_session_send(session, data, len, delta_ts, 0, 0, NULL, NULL);
}

static inline uint8_t rtp_header_get_v(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_V_MASK, h->vpxcc);
}

static inline uint8_t rtp_header_get_p(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_P_MASK, h->vpxcc);
}

static inline uint8_t rtp_header_get_x(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_X_MASK, h->vpxcc);
}

static inline uint8_t rtp_header_get_cc(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_CC_MASK, h->vpxcc);
}

static inline uint8_t rtp_header_get_m(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_M_MASK, h->mpt);
}

static inline uint8_t rtp_header_get_pt(const struct rtp_header *h)
{
        __ASSERT_NO_MSG(h != NULL);
 
        return FIELD_GET(RTP_HDR_PT_MASK, h->mpt);
}

static inline void rtp_header_set_v(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->vpxcc &= ~RTP_HDR_V_MASK;
        h->vpxcc |= FIELD_PREP(RTP_HDR_V_MASK, value);
}

static inline void rtp_header_set_p(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->vpxcc &= ~RTP_HDR_P_MASK;
        h->vpxcc |= FIELD_PREP(RTP_HDR_P_MASK, value);
}

static inline void rtp_header_set_x(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->vpxcc &= ~RTP_HDR_X_MASK;
        h->vpxcc |= FIELD_PREP(RTP_HDR_X_MASK, value);
}

static inline void rtp_header_set_cc(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->vpxcc &= ~RTP_HDR_CC_MASK;
        h->vpxcc |= FIELD_PREP(RTP_HDR_CC_MASK, value);
}

static inline void rtp_header_set_m(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->mpt &= ~RTP_HDR_M_MASK;
        h->mpt |= FIELD_PREP(RTP_HDR_M_MASK, value);
}

static inline void rtp_header_set_pt(struct rtp_header *h, uint8_t value)
{
        __ASSERT_NO_MSG(h != NULL);
 
        h->mpt &= ~RTP_HDR_PT_MASK;
        h->mpt |= FIELD_PREP(RTP_HDR_PT_MASK, value);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NET_RTP_H_ */