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 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 Interpolation
  {
    BilinearFast = CExports::CVCBI_BilinearFast,
    Bilinear = CExports::CVCBI_Bilinear,
    Bicubic = CExports::CVCBI_Bicubic,
  };
 
  enum class CodecStatus
  {
    Ok = CExports::CVCBCS_Ok,
    ReadoutRequired = CExports::CVCBCS_ReadoutRequired
  };
 
 
  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
    {
      return !(*this == other);
    }
 
  private:
    int32_t numerator_ = 0;
    int32_t denominator_ = 1;
  };
 
  inline void SetBackendLogLevel(LogLevel logLevel)
  {
    CVB_CALL_CAPI_CHECKED(CVCBSetBackendLogLevel(static_cast<CExports::CVCBLogLevel>(logLevel)));
  }
}
 
CVB_END_INLINE_NS
 
}