rtp_depayloader.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_DEPAYLOADER_H_
#define RTP_RTP_DEPAYLOADER_H_
 
#include <functional>
#include <string>
#include <vector>
 
#include "rtp/rtp_depayloader.h"
#include "rtp/rtp_types.h"
 
namespace mediax::rtp {
 
class RtpDepayloader;
 
using RtpCallback = std::function<void(const RtpDepayloader& depay, RtpFrameData frame)>;
 
enum class StreamState {
  kClosed,
  kOpen,
  kStarted,
  kStopped
};
enum class StreamState {…};
 
enum class SettingsMask {
  hostname = 0b00000001,
  port = 0b00000010,
  name = 0b00000100,
  height = 0b00001000,
  width = 0b00010000,
  framerate = 0b00100000,
  encoding = 0b01000000,
  all = 0b01111111
};
enum class SettingsMask {…};
 
class RtpDepayloader {
 public:
  RtpDepayloader();
 
  virtual ~RtpDepayloader() = default;
 
  RtpDepayloader(RtpDepayloader const&) = delete;
 
  RtpDepayloader& operator=(RtpDepayloader const&) = delete;
 
  virtual void SetStreamInfo(const ::mediax::rtp::StreamInformation& stream_information) = 0;
 
  void RegisterCallback(const ::mediax::rtp::RtpCallback& callback);
 
  virtual bool Open() {
    state_ = StreamState::kOpen;
    return true;
  }
  virtual bool Open() {…}
 
  virtual void Start() { state_ = StreamState::kStarted; }
 
  virtual void Stop() { state_ = StreamState::kStopped; }
 
  virtual void Close() { state_ = StreamState::kClosed; }
 
  virtual bool Receive(mediax::rtp::RtpFrameData* data, int32_t timeout = 0) = 0;
 
  void SetSessionName(std::string_view name);
 
  std::string GetSessionName();
 
  ::mediax::rtp::ColourspaceType GetColourSpace();
 
  void SetHeight(uint32_t height);
 
  uint32_t GetHeight() const;
 
  void SetWidth(uint32_t width);
 
  uint32_t GetWidth() const;
 
  void SetFramerate(uint32_t framerate);
 
  uint32_t GetFrameRate() const;
 
  std::string GetIpAddress() const;
 
  void SetIpAddress(std::string_view ip_address);
 
  void SetPort(uint32_t port);
 
  uint32_t GetPort() const;
 
  void SetColourSpace(::mediax::rtp::ColourspaceType colourspace);
 
  bool SettingsValid() const;
 
  ::mediax::rtp::ColourspaceType GetColourSpace() const;
 
  bool IsMulticast(std::string_view ip_address) const;
 
  bool CallbackRegistered() const;
 
  void UnregisterCallback();
 
  virtual void Callback(::mediax::rtp::RtpFrameData frame) const = 0;
 
  ::mediax::rtp::RtpPortType& GetStream();
 
  ::mediax::rtp::RtpCallback GetCallback() const { return callback_; }
 
  std::vector<uint8_t>& GetBuffer() { return buffer_in_; }
 
  uint32_t GetBufferSize() const { return static_cast<uint32_t>(buffer_in_.size()); }
 
  void SetBufferSize(uint32_t size) { buffer_in_.resize(size); }
 
  ::mediax::rtp::StreamState GetState() const { return state_; }
 
 private:
  ::mediax::rtp::StreamState state_ = ::mediax::rtp::StreamState::kClosed;
  ::mediax::rtp::RtpCallback callback_;
  std::vector<uint8_t> buffer_in_;
  bool callback_registered_ = false;
  ::mediax::rtp::RtpPortType ingress_ = {};
  uint32_t settings_mask_ = 0;
};  // namespace mediax::rtp
class RtpDepayloader {…};
 
}  // namespace mediax::rtp
 
#endif  // RTP_RTP_DEPAYLOADER_H_