recorder.hpp

#pragma once
 
#include <memory>
 
#include "../global.hpp"
#include "../exception.hpp"
#include "../string.hpp"
#include "../size_2d.hpp"
 
#include "../image.hpp"
 
#include "movie2.hpp"
#include "recording_settings.hpp"
 
#include "_detail/detail_recording_engine.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
template <>
inline HandleGuard<Movie2::Recorder>::HandleGuard(void * handle) noexcept
  : HandleGuard<Movie2::Recorder>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
{
}
 
namespace Movie2
{
 
 
class Recorder
{
 
  public:
 
 
    static RecorderPtr FromHandle(HandleGuard<Recorder>&& guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::unique_ptr<Recorder>(new Recorder(std::move(guard)));
    }
 
 
    static std::unique_ptr<Recorder> Create(const String & path, Size2D<int> size, RecorderPixelFormat pixelFormat, const RecordingSettings& settings)
    {
      return Create(path, size, pixelFormat, Private::RecordingEngine::Create(settings));
    }
 
 
    static std::unique_ptr<Recorder> Create(const String & path, Size2D<int> size, RecorderPixelFormat pixelFormat)
    {
      return Create(path, size, pixelFormat, Private::RecordingEngine::Create(DirectShowSettings()));
    }
 
 
    void * Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
    void Write(const Image & image, const String & metaData = String())
    {
      metaData_ = metaData;
 
      auto res = CVB_CALL_CAPI(Movie2SetImage(Handle(), image.Handle()));
      if (res != CExports::CVC_E_OK)
        Utilities::SystemInfo::ThrowLastError();
 
      res = CVB_CALL_CAPI(Movie2AddFrame(Handle()));
      if (res != CExports::CVC_E_OK)
        Utilities::SystemInfo::ThrowLastError();
    }
 
    virtual ~Recorder()
    {
      if (Handle())
      {
        CExports::Movie2StopRecording(Handle());
      }
    }
 
    Recorder(HandleGuard<Recorder>&& guard) noexcept
      : handle_(std::move(guard))
    {
    }
 
  private:
 
    Recorder(Recorder && other) noexcept
      : handle_(std::move(other.handle_))
    {
    }
 
    Recorder(const String & path, Size2D<int> size, RecorderPixelFormat pixelFormat, Private::RecordingEnginePtr engine)
      : Recorder(std::move(*CreateRecorder(size, pixelFormat, engine)))
    {
      // After creating recorder
      // configure the engine
      ConfigureEngine(engine);
      // and start recording
      Record(path);
    }
 
    static std::unique_ptr<Recorder> Create(const String & path, Size2D<int> size, RecorderPixelFormat pixelFormat, Private::RecordingEnginePtr engine)
    {
      return std::unique_ptr<Recorder>(new Recorder(path, size, pixelFormat, engine));
    }
 
    static RecorderPtr CreateRecorder(Size2D<int> size, RecorderPixelFormat pixelFormat, Private::RecordingEnginePtr engine)
    {
      intptr_t dummyBuffer = 0;
      auto dummyImage = (pixelFormat == RecorderPixelFormat::Mono)
        ? WrappedImage::FromGreyPixels(&dummyBuffer, size.Width() * size.Height(), size.Width(), size.Height(), DataType::Int8BppUnsigned(), 1, size.Width())
        : WrappedImage::FromRgbPixels(&dummyBuffer, size.Width() * size.Height() * 3, size.Width(), size.Height(), DataType::Int8BppUnsigned(), 3, size.Width() * 3, 1);
 
      HandleGuard<Recorder> guard(CExports::CreateMovie2RecorderEx(static_cast<CExports::Movie2_RecordingEngine>(engine->Settings().EngineType()), dummyImage->Handle()));
      if (!guard.Handle())
        throw std::runtime_error("failed to create movie recorder");
 
      return std::make_unique<Recorder>(std::move(guard));
    }
 
    void ConfigureEngine(Private::RecordingEnginePtr engine)
    {
      engine_ = engine;
 
      if (engine_->Settings().EngineType() == RecordingEngineType::DirectShow)
        ConfigureDirectShowEngine();
      else if (engine_->Settings().EngineType() == RecordingEngineType::RawVideo)
        ConfigureRawVideoEngine();
    }
 
    void ConfigureDirectShowEngine()
    {
      auto directShowEngine = std::dynamic_pointer_cast<Private::DirectShowEngine>(engine_);
      const auto& settings = directShowEngine->Settings();
 
      CVB_CALL_CAPI(Movie2SetSyncMode(Handle(), CExports::Movie2_SyncAfterCopy));
      CVB_CALL_CAPI(Movie2SetAcqMode(Handle(), CExports::Movie2_AcqAddFrame));
      CVB_CALL_CAPI(Movie2SetCompressorIndex(Handle(), static_cast<CExports::cvbval_t>(settings.CodecIndex())));
      CVB_CALL_CAPI(Movie2SetFrameRate(Handle(), settings.FrameRate()));
      CVB_CALL_CAPI(Movie2SetUseMetadata(Handle(), (settings.UseMetaData()) ? 1 : 0));
 
      if (settings.UseMetaData())
      {
        Internal::DoResCall([&]()
        {
          CExports::pfMovie2ProvideMetaData metaDataCallback = [](CExports::MOVIE2RECORDER, char* szMetaData, CExports::cvbval_t BufferSize, void* pUserData)
          {
            if (szMetaData && BufferSize > 0)
            {
              auto recorder = reinterpret_cast<Cvb::Movie2::Recorder*>(pUserData);
              auto metaData = recorder->metaData_;
 
              std::string metaDataAscii(Internal::CastToAscii (metaData));
              size_t charsToCopy = std::min(metaData.size(), static_cast<std::size_t>(BufferSize) - 1);
              std::copy_n(metaDataAscii.begin(), charsToCopy, szMetaData);
              szMetaData[charsToCopy] = 0;
            }
          };
 
          CExports::cvbval_t dummy = 0;
          return CVB_CALL_CAPI(Movie2RegisterMetaDataCallback(Handle(), metaDataCallback, this, dummy));
        });
      }
    }
 
    void ConfigureRawVideoEngine()
    {
      const auto& settings = engine_->Settings();
      CVB_CALL_CAPI(Movie2SetSyncMode(Handle(), CExports::Movie2_SyncAfterCopy));
      CVB_CALL_CAPI(Movie2SetAcqMode(Handle(), CExports::Movie2_AcqAddFrame));
      Internal::DoResCall([&]()
      {
        return CVB_CALL_CAPI(Movie2SetFrameRate(Handle(), settings.FrameRate()));
      });
    }
 
    void Record(const String & path)
    {
      auto res = CExports::Movie2SetTargetFileNameTyped(Handle(), path.c_str());
      if (res != CExports::CVC_E_OK)
        Utilities::SystemInfo::ThrowLastError();
 
      Internal::DoResCall([&]()
      {
        return CVB_CALL_CAPI(Movie2StartRecording(Handle()));
      });
    }
 
  private:
    HandleGuard<Recorder>   handle_;
    Private::RecordingEnginePtr engine_;
    String                  metaData_;
};
 
}
 
 
CVB_END_INLINE_NS
 
}