From dc9a0809953aa965c66d4f6c10b7e6a634f593b0 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 10 Feb 2025 13:38:30 +0100 Subject: [PATCH 1/4] Add SDL3_image unit --- units/SDL3_image.pas | 2220 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2220 insertions(+) create mode 100644 units/SDL3_image.pas diff --git a/units/SDL3_image.pas b/units/SDL3_image.pas new file mode 100644 index 0000000..cec46f5 --- /dev/null +++ b/units/SDL3_image.pas @@ -0,0 +1,2220 @@ +unit SDL3_image; + +{ + This file is part of: + + SDL3 for Pascal + (https://github.com/PascalGameDevelopment/SDL3-for-Pascal) + SPDX-License-Identifier: Zlib +} + +{* + * # CategorySDLImage + * + * Header file for SDL_image library + * + * A simple library to load images of various formats as SDL surfaces + } + +{$DEFINE SDL_IMAGE} + +{$I sdl.inc} + +interface + + {$IFDEF WINDOWS} + uses + SDL3, + {$IFDEF FPC} + ctypes, + {$ENDIF} + Windows; + {$ENDIF} + + {$IF DEFINED(UNIX) AND NOT DEFINED(ANDROID)} + uses + SDL3, + {$IFDEF FPC} + ctypes, + UnixType, + {$ENDIF} + {$IFDEF DARWIN} + CocoaAll; + {$ELSE} + X, + XLib; + {$ENDIF} + {$ENDIF} + + {$IF DEFINED(UNIX) AND DEFINED(ANDROID) AND DEFINED(FPC)} + uses + SDL3, + ctypes, + UnixType; + {$ENDIF} + +const + + {$IFDEF WINDOWS} + IMG_LibName = 'SDL3_image.dll'; + {$ENDIF} + + {$IFDEF UNIX} + {$IFDEF DARWIN} + IMG_LibName = 'libSDL3_image.dylib'; + {$IFDEF FPC} + {$LINKLIB libSDL2} + {$ENDIF} + {$ELSE} + {$IFDEF FPC} + IMG_LibName = 'libSDL3_image.so'; + {$ELSE} + IMG_LibName = 'libSDL3_image.so.0'; + {$ENDIF} + {$ENDIF} + {$ENDIF} + + {$IFDEF MACOS} + IMG_LibName = 'SDL3_image'; + {$IFDEF FPC} + {$linklib libSDL3} + {$ENDIF} + {$ENDIF} + +{* + * Printable format: "%d.%d.%d", MAJOR, MINOR, MICRO + } + +const + SDL_IMAGE_MAJOR_VERSION = 3; + SDL_IMAGE_MINOR_VERSION = 2; + SDL_IMAGE_MICRO_VERSION = 0; + +{* + * This is the version number macro for the current SDL_image version. + } +function SDL_IMAGE_VERSION: Integer; + +{* + * This macro will evaluate to true if compiled with SDL_image at least X.Y.Z. + } +function SDL_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; + +{* + * This function gets the version of the dynamically linked SDL_image library. + * + * \returns SDL_image version. + * + * \since This function is available since SDL_image 3.0.0. + } +function IMG_Version: cint; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Version' {$ENDIF} {$ENDIF}; + +{* + * Load an image from an SDL data source into a software surface. + * + * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use + * this if you plan to hand the data to something else or manipulate it + * further in code. + * + * There are no guarantees about what format the new SDL_Surface data will be; + * in many cases, SDL_image will attempt to supply a surface that exactly + * matches the provided image, but in others it might have to convert (either + * because the image is in a format that SDL doesn't directly support or + * because it's compressed data that could reasonably uncompress to various + * formats and SDL_image had to pick one). You can inspect an SDL_Surface for + * its specifics, and use SDL_ConvertSurface to then migrate to any supported + * format. + * + * If the image format supports a transparent pixel, SDL will set the colorkey + * for the surface. You can enable RLE acceleration on the surface afterwards + * by calling: SDL_SetSurfaceColorKey(image, SDL_RLEACCEL, + * image->format->colorkey); + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * Even though this function accepts a file type, SDL_image may still try + * other decoders that are capable of detecting file type from the contents of + * the image data, but may rely on the caller-provided type string for formats + * that it cannot autodetect. If `type` is nil, SDL_image will rely solely on + * its ability to guess the format. + * + * There is a separate function to read files from disk without having to deal + * with SDL_IOStream: `IMG_Load("filename.jpg")` will call this function and + * manage those details for you, determining the file type from the filename's + * extension. + * + * There is also IMG_Load_IO(), which is equivalent to this function except + * that it will rely on SDL_image to determine what type of data it is + * loading, much like passing a nil for type. + * + * If you are using SDL's 2D rendering API, there is an equivalent call to + * load images directly into an SDL_Texture for use by the GPU without using a + * software surface: call IMG_LoadTextureTyped_IO() instead. + * + * When done with the returned surface, the app should dispose of it with a + * call to SDL_DestroySurface(). + * + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \param type a filename extension that represent this data ("BMP", "GIF", + * "PNG", etc). + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_Load + * \sa IMG_Load_IO + * \sa SDL_DestroySurface + } +function IMG_LoadTyped_IO(src: PSDL_IOStream; closeio: cbool; type_: PAnsiChar): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTyped_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an image from a filesystem path into a software surface. + * + * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use + * this if you plan to hand the data to something else or manipulate it + * further in code. + * + * There are no guarantees about what format the new SDL_Surface data will be; + * in many cases, SDL_image will attempt to supply a surface that exactly + * matches the provided image, but in others it might have to convert (either + * because the image is in a format that SDL doesn't directly support or + * because it's compressed data that could reasonably uncompress to various + * formats and SDL_image had to pick one). You can inspect an SDL_Surface for + * its specifics, and use SDL_ConvertSurface to then migrate to any supported + * format. + * + * If the image format supports a transparent pixel, SDL will set the colorkey + * for the surface. You can enable RLE acceleration on the surface afterwards + * by calling: SDL_SetSurfaceColorKey(image, SDL_RLEACCEL, + * image->format->colorkey); + * + * There is a separate function to read files from an SDL_IOStream, if you + * need an i/o abstraction to provide data from anywhere instead of a simple + * filesystem read; that function is IMG_Load_IO(). + * + * If you are using SDL's 2D rendering API, there is an equivalent call to + * load images directly into an SDL_Texture for use by the GPU without using a + * software surface: call IMG_LoadTexture() instead. + * + * When done with the returned surface, the app should dispose of it with a + * call to + * [SDL_DestroySurface](https://wiki.libsdl.org/SDL3/SDL_DestroySurface) + * (). + * + * \param file a path on the filesystem to load an image from. + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadTyped_IO + * \sa IMG_Load_IO + * \sa SDL_DestroySurface + } +function IMG_Load(file_: PAnsiChar): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load' {$ENDIF} {$ENDIF}; + +{* + * Load an image from an SDL data source into a software surface. + * + * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use + * this if you plan to hand the data to something else or manipulate it + * further in code. + * + * There are no guarantees about what format the new SDL_Surface data will be; + * in many cases, SDL_image will attempt to supply a surface that exactly + * matches the provided image, but in others it might have to convert (either + * because the image is in a format that SDL doesn't directly support or + * because it's compressed data that could reasonably uncompress to various + * formats and SDL_image had to pick one). You can inspect an SDL_Surface for + * its specifics, and use SDL_ConvertSurface to then migrate to any supported + * format. + * + * If the image format supports a transparent pixel, SDL will set the colorkey + * for the surface. You can enable RLE acceleration on the surface afterwards + * by calling: SDL_SetSurfaceColorKey(image, SDL_RLEACCEL, + * image->format->colorkey); + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * There is a separate function to read files from disk without having to deal + * with SDL_IOStream: `IMG_Load("filename.jpg")` will call this function and + * manage those details for you, determining the file type from the filename's + * extension. + * + * There is also IMG_LoadTyped_IO(), which is equivalent to this function + * except a file extension (like "BMP", "JPG", etc) can be specified, in case + * SDL_image cannot autodetect the file format. + * + * If you are using SDL's 2D rendering API, there is an equivalent call to + * load images directly into an SDL_Texture for use by the GPU without using a + * software surface: call IMG_LoadTexture_IO() instead. + * + * When done with the returned surface, the app should dispose of it with a + * call to SDL_DestroySurface(). + * + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_Load + * \sa IMG_LoadTyped_IO + * \sa SDL_DestroySurface + } +function IMG_Load_IO(src: PSDL_IOStream; closeio: cbool): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an image from a filesystem path into a GPU texture. + * + * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render + * API. This can be significantly more efficient than using a CPU-bound + * SDL_Surface if you don't need to manipulate the image directly after + * loading it. + * + * If the loaded image has transparency or a colorkey, a texture with an alpha + * channel will be created. Otherwise, SDL_image will attempt to create an + * SDL_Texture in the most format that most reasonably represents the image + * data (but in many cases, this will just end up being 32-bit RGB or 32-bit + * RGBA). + * + * There is a separate function to read files from an SDL_IOStream, if you + * need an i/o abstraction to provide data from anywhere instead of a simple + * filesystem read; that function is IMG_LoadTexture_IO(). + * + * If you would rather decode an image to an SDL_Surface (a buffer of pixels + * in CPU memory), call IMG_Load() instead. + * + * When done with the returned texture, the app should dispose of it with a + * call to SDL_DestroyTexture(). + * + * \param renderer the SDL_Renderer to use to create the GPU texture. + * \param file a path on the filesystem to load an image from. + * \returns a new texture, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadTextureTyped_IO + * \sa IMG_LoadTexture_IO + } +function IMG_LoadTexture(renderer: PSDL_Renderer; file_: PAnsiChar): PSDL_Texture; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture' {$ENDIF} {$ENDIF}; + +{* + * Load an image from an SDL data source into a GPU texture. + * + * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render + * API. This can be significantly more efficient than using a CPU-bound + * SDL_Surface if you don't need to manipulate the image directly after + * loading it. + * + * If the loaded image has transparency or a colorkey, a texture with an alpha + * channel will be created. Otherwise, SDL_image will attempt to create an + * SDL_Texture in the most format that most reasonably represents the image + * data (but in many cases, this will just end up being 32-bit RGB or 32-bit + * RGBA). + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * There is a separate function to read files from disk without having to deal + * with SDL_IOStream: `IMG_LoadTexture(renderer, "filename.jpg")` will call + * this function and manage those details for you, determining the file type + * from the filename's extension. + * + * There is also IMG_LoadTextureTyped_IO(), which is equivalent to this + * function except a file extension (like "BMP", "JPG", etc) can be specified, + * in case SDL_image cannot autodetect the file format. + * + * If you would rather decode an image to an SDL_Surface (a buffer of pixels + * in CPU memory), call IMG_Load() instead. + * + * When done with the returned texture, the app should dispose of it with a + * call to SDL_DestroyTexture(). + * + * \param renderer the SDL_Renderer to use to create the GPU texture. + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \returns a new texture, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadTexture + * \sa IMG_LoadTextureTyped_IO + * \sa SDL_DestroyTexture + } +function IMG_LoadTexture_IO(renderer: PSDL_Renderer; src: PSDL_IOStream; closeio: cbool): PSDL_Texture; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an image from an SDL data source into a GPU texture. + * + * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render + * API. This can be significantly more efficient than using a CPU-bound + * SDL_Surface if you don't need to manipulate the image directly after + * loading it. + * + * If the loaded image has transparency or a colorkey, a texture with an alpha + * channel will be created. Otherwise, SDL_image will attempt to create an + * SDL_Texture in the most format that most reasonably represents the image + * data (but in many cases, this will just end up being 32-bit RGB or 32-bit + * RGBA). + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * Even though this function accepts a file type, SDL_image may still try + * other decoders that are capable of detecting file type from the contents of + * the image data, but may rely on the caller-provided type string for formats + * that it cannot autodetect. If `type` is nil, SDL_image will rely solely on + * its ability to guess the format. + * + * There is a separate function to read files from disk without having to deal + * with SDL_IOStream: `IMG_LoadTexture("filename.jpg")` will call this + * function and manage those details for you, determining the file type from + * the filename's extension. + * + * There is also IMG_LoadTexture_IO(), which is equivalent to this function + * except that it will rely on SDL_image to determine what type of data it is + * loading, much like passing a nil for type. + * + * If you would rather decode an image to an SDL_Surface (a buffer of pixels + * in CPU memory), call IMG_LoadTyped_IO() instead. + * + * When done with the returned texture, the app should dispose of it with a + * call to SDL_DestroyTexture(). + * + * \param renderer the SDL_Renderer to use to create the GPU texture. + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \param type a filename extension that represent this data ("BMP", "GIF", + * "PNG", etc). + * \returns a new texture, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadTexture + * \sa IMG_LoadTexture_IO + * \sa SDL_DestroyTexture + } +function IMG_LoadTextureTyped_IO(renderer: PSDL_Renderer; src: PSDL_IOStream; closeio: cbool; type_: PAnsiChar): PSDL_Texture; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTextureTyped_IO' {$ENDIF} {$ENDIF}; + +{* + * Detect AVIF image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is AVIF data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isAVIF(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isAVIF' {$ENDIF} {$ENDIF}; + +{* + * Detect ICO image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is ICO data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isICO(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isICO' {$ENDIF} {$ENDIF}; + +{* + * Detect CUR image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is CUR data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isCUR(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isCUR' {$ENDIF} {$ENDIF}; + +{* + * Detect BMP image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is BMP data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isBMP(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isBMP' {$ENDIF} {$ENDIF}; + +{* + * Detect GIF image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is GIF data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isGIF(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isGIF' {$ENDIF} {$ENDIF}; + +{* + * Detect JPG image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is JPG data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isJPG(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isJPG' {$ENDIF} {$ENDIF}; + +{* + * Detect JXL image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is JXL data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isJXL(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isJXL' {$ENDIF} {$ENDIF}; + +{* + * Detect LBM image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is LBM data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isLBM(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isLBM' {$ENDIF} {$ENDIF}; + +{* + * Detect PCX image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is PCX data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isPCX(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPCX' {$ENDIF} {$ENDIF}; + +{* + * Detect PNG image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is PNG data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isPNG(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNG' {$ENDIF} {$ENDIF}; + +{* + * Detect PNM image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is PNM data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isPNM(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNM' {$ENDIF} {$ENDIF}; + +{* + * Detect SVG image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is SVG data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isSVG(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isSVG' {$ENDIF} {$ENDIF}; + +{* + * Detect QOI image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is QOI data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isQOI(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isQOI' {$ENDIF} {$ENDIF}; + +{* + * Detect TIFF image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is TIFF data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isTIF(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isTIF' {$ENDIF} {$ENDIF}; + +{* + * Detect XCF image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is XCF data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXPM + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isXCF(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXCF' {$ENDIF} {$ENDIF}; + +{* + * Detect XPM image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is XPM data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXV + * \sa IMG_isWEBP + } +function IMG_isXPM(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXPM' {$ENDIF} {$ENDIF}; + +{* + * Detect XV image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is XV data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isWEBP + } +function IMG_isXV(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXV' {$ENDIF} {$ENDIF}; + +{* + * Detect WEBP image data on a readable/seekable SDL_IOStream. + * + * This function attempts to determine if a file is a given filetype, reading + * the least amount possible from the SDL_IOStream (usually a few bytes). + * + * There is no distinction made between "not the filetype in question" and + * basic i/o errors. + * + * This function will always attempt to seek `src` back to where it started + * when this function was called, but it will not report any errors in doing + * so, but assuming seeking works, this means you can immediately use this + * with a different IMG_isTYPE function, or load the image without further + * seeking. + * + * You do not need to call this function to load data; SDL_image can work to + * determine file type in many cases in its standard load functions. + * + * \param src a seekable/readable SDL_IOStream to provide image data. + * \returns non-zero if this is WEBP data, zero otherwise. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_isAVIF + * \sa IMG_isICO + * \sa IMG_isCUR + * \sa IMG_isBMP + * \sa IMG_isGIF + * \sa IMG_isJPG + * \sa IMG_isJXL + * \sa IMG_isLBM + * \sa IMG_isPCX + * \sa IMG_isPNG + * \sa IMG_isPNM + * \sa IMG_isSVG + * \sa IMG_isQOI + * \sa IMG_isTIF + * \sa IMG_isXCF + * \sa IMG_isXPM + * \sa IMG_isXV + } +function IMG_isWEBP(src: PSDL_IOStream): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isWEBP' {$ENDIF} {$ENDIF}; + +{* + * Load a AVIF image directly. + * + * If you know you definitely have a AVIF image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadAVIF_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadAVIF_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a ICO image directly. + * + * If you know you definitely have a ICO image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadICO_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadICO_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a CUR image directly. + * + * If you know you definitely have a CUR image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadCUR_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadCUR_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a BMP image directly. + * + * If you know you definitely have a BMP image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadBMP_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadBMP_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a GIF image directly. + * + * If you know you definitely have a GIF image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadGIF_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadGIF_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a JPG image directly. + * + * If you know you definitely have a JPG image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadJPG_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadJPG_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a JXL image directly. + * + * If you know you definitely have a JXL image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadJXL_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadJXL_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a LBM image directly. + * + * If you know you definitely have a LBM image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadLBM_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadLBM_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a PCX image directly. + * + * If you know you definitely have a PCX image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadPCX_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPCX_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a PNG image directly. + * + * If you know you definitely have a PNG image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadPNG_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNG_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a PNM image directly. + * + * If you know you definitely have a PNM image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadPNM_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNM_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a SVG image directly. + * + * If you know you definitely have a SVG image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadSVG_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadSVG_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a QOI image directly. + * + * If you know you definitely have a QOI image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadQOI_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadQOI_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a TGA image directly. + * + * If you know you definitely have a TGA image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadTGA_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTGA_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a TIFF image directly. + * + * If you know you definitely have a TIFF image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadTIF_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTIF_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a XCF image directly. + * + * If you know you definitely have a XCF image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadXCF_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXCF_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a XPM image directly. + * + * If you know you definitely have a XPM image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXV_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadXPM_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXPM_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a XV image directly. + * + * If you know you definitely have a XV image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadWEBP_IO + } +function IMG_LoadXV_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXV_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a WEBP image directly. + * + * If you know you definitely have a WEBP image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream to load image data from. + * \returns SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAVIF_IO + * \sa IMG_LoadICO_IO + * \sa IMG_LoadCUR_IO + * \sa IMG_LoadBMP_IO + * \sa IMG_LoadGIF_IO + * \sa IMG_LoadJPG_IO + * \sa IMG_LoadJXL_IO + * \sa IMG_LoadLBM_IO + * \sa IMG_LoadPCX_IO + * \sa IMG_LoadPNG_IO + * \sa IMG_LoadPNM_IO + * \sa IMG_LoadSVG_IO + * \sa IMG_LoadQOI_IO + * \sa IMG_LoadTGA_IO + * \sa IMG_LoadTIF_IO + * \sa IMG_LoadXCF_IO + * \sa IMG_LoadXPM_IO + * \sa IMG_LoadXV_IO + } +function IMG_LoadWEBP_IO(src: PSDL_IOStream): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadWEBP_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an SVG image, scaled to a specific size. + * + * Since SVG files are resolution-independent, you specify the size you would + * like the output image to be and it will be generated at those dimensions. + * + * Either width or height may be 0 and the image will be auto-sized to + * preserve aspect ratio. + * + * When done with the returned surface, the app should dispose of it with a + * call to SDL_DestroySurface(). + * + * \param src an SDL_IOStream to load SVG data from. + * \param width desired width of the generated surface, in pixels. + * \param height desired height of the generated surface, in pixels. + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + } +function IMG_LoadSizedSVG_IO(src: PSDL_IOStream; width: cint; height: cint): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadSizedSVG_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an XPM image from a memory array. + * + * The returned surface will be an 8bpp indexed surface, if possible, + * otherwise it will be 32bpp. If you always want 32-bit data, use + * IMG_ReadXPMFromArrayToRGB888() instead. + * + * When done with the returned surface, the app should dispose of it with a + * call to SDL_DestroySurface(). + * + * \param xpm a null-terminated array of strings that comprise XPM data. + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_ReadXPMFromArrayToRGB888 + } +function IMG_ReadXPMFromArray(xpm: PPAnsiChar): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_ReadXPMFromArray' {$ENDIF} {$ENDIF}; + +{* + * Load an XPM image from a memory array. + * + * The returned surface will always be a 32-bit RGB surface. If you want 8-bit + * indexed colors (and the XPM data allows it), use IMG_ReadXPMFromArray() + * instead. + * + * When done with the returned surface, the app should dispose of it with a + * call to SDL_DestroySurface(). + * + * \param xpm a null-terminated array of strings that comprise XPM data. + * \returns a new SDL surface, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_ReadXPMFromArray + } +function IMG_ReadXPMFromArrayToRGB888(xpm: PPAnsiChar): PSDL_Surface; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_ReadXPMFromArrayToRGB888' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into a AVIF image file. + * + * If the file already exists, it will be overwritten. + * + * \param surface the SDL surface to save. + * \param file path on the filesystem to write new file to. + * \param quality the desired quality, ranging between 0 (lowest) and 100 + * (highest). + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SaveAVIF_IO + } +function IMG_SaveAVIF(surface: PSDL_Surface; file_: PAnsiChar; quality: cint): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SaveAVIF' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into AVIF image data, via an SDL_IOStream. + * + * If you just want to save to a filename, you can use IMG_SaveAVIF() instead. + * + * If `closeio` is true, `dst` will be closed before returning, whether this + * function succeeds or not. + * + * \param surface the SDL surface to save. + * \param dst the SDL_IOStream to save the image data to. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \param quality the desired quality, ranging between 0 (lowest) and 100 + * (highest). + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SaveAVIF + } +function IMG_SaveAVIF_IO(surface: PSDL_Surface; dst: PSDL_IOStream; closeio: cbool; quality: cint): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SaveAVIF_IO' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into a PNG image file. + * + * If the file already exists, it will be overwritten. + * + * \param surface the SDL surface to save. + * \param file path on the filesystem to write new file to. + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SavePNG_IO + } +function IMG_SavePNG(surface: PSDL_Surface; file_: PAnsiChar): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into PNG image data, via an SDL_IOStream. + * + * If you just want to save to a filename, you can use IMG_SavePNG() instead. + * + * If `closeio` is true, `dst` will be closed before returning, whether this + * function succeeds or not. + * + * \param surface the SDL surface to save. + * \param dst the SDL_IOStream to save the image data to. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SavePNG + } +function IMG_SavePNG_IO(surface: PSDL_Surface; dst: PSDL_IOStream; closeio: cbool): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG_IO' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into a JPEG image file. + * + * If the file already exists, it will be overwritten. + * + * \param surface the SDL surface to save. + * \param file path on the filesystem to write new file to. + * \param quality [0; 33] is Lowest quality, [34; 66] is Middle quality, [67; + * 100] is Highest quality. + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SaveJPG_IO + } +function IMG_SaveJPG(surface: PSDL_Surface; file_: PAnsiChar; quality: cint): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SaveJPG' {$ENDIF} {$ENDIF}; + +{* + * Save an SDL_Surface into JPEG image data, via an SDL_IOStream. + * + * If you just want to save to a filename, you can use IMG_SaveJPG() instead. + * + * If `closeio` is true, `dst` will be closed before returning, whether this + * function succeeds or not. + * + * \param surface the SDL surface to save. + * \param dst the SDL_IOStream to save the image data to. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \param quality [0; 33] is Lowest quality, [34; 66] is Middle quality, [67; + * 100] is Highest quality. + * \returns true on success or false on failure; call SDL_GetError() for more + * information. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_SaveJPG + } +function IMG_SaveJPG_IO(surface: PSDL_Surface; dst: PSDL_IOStream; closeio: cbool; quality: cint): cbool; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SaveJPG_IO' {$ENDIF} {$ENDIF}; + +{* + * Animated image support + * + * Currently only animated GIFs and WEBP images are supported. + } +type + PPIMG_Animation = ^PIMG_Animation; + PIMG_Animation = ^TIMG_Animation; + TIMG_Animation = record + w: cint; + h: cint; + count: cint; + frames: PPSDL_Surface; + delays: pcint; + end; + +{* + * Load an animation from a file. + * + * When done with the returned animation, the app should dispose of it with a + * call to IMG_FreeAnimation(). + * + * \param file path on the filesystem containing an animated image. + * \returns a new IMG_Animation, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_FreeAnimation + } +function IMG_LoadAnimation(file_: PAnsiChar): PIMG_Animation; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadAnimation' {$ENDIF} {$ENDIF}; + +{* + * Load an animation from an SDL_IOStream. + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * When done with the returned animation, the app should dispose of it with a + * call to IMG_FreeAnimation(). + * + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \returns a new IMG_Animation, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_FreeAnimation + } +function IMG_LoadAnimation_IO(src: PSDL_IOStream; closeio: cbool): PIMG_Animation; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadAnimation_IO' {$ENDIF} {$ENDIF}; + +{* + * Load an animation from an SDL datasource + * + * Even though this function accepts a file type, SDL_image may still try + * other decoders that are capable of detecting file type from the contents of + * the image data, but may rely on the caller-provided type string for formats + * that it cannot autodetect. If `type` is nil, SDL_image will rely solely on + * its ability to guess the format. + * + * If `closeio` is true, `src` will be closed before returning, whether this + * function succeeds or not. SDL_image reads everything it needs from `src` + * during this call in any case. + * + * When done with the returned animation, the app should dispose of it with a + * call to IMG_FreeAnimation(). + * + * \param src an SDL_IOStream that data will be read from. + * \param closeio true to close/free the SDL_IOStream before returning, false + * to leave it open. + * \param type a filename extension that represent this data ("GIF", etc). + * \returns a new IMG_Animation, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAnimation + * \sa IMG_LoadAnimation_IO + * \sa IMG_FreeAnimation + } +function IMG_LoadAnimationTyped_IO(src: PSDL_IOStream; closeio: cbool; type_: PAnsiChar): PIMG_Animation; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadAnimationTyped_IO' {$ENDIF} {$ENDIF}; + +{* + * Dispose of an IMG_Animation and free its resources. + * + * The provided `anim` Pointer is not valid once this call returns. + * + * \param anim IMG_Animation to dispose of. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAnimation + * \sa IMG_LoadAnimation_IO + * \sa IMG_LoadAnimationTyped_IO + } +procedure IMG_FreeAnimation(anim: PIMG_Animation); cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_FreeAnimation' {$ENDIF} {$ENDIF}; + +{* + * Load a GIF animation directly. + * + * If you know you definitely have a GIF image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream that data will be read from. + * \returns a new IMG_Animation, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAnimation + * \sa IMG_LoadAnimation_IO + * \sa IMG_LoadAnimationTyped_IO + * \sa IMG_FreeAnimation + } +function IMG_LoadGIFAnimation_IO(src: PSDL_IOStream): PIMG_Animation; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadGIFAnimation_IO' {$ENDIF} {$ENDIF}; + +{* + * Load a WEBP animation directly. + * + * If you know you definitely have a WEBP image, you can call this function, + * which will skip SDL_image's file format detection routines. Generally it's + * better to use the abstract interfaces; also, there is only an SDL_IOStream + * interface available here. + * + * \param src an SDL_IOStream that data will be read from. + * \returns a new IMG_Animation, or nil on error. + * + * \since This function is available since SDL_image 3.0.0. + * + * \sa IMG_LoadAnimation + * \sa IMG_LoadAnimation_IO + * \sa IMG_LoadAnimationTyped_IO + * \sa IMG_FreeAnimation + } +function IMG_LoadWEBPAnimation_IO(src: PSDL_IOStream): PIMG_Animation; cdecl; + external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadWEBPAnimation_IO' {$ENDIF} {$ENDIF}; + +implementation + +function SDL_IMAGE_VERSION: Integer; +begin + Result:=SDL_VERSIONNUM(SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_MICRO_VERSION); +end; + +function SDL_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; +begin + Result:=((SDL_IMAGE_MAJOR_VERSION >= X) and + ((SDL_IMAGE_MAJOR_VERSION > X) or (SDL_IMAGE_MINOR_VERSION >= Y)) and + ((SDL_IMAGE_MAJOR_VERSION > X) or (SDL_IMAGE_MINOR_VERSION > Y) or (SDL_IMAGE_MICRO_VERSION >= Z))); +end; + +end. + From 02908d9baaa5f03a906cb35262cbf258e8b3ad66 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 10 Feb 2025 14:13:53 +0100 Subject: [PATCH 2/4] Adds quick SDL3_image test + sample images --- tests/sample.bmp | Bin 0 -> 16522 bytes tests/sample.jpg | Bin 0 -> 2538 bytes tests/sample.png | Bin 0 -> 4533 bytes tests/testsdl3imageunit.pas | 58 ++++++++++++++++++++++++++++++++++++ 4 files changed, 58 insertions(+) create mode 100644 tests/sample.bmp create mode 100644 tests/sample.jpg create mode 100644 tests/sample.png create mode 100644 tests/testsdl3imageunit.pas diff --git a/tests/sample.bmp b/tests/sample.bmp new file mode 100644 index 0000000000000000000000000000000000000000..f9eda351ce478791606288c819bd7229a0d0dd65 GIT binary patch literal 16522 zcma)D2b7ofl_hnvC1=m>rtc;uo3hD9K>-m9N|9cr4$^xa5ClRI>C%hzp$Z}hsB{Ds z1p!e&K*0(ziV+1Rl1(t0n7qCBmGArgXV`PrlZj>K41AaS?!E86Z)!H4R=u45H4XoN z4?e2<#}~@|u-upM&-@QRE^iQT&mi@I`%7NRP%X7CklS8$d$_q6c$>Ev}Bst}!}0uv!DCGZ z%cjP}U;r@auNZ721`TrzcGvF$3_8nGbvw$Q1cPVmv{DQX)+PpbCjG;N7ak;AisQ4UR#T9~lOfzpofvR1ChY z82nFy!R5f9{NF1Ee<}YJ`Rg@b0tR0Y`DHnIxYAUiACF4P0aQQm$;M%V{4~W6n zzJEvyfp>*Jq)o&caFM0Wi3gvrrX0s0tj2K_xk@vv94v1q|N4@oIVJ#$O~DfCtxO z7OG$tDqkfZR>mv<1Dyq6@O#ceMa;r=J`2F$Q_RAr6#|2=$mdsoSsuFMUdLdRtZ#-{ z2p&KWHn|>b$@HLarU$#B2fOQ24`LR;1JwiYpiXOOL8=E$GCkldya*n=sCr-+m>$?H z>|U@)%6%sC@Rsea2Nhip9D~xcKn$+`kzAl2a25(M_(mB$_!L_3SzrJ?c<_#KhQS@= z!KiE&HaZVf4=@W`5lm``J z7QUu>@L==tvZnc1d8j#faK~tHVI+7kBG&_IB6*;C08PX!>?rLE2?hn42wyk=Ur;?z zUnt9i5T^qFlZ<`3+jzI20Ip%=%4=@eSY@^=fUZl9D_^`f(P(M_`*4O<9T@F1zjmd&wsKJ&fPJU*<2`AT7>bkRM+DTq<4q zR0bb?RW|k?pXUSk!ivQY>DSNRwg=e&zL05RTeJy!468K73qGcI^N?bRHlds5jp5U+#_Y1@Pd! z&q8TEPz-z)$b-w^!HSks{PU-O(|@KW#Yck=F3Dq^ zM_?Ar8<#C!tDl>N=YPUAF?cZPz!Cl2)-h9MKQvK&0r`k}P=x2Ni{}qbJce1=wqS{V z{g{)l%Qvs^Yj^zMqP*6!iRyv*f@P#!4-A73zyb3G^G5o@CCx~#iQoY-Sl()ytZX@1 zR<-~J;K6Fl!px;xvS;mo>?=$C`Dbi<8lHfh z=oyI^O!Vj9JZ75ggD)^AhBvms^Vh-iAFcsStZBZm)t{eOPdWOMJU3*RywtL}JUwHk zbbIfD{@N?|>`QVYH4zwSJ|GW%ia8(#%tzD$`U1Vt^?;gq9cKZ0fSkCj)pS|bk{Eyo zEo>HMEZwTVPP4Ng%DNV#vy4PdOp8qB=~~m#7;87 zpMTR>K0ovz$;$EkkrSDfw=7($->c`@_vJ*5T6tDRK6qi!V7Usvb_Z}kv+~X6jRic& zGE$nAfdey=XJzt$zCa9?w3;bPfdP520z7yCJecOsKWy)@Bp+B#q$W0e|6|3#G;x5G zlsv4z=V^HUJR@;m=py3}9M#Wl8ao|1v2BI{^FeF;`PasuzwQgr1A60TfBuDgo|O}^ zFEArjvy9Z~+((K5_XYaGX~%#$QF)-gknkWhv9j+A;DKdj%ZVkeXUme-GnEI+!2{~S z)TP_>_dIm(ar4GI#>iUD2k=H@ZWl9`&p|L>888$i9B$b0=i|(5bSy!%$hg>QVU){;VqCIj{cXpJm}AJ7i~{VX~{o zUK$D3y&;Zo_(+JFTN~$hmMpZt&3#WtoxjO|a$_-D-r!$bLZe(y~aW|}7Y&a}~=f8@zGv^EST zEqh#_XZVg6Wa^@=()67V<@=XEm+O#!`W=NI4xF9q0dnHJl1KFGCvD#+CG#GVqIb^A zPmoz|gSJiHwcmE8`aNaNmZzi-AZ z&$rLX&-uMR{zN7pJ|WL{?`eDEZApiM{(!Ua<}KWty+dI}q9%d|ih=J7=VD*b4(0nY zx9wt?SF{i~EX;T?VcD+i`NJ2O4_13dq8_YeR)!wvzQ7IzJ(B6cU})l9>W%r{=z0JQ zcGb^!rqF}E-XqZ)=?mN!Y-egLx;saYr2THfA$6@&S0jRy+=uWaoBvJ)l|!g%t*jsb&GNC3$`<{ zL&%nIv}>RRsV{JEv<_wVoy+C^I|BpqV1bNV_JltFP&|Kl z~pl=Hwah(6J>vhB{?7uY8r z;qF|+Iu!H9=+c-ELJtZtP+!RML9U71ooBUMAq5y<4#qBjQlEdw&Lipzfx&WMz^wcL zFj(zbc};U>1Mba9kHii|y)pVk_6OhrcjpGyCt8;lJredt?o4&sp+~zj%Sg5_kO$VK z84nx--y1Uwpa;wc#31v==nrCVRByDMDY~>7?Ni?a3Bv)V&cHtPTv&r7<6@L!ZhI-WN;{ z!W%6g(;{?i9zUr<%66D)~WKwlFq`((8M$=>umuUi8~X#aZ<+( zGP&b=@W3#LS(vGsxD4L71o?nGSXd@2rx>U&Xoupn;C*813mcG?A1O5pdS^;H)yK6v zhz`a2#L$DirgZ&YPU{3peBye`-0w?^v06tK_hx&f7uFe zj9!_V$ooq4NM$jwZk;*tkop2KV5eMPj<8Eh@&S2ZdSIHUS=o2z@trrx#7@AVG!GJA zuvuVExN6yyVHV&)5;542OI9&lGM3<_>6 zb=rGAa6QQSL}+47!yvmmC$msm6Ju{2+j*;u@4Q(iBp9TcnDbzT%xPyBs4wWgKwp?^ znurc1yfMp(oCVz%cw@H#oF@od?v!j)p7f`Mjb?o4fPTWFQt8`&SkzHo%Mcb^63#B67RFO2HC+c4;| zLuX+eW?>vOQT2enfNVftxDpTO3t4}VV&FYemJ^9V_(HZfMn<{^94Li>=0x6HLl4*= zm?l21nrPiRZ|{+jtVePlB;Kewu~y`R{O%k()5va5%BXIR0eCPb;Q=w2s5~$XA}6XQ zA}h~s$DA0mz`c*pf5y5(swZO z_fTwaG#+GkrpQRZ;7BPwIF4?8c=tV`7!>eeJ2Wxz1?a(K&53zdPJLlEd|{5~MAJm> zjMRfU+N~Q8W@uJUbK+{|1ME!HgSanjXll22-4_yXERz#`cYZQ@B;TDw4>${kf%ON6 zxI24?5_-T{_*IW*6oV1q!9Arg7^fI;7NCj92h7QqkqWai^YXVv67=Bio(CL*oCgJZ;F@R{Y?g_!FO-@EW+dwml3BPj?UAU7 zn1$rt$PR_Gu*xyejHG&CyR&BH*qzg?tQo1;_XT7m?@;Xaj`y*Ef$j_1Cq|b>Z?wHJ z>l49)LA{;>1_xzm&;2s2J22>;^FU{z8}b2oFt#&tqUVD=D|2sNm-Pp!CaNBUCWbFi z6B7*d?p)9x1P|D$5(D!_+nGx3&Ph&;_f)fe0lvWZP%>}y_tG>U;LgNZFg<82clCN+ z2KOWe;6YE!LW02v%t9GG$o7RaC;BXCM)Is&N)w|~RbNm&;LhkBO3Z?0<-`>w`01P+_@t!K*O^jKu`=>*$qzZ|v9SgcSEah7a(d*I}In!{DIlf#w6ppwujk<=&WiV`OD?Y1$(_Bx$$K z-8t99n1wtiau#A=P+v&)g&YIxP}Zv+7zQa1Y+vwM@O>fc4|H#IZ_MrsZKQACm!&T- z=no9Yfq}iRguy-;-Xp;P`G7p&ER3Nqcz?j0nCU@aKpqtI%FKyNpat%Yi5{f05Pf3i zjl3`DEO2+WeL?p|ytAHTkiWA{9%xQF^HUqF3oZxePIT=^|&)xpGZB(Z!FxM zJtO%n=+f^*x*fgVw~r?u}ViZcYrwCb#!A9~ckf-WV9@ zd;9bS=EUd|-4}Rg>e26Y>DBL5>D}*?5Q739s2(66s3sDF@P&M5Vm?qF00Zs{><`$f z>dvHD*}QRTdtv}@bRO7^g|krNooZo^WZvi)Tu~G03o#4a8M!Y2188F0nF0g)0^iHC zce2>2cFW$|@816n>Dm7^VDO6c!Yrg1m^Ydpq!@5tU_Kbp?WxQcMt5b8mUbw}%G#-N zcaFUgvk-c41z(8%AiuR?7Qh4M#7q<_{lod;jR;;0m*#dcdFG zD7?9@=etPgmF;KRlC13S;^-_OBk|VOdBEGE81#1@=q%)V(6_I7V=*$48{#P`;BcvkK-@Ez$y3C<82H^|JgF_hxLtPVxvp--~rZ1$L$bBKz zMDG(VD|1(P(DFekJzzetZryHeh2H2rl4qpV&I9X_A|oZ5s6X3i@8YDI$WFDxz;}fh zbRO^v@-Ey)yR&*MrCh zNlu(s#GIIP>$*F8KES)mrS}EPiT7HcNKIr;)DDH-$e-`b-^JP5&@{3AUGGUpV9+rz zC?*d$3%~%g(36_zzMwe~7{n}?9^|vYe88MYJH#reMk@6_l4hiqwl@~`iRpVNu8AoIr83f;cfBv|2fn8~$S?p8bQX%=fF_zZ_U?Pq zyfK{x@PHUFCk~GOz;|ck!4ujaL_P=}@aAmy1@}hZ8>e^RER@Pfz<@VbyRqc=#@LP{H147+9Z}&qC3l3yMKI@&L17dH@Wl2b=}>g&v-ff(Pmgp$G1b zk(JXfZG>u~@j!2Fk&&=BPVk%>+}W8f$IS=Sfm)lI~f0$9u&Tx zs62>H6+CD&_#-JAd_jr^84ud|EOZ*+nn)f{4=@Xn69a>On1$j#FDARQ&4Tuc%t-9g z;0u{1CVG(VOxdlC_eS;yxUs++4TDv7Z%p+-_r}n~JRew>W*Ef25IYm|!P;haZ!G8! zpoy&qU&IG6a30t!xE^p8)E9yW$VkD1e$<1PkQ0xqH|AM6`b2c9niG+gGfhl*zrksf?PD literal 0 HcmV?d00001 diff --git a/tests/sample.jpg b/tests/sample.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5066ee3d850be3debc70861a8291ed6ffd519f1 GIT binary patch literal 2538 zcmb7E30PBC7C!G~0ZD)t2#8c@BAXQG7*J7RWC;OLsR3oHxP(9em3_4!h=Ut-qXHEW z6fDqBDy|jjhsf4pI@nPRs~ZSXi$zfw6@>WazJSoL-`H>F4nR8r$gQZoK4|ve7u17- zW2FEX4=p=NqhjI^-iq+j#JDI5pFo%^4V45T{2juUF(^QUyC{9&6ds~*h!W!n0yk!Z zmk`~Ji!d+bcR28OSQ;7=j%*eq8{?qx2(&-$H-&>JoI>I79q}kOrBF9y2S<3XNB_p? zJ0IM@9Xvn`JP3q%2!kCEhxiJE2&9PxFSPFb0e^j^zZiK1BCjxzA`cgcgm923{ej8> zvOzM-ZLG}3TB*X=&H#*uBsppVpmH2Qaf~DgB{)RX%TjeVLtyByZDaa)W(#YZFdB6WoHCt*h#4c;3RmLUT@ z%HT@JyqqqjWpmgO%F!b^>p}eB_(+IF{=vC_@-+27ABgUFJn%YX`$+uc4TEm`WViGAEmmb|=e}(3KEAi-x3l%loian= z$#;D%R_D5+Ium!DdExWuane}lr(P{qD3tjeG|vD>e7zSOFb-c!Ti~gT0uk(htwz#r z@;^w#t;Cggw>-Xz>>t!Vu4=Z?*_&)%{d9Y^xw(a}Ztb~p%-%tbo8ejz-Tla zRSjeMZ0cxKep&*)lc$8K&0U~lY#n{kBqqK1g)$hN3WnpX$^br>mqDm;oEM5zi|KfV zcn`;Mp$Lk(3o^u+NQP3*)cd21{vF^UBB^$SyyZdD5{WZ7t zWq|ip-@j$1(oYm7R4^lbSS7#OW&CSl<%L@Hvu&$3r#cShr#(!&zPEjmq2G%fSJTSy zwnNz?4gY*{yE?K_U-p!@Lg)0PMh^%vr9et)L5wXWm537#^BLXt2%nDe6=X@C6c{=f!$L{Ai{{h*vx`Y^H>>sx+9X z0biEH!3fh$@KySe-t)|kl})z$o{#0|L)eeH&ui#$%wLl3Q1gw48W7C_G=1OuD^GCZ zc}BlLQ)>H~D&)gnSa-4)3&UJ@wX;OX}8UC z+JLt&ChFqDqfd@tD-DWRqS~CJrNR);v)>lhuaRBKJ;d=AV;->OtPiJrV4BKv#tZrG$eSb8%eY1i1BkWCt!pDi3%o0E`0T{@yYFO&e#8)2UK%#LucyNmmVP~%nJ2bBoViAD`H{jx z5pZ>}{=DpX$D+aeEX6N3$|@Rz*h|~xB2n$HO+OfB*Y)W)%Eppk4(Dbk?D9_^E~{Ck m=;fA{$6xPWpW<<#tJt*NYw&r2(FLPzSHF8zFlu{??EViz`x8O{ literal 0 HcmV?d00001 diff --git a/tests/sample.png b/tests/sample.png new file mode 100644 index 0000000000000000000000000000000000000000..f7a2fed3ad5fb099f59b240e05c474c7cb4d306a GIT binary patch literal 4533 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 T`rMTi00000NkvXXu0mjfZ~ual literal 0 HcmV?d00001 diff --git a/tests/testsdl3imageunit.pas b/tests/testsdl3imageunit.pas new file mode 100644 index 0000000..7b7a67b --- /dev/null +++ b/tests/testsdl3imageunit.pas @@ -0,0 +1,58 @@ +{ + This file is part of: + + SDL3 for Pascal + (https://github.com/PascalGameDevelopment/SDL3-for-Pascal) + SPDX-License-Identifier: Zlib +} + +{ Test SDL3_image routines } + +program testsdl3imageunit; + +uses + SDL3, SDL3_image; + +var + Window: PSDL_Window = nil; + Renderer: PSDL_Renderer = nil; + ImageSurface: PSDL_Surface = nil; + ImageTexture: PSDL_Texture = nil; + +procedure RenderImage(file_:PChar); +begin + ImageSurface := IMG_Load(file_); + ImageTexture := SDL_CreateTextureFromSurface(Renderer, ImageSurface); + SDL_RenderClear(Renderer); + SDL_RenderTexture(Renderer, ImageTexture, nil, nil); + SDL_RenderPresent(Renderer); + SDL_Delay(1000); + SDL_RenderClear(Renderer); + SDL_DestroyTexture(ImageTexture); + SDL_DestroySurface(ImageSurface); +end; + +begin + + SDL_Log('Linked SDL3_image version: %d',[IMG_Version]); + + if not SDL_Init(SDL_INIT_VIDEO) then + begin + SDL_Log('Couldn''t initialize SDL: %s', [SDL_GetError]); + Exit; + end; + + if not SDL_CreateWindowAndRenderer('Images', 640, 480, 0, @Window, @Renderer) then + begin + SDL_Log('Couldn''t create window/renderer: %s', [SDL_GetError]); + Exit; + end; + + RenderImage('sample.bmp'); + RenderImage('sample.png'); + RenderImage('sample.jpg'); + + SDL_Quit(); + +end. + From 5c3a959ba794f68c03a607c2c23244879672cb38 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 10 Feb 2025 14:17:52 +0100 Subject: [PATCH 3/4] FIX: SDL_IMAGE_VERSION_ATLEAST macro --- units/SDL3_image.pas | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/units/SDL3_image.pas b/units/SDL3_image.pas index cec46f5..c6b92dd 100644 --- a/units/SDL3_image.pas +++ b/units/SDL3_image.pas @@ -98,7 +98,7 @@ function SDL_IMAGE_VERSION: Integer; {* * This macro will evaluate to true if compiled with SDL_image at least X.Y.Z. } -function SDL_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; +function SDL_IMAGE_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; {* * This function gets the version of the dynamically linked SDL_image library. @@ -2209,7 +2209,7 @@ function SDL_IMAGE_VERSION: Integer; Result:=SDL_VERSIONNUM(SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_MICRO_VERSION); end; -function SDL_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; +function SDL_IMAGE_VERSION_ATLEAST(X, Y, Z: Integer): Boolean; begin Result:=((SDL_IMAGE_MAJOR_VERSION >= X) and ((SDL_IMAGE_MAJOR_VERSION > X) or (SDL_IMAGE_MINOR_VERSION >= Y)) and From 8b66f8abf29cf0e838eb8f1f05fcbfb6f079b871 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 10 Feb 2025 19:53:37 +0100 Subject: [PATCH 4/4] FIX: typo libSDL2/3 --- units/SDL3_image.pas | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/units/SDL3_image.pas b/units/SDL3_image.pas index c6b92dd..38e9354 100644 --- a/units/SDL3_image.pas +++ b/units/SDL3_image.pas @@ -63,7 +63,7 @@ interface {$IFDEF DARWIN} IMG_LibName = 'libSDL3_image.dylib'; {$IFDEF FPC} - {$LINKLIB libSDL2} + {$LINKLIB libSDL3} {$ENDIF} {$ELSE} {$IFDEF FPC}