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 RecorderPtr FromHandle(HandleGuard<Recorder> &&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, {…}


      static std::unique_ptr<Recorder> Create(const String &path, Size2D<int> size, RecorderPixelFormat pixelFormat)
      {
        return Create(path, size, pixelFormat, Private::RecordingEngine::Create(DirectShowSettings()));
      }
      static std::unique_ptr<Recorder> Create(const String &path, Size2D<int> size, RecorderPixelFormat pixelFormat) {…}


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
      void *Handle() const noexcept {…}


      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();
      }
      void Write(const Image &image, const String &metaData = String()) {…}
 
      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_;
    };
    class Recorder {…};
 
  }  // namespace Movie2
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb