SDL3pp_image.h

#ifndef SDL3PP_IMAGE_H_
#define SDL3PP_IMAGE_H_
 
#include "SDL3pp_error.h"
#include "SDL3pp_gpu.h"
#include "SDL3pp_mouse.h"
#include "SDL3pp_render.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_version.h"
#include "SDL3pp_video.h"
 
#if defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#include <SDL3_image/SDL_image.h>
 
namespace SDL {

 
// Forward decl
struct AnimationBase;
 
// Forward decl
struct Animation;

using AnimationRaw = IMG_Animation*;

using AnimationRawConst = const IMG_Animation*;

using AnimationRef = ResourceRefT<AnimationBase>;

using AnimationConstRef = ResourceConstRef<AnimationRaw, AnimationRawConst>;
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
// Forward decl
struct AnimationEncoderBase;
 
// Forward decl
struct AnimationEncoder;

using AnimationEncoderRaw = IMG_AnimationEncoder*;

using AnimationEncoderRef = ResourceRefT<AnimationEncoderBase>;
 
// Forward decl
struct AnimationDecoderBase;
 
// Forward decl
struct AnimationDecoder;

using AnimationDecoderRaw = IMG_AnimationDecoder*;

using AnimationDecoderRef = ResourceRefT<AnimationDecoderBase>;
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
#ifdef SDL3PP_DOC

#define SDL_IMAGE_MAJOR_VERSION
 
#define SDL_IMAGE_MINOR_VERSION
 
#define SDL_IMAGE_MICRO_VERSION


#define SDL_IMAGE_VERSION                                                      \
  SDL_VERSIONNUM(                                                              \
    SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_MICRO_VERSION)

#define SDL_IMAGE_VERSION_ATLEAST(X, Y, Z)                                     \
  ((SDL_IMAGE_MAJOR_VERSION >= X) &&                                           \
   (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION >= Y) &&            \
   (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION > Y ||              \
    SDL_IMAGE_MICRO_VERSION >= Z))
 
#endif // SDL3PP_DOC
 
namespace IMG {

inline int Version() { return IMG_Version(); }
 
} // namespace IMG

inline Surface LoadSurface(StringParam file) { return Surface{IMG_Load(file)}; }
 
inline Surface::Surface(StringParam file)
  : Surface(IMG_Load(file))
{
}
 
inline Surface::Surface(IOStreamRef src, bool closeio)
  : Surface(IMG_Load_IO(src, closeio))
{
}

inline Surface LoadSurface_IO(IOStreamRef src, bool closeio = false)
{
  return Surface{IMG_Load_IO(src, closeio)};
}

inline Surface LoadSurfaceTyped_IO(IOStreamRef src,
                                   StringParam type,
                                   bool closeio = false)
{
  return Surface(IMG_LoadTyped_IO(src, closeio, type));
}

inline Texture LoadTexture(RendererRef renderer, StringParam file)
{
  return Texture(IMG_LoadTexture(renderer, file));
}
 
inline Texture::Texture(RendererRef renderer, StringParam file)
  : Texture(IMG_LoadTexture(renderer, file))
{
}
 
inline Texture::Texture(RendererRef renderer, IOStreamRef src, bool closeio)
  : Texture(IMG_LoadTexture_IO(renderer, src, closeio))
{
}

inline Texture LoadTexture_IO(RendererRef renderer,
                              IOStreamRef src,
                              bool closeio = false)
{
  return Texture(IMG_LoadTexture_IO(renderer, src, closeio));
}

inline Texture LoadTextureTyped_IO(RendererRef renderer,
                                   IOStreamRef src,
                                   StringParam type,
                                   bool closeio = false)
{
  return Texture(IMG_LoadTextureTyped_IO(renderer, src, closeio, type));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline GPUTexture LoadGPUTexture(GPUDeviceRef device,
                                 GPUCopyPass copy_pass,
                                 StringParam file,
                                 int* width = nullptr,
                                 int* height = nullptr)
{
  return IMG_LoadGPUTexture(device, copy_pass, file, width, height);
}

inline GPUTexture LoadGPUTexture_IO(GPUDeviceRef device,
                                    GPUCopyPass copy_pass,
                                    IOStreamRef src,
                                    bool closeio = false,
                                    int* width = nullptr,
                                    int* height = nullptr)
{
  return IMG_LoadGPUTexture_IO(device, copy_pass, src, closeio, width, height);
}

inline GPUTexture LoadGPUTextureTyped_IO(GPUDeviceRef device,
                                         GPUCopyPass copy_pass,
                                         IOStreamRef src,
                                         StringParam type,
                                         bool closeio = false,
                                         int* width = nullptr,
                                         int* height = nullptr)
{
  return IMG_LoadGPUTextureTyped_IO(
    device, copy_pass, src, closeio, type, width, height);
}

inline Surface GetClipboardImage() { return Surface{IMG_GetClipboardImage()}; }

inline bool isANI(IOStreamRef src) { return IMG_isANI(src); }
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline bool isAVIF(IOStreamRef src) { return IMG_isAVIF(src); }

inline bool isCUR(IOStreamRef src) { return IMG_isCUR(src); }

inline bool isBMP(IOStreamRef src) { return IMG_isBMP(src); }

inline bool isGIF(IOStreamRef src) { return IMG_isGIF(src); }

inline bool isICO(IOStreamRef src) { return IMG_isICO(src); }

inline bool isJPG(IOStreamRef src) { return IMG_isJPG(src); }

inline bool isJXL(IOStreamRef src) { return IMG_isJXL(src); }

inline bool isLBM(IOStreamRef src) { return IMG_isLBM(src); }

inline bool isPCX(IOStreamRef src) { return IMG_isPCX(src); }

inline bool isPNG(IOStreamRef src) { return IMG_isPNG(src); }

inline bool isPNM(IOStreamRef src) { return IMG_isPNM(src); }

inline bool isQOI(IOStreamRef src) { return IMG_isQOI(src); }

inline bool isSVG(IOStreamRef src) { return IMG_isSVG(src); }

inline bool isTIF(IOStreamRef src) { return IMG_isTIF(src); }

inline bool isWEBP(IOStreamRef src) { return IMG_isWEBP(src); }

inline bool isXCF(IOStreamRef src) { return IMG_isXCF(src); }

inline bool isXPM(IOStreamRef src) { return IMG_isXPM(src); }

inline bool isXV(IOStreamRef src) { return IMG_isXV(src); }

inline Surface LoadAVIF_IO(IOStreamRef src)
{
  return Surface(IMG_LoadAVIF_IO(src));
}

inline Surface LoadCUR_IO(IOStreamRef src)
{
  return Surface{IMG_LoadCUR_IO(src)};
}

inline Surface LoadGIF_IO(IOStreamRef src)
{
  return Surface{IMG_LoadGIF_IO(src)};
}

inline Surface LoadICO_IO(IOStreamRef src)
{
  return Surface{IMG_LoadICO_IO(src)};
}

inline Surface LoadJPG_IO(IOStreamRef src)
{
  return Surface{IMG_LoadJPG_IO(src)};
}

inline Surface LoadJXL_IO(IOStreamRef src)
{
  return Surface{IMG_LoadJXL_IO(src)};
}

inline Surface LoadLBM_IO(IOStreamRef src)
{
  return Surface{IMG_LoadLBM_IO(src)};
}

inline Surface LoadPCX_IO(IOStreamRef src)
{
  return Surface{IMG_LoadPCX_IO(src)};
}

inline Surface LoadPNG_IO(IOStreamRef src)
{
  return Surface{IMG_LoadPNG_IO(src)};
}

inline Surface LoadPNG_IO(IOStreamRef src, bool closeio)
{
  if (!closeio) return Surface{LoadPNG_IO(src)};
  Surface temp{LoadPNG_IO(src)};
  src.Close();
  return temp;
}

inline Surface LoadPNG(StringParam file)
{
  return LoadPNG_IO(IOFromFile(std::move(file), "rb"));
}

inline Surface LoadPNM_IO(IOStreamRef src)
{
  return Surface{IMG_LoadPNM_IO(src)};
}

inline Surface LoadSVG_IO(IOStreamRef src)
{
  return Surface{IMG_LoadSVG_IO(src)};
}

inline Surface LoadSizedSVG_IO(IOStreamRef src, const PointRaw& size)
{
  return Surface{IMG_LoadSizedSVG_IO(src, size.x, size.y)};
}

inline Surface LoadQOI_IO(IOStreamRef src)
{
  return Surface{IMG_LoadQOI_IO(src)};
}

inline Surface LoadTGA_IO(IOStreamRef src)
{
  return Surface{IMG_LoadTGA_IO(src)};
}

inline Surface LoadTIF_IO(IOStreamRef src)
{
  return Surface{IMG_LoadTIF_IO(src)};
}

inline Surface LoadWEBP_IO(IOStreamRef src)
{
  return Surface{IMG_LoadWEBP_IO(src)};
}

inline Surface LoadXCF_IO(IOStreamRef src)
{
  return Surface{IMG_LoadXCF_IO(src)};
}

inline Surface LoadXPM_IO(IOStreamRef src)
{
  return Surface{IMG_LoadXPM_IO(src)};
}

inline Surface LoadXV_IO(IOStreamRef src)
{
  return Surface{IMG_LoadXV_IO(src)};
}

inline Surface ReadXPMFromArray(char** xpm)
{
  return Surface{IMG_ReadXPMFromArray(xpm)};
}

inline Surface ReadXPMFromArrayToRGB888(char** xpm)
{
  return Surface{IMG_ReadXPMFromArrayToRGB888(xpm)};
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void Save(SurfaceConstRef surface, StringParam file)
{
  CheckError(IMG_Save(surface, file));
}
 
inline void SurfaceBase::Save(StringParam filename) const
{
  SDL::Save(*this, std::move(filename));
}

inline void SaveTyped_IO(SurfaceConstRef surface,
                         IOStreamRef dst,
                         StringParam type,
                         bool closeio = false)
{
  CheckError(IMG_SaveTyped_IO(surface, dst, closeio, type));
}
 
inline void SurfaceBase::SaveTyped_IO(IOStreamRef dst,
                                      StringParam type,
                                      bool closeio) const
{
  SDL::SaveTyped_IO(*this, dst, std::move(type), closeio);
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void SaveAVIF(SurfaceRef surface, StringParam file, int quality)
{
  CheckError(IMG_SaveAVIF(surface, file, quality));
}

inline void SaveAVIF_IO(SurfaceRef surface,
                        IOStreamRef dst,
                        int quality,
                        bool closeio = false)
{
  CheckError(IMG_SaveAVIF_IO(surface, dst, closeio, quality));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void SaveCUR(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SaveCUR(surface, file));
}

inline void SaveCUR_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(IMG_SaveCUR_IO(surface, dst, closeio));
}

inline void SaveGIF(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SaveGIF(surface, file));
}

inline void SaveGIF_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(IMG_SaveGIF_IO(surface, dst, closeio));
}

inline void SaveICO(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SaveICO(surface, file));
}

inline void SaveICO_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(IMG_SaveICO_IO(surface, dst, closeio));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void SaveJPG(SurfaceRef surface, StringParam file, int quality)
{
  CheckError(IMG_SaveJPG(surface, file, quality));
}

inline void SaveJPG_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       int quality,
                       bool closeio = false)
{
  CheckError(IMG_SaveJPG_IO(surface, dst, closeio, quality));
}

inline void SavePNG(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SavePNG(surface, file));
}
 
inline void SurfaceBase::SavePNG(StringParam file) const
{
  SDL::SavePNG(get(), std::move(file));
}

inline void SavePNG_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(IMG_SavePNG_IO(surface, dst, closeio));
}
 
inline void SurfaceBase::SavePNG_IO(IOStreamRef dst, bool closeio) const
{
  SDL::SavePNG_IO(get(), dst, closeio);
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void SaveTGA(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SaveTGA(surface, file));
}

inline void SaveTGA_IO(SurfaceRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(IMG_SaveTGA_IO(surface, dst, closeio));
}

inline void SaveWEBP(SurfaceRef surface, StringParam file, float quality)
{
  CheckError(IMG_SaveWEBP(surface, file, quality));
}

inline void SaveWEBP_IO(SurfaceRef surface,
                        IOStreamRef dst,
                        float quality,
                        bool closeio = false)
{
  CheckError(IMG_SaveWEBP_IO(surface, dst, closeio, quality));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

struct AnimationBase : ResourceBaseT<AnimationRaw, AnimationRawConst>
{
  using ResourceBaseT::ResourceBaseT;

  constexpr operator AnimationConstRef() const noexcept { return get(); }

  void Free();

  int GetWidth() const;

  int GetHeight() const;

  Point GetSize() const;

  int GetCount() const;

  Surface GetFrame(int index) const;

  int GetDelay(int index) const;
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

  void Save(StringParam file);

  void SaveTyped_IO(IOStreamRef dst, StringParam type, bool closeio = false);

  void SaveANI_IO(IOStreamRef dst, bool closeio = false);

  void SaveAPNG_IO(IOStreamRef dst, bool closeio = false);

  void SaveAVIF_IO(IOStreamRef dst, int quality, bool closeio = false);

  void SaveGIF_IO(IOStreamRef dst, bool closeio = false);

  void SaveWEBP_IO(IOStreamRef dst, int quality, bool closeio = false);

  Cursor CreateCursor(const PointRaw& hotspot);
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
};

struct Animation : AnimationBase
{
  using AnimationBase::AnimationBase;

  constexpr explicit Animation(AnimationRaw resource) noexcept
    : AnimationBase(resource)
  {
  }

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

  Animation(StringParam file);

  Animation(IOStreamRef src, bool closeio = false);

  ~Animation() { IMG_FreeAnimation(get()); }

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

inline int GetAnimationWidth(AnimationConstRef anim) { return anim->w; }
 
inline int AnimationBase::GetWidth() const
{
  return SDL::GetAnimationWidth(get());
}

inline int GetAnimationHeight(AnimationConstRef anim) { return anim->h; }
 
inline int AnimationBase::GetHeight() const
{
  return SDL::GetAnimationHeight(get());
}

inline Point GetAnimationSize(AnimationConstRef anim)
{
  return {anim->w, anim->h};
}
 
inline Point AnimationBase::GetSize() const
{
  return SDL::GetAnimationSize(get());
}

inline int GetAnimationCount(AnimationConstRef anim) { return anim->count; }
 
inline int AnimationBase::GetCount() const
{
  return SDL::GetAnimationCount(get());
}

inline Surface GetAnimationFrame(AnimationConstRef anim, int index)
{
  return Surface::borrow(anim->frames[index]);
}
 
inline Surface AnimationBase::GetFrame(int index) const
{
  return SDL::GetAnimationFrame(get(), index);
}

inline int GetAnimationDelay(AnimationConstRef anim, int index)
{
  return anim->delays[index];
}
 
inline int AnimationBase::GetDelay(int index) const
{
  return SDL::GetAnimationDelay(get(), index);
}

inline Animation LoadAnimation(StringParam file)
{
  return Animation(std::move(file));
}
 
inline Animation::Animation(StringParam file)
  : Animation(IMG_LoadAnimation(file))
{
}
 
inline Animation::Animation(IOStreamRef src, bool closeio)
  : Animation(IMG_LoadAnimation_IO(src, closeio))
{
}

inline Animation LoadAnimation_IO(IOStreamRef src, bool closeio = false)
{
  return Animation(src, closeio);
}

inline Animation LoadAnimationTyped_IO(IOStreamRef src,
                                       StringParam type,
                                       bool closeio = false)
{
  return Animation(IMG_LoadAnimationTyped_IO(src, closeio, type));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline Animation LoadANIAnimation_IO(IOStreamRef src)
{
  return Animation(IMG_LoadANIAnimation_IO(src));
}

inline Animation LoadAPNGAnimation_IO(IOStreamRef src)
{
  return Animation(IMG_LoadAPNGAnimation_IO(src));
}

inline Animation LoadAVIFAnimation_IO(IOStreamRef src)
{
  return Animation(IMG_LoadAVIFAnimation_IO(src));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline Animation LoadGIFAnimation_IO(IOStreamRef src)
{
  return Animation(IMG_LoadGIFAnimation_IO(src));
}

inline Animation LoadWEBPAnimation_IO(IOStreamRef src)
{
  return Animation{IMG_LoadWEBPAnimation_IO(src)};
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void SaveAnimation(AnimationRef anim, StringParam file)
{
  CheckError(IMG_SaveAnimation(anim, file));
}
 
inline void AnimationBase::Save(StringParam file)
{
  SDL::SaveAnimation(get(), std::move(file));
}

inline void SaveAnimationTyped_IO(AnimationRef anim,
                                  IOStreamRef dst,
                                  StringParam type,
                                  bool closeio = false)
{
  CheckError(IMG_SaveAnimationTyped_IO(anim, dst, closeio, type));
}
 
inline void AnimationBase::SaveTyped_IO(IOStreamRef dst,
                                        StringParam type,
                                        bool closeio)
{
  SDL::SaveAnimationTyped_IO(get(), dst, std::move(type), closeio);
}

inline void SaveANIAnimation_IO(AnimationRef anim,
                                IOStreamRef dst,
                                bool closeio = false)
{
  CheckError(IMG_SaveANIAnimation_IO(anim, dst, closeio));
}
 
inline void AnimationBase::SaveANI_IO(IOStreamRef dst, bool closeio)
{
  SDL::SaveANIAnimation_IO(get(), dst, closeio);
}

inline void SaveAPNGAnimation_IO(AnimationRef anim,
                                 IOStreamRef dst,
                                 bool closeio = false)
{
  CheckError(IMG_SaveAPNGAnimation_IO(anim, dst, closeio));
}
 
inline void AnimationBase::SaveAPNG_IO(IOStreamRef dst, bool closeio)
{
  SDL::SaveAPNGAnimation_IO(get(), dst, closeio);
}

inline void SaveAVIFAnimation_IO(AnimationRef anim,
                                 IOStreamRef dst,
                                 int quality,
                                 bool closeio = false)
{
  CheckError(IMG_SaveAVIFAnimation_IO(anim, dst, closeio, quality));
}
 
inline void AnimationBase::SaveAVIF_IO(IOStreamRef dst,
                                       int quality,
                                       bool closeio)
{
  SDL::SaveAVIFAnimation_IO(get(), dst, quality, closeio);
}

inline void SaveGIFAnimation_IO(AnimationRef anim,
                                IOStreamRef dst,
                                bool closeio = false)
{
  CheckError(IMG_SaveGIFAnimation_IO(anim, dst, closeio));
}
 
inline void AnimationBase::SaveGIF_IO(IOStreamRef dst, bool closeio)
{
  SDL::SaveGIFAnimation_IO(get(), dst, closeio);
}

inline void SaveWEBPAnimation_IO(AnimationRef anim,
                                 IOStreamRef dst,
                                 int quality,
                                 bool closeio = false)
{
  CheckError(IMG_SaveWEBPAnimation_IO(anim, dst, closeio, quality));
}
 
inline void AnimationBase::SaveWEBP_IO(IOStreamRef dst,
                                       int quality,
                                       bool closeio)
{
  SDL::SaveWEBPAnimation_IO(get(), dst, quality, closeio);
}

inline Cursor CreateAnimatedCursor(AnimationRef anim, const PointRaw& hotspot)
{
  return Cursor(
    CheckError(IMG_CreateAnimatedCursor(anim, hotspot.x, hotspot.y)));
}
 
inline Cursor AnimationBase::CreateCursor(const PointRaw& hotspot)
{
  return SDL::CreateAnimatedCursor(get(), hotspot);
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

inline void FreeAnimation(AnimationRaw anim) { IMG_FreeAnimation(anim); }
 
inline void AnimationBase::Free() { FreeAnimation(release()); }
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

struct AnimationEncoderBase : ResourceBaseT<AnimationEncoderRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  void AddFrame(SurfaceRef surface, Uint64 duration);
};

struct AnimationEncoder : AnimationEncoderBase
{
  using AnimationEncoderBase::AnimationEncoderBase;

  constexpr explicit AnimationEncoder(AnimationEncoderRaw resource) noexcept
    : AnimationEncoderBase(resource)
  {
  }

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

  AnimationEncoder(StringParam file);

  AnimationEncoder(IOStreamRef dst, StringParam type, bool closeio = false);

  AnimationEncoder(PropertiesRef props);

  ~AnimationEncoder() { IMG_CloseAnimationEncoder(get()); }

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

inline AnimationEncoder CreateAnimationEncoder(StringParam file)
{
  return AnimationEncoder(std::move(file));
}
 
inline AnimationEncoder::AnimationEncoder(StringParam file)
  : AnimationEncoder(CheckError(IMG_CreateAnimationEncoder(file)))
{
}
 
inline AnimationEncoder::AnimationEncoder(IOStreamRef dst,
                                          StringParam type,
                                          bool closeio)
  : AnimationEncoder(
      CheckError(IMG_CreateAnimationEncoder_IO(dst, closeio, type)))
{
}
 
inline AnimationEncoder::AnimationEncoder(PropertiesRef props)
  : AnimationEncoder(
      CheckError(IMG_CreateAnimationEncoderWithProperties(props)))
{
}

inline AnimationEncoder CreateAnimationEncoder_IO(IOStreamRef dst,
                                                  StringParam type,
                                                  bool closeio = false)
{
  return AnimationEncoder(dst, std::move(type), closeio);
}

inline AnimationEncoder CreateAnimationEncoderWithProperties(
  PropertiesRef props)
{
  return AnimationEncoder(props);
}

namespace prop::AnimationEncoder::Create {
 
constexpr auto FILENAME_STRING =
  IMG_PROP_ANIMATION_ENCODER_CREATE_FILENAME_STRING; 
 
constexpr auto IOSTREAM_POINTER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_IOSTREAM_POINTER; 
 
constexpr auto IOSTREAM_AUTOCLOSE_BOOLEAN =
  IMG_PROP_ANIMATION_ENCODER_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN; 
 
constexpr auto TYPE_STRING =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TYPE_STRING; 
 
constexpr auto QUALITY_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_QUALITY_NUMBER; 
 
constexpr auto TIMEBASE_NUMERATOR_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TIMEBASE_NUMERATOR_NUMBER; 
 
constexpr auto TIMEBASE_DENOMINATOR_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TIMEBASE_DENOMINATOR_NUMBER; 
 
constexpr auto AVIF_MAX_THREADS_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_AVIF_MAX_THREADS_NUMBER; 
 
constexpr auto AVIF_KEYFRAME_INTERVAL_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_AVIF_KEYFRAME_INTERVAL_NUMBER; 
 
constexpr auto GIF_USE_LUT_BOOLEAN =
  IMG_PROP_ANIMATION_ENCODER_CREATE_GIF_USE_LUT_BOOLEAN; 
 
} // namespace prop::AnimationEncoder::Create

inline void AddAnimationEncoderFrame(AnimationEncoderRef encoder,
                                     SurfaceRef surface,
                                     Uint64 duration)
{
  CheckError(IMG_AddAnimationEncoderFrame(encoder, surface, duration));
}
 
inline void AnimationEncoderBase::AddFrame(SurfaceRef surface, Uint64 duration)
{
  SDL::AddAnimationEncoderFrame(get(), surface, duration);
}

inline void CloseAnimationEncoder(AnimationEncoderRaw encoder)
{
  CheckError(IMG_CloseAnimationEncoder(encoder));
}
 
inline void AnimationEncoderBase::Close() { CloseAnimationEncoder(release()); }

using AnimationDecoderStatus = IMG_AnimationDecoderStatus;
 
constexpr AnimationDecoderStatus DECODER_STATUS_INVALID =
  IMG_DECODER_STATUS_INVALID; 
 
constexpr AnimationDecoderStatus DECODER_STATUS_OK =
  IMG_DECODER_STATUS_OK; 

constexpr AnimationDecoderStatus DECODER_STATUS_FAILED =
  IMG_DECODER_STATUS_FAILED;
 
constexpr AnimationDecoderStatus DECODER_STATUS_COMPLETE =
  IMG_DECODER_STATUS_COMPLETE; 

struct AnimationDecoderBase : ResourceBaseT<AnimationDecoderRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  PropertiesRef GetProperties();

  Surface GetFrame(Uint64* duration);

  AnimationDecoderStatus GetStatus();

  void Reset();
};

struct AnimationDecoder : AnimationDecoderBase
{
  using AnimationDecoderBase::AnimationDecoderBase;

  constexpr explicit AnimationDecoder(AnimationDecoderRaw resource) noexcept
    : AnimationDecoderBase(resource)
  {
  }

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

  AnimationDecoder(StringParam file);

  AnimationDecoder(IOStreamRef src, StringParam type, bool closeio = false);

  AnimationDecoder(PropertiesRef props);

  ~AnimationDecoder() { IMG_CloseAnimationDecoder(get()); }

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

inline AnimationDecoder CreateAnimationDecoder(StringParam file)
{
  return AnimationDecoder(std::move(file));
}
 
inline AnimationDecoder::AnimationDecoder(StringParam file)
  : AnimationDecoder(CheckError(IMG_CreateAnimationDecoder(file)))
{
}
 
inline AnimationDecoder::AnimationDecoder(IOStreamRef src,
                                          StringParam type,
                                          bool closeio)
  : AnimationDecoder(
      CheckError(IMG_CreateAnimationDecoder_IO(src, closeio, type)))
{
}
 
inline AnimationDecoder::AnimationDecoder(PropertiesRef props)
  : AnimationDecoder(
      CheckError(IMG_CreateAnimationDecoderWithProperties(props)))
{
}

inline AnimationDecoder CreateAnimationDecoder_IO(IOStreamRef src,
                                                  StringParam type,
                                                  bool closeio = false)
{
  return AnimationDecoder(src, std::move(type), closeio);
}

inline AnimationDecoder CreateAnimationDecoderWithProperties(
  PropertiesRef props)
{
  return AnimationDecoder(props);
}

namespace prop::AnimationDecoder::Create {
 
constexpr auto FILENAME_STRING =
  IMG_PROP_ANIMATION_DECODER_CREATE_FILENAME_STRING; 
 
constexpr auto IOSTREAM_POINTER =
  IMG_PROP_ANIMATION_DECODER_CREATE_IOSTREAM_POINTER; 
 
constexpr auto IOSTREAM_AUTOCLOSE_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN; 
 
constexpr auto TYPE_STRING =
  IMG_PROP_ANIMATION_DECODER_CREATE_TYPE_STRING; 
 
constexpr auto TIMEBASE_NUMERATOR_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_TIMEBASE_NUMERATOR_NUMBER; 
 
constexpr auto TIMEBASE_DENOMINATOR_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_TIMEBASE_DENOMINATOR_NUMBER; 
 
constexpr auto AVIF_MAX_THREADS_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_MAX_THREADS_NUMBER; 
 
constexpr auto AVIF_ALLOW_INCREMENTAL_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_ALLOW_INCREMENTAL_BOOLEAN; 
 
constexpr auto AVIF_ALLOW_PROGRESSIVE_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_ALLOW_PROGRESSIVE_BOOLEAN; 
 
constexpr auto GIF_TRANSPARENT_COLOR_INDEX_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_GIF_TRANSPARENT_COLOR_INDEX_NUMBER; 
 
constexpr auto GIF_NUM_COLORS_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_GIF_NUM_COLORS_NUMBER; 
 
} // namespace prop::AnimationDecoder::Create

inline PropertiesRef GetAnimationDecoderProperties(AnimationDecoderRef decoder)
{
  return IMG_GetAnimationDecoderProperties(decoder);
}
 
inline PropertiesRef AnimationDecoderBase::GetProperties()
{
  return SDL::GetAnimationDecoderProperties(get());
}

namespace prop::AnimationDecoder::Metadata {
 
constexpr auto IGNORE_PROPS_BOOLEAN =
  IMG_PROP_METADATA_IGNORE_PROPS_BOOLEAN; 
 
constexpr auto DESCRIPTION_STRING =
  IMG_PROP_METADATA_DESCRIPTION_STRING; 
 
constexpr auto COPYRIGHT_STRING =
  IMG_PROP_METADATA_COPYRIGHT_STRING; 
 
constexpr auto TITLE_STRING =
  IMG_PROP_METADATA_TITLE_STRING; 
 
constexpr auto AUTHOR_STRING =
  IMG_PROP_METADATA_AUTHOR_STRING; 
 
constexpr auto CREATION_TIME_STRING =
  IMG_PROP_METADATA_CREATION_TIME_STRING; 
 
constexpr auto FRAME_COUNT_NUMBER =
  IMG_PROP_METADATA_FRAME_COUNT_NUMBER; 
 
constexpr auto LOOP_COUNT_NUMBER =
  IMG_PROP_METADATA_LOOP_COUNT_NUMBER; 
 
} // namespace prop::AnimationDecoder::Metadata

inline Surface GetAnimationDecoderFrame(AnimationDecoderRef decoder,
                                        Uint64* duration)
{
  SDL_Surface* frame = nullptr;
  CheckError(IMG_GetAnimationDecoderFrame(decoder, &frame, duration));
  return Surface::borrow(frame);
}
 
inline Surface AnimationDecoderBase::GetFrame(Uint64* duration)
{
  return SDL::GetAnimationDecoderFrame(get(), duration);
}

inline AnimationDecoderStatus GetAnimationDecoderStatus(
  AnimationDecoderRef decoder)
{
  return IMG_GetAnimationDecoderStatus(decoder);
}
 
inline AnimationDecoderStatus AnimationDecoderBase::GetStatus()
{
  return SDL::GetAnimationDecoderStatus(get());
}

inline void ResetAnimationDecoder(AnimationDecoderRef decoder)
{
  CheckError(IMG_ResetAnimationDecoder(decoder));
}
 
inline void AnimationDecoderBase::Reset() { SDL::ResetAnimationDecoder(get()); }

inline void CloseAnimationDecoder(AnimationDecoderRaw decoder)
{
  CheckError(IMG_CloseAnimationDecoder(decoder));
}
 
inline void AnimationDecoderBase::Close() { CloseAnimationDecoder(release()); }
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)

 
} // namespace SDL
 
#else // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
namespace SDL {
 
inline Surface::Surface(StringParam file)
  : Surface(LoadBMP(std::move(file)))
{
}
 
inline Surface::Surface(IOStreamRef src, bool closeio)
  : Surface(LoadBMP_IO(std::move(src), closeio))
{
}
 
inline Texture::Texture(RendererRef renderer, StringParam file)
  : Texture(std::move(renderer), Surface(std::move(file)))
{
}
 
inline Texture::Texture(RendererRef renderer, IOStreamRef src, bool closeio)
  : Texture(std::move(renderer), Surface(std::move(src), closeio))
{
}
 
} // namespace SDL
 
#endif // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_IMAGE_H_ */