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 CameraBase;
 
// Forward decl
struct Camera;

using CameraRaw = SDL_Camera*;

using CameraRef = ResourceRefT<CameraBase>;
 
// 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)

struct CameraBase : ResourceBaseT<CameraRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  CameraPermissionState GetPermissionState();

  CameraID GetID();

  PropertiesRef GetProperties();

  std::optional<CameraSpec> GetFormat();

  CameraFrame AcquireFrame(Uint64* timestampNS = nullptr);

  void ReleaseFrame(CameraFrame&& lock);
};

struct Camera : CameraBase
{
  using CameraBase::CameraBase;

  constexpr explicit Camera(CameraRaw resource) noexcept
    : CameraBase(resource)
  {
  }

  constexpr Camera(Camera&& other) noexcept
    : Camera(other.release())
  {
  }

  Camera(CameraID instance_id, OptionalRef<const CameraSpec> spec = {});

  ~Camera() { SDL_CloseCamera(get()); }

  constexpr Camera& operator=(Camera&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

class CameraFrame : public Surface
{
  CameraRef m_lock;
 
public:
  CameraFrame(CameraRef resource, Uint64* timestampNS = nullptr);

  CameraFrame(const CameraFrame& other) = delete;

  CameraFrame(CameraFrame&& other) noexcept
    : Surface(std::move(other))
    , m_lock(std::move(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;
  }

  void reset();

  CameraRef resource() const { return m_lock; }
};

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 Camera::Camera(CameraID instance_id, OptionalRef<const CameraSpec> spec)
  : Camera(SDL_OpenCamera(instance_id, spec))
{
}

inline CameraPermissionState GetCameraPermissionState(CameraRef camera)
{
  return SDL_GetCameraPermissionState(camera);
}
 
inline CameraPermissionState CameraBase::GetPermissionState()
{
  return SDL::GetCameraPermissionState(get());
}

inline CameraID GetCameraID(CameraRef camera)
{
  return CheckError(SDL_GetCameraID(camera));
}
 
inline CameraID CameraBase::GetID() { return SDL::GetCameraID(get()); }

inline PropertiesRef GetCameraProperties(CameraRef camera)
{
  return {CheckError(SDL_GetCameraProperties(camera))};
}
 
inline PropertiesRef CameraBase::GetProperties()
{
  return SDL::GetCameraProperties(get());
}

inline std::optional<CameraSpec> GetCameraFormat(CameraRef camera)
{
  if (CameraSpec spec; SDL_GetCameraFormat(camera, &spec)) return spec;
  return std::nullopt;
}
 
inline std::optional<CameraSpec> CameraBase::GetFormat()
{
  return SDL::GetCameraFormat(get());
}

inline Surface AcquireCameraFrame(CameraRef camera,
                                  Uint64* timestampNS = nullptr)
{
  return Surface::borrow(SDL_AcquireCameraFrame(camera, timestampNS));
}
 
inline CameraFrame CameraBase::AcquireFrame(Uint64* timestampNS)
{
  return {CameraRef(*this), timestampNS};
}
 
inline CameraFrame::CameraFrame(CameraRef resource, Uint64* timestampNS)
  : Surface(AcquireCameraFrame(resource, timestampNS))
  , m_lock(std::move(resource))
{
  if (!*this) m_lock.release();
}

inline void ReleaseCameraFrame(CameraRef camera, SurfaceRef frame)
{
  SDL_ReleaseCameraFrame(camera, frame);
}
 
inline void CameraBase::ReleaseFrame(CameraFrame&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(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 CameraBase::Close() { CloseCamera(release()); }

 
} // namespace SDL
 
#endif /* SDL3PP_CAMERA_H_ */