LibavInterrupt.hpp

#pragma once
#include <Media/Libav.hpp>
#if SCORE_HAS_LIBAV
 
extern "C" {
#include <libavformat/avformat.h>
}
 
#include <atomic>
#include <chrono>
 
namespace Video
{
 
class LibavInterrupt
{
public:
  using clock = std::chrono::steady_clock;
 
  void install(AVFormatContext& ctx) noexcept
  {
    ctx.interrupt_callback.callback = &LibavInterrupt::on_interrupt;
    ctx.interrupt_callback.opaque = this;
  }
 
  void arm(std::chrono::milliseconds timeout) noexcept
  {
    m_deadline.store(
        (clock::now() + timeout).time_since_epoch().count(), std::memory_order_release);
  }
 
  void disarm() noexcept { m_deadline.store(none, std::memory_order_release); }
 
  void abort() noexcept { m_aborted.store(true, std::memory_order_release); }
 
  void reset() noexcept
  {
    m_aborted.store(false, std::memory_order_release);
    disarm();
  }
 
  bool aborted() const noexcept { return m_aborted.load(std::memory_order_acquire); }
 
  bool expired() const noexcept
  {
    if(aborted())
      return true;
 
    const auto deadline = m_deadline.load(std::memory_order_acquire);
    return deadline != none && clock::now().time_since_epoch().count() >= deadline;
  }
 
private:
  static constexpr int64_t none = 0;
 
  static int on_interrupt(void* opaque) noexcept
  {
    return static_cast<const LibavInterrupt*>(opaque)->expired() ? 1 : 0;
  }
 
  std::atomic<int64_t> m_deadline{none};
  std::atomic_bool m_aborted{};
};
 
struct LibavTimeout
{
  explicit LibavTimeout(LibavInterrupt& itr, std::chrono::milliseconds t) noexcept
      : m_itr{itr}
  {
    m_itr.arm(t);
  }
  ~LibavTimeout() { m_itr.disarm(); }
 
  LibavTimeout(const LibavTimeout&) = delete;
  LibavTimeout& operator=(const LibavTimeout&) = delete;
 
private:
  LibavInterrupt& m_itr;
};
 
}
#endif