codec_bridge.hpp

#pragma once
 
#include <memory>
 
#include "../_cexports/c_codec_bridge.h"
 
#include "../utilities/system_info.hpp"
#include "../global.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  namespace CodecBridge
  {
 
    class Decoder;
    using DecoderPtr = std::shared_ptr<Decoder>;
 
    class Encoder;
    using EncoderPtr = std::shared_ptr<Encoder>;
 
    class CodecConfig;
    using CodecConfigPtr = std::shared_ptr<CodecConfig>;
 
    class FormatConverter;
    using FormatConverterPtr = std::shared_ptr<FormatConverter>;
 
    class Frame;
    using FramePtr = std::shared_ptr<Frame>;
 
    class InputContainer;
    using InputContainerPtr = std::shared_ptr<InputContainer>;
 
    class OutputContainer;
    using OutputContainerPtr = std::shared_ptr<OutputContainer>;
 
    class Packet;
    using PacketPtr = std::shared_ptr<Packet>;


    enum class LogLevel
    {
      Quiet = CExports::CVCBLL_Quiet,
      Panic = CExports::CVCBLL_Panic,
      Fatal = CExports::CVCBLL_Fatal,
      Error = CExports::CVCBLL_Error,
      Warning = CExports::CVCBLL_Warning,
      Info = CExports::CVCBLL_Info,
      Verbose = CExports::CVCBLL_Verbose,
      Debug = CExports::CVCBLL_Debug,
      Trace = CExports::CVCBLL_Trace,
    };
    enum class LogLevel {…};


    enum class PixelFormat
    {
      None = CExports::CVCBPF_None,
      YUV420P = CExports::CVCBPF_YUV420P,
      YUYV422 = CExports::CVCBPF_YUYV422,
      RGB24 = CExports::CVCBPF_RGB24,
      BGR24 = CExports::CVCBPF_BGR24,
      YUV422P = CExports::CVCBPF_YUV422P,
      YUV444P = CExports::CVCBPF_YUV444P,
      GRAY8 = CExports::CVCBPF_GRAY8,
      NV12 = CExports::CVCBPF_NV12,
      NV21 = CExports::CVCBPF_NV21,
      RGBA = CExports::CVCBPF_RGBA,
      BGRA = CExports::CVCBPF_BGRA,
      YUV444P16LE = CExports::CVCBPF_YUV444P16LE,
      DXVA2_VLD = CExports::CVCBPF_DXVA2_VLD,
      YUV420P10LE = CExports::CVCBPF_YUV420P10LE,
      YUV422P10LE = CExports::CVCBPF_YUV422P10LE,
      YUV444P10LE = CExports::CVCBPF_YUV444P10LE,
      GBRP = CExports::CVCBPF_GBRP,
      GBRP10LE = CExports::CVCBPF_GBRP10LE,
      GBRP16LE = CExports::CVCBPF_GBRP16LE,
      NV16 = CExports::CVCBPF_NV16,
      NV20LE = CExports::CVCBPF_NV20LE,
      QSV = CExports::CVCBPF_QSV,
      CUDA = CExports::CVCBPF_CUDA,
      RGB0 = CExports::CVCBPF_RGB0,
      BGR0 = CExports::CVCBPF_BGR0,
      YUV420P12LE = CExports::CVCBPF_YUV420P12LE,
      YUV422P12LE = CExports::CVCBPF_YUV422P12LE,
      YUV444P12LE = CExports::CVCBPF_YUV444P12LE,
      GBRP12LE = CExports::CVCBPF_GBRP12LE,
      P010LE = CExports::CVCBPF_P010LE,
      GRAY12LE = CExports::CVCBPF_GRAY12LE,
      GRAY10LE = CExports::CVCBPF_GRAY10LE,
      P016LE = CExports::CVCBPF_P016LE,
      D3D11 = CExports::CVCBPF_D3D11,
      Y210LE = CExports::CVCBPF_Y210LE,
      X2RGB10LE = CExports::CVCBPF_X2RGB10LE,
      X2BGR10LE = CExports::CVCBPF_X2BGR10LE,
    };
    enum class PixelFormat {…};


    enum class Interpolation
    {
      BilinearFast = CExports::CVCBI_BilinearFast,
      Bilinear = CExports::CVCBI_Bilinear,
      Bicubic = CExports::CVCBI_Bicubic,
    };
    enum class Interpolation {…};

    enum class CodecStatus
    {
      Ok = CExports::CVCBCS_Ok,
      ReadoutRequired = CExports::CVCBCS_ReadoutRequired
    };
    enum class CodecStatus {…};


    class Rational final
    {
 
    public:
      Rational(int numerator, int denominator) noexcept
          : numerator_(numerator)
          , denominator_(denominator)
      {
      }
 
      Rational() noexcept                                 = default;
      Rational(const Rational &other) noexcept            = default;
      Rational &operator=(const Rational &other) noexcept = default;
      Rational(Rational &&other) noexcept                 = default;
      Rational &operator=(Rational &&other) noexcept      = default;
      ~Rational()                                         = default;
 
      int Numerator() const noexcept
      {
        return numerator_;
      }
 
      void SetNumerator(int numerator) noexcept
      {
        numerator_ = numerator;
      }
 
      int Denominator() const noexcept
      {
        return denominator_;
      }
 
      void SetDenominator(int denominator) noexcept
      {
        denominator_ = denominator;
      }


      bool operator==(const Rational &other) const noexcept
      {
        return numerator_ == other.numerator_ && denominator_ == other.denominator_;
      }
      bool operator==(const Rational &other) const noexcept {…}


      bool operator!=(const Rational &other) const noexcept
      {
        return !(*this == other);
      }
      bool operator!=(const Rational &other) const noexcept {…}
 
    private:
      int32_t numerator_ = 0;
      int32_t denominator_ = 1;
    };
    class Rational final {…};
 
    inline void SetBackendLogLevel(LogLevel logLevel)
    {
      CVB_CALL_CAPI_CHECKED(CVCBSetBackendLogLevel(static_cast<CExports::CVCBLogLevel>(logLevel)));
    }
  }  // namespace CodecBridge
  namespace CodecBridge {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb