CaptureStrategyCommon.hpp

Go to the documentation of this file.

#pragma once
 
#include <QtGui/private/qrhi_p.h>
 
#include <QDebug>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
 
namespace score::gfx::interop
{
 
struct CaptureSlotPublisher
{
  std::atomic<int> pending{-1};
 
  void publish(std::size_t i) noexcept
  {
    pending.store(static_cast<int>(i), std::memory_order_release);
  }
  int consume() noexcept { return pending.exchange(-1, std::memory_order_acquire); }
  void reset() noexcept { pending.store(-1, std::memory_order_relaxed); }
};
 
struct BorrowedSlotTracker
{
  static constexpr std::size_t kMaxSlots = 32;
 
  CaptureSlotPublisher publisher;
 
  std::size_t retireDepth{1};
 
  int ingest(std::size_t i) noexcept
  {
    const int displaced = publisher.pending.exchange(int(i), std::memory_order_acq_rel);
    if(displaced >= 0 && displaced != int(i))
    {
      returns.fetch_or(1u << unsigned(displaced), std::memory_order_release);
      return displaced;
    }
    return -1;
  }
 
  int acquire() noexcept
  {
    const int slot = publisher.consume();
    if(slot < 0)
      return -1;
 
    ++acquisitions;
    if(held >= 0 && held != slot && retireN < kMaxSlots)
      retire[retireN++] = Retired{held, acquisitions};
    held = slot;
 
    std::uint32_t freed = 0;
    std::size_t keep = 0;
    for(std::size_t i = 0; i < retireN; ++i)
    {
      if(acquisitions - retire[i].at >= retireDepth)
        freed |= 1u << unsigned(retire[i].slot);
      else
        retire[keep++] = retire[i];
    }
    retireN = keep;
    if(freed)
      returns.fetch_or(freed, std::memory_order_release);
    return slot;
  }
 
  std::uint32_t takeReturned() noexcept
  {
    return returns.exchange(0, std::memory_order_acquire);
  }
 
  void reset() noexcept
  {
    publisher.reset();
    returns.store(0, std::memory_order_relaxed);
    held = -1;
    acquisitions = 0;
    retireN = 0;
  }
 
private:
  struct Retired
  {
    int slot{};
    std::uint64_t at{};
  };
  std::atomic<std::uint32_t> returns{0};
  Retired retire[kMaxSlots]{};
  std::size_t retireN{0};
  int held{-1};
  std::uint64_t acquisitions{0};
};
 
inline bool validateCaptureTextureBytes(
    const QRhiTexture* tex, std::uint32_t frameByteSize, const char* tag) noexcept
{
  if(!tex)
    return false;
  const auto sz = tex->pixelSize();
  const auto expected = static_cast<std::uint32_t>(sz.width()) * 4u
                        * static_cast<std::uint32_t>(sz.height());
  if(expected != frameByteSize)
  {
    qWarning() << tag << "outputTexture byte size" << expected
               << "!= captured frame size" << frameByteSize;
    return false;
  }
  return true;
}
 
} // namespace score::gfx::interop