From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/video/SDL_bmp.c | 879 ++++++++++++++++++++++++++++++++++ 1 file changed, 879 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/video/SDL_bmp.c (limited to 'contrib/SDL-3.2.8/src/video/SDL_bmp.c') diff --git a/contrib/SDL-3.2.8/src/video/SDL_bmp.c b/contrib/SDL-3.2.8/src/video/SDL_bmp.c new file mode 100644 index 0000000..688086f --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/SDL_bmp.c @@ -0,0 +1,879 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +/* + Code to load and save surfaces in Windows BMP format. + + Why support BMP format? Well, it's a native format for Windows, and + most image processing programs can read and write it. It would be nice + to be able to have at least one image format that we can natively load + and save, and since PNG is so complex that it would bloat the library, + BMP is a good alternative. + + This code currently supports Win32 DIBs in uncompressed 8 and 24 bpp. +*/ + +#include "SDL_pixels_c.h" +#include "SDL_surface_c.h" + +#define SAVE_32BIT_BMP + +// Compression encodings for BMP files +#ifndef BI_RGB +#define BI_RGB 0 +#define BI_RLE8 1 +#define BI_RLE4 2 +#define BI_BITFIELDS 3 +#endif + +// Logical color space values for BMP files +// https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wmf/eb4bbd50-b3ce-4917-895c-be31f214797f +#ifndef LCS_WINDOWS_COLOR_SPACE +// 0x57696E20 == "Win " +#define LCS_WINDOWS_COLOR_SPACE 0x57696E20 +#endif + +#ifndef LCS_sRGB +// 0x73524742 == "sRGB" +#define LCS_sRGB 0x73524742 +#endif + +// Logical/physical color relationship +// https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wmf/9fec0834-607d-427d-abd5-ab240fb0db38 +#ifndef LCS_GM_GRAPHICS +#define LCS_GM_GRAPHICS 0x00000002 +#endif + +static bool readRlePixels(SDL_Surface *surface, SDL_IOStream *src, int isRle8) +{ + /* + | Sets the surface pixels from src. A bmp image is upside down. + */ + int pitch = surface->pitch; + int height = surface->h; + Uint8 *start = (Uint8 *)surface->pixels; + Uint8 *end = start + (height * pitch); + Uint8 *bits = end - pitch, *spot; + int ofs = 0; + Uint8 ch; + Uint8 needsPad; + const int pixels_per_byte = (isRle8 ? 1 : 2); + +#define COPY_PIXEL(x) \ + spot = &bits[ofs++]; \ + if (spot >= start && spot < end) \ + *spot = (x) + + for (;;) { + if (!SDL_ReadU8(src, &ch)) { + return false; + } + /* + | encoded mode starts with a run length, and then a byte + | with two colour indexes to alternate between for the run + */ + if (ch) { + Uint8 pixel; + if (!SDL_ReadU8(src, &pixel)) { + return false; + } + ch /= pixels_per_byte; + do { + COPY_PIXEL(pixel); + } while (--ch); + } else { + /* + | A leading zero is an escape; it may signal the end of the bitmap, + | a cursor move, or some absolute data. + | zero tag may be absolute mode or an escape + */ + if (!SDL_ReadU8(src, &ch)) { + return false; + } + switch (ch) { + case 0: // end of line + ofs = 0; + bits -= pitch; // go to previous + break; + case 1: // end of bitmap + return true; // success! + case 2: // delta + if (!SDL_ReadU8(src, &ch)) { + return false; + } + ofs += ch / pixels_per_byte; + + if (!SDL_ReadU8(src, &ch)) { + return false; + } + bits -= ((ch / pixels_per_byte) * pitch); + break; + default: // no compression + ch /= pixels_per_byte; + needsPad = (ch & 1); + do { + Uint8 pixel; + if (!SDL_ReadU8(src, &pixel)) { + return false; + } + COPY_PIXEL(pixel); + } while (--ch); + + // pad at even boundary + if (needsPad && !SDL_ReadU8(src, &ch)) { + return false; + } + break; + } + } + } +} + +static void CorrectAlphaChannel(SDL_Surface *surface) +{ + // Check to see if there is any alpha channel data + bool hasAlpha = false; +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + int alphaChannelOffset = 0; +#else + int alphaChannelOffset = 3; +#endif + Uint8 *alpha = ((Uint8 *)surface->pixels) + alphaChannelOffset; + Uint8 *end = alpha + surface->h * surface->pitch; + + while (alpha < end) { + if (*alpha != 0) { + hasAlpha = true; + break; + } + alpha += 4; + } + + if (!hasAlpha) { + alpha = ((Uint8 *)surface->pixels) + alphaChannelOffset; + while (alpha < end) { + *alpha = SDL_ALPHA_OPAQUE; + alpha += 4; + } + } +} + +SDL_Surface *SDL_LoadBMP_IO(SDL_IOStream *src, bool closeio) +{ + bool was_error = true; + Sint64 fp_offset = 0; + int i, pad; + SDL_Surface *surface; + Uint32 Rmask = 0; + Uint32 Gmask = 0; + Uint32 Bmask = 0; + Uint32 Amask = 0; + Uint8 *bits; + Uint8 *top, *end; + bool topDown; + bool haveRGBMasks = false; + bool haveAlphaMask = false; + bool correctAlpha = false; + + // The Win32 BMP file header (14 bytes) + char magic[2]; + // Uint32 bfSize; + // Uint16 bfReserved1; + // Uint16 bfReserved2; + Uint32 bfOffBits; + + // The Win32 BITMAPINFOHEADER struct (40 bytes) + Uint32 biSize; + Sint32 biWidth = 0; + Sint32 biHeight = 0; + // Uint16 biPlanes; + Uint16 biBitCount = 0; + Uint32 biCompression = 0; + // Uint32 biSizeImage; + // Sint32 biXPelsPerMeter; + // Sint32 biYPelsPerMeter; + Uint32 biClrUsed = 0; + // Uint32 biClrImportant; + + // Make sure we are passed a valid data source + surface = NULL; + if (!src) { + SDL_InvalidParamError("src"); + goto done; + } + + // Read in the BMP file header + fp_offset = SDL_TellIO(src); + if (fp_offset < 0) { + goto done; + } + SDL_ClearError(); + if (SDL_ReadIO(src, magic, 2) != 2) { + goto done; + } + if (SDL_strncmp(magic, "BM", 2) != 0) { + SDL_SetError("File is not a Windows BMP file"); + goto done; + } + if (!SDL_ReadU32LE(src, NULL /* bfSize */) || + !SDL_ReadU16LE(src, NULL /* bfReserved1 */) || + !SDL_ReadU16LE(src, NULL /* bfReserved2 */) || + !SDL_ReadU32LE(src, &bfOffBits)) { + goto done; + } + + // Read the Win32 BITMAPINFOHEADER + if (!SDL_ReadU32LE(src, &biSize)) { + goto done; + } + if (biSize == 12) { // really old BITMAPCOREHEADER + Uint16 biWidth16, biHeight16; + if (!SDL_ReadU16LE(src, &biWidth16) || + !SDL_ReadU16LE(src, &biHeight16) || + !SDL_ReadU16LE(src, NULL /* biPlanes */) || + !SDL_ReadU16LE(src, &biBitCount)) { + goto done; + } + biWidth = biWidth16; + biHeight = biHeight16; + biCompression = BI_RGB; + // biSizeImage = 0; + // biXPelsPerMeter = 0; + // biYPelsPerMeter = 0; + biClrUsed = 0; + // biClrImportant = 0; + } else if (biSize >= 40) { // some version of BITMAPINFOHEADER + Uint32 headerSize; + if (!SDL_ReadS32LE(src, &biWidth) || + !SDL_ReadS32LE(src, &biHeight) || + !SDL_ReadU16LE(src, NULL /* biPlanes */) || + !SDL_ReadU16LE(src, &biBitCount) || + !SDL_ReadU32LE(src, &biCompression) || + !SDL_ReadU32LE(src, NULL /* biSizeImage */) || + !SDL_ReadU32LE(src, NULL /* biXPelsPerMeter */) || + !SDL_ReadU32LE(src, NULL /* biYPelsPerMeter */) || + !SDL_ReadU32LE(src, &biClrUsed) || + !SDL_ReadU32LE(src, NULL /* biClrImportant */)) { + goto done; + } + + // 64 == BITMAPCOREHEADER2, an incompatible OS/2 2.x extension. Skip this stuff for now. + if (biSize != 64) { + /* This is complicated. If compression is BI_BITFIELDS, then + we have 3 DWORDS that specify the RGB masks. This is either + stored here in an BITMAPV2INFOHEADER (which only differs in + that it adds these RGB masks) and biSize >= 52, or we've got + these masks stored in the exact same place, but strictly + speaking, this is the bmiColors field in BITMAPINFO immediately + following the legacy v1 info header, just past biSize. */ + if (biCompression == BI_BITFIELDS) { + haveRGBMasks = true; + if (!SDL_ReadU32LE(src, &Rmask) || + !SDL_ReadU32LE(src, &Gmask) || + !SDL_ReadU32LE(src, &Bmask)) { + goto done; + } + + // ...v3 adds an alpha mask. + if (biSize >= 56) { // BITMAPV3INFOHEADER; adds alpha mask + haveAlphaMask = true; + if (!SDL_ReadU32LE(src, &Amask)) { + goto done; + } + } + } else { + // the mask fields are ignored for v2+ headers if not BI_BITFIELD. + if (biSize >= 52) { // BITMAPV2INFOHEADER; adds RGB masks + if (!SDL_ReadU32LE(src, NULL /* Rmask */) || + !SDL_ReadU32LE(src, NULL /* Gmask */) || + !SDL_ReadU32LE(src, NULL /* Bmask */)) { + goto done; + } + } + if (biSize >= 56) { // BITMAPV3INFOHEADER; adds alpha mask + if (!SDL_ReadU32LE(src, NULL /* Amask */)) { + goto done; + } + } + } + + /* Insert other fields here; Wikipedia and MSDN say we're up to + v5 of this header, but we ignore those for now (they add gamma, + color spaces, etc). Ignoring the weird OS/2 2.x format, we + currently parse up to v3 correctly (hopefully!). */ + } + + // skip any header bytes we didn't handle... + headerSize = (Uint32)(SDL_TellIO(src) - (fp_offset + 14)); + if (biSize > headerSize) { + if (SDL_SeekIO(src, (biSize - headerSize), SDL_IO_SEEK_CUR) < 0) { + goto done; + } + } + } + if (biWidth <= 0 || biHeight == 0) { + SDL_SetError("BMP file with bad dimensions (%" SDL_PRIs32 "x%" SDL_PRIs32 ")", biWidth, biHeight); + goto done; + } + if (biHeight < 0) { + topDown = true; + biHeight = -biHeight; + } else { + topDown = false; + } + + // Check for read error + if (SDL_strcmp(SDL_GetError(), "") != 0) { + goto done; + } + + // Reject invalid bit depths + switch (biBitCount) { + case 0: + case 3: + case 5: + case 6: + case 7: + SDL_SetError("%u bpp BMP images are not supported", biBitCount); + goto done; + default: + break; + } + + // RLE4 and RLE8 BMP compression is supported + switch (biCompression) { + case BI_RGB: + // If there are no masks, use the defaults + SDL_assert(!haveRGBMasks); + SDL_assert(!haveAlphaMask); + // Default values for the BMP format + switch (biBitCount) { + case 15: + case 16: + // SDL_PIXELFORMAT_XRGB1555 or SDL_PIXELFORMAT_ARGB1555 if Amask + Rmask = 0x7C00; + Gmask = 0x03E0; + Bmask = 0x001F; + break; + case 24: +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + // SDL_PIXELFORMAT_RGB24 + Rmask = 0x000000FF; + Gmask = 0x0000FF00; + Bmask = 0x00FF0000; +#else + // SDL_PIXELFORMAT_BGR24 + Rmask = 0x00FF0000; + Gmask = 0x0000FF00; + Bmask = 0x000000FF; +#endif + break; + case 32: + // We don't know if this has alpha channel or not + correctAlpha = true; + // SDL_PIXELFORMAT_RGBA8888 + Amask = 0xFF000000; + Rmask = 0x00FF0000; + Gmask = 0x0000FF00; + Bmask = 0x000000FF; + break; + default: + break; + } + break; + + case BI_BITFIELDS: + break; // we handled this in the info header. + + default: + break; + } + + // Create a compatible surface, note that the colors are RGB ordered + { + SDL_PixelFormat format; + + // Get the pixel format + format = SDL_GetPixelFormatForMasks(biBitCount, Rmask, Gmask, Bmask, Amask); + surface = SDL_CreateSurface(biWidth, biHeight, format); + + if (!surface) { + goto done; + } + } + + // Load the palette, if any + if (SDL_ISPIXELFORMAT_INDEXED(surface->format)) { + SDL_Palette *palette = SDL_CreateSurfacePalette(surface); + if (!palette) { + goto done; + } + + if (SDL_SeekIO(src, fp_offset + 14 + biSize, SDL_IO_SEEK_SET) < 0) { + SDL_SetError("Error seeking in datastream"); + goto done; + } + + if (biBitCount >= 32) { // we shift biClrUsed by this value later. + SDL_SetError("Unsupported or incorrect biBitCount field"); + goto done; + } + + if (biClrUsed == 0) { + biClrUsed = 1 << biBitCount; + } + + if (biClrUsed > (Uint32)palette->ncolors) { + biClrUsed = 1 << biBitCount; // try forcing it? + if (biClrUsed > (Uint32)palette->ncolors) { + SDL_SetError("Unsupported or incorrect biClrUsed field"); + goto done; + } + } + palette->ncolors = biClrUsed; + + if (biSize == 12) { + for (i = 0; i < palette->ncolors; ++i) { + if (!SDL_ReadU8(src, &palette->colors[i].b) || + !SDL_ReadU8(src, &palette->colors[i].g) || + !SDL_ReadU8(src, &palette->colors[i].r)) { + goto done; + } + palette->colors[i].a = SDL_ALPHA_OPAQUE; + } + } else { + for (i = 0; i < palette->ncolors; ++i) { + if (!SDL_ReadU8(src, &palette->colors[i].b) || + !SDL_ReadU8(src, &palette->colors[i].g) || + !SDL_ReadU8(src, &palette->colors[i].r) || + !SDL_ReadU8(src, &palette->colors[i].a)) { + goto done; + } + + /* According to Microsoft documentation, the fourth element + is reserved and must be zero, so we shouldn't treat it as + alpha. + */ + palette->colors[i].a = SDL_ALPHA_OPAQUE; + } + } + } + + // Read the surface pixels. Note that the bmp image is upside down + if (SDL_SeekIO(src, fp_offset + bfOffBits, SDL_IO_SEEK_SET) < 0) { + SDL_SetError("Error seeking in datastream"); + goto done; + } + if ((biCompression == BI_RLE4) || (biCompression == BI_RLE8)) { + if (!readRlePixels(surface, src, biCompression == BI_RLE8)) { + SDL_SetError("Error reading from datastream"); + goto done; + } + + // Success! + was_error = false; + goto done; + } + top = (Uint8 *)surface->pixels; + end = (Uint8 *)surface->pixels + (surface->h * surface->pitch); + pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0); + if (topDown) { + bits = top; + } else { + bits = end - surface->pitch; + } + while (bits >= top && bits < end) { + if (SDL_ReadIO(src, bits, surface->pitch) != (size_t)surface->pitch) { + goto done; + } + if (biBitCount == 8 && surface->palette && biClrUsed < (1u << biBitCount)) { + for (i = 0; i < surface->w; ++i) { + if (bits[i] >= biClrUsed) { + SDL_SetError("A BMP image contains a pixel with a color out of the palette"); + goto done; + } + } + } +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + /* Byte-swap the pixels if needed. Note that the 24bpp + case has already been taken care of above. */ + switch (biBitCount) { + case 15: + case 16: + { + Uint16 *pix = (Uint16 *)bits; + for (i = 0; i < surface->w; i++) { + pix[i] = SDL_Swap16(pix[i]); + } + break; + } + + case 32: + { + Uint32 *pix = (Uint32 *)bits; + for (i = 0; i < surface->w; i++) { + pix[i] = SDL_Swap32(pix[i]); + } + break; + } + } +#endif + + // Skip padding bytes, ugh + if (pad) { + Uint8 padbyte; + for (i = 0; i < pad; ++i) { + if (!SDL_ReadU8(src, &padbyte)) { + goto done; + } + } + } + if (topDown) { + bits += surface->pitch; + } else { + bits -= surface->pitch; + } + } + if (correctAlpha) { + CorrectAlphaChannel(surface); + } + + was_error = false; + +done: + if (was_error) { + if (src) { + SDL_SeekIO(src, fp_offset, SDL_IO_SEEK_SET); + } + SDL_DestroySurface(surface); + surface = NULL; + } + if (closeio && src) { + SDL_CloseIO(src); + } + return surface; +} + +SDL_Surface *SDL_LoadBMP(const char *file) +{ + SDL_IOStream *stream = SDL_IOFromFile(file, "rb"); + if (!stream) { + return NULL; + } + return SDL_LoadBMP_IO(stream, true); +} + +bool SDL_SaveBMP_IO(SDL_Surface *surface, SDL_IOStream *dst, bool closeio) +{ + bool was_error = true; + Sint64 fp_offset, new_offset; + int i, pad; + SDL_Surface *intermediate_surface = NULL; + Uint8 *bits; + bool save32bit = false; + bool saveLegacyBMP = false; + + // The Win32 BMP file header (14 bytes) + char magic[2] = { 'B', 'M' }; + Uint32 bfSize; + Uint16 bfReserved1; + Uint16 bfReserved2; + Uint32 bfOffBits; + + // The Win32 BITMAPINFOHEADER struct (40 bytes) + Uint32 biSize; + Sint32 biWidth; + Sint32 biHeight; + Uint16 biPlanes; + Uint16 biBitCount; + Uint32 biCompression; + Uint32 biSizeImage; + Sint32 biXPelsPerMeter; + Sint32 biYPelsPerMeter; + Uint32 biClrUsed; + Uint32 biClrImportant; + + // The additional header members from the Win32 BITMAPV4HEADER struct (108 bytes in total) + Uint32 bV4RedMask = 0; + Uint32 bV4GreenMask = 0; + Uint32 bV4BlueMask = 0; + Uint32 bV4AlphaMask = 0; + Uint32 bV4CSType = 0; + Sint32 bV4Endpoints[3 * 3] = { 0 }; + Uint32 bV4GammaRed = 0; + Uint32 bV4GammaGreen = 0; + Uint32 bV4GammaBlue = 0; + + // The additional header members from the Win32 BITMAPV5HEADER struct (124 bytes in total) + Uint32 bV5Intent = 0; + Uint32 bV5ProfileData = 0; + Uint32 bV5ProfileSize = 0; + Uint32 bV5Reserved = 0; + + // Make sure we have somewhere to save + if (!SDL_SurfaceValid(surface)) { + SDL_InvalidParamError("surface"); + goto done; + } + if (!dst) { + SDL_InvalidParamError("dst"); + goto done; + } + +#ifdef SAVE_32BIT_BMP + // We can save alpha information in a 32-bit BMP + if (SDL_BITSPERPIXEL(surface->format) >= 8 && + (SDL_ISPIXELFORMAT_ALPHA(surface->format) || + surface->map.info.flags & SDL_COPY_COLORKEY)) { + save32bit = true; + } +#endif // SAVE_32BIT_BMP + + if (surface->palette && !save32bit) { + if (SDL_BITSPERPIXEL(surface->format) == 8) { + intermediate_surface = surface; + } else { + SDL_SetError("%u bpp BMP files not supported", + SDL_BITSPERPIXEL(surface->format)); + goto done; + } + } else if ((surface->format == SDL_PIXELFORMAT_BGR24 && !save32bit) || + (surface->format == SDL_PIXELFORMAT_BGRA32 && save32bit)) { + intermediate_surface = surface; + } else { + SDL_PixelFormat pixel_format; + + /* If the surface has a colorkey or alpha channel we'll save a + 32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */ + if (save32bit) { + pixel_format = SDL_PIXELFORMAT_BGRA32; + } else { + pixel_format = SDL_PIXELFORMAT_BGR24; + } + intermediate_surface = SDL_ConvertSurface(surface, pixel_format); + if (!intermediate_surface) { + SDL_SetError("Couldn't convert image to %d bpp", + (int)SDL_BITSPERPIXEL(pixel_format)); + goto done; + } + } + + if (save32bit) { + saveLegacyBMP = SDL_GetHintBoolean(SDL_HINT_BMP_SAVE_LEGACY_FORMAT, false); + } + + if (SDL_LockSurface(intermediate_surface)) { + const size_t bw = intermediate_surface->w * intermediate_surface->fmt->bytes_per_pixel; + + // Set the BMP file header values + bfSize = 0; // We'll write this when we're done + bfReserved1 = 0; + bfReserved2 = 0; + bfOffBits = 0; // We'll write this when we're done + + // Write the BMP file header values + fp_offset = SDL_TellIO(dst); + if (fp_offset < 0) { + goto done; + } + if (SDL_WriteIO(dst, magic, 2) != 2 || + !SDL_WriteU32LE(dst, bfSize) || + !SDL_WriteU16LE(dst, bfReserved1) || + !SDL_WriteU16LE(dst, bfReserved2) || + !SDL_WriteU32LE(dst, bfOffBits)) { + goto done; + } + + // Set the BMP info values + biSize = 40; + biWidth = intermediate_surface->w; + biHeight = intermediate_surface->h; + biPlanes = 1; + biBitCount = intermediate_surface->fmt->bits_per_pixel; + biCompression = BI_RGB; + biSizeImage = intermediate_surface->h * intermediate_surface->pitch; + biXPelsPerMeter = 0; + biYPelsPerMeter = 0; + if (intermediate_surface->palette) { + biClrUsed = intermediate_surface->palette->ncolors; + } else { + biClrUsed = 0; + } + biClrImportant = 0; + + // Set the BMP info values + if (save32bit && !saveLegacyBMP) { + biSize = 124; + // Version 4 values + biCompression = BI_BITFIELDS; + // The BMP format is always little endian, these masks stay the same + bV4RedMask = 0x00ff0000; + bV4GreenMask = 0x0000ff00; + bV4BlueMask = 0x000000ff; + bV4AlphaMask = 0xff000000; + bV4CSType = LCS_sRGB; + bV4GammaRed = 0; + bV4GammaGreen = 0; + bV4GammaBlue = 0; + // Version 5 values + bV5Intent = LCS_GM_GRAPHICS; + bV5ProfileData = 0; + bV5ProfileSize = 0; + bV5Reserved = 0; + } + + // Write the BMP info values + if (!SDL_WriteU32LE(dst, biSize) || + !SDL_WriteS32LE(dst, biWidth) || + !SDL_WriteS32LE(dst, biHeight) || + !SDL_WriteU16LE(dst, biPlanes) || + !SDL_WriteU16LE(dst, biBitCount) || + !SDL_WriteU32LE(dst, biCompression) || + !SDL_WriteU32LE(dst, biSizeImage) || + !SDL_WriteU32LE(dst, biXPelsPerMeter) || + !SDL_WriteU32LE(dst, biYPelsPerMeter) || + !SDL_WriteU32LE(dst, biClrUsed) || + !SDL_WriteU32LE(dst, biClrImportant)) { + goto done; + } + + // Write the BMP info values + if (save32bit && !saveLegacyBMP) { + // Version 4 values + if (!SDL_WriteU32LE(dst, bV4RedMask) || + !SDL_WriteU32LE(dst, bV4GreenMask) || + !SDL_WriteU32LE(dst, bV4BlueMask) || + !SDL_WriteU32LE(dst, bV4AlphaMask) || + !SDL_WriteU32LE(dst, bV4CSType)) { + goto done; + } + for (i = 0; i < 3 * 3; i++) { + if (!SDL_WriteU32LE(dst, bV4Endpoints[i])) { + goto done; + } + } + if (!SDL_WriteU32LE(dst, bV4GammaRed) || + !SDL_WriteU32LE(dst, bV4GammaGreen) || + !SDL_WriteU32LE(dst, bV4GammaBlue)) { + goto done; + } + // Version 5 values + if (!SDL_WriteU32LE(dst, bV5Intent) || + !SDL_WriteU32LE(dst, bV5ProfileData) || + !SDL_WriteU32LE(dst, bV5ProfileSize) || + !SDL_WriteU32LE(dst, bV5Reserved)) { + goto done; + } + } + + // Write the palette (in BGR color order) + if (intermediate_surface->palette) { + SDL_Color *colors; + int ncolors; + + colors = intermediate_surface->palette->colors; + ncolors = intermediate_surface->palette->ncolors; + for (i = 0; i < ncolors; ++i) { + if (!SDL_WriteU8(dst, colors[i].b) || + !SDL_WriteU8(dst, colors[i].g) || + !SDL_WriteU8(dst, colors[i].r) || + !SDL_WriteU8(dst, colors[i].a)) { + goto done; + } + } + } + + // Write the bitmap offset + bfOffBits = (Uint32)(SDL_TellIO(dst) - fp_offset); + if (SDL_SeekIO(dst, fp_offset + 10, SDL_IO_SEEK_SET) < 0) { + goto done; + } + if (!SDL_WriteU32LE(dst, bfOffBits)) { + goto done; + } + if (SDL_SeekIO(dst, fp_offset + bfOffBits, SDL_IO_SEEK_SET) < 0) { + goto done; + } + + // Write the bitmap image upside down + bits = (Uint8 *)intermediate_surface->pixels + (intermediate_surface->h * intermediate_surface->pitch); + pad = ((bw % 4) ? (4 - (bw % 4)) : 0); + while (bits > (Uint8 *)intermediate_surface->pixels) { + bits -= intermediate_surface->pitch; + if (SDL_WriteIO(dst, bits, bw) != bw) { + goto done; + } + if (pad) { + const Uint8 padbyte = 0; + for (i = 0; i < pad; ++i) { + if (!SDL_WriteU8(dst, padbyte)) { + goto done; + } + } + } + } + + // Write the BMP file size + new_offset = SDL_TellIO(dst); + if (new_offset < 0) { + goto done; + } + bfSize = (Uint32)(new_offset - fp_offset); + if (SDL_SeekIO(dst, fp_offset + 2, SDL_IO_SEEK_SET) < 0) { + goto done; + } + if (!SDL_WriteU32LE(dst, bfSize)) { + goto done; + } + if (SDL_SeekIO(dst, fp_offset + bfSize, SDL_IO_SEEK_SET) < 0) { + goto done; + } + + // Close it up.. + SDL_UnlockSurface(intermediate_surface); + + was_error = false; + } + +done: + if (intermediate_surface && intermediate_surface != surface) { + SDL_DestroySurface(intermediate_surface); + } + if (closeio && dst) { + if (!SDL_CloseIO(dst)) { + was_error = true; + } + } + if (was_error) { + return false; + } + return true; +} + +bool SDL_SaveBMP(SDL_Surface *surface, const char *file) +{ + SDL_IOStream *stream = SDL_IOFromFile(file, "wb"); + if (!stream) { + return false; + } + return SDL_SaveBMP_IO(surface, stream, true); +} -- cgit v1.2.3