detail_recording_engine.hpp

#pragma once
 
#include "../global.hpp"
#include "../string.hpp"
#include "../exception.hpp"
 
#include "recording_settings.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Movie2
  {
 
    namespace Private
    {
 
      class RecordingEngine;
      using RecordingEnginePtr = std::shared_ptr<RecordingEngine>;
 
      class DirectShowEngine;
      using DirectShowEnginePtr = std::shared_ptr<DirectShowEngine>;
 
      class RawVideoEngine;
      using RawVideoEnginePtr = std::shared_ptr<RawVideoEngine>;
 
      class RecordingEngine
      {
 
      public:
        static RecordingEnginePtr Create(const RecordingSettings &settings);
 
        virtual const RecordingSettings &Settings()
        {
          return settings_;
        }
 
      protected:
        RecordingEngine(const RecordingSettings &settings) noexcept
            : settings_(settings)
        {
        }
 
        ~RecordingEngine() = default;
 
      private:
        RecordingEngine() noexcept = default;
 
      protected:
        const RecordingSettings &settings_;
      };
 
      class DirectShowEngine : public RecordingEngine
      {
      public:
        DirectShowEngine(const DirectShowSettings &settings) noexcept
            : RecordingEngine(settings)
        {
        }
 
        virtual const DirectShowSettings &Settings() noexcept
        {
          return dynamic_cast<const DirectShowSettings &>(settings_);
        }
      };
 
      class RawVideoEngine : public RecordingEngine
      {
      public:
        RawVideoEngine(const RawVideoSettings &settings) noexcept
            : RecordingEngine(settings)
        {
        }
 
        virtual const RawVideoSettings &Settings() noexcept
        {
          return dynamic_cast<const RawVideoSettings &>(settings_);
        }
      };
 
      inline RecordingEnginePtr RecordingEngine::Create(const RecordingSettings &settings)
      {
        if (settings.EngineType() == RecordingEngineType::DirectShow)
        {
          const auto &s = dynamic_cast<const DirectShowSettings &>(settings);
          return std::make_shared<DirectShowEngine>(s);
        }
        else if (settings.EngineType() == RecordingEngineType::RawVideo)
        {
          const auto &s = dynamic_cast<const RawVideoSettings &>(settings);
          return std::dynamic_pointer_cast<RecordingEngine>(std::make_shared<RawVideoEngine>(s));
        }
        else
          throw std::runtime_error("failed to create recording engine (unsupported settings)");
      }
 
    }  // namespace Private
 
  }  // namespace Movie2
  namespace Movie2 {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb