// Copyright 2024 The Wuffs Authors. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. // // SPDX-License-Identifier: Apache-2.0 OR MIT // ---------------- Wuffs' reimplementation of the STB API. // // This is a drop-in replacement of that third-party library. // // Disabled by default, unless you #define the // WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB macro beforehand. // // For API docs, see https://github.com/nothings/stb #if defined(WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB) #include #include #ifdef __cplusplus extern "C" { #endif // -------- #if defined(__GNUC__) __thread const char* // wuffs_drop_in__stb__g_failure_reason = NULL; #elif defined(_MSC_VER) __declspec(thread) const char* // wuffs_drop_in__stb__g_failure_reason = NULL; #else const char* // wuffs_drop_in__stb__g_failure_reason = NULL; #endif // -------- static void // wuffs_drop_in__stb__read( // wuffs_base__io_buffer* srcbuf, // stbi_io_callbacks const* clbk, // void* user) { uint8_t* ptr = wuffs_base__io_buffer__writer_pointer(srcbuf); size_t len = wuffs_base__io_buffer__writer_length(srcbuf); if (len > INT_MAX) { len = INT_MAX; } int n = clbk->read(user, (char*)ptr, (int)len); if (n > 0) { srcbuf->meta.wi += (size_t)n; } else { srcbuf->meta.closed = clbk->eof(user); } } static wuffs_base__image_decoder* // wuffs_drop_in__stb__make_decoder( // wuffs_base__io_buffer* srcbuf, // stbi_io_callbacks const* clbk, // void* user) { while (1) { int32_t fourcc = wuffs_base__magic_number_guess_fourcc( wuffs_base__io_buffer__reader_slice(srcbuf), srcbuf->meta.closed); if (fourcc < 0) { if (srcbuf->meta.closed || !clbk) { break; } wuffs_drop_in__stb__read(srcbuf, clbk, user); continue; } switch (fourcc) { #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP) case WUFFS_BASE__FOURCC__BMP: return wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) case WUFFS_BASE__FOURCC__ETC2: return wuffs_etc2__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) case WUFFS_BASE__FOURCC__GIF: return wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__HANDSUM) case WUFFS_BASE__FOURCC__HNSM: return wuffs_handsum__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JPEG) case WUFFS_BASE__FOURCC__JPEG: return wuffs_jpeg__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE) case WUFFS_BASE__FOURCC__NIE: return wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NETPBM) case WUFFS_BASE__FOURCC__NPBM: return wuffs_netpbm__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG) case WUFFS_BASE__FOURCC__PNG: return wuffs_png__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__QOI) case WUFFS_BASE__FOURCC__QOI: return wuffs_qoi__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) case WUFFS_BASE__FOURCC__TGA: return wuffs_targa__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) case WUFFS_BASE__FOURCC__TH: return wuffs_thumbhash__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) case WUFFS_BASE__FOURCC__WBMP: return wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) case WUFFS_BASE__FOURCC__WEBP: return wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder(); #endif } wuffs_drop_in__stb__g_failure_reason = "unknown image type"; break; } return NULL; } // -------- static int // wuffs_drop_in__stb__channel_count( // wuffs_base__pixel_format pixfmt) { uint32_t n_color = wuffs_base__pixel_format__coloration(&pixfmt); uint32_t n_alpha = wuffs_base__pixel_format__transparency(&pixfmt) != WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE; return (int)(n_color + n_alpha); } static stbi_uc* // wuffs_drop_in__stb__load1( // wuffs_base__io_buffer* srcbuf, // stbi_io_callbacks const* clbk, // void* user, // wuffs_base__image_decoder* dec, // wuffs_base__image_config* ic, // int desired_channels, // int info_only) { // Favor faster decodes over rejecting invalid checksums. wuffs_base__image_decoder__set_quirk(dec, WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, 1); while (1) { wuffs_base__status status = wuffs_base__image_decoder__decode_image_config(dec, ic, srcbuf); if (status.repr == NULL) { break; } else if ((status.repr != wuffs_base__suspension__short_read) || !clbk) { wuffs_drop_in__stb__g_failure_reason = status.repr; return NULL; } if (wuffs_base__io_buffer__compact(srcbuf) <= 0) { wuffs_drop_in__stb__g_failure_reason = "I/O buffer is too small"; return NULL; } wuffs_drop_in__stb__read(srcbuf, clbk, user); } uint32_t w = wuffs_base__pixel_config__width(&ic->pixcfg); uint32_t h = wuffs_base__pixel_config__height(&ic->pixcfg); if ((w > 0xFFFFFF) || (h > 0xFFFFFF)) { wuffs_drop_in__stb__g_failure_reason = "image is too large"; return NULL; } else if (info_only) { return NULL; } wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format(0); wuffs_base__pixel_format src_pixfmt = wuffs_base__pixel_config__pixel_format(&ic->pixcfg); if (desired_channels == 0) { desired_channels = wuffs_drop_in__stb__channel_count(src_pixfmt); } switch (desired_channels) { case 1: dst_pixfmt.repr = WUFFS_BASE__PIXEL_FORMAT__Y; break; case 2: // As of March 2026, Wuffs doesn't support converting the full range of // source pixel formats to the YA_NONPREMUL destination pixel format. if (src_pixfmt.repr != WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL) { wuffs_drop_in__stb__g_failure_reason = "unsupported YA_NONPREMUL format conversion"; return NULL; } dst_pixfmt.repr = WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL; break; case 3: dst_pixfmt.repr = WUFFS_BASE__PIXEL_FORMAT__RGB; break; case 4: dst_pixfmt.repr = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL; break; default: wuffs_drop_in__stb__g_failure_reason = "internal format conversion error"; return NULL; } uint64_t pixbuf_len = (uint64_t)w * (uint64_t)h * (uint64_t)desired_channels; wuffs_base__range_ii_u64 r = wuffs_base__image_decoder__workbuf_len(dec); if (wuffs_base__range_ii_u64__is_empty(&r)) { wuffs_drop_in__stb__g_failure_reason = "indeterminate workbuf length"; return NULL; } uint64_t workbuf_len = r.max_incl; #if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull if ((pixbuf_len > ((uint64_t)SIZE_MAX)) || (workbuf_len > ((uint64_t)SIZE_MAX))) { wuffs_drop_in__stb__g_failure_reason = "image is too large"; return NULL; } #endif void* pixbuf_ptr = malloc((size_t)pixbuf_len); if (!pixbuf_ptr) { wuffs_drop_in__stb__g_failure_reason = "out of memory"; return NULL; } void* workbuf_ptr = malloc((size_t)workbuf_len); if (!workbuf_ptr) { free(pixbuf_ptr); wuffs_drop_in__stb__g_failure_reason = "out of memory"; return NULL; } wuffs_base__slice_u8 workbuf = wuffs_base__make_slice_u8((uint8_t*)workbuf_ptr, (size_t)workbuf_len); wuffs_base__pixel_config pc = wuffs_base__null_pixel_config(); wuffs_base__pixel_config__set(&pc, dst_pixfmt.repr, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h); wuffs_base__pixel_buffer pb = wuffs_base__null_pixel_buffer(); { wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( &pb, &pc, wuffs_base__make_slice_u8((uint8_t*)pixbuf_ptr, (size_t)pixbuf_len)); if (status.repr) { free(workbuf_ptr); free(pixbuf_ptr); wuffs_drop_in__stb__g_failure_reason = status.repr; return NULL; } } while (1) { wuffs_base__status status = wuffs_base__image_decoder__decode_frame( dec, &pb, srcbuf, WUFFS_BASE__PIXEL_BLEND__SRC, workbuf, NULL); if (status.repr == NULL) { break; } else if ((status.repr != wuffs_base__suspension__short_read) || !clbk) { free(workbuf_ptr); free(pixbuf_ptr); wuffs_drop_in__stb__g_failure_reason = status.repr; return NULL; } if (wuffs_base__io_buffer__compact(srcbuf) <= 0) { free(workbuf_ptr); free(pixbuf_ptr); wuffs_drop_in__stb__g_failure_reason = "I/O buffer is too small"; return NULL; } wuffs_drop_in__stb__read(srcbuf, clbk, user); } free(workbuf_ptr); return (stbi_uc*)pixbuf_ptr; } static stbi_uc* // wuffs_drop_in__stb__load0( // wuffs_base__io_buffer* srcbuf, // stbi_io_callbacks const* clbk, // void* user, // int* x, // int* y, // int* channels_in_file, // int desired_channels, // int info_only) { if ((desired_channels < 0) || (4 < desired_channels)) { wuffs_drop_in__stb__g_failure_reason = "bad desired_channels argument"; return NULL; } wuffs_base__image_decoder* dec = wuffs_drop_in__stb__make_decoder(srcbuf, clbk, user); if (!dec) { if (wuffs_drop_in__stb__g_failure_reason == NULL) { wuffs_drop_in__stb__g_failure_reason = "couldn't allocate image decoder"; } return NULL; } wuffs_base__image_config ic = wuffs_base__null_image_config(); stbi_uc* ret = wuffs_drop_in__stb__load1(srcbuf, clbk, user, dec, &ic, desired_channels, info_only); free(dec); if (!info_only && !ret) { return NULL; } if (x) { *x = (int)wuffs_base__pixel_config__width(&ic.pixcfg); } if (y) { *y = (int)wuffs_base__pixel_config__height(&ic.pixcfg); } if (channels_in_file) { *channels_in_file = wuffs_drop_in__stb__channel_count( wuffs_base__pixel_config__pixel_format(&ic.pixcfg)); } return ret; } // -------- WUFFS_DROP_IN__STB__MAYBE_STATIC int // stbi_info_from_memory( // stbi_uc const* buffer, // int len, // int* x, // int* y, // int* comp) { wuffs_drop_in__stb__g_failure_reason = NULL; if (len < 0) { wuffs_drop_in__stb__g_failure_reason = "negative buffer length"; return 0; } else if (len == 0) { wuffs_drop_in__stb__g_failure_reason = "empty buffer"; return 0; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__reader( wuffs_base__strip_const_from_u8_ptr((const uint8_t*)buffer), (size_t)len, true); wuffs_drop_in__stb__load0(&srcbuf, NULL, NULL, x, y, comp, 0, 1); return wuffs_drop_in__stb__g_failure_reason == NULL; } WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // stbi_load_from_memory( // stbi_uc const* buffer, // int len, // int* x, // int* y, // int* channels_in_file, // int desired_channels) { wuffs_drop_in__stb__g_failure_reason = NULL; if (len < 0) { wuffs_drop_in__stb__g_failure_reason = "negative buffer length"; return NULL; } else if (len == 0) { wuffs_drop_in__stb__g_failure_reason = "empty buffer"; return NULL; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__reader( wuffs_base__strip_const_from_u8_ptr((const uint8_t*)buffer), (size_t)len, true); return wuffs_drop_in__stb__load0(&srcbuf, NULL, NULL, x, y, channels_in_file, desired_channels, 0); } WUFFS_DROP_IN__STB__MAYBE_STATIC int // stbi_info_from_callbacks( // stbi_io_callbacks const* clbk, // void* user, // int* x, // int* y, // int* comp) { wuffs_drop_in__stb__g_failure_reason = NULL; void* iobuf_ptr = malloc(65536u); if (!iobuf_ptr) { wuffs_drop_in__stb__g_failure_reason = "out of memory"; return 0; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); wuffs_drop_in__stb__load0(&srcbuf, clbk, user, x, y, comp, 0, 1); free(iobuf_ptr); return wuffs_drop_in__stb__g_failure_reason == NULL; } WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // stbi_load_from_callbacks( // stbi_io_callbacks const* clbk, // void* user, // int* x, // int* y, // int* channels_in_file, // int desired_channels) { wuffs_drop_in__stb__g_failure_reason = NULL; void* iobuf_ptr = malloc(65536u); if (!iobuf_ptr) { wuffs_drop_in__stb__g_failure_reason = "out of memory"; return NULL; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); stbi_uc* ret = wuffs_drop_in__stb__load0( &srcbuf, clbk, user, x, y, channels_in_file, desired_channels, 0); free(iobuf_ptr); return ret; } WUFFS_DROP_IN__STB__MAYBE_STATIC void // stbi_image_free( // void* retval_from_stbi_load) { wuffs_drop_in__stb__g_failure_reason = NULL; free(retval_from_stbi_load); } WUFFS_DROP_IN__STB__MAYBE_STATIC const char* // stbi_failure_reason(void) { return wuffs_drop_in__stb__g_failure_reason ? wuffs_drop_in__stb__g_failure_reason : "ok"; } // -------- #if !defined(STBI_NO_STDIO) #include // TODO: retry after EINTR? static int // wuffs_drop_in__stb__file_callbacks__read( // void* user, // char* data, // int size) { return (int)fread(data, 1u, (size_t)size, (FILE*)user); } static void // wuffs_drop_in__stb__file_callbacks__skip( // void* user, // int n) { fseek((FILE*)user, (long)n, SEEK_CUR); } static int // wuffs_drop_in__stb__file_callbacks__eof( // void* user) { return feof((FILE*)user); } WUFFS_DROP_IN__STB__MAYBE_STATIC int // stbi_info( // char const* filename, // int* x, // int* y, // int* comp) { wuffs_drop_in__stb__g_failure_reason = NULL; FILE* f = fopen(filename, "rb"); if (!f) { wuffs_drop_in__stb__g_failure_reason = "could not open file"; return 0; } int ret = stbi_info_from_file(f, x, y, comp); fclose(f); return ret; } WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // stbi_load( // char const* filename, // int* x, // int* y, // int* channels_in_file, // int desired_channels) { wuffs_drop_in__stb__g_failure_reason = NULL; FILE* f = fopen(filename, "rb"); if (!f) { wuffs_drop_in__stb__g_failure_reason = "could not open file"; return NULL; } stbi_uc* ret = stbi_load_from_file(f, x, y, channels_in_file, desired_channels); fclose(f); return ret; } WUFFS_DROP_IN__STB__MAYBE_STATIC int // stbi_info_from_file( // FILE* f, // int* x, // int* y, // int* comp) { wuffs_drop_in__stb__g_failure_reason = NULL; void* iobuf_ptr = malloc(65536u); if (!iobuf_ptr) { wuffs_drop_in__stb__g_failure_reason = "out of memory"; return 0; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); stbi_io_callbacks clbk; clbk.read = &wuffs_drop_in__stb__file_callbacks__read; clbk.skip = &wuffs_drop_in__stb__file_callbacks__skip; clbk.eof = &wuffs_drop_in__stb__file_callbacks__eof; wuffs_drop_in__stb__load0(&srcbuf, &clbk, f, x, y, comp, 0, 1); free(iobuf_ptr); return wuffs_drop_in__stb__g_failure_reason == NULL; } WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // stbi_load_from_file( // FILE* f, // int* x, // int* y, // int* channels_in_file, // int desired_channels) { wuffs_drop_in__stb__g_failure_reason = NULL; void* iobuf_ptr = malloc(65536u); if (!iobuf_ptr) { wuffs_drop_in__stb__g_failure_reason = "out of memory"; return NULL; } wuffs_base__io_buffer srcbuf = wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); stbi_io_callbacks clbk; clbk.read = &wuffs_drop_in__stb__file_callbacks__read; clbk.skip = &wuffs_drop_in__stb__file_callbacks__skip; clbk.eof = &wuffs_drop_in__stb__file_callbacks__eof; stbi_uc* ret = wuffs_drop_in__stb__load0( &srcbuf, &clbk, f, x, y, channels_in_file, desired_channels, 0); free(iobuf_ptr); return ret; } #endif // !defined(STBI_NO_STDIO) // -------- #ifdef __cplusplus } // extern "C" #endif #endif // defined (WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB)