From c212e5ce1e74a1bbe041d4c3364e62e8d7687edd Mon Sep 17 00:00:00 2001 From: Katajisto Date: Thu, 1 May 2025 13:34:08 +0300 Subject: [PATCH] add stb image --- modules/sokol-jai/sokol/build_clibs_wasm.sh | 2 + modules/sokol-jai/sokol/c/stb_image.c | 11 + modules/sokol-jai/sokol/c/stb_image.h | 7985 ++++++++++++++++++ modules/stb_image/android/arm64/stb_image.a | Bin 0 -> 160804 bytes modules/stb_image/android/arm64/stb_image.so | Bin 0 -> 133064 bytes modules/stb_image/android/x64/stb_image.a | Bin 0 -> 175444 bytes modules/stb_image/android/x64/stb_image.so | Bin 0 -> 143520 bytes modules/stb_image/bindings.jai | 145 + modules/stb_image/generate.jai | 151 + modules/stb_image/linux/stb_image.a | Bin 0 -> 166596 bytes modules/stb_image/linux/stb_image.so | Bin 0 -> 146568 bytes modules/stb_image/module.jai | 12 + modules/stb_image/source/stb_image.c | 11 + modules/stb_image/source/stb_image.h | 7985 ++++++++++++++++++ modules/stb_image/windows/stb_image.dll | Bin 0 -> 277504 bytes modules/stb_image/windows/stb_image.lib | Bin 0 -> 289394 bytes 16 files changed, 16302 insertions(+) create mode 100644 modules/sokol-jai/sokol/c/stb_image.c create mode 100644 modules/sokol-jai/sokol/c/stb_image.h create mode 100644 modules/stb_image/android/arm64/stb_image.a create mode 100644 modules/stb_image/android/arm64/stb_image.so create mode 100644 modules/stb_image/android/x64/stb_image.a create mode 100644 modules/stb_image/android/x64/stb_image.so create mode 100644 modules/stb_image/bindings.jai create mode 100644 modules/stb_image/generate.jai create mode 100644 modules/stb_image/linux/stb_image.a create mode 100755 modules/stb_image/linux/stb_image.so create mode 100644 modules/stb_image/module.jai create mode 100644 modules/stb_image/source/stb_image.c create mode 100644 modules/stb_image/source/stb_image.h create mode 100644 modules/stb_image/windows/stb_image.dll create mode 100644 modules/stb_image/windows/stb_image.lib diff --git a/modules/sokol-jai/sokol/build_clibs_wasm.sh b/modules/sokol-jai/sokol/build_clibs_wasm.sh index 35f92ca..7bc75f2 100755 --- a/modules/sokol-jai/sokol/build_clibs_wasm.sh +++ b/modules/sokol-jai/sokol/build_clibs_wasm.sh @@ -30,6 +30,7 @@ build_lib_wasm_release sokol_shape shape/sokol_shape_wasm_gl_release SOKOL build_lib_wasm_release sokol_fontstash fontstash/sokol_fontstash_wasm_gl_release SOKOL_GLES3 build_lib_wasm_release sokol_fetch fetch/sokol_fetch_wasm_gl_release SOKOL_GLES3 build_lib_wasm_release sokol_gl gl/sokol_gl_wasm_gl_release SOKOL_GLES3 +build_lib_wasm_release stb_image stbi/stb_image SOKOL_GLES3 # wasm + GL + Debug build_lib_wasm_debug sokol_log log/sokol_log_wasm_gl_debug SOKOL_GLES3 @@ -43,5 +44,6 @@ build_lib_wasm_debug sokol_shape shape/sokol_shape_wasm_gl_debug SOKOL_G build_lib_wasm_debug sokol_fontstash fontstash/sokol_fontstash_wasm_gl_debug SOKOL_GLES3 build_lib_wasm_debug sokol_fetch fetch/sokol_fetch_wasm_gl_debug SOKOL_GLES3 build_lib_wasm_debug sokol_gl gl/sokol_gl_wasm_gl_debug SOKOL_GLES3 +build_lib_wasm_debug stb_image stbi/stb_image SOKOL_GLES3 rm *.o diff --git a/modules/sokol-jai/sokol/c/stb_image.c b/modules/sokol-jai/sokol/c/stb_image.c new file mode 100644 index 0000000..da81036 --- /dev/null +++ b/modules/sokol-jai/sokol/c/stb_image.c @@ -0,0 +1,11 @@ +#ifdef WIN32 +#define __EXPORT __declspec(dllexport) +#else +#define __EXPORT +#endif + +#define STBIDEF extern __EXPORT + +#define STBI_NO_STDIO +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" diff --git a/modules/sokol-jai/sokol/c/stb_image.h b/modules/sokol-jai/sokol/c/stb_image.h new file mode 100644 index 0000000..a632d54 --- /dev/null +++ b/modules/sokol-jai/sokol/c/stb_image.h @@ -0,0 +1,7985 @@ +/* stb_image - v2.29 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/modules/stb_image/android/arm64/stb_image.a b/modules/stb_image/android/arm64/stb_image.a new file mode 100644 index 0000000000000000000000000000000000000000..45b38a5f62c897fbf7b652988d6bc3893f8ea6f2 GIT binary patch literal 160804 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�zkl*)7sf5%_$aL| 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%0D`CLP9})c+vtNyZ+<81otU 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 literal 0 HcmV?d00001 diff --git a/modules/stb_image/android/x64/stb_image.a b/modules/stb_image/android/x64/stb_image.a new file mode 100644 index 0000000000000000000000000000000000000000..17c8b88c06d8775404cbb2f19fa662ae7e43790a GIT binary patch literal 175444 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�+y^D@DZx*Bu+r?Mkt6j>n=O!8kX^47qcQ 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 literal 0 HcmV?d00001 diff --git a/modules/stb_image/android/x64/stb_image.so b/modules/stb_image/android/x64/stb_image.so new file mode 100644 index 0000000000000000000000000000000000000000..8a9422747854b4b59f9e71cc184e24ceeb9c1c9f GIT binary patch literal 143520 zcmdqK4SZC^^*4U+?glmxau)!Upc@Mk548K_TRYL_-pjjbM2T z?nZN67O2t|TeP&&*0%bCR*KY8-SCnGU&D)t?-5aUUD1FD2_pOdp1Jq#-VGbk{%Zfv z^DLj6xpQXb%$YN1&YU?jb6J|}oMhm6PWu_T@mw^`e;wTBt8aw65Y5 zf>v2$!!0VETG+i@zER1LKPon~sLYzFhFUqwMfLgB`uu8rT3D^-*FudiQ$BGO6JO3n zXSIM#_-WPVtK}+2DDduKrpjzB)Odd@$`PGE^hf3CsaE;cJzS$A)Iv2INA2|BA-cuN z;+m@RV(t>W*IaY$90dRNFC#rWJv-x?(f>Ar9tskj1LCBSIL3ot)C0V%2e`incykZ% zS9^dT?g9Qq5Ad&hfd3W^j@PcIdw{n9t`1FLjQ-Nl;qmYcgV4l-Z|MR4Vh`{gJ-}b- z0p8XF{H-3~AM^nKv#cOZB9^lp<;G=thJ9>cM(gS=>5Ab>Dx&d4g*QV;z z-fCBdRd`3C0yq!-O}~p+|0Z$P#Y()73QuKxNaCu0p}?&w{8EI3pPQ?|)qtC>!t-f> z;HSZlsrb`ZD)1Fbz)d$Qc-E~_05_`eH7cC@nF7%0AFSfvSfb`v>3Kzk=hP|i4^=#$ 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 literal 0 HcmV?d00001 diff --git a/modules/stb_image/bindings.jai b/modules/stb_image/bindings.jai new file mode 100644 index 0000000..fb4fe14 --- /dev/null +++ b/modules/stb_image/bindings.jai @@ -0,0 +1,145 @@ +// +// This file was auto-generated using the following command: +// +// jai generate.jai +// + + + +STBI_VERSION :: 1; + +STBI :: enum u32 { + default :: 0; + + grey :: 1; + grey_alpha :: 2; + rgb :: 3; + rgb_alpha :: 4; + + STBI_default :: default; + + STBI_grey :: grey; + STBI_grey_alpha :: grey_alpha; + STBI_rgb :: rgb; + STBI_rgb_alpha :: rgb_alpha; +} + +// +// load image by filename, open file, or memory buffer +// +stbi_io_callbacks :: struct { + read: #type (user: *void, data: *u8, size: s32) -> s32 #c_call; // fill 'data' with 'size' bytes. return number of bytes actually read + skip: #type (user: *void, n: s32) -> void #c_call; // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + eof: #type (user: *void) -> s32 #c_call; // returns nonzero if we are at end of file/data +} + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// +stbi_load_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image; +stbi_load_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image; + +stbi_load :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image; +stbi_load_from_file :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u8 #foreign stb_image; + +stbi_load_gif_from_memory :: (buffer: *u8, len: s32, delays: **s32, x: *s32, y: *s32, z: *s32, comp: *s32, req_comp: s32) -> *u8 #foreign stb_image; + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// +stbi_load_16_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image; +stbi_load_16_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image; + +stbi_load_16 :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image; +stbi_load_from_file_16 :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *u16 #foreign stb_image; + +stbi_loadf_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image; +stbi_loadf_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image; + +stbi_loadf :: (filename: *u8, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image; +stbi_loadf_from_file :: (f: *FILE, x: *s32, y: *s32, channels_in_file: *s32, desired_channels: s32) -> *float #foreign stb_image; + +stbi_hdr_to_ldr_gamma :: (gamma: float) -> void #foreign stb_image; +stbi_hdr_to_ldr_scale :: (scale: float) -> void #foreign stb_image; + +stbi_ldr_to_hdr_gamma :: (gamma: float) -> void #foreign stb_image; +stbi_ldr_to_hdr_scale :: (scale: float) -> void #foreign stb_image; + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +stbi_is_hdr_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void) -> s32 #foreign stb_image; +stbi_is_hdr_from_memory :: (buffer: *u8, len: s32) -> s32 #foreign stb_image; + +stbi_is_hdr :: (filename: *u8) -> s32 #foreign stb_image; +stbi_is_hdr_from_file :: (f: *FILE) -> s32 #foreign stb_image; + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +stbi_failure_reason :: () -> *u8 #foreign stb_image; + +// free the loaded image -- this is just free() +stbi_image_free :: (retval_from_stbi_load: *void) -> void #foreign stb_image; + +// get image dimensions & components without fully decoding +stbi_info_from_memory :: (buffer: *u8, len: s32, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image; +stbi_info_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image; +stbi_is_16_bit_from_memory :: (buffer: *u8, len: s32) -> s32 #foreign stb_image; +stbi_is_16_bit_from_callbacks :: (clbk: *stbi_io_callbacks, user: *void) -> s32 #foreign stb_image; + +stbi_info :: (filename: *u8, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image; +stbi_info_from_file :: (f: *FILE, x: *s32, y: *s32, comp: *s32) -> s32 #foreign stb_image; +stbi_is_16_bit :: (filename: *u8) -> s32 #foreign stb_image; +stbi_is_16_bit_from_file :: (f: *FILE) -> s32 #foreign stb_image; + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +stbi_set_unpremultiply_on_load :: (flag_true_if_should_unpremultiply: s32) -> void #foreign stb_image; + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +stbi_convert_iphone_png_to_rgb :: (flag_true_if_should_convert: s32) -> void #foreign stb_image; + +// flip the image vertically, so the first pixel in the output array is the bottom left +stbi_set_flip_vertically_on_load :: (flag_true_if_should_flip: s32) -> void #foreign stb_image; + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +stbi_set_unpremultiply_on_load_thread :: (flag_true_if_should_unpremultiply: s32) -> void #foreign stb_image; +stbi_convert_iphone_png_to_rgb_thread :: (flag_true_if_should_convert: s32) -> void #foreign stb_image; +stbi_set_flip_vertically_on_load_thread :: (flag_true_if_should_flip: s32) -> void #foreign stb_image; + +// ZLIB client - used by PNG, available for other purposes +stbi_zlib_decode_malloc_guesssize :: (buffer: *u8, len: s32, initial_size: s32, outlen: *s32) -> *u8 #foreign stb_image; +stbi_zlib_decode_malloc_guesssize_headerflag :: (buffer: *u8, len: s32, initial_size: s32, outlen: *s32, parse_header: s32) -> *u8 #foreign stb_image; +stbi_zlib_decode_malloc :: (buffer: *u8, len: s32, outlen: *s32) -> *u8 #foreign stb_image; +stbi_zlib_decode_buffer :: (obuffer: *u8, olen: s32, ibuffer: *u8, ilen: s32) -> s32 #foreign stb_image; + +stbi_zlib_decode_noheader_malloc :: (buffer: *u8, len: s32, outlen: *s32) -> *u8 #foreign stb_image; +stbi_zlib_decode_noheader_buffer :: (obuffer: *u8, olen: s32, ibuffer: *u8, ilen: s32) -> s32 #foreign stb_image; + +#scope_file + + +#if OS == .WINDOWS { + stb_image :: #library "windows/stb_image"; +} else #if OS == .LINUX { + stb_image :: #library "linux/stb_image"; +} else #if OS == .MACOS { + stb_image :: #library "macos/stb_image"; +} else #if OS == .ANDROID { + #if CPU == .X64 { + stb_image :: #library "android/x64/stb_image"; + } else #if CPU == .ARM64 { + stb_image :: #library "android/arm64/stb_image"; + } +} else #if OS == .PS5 { + stb_image :: #library "ps5/stb_image"; +} else #if OS == .WASM { + stb_image :: #library "wasm/stb_image"; +} else { + #assert false; +} + diff --git a/modules/stb_image/generate.jai b/modules/stb_image/generate.jai new file mode 100644 index 0000000..8f9e3bf --- /dev/null +++ b/modules/stb_image/generate.jai @@ -0,0 +1,151 @@ +AT_COMPILE_TIME :: true; + +SOURCE_PATH :: "source"; +LIB_BASE_NAME :: "stb_image"; + +#if AT_COMPILE_TIME { + #run,stallable { + set_build_options_dc(.{do_output=false}); + options := get_build_options(); + args := options.compile_time_command_line; + if !generate_bindings(args, options.minimum_os_version) { + compiler_set_workspace_status(.FAILED); + } + } +} else { + #import "System"; + + main :: () { + set_working_directory(path_strip_filename(get_path_of_running_executable())); + if !generate_bindings(get_command_line_arguments(), #run get_build_options().minimum_os_version) { + exit(1); + } + } +} + +generate_bindings :: (args: [] string, minimum_os_version: type_of(Build_Options.minimum_os_version)) -> bool { + target_android := array_find(args, "-android"); + target_x64 := array_find(args, "-x64"); + target_arm := array_find(args, "-arm64"); + compile := array_find(args, "-compile"); + compile_debug := array_find(args, "-debug"); + + os_target := OS; + cpu_target := CPU; + if target_android os_target = .ANDROID; + if target_x64 cpu_target = .X64; + if target_arm cpu_target = .ARM64; + + lib_directory: string; + if os_target == { + case .WINDOWS; + lib_directory = "windows"; + case .LINUX; + lib_directory = "linux"; + case .MACOS; + lib_directory = "macos"; + case .ANDROID; + lib_directory = ifx cpu_target == .X64 then "android/x64" else "android/arm64"; + case .PS5; + lib_directory = "ps5"; + case; + assert(false); + } + + if compile { + source_file := tprint("%/stb_image.c", SOURCE_PATH); + + make_directory_if_it_does_not_exist(lib_directory, recursive = true); + lib_path := tprint("%/%", lib_directory, LIB_BASE_NAME); + success := true; + if os_target == .MACOS { + lib_path_x64 := tprint("%_x64", lib_path); + lib_path_arm64 := tprint("%_arm64", lib_path); + macos_x64_version_arg := "-mmacos-version-min=10.13"; // Our current x64 min version + macos_arm64_version_arg := "-mmacos-version-min=11.0"; // Earliest version that supports arm64 + // x64 variant + success &&= build_cpp_dynamic_lib(lib_path_x64, source_file, extra = .["-arch", "x86_64", macos_x64_version_arg], debug=compile_debug); + success &&= build_cpp_static_lib( lib_path_x64, source_file, extra = .["-arch", "x86_64", macos_x64_version_arg], debug=compile_debug); + // arm64 variant + success &&= build_cpp_dynamic_lib(lib_path_arm64, source_file, extra = .["-arch", "arm64", macos_arm64_version_arg], debug=compile_debug); + success &&= build_cpp_static_lib( lib_path_arm64, source_file, extra = .["-arch", "arm64", macos_arm64_version_arg], debug=compile_debug); + // create universal binaries + run_result := run_command("lipo", "-create", tprint("%.dylib", lib_path_x64), tprint("%.dylib", lib_path_arm64), "-output", tprint("%.dylib", lib_path)); + success &&= (run_result.exit_code == 0); + run_result = run_command("lipo", "-create", tprint("%.a", lib_path_x64), tprint("%.a", lib_path_arm64), "-output", tprint("%.a", lib_path)); + success &&= (run_result.exit_code == 0); + } else { + extra: [..] string; + if os_target == .ANDROID { + _, target_triple_with_sdk := get_android_target_triple(cpu_target); + array_add(*extra, "-target", target_triple_with_sdk); + } + if os_target != .WINDOWS { + array_add(*extra, "-fPIC"); + } + + if os_target != .PS5 && os_target != .WASM { + success &&= build_cpp_dynamic_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra); + } + success &&= build_cpp_static_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra); + } + + if !success return false; + } + + options: Generate_Bindings_Options; + options.os = os_target; + options.cpu = cpu_target; + { + using options; + + array_add(*libpaths, lib_directory); + array_add(*libnames, LIB_BASE_NAME); + array_add(*source_files, tprint("%/stb_image.h", SOURCE_PATH)); + array_add(*typedef_prefixes_to_unwrap, "stbi_"); + + + generate_library_declarations = false; + footer = tprint(FOOTER_TEMPLATE, LIB_BASE_NAME); + + auto_detect_enum_prefixes = true; + log_stripped_declarations = false; + generate_compile_time_struct_checks = false; + } + + output_filename := "bindings.jai"; + return generate_bindings(options, output_filename); +} + +FOOTER_TEMPLATE :: #string END + +#if OS == .WINDOWS { + %1 :: #library "windows/%1"; +} else #if OS == .LINUX { + %1 :: #library "linux/%1"; +} else #if OS == .MACOS { + %1 :: #library "macos/%1"; +} else #if OS == .ANDROID { + #if CPU == .X64 { + %1 :: #library "android/x64/%1"; + } else #if CPU == .ARM64 { + %1 :: #library "android/arm64/%1"; + } +} else #if OS == .PS5 { + %1 :: #library "ps5/%1"; +} else #if OS == .WASM { + // Wasm will be linked with emcc. +} else { + #assert false; +} + +END + +#import "Basic"; +#import "Bindings_Generator"; +#import "BuildCpp"; +#import "Compiler"; +#import "File"; +#import "Process"; +#import "Toolchains/Android"; + diff --git a/modules/stb_image/linux/stb_image.a b/modules/stb_image/linux/stb_image.a new file mode 100644 index 0000000000000000000000000000000000000000..fa8f92520d62eb751108a6b55f021f73eae83184 GIT binary patch literal 166596 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 literal 0 HcmV?d00001 diff --git a/modules/stb_image/linux/stb_image.so b/modules/stb_image/linux/stb_image.so new file mode 100755 index 0000000000000000000000000000000000000000..e12cea9bc6caa093ef9000b3a399c0d7664c3800 GIT binary patch literal 146568 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É?0TsWDa-Im+xx#^^Dl$BoV$oiU!qyT+R8%Ec^b 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 +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/modules/stb_image/windows/stb_image.dll b/modules/stb_image/windows/stb_image.dll new file mode 100644 index 0000000000000000000000000000000000000000..f27c3c39525a71ddb5f53926f1ac42e4f72f1ca4 GIT binary patch literal 277504 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 P@jE1{|NHybHSj+G6)~Na literal 0 HcmV?d00001 diff --git a/modules/stb_image/windows/stb_image.lib b/modules/stb_image/windows/stb_image.lib new file mode 100644 index 0000000000000000000000000000000000000000..aa89310d731539ca3e958adf72d39baece15de5c GIT binary patch literal 289394 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 f`TS!94}Wzms!xHA>$v;C}^}&y#R-zDD;2cq!ex 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 xLt77cXW7uKzL`_~*D?%kt#6P*>+`N