SDL3pp_camera.h

#ifndef SDL3PP_CAMERA_H_
#define SDL3PP_CAMERA_H_
 
#include <SDL3/SDL_camera.h>
#include "SDL3pp_error.h"
#include "SDL3pp_pixels.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_surface.h"
 
namespace SDL {
 
// Forward decl
struct Camera;
 
using CameraRaw = SDL_Camera*;
 
// Forward decl
struct CameraRef;
 
struct CameraParam
{
  CameraRaw value; 
 
  constexpr CameraParam(CameraRaw value)
    : value(value)
  {
  }
 
  constexpr CameraParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const CameraParam& other) const = default;
 
  constexpr operator CameraRaw() const { return value; }
};
 
// Forward decl
struct CameraFrame;
 
using CameraID = SDL_CameraID;
 
using CameraSpec = SDL_CameraSpec;
 
using CameraPosition = SDL_CameraPosition;
 
constexpr CameraPosition CAMERA_POSITION_UNKNOWN =
  SDL_CAMERA_POSITION_UNKNOWN; 
 
constexpr CameraPosition CAMERA_POSITION_FRONT_FACING =
  SDL_CAMERA_POSITION_FRONT_FACING; 
 
constexpr CameraPosition CAMERA_POSITION_BACK_FACING =
  SDL_CAMERA_POSITION_BACK_FACING; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
using CameraPermissionState = SDL_CameraPermissionState;
 
constexpr CameraPermissionState CAMERA_PERMISSION_STATE_DENIED =
  SDL_CAMERA_PERMISSION_STATE_DENIED; 
 
constexpr CameraPermissionState CAMERA_PERMISSION_STATE_PENDING =
  SDL_CAMERA_PERMISSION_STATE_PENDING; 
 
constexpr CameraPermissionState CAMERA_PERMISSION_STATE_APPROVED =
  SDL_CAMERA_PERMISSION_STATE_APPROVED; 
#else
 
using CameraPermissionState = int;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
class Camera
{
  CameraRaw m_resource = nullptr;
 
public:
  constexpr Camera(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Camera(const CameraRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Camera(const Camera& other) noexcept = default;
 
public:
  constexpr Camera(Camera&& other) noexcept
    : Camera(other.release())
  {
  }
 
  constexpr Camera(const CameraRef& other) = delete;
 
  constexpr Camera(CameraRef&& other) = delete;
 
  Camera(CameraID instance_id, OptionalRef<const CameraSpec> spec = {})
    : m_resource(SDL_OpenCamera(instance_id, spec))
  {
  }
 
  ~Camera() { SDL_CloseCamera(m_resource); }
 
  constexpr Camera& operator=(Camera&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Camera& operator=(const Camera& other) noexcept = default;
 
public:
  constexpr CameraRaw get() const noexcept { return m_resource; }
 
  constexpr CameraRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Camera& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator CameraParam() const noexcept { return {m_resource}; }
 
  void Close();
 
  CameraPermissionState GetPermissionState();
 
  CameraID GetID();
 
  PropertiesRef GetProperties();
 
  std::optional<CameraSpec> GetFormat();
 
  CameraFrame AcquireFrame(Uint64* timestampNS = nullptr);
 
  void ReleaseFrame(CameraFrame&& lock);
};
 
struct CameraRef : Camera
{
  using Camera::Camera;
 
  CameraRef(CameraParam resource) noexcept
    : Camera(resource.value)
  {
  }
 
  CameraRef(CameraRaw resource) noexcept
    : Camera(resource)
  {
  }
 
  constexpr CameraRef(const CameraRef& other) noexcept = default;
 
  ~CameraRef() { release(); }
};
 
class CameraFrame : public Surface
{
  CameraRef m_lock;
 
public:
  CameraFrame(CameraRef resource, Uint64* timestampNS = nullptr);
 
  CameraFrame(const CameraFrame& other) = delete;
 
  constexpr CameraFrame(CameraFrame&& other) noexcept
    : Surface(std::move(other))
    , m_lock(other.m_lock)
  {
    other.m_lock = {};
  }
 
  ~CameraFrame() { reset(); }
 
  CameraFrame& operator=(const CameraFrame& other) = delete;
 
  CameraFrame& operator=(CameraFrame&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }
 
  constexpr operator bool() const
  {
    return bool(m_lock) && Surface::operator bool();
  }
 
  void reset();
 
  CameraRef get() { return m_lock; }
 
  void release()
  {
    Surface::release();
    m_lock.release();
  }
};
 
inline int GetNumCameraDrivers() { return SDL_GetNumCameraDrivers(); }
 
inline const char* GetCameraDriver(int index)
{
  return SDL_GetCameraDriver(index);
}
 
inline const char* GetCurrentCameraDriver()
{
  return SDL_GetCurrentCameraDriver();
}
 
inline OwnArray<CameraID> GetCameras()
{
  int count;
  auto data = SDL_GetCameras(&count);
  return OwnArray<CameraID>(data, count);
}
 
inline OwnArray<CameraSpec*> GetCameraSupportedFormats(CameraID instance_id)
{
  int count;
  auto data = SDL_GetCameraSupportedFormats(instance_id, &count);
  return OwnArray<CameraSpec*>(data, count);
}
 
inline const char* GetCameraName(CameraID instance_id)
{
  return SDL_GetCameraName(instance_id);
}
 
inline CameraPosition GetCameraPosition(CameraID instance_id)
{
  return SDL_GetCameraPosition(instance_id);
}
 
inline Camera OpenCamera(CameraID instance_id,
                         OptionalRef<const CameraSpec> spec = {})
{
  return Camera(instance_id, spec);
}
 
inline CameraPermissionState GetCameraPermissionState(CameraParam camera)
{
  return SDL_GetCameraPermissionState(camera);
}
 
inline CameraPermissionState Camera::GetPermissionState()
{
  return SDL::GetCameraPermissionState(m_resource);
}
 
inline CameraID GetCameraID(CameraParam camera)
{
  return CheckError(SDL_GetCameraID(camera));
}
 
inline CameraID Camera::GetID() { return SDL::GetCameraID(m_resource); }
 
inline PropertiesRef GetCameraProperties(CameraParam camera)
{
  return {CheckError(SDL_GetCameraProperties(camera))};
}
 
inline PropertiesRef Camera::GetProperties()
{
  return SDL::GetCameraProperties(m_resource);
}
 
inline std::optional<CameraSpec> GetCameraFormat(CameraParam camera)
{
  if (CameraSpec spec; SDL_GetCameraFormat(camera, &spec)) return spec;
  return std::nullopt;
}
 
inline std::optional<CameraSpec> Camera::GetFormat()
{
  return SDL::GetCameraFormat(m_resource);
}
 
inline Surface AcquireCameraFrame(CameraParam camera,
                                  Uint64* timestampNS = nullptr)
{
  return Surface::Borrow(SDL_AcquireCameraFrame(camera, timestampNS));
}
 
inline CameraFrame Camera::AcquireFrame(Uint64* timestampNS)
{
  return {CameraRef(*this)};
}
 
inline CameraFrame::CameraFrame(CameraRef resource, Uint64* timestampNS)
  : Surface(AcquireCameraFrame(resource, timestampNS))
  , m_lock(std::move(resource))
{
  if (!*this) m_lock.release();
}
 
inline void ReleaseCameraFrame(CameraParam camera, SurfaceParam frame)
{
  SDL_ReleaseCameraFrame(camera, frame);
}
 
inline void Camera::ReleaseFrame(CameraFrame&& lock)
{
  SDL_assert_paranoid(lock.get() == *this);
  lock.reset();
}
 
inline void CameraFrame::reset()
{
  if (!m_lock) return;
  ReleaseCameraFrame(m_lock, Surface::release());
  m_lock = {};
}
 
inline void CloseCamera(CameraRaw camera) { SDL_CloseCamera(camera); }
 
inline void Camera::Close() { CloseCamera(release()); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_CAMERA_H_ */