DMACaptureInputNode.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
 
#include <Gfx/Graph/CaptureAdjust.hpp>
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/interop/GpuCapabilities.hpp>
 
#include <Video/VideoInterface.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <functional>
#include <memory>
#include <vector>
 
namespace score::gfx
{
class GPUVideoDecoder;
 
namespace interop
{
struct VideoCaptureStrategy;
struct VideoCaptureSlotRing;
class CaptureSyncGroup;
}
 
struct SCORE_PLUGIN_GFX_EXPORT DMACaptureBackend
{
  virtual ~DMACaptureBackend();
 
  virtual bool open() = 0;
 
  virtual int width() const noexcept = 0;
  virtual int height() const noexcept = 0;
  virtual uint32_t frameByteSize() const noexcept = 0;
 
  virtual Video::ImageFormat imageFormat() const = 0;
 
  virtual std::unique_ptr<GPUVideoDecoder>
  makeDecoder(Video::VideoMetadata&) = 0;
 
  virtual std::unique_ptr<interop::VideoCaptureStrategy>
  pickStrategy(QRhi::Implementation backend, const interop::GpuCapabilities& caps)
      = 0;
 
  virtual std::vector<std::function<std::unique_ptr<interop::VideoCaptureStrategy>()>>
  pickStrategies(
      QRhi::Implementation backend, const interop::GpuCapabilities& caps);
 
  virtual std::unique_ptr<interop::VideoCaptureStrategy>
  makeCpuStrategy() = 0;
 
  virtual void setStrategy(interop::VideoCaptureStrategy*) noexcept = 0;
 
  virtual void start() = 0;
  virtual void stop() = 0;
 
  virtual bool decoderNeedsExternalImage() const noexcept { return false; }
 
  virtual void dropExternalImageRequest() noexcept { }
 
  struct SyncMembership
  {
    interop::CaptureSyncGroup* group{};
    std::size_t member{0};
  };
  virtual SyncMembership syncGroup() noexcept { return {}; }
 
 
  virtual void setSyncGroupEngaged(bool) noexcept { }
};
 
struct SCORE_PLUGIN_GFX_EXPORT DMACaptureInputNode : ProcessNode
{
  DMACaptureInputNode();
  ~DMACaptureInputNode() override;
 
  NodeRenderer* createRenderer(RenderList& r) const noexcept override;
 
  virtual std::unique_ptr<DMACaptureBackend>
  makeCaptureBackend(interop::VideoCaptureSlotRing& ring) const = 0;
 
  const char* engagedCaptureStrategy() const noexcept
  {
    return m_engagedStrategy.load(std::memory_order_acquire);
  }
 
  bool captureStrategyPinUnmet() const noexcept
  {
    return m_pinUnmet.load(std::memory_order_acquire);
  }
 
  void setEngagedCaptureStrategy(const char* name, bool pinUnmet) const noexcept
  {
    m_engagedStrategy.store(name, std::memory_order_release);
    m_pinUnmet.store(pinUnmet, std::memory_order_release);
  }
 
  std::uint64_t capturedFrameCount() const noexcept
  {
    return m_capturedFrames.load(std::memory_order_acquire);
  }
 
  void setCapturedFrameCount(std::uint64_t n) const noexcept
  {
    m_capturedFrames.store(n, std::memory_order_release);
  }
 
  CaptureAdjustSlot& adjustments() const noexcept { return m_adjust; }
 
  class Renderer;
 
private:
  mutable std::atomic<const char*> m_engagedStrategy{nullptr};
  mutable std::atomic<bool> m_pinUnmet{false};
  mutable std::atomic<std::uint64_t> m_capturedFrames{0};
  mutable CaptureAdjustSlot m_adjust;
 
public:
};
 
} // namespace score::gfx