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

}