jpeg_converter.hpp

#pragma once
 
#include "../_cexports/c_webstreaming.h"
#include "converter.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace WebStreaming
{
 
class JPEGConverter
  : public Converter
{
  private:
 
    struct PrivateTag {};
 
  public:
 
 
    static JPEGConverterPtr Create()
    {
      return Internal::DoResCallShareOut<JPEGConverter>([&](void*& handle)
        {
          return CVB_CALL_CAPI(CVWSCreateConverter(CExports::CVWSCT_Jpeg, handle));
        });
    }
 
    template<class T>
    static JPEGConverterPtr FromHandle(HandleGuard<Converter>&& guard)
    {
      static_assert(std::is_same<JPEGConverter, T>::value, "CVB: T must be JPEGConverter");
      if (!guard.Handle())
        throw std::runtime_error("converter handle invalid");
      return std::make_shared<T>(std::move(guard), PrivateTag{});
    }
 
    JPEGConverter(HandleGuard<Converter>&& guard, PrivateTag) noexcept
      : Converter(std::move(guard))
    {
    }
 
 
    int Scale() const
    {
      CExports::cvbint64_t value = 0;
      CVB_CALL_CAPI_CHECKED(CVWSGetPropertyAsInteger(Handle(), CExports::CVWSCP_JPEGScale, value));
      return static_cast<int>(value);
    }
 
 
    void SetScale(int scale)
    {
      CVB_CALL_CAPI_CHECKED(CVWSSetPropertyAsInteger(Handle(), CExports::CVWSCP_JPEGScale, static_cast<CExports::cvbint64_t>(scale)));
    }
 
 
    int Quality() const
    {
      CExports::cvbint64_t value = 0;
      CVB_CALL_CAPI_CHECKED(CVWSGetPropertyAsInteger(Handle(), CExports::CVWSCP_JPEGQualityLevel, value));
      return static_cast<int>(value);
    }
 
 
    void SetQuality(int quality)
    {
      CVB_CALL_CAPI_CHECKED(CVWSSetPropertyAsInteger(Handle(), CExports::CVWSCP_JPEGQualityLevel, static_cast<CExports::cvbint64_t>(quality)));
    }
 
    
};
 
}
 
CVB_END_INLINE_NS
 
}