rtp_types.h

Go to the documentation of this file.

//
// Copyright (c) 2025, Astute Systems PTY LTD
//
// This file is part of the VivoeX project developed by Astute Systems.
//
// Licensed under the Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
// License. See the LICENSE file in the project root for full license details.
//
 
#ifndef RTP_RTP_TYPES_H_
#define RTP_RTP_TYPES_H_
 
#include <stdint.h>
 
#include <array>
#include <map>
#include <string>
 
namespace mediax::rtp {
 
enum class StatusCode { kStatusOk = 0, kStatusError };
 
const uint16_t kSapPort = 9875;
 
// RTP constants
const uint32_t kRtpVersion = 0x2;
const uint32_t kRtpExtension = 0x0;
const uint32_t kRtpMarker = 0x0;
const uint32_t kRtpPayloadType = 0x60;
const uint32_t kRtpSource = 0x12345678;
const uint32_t kRtpFramerate = 25;
const uint32_t Hz90 = 90000;
const uint32_t kNumberLinesPerPacket = 10;
const uint32_t kMaximumBufferSize = 1280 * 3;
const uint32_t kMaxUdpData = kMaximumBufferSize + 100;
const uint32_t kRtpCheck = 0;
const uint32_t kRtpThreaded = 1;
const uint32_t kPitch = 4;
 
struct float4 {
  float x;
  float y;
  float z;
  float w;
};
 
struct Rgb {
  uint8_t red;
  uint8_t green;
  uint8_t blue;
};
 
struct RtpHeaderData {
  uint32_t protocol : 32;
  uint32_t timestamp : 32;
  uint32_t source : 32;
};
 
struct RtpLineHeader {
  uint16_t length;
  uint16_t line_number;
  uint16_t offset;
};
 
enum class ColourspaceType {
  kColourspaceRgb24 = 0,
  kColourspaceYuv422,
  kColourspaceYuv420p,
  kColourspaceMono8,
  kColourspaceMono16,
  kColourspaceRgba,  // Not a GVA uncompressed video format
  kColourspaceBgra,  // Not a GVA uncompressed video format
  kColourspaceNv12,  // Not a GVA uncompressed video format
  kColourspaceJpeg2000,
  kColourspaceH264Part4,
  kColourspaceH264Part10,
  kColourspaceH265,
  kColourspaceAv1,
  kColourspaceUndefined
};
 
const std::map<ColourspaceType, uint8_t> kColourspaceBytes = {
    {ColourspaceType::kColourspaceUndefined, 0}, {ColourspaceType::kColourspaceRgb24, 3},
    {ColourspaceType::kColourspaceYuv422, 2},    {ColourspaceType::kColourspaceYuv420p, 3},
    {ColourspaceType::kColourspaceMono8, 1},     {ColourspaceType::kColourspaceMono16, 2},
    {ColourspaceType::kColourspaceJpeg2000, 3},  {ColourspaceType::kColourspaceH264Part4, 3},
    {ColourspaceType::kColourspaceH264Part10, 3}};
 
const std::map<ColourspaceType, std::string> kRtpMap = {
    {ColourspaceType::kColourspaceUndefined, "unknown"}, {ColourspaceType::kColourspaceRgb24, "raw"},
    {ColourspaceType::kColourspaceYuv422, "raw"},        {ColourspaceType::kColourspaceMono8, "raw"},
    {ColourspaceType::kColourspaceMono16, "raw"},        {ColourspaceType::kColourspaceJpeg2000, "jpeg2000"},
    {ColourspaceType::kColourspaceH264Part4, "nv12"},    {ColourspaceType::kColourspaceH264Part10, "nv12"}};
const std::map<ColourspaceType, std::string> kColourspace = {
    {ColourspaceType::kColourspaceUndefined, "unknown"},
    {ColourspaceType::kColourspaceRgb24, "RGB"},
    {ColourspaceType::kColourspaceYuv422, "YCbCr-4:2:2"},
    {ColourspaceType::kColourspaceMono8, "GRAYSCALE"},
    {ColourspaceType::kColourspaceMono16, "GRAYSCALE"},
    {ColourspaceType::kColourspaceJpeg2000, "YCbCr-4:2:2"},
    {ColourspaceType::kColourspaceH264Part4, "H264 (Part 4)"},
    {ColourspaceType::kColourspaceH264Part10, "H264 (Part 10)"}};
 
struct RtpPortType {
  std::string hostname;
  uint32_t port_no = 0;
  int sockfd = 0;
  std::string name = "unknown";
  uint32_t height = 0;
  uint32_t width = 0;
  uint32_t framerate = 25;
  ColourspaceType encoding;
  bool socket_open = false;
  bool settings_valid = false;
};
 
struct RtpPayloadHeader {
  uint16_t extended_sequence_number;
  std::array<RtpLineHeader, kNumberLinesPerPacket> line;  // This can be multiline min the future
};
 
struct RtpHeader {
  RtpHeaderData rtp;
  RtpPayloadHeader payload;
};
 
struct RtpPacket {
  RtpHeader head;
  std::array<int8_t, kMaximumBufferSize> data;
};
 
struct Resolution {
  uint32_t height;
  uint32_t width;
};
 
struct RtpFrameData {
  Resolution resolution;
  uint8_t *cpu_buffer;
  mediax::rtp::ColourspaceType encoding;
};
 
struct TxData {
  uint8_t *rgb_frame;
  uint8_t *encoded_frame;
  uint32_t width;
  uint32_t height;
};
 
struct StreamInformation {
  std::string session_name;
  std::string hostname;
  uint32_t port = 5004;
  uint32_t height;
  uint32_t width;
  uint32_t framerate;
  ::mediax::rtp::ColourspaceType encoding;
  bool deleted = false;
};
 
}  // namespace mediax::rtp
 
#endif  // RTP_RTP_TYPES_H_