util.hh

Go to the documentation of this file.

#pragma once
 
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#else
#include <sys/time.h>
#endif
 
#include <algorithm>
#include <cstdint>
#include <cstddef>
#include <cstdio>
#include <cstring>
#include <string>
 
#if defined(_MSC_VER)
typedef SSIZE_T ssize_t;
#endif
 
/* https://stackoverflow.com/questions/1537964/visual-c-equivalent-of-gccs-attribute-packed  */
#if defined(__MINGW32__) || defined(__MINGW64__) || defined(__linux__)
#define PACK(__Declaration__) __Declaration__ __attribute__((__packed__))
#else
#define PACK(__Declaration__) __pragma(pack(push, 1)) __Declaration__ __pragma(pack(pop))
#endif
 
#ifdef _WIN32
    typedef SOCKET socket_t;
#else
    typedef int socket_t;
#endif
 
const int MAX_PACKET       = 65536;
const int MAX_PAYLOAD      = 1446;
const int PKT_MAX_DELAY    = 100;
 
/* TODO: add ability for user to specify these? */
enum HEADER_SIZES {
    ETH_HDR_SIZE  = 14,
    IPV4_HDR_SIZE = 20,
    UDP_HDR_SIZE  =  8,
    RTP_HDR_SIZE  = 12
};
 
typedef enum RTP_ERROR {
    RTP_MULTIPLE_PKTS_READY = 6,
    RTP_PKT_READY           = 5,
    RTP_PKT_MODIFIED        = 4,
    RTP_PKT_NOT_HANDLED     = 3,
    RTP_INTERRUPTED         = 2,
    RTP_NOT_READY           = 1,
    RTP_OK                  = 0,    
    RTP_GENERIC_ERROR       = -1,   
    RTP_SOCKET_ERROR        = -2,   
    RTP_BIND_ERROR          = -3,   
    RTP_INVALID_VALUE       = -4,   
    RTP_SEND_ERROR          = -5,   
    RTP_MEMORY_ERROR        = -6,   
    RTP_SSRC_COLLISION      = -7,   
    RTP_INITIALIZED         = -8,   
    RTP_NOT_INITIALIZED     = -9,   
    RTP_NOT_SUPPORTED       = -10,  
    RTP_RECV_ERROR          = -11,  
    RTP_TIMEOUT             = -12,  
    RTP_NOT_FOUND           = -13,  
    RTP_AUTH_TAG_MISMATCH   = -14,  
} rtp_error_t;
 
typedef enum RTP_FORMAT {
    RTP_FORMAT_GENERIC = 0,   
    RTP_FORMAT_H264    = 95,  
    RTP_FORMAT_H265    = 96,  
    RTP_FORMAT_H266    = 97,  
    RTP_FORMAT_OPUS    = 98,  
} rtp_format_t;
 
typedef enum RTP_FLAGS {
    RTP_NO_FLAGS = 0 << 0,
 
    RTP_SLICE    = 1 << 0,
 
    RTP_COPY     = 1 << 1
 
} rtp_flags_t;
 
enum RTP_CTX_ENABLE_FLAGS {
    RCE_NO_FLAGS                  = 0 << 0,
 
    /* Enable system call dispatcher (HEVC only) */
    RCE_SYSTEM_CALL_DISPATCHER    = 1 << 2,
 
    RCE_SRTP                      = 1 << 3,
 
    RCE_SRTP_KMNGMNT_ZRTP         = 1 << 4,
 
    RCE_SRTP_KMNGMNT_USER         = 1 << 5,
 
    RCE_NO_H26X_INTRA_DELAY       = 1 << 5,
 
    RCE_FRAGMENT_GENERIC          = 1 << 6,
 
    RCE_SRTP_INPLACE_ENCRYPTION   = 1 << 7,
 
    RCE_NO_SYSTEM_CALL_CLUSTERING = 1 << 8,
 
    RCE_SRTP_NULL_CIPHER          = 1 << 9,
 
    RCE_SRTP_AUTHENTICATE_RTP     = 1 << 10,
 
    RCE_SRTP_REPLAY_PROTECTION    = 1 << 11,
 
    RCE_RTCP                      = 1 << 12,
 
    RCE_H26X_PREPEND_SC           = 1 << 13,
 
    RCE_HOLEPUNCH_KEEPALIVE       = 1 << 14,
 
    RCE_LAST                      = 1 << 15,
};
 
enum RTP_CTX_CONFIGURATION_FLAGS {
    RCC_NO_FLAGS         = 0,
 
    RCC_UDP_RCV_BUF_SIZE = 1,
 
    RCC_UDP_SND_BUF_SIZE = 2,
 
    RCC_PKT_MAX_DELAY    = 3,
 
    RCC_DYN_PAYLOAD_TYPE = 4,
 
    RCC_MTU_SIZE         = 5,
 
    RCC_LAST
};
 
enum NOTIFY_REASON {
 
    /* Timer for the active frame has expired and it has been dropped */
    NR_FRAME_DROPPED = 0,
};
 
/* see src/util.hh for more information */
typedef struct rtp_ctx_conf {
    int flags;
    ssize_t ctx_values[RCC_LAST];
} rtp_ctx_conf_t;
 
extern thread_local rtp_error_t rtp_errno;
 
#define TIME_DIFF(s, e, u) ((ssize_t)std::chrono::duration_cast<std::chrono::u>(e - s).count())
 
#define SET_NEXT_FIELD_32(a, p, v) do { *(uint32_t *)&(a)[p] = (v); p += 4; } while (0)
#define SET_FIELD_32(a, i, v)      do { *(uint32_t *)&(a)[i] = (v); } while (0)
 
static inline void hex_dump(uint8_t *buf, size_t len)
{
    if (!buf)
        return;
 
    for (size_t i = 0; i < len; i += 10) {
        fprintf(stderr, "\t");
        for (size_t k = i; k < i + 10; ++k) {
            fprintf(stderr, "0x%02x ", buf[k]);
        }
        fprintf(stderr, "\n");
    }
}
 
static inline void set_bytes(int *ptr, int nbytes)
{
    if (ptr)
        *ptr = nbytes;
}
 
static inline void *memdup(const void *src, size_t len)
{
    uint8_t *dst = new uint8_t[len];
    std::memcpy(dst, src, len);
 
    return dst;
}
 
static inline std::string generate_string(size_t length)
{
    auto randchar = []() -> char
    {
        const char charset[] =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
        const size_t max_index = (sizeof(charset) - 1);
        return charset[ rand() % max_index ];
    };
 
    std::string str(length, 0);
    std::generate_n(str.begin(), length, randchar);
    return str;
}