packet.hpp

#pragma once
 
#include "codec_bridge.hpp"
#include "../global.hpp"
#include "../utilities/system_info.hpp"
#include "../shims/stdoptional.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<CodecBridge::Packet>::HandleGuard(void *handle) noexcept
      : HandleGuard<CodecBridge::Packet>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodecBridge
  {

    class Packet final
    {
 
    public:
      static std::unique_ptr<Packet> FromHandle(HandleGuard<Packet> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
 
        return std::make_unique<Packet>(std::move(guard));
      }
 
      explicit Packet(HandleGuard<Packet> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
      Packet(const Packet &other)            = delete;
      Packet &operator=(const Packet &other) = delete;
      Packet(Packet &&other)                 = delete;
      Packet &operator=(Packet &&other)      = delete;
 
      ~Packet() = default;
 
      void *Handle() const noexcept
      {
        return handle_.Handle();
      }


      size_t Size() const
      {
        size_t size = 0;
        CVB_CALL_CAPI_CHECKED(CVCBufferGetSize(Handle(), size));
        return size;
      }
      size_t Size() const {…}


      void *BasePtr() const
      {
        void *basePtr = nullptr;
        CVB_CALL_CAPI_CHECKED(CVCBufferGetBasePtr(Handle(), basePtr));
        return basePtr;
      }
      void *BasePtr() const {…}


      Cvb::optional<int> StreamIndex() const
      {
        auto index = Property<int>(CExports::CVCBPP_StreamIndex);
        if (index == -1)
          return {};
        return index;
      }
      Cvb::optional<int> StreamIndex() const {…}


      int64_t PresentationTimeStamp() const
      {
        return static_cast<int64_t>(Property<int64_t>(CExports::CVCBPP_PresentationTimestamp));
      }
      int64_t PresentationTimeStamp() const {…}


      Rational TimeBase() const
      {
        auto timeBase = Property<CExports::CVCBRational>(CExports::CVCBPP_TimeBase);
        return {timeBase.Numerator, timeBase.Denominator};
      }
      Rational TimeBase() const {…}
 
    private:
      template <class T>
      T Property(CExports::CVCBPacketProperty property) const
      {
        T value     = {};
        size_t size = sizeof(T);
        CVB_CALL_CAPI_CHECKED(CVCBPacketGetProperty(Handle(), property, &value, size));
        return value;
      }
 
      HandleGuard<Packet> handle_;
    };
    class Packet final {…};
 
  }  // namespace CodecBridge
 
  CVB_END_INLINE_NS
}  // namespace Cvb