recording_settings.hpp

#pragma once
 
#include "../global.hpp"
#include "../string.hpp"
#include "../exception.hpp"
 
#include "movie2.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace Movie2
{
 
 
class RecordingSettings
{
  friend class RecordingEngine;
 
  protected:
 
 
    RecordingSettings() noexcept = default;
 
 
  public:
 
    virtual ~RecordingSettings() = default;
 
 
    double FrameRate() const noexcept
    {
      return frameRate_;
    }
 
 
    void SetFrameRate(double frameRate)
    {
      if (frameRate < 0)
        throw std::invalid_argument("frame rate must be grater than zero");
 
      frameRate_ = frameRate;
    }
 
 
    RecordingEngineType EngineType() const noexcept
    {
      return engineType_;
    }
 
  protected:
    RecordingSettings(RecordingEngineType type) noexcept
      : engineType_(type)
    {}
 
    int                   codecIndex_  = 0;
    bool                  useMetaData_ = false;
 
  private:
 
    double                frameRate_  = 25.0;
    RecordingEngineType   engineType_ = RecordingEngineType::Undefined;
 
 
};
 
 
class DirectShowSettings : public RecordingSettings
{
 
friend class DirectShowEngine;
 
public:
 
  DirectShowSettings() noexcept
    : RecordingSettings(RecordingEngineType::DirectShow)
  {}
 
  ~DirectShowSettings() = default;
 
 
  std::vector<String> AvailableCodecs()
  {
    auto handle = CreateMovie2();
 
    CExports::cvbval_t numComperessors = 0;
    auto resultNumCompressors = CExports::Movie2GetNumCompressors(handle.get(), numComperessors);
    if (resultNumCompressors < 0)
      std::rethrow_exception(CvbException::FromCvbResult(resultNumCompressors, "failed to get the number of compressors"));
 
 
    std::vector<String> codecs(static_cast<std::size_t>(numComperessors));
    for (CExports::cvbres_t i = 0; i < numComperessors; ++i)
    {
      std::vector<Char> buffer(1024);
      auto resultCompressorName = CExports::Movie2GetCompressorNameTyped(handle.get(), i, &buffer[0], static_cast<CExports::cvbres_t>(buffer.size()));
      if (resultCompressorName < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultCompressorName, "failed to get compressor name"));
 
      codecs[static_cast<size_t>(i)] = String(&buffer[0]);
    }
    return codecs;
  }
 
 
  String Codec() const
  {
    auto handle = CreateMovie2();
 
    std::vector<Char> buffer(1024);
    auto resultCompressorName = CExports::Movie2GetCompressorNameTyped(handle.get(),
                                                                       static_cast<CExports::cvbval_t>(codecIndex_),
                                                                       &buffer[0],
                                                                       static_cast<CExports::cvbres_t>(buffer.size()));
    if (resultCompressorName < 0)
      std::rethrow_exception(CvbException::FromCvbResult(resultCompressorName, "failed to get compressor name"));
 
    return String(&buffer[0]);
  }
 
 
  void SetCodec(const String& name)
  {
    auto codecs = AvailableCodecs();
    auto codecIndex = std::find(codecs.begin(), codecs.end(), name) - codecs.begin();
    if (codecIndex >= static_cast<std::ptrdiff_t>(codecs.size()))
      throw std::invalid_argument("requested codec not available");
 
    codecIndex_ = static_cast<int>(codecIndex);
  }
 
 
  bool UseMetaData() const noexcept
  {
    return useMetaData_;
  }
 
 
  void SetUseMetaData(bool useMetaData) noexcept
  {
    useMetaData_ = useMetaData;
  }
 
//protected: // TODO
 
  int CodecIndex() const noexcept
  {
    return codecIndex_;
  }
 
private:
 
  static std::unique_ptr<void, void(*)(void *)> CreateMovie2()
  {
    std::unique_ptr<void, void(*)(void *)> handle(CExports::CreateMovie2Recorder(CExports::Movie2_EngineDirectShow),
                                                  [](void * handle) { CVB_CALL_CAPI(ReleaseObject(handle)); });
 
    if (!handle)
      throw std::runtime_error("failed to create movie recorder");
 
    return handle;
  }
 
 
 
};
 
 
class RawVideoSettings : public RecordingSettings
{
 
friend class RawVideoEngine;
 
public:
 
 
  RawVideoSettings() noexcept
    : RecordingSettings(RecordingEngineType::RawVideo)
  {}
 
  ~RawVideoSettings() = default;
 
};
 
}
 
CVB_END_INLINE_NS
 
}