0/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
1 no warranty implied; use at your own risk
3 Do this:
4 #define STB_IMAGE_IMPLEMENTATION
5 before you include this file in *one* C or C++ file to create the implementation.
7 // i.e. it should look like this:
8 #include ...
9 #include ...
10 #include ...
11 #define STB_IMAGE_IMPLEMENTATION
12 #include "stb_image.h"
14 You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
15 And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
18 QUICK NOTES:
19 Primarily of interest to game developers and other people who can
20 avoid problematic images and only need the trivial interface
22 JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
23 PNG 1/2/4/8/16-bit-per-channel
25 TGA (not sure what subset, if a subset)
26 BMP non-1bpp, non-RLE
27 PSD (composited view only, no extra channels, 8/16 bit-per-channel)
29 GIF (*comp always reports as 4-channel)
30 HDR (radiance rgbE format)
31 PIC (Softimage PIC)
32 PNM (PPM and PGM binary only)
34 Animated GIF still needs a proper API, but here's one way to do it:
35 http://gist.github.com/urraka/685d9a6340b26b830d49
37 - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
38 - decode from arbitrary I/O callbacks
39 - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
41 Full documentation under "DOCUMENTATION" below.
44LICENSE
46 See end of file for license information.
48RECENT REVISION HISTORY:
50 2.30 (2024-05-31) avoid erroneous gcc warning
51 2.29 (2023-05-xx) optimizations
52 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff
53 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
54 2.26 (2020-07-13) many minor fixes
55 2.25 (2020-02-02) fix warnings
56 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
57 2.23 (2019-08-11) fix clang static analysis warning
58 2.22 (2019-03-04) gif fixes, fix warnings
59 2.21 (2019-02-25) fix typo in comment
60 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
61 2.19 (2018-02-11) fix warning
62 2.18 (2018-01-30) fix warnings
63 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
64 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
65 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
66 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
67 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
68 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
69 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
70 RGB-format JPEG; remove white matting in PSD;
71 allocate large structures on the stack;
72 correct channel count for PNG & BMP
73 2.10 (2016-01-22) avoid warning introduced in 2.09
74 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
76 See end of file for full revision history.
79 ============================ Contributors =========================
81 Image formats Extensions, features
82 Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info)
83 Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info)
84 Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG)
85 Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks)
86 Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG)
87 Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)
88 Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)
89 github:urraka (animated gif) Junggon Kim (PNM comments)
90 Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)
91 socks-the-fox (16-bit PNG)
92 Jeremy Sawicki (handle all ImageNet JPGs)
93 Optimizations & bugfixes Mikhail Morozov (1-bit BMP)
94 Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query)
95 Arseny Kapoulkine Simon Breuss (16-bit PNM)
96 John-Mark Allen
97 Carmelo J Fdez-Aguera
99 Bug & warning fixes
100 Marc LeBlanc David Woo Guillaume George Martins Mozeiko
101 Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski
102 Phil Jordan Dave Moore Roy Eltham
103 Hayaki Saito Nathan Reed Won Chun
104 Luke Graham Johan Duparc Nick Verigakis the Horde3D community
105 Thomas Ruf Ronny Chevalier github:rlyeh
106 Janez Zemva John Bartholomew Michal Cichon github:romigrou
107 Jonathan Blow Ken Hamada Tero Hanninen github:svdijk
108 Eugene Golushkov Laurent Gomila Cort Stratton github:snagar
109 Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex
110 Cass Everitt Ryamond Barbiero github:grim210
111 Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw
112 Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus
113 Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo
114 Julian Raschke Gregory Mullen Christian Floisand github:darealshinji
115 Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007
116 Brad Weinberger Matvey Cherevko github:mosra
117 Luca Sas Alexander Veselov Zack Middleton [reserved]
118 Ryan C. Gordon [reserved] [reserved]
119 DO NOT ADD YOUR NAME HERE
121 Jacko Dirks
123 To add your name to the credits, pick a random blank space in the middle and fill it.
124 80% of merge conflicts on stb PRs are due to people adding their name at the end
125 of the credits.
126*/
128#ifndef STBI_INCLUDE_STB_IMAGE_H
129#define STBI_INCLUDE_STB_IMAGE_H
131// DOCUMENTATION
132//
133// Limitations:
134// - no 12-bit-per-channel JPEG
135// - no JPEGs with arithmetic coding
136// - GIF always returns *comp=4
137//
138// Basic usage (see HDR discussion below for HDR usage):
139// int x,y,n;
140// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
141// // ... process data if not NULL ...
142// // ... x = width, y = height, n = # 8-bit components per pixel ...
143// // ... replace '0' with '1'..'4' to force that many components per pixel
144// // ... but 'n' will always be the number that it would have been if you said 0
145// stbi_image_free(data);
146//
147// Standard parameters:
148// int *x -- outputs image width in pixels
149// int *y -- outputs image height in pixels
150// int *channels_in_file -- outputs # of image components in image file
151// int desired_channels -- if non-zero, # of image components requested in result
152//
153// The return value from an image loader is an 'unsigned char *' which points
154// to the pixel data, or NULL on an allocation failure or if the image is
155// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
156// with each pixel consisting of N interleaved 8-bit components; the first
157// pixel pointed to is top-left-most in the image. There is no padding between
158// image scanlines or between pixels, regardless of format. The number of
159// components N is 'desired_channels' if desired_channels is non-zero, or
160// *channels_in_file otherwise. If desired_channels is non-zero,
161// *channels_in_file has the number of components that _would_ have been
162// output otherwise. E.g. if you set desired_channels to 4, you will always
163// get RGBA output, but you can check *channels_in_file to see if it's trivially
164// opaque because e.g. there were only 3 channels in the source image.
165//
166// An output image with N components has the following components interleaved
167// in this order in each pixel:
168//
169// N=#comp components
170// 1 grey
171// 2 grey, alpha
172// 3 red, green, blue
173// 4 red, green, blue, alpha
174//
175// If image loading fails for any reason, the return value will be NULL,
176// and *x, *y, *channels_in_file will be unchanged. The function
177// stbi_failure_reason() can be queried for an extremely brief, end-user
178// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
179// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
180// more user-friendly ones.
181//
182// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
183//
184// To query the width, height and component count of an image without having to
185// decode the full file, you can use the stbi_info family of functions:
186//
187// int x,y,n,ok;
188// ok = stbi_info(filename, &x, &y, &n);
189// // returns ok=1 and sets x, y, n if image is a supported format,
190// // 0 otherwise.
191//
192// Note that stb_image pervasively uses ints in its public API for sizes,
193// including sizes of memory buffers. This is now part of the API and thus
194// hard to change without causing breakage. As a result, the various image
195// loaders all have certain limits on image size; these differ somewhat
196// by format but generally boil down to either just under 2GB or just under
197// 1GB. When the decoded image would be larger than this, stb_image decoding
198// will fail.
199//
200// Additionally, stb_image will reject image files that have any of their
201// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
202// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
203// the only way to have an image with such dimensions load correctly
204// is for it to have a rather extreme aspect ratio. Either way, the
205// assumption here is that such larger images are likely to be malformed
206// or malicious. If you do need to load an image with individual dimensions
207// larger than that, and it still fits in the overall size limit, you can
208// #define STBI_MAX_DIMENSIONS on your own to be something larger.
209//
210// ===========================================================================
211//
212// UNICODE:
213//
214// If compiling for Windows and you wish to use Unicode filenames, compile
215// with
216// #define STBI_WINDOWS_UTF8
217// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
218// Windows wchar_t filenames to utf8.
219//
220// ===========================================================================
221//
222// Philosophy
223//
224// stb libraries are designed with the following priorities:
225//
226// 1. easy to use
227// 2. easy to maintain
228// 3. good performance
229//
230// Sometimes I let "good performance" creep up in priority over "easy to maintain",
231// and for best performance I may provide less-easy-to-use APIs that give higher
232// performance, in addition to the easy-to-use ones. Nevertheless, it's important
233// to keep in mind that from the standpoint of you, a client of this library,
234// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
235//
236// Some secondary priorities arise directly from the first two, some of which
237// provide more explicit reasons why performance can't be emphasized.
238//
239// - Portable ("ease of use")
240// - Small source code footprint ("easy to maintain")
241// - No dependencies ("ease of use")
242//
243// ===========================================================================
244//
245// I/O callbacks
246//
247// I/O callbacks allow you to read from arbitrary sources, like packaged
248// files or some other source. Data read from callbacks are processed
249// through a small internal buffer (currently 128 bytes) to try to reduce
250// overhead.
251//
252// The three functions you must define are "read" (reads some bytes of data),
253// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
254//
255// ===========================================================================
256//
257// SIMD support
258//
259// The JPEG decoder will try to automatically use SIMD kernels on x86 when
260// supported by the compiler. For ARM Neon support, you must explicitly
261// request it.
262//
263// (The old do-it-yourself SIMD API is no longer supported in the current
264// code.)
265//
266// On x86, SSE2 will automatically be used when available based on a run-time
267// test; if not, the generic C versions are used as a fall-back. On ARM targets,
268// the typical path is to have separate builds for NEON and non-NEON devices
269// (at least this is true for iOS and Android). Therefore, the NEON support is
270// toggled by a build flag: define STBI_NEON to get NEON loops.
271//
272// If for some reason you do not want to use any of SIMD code, or if
273// you have issues compiling it, you can disable it entirely by
274// defining STBI_NO_SIMD.
275//
276// ===========================================================================
277//
278// HDR image support (disable by defining STBI_NO_HDR)
279//
280// stb_image supports loading HDR images in general, and currently the Radiance
281// .HDR file format specifically. You can still load any file through the existing
282// interface; if you attempt to load an HDR file, it will be automatically remapped
283// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
284// both of these constants can be reconfigured through this interface:
285//
286// stbi_hdr_to_ldr_gamma(2.2f);
287// stbi_hdr_to_ldr_scale(1.0f);
288//
289// (note, do not use _inverse_ constants; stbi_image will invert them
290// appropriately).
291//
292// Additionally, there is a new, parallel interface for loading files as
293// (linear) floats to preserve the full dynamic range:
294//
295// float *data = stbi_loadf(filename, &x, &y, &n, 0);
296//
297// If you load LDR images through this interface, those images will
298// be promoted to floating point values, run through the inverse of
299// constants corresponding to the above:
300//
301// stbi_ldr_to_hdr_scale(1.0f);
302// stbi_ldr_to_hdr_gamma(2.2f);
303//
304// Finally, given a filename (or an open file or memory block--see header
305// file for details) containing image data, you can query for the "most
306// appropriate" interface to use (that is, whether the image is HDR or
307// not), using:
308//
309// stbi_is_hdr(char *filename);
310//
311// ===========================================================================
312//
313// iPhone PNG support:
314//
315// We optionally support converting iPhone-formatted PNGs (which store
316// premultiplied BGRA) back to RGB, even though they're internally encoded
317// differently. To enable this conversion, call
318// stbi_convert_iphone_png_to_rgb(1).
319//
320// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
321// pixel to remove any premultiplied alpha *only* if the image file explicitly
322// says there's premultiplied data (currently only happens in iPhone images,
323// and only if iPhone convert-to-rgb processing is on).
324//
325// ===========================================================================
326//
327// ADDITIONAL CONFIGURATION
328//
329// - You can suppress implementation of any of the decoders to reduce
330// your code footprint by #defining one or more of the following
331// symbols before creating the implementation.
332//
333// STBI_NO_JPEG
334// STBI_NO_PNG
335// STBI_NO_BMP
336// STBI_NO_PSD
337// STBI_NO_TGA
338// STBI_NO_GIF
339// STBI_NO_HDR
340// STBI_NO_PIC
341// STBI_NO_PNM (.ppm and .pgm)
342//
343// - You can request *only* certain decoders and suppress all other ones
344// (this will be more forward-compatible, as addition of new decoders
345// doesn't require you to disable them explicitly):
346//
347// STBI_ONLY_JPEG
348// STBI_ONLY_PNG
349// STBI_ONLY_BMP
350// STBI_ONLY_PSD
351// STBI_ONLY_TGA
352// STBI_ONLY_GIF
353// STBI_ONLY_HDR
354// STBI_ONLY_PIC
355// STBI_ONLY_PNM (.ppm and .pgm)
356//
357// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
358// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
359//
360// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
361// than that size (in either width or height) without further processing.
362// This is to let programs in the wild set an upper bound to prevent
363// denial-of-service attacks on untrusted data, as one could generate a
364// valid image of gigantic dimensions and force stb_image to allocate a
365// huge block of memory and spend disproportionate time decoding it. By
366// default this is set to (1 << 24), which is 16777216, but that's still
367// very big.
369#ifndef STBI_NO_STDIO
370#include <stdio.h>
371#endif // STBI_NO_STDIO
373#define STBI_VERSION 1
375enum
376{
377 STBI_default = 0, // only used for desired_channels
379 STBI_grey = 1,
380 STBI_grey_alpha = 2,
381 STBI_rgb = 3,
382 STBI_rgb_alpha = 4
383};
385#include <stdlib.h>
386typedef unsigned char stbi_uc;
387typedef unsigned short stbi_us;
389#ifdef __cplusplus
390extern "C" {
391#endif
393#ifndef STBIDEF
394#ifdef STB_IMAGE_STATIC
395#define STBIDEF static
396#else
397#define STBIDEF extern
398#endif
399#endif
401//////////////////////////////////////////////////////////////////////////////
402//
403// PRIMARY API - works on images of any type
404//
406//
407// load image by filename, open file, or memory buffer
408//
410typedef struct
411{
412 int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
413 void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
414 int (*eof) (void *user); // returns nonzero if we are at end of file/data
415} stbi_io_callbacks;
417////////////////////////////////////
418//
419// 8-bits-per-channel interface
420//
422STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels);
423STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
425#ifndef STBI_NO_STDIO
426STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
427STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
428// for stbi_load_from_file, file pointer is left pointing immediately after image
429#endif
431#ifndef STBI_NO_GIF
432STBIDEF 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);
433#endif
435#ifdef STBI_WINDOWS_UTF8
436STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
437#endif
439////////////////////////////////////
440//
441// 16-bits-per-channel interface
442//
444STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
445STBIDEF 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);
447#ifndef STBI_NO_STDIO
448STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
449STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
450#endif
452////////////////////////////////////
453//
454// float-per-channel interface
455//
456#ifndef STBI_NO_LINEAR
457 STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
458 STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
460 #ifndef STBI_NO_STDIO
461 STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
462 STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
463 #endif
464#endif
466#ifndef STBI_NO_HDR
467 STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
468 STBIDEF void stbi_hdr_to_ldr_scale(float scale);
469#endif // STBI_NO_HDR
471#ifndef STBI_NO_LINEAR
472 STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
473 STBIDEF void stbi_ldr_to_hdr_scale(float scale);
474#endif // STBI_NO_LINEAR
476// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
477STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
478STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
479#ifndef STBI_NO_STDIO
480STBIDEF int stbi_is_hdr (char const *filename);
481STBIDEF int stbi_is_hdr_from_file(FILE *f);
482#endif // STBI_NO_STDIO
485// get a VERY brief reason for failure
486// on most compilers (and ALL modern mainstream compilers) this is threadsafe
487STBIDEF const char *stbi_failure_reason (void);
489// free the loaded image -- this is just free()
490STBIDEF void stbi_image_free (void *retval_from_stbi_load);
492// get image dimensions & components without fully decoding
493STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
494STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
495STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
496STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
498#ifndef STBI_NO_STDIO
499STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);
500STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
501STBIDEF int stbi_is_16_bit (char const *filename);
502STBIDEF int stbi_is_16_bit_from_file(FILE *f);
503#endif
507// for image formats that explicitly notate that they have premultiplied alpha,
508// we just return the colors as stored in the file. set this flag to force
509// unpremultiplication. results are undefined if the unpremultiply overflow.
510STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
512// indicate whether we should process iphone images back to canonical format,
513// or just pass them through "as-is"
514STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
516// flip the image vertically, so the first pixel in the output array is the bottom left
517STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
519// as above, but only applies to images loaded on the thread that calls the function
520// this function is only available if your compiler supports thread-local variables;
521// calling it will fail to link if your compiler doesn't
522STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
523STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
524STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
526// ZLIB client - used by PNG, available for other purposes
528STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
529STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
530STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
531STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
533STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
534STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
537#ifdef __cplusplus
538}
539#endif
541//
542//
543//// end header file /////////////////////////////////////////////////////
544#endif // STBI_INCLUDE_STB_IMAGE_H
546#ifdef STB_IMAGE_IMPLEMENTATION
548#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
549 || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
550 || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
551 || defined(STBI_ONLY_ZLIB)
552 #ifndef STBI_ONLY_JPEG
553 #define STBI_NO_JPEG
554 #endif
555 #ifndef STBI_ONLY_PNG
556 #define STBI_NO_PNG
557 #endif
558 #ifndef STBI_ONLY_BMP
559 #define STBI_NO_BMP
560 #endif
561 #ifndef STBI_ONLY_PSD
562 #define STBI_NO_PSD
563 #endif
564 #ifndef STBI_ONLY_TGA
565 #define STBI_NO_TGA
566 #endif
567 #ifndef STBI_ONLY_GIF
568 #define STBI_NO_GIF
569 #endif
570 #ifndef STBI_ONLY_HDR
571 #define STBI_NO_HDR
572 #endif
573 #ifndef STBI_ONLY_PIC
574 #define STBI_NO_PIC
575 #endif
576 #ifndef STBI_ONLY_PNM
577 #define STBI_NO_PNM
578 #endif
579#endif
581#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
582#define STBI_NO_ZLIB
583#endif
586#include <stdarg.h>
587#include <stddef.h> // ptrdiff_t on osx
588#include <stdlib.h>
589#include <string.h>
590#include <limits.h>
592#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
593#include <math.h> // ldexp, pow
594#endif
596#ifndef STBI_NO_STDIO
597#include <stdio.h>
598#endif
600#ifndef STBI_ASSERT
601#include <assert.h>
602#define STBI_ASSERT(x) assert(x)
603#endif
605#ifdef __cplusplus
606#define STBI_EXTERN extern "C"
607#else
608#define STBI_EXTERN extern
609#endif
612#ifndef _MSC_VER
613 #ifdef __cplusplus
614 #define stbi_inline inline
615 #else
616 #define stbi_inline
617 #endif
618#else
619 #define stbi_inline __forceinline
620#endif
622#ifndef STBI_NO_THREAD_LOCALS
623 #if defined(__cplusplus) && __cplusplus >= 201103L
624 #define STBI_THREAD_LOCAL thread_local
625 #elif defined(__GNUC__) && __GNUC__ < 5
626 #define STBI_THREAD_LOCAL __thread
627 #elif defined(_MSC_VER)
628 #define STBI_THREAD_LOCAL __declspec(thread)
629 #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
630 #define STBI_THREAD_LOCAL _Thread_local
631 #endif
633 #ifndef STBI_THREAD_LOCAL
634 #if defined(__GNUC__)
635 #define STBI_THREAD_LOCAL __thread
636 #endif
637 #endif
638#endif
640#if defined(_MSC_VER) || defined(__SYMBIAN32__)
641typedef unsigned short stbi__uint16;
642typedef signed short stbi__int16;
643typedef unsigned int stbi__uint32;
644typedef signed int stbi__int32;
645#else
646#include <stdint.h>
647typedef uint16_t stbi__uint16;
648typedef int16_t stbi__int16;
649typedef uint32_t stbi__uint32;
650typedef int32_t stbi__int32;
651#endif
653// should produce compiler error if size is wrong
654typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
656#ifdef _MSC_VER
657#define STBI_NOTUSED(v) (void)(v)
658#else
659#define STBI_NOTUSED(v) (void)sizeof(v)
660#endif
662#ifdef _MSC_VER
663#define STBI_HAS_LROTL
664#endif
666#ifdef STBI_HAS_LROTL
667 #define stbi_lrot(x,y) _lrotl(x,y)
668#else
669 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))
670#endif
672#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
673// ok
674#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
675// ok
676#else
677#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
678#endif
680#ifndef STBI_MALLOC
681#define STBI_MALLOC(sz) malloc(sz)
682#define STBI_REALLOC(p,newsz) realloc(p,newsz)
683#define STBI_FREE(p) free(p)
684#endif
686#ifndef STBI_REALLOC_SIZED
687#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
688#endif
690// x86/x64 detection
691#if defined(__x86_64__) || defined(_M_X64)
692#define STBI__X64_TARGET
693#elif defined(__i386) || defined(_M_IX86)
694#define STBI__X86_TARGET
695#endif
697#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
698// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
699// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
700// but previous attempts to provide the SSE2 functions with runtime
701// detection caused numerous issues. The way architecture extensions are
702// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
703// New behavior: if compiled with -msse2, we use SSE2 without any
704// detection; if not, we don't use it at all.
705#define STBI_NO_SIMD
706#endif
708#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
709// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
710//
711// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
712// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
713// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
714// simultaneously enabling "-mstackrealign".
715//
716// See https://github.com/nothings/stb/issues/81 for more information.
717//
718// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
719// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
720#define STBI_NO_SIMD
721#endif
723#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
724#define STBI_SSE2
725#include <emmintrin.h>
727#ifdef _MSC_VER
729#if _MSC_VER >= 1400 // not VC6
730#include <intrin.h> // __cpuid
731static int stbi__cpuid3(void)
732{
733 int info[4];
734 __cpuid(info,1);
735 return info[3];
736}
737#else
738static int stbi__cpuid3(void)
739{
740 int res;
741 __asm {
742 mov eax,1
743 cpuid
744 mov res,edx
745 }
746 return res;
747}
748#endif
750#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
752#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
753static int stbi__sse2_available(void)
754{
755 int info3 = stbi__cpuid3();
756 return ((info3 >> 26) & 1) != 0;
757}
758#endif
760#else // assume GCC-style if not VC++
761#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
763#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
764static int stbi__sse2_available(void)
765{
766 // If we're even attempting to compile this on GCC/Clang, that means
767 // -msse2 is on, which means the compiler is allowed to use SSE2
768 // instructions at will, and so are we.
769 return 1;
770}
771#endif
773#endif
774#endif
776// ARM NEON
777#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
778#undef STBI_NEON
779#endif
781#ifdef STBI_NEON
782#include <arm_neon.h>
783#ifdef _MSC_VER
784#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
785#else
786#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
787#endif
788#endif
790#ifndef STBI_SIMD_ALIGN
791#define STBI_SIMD_ALIGN(type, name) type name
792#endif
794#ifndef STBI_MAX_DIMENSIONS
795#define STBI_MAX_DIMENSIONS (1 << 24)
796#endif
798///////////////////////////////////////////////
799//
800// stbi__context struct and start_xxx functions
802// stbi__context structure is our basic context used by all images, so it
803// contains all the IO context, plus some basic image information
804typedef struct
805{
806 stbi__uint32 img_x, img_y;
807 int img_n, img_out_n;
809 stbi_io_callbacks io;
810 void *io_user_data;
812 int read_from_callbacks;
813 int buflen;
814 stbi_uc buffer_start[128];
815 int callback_already_read;
817 stbi_uc *img_buffer, *img_buffer_end;
818 stbi_uc *img_buffer_original, *img_buffer_original_end;
819} stbi__context;
822static void stbi__refill_buffer(stbi__context *s);
824// initialize a memory-decode context
825static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
826{
827 s->io.read = NULL;
828 s->read_from_callbacks = 0;
829 s->callback_already_read = 0;
830 s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
831 s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
832}
834// initialize a callback-based context
835static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
836{
837 s->io = *c;
838 s->io_user_data = user;
839 s->buflen = sizeof(s->buffer_start);
840 s->read_from_callbacks = 1;
841 s->callback_already_read = 0;
842 s->img_buffer = s->img_buffer_original = s->buffer_start;
843 stbi__refill_buffer(s);
844 s->img_buffer_original_end = s->img_buffer_end;
845}
847#ifndef STBI_NO_STDIO
849static int stbi__stdio_read(void *user, char *data, int size)
850{
851 return (int) fread(data,1,size,(FILE*) user);
852}
854static void stbi__stdio_skip(void *user, int n)
855{
856 int ch;
857 fseek((FILE*) user, n, SEEK_CUR);
858 ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */
859 if (ch != EOF) {
860 ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */
861 }
862}
864static int stbi__stdio_eof(void *user)
865{
866 return feof((FILE*) user) || ferror((FILE *) user);
867}
869static stbi_io_callbacks stbi__stdio_callbacks =
870{
871 stbi__stdio_read,
872 stbi__stdio_skip,
873 stbi__stdio_eof,
874};
876static void stbi__start_file(stbi__context *s, FILE *f)
877{
878 stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
879}
881//static void stop_file(stbi__context *s) { }
883#endif // !STBI_NO_STDIO
885static void stbi__rewind(stbi__context *s)
886{
887 // conceptually rewind SHOULD rewind to the beginning of the stream,
888 // but we just rewind to the beginning of the initial buffer, because
889 // we only use it after doing 'test', which only ever looks at at most 92 bytes
890 s->img_buffer = s->img_buffer_original;
891 s->img_buffer_end = s->img_buffer_original_end;
892}
894enum
895{
896 STBI_ORDER_RGB,
897 STBI_ORDER_BGR
898};
900typedef struct
901{
902 int bits_per_channel;
903 int num_channels;
904 int channel_order;
905} stbi__result_info;
907#ifndef STBI_NO_JPEG
908static int stbi__jpeg_test(stbi__context *s);
909static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
910static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
911#endif
913#ifndef STBI_NO_PNG
914static int stbi__png_test(stbi__context *s);
915static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
916static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
917static int stbi__png_is16(stbi__context *s);
918#endif
920#ifndef STBI_NO_BMP
921static int stbi__bmp_test(stbi__context *s);
922static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
923static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
924#endif
926#ifndef STBI_NO_TGA
927static int stbi__tga_test(stbi__context *s);
928static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
929static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
930#endif
932#ifndef STBI_NO_PSD
933static int stbi__psd_test(stbi__context *s);
934static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
935static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
936static int stbi__psd_is16(stbi__context *s);
937#endif
939#ifndef STBI_NO_HDR
940static int stbi__hdr_test(stbi__context *s);
941static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
942static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
943#endif
945#ifndef STBI_NO_PIC
946static int stbi__pic_test(stbi__context *s);
947static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
948static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
949#endif
951#ifndef STBI_NO_GIF
952static int stbi__gif_test(stbi__context *s);
953static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
954static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
955static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
956#endif
958#ifndef STBI_NO_PNM
959static int stbi__pnm_test(stbi__context *s);
960static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
961static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
962static int stbi__pnm_is16(stbi__context *s);
963#endif
965static
966#ifdef STBI_THREAD_LOCAL
967STBI_THREAD_LOCAL
968#endif
969const char *stbi__g_failure_reason;
971STBIDEF const char *stbi_failure_reason(void)
972{
973 return stbi__g_failure_reason;
974}
976#ifndef STBI_NO_FAILURE_STRINGS
977static int stbi__err(const char *str)
978{
979 stbi__g_failure_reason = str;
980 return 0;
981}
982#endif
984static void *stbi__malloc(size_t size)
985{
986 return STBI_MALLOC(size);
987}
989// stb_image uses ints pervasively, including for offset calculations.
990// therefore the largest decoded image size we can support with the
991// current code, even on 64-bit targets, is INT_MAX. this is not a
992// significant limitation for the intended use case.
993//
994// we do, however, need to make sure our size calculations don't
995// overflow. hence a few helper functions for size calculations that
996// multiply integers together, making sure that they're non-negative
997// and no overflow occurs.
999// return 1 if the sum is valid, 0 on overflow.
1000// negative terms are considered invalid.
1001static int stbi__addsizes_valid(int a, int b)
1002{
1003 if (b < 0) return 0;
1004 // now 0 <= b <= INT_MAX, hence also
1005 // 0 <= INT_MAX - b <= INTMAX.
1006 // And "a + b <= INT_MAX" (which might overflow) is the
1007 // same as a <= INT_MAX - b (no overflow)
1008 return a <= INT_MAX - b;
1009}
1011// returns 1 if the product is valid, 0 on overflow.
1012// negative factors are considered invalid.
1013static int stbi__mul2sizes_valid(int a, int b)
1014{
1015 if (a < 0 || b < 0) return 0;
1016 if (b == 0) return 1; // mul-by-0 is always safe
1017 // portable way to check for no overflows in a*b
1018 return a <= INT_MAX/b;
1019}
1021#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
1022// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
1023static int stbi__mad2sizes_valid(int a, int b, int add)
1024{
1025 return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
1026}
1027#endif
1029// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
1030static int stbi__mad3sizes_valid(int a, int b, int c, int add)
1031{
1032 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
1033 stbi__addsizes_valid(a*b*c, add);
1034}
1036// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
1037#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1038static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
1039{
1040 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
1041 stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
1042}
1043#endif
1045#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
1046// mallocs with size overflow checking
1047static void *stbi__malloc_mad2(int a, int b, int add)
1048{
1049 if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
1050 return stbi__malloc(a*b + add);
1051}
1052#endif
1054static void *stbi__malloc_mad3(int a, int b, int c, int add)
1055{
1056 if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
1057 return stbi__malloc(a*b*c + add);
1058}
1060#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1061static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
1062{
1063 if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
1064 return stbi__malloc(a*b*c*d + add);
1065}
1066#endif
1068// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
1069static int stbi__addints_valid(int a, int b)
1070{
1071 if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
1072 if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
1073 return a <= INT_MAX - b;
1074}
1076// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
1077static int stbi__mul2shorts_valid(int a, int b)
1078{
1079 if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
1080 if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
1081 if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
1082 return a >= SHRT_MIN / b;
1083}
1085// stbi__err - error
1086// stbi__errpf - error returning pointer to float
1087// stbi__errpuc - error returning pointer to unsigned char
1089#ifdef STBI_NO_FAILURE_STRINGS
1090 #define stbi__err(x,y) 0
1091#elif defined(STBI_FAILURE_USERMSG)
1092 #define stbi__err(x,y) stbi__err(y)
1093#else
1094 #define stbi__err(x,y) stbi__err(x)
1095#endif
1097#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
1098#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
1100STBIDEF void stbi_image_free(void *retval_from_stbi_load)
1101{
1102 STBI_FREE(retval_from_stbi_load);
1103}
1105#ifndef STBI_NO_LINEAR
1106static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
1107#endif
1109#ifndef STBI_NO_HDR
1110static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
1111#endif
1113static int stbi__vertically_flip_on_load_global = 0;
1115STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
1116{
1117 stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
1118}
1120#ifndef STBI_THREAD_LOCAL
1121#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
1122#else
1123static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
1125STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
1126{
1127 stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
1128 stbi__vertically_flip_on_load_set = 1;
1129}
1131#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \
1132 ? stbi__vertically_flip_on_load_local \
1133 : stbi__vertically_flip_on_load_global)
1134#endif // STBI_THREAD_LOCAL
1136static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
1137{
1138 memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
1139 ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
1140 ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
1141 ri->num_channels = 0;
1143 // test the formats with a very explicit header first (at least a FOURCC
1144 // or distinctive magic number first)
1145 #ifndef STBI_NO_PNG
1146 if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);
1147 #endif
1148 #ifndef STBI_NO_BMP
1149 if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);
1150 #endif
1151 #ifndef STBI_NO_GIF
1152 if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);
1153 #endif
1154 #ifndef STBI_NO_PSD
1155 if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
1156 #else
1157 STBI_NOTUSED(bpc);
1158 #endif
1159 #ifndef STBI_NO_PIC
1160 if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);
1161 #endif
1163 // then the formats that can end up attempting to load with just 1 or 2
1164 // bytes matching expectations; these are prone to false positives, so
1165 // try them later
1166 #ifndef STBI_NO_JPEG
1167 if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
1168 #endif
1169 #ifndef STBI_NO_PNM
1170 if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);
1171 #endif
1173 #ifndef STBI_NO_HDR
1174 if (stbi__hdr_test(s)) {
1175 float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
1176 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
1177 }
1178 #endif
1180 #ifndef STBI_NO_TGA
1181 // test tga last because it's a crappy test!
1182 if (stbi__tga_test(s))
1183 return stbi__tga_load(s,x,y,comp,req_comp, ri);
1184 #endif
1186 return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
1187}
1189static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
1190{
1191 int i;
1192 int img_len = w * h * channels;
1193 stbi_uc *reduced;
1195 reduced = (stbi_uc *) stbi__malloc(img_len);
1196 if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
1198 for (i = 0; i < img_len; ++i)
1199 reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
1201 STBI_FREE(orig);
1202 return reduced;
1203}
1205static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
1206{
1207 int i;
1208 int img_len = w * h * channels;
1209 stbi__uint16 *enlarged;
1211 enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
1212 if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
1214 for (i = 0; i < img_len; ++i)
1215 enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
1217 STBI_FREE(orig);
1218 return enlarged;
1219}
1221static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
1222{
1223 int row;
1224 size_t bytes_per_row = (size_t)w * bytes_per_pixel;
1225 stbi_uc temp[2048];
1226 stbi_uc *bytes = (stbi_uc *)image;
1228 for (row = 0; row < (h>>1); row++) {
1229 stbi_uc *row0 = bytes + row*bytes_per_row;
1230 stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
1231 // swap row0 with row1
1232 size_t bytes_left = bytes_per_row;
1233 while (bytes_left) {
1234 size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
1235 memcpy(temp, row0, bytes_copy);
1236 memcpy(row0, row1, bytes_copy);
1237 memcpy(row1, temp, bytes_copy);
1238 row0 += bytes_copy;
1239 row1 += bytes_copy;
1240 bytes_left -= bytes_copy;
1241 }
1242 }
1243}
1245#ifndef STBI_NO_GIF
1246static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
1247{
1248 int slice;
1249 int slice_size = w * h * bytes_per_pixel;
1251 stbi_uc *bytes = (stbi_uc *)image;
1252 for (slice = 0; slice < z; ++slice) {
1253 stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
1254 bytes += slice_size;
1255 }
1256}
1257#endif
1259static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1260{
1261 stbi__result_info ri;
1262 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
1264 if (result == NULL)
1265 return NULL;
1267 // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
1268 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1270 if (ri.bits_per_channel != 8) {
1271 result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1272 ri.bits_per_channel = 8;
1273 }
1275 // @TODO: move stbi__convert_format to here
1277 if (stbi__vertically_flip_on_load) {
1278 int channels = req_comp ? req_comp : *comp;
1279 stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
1280 }
1282 return (unsigned char *) result;
1283}
1285static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1286{
1287 stbi__result_info ri;
1288 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
1290 if (result == NULL)
1291 return NULL;
1293 // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
1294 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1296 if (ri.bits_per_channel != 16) {
1297 result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1298 ri.bits_per_channel = 16;
1299 }
1301 // @TODO: move stbi__convert_format16 to here
1302 // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
1304 if (stbi__vertically_flip_on_load) {
1305 int channels = req_comp ? req_comp : *comp;
1306 stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
1307 }
1309 return (stbi__uint16 *) result;
1310}
1312#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
1313static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
1314{
1315 if (stbi__vertically_flip_on_load && result != NULL) {
1316 int channels = req_comp ? req_comp : *comp;
1317 stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
1318 }
1319}
1320#endif
1322#ifndef STBI_NO_STDIO
1324#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1325STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
1326STBI_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);
1327#endif
1329#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1330STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
1331{
1332 return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
1333}
1334#endif
1336static FILE *stbi__fopen(char const *filename, char const *mode)
1337{
1338 FILE *f;
1339#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1340 wchar_t wMode[64];
1341 wchar_t wFilename[1024];
1342 if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
1343 return 0;
1345 if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
1346 return 0;
1348#if defined(_MSC_VER) && _MSC_VER >= 1400
1349 if (0 != _wfopen_s(&f, wFilename, wMode))
1350 f = 0;
1351#else
1352 f = _wfopen(wFilename, wMode);
1353#endif
1355#elif defined(_MSC_VER) && _MSC_VER >= 1400
1356 if (0 != fopen_s(&f, filename, mode))
1357 f=0;
1358#else
1359 f = fopen(filename, mode);
1360#endif
1361 return f;
1362}
1365STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
1366{
1367 FILE *f = stbi__fopen(filename, "rb");
1368 unsigned char *result;
1369 if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
1370 result = stbi_load_from_file(f,x,y,comp,req_comp);
1371 fclose(f);
1372 return result;
1373}
1375STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
1376{
1377 unsigned char *result;
1378 stbi__context s;
1379 stbi__start_file(&s,f);
1380 result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1381 if (result) {
1382 // need to 'unget' all the characters in the IO buffer
1383 fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
1384 }
1385 return result;
1386}
1388STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
1389{
1390 stbi__uint16 *result;
1391 stbi__context s;
1392 stbi__start_file(&s,f);
1393 result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
1394 if (result) {
1395 // need to 'unget' all the characters in the IO buffer
1396 fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
1397 }
1398 return result;
1399}
1401STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
1402{
1403 FILE *f = stbi__fopen(filename, "rb");
1404 stbi__uint16 *result;
1405 if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
1406 result = stbi_load_from_file_16(f,x,y,comp,req_comp);
1407 fclose(f);
1408 return result;
1409}
1412#endif //!STBI_NO_STDIO
1414STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
1415{
1416 stbi__context s;
1417 stbi__start_mem(&s,buffer,len);
1418 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1419}
1421STBIDEF 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)
1422{
1423 stbi__context s;
1424 stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
1425 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1426}
1428STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
1429{
1430 stbi__context s;
1431 stbi__start_mem(&s,buffer,len);
1432 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1433}
1435STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
1436{
1437 stbi__context s;
1438 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1439 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1440}
1442#ifndef STBI_NO_GIF
1443STBIDEF 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)
1444{
1445 unsigned char *result;
1446 stbi__context s;
1447 stbi__start_mem(&s,buffer,len);
1449 result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
1450 if (stbi__vertically_flip_on_load) {
1451 stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
1452 }
1454 return result;
1455}
1456#endif
1458#ifndef STBI_NO_LINEAR
1459static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1460{
1461 unsigned char *data;
1462 #ifndef STBI_NO_HDR
1463 if (stbi__hdr_test(s)) {
1464 stbi__result_info ri;
1465 float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
1466 if (hdr_data)
1467 stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
1468 return hdr_data;
1469 }
1470 #endif
1471 data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
1472 if (data)
1473 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
1474 return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
1475}
1477STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
1478{
1479 stbi__context s;
1480 stbi__start_mem(&s,buffer,len);
1481 return stbi__loadf_main(&s,x,y,comp,req_comp);
1482}
1484STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
1485{
1486 stbi__context s;
1487 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1488 return stbi__loadf_main(&s,x,y,comp,req_comp);
1489}
1491#ifndef STBI_NO_STDIO
1492STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
1493{
1494 float *result;
1495 FILE *f = stbi__fopen(filename, "rb");
1496 if (!f) return stbi__errpf("can't fopen", "Unable to open file");
1497 result = stbi_loadf_from_file(f,x,y,comp,req_comp);
1498 fclose(f);
1499 return result;
1500}
1502STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
1503{
1504 stbi__context s;
1505 stbi__start_file(&s,f);
1506 return stbi__loadf_main(&s,x,y,comp,req_comp);
1507}
1508#endif // !STBI_NO_STDIO
1510#endif // !STBI_NO_LINEAR
1512// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
1513// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
1514// reports false!
1516STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
1517{
1518 #ifndef STBI_NO_HDR
1519 stbi__context s;
1520 stbi__start_mem(&s,buffer,len);
1521 return stbi__hdr_test(&s);
1522 #else
1523 STBI_NOTUSED(buffer);
1524 STBI_NOTUSED(len);
1525 return 0;
1526 #endif
1527}
1529#ifndef STBI_NO_STDIO
1530STBIDEF int stbi_is_hdr (char const *filename)
1531{
1532 FILE *f = stbi__fopen(filename, "rb");
1533 int result=0;
1534 if (f) {
1535 result = stbi_is_hdr_from_file(f);
1536 fclose(f);
1537 }
1538 return result;
1539}
1541STBIDEF int stbi_is_hdr_from_file(FILE *f)
1542{
1543 #ifndef STBI_NO_HDR
1544 long pos = ftell(f);
1545 int res;
1546 stbi__context s;
1547 stbi__start_file(&s,f);
1548 res = stbi__hdr_test(&s);
1549 fseek(f, pos, SEEK_SET);
1550 return res;
1551 #else
1552 STBI_NOTUSED(f);
1553 return 0;
1554 #endif
1555}
1556#endif // !STBI_NO_STDIO
1558STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
1559{
1560 #ifndef STBI_NO_HDR
1561 stbi__context s;
1562 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1563 return stbi__hdr_test(&s);
1564 #else
1565 STBI_NOTUSED(clbk);
1566 STBI_NOTUSED(user);
1567 return 0;
1568 #endif
1569}
1571#ifndef STBI_NO_LINEAR
1572static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
1574STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
1575STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
1576#endif
1578static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
1580STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
1581STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
1584//////////////////////////////////////////////////////////////////////////////
1585//
1586// Common code used by all image loaders
1587//
1589enum
1590{
1591 STBI__SCAN_load=0,
1592 STBI__SCAN_type,
1593 STBI__SCAN_header
1594};
1596static void stbi__refill_buffer(stbi__context *s)
1597{
1598 int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
1599 s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
1600 if (n == 0) {
1601 // at end of file, treat same as if from memory, but need to handle case
1602 // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
1603 s->read_from_callbacks = 0;
1604 s->img_buffer = s->buffer_start;
1605 s->img_buffer_end = s->buffer_start+1;
1606 *s->img_buffer = 0;
1607 } else {
1608 s->img_buffer = s->buffer_start;
1609 s->img_buffer_end = s->buffer_start + n;
1610 }
1611}
1613stbi_inline static stbi_uc stbi__get8(stbi__context *s)
1614{
1615 if (s->img_buffer < s->img_buffer_end)
1616 return *s->img_buffer++;
1617 if (s->read_from_callbacks) {
1618 stbi__refill_buffer(s);
1619 return *s->img_buffer++;
1620 }
1621 return 0;
1622}
1624#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1625// nothing
1626#else
1627stbi_inline static int stbi__at_eof(stbi__context *s)
1628{
1629 if (s->io.read) {
1630 if (!(s->io.eof)(s->io_user_data)) return 0;
1631 // if feof() is true, check if buffer = end
1632 // special case: we've only got the special 0 character at the end
1633 if (s->read_from_callbacks == 0) return 1;
1634 }
1636 return s->img_buffer >= s->img_buffer_end;
1637}
1638#endif
1640#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)
1641// nothing
1642#else
1643static void stbi__skip(stbi__context *s, int n)
1644{
1645 if (n == 0) return; // already there!
1646 if (n < 0) {
1647 s->img_buffer = s->img_buffer_end;
1648 return;
1649 }
1650 if (s->io.read) {
1651 int blen = (int) (s->img_buffer_end - s->img_buffer);
1652 if (blen < n) {
1653 s->img_buffer = s->img_buffer_end;
1654 (s->io.skip)(s->io_user_data, n - blen);
1655 return;
1656 }
1657 }
1658 s->img_buffer += n;
1659}
1660#endif
1662#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
1663// nothing
1664#else
1665static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
1666{
1667 if (s->io.read) {
1668 int blen = (int) (s->img_buffer_end - s->img_buffer);
1669 if (blen < n) {
1670 int res, count;
1672 memcpy(buffer, s->img_buffer, blen);
1674 count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
1675 res = (count == (n-blen));
1676 s->img_buffer = s->img_buffer_end;
1677 return res;
1678 }
1679 }
1681 if (s->img_buffer+n <= s->img_buffer_end) {
1682 memcpy(buffer, s->img_buffer, n);
1683 s->img_buffer += n;
1684 return 1;
1685 } else
1686 return 0;
1687}
1688#endif
1690#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1691// nothing
1692#else
1693static int stbi__get16be(stbi__context *s)
1694{
1695 int z = stbi__get8(s);
1696 return (z << 8) + stbi__get8(s);
1697}
1698#endif
1700#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1701// nothing
1702#else
1703static stbi__uint32 stbi__get32be(stbi__context *s)
1704{
1705 stbi__uint32 z = stbi__get16be(s);
1706 return (z << 16) + stbi__get16be(s);
1707}
1708#endif
1710#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
1711// nothing
1712#else
1713static int stbi__get16le(stbi__context *s)
1714{
1715 int z = stbi__get8(s);
1716 return z + (stbi__get8(s) << 8);
1717}
1718#endif
1720#ifndef STBI_NO_BMP
1721static stbi__uint32 stbi__get32le(stbi__context *s)
1722{
1723 stbi__uint32 z = stbi__get16le(s);
1724 z += (stbi__uint32)stbi__get16le(s) << 16;
1725 return z;
1726}
1727#endif
1729#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
1731#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)
1732// nothing
1733#else
1734//////////////////////////////////////////////////////////////////////////////
1735//
1736// generic converter from built-in img_n to req_comp
1737// individual types do this automatically as much as possible (e.g. jpeg
1738// does all cases internally since it needs to colorspace convert anyway,
1739// and it never has alpha, so very few cases ). png can automatically
1740// interleave an alpha=255 channel, but falls back to this for other cases
1741//
1742// assume data buffer is malloced, so malloc a new one and free that one
1743// only failure mode is malloc failing
1745static stbi_uc stbi__compute_y(int r, int g, int b)
1746{
1747 return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
1748}
1749#endif
1751#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)
1752// nothing
1753#else
1754static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
1755{
1756 int i,j;
1757 unsigned char *good;
1759 if (req_comp == img_n) return data;
1760 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1762 good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
1763 if (good == NULL) {
1764 STBI_FREE(data);
1765 return stbi__errpuc("outofmem", "Out of memory");
1766 }
1768 for (j=0; j < (int) y; ++j) {
1769 unsigned char *src = data + j * x * img_n ;
1770 unsigned char *dest = good + j * x * req_comp;
1772 #define STBI__COMBO(a,b) ((a)*8+(b))
1773 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1774 // convert source image with img_n components to one with req_comp components;
1775 // avoid switch per pixel, so use switch per scanline and massive macros
1776 switch (STBI__COMBO(img_n, req_comp)) {
1777 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
1778 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1779 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
1780 STBI__CASE(2,1) { dest[0]=src[0]; } break;
1781 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1782 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
1783 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
1784 STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
1785 STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
1786 STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
1787 STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
1788 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
1789 default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
1790 }
1791 #undef STBI__CASE
1792 }
1794 STBI_FREE(data);
1795 return good;
1796}
1797#endif
1799#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1800// nothing
1801#else
1802static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
1803{
1804 return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
1805}
1806#endif
1808#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1809// nothing
1810#else
1811static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
1812{
1813 int i,j;
1814 stbi__uint16 *good;
1816 if (req_comp == img_n) return data;
1817 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1819 good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
1820 if (good == NULL) {
1821 STBI_FREE(data);
1822 return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
1823 }
1825 for (j=0; j < (int) y; ++j) {
1826 stbi__uint16 *src = data + j * x * img_n ;
1827 stbi__uint16 *dest = good + j * x * req_comp;
1829 #define STBI__COMBO(a,b) ((a)*8+(b))
1830 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1831 // convert source image with img_n components to one with req_comp components;
1832 // avoid switch per pixel, so use switch per scanline and massive macros
1833 switch (STBI__COMBO(img_n, req_comp)) {
1834 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;
1835 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1836 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;
1837 STBI__CASE(2,1) { dest[0]=src[0]; } break;
1838 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1839 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
1840 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
1841 STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
1842 STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
1843 STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
1844 STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
1845 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
1846 default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
1847 }
1848 #undef STBI__CASE
1849 }
1851 STBI_FREE(data);
1852 return good;
1853}
1854#endif
1856#ifndef STBI_NO_LINEAR
1857static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
1858{
1859 int i,k,n;
1860 float *output;
1861 if (!data) return NULL;
1862 output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
1863 if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
1864 // compute number of non-alpha components
1865 if (comp & 1) n = comp; else n = comp-1;
1866 for (i=0; i < x*y; ++i) {
1867 for (k=0; k < n; ++k) {
1868 output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
1869 }
1870 }
1871 if (n < comp) {
1872 for (i=0; i < x*y; ++i) {
1873 output[i*comp + n] = data[i*comp + n]/255.0f;
1874 }
1875 }
1876 STBI_FREE(data);
1877 return output;
1878}
1879#endif
1881#ifndef STBI_NO_HDR
1882#define stbi__float2int(x) ((int) (x))
1883static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
1884{
1885 int i,k,n;
1886 stbi_uc *output;
1887 if (!data) return NULL;
1888 output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
1889 if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
1890 // compute number of non-alpha components
1891 if (comp & 1) n = comp; else n = comp-1;
1892 for (i=0; i < x*y; ++i) {
1893 for (k=0; k < n; ++k) {
1894 float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
1895 if (z < 0) z = 0;
1896 if (z > 255) z = 255;
1897 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
1898 }
1899 if (k < comp) {
1900 float z = data[i*comp+k] * 255 + 0.5f;
1901 if (z < 0) z = 0;
1902 if (z > 255) z = 255;
1903 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
1904 }
1905 }
1906 STBI_FREE(data);
1907 return output;
1908}
1909#endif
1911//////////////////////////////////////////////////////////////////////////////
1912//
1913// "baseline" JPEG/JFIF decoder
1914//
1915// simple implementation
1916// - doesn't support delayed output of y-dimension
1917// - simple interface (only one output format: 8-bit interleaved RGB)
1918// - doesn't try to recover corrupt jpegs
1919// - doesn't allow partial loading, loading multiple at once
1920// - still fast on x86 (copying globals into locals doesn't help x86)
1921// - allocates lots of intermediate memory (full size of all components)
1922// - non-interleaved case requires this anyway
1923// - allows good upsampling (see next)
1924// high-quality
1925// - upsampled channels are bilinearly interpolated, even across blocks
1926// - quality integer IDCT derived from IJG's 'slow'
1927// performance
1928// - fast huffman; reasonable integer IDCT
1929// - some SIMD kernels for common paths on targets with SSE2/NEON
1930// - uses a lot of intermediate memory, could cache poorly
1932#ifndef STBI_NO_JPEG
1934// huffman decoding acceleration
1935#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
1937typedef struct
1938{
1939 stbi_uc fast[1 << FAST_BITS];
1940 // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
1941 stbi__uint16 code[256];
1942 stbi_uc values[256];
1943 stbi_uc size[257];
1944 unsigned int maxcode[18];
1945 int delta[17]; // old 'firstsymbol' - old 'firstcode'
1946} stbi__huffman;
1948typedef struct
1949{
1950 stbi__context *s;
1951 stbi__huffman huff_dc[4];
1952 stbi__huffman huff_ac[4];
1953 stbi__uint16 dequant[4][64];
1954 stbi__int16 fast_ac[4][1 << FAST_BITS];
1956// sizes for components, interleaved MCUs
1957 int img_h_max, img_v_max;
1958 int img_mcu_x, img_mcu_y;
1959 int img_mcu_w, img_mcu_h;
1961// definition of jpeg image component
1962 struct
1963 {
1964 int id;
1965 int h,v;
1966 int tq;
1967 int hd,ha;
1968 int dc_pred;
1970 int x,y,w2,h2;
1971 stbi_uc *data;
1972 void *raw_data, *raw_coeff;
1973 stbi_uc *linebuf;
1974 short *coeff; // progressive only
1975 int coeff_w, coeff_h; // number of 8x8 coefficient blocks
1976 } img_comp[4];
1978 stbi__uint32 code_buffer; // jpeg entropy-coded buffer
1979 int code_bits; // number of valid bits
1980 unsigned char marker; // marker seen while filling entropy buffer
1981 int nomore; // flag if we saw a marker so must stop
1983 int progressive;
1984 int spec_start;
1985 int spec_end;
1986 int succ_high;
1987 int succ_low;
1988 int eob_run;
1989 int jfif;
1990 int app14_color_transform; // Adobe APP14 tag
1991 int rgb;
1993 int scan_n, order[4];
1994 int restart_interval, todo;
1996// kernels
1997 void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
1998 void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
1999 stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
2000} stbi__jpeg;
2002static int stbi__build_huffman(stbi__huffman *h, int *count)
2003{
2004 int i,j,k=0;
2005 unsigned int code;
2006 // build size list for each symbol (from JPEG spec)
2007 for (i=0; i < 16; ++i) {
2008 for (j=0; j < count[i]; ++j) {
2009 h->size[k++] = (stbi_uc) (i+1);
2010 if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
2011 }
2012 }
2013 h->size[k] = 0;
2015 // compute actual symbols (from jpeg spec)
2016 code = 0;
2017 k = 0;
2018 for(j=1; j <= 16; ++j) {
2019 // compute delta to add to code to compute symbol id
2020 h->delta[j] = k - code;
2021 if (h->size[k] == j) {
2022 while (h->size[k] == j)
2023 h->code[k++] = (stbi__uint16) (code++);
2024 if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
2025 }
2026 // compute largest code + 1 for this size, preshifted as needed later
2027 h->maxcode[j] = code << (16-j);
2028 code <<= 1;
2029 }
2030 h->maxcode[j] = 0xffffffff;
2032 // build non-spec acceleration table; 255 is flag for not-accelerated
2033 memset(h->fast, 255, 1 << FAST_BITS);
2034 for (i=0; i < k; ++i) {
2035 int s = h->size[i];
2036 if (s <= FAST_BITS) {
2037 int c = h->code[i] << (FAST_BITS-s);
2038 int m = 1 << (FAST_BITS-s);
2039 for (j=0; j < m; ++j) {
2040 h->fast[c+j] = (stbi_uc) i;
2041 }
2042 }
2043 }
2044 return 1;
2045}
2047// build a table that decodes both magnitude and value of small ACs in
2048// one go.
2049static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
2050{
2051 int i;
2052 for (i=0; i < (1 << FAST_BITS); ++i) {
2053 stbi_uc fast = h->fast[i];
2054 fast_ac[i] = 0;
2055 if (fast < 255) {
2056 int rs = h->values[fast];
2057 int run = (rs >> 4) & 15;
2058 int magbits = rs & 15;
2059 int len = h->size[fast];
2061 if (magbits && len + magbits <= FAST_BITS) {
2062 // magnitude code followed by receive_extend code
2063 int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
2064 int m = 1 << (magbits - 1);
2065 if (k < m) k += (~0U << magbits) + 1;
2066 // if the result is small enough, we can fit it in fast_ac table
2067 if (k >= -128 && k <= 127)
2068 fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
2069 }
2070 }
2071 }
2072}
2074static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
2075{
2076 do {
2077 unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
2078 if (b == 0xff) {
2079 int c = stbi__get8(j->s);
2080 while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
2081 if (c != 0) {
2082 j->marker = (unsigned char) c;
2083 j->nomore = 1;
2084 return;
2085 }
2086 }
2087 j->code_buffer |= b << (24 - j->code_bits);
2088 j->code_bits += 8;
2089 } while (j->code_bits <= 24);
2090}
2092// (1 << n) - 1
2093static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
2095// decode a jpeg huffman value from the bitstream
2096stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
2097{
2098 unsigned int temp;
2099 int c,k;
2101 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2103 // look at the top FAST_BITS and determine what symbol ID it is,
2104 // if the code is <= FAST_BITS
2105 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2106 k = h->fast[c];
2107 if (k < 255) {
2108 int s = h->size[k];
2109 if (s > j->code_bits)
2110 return -1;
2111 j->code_buffer <<= s;
2112 j->code_bits -= s;
2113 return h->values[k];
2114 }
2116 // naive test is to shift the code_buffer down so k bits are
2117 // valid, then test against maxcode. To speed this up, we've
2118 // preshifted maxcode left so that it has (16-k) 0s at the
2119 // end; in other words, regardless of the number of bits, it
2120 // wants to be compared against something shifted to have 16;
2121 // that way we don't need to shift inside the loop.
2122 temp = j->code_buffer >> 16;
2123 for (k=FAST_BITS+1 ; ; ++k)
2124 if (temp < h->maxcode[k])
2125 break;
2126 if (k == 17) {
2127 // error! code not found
2128 j->code_bits -= 16;
2129 return -1;
2130 }
2132 if (k > j->code_bits)
2133 return -1;
2135 // convert the huffman code to the symbol id
2136 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
2137 if(c < 0 || c >= 256) // symbol id out of bounds!
2138 return -1;
2139 STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
2141 // convert the id to a symbol
2142 j->code_bits -= k;
2143 j->code_buffer <<= k;
2144 return h->values[c];
2145}
2147// bias[n] = (-1<<n) + 1
2148static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
2150// combined JPEG 'receive' and JPEG 'extend', since baseline
2151// always extends everything it receives.
2152stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
2153{
2154 unsigned int k;
2155 int sgn;
2156 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
2157 if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
2159 sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
2160 k = stbi_lrot(j->code_buffer, n);
2161 j->code_buffer = k & ~stbi__bmask[n];
2162 k &= stbi__bmask[n];
2163 j->code_bits -= n;
2164 return k + (stbi__jbias[n] & (sgn - 1));
2165}
2167// get some unsigned bits
2168stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
2169{
2170 unsigned int k;
2171 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
2172 if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
2173 k = stbi_lrot(j->code_buffer, n);
2174 j->code_buffer = k & ~stbi__bmask[n];
2175 k &= stbi__bmask[n];
2176 j->code_bits -= n;
2177 return k;
2178}
2180stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
2181{
2182 unsigned int k;
2183 if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
2184 if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
2185 k = j->code_buffer;
2186 j->code_buffer <<= 1;
2187 --j->code_bits;
2188 return k & 0x80000000;
2189}
2191// given a value that's at position X in the zigzag stream,
2192// where does it appear in the 8x8 matrix coded as row-major?
2193static const stbi_uc stbi__jpeg_dezigzag[64+15] =
2194{
2195 0, 1, 8, 16, 9, 2, 3, 10,
2196 17, 24, 32, 25, 18, 11, 4, 5,
2197 12, 19, 26, 33, 40, 48, 41, 34,
2198 27, 20, 13, 6, 7, 14, 21, 28,
2199 35, 42, 49, 56, 57, 50, 43, 36,
2200 29, 22, 15, 23, 30, 37, 44, 51,
2201 58, 59, 52, 45, 38, 31, 39, 46,
2202 53, 60, 61, 54, 47, 55, 62, 63,
2203 // let corrupt input sample past end
2204 63, 63, 63, 63, 63, 63, 63, 63,
2205 63, 63, 63, 63, 63, 63, 63
2206};
2208// decode one 64-entry block--
2209static 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)
2210{
2211 int diff,dc,k;
2212 int t;
2214 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2215 t = stbi__jpeg_huff_decode(j, hdc);
2216 if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
2218 // 0 all the ac values now so we can do it 32-bits at a time
2219 memset(data,0,64*sizeof(data[0]));
2221 diff = t ? stbi__extend_receive(j, t) : 0;
2222 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
2223 dc = j->img_comp[b].dc_pred + diff;
2224 j->img_comp[b].dc_pred = dc;
2225 if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2226 data[0] = (short) (dc * dequant[0]);
2228 // decode AC components, see JPEG spec
2229 k = 1;
2230 do {
2231 unsigned int zig;
2232 int c,r,s;
2233 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2234 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2235 r = fac[c];
2236 if (r) { // fast-AC path
2237 k += (r >> 4) & 15; // run
2238 s = r & 15; // combined length
2239 if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
2240 j->code_buffer <<= s;
2241 j->code_bits -= s;
2242 // decode into unzigzag'd location
2243 zig = stbi__jpeg_dezigzag[k++];
2244 data[zig] = (short) ((r >> 8) * dequant[zig]);
2245 } else {
2246 int rs = stbi__jpeg_huff_decode(j, hac);
2247 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2248 s = rs & 15;
2249 r = rs >> 4;
2250 if (s == 0) {
2251 if (rs != 0xf0) break; // end block
2252 k += 16;
2253 } else {
2254 k += r;
2255 // decode into unzigzag'd location
2256 zig = stbi__jpeg_dezigzag[k++];
2257 data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
2258 }
2259 }
2260 } while (k < 64);
2261 return 1;
2262}
2264static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
2265{
2266 int diff,dc;
2267 int t;
2268 if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2270 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2272 if (j->succ_high == 0) {
2273 // first scan for DC coefficient, must be first
2274 memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
2275 t = stbi__jpeg_huff_decode(j, hdc);
2276 if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2277 diff = t ? stbi__extend_receive(j, t) : 0;
2279 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
2280 dc = j->img_comp[b].dc_pred + diff;
2281 j->img_comp[b].dc_pred = dc;
2282 if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2283 data[0] = (short) (dc * (1 << j->succ_low));
2284 } else {
2285 // refinement scan for DC coefficient
2286 if (stbi__jpeg_get_bit(j))
2287 data[0] += (short) (1 << j->succ_low);
2288 }
2289 return 1;
2290}
2292// @OPTIMIZE: store non-zigzagged during the decode passes,
2293// and only de-zigzag when dequantizing
2294static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
2295{
2296 int k;
2297 if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2299 if (j->succ_high == 0) {
2300 int shift = j->succ_low;
2302 if (j->eob_run) {
2303 --j->eob_run;
2304 return 1;
2305 }
2307 k = j->spec_start;
2308 do {
2309 unsigned int zig;
2310 int c,r,s;
2311 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2312 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2313 r = fac[c];
2314 if (r) { // fast-AC path
2315 k += (r >> 4) & 15; // run
2316 s = r & 15; // combined length
2317 if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
2318 j->code_buffer <<= s;
2319 j->code_bits -= s;
2320 zig = stbi__jpeg_dezigzag[k++];
2321 data[zig] = (short) ((r >> 8) * (1 << shift));
2322 } else {
2323 int rs = stbi__jpeg_huff_decode(j, hac);
2324 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2325 s = rs & 15;
2326 r = rs >> 4;
2327 if (s == 0) {
2328 if (r < 15) {
2329 j->eob_run = (1 << r);
2330 if (r)
2331 j->eob_run += stbi__jpeg_get_bits(j, r);
2332 --j->eob_run;
2333 break;
2334 }
2335 k += 16;
2336 } else {
2337 k += r;
2338 zig = stbi__jpeg_dezigzag[k++];
2339 data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
2340 }
2341 }
2342 } while (k <= j->spec_end);
2343 } else {
2344 // refinement scan for these AC coefficients
2346 short bit = (short) (1 << j->succ_low);
2348 if (j->eob_run) {
2349 --j->eob_run;
2350 for (k = j->spec_start; k <= j->spec_end; ++k) {
2351 short *p = &data[stbi__jpeg_dezigzag[k]];
2352 if (*p != 0)
2353 if (stbi__jpeg_get_bit(j))
2354 if ((*p & bit)==0) {
2355 if (*p > 0)
2356 *p += bit;
2357 else
2358 *p -= bit;
2359 }
2360 }
2361 } else {
2362 k = j->spec_start;
2363 do {
2364 int r,s;
2365 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
2366 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2367 s = rs & 15;
2368 r = rs >> 4;
2369 if (s == 0) {
2370 if (r < 15) {
2371 j->eob_run = (1 << r) - 1;
2372 if (r)
2373 j->eob_run += stbi__jpeg_get_bits(j, r);
2374 r = 64; // force end of block
2375 } else {
2376 // r=15 s=0 should write 16 0s, so we just do
2377 // a run of 15 0s and then write s (which is 0),
2378 // so we don't have to do anything special here
2379 }
2380 } else {
2381 if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
2382 // sign bit
2383 if (stbi__jpeg_get_bit(j))
2384 s = bit;
2385 else
2386 s = -bit;
2387 }
2389 // advance by r
2390 while (k <= j->spec_end) {
2391 short *p = &data[stbi__jpeg_dezigzag[k++]];
2392 if (*p != 0) {
2393 if (stbi__jpeg_get_bit(j))
2394 if ((*p & bit)==0) {
2395 if (*p > 0)
2396 *p += bit;
2397 else
2398 *p -= bit;
2399 }
2400 } else {
2401 if (r == 0) {
2402 *p = (short) s;
2403 break;
2404 }
2405 --r;
2406 }
2407 }
2408 } while (k <= j->spec_end);
2409 }
2410 }
2411 return 1;
2412}
2414// take a -128..127 value and stbi__clamp it and convert to 0..255
2415stbi_inline static stbi_uc stbi__clamp(int x)
2416{
2417 // trick to use a single test to catch both cases
2418 if ((unsigned int) x > 255) {
2419 if (x < 0) return 0;
2420 if (x > 255) return 255;
2421 }
2422 return (stbi_uc) x;
2423}
2425#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
2426#define stbi__fsh(x) ((x) * 4096)
2428// derived from jidctint -- DCT_ISLOW
2429#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
2430 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
2431 p2 = s2; \
2432 p3 = s6; \
2433 p1 = (p2+p3) * stbi__f2f(0.5411961f); \
2434 t2 = p1 + p3*stbi__f2f(-1.847759065f); \
2435 t3 = p1 + p2*stbi__f2f( 0.765366865f); \
2436 p2 = s0; \
2437 p3 = s4; \
2438 t0 = stbi__fsh(p2+p3); \
2439 t1 = stbi__fsh(p2-p3); \
2440 x0 = t0+t3; \
2441 x3 = t0-t3; \
2442 x1 = t1+t2; \
2443 x2 = t1-t2; \
2444 t0 = s7; \
2445 t1 = s5; \
2446 t2 = s3; \
2447 t3 = s1; \
2448 p3 = t0+t2; \
2449 p4 = t1+t3; \
2450 p1 = t0+t3; \
2451 p2 = t1+t2; \
2452 p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
2453 t0 = t0*stbi__f2f( 0.298631336f); \
2454 t1 = t1*stbi__f2f( 2.053119869f); \
2455 t2 = t2*stbi__f2f( 3.072711026f); \
2456 t3 = t3*stbi__f2f( 1.501321110f); \
2457 p1 = p5 + p1*stbi__f2f(-0.899976223f); \
2458 p2 = p5 + p2*stbi__f2f(-2.562915447f); \
2459 p3 = p3*stbi__f2f(-1.961570560f); \
2460 p4 = p4*stbi__f2f(-0.390180644f); \
2461 t3 += p1+p4; \
2462 t2 += p2+p3; \
2463 t1 += p2+p4; \
2464 t0 += p1+p3;
2466static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
2467{
2468 int i,val[64],*v=val;
2469 stbi_uc *o;
2470 short *d = data;
2472 // columns
2473 for (i=0; i < 8; ++i,++d, ++v) {
2474 // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
2475 if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
2476 && d[40]==0 && d[48]==0 && d[56]==0) {
2477 // no shortcut 0 seconds
2478 // (1|2|3|4|5|6|7)==0 0 seconds
2479 // all separate -0.047 seconds
2480 // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
2481 int dcterm = d[0]*4;
2482 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
2483 } else {
2484 STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
2485 // constants scaled things up by 1<<12; let's bring them back
2486 // down, but keep 2 extra bits of precision
2487 x0 += 512; x1 += 512; x2 += 512; x3 += 512;
2488 v[ 0] = (x0+t3) >> 10;
2489 v[56] = (x0-t3) >> 10;
2490 v[ 8] = (x1+t2) >> 10;
2491 v[48] = (x1-t2) >> 10;
2492 v[16] = (x2+t1) >> 10;
2493 v[40] = (x2-t1) >> 10;
2494 v[24] = (x3+t0) >> 10;
2495 v[32] = (x3-t0) >> 10;
2496 }
2497 }
2499 for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
2500 // no fast case since the first 1D IDCT spread components out
2501 STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
2502 // constants scaled things up by 1<<12, plus we had 1<<2 from first
2503 // loop, plus horizontal and vertical each scale by sqrt(8) so together
2504 // we've got an extra 1<<3, so 1<<17 total we need to remove.
2505 // so we want to round that, which means adding 0.5 * 1<<17,
2506 // aka 65536. Also, we'll end up with -128 to 127 that we want
2507 // to encode as 0..255 by adding 128, so we'll add that before the shift
2508 x0 += 65536 + (128<<17);
2509 x1 += 65536 + (128<<17);
2510 x2 += 65536 + (128<<17);
2511 x3 += 65536 + (128<<17);
2512 // tried computing the shifts into temps, or'ing the temps to see
2513 // if any were out of range, but that was slower
2514 o[0] = stbi__clamp((x0+t3) >> 17);
2515 o[7] = stbi__clamp((x0-t3) >> 17);
2516 o[1] = stbi__clamp((x1+t2) >> 17);
2517 o[6] = stbi__clamp((x1-t2) >> 17);
2518 o[2] = stbi__clamp((x2+t1) >> 17);
2519 o[5] = stbi__clamp((x2-t1) >> 17);
2520 o[3] = stbi__clamp((x3+t0) >> 17);
2521 o[4] = stbi__clamp((x3-t0) >> 17);
2522 }
2523}
2525#ifdef STBI_SSE2
2526// sse2 integer IDCT. not the fastest possible implementation but it
2527// produces bit-identical results to the generic C version so it's
2528// fully "transparent".
2529static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
2530{
2531 // This is constructed to match our regular (generic) integer IDCT exactly.
2532 __m128i row0, row1, row2, row3, row4, row5, row6, row7;
2533 __m128i tmp;
2535 // dot product constant: even elems=x, odd elems=y
2536 #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
2538 // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)
2539 // out(1) = c1[even]*x + c1[odd]*y
2540 #define dct_rot(out0,out1, x,y,c0,c1) \
2541 __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
2542 __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
2543 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
2544 __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
2545 __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
2546 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
2548 // out = in << 12 (in 16-bit, out 32-bit)
2549 #define dct_widen(out, in) \
2550 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
2551 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
2553 // wide add
2554 #define dct_wadd(out, a, b) \
2555 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
2556 __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
2558 // wide sub
2559 #define dct_wsub(out, a, b) \
2560 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
2561 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
2563 // butterfly a/b, add bias, then shift by "s" and pack
2564 #define dct_bfly32o(out0, out1, a,b,bias,s) \
2565 { \
2566 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
2567 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
2568 dct_wadd(sum, abiased, b); \
2569 dct_wsub(dif, abiased, b); \
2570 out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
2571 out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
2572 }
2574 // 8-bit interleave step (for transposes)
2575 #define dct_interleave8(a, b) \
2576 tmp = a; \
2577 a = _mm_unpacklo_epi8(a, b); \
2578 b = _mm_unpackhi_epi8(tmp, b)
2580 // 16-bit interleave step (for transposes)
2581 #define dct_interleave16(a, b) \
2582 tmp = a; \
2583 a = _mm_unpacklo_epi16(a, b); \
2584 b = _mm_unpackhi_epi16(tmp, b)
2586 #define dct_pass(bias,shift) \
2587 { \
2588 /* even part */ \
2589 dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
2590 __m128i sum04 = _mm_add_epi16(row0, row4); \
2591 __m128i dif04 = _mm_sub_epi16(row0, row4); \
2592 dct_widen(t0e, sum04); \
2593 dct_widen(t1e, dif04); \
2594 dct_wadd(x0, t0e, t3e); \
2595 dct_wsub(x3, t0e, t3e); \
2596 dct_wadd(x1, t1e, t2e); \
2597 dct_wsub(x2, t1e, t2e); \
2598 /* odd part */ \
2599 dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
2600 dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
2601 __m128i sum17 = _mm_add_epi16(row1, row7); \
2602 __m128i sum35 = _mm_add_epi16(row3, row5); \
2603 dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
2604 dct_wadd(x4, y0o, y4o); \
2605 dct_wadd(x5, y1o, y5o); \
2606 dct_wadd(x6, y2o, y5o); \
2607 dct_wadd(x7, y3o, y4o); \
2608 dct_bfly32o(row0,row7, x0,x7,bias,shift); \
2609 dct_bfly32o(row1,row6, x1,x6,bias,shift); \
2610 dct_bfly32o(row2,row5, x2,x5,bias,shift); \
2611 dct_bfly32o(row3,row4, x3,x4,bias,shift); \
2612 }
2614 __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
2615 __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
2616 __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
2617 __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
2618 __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
2619 __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
2620 __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
2621 __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
2623 // rounding biases in column/row passes, see stbi__idct_block for explanation.
2624 __m128i bias_0 = _mm_set1_epi32(512);
2625 __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
2627 // load
2628 row0 = _mm_load_si128((const __m128i *) (data + 0*8));
2629 row1 = _mm_load_si128((const __m128i *) (data + 1*8));
2630 row2 = _mm_load_si128((const __m128i *) (data + 2*8));
2631 row3 = _mm_load_si128((const __m128i *) (data + 3*8));
2632 row4 = _mm_load_si128((const __m128i *) (data + 4*8));
2633 row5 = _mm_load_si128((const __m128i *) (data + 5*8));
2634 row6 = _mm_load_si128((const __m128i *) (data + 6*8));
2635 row7 = _mm_load_si128((const __m128i *) (data + 7*8));
2637 // column pass
2638 dct_pass(bias_0, 10);
2640 {
2641 // 16bit 8x8 transpose pass 1
2642 dct_interleave16(row0, row4);
2643 dct_interleave16(row1, row5);
2644 dct_interleave16(row2, row6);
2645 dct_interleave16(row3, row7);
2647 // transpose pass 2
2648 dct_interleave16(row0, row2);
2649 dct_interleave16(row1, row3);
2650 dct_interleave16(row4, row6);
2651 dct_interleave16(row5, row7);
2653 // transpose pass 3
2654 dct_interleave16(row0, row1);
2655 dct_interleave16(row2, row3);
2656 dct_interleave16(row4, row5);
2657 dct_interleave16(row6, row7);
2658 }
2660 // row pass
2661 dct_pass(bias_1, 17);
2663 {
2664 // pack
2665 __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
2666 __m128i p1 = _mm_packus_epi16(row2, row3);
2667 __m128i p2 = _mm_packus_epi16(row4, row5);
2668 __m128i p3 = _mm_packus_epi16(row6, row7);
2670 // 8bit 8x8 transpose pass 1
2671 dct_interleave8(p0, p2); // a0e0a1e1...
2672 dct_interleave8(p1, p3); // c0g0c1g1...
2674 // transpose pass 2
2675 dct_interleave8(p0, p1); // a0c0e0g0...
2676 dct_interleave8(p2, p3); // b0d0f0h0...
2678 // transpose pass 3
2679 dct_interleave8(p0, p2); // a0b0c0d0...
2680 dct_interleave8(p1, p3); // a4b4c4d4...
2682 // store
2683 _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
2684 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
2685 _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
2686 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
2687 _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
2688 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
2689 _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
2690 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
2691 }
2693#undef dct_const
2694#undef dct_rot
2695#undef dct_widen
2696#undef dct_wadd
2697#undef dct_wsub
2698#undef dct_bfly32o
2699#undef dct_interleave8
2700#undef dct_interleave16
2701#undef dct_pass
2702}
2704#endif // STBI_SSE2
2706#ifdef STBI_NEON
2708// NEON integer IDCT. should produce bit-identical
2709// results to the generic C version.
2710static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
2711{
2712 int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
2714 int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
2715 int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
2716 int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
2717 int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
2718 int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
2719 int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
2720 int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
2721 int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
2722 int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
2723 int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
2724 int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
2725 int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
2727#define dct_long_mul(out, inq, coeff) \
2728 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
2729 int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
2731#define dct_long_mac(out, acc, inq, coeff) \
2732 int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
2733 int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
2735#define dct_widen(out, inq) \
2736 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
2737 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
2739// wide add
2740#define dct_wadd(out, a, b) \
2741 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
2742 int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
2744// wide sub
2745#define dct_wsub(out, a, b) \
2746 int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
2747 int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
2749// butterfly a/b, then shift using "shiftop" by "s" and pack
2750#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
2751 { \
2752 dct_wadd(sum, a, b); \
2753 dct_wsub(dif, a, b); \
2754 out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
2755 out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
2756 }
2758#define dct_pass(shiftop, shift) \
2759 { \
2760 /* even part */ \
2761 int16x8_t sum26 = vaddq_s16(row2, row6); \
2762 dct_long_mul(p1e, sum26, rot0_0); \
2763 dct_long_mac(t2e, p1e, row6, rot0_1); \
2764 dct_long_mac(t3e, p1e, row2, rot0_2); \
2765 int16x8_t sum04 = vaddq_s16(row0, row4); \
2766 int16x8_t dif04 = vsubq_s16(row0, row4); \
2767 dct_widen(t0e, sum04); \
2768 dct_widen(t1e, dif04); \
2769 dct_wadd(x0, t0e, t3e); \
2770 dct_wsub(x3, t0e, t3e); \
2771 dct_wadd(x1, t1e, t2e); \
2772 dct_wsub(x2, t1e, t2e); \
2773 /* odd part */ \
2774 int16x8_t sum15 = vaddq_s16(row1, row5); \
2775 int16x8_t sum17 = vaddq_s16(row1, row7); \
2776 int16x8_t sum35 = vaddq_s16(row3, row5); \
2777 int16x8_t sum37 = vaddq_s16(row3, row7); \
2778 int16x8_t sumodd = vaddq_s16(sum17, sum35); \
2779 dct_long_mul(p5o, sumodd, rot1_0); \
2780 dct_long_mac(p1o, p5o, sum17, rot1_1); \
2781 dct_long_mac(p2o, p5o, sum35, rot1_2); \
2782 dct_long_mul(p3o, sum37, rot2_0); \
2783 dct_long_mul(p4o, sum15, rot2_1); \
2784 dct_wadd(sump13o, p1o, p3o); \
2785 dct_wadd(sump24o, p2o, p4o); \
2786 dct_wadd(sump23o, p2o, p3o); \
2787 dct_wadd(sump14o, p1o, p4o); \
2788 dct_long_mac(x4, sump13o, row7, rot3_0); \
2789 dct_long_mac(x5, sump24o, row5, rot3_1); \
2790 dct_long_mac(x6, sump23o, row3, rot3_2); \
2791 dct_long_mac(x7, sump14o, row1, rot3_3); \
2792 dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
2793 dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
2794 dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
2795 dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
2796 }
2798 // load
2799 row0 = vld1q_s16(data + 0*8);
2800 row1 = vld1q_s16(data + 1*8);
2801 row2 = vld1q_s16(data + 2*8);
2802 row3 = vld1q_s16(data + 3*8);
2803 row4 = vld1q_s16(data + 4*8);
2804 row5 = vld1q_s16(data + 5*8);
2805 row6 = vld1q_s16(data + 6*8);
2806 row7 = vld1q_s16(data + 7*8);
2808 // add DC bias
2809 row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
2811 // column pass
2812 dct_pass(vrshrn_n_s32, 10);
2814 // 16bit 8x8 transpose
2815 {
2816// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
2817// whether compilers actually get this is another story, sadly.
2818#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
2819#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]); }
2820#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)); }
2822 // pass 1
2823 dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
2824 dct_trn16(row2, row3);
2825 dct_trn16(row4, row5);
2826 dct_trn16(row6, row7);
2828 // pass 2
2829 dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
2830 dct_trn32(row1, row3);
2831 dct_trn32(row4, row6);
2832 dct_trn32(row5, row7);
2834 // pass 3
2835 dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
2836 dct_trn64(row1, row5);
2837 dct_trn64(row2, row6);
2838 dct_trn64(row3, row7);
2840#undef dct_trn16
2841#undef dct_trn32
2842#undef dct_trn64
2843 }
2845 // row pass
2846 // vrshrn_n_s32 only supports shifts up to 16, we need
2847 // 17. so do a non-rounding shift of 16 first then follow
2848 // up with a rounding shift by 1.
2849 dct_pass(vshrn_n_s32, 16);
2851 {
2852 // pack and round
2853 uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
2854 uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
2855 uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
2856 uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
2857 uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
2858 uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
2859 uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
2860 uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
2862 // again, these can translate into one instruction, but often don't.
2863#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
2864#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]); }
2865#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]); }
2867 // sadly can't use interleaved stores here since we only write
2868 // 8 bytes to each scan line!
2870 // 8x8 8-bit transpose pass 1
2871 dct_trn8_8(p0, p1);
2872 dct_trn8_8(p2, p3);
2873 dct_trn8_8(p4, p5);
2874 dct_trn8_8(p6, p7);
2876 // pass 2
2877 dct_trn8_16(p0, p2);
2878 dct_trn8_16(p1, p3);
2879 dct_trn8_16(p4, p6);
2880 dct_trn8_16(p5, p7);
2882 // pass 3
2883 dct_trn8_32(p0, p4);
2884 dct_trn8_32(p1, p5);
2885 dct_trn8_32(p2, p6);
2886 dct_trn8_32(p3, p7);
2888 // store
2889 vst1_u8(out, p0); out += out_stride;
2890 vst1_u8(out, p1); out += out_stride;
2891 vst1_u8(out, p2); out += out_stride;
2892 vst1_u8(out, p3); out += out_stride;
2893 vst1_u8(out, p4); out += out_stride;
2894 vst1_u8(out, p5); out += out_stride;
2895 vst1_u8(out, p6); out += out_stride;
2896 vst1_u8(out, p7);
2898#undef dct_trn8_8
2899#undef dct_trn8_16
2900#undef dct_trn8_32
2901 }
2903#undef dct_long_mul
2904#undef dct_long_mac
2905#undef dct_widen
2906#undef dct_wadd
2907#undef dct_wsub
2908#undef dct_bfly32o
2909#undef dct_pass
2910}
2912#endif // STBI_NEON
2914#define STBI__MARKER_none 0xff
2915// if there's a pending marker from the entropy stream, return that
2916// otherwise, fetch from the stream and get a marker. if there's no
2917// marker, return 0xff, which is never a valid marker value
2918static stbi_uc stbi__get_marker(stbi__jpeg *j)
2919{
2920 stbi_uc x;
2921 if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
2922 x = stbi__get8(j->s);
2923 if (x != 0xff) return STBI__MARKER_none;
2924 while (x == 0xff)
2925 x = stbi__get8(j->s); // consume repeated 0xff fill bytes
2926 return x;
2927}
2929// in each scan, we'll have scan_n components, and the order
2930// of the components is specified by order[]
2931#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
2933// after a restart interval, stbi__jpeg_reset the entropy decoder and
2934// the dc prediction
2935static void stbi__jpeg_reset(stbi__jpeg *j)
2936{
2937 j->code_bits = 0;
2938 j->code_buffer = 0;
2939 j->nomore = 0;
2940 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;
2941 j->marker = STBI__MARKER_none;
2942 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
2943 j->eob_run = 0;
2944 // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
2945 // since we don't even allow 1<<30 pixels
2946}
2948static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
2949{
2950 stbi__jpeg_reset(z);
2951 if (!z->progressive) {
2952 if (z->scan_n == 1) {
2953 int i,j;
2954 STBI_SIMD_ALIGN(short, data[64]);
2955 int n = z->order[0];
2956 // non-interleaved data, we just need to process one block at a time,
2957 // in trivial scanline order
2958 // number of blocks to do just depends on how many actual "pixels" this
2959 // component has, independent of interleaved MCU blocking and such
2960 int w = (z->img_comp[n].x+7) >> 3;
2961 int h = (z->img_comp[n].y+7) >> 3;
2962 for (j=0; j < h; ++j) {
2963 for (i=0; i < w; ++i) {
2964 int ha = z->img_comp[n].ha;
2965 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;
2966 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
2967 // every data block is an MCU, so countdown the restart interval
2968 if (--z->todo <= 0) {
2969 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2970 // if it's NOT a restart, then just bail, so we get corrupt data
2971 // rather than no data
2972 if (!STBI__RESTART(z->marker)) return 1;
2973 stbi__jpeg_reset(z);
2974 }
2975 }
2976 }
2977 return 1;
2978 } else { // interleaved
2979 int i,j,k,x,y;
2980 STBI_SIMD_ALIGN(short, data[64]);
2981 for (j=0; j < z->img_mcu_y; ++j) {
2982 for (i=0; i < z->img_mcu_x; ++i) {
2983 // scan an interleaved mcu... process scan_n components in order
2984 for (k=0; k < z->scan_n; ++k) {
2985 int n = z->order[k];
2986 // scan out an mcu's worth of this component; that's just determined
2987 // by the basic H and V specified for the component
2988 for (y=0; y < z->img_comp[n].v; ++y) {
2989 for (x=0; x < z->img_comp[n].h; ++x) {
2990 int x2 = (i*z->img_comp[n].h + x)*8;
2991 int y2 = (j*z->img_comp[n].v + y)*8;
2992 int ha = z->img_comp[n].ha;
2993 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;
2994 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
2995 }
2996 }
2997 }
2998 // after all interleaved components, that's an interleaved MCU,
2999 // so now count down the restart interval
3000 if (--z->todo <= 0) {
3001 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3002 if (!STBI__RESTART(z->marker)) return 1;
3003 stbi__jpeg_reset(z);
3004 }
3005 }
3006 }
3007 return 1;
3008 }
3009 } else {
3010 if (z->scan_n == 1) {
3011 int i,j;
3012 int n = z->order[0];
3013 // non-interleaved data, we just need to process one block at a time,
3014 // in trivial scanline order
3015 // number of blocks to do just depends on how many actual "pixels" this
3016 // component has, independent of interleaved MCU blocking and such
3017 int w = (z->img_comp[n].x+7) >> 3;
3018 int h = (z->img_comp[n].y+7) >> 3;
3019 for (j=0; j < h; ++j) {
3020 for (i=0; i < w; ++i) {
3021 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3022 if (z->spec_start == 0) {
3023 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3024 return 0;
3025 } else {
3026 int ha = z->img_comp[n].ha;
3027 if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
3028 return 0;
3029 }
3030 // every data block is an MCU, so countdown the restart interval
3031 if (--z->todo <= 0) {
3032 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3033 if (!STBI__RESTART(z->marker)) return 1;
3034 stbi__jpeg_reset(z);
3035 }
3036 }
3037 }
3038 return 1;
3039 } else { // interleaved
3040 int i,j,k,x,y;
3041 for (j=0; j < z->img_mcu_y; ++j) {
3042 for (i=0; i < z->img_mcu_x; ++i) {
3043 // scan an interleaved mcu... process scan_n components in order
3044 for (k=0; k < z->scan_n; ++k) {
3045 int n = z->order[k];
3046 // scan out an mcu's worth of this component; that's just determined
3047 // by the basic H and V specified for the component
3048 for (y=0; y < z->img_comp[n].v; ++y) {
3049 for (x=0; x < z->img_comp[n].h; ++x) {
3050 int x2 = (i*z->img_comp[n].h + x);
3051 int y2 = (j*z->img_comp[n].v + y);
3052 short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
3053 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3054 return 0;
3055 }
3056 }
3057 }
3058 // after all interleaved components, that's an interleaved MCU,
3059 // so now count down the restart interval
3060 if (--z->todo <= 0) {
3061 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3062 if (!STBI__RESTART(z->marker)) return 1;
3063 stbi__jpeg_reset(z);
3064 }
3065 }
3066 }
3067 return 1;
3068 }
3069 }
3070}
3072static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
3073{
3074 int i;
3075 for (i=0; i < 64; ++i)
3076 data[i] *= dequant[i];
3077}
3079static void stbi__jpeg_finish(stbi__jpeg *z)
3080{
3081 if (z->progressive) {
3082 // dequantize and idct the data
3083 int i,j,n;
3084 for (n=0; n < z->s->img_n; ++n) {
3085 int w = (z->img_comp[n].x+7) >> 3;
3086 int h = (z->img_comp[n].y+7) >> 3;
3087 for (j=0; j < h; ++j) {
3088 for (i=0; i < w; ++i) {
3089 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3090 stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
3091 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
3092 }
3093 }
3094 }
3095 }
3096}
3098static int stbi__process_marker(stbi__jpeg *z, int m)
3099{
3100 int L;
3101 switch (m) {
3102 case STBI__MARKER_none: // no marker found
3103 return stbi__err("expected marker","Corrupt JPEG");
3105 case 0xDD: // DRI - specify restart interval
3106 if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
3107 z->restart_interval = stbi__get16be(z->s);
3108 return 1;
3110 case 0xDB: // DQT - define quantization table
3111 L = stbi__get16be(z->s)-2;
3112 while (L > 0) {
3113 int q = stbi__get8(z->s);
3114 int p = q >> 4, sixteen = (p != 0);
3115 int t = q & 15,i;
3116 if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
3117 if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
3119 for (i=0; i < 64; ++i)
3120 z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
3121 L -= (sixteen ? 129 : 65);
3122 }
3123 return L==0;
3125 case 0xC4: // DHT - define huffman table
3126 L = stbi__get16be(z->s)-2;
3127 while (L > 0) {
3128 stbi_uc *v;
3129 int sizes[16],i,n=0;
3130 int q = stbi__get8(z->s);
3131 int tc = q >> 4;
3132 int th = q & 15;
3133 if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
3134 for (i=0; i < 16; ++i) {
3135 sizes[i] = stbi__get8(z->s);
3136 n += sizes[i];
3137 }
3138 if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
3139 L -= 17;
3140 if (tc == 0) {
3141 if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
3142 v = z->huff_dc[th].values;
3143 } else {
3144 if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
3145 v = z->huff_ac[th].values;
3146 }
3147 for (i=0; i < n; ++i)
3148 v[i] = stbi__get8(z->s);
3149 if (tc != 0)
3150 stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
3151 L -= n;
3152 }
3153 return L==0;
3154 }
3156 // check for comment block or APP blocks
3157 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
3158 L = stbi__get16be(z->s);
3159 if (L < 2) {
3160 if (m == 0xFE)
3161 return stbi__err("bad COM len","Corrupt JPEG");
3162 else
3163 return stbi__err("bad APP len","Corrupt JPEG");
3164 }
3165 L -= 2;
3167 if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
3168 static const unsigned char tag[5] = {'J','F','I','F','\0'};
3169 int ok = 1;
3170 int i;
3171 for (i=0; i < 5; ++i)
3172 if (stbi__get8(z->s) != tag[i])
3173 ok = 0;
3174 L -= 5;
3175 if (ok)
3176 z->jfif = 1;
3177 } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
3178 static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
3179 int ok = 1;
3180 int i;
3181 for (i=0; i < 6; ++i)
3182 if (stbi__get8(z->s) != tag[i])
3183 ok = 0;
3184 L -= 6;
3185 if (ok) {
3186 stbi__get8(z->s); // version
3187 stbi__get16be(z->s); // flags0
3188 stbi__get16be(z->s); // flags1
3189 z->app14_color_transform = stbi__get8(z->s); // color transform
3190 L -= 6;
3191 }
3192 }
3194 stbi__skip(z->s, L);
3195 return 1;
3196 }
3198 return stbi__err("unknown marker","Corrupt JPEG");
3199}
3201// after we see SOS
3202static int stbi__process_scan_header(stbi__jpeg *z)
3203{
3204 int i;
3205 int Ls = stbi__get16be(z->s);
3206 z->scan_n = stbi__get8(z->s);
3207 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");
3208 if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
3209 for (i=0; i < z->scan_n; ++i) {
3210 int id = stbi__get8(z->s), which;
3211 int q = stbi__get8(z->s);
3212 for (which = 0; which < z->s->img_n; ++which)
3213 if (z->img_comp[which].id == id)
3214 break;
3215 if (which == z->s->img_n) return 0; // no match
3216 z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
3217 z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
3218 z->order[i] = which;
3219 }
3221 {
3222 int aa;
3223 z->spec_start = stbi__get8(z->s);
3224 z->spec_end = stbi__get8(z->s); // should be 63, but might be 0
3225 aa = stbi__get8(z->s);
3226 z->succ_high = (aa >> 4);
3227 z->succ_low = (aa & 15);
3228 if (z->progressive) {
3229 if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
3230 return stbi__err("bad SOS", "Corrupt JPEG");
3231 } else {
3232 if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
3233 if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
3234 z->spec_end = 63;
3235 }
3236 }
3238 return 1;
3239}
3241static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
3242{
3243 int i;
3244 for (i=0; i < ncomp; ++i) {
3245 if (z->img_comp[i].raw_data) {
3246 STBI_FREE(z->img_comp[i].raw_data);
3247 z->img_comp[i].raw_data = NULL;
3248 z->img_comp[i].data = NULL;
3249 }
3250 if (z->img_comp[i].raw_coeff) {
3251 STBI_FREE(z->img_comp[i].raw_coeff);
3252 z->img_comp[i].raw_coeff = 0;
3253 z->img_comp[i].coeff = 0;
3254 }
3255 if (z->img_comp[i].linebuf) {
3256 STBI_FREE(z->img_comp[i].linebuf);
3257 z->img_comp[i].linebuf = NULL;
3258 }
3259 }
3260 return why;
3261}
3263static int stbi__process_frame_header(stbi__jpeg *z, int scan)
3264{
3265 stbi__context *s = z->s;
3266 int Lf,p,i,q, h_max=1,v_max=1,c;
3267 Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
3268 p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
3269 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
3270 s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
3271 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
3272 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
3273 c = stbi__get8(s);
3274 if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
3275 s->img_n = c;
3276 for (i=0; i < c; ++i) {
3277 z->img_comp[i].data = NULL;
3278 z->img_comp[i].linebuf = NULL;
3279 }
3281 if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
3283 z->rgb = 0;
3284 for (i=0; i < s->img_n; ++i) {
3285 static const unsigned char rgb[3] = { 'R', 'G', 'B' };
3286 z->img_comp[i].id = stbi__get8(s);
3287 if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
3288 ++z->rgb;
3289 q = stbi__get8(s);
3290 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");
3291 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");
3292 z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
3293 }
3295 if (scan != STBI__SCAN_load) return 1;
3297 if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
3299 for (i=0; i < s->img_n; ++i) {
3300 if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
3301 if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
3302 }
3304 // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
3305 // and I've never seen a non-corrupted JPEG file actually use them
3306 for (i=0; i < s->img_n; ++i) {
3307 if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
3308 if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
3309 }
3311 // compute interleaved mcu info
3312 z->img_h_max = h_max;
3313 z->img_v_max = v_max;
3314 z->img_mcu_w = h_max * 8;
3315 z->img_mcu_h = v_max * 8;
3316 // these sizes can't be more than 17 bits
3317 z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
3318 z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
3320 for (i=0; i < s->img_n; ++i) {
3321 // number of effective pixels (e.g. for non-interleaved MCU)
3322 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
3323 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
3324 // to simplify generation, we'll allocate enough memory to decode
3325 // the bogus oversized data from using interleaved MCUs and their
3326 // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
3327 // discard the extra data until colorspace conversion
3328 //
3329 // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
3330 // so these muls can't overflow with 32-bit ints (which we require)
3331 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
3332 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
3333 z->img_comp[i].coeff = 0;
3334 z->img_comp[i].raw_coeff = 0;
3335 z->img_comp[i].linebuf = NULL;
3336 z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
3337 if (z->img_comp[i].raw_data == NULL)
3338 return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
3339 // align blocks for idct using mmx/sse
3340 z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
3341 if (z->progressive) {
3342 // w2, h2 are multiples of 8 (see above)
3343 z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
3344 z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
3345 z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
3346 if (z->img_comp[i].raw_coeff == NULL)
3347 return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
3348 z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
3349 }
3350 }
3352 return 1;
3353}
3355// use comparisons since in some cases we handle more than one case (e.g. SOF)
3356#define stbi__DNL(x) ((x) == 0xdc)
3357#define stbi__SOI(x) ((x) == 0xd8)
3358#define stbi__EOI(x) ((x) == 0xd9)
3359#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
3360#define stbi__SOS(x) ((x) == 0xda)
3362#define stbi__SOF_progressive(x) ((x) == 0xc2)
3364static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
3365{
3366 int m;
3367 z->jfif = 0;
3368 z->app14_color_transform = -1; // valid values are 0,1,2
3369 z->marker = STBI__MARKER_none; // initialize cached marker to empty
3370 m = stbi__get_marker(z);
3371 if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
3372 if (scan == STBI__SCAN_type) return 1;
3373 m = stbi__get_marker(z);
3374 while (!stbi__SOF(m)) {
3375 if (!stbi__process_marker(z,m)) return 0;
3376 m = stbi__get_marker(z);
3377 while (m == STBI__MARKER_none) {
3378 // some files have extra padding after their blocks, so ok, we'll scan
3379 if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
3380 m = stbi__get_marker(z);
3381 }
3382 }
3383 z->progressive = stbi__SOF_progressive(m);
3384 if (!stbi__process_frame_header(z, scan)) return 0;
3385 return 1;
3386}
3388static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
3389{
3390 // some JPEGs have junk at end, skip over it but if we find what looks
3391 // like a valid marker, resume there
3392 while (!stbi__at_eof(j->s)) {
3393 stbi_uc x = stbi__get8(j->s);
3394 while (x == 0xff) { // might be a marker
3395 if (stbi__at_eof(j->s)) return STBI__MARKER_none;
3396 x = stbi__get8(j->s);
3397 if (x != 0x00 && x != 0xff) {
3398 // not a stuffed zero or lead-in to another marker, looks
3399 // like an actual marker, return it
3400 return x;
3401 }
3402 // stuffed zero has x=0 now which ends the loop, meaning we go
3403 // back to regular scan loop.
3404 // repeated 0xff keeps trying to read the next byte of the marker.
3405 }
3406 }
3407 return STBI__MARKER_none;
3408}
3410// decode image to YCbCr format
3411static int stbi__decode_jpeg_image(stbi__jpeg *j)
3412{
3413 int m;
3414 for (m = 0; m < 4; m++) {
3415 j->img_comp[m].raw_data = NULL;
3416 j->img_comp[m].raw_coeff = NULL;
3417 }
3418 j->restart_interval = 0;
3419 if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
3420 m = stbi__get_marker(j);
3421 while (!stbi__EOI(m)) {
3422 if (stbi__SOS(m)) {
3423 if (!stbi__process_scan_header(j)) return 0;
3424 if (!stbi__parse_entropy_coded_data(j)) return 0;
3425 if (j->marker == STBI__MARKER_none ) {
3426 j->marker = stbi__skip_jpeg_junk_at_end(j);
3427 // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
3428 }
3429 m = stbi__get_marker(j);
3430 if (STBI__RESTART(m))
3431 m = stbi__get_marker(j);
3432 } else if (stbi__DNL(m)) {
3433 int Ld = stbi__get16be(j->s);
3434 stbi__uint32 NL = stbi__get16be(j->s);
3435 if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
3436 if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
3437 m = stbi__get_marker(j);
3438 } else {
3439 if (!stbi__process_marker(j, m)) return 1;
3440 m = stbi__get_marker(j);
3441 }
3442 }
3443 if (j->progressive)
3444 stbi__jpeg_finish(j);
3445 return 1;
3446}
3448// static jfif-centered resampling (across block boundaries)
3450typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
3451 int w, int hs);
3453#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
3455static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3456{
3457 STBI_NOTUSED(out);
3458 STBI_NOTUSED(in_far);
3459 STBI_NOTUSED(w);
3460 STBI_NOTUSED(hs);
3461 return in_near;
3462}
3464static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3465{
3466 // need to generate two samples vertically for every one in input
3467 int i;
3468 STBI_NOTUSED(hs);
3469 for (i=0; i < w; ++i)
3470 out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
3471 return out;
3472}
3474static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3475{
3476 // need to generate two samples horizontally for every one in input
3477 int i;
3478 stbi_uc *input = in_near;
3480 if (w == 1) {
3481 // if only one sample, can't do any interpolation
3482 out[0] = out[1] = input[0];
3483 return out;
3484 }
3486 out[0] = input[0];
3487 out[1] = stbi__div4(input[0]*3 + input[1] + 2);
3488 for (i=1; i < w-1; ++i) {
3489 int n = 3*input[i]+2;
3490 out[i*2+0] = stbi__div4(n+input[i-1]);
3491 out[i*2+1] = stbi__div4(n+input[i+1]);
3492 }
3493 out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
3494 out[i*2+1] = input[w-1];
3496 STBI_NOTUSED(in_far);
3497 STBI_NOTUSED(hs);
3499 return out;
3500}
3502#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
3504static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3505{
3506 // need to generate 2x2 samples for every one in input
3507 int i,t0,t1;
3508 if (w == 1) {
3509 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3510 return out;
3511 }
3513 t1 = 3*in_near[0] + in_far[0];
3514 out[0] = stbi__div4(t1+2);
3515 for (i=1; i < w; ++i) {
3516 t0 = t1;
3517 t1 = 3*in_near[i]+in_far[i];
3518 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3519 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3520 }
3521 out[w*2-1] = stbi__div4(t1+2);
3523 STBI_NOTUSED(hs);
3525 return out;
3526}
3528#if defined(STBI_SSE2) || defined(STBI_NEON)
3529static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3530{
3531 // need to generate 2x2 samples for every one in input
3532 int i=0,t0,t1;
3534 if (w == 1) {
3535 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3536 return out;
3537 }
3539 t1 = 3*in_near[0] + in_far[0];
3540 // process groups of 8 pixels for as long as we can.
3541 // note we can't handle the last pixel in a row in this loop
3542 // because we need to handle the filter boundary conditions.
3543 for (; i < ((w-1) & ~7); i += 8) {
3544#if defined(STBI_SSE2)
3545 // load and perform the vertical filtering pass
3546 // this uses 3*x + y = 4*x + (y - x)
3547 __m128i zero = _mm_setzero_si128();
3548 __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
3549 __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
3550 __m128i farw = _mm_unpacklo_epi8(farb, zero);
3551 __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
3552 __m128i diff = _mm_sub_epi16(farw, nearw);
3553 __m128i nears = _mm_slli_epi16(nearw, 2);
3554 __m128i curr = _mm_add_epi16(nears, diff); // current row
3556 // horizontal filter works the same based on shifted vers of current
3557 // row. "prev" is current row shifted right by 1 pixel; we need to
3558 // insert the previous pixel value (from t1).
3559 // "next" is current row shifted left by 1 pixel, with first pixel
3560 // of next block of 8 pixels added in.
3561 __m128i prv0 = _mm_slli_si128(curr, 2);
3562 __m128i nxt0 = _mm_srli_si128(curr, 2);
3563 __m128i prev = _mm_insert_epi16(prv0, t1, 0);
3564 __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
3566 // horizontal filter, polyphase implementation since it's convenient:
3567 // even pixels = 3*cur + prev = cur*4 + (prev - cur)
3568 // odd pixels = 3*cur + next = cur*4 + (next - cur)
3569 // note the shared term.
3570 __m128i bias = _mm_set1_epi16(8);
3571 __m128i curs = _mm_slli_epi16(curr, 2);
3572 __m128i prvd = _mm_sub_epi16(prev, curr);
3573 __m128i nxtd = _mm_sub_epi16(next, curr);
3574 __m128i curb = _mm_add_epi16(curs, bias);
3575 __m128i even = _mm_add_epi16(prvd, curb);
3576 __m128i odd = _mm_add_epi16(nxtd, curb);
3578 // interleave even and odd pixels, then undo scaling.
3579 __m128i int0 = _mm_unpacklo_epi16(even, odd);
3580 __m128i int1 = _mm_unpackhi_epi16(even, odd);
3581 __m128i de0 = _mm_srli_epi16(int0, 4);
3582 __m128i de1 = _mm_srli_epi16(int1, 4);
3584 // pack and write output
3585 __m128i outv = _mm_packus_epi16(de0, de1);
3586 _mm_storeu_si128((__m128i *) (out + i*2), outv);
3587#elif defined(STBI_NEON)
3588 // load and perform the vertical filtering pass
3589 // this uses 3*x + y = 4*x + (y - x)
3590 uint8x8_t farb = vld1_u8(in_far + i);
3591 uint8x8_t nearb = vld1_u8(in_near + i);
3592 int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
3593 int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
3594 int16x8_t curr = vaddq_s16(nears, diff); // current row
3596 // horizontal filter works the same based on shifted vers of current
3597 // row. "prev" is current row shifted right by 1 pixel; we need to
3598 // insert the previous pixel value (from t1).
3599 // "next" is current row shifted left by 1 pixel, with first pixel
3600 // of next block of 8 pixels added in.
3601 int16x8_t prv0 = vextq_s16(curr, curr, 7);
3602 int16x8_t nxt0 = vextq_s16(curr, curr, 1);
3603 int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
3604 int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
3606 // horizontal filter, polyphase implementation since it's convenient:
3607 // even pixels = 3*cur + prev = cur*4 + (prev - cur)
3608 // odd pixels = 3*cur + next = cur*4 + (next - cur)
3609 // note the shared term.
3610 int16x8_t curs = vshlq_n_s16(curr, 2);
3611 int16x8_t prvd = vsubq_s16(prev, curr);
3612 int16x8_t nxtd = vsubq_s16(next, curr);
3613 int16x8_t even = vaddq_s16(curs, prvd);
3614 int16x8_t odd = vaddq_s16(curs, nxtd);
3616 // undo scaling and round, then store with even/odd phases interleaved
3617 uint8x8x2_t o;
3618 o.val[0] = vqrshrun_n_s16(even, 4);
3619 o.val[1] = vqrshrun_n_s16(odd, 4);
3620 vst2_u8(out + i*2, o);
3621#endif
3623 // "previous" value for next iter
3624 t1 = 3*in_near[i+7] + in_far[i+7];
3625 }
3627 t0 = t1;
3628 t1 = 3*in_near[i] + in_far[i];
3629 out[i*2] = stbi__div16(3*t1 + t0 + 8);
3631 for (++i; i < w; ++i) {
3632 t0 = t1;
3633 t1 = 3*in_near[i]+in_far[i];
3634 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3635 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3636 }
3637 out[w*2-1] = stbi__div4(t1+2);
3639 STBI_NOTUSED(hs);
3641 return out;
3642}
3643#endif
3645static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3646{
3647 // resample with nearest-neighbor
3648 int i,j;
3649 STBI_NOTUSED(in_far);
3650 for (i=0; i < w; ++i)
3651 for (j=0; j < hs; ++j)
3652 out[i*hs+j] = in_near[i];
3653 return out;
3654}
3656// this is a reduced-precision calculation of YCbCr-to-RGB introduced
3657// to make sure the code produces the same results in both SIMD and scalar
3658#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
3659static 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)
3660{
3661 int i;
3662 for (i=0; i < count; ++i) {
3663 int y_fixed = (y[i] << 20) + (1<<19); // rounding
3664 int r,g,b;
3665 int cr = pcr[i] - 128;
3666 int cb = pcb[i] - 128;
3667 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3668 g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3669 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3670 r >>= 20;
3671 g >>= 20;
3672 b >>= 20;
3673 if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
3674 if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
3675 if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
3676 out[0] = (stbi_uc)r;
3677 out[1] = (stbi_uc)g;
3678 out[2] = (stbi_uc)b;
3679 out[3] = 255;
3680 out += step;
3681 }
3682}
3684#if defined(STBI_SSE2) || defined(STBI_NEON)
3685static 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)
3686{
3687 int i = 0;
3689#ifdef STBI_SSE2
3690 // step == 3 is pretty ugly on the final interleave, and i'm not convinced
3691 // it's useful in practice (you wouldn't use it for textures, for example).
3692 // so just accelerate step == 4 case.
3693 if (step == 4) {
3694 // this is a fairly straightforward implementation and not super-optimized.
3695 __m128i signflip = _mm_set1_epi8(-0x80);
3696 __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));
3697 __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
3698 __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
3699 __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));
3700 __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
3701 __m128i xw = _mm_set1_epi16(255); // alpha channel
3703 for (; i+7 < count; i += 8) {
3704 // load
3705 __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
3706 __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
3707 __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
3708 __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
3709 __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
3711 // unpack to short (and left-shift cr, cb by 8)
3712 __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
3713 __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
3714 __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
3716 // color transform
3717 __m128i yws = _mm_srli_epi16(yw, 4);
3718 __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
3719 __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
3720 __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
3721 __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
3722 __m128i rws = _mm_add_epi16(cr0, yws);
3723 __m128i gwt = _mm_add_epi16(cb0, yws);
3724 __m128i bws = _mm_add_epi16(yws, cb1);
3725 __m128i gws = _mm_add_epi16(gwt, cr1);
3727 // descale
3728 __m128i rw = _mm_srai_epi16(rws, 4);
3729 __m128i bw = _mm_srai_epi16(bws, 4);
3730 __m128i gw = _mm_srai_epi16(gws, 4);
3732 // back to byte, set up for transpose
3733 __m128i brb = _mm_packus_epi16(rw, bw);
3734 __m128i gxb = _mm_packus_epi16(gw, xw);
3736 // transpose to interleave channels
3737 __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
3738 __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
3739 __m128i o0 = _mm_unpacklo_epi16(t0, t1);
3740 __m128i o1 = _mm_unpackhi_epi16(t0, t1);
3742 // store
3743 _mm_storeu_si128((__m128i *) (out + 0), o0);
3744 _mm_storeu_si128((__m128i *) (out + 16), o1);
3745 out += 32;
3746 }
3747 }
3748#endif
3750#ifdef STBI_NEON
3751 // in this version, step=3 support would be easy to add. but is there demand?
3752 if (step == 4) {
3753 // this is a fairly straightforward implementation and not super-optimized.
3754 uint8x8_t signflip = vdup_n_u8(0x80);
3755 int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));
3756 int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
3757 int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
3758 int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));
3760 for (; i+7 < count; i += 8) {
3761 // load
3762 uint8x8_t y_bytes = vld1_u8(y + i);
3763 uint8x8_t cr_bytes = vld1_u8(pcr + i);
3764 uint8x8_t cb_bytes = vld1_u8(pcb + i);
3765 int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
3766 int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
3768 // expand to s16
3769 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
3770 int16x8_t crw = vshll_n_s8(cr_biased, 7);
3771 int16x8_t cbw = vshll_n_s8(cb_biased, 7);
3773 // color transform
3774 int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
3775 int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
3776 int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
3777 int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
3778 int16x8_t rws = vaddq_s16(yws, cr0);
3779 int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
3780 int16x8_t bws = vaddq_s16(yws, cb1);
3782 // undo scaling, round, convert to byte
3783 uint8x8x4_t o;
3784 o.val[0] = vqrshrun_n_s16(rws, 4);
3785 o.val[1] = vqrshrun_n_s16(gws, 4);
3786 o.val[2] = vqrshrun_n_s16(bws, 4);
3787 o.val[3] = vdup_n_u8(255);
3789 // store, interleaving r/g/b/a
3790 vst4_u8(out, o);
3791 out += 8*4;
3792 }
3793 }
3794#endif
3796 for (; i < count; ++i) {
3797 int y_fixed = (y[i] << 20) + (1<<19); // rounding
3798 int r,g,b;
3799 int cr = pcr[i] - 128;
3800 int cb = pcb[i] - 128;
3801 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3802 g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3803 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3804 r >>= 20;
3805 g >>= 20;
3806 b >>= 20;
3807 if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
3808 if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
3809 if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
3810 out[0] = (stbi_uc)r;
3811 out[1] = (stbi_uc)g;
3812 out[2] = (stbi_uc)b;
3813 out[3] = 255;
3814 out += step;
3815 }
3816}
3817#endif
3819// set up the kernels
3820static void stbi__setup_jpeg(stbi__jpeg *j)
3821{
3822 j->idct_block_kernel = stbi__idct_block;
3823 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
3824 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
3826#ifdef STBI_SSE2
3827 if (stbi__sse2_available()) {
3828 j->idct_block_kernel = stbi__idct_simd;
3829 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3830 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3831 }
3832#endif
3834#ifdef STBI_NEON
3835 j->idct_block_kernel = stbi__idct_simd;
3836 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3837 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3838#endif
3839}
3841// clean up the temporary component buffers
3842static void stbi__cleanup_jpeg(stbi__jpeg *j)
3843{
3844 stbi__free_jpeg_components(j, j->s->img_n, 0);
3845}
3847typedef struct
3848{
3849 resample_row_func resample;
3850 stbi_uc *line0,*line1;
3851 int hs,vs; // expansion factor in each axis
3852 int w_lores; // horizontal pixels pre-expansion
3853 int ystep; // how far through vertical expansion we are
3854 int ypos; // which pre-expansion row we're on
3855} stbi__resample;
3857// fast 0..255 * 0..255 => 0..255 rounded multiplication
3858static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
3859{
3860 unsigned int t = x*y + 128;
3861 return (stbi_uc) ((t + (t >>8)) >> 8);
3862}
3864static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
3865{
3866 int n, decode_n, is_rgb;
3867 z->s->img_n = 0; // make stbi__cleanup_jpeg safe
3869 // validate req_comp
3870 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
3872 // load a jpeg image from whichever source, but leave in YCbCr format
3873 if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
3875 // determine actual number of components to generate
3876 n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
3878 is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
3880 if (z->s->img_n == 3 && n < 3 && !is_rgb)
3881 decode_n = 1;
3882 else
3883 decode_n = z->s->img_n;
3885 // nothing to do if no components requested; check this now to avoid
3886 // accessing uninitialized coutput[0] later
3887 if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
3889 // resample and color-convert
3890 {
3891 int k;
3892 unsigned int i,j;
3893 stbi_uc *output;
3894 stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
3896 stbi__resample res_comp[4];
3898 for (k=0; k < decode_n; ++k) {
3899 stbi__resample *r = &res_comp[k];
3901 // allocate line buffer big enough for upsampling off the edges
3902 // with upsample factor of 4
3903 z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
3904 if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
3906 r->hs = z->img_h_max / z->img_comp[k].h;
3907 r->vs = z->img_v_max / z->img_comp[k].v;
3908 r->ystep = r->vs >> 1;
3909 r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
3910 r->ypos = 0;
3911 r->line0 = r->line1 = z->img_comp[k].data;
3913 if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
3914 else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
3915 else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
3916 else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
3917 else r->resample = stbi__resample_row_generic;
3918 }
3920 // can't error after this so, this is safe
3921 output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
3922 if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
3924 // now go ahead and resample
3925 for (j=0; j < z->s->img_y; ++j) {
3926 stbi_uc *out = output + n * z->s->img_x * j;
3927 for (k=0; k < decode_n; ++k) {
3928 stbi__resample *r = &res_comp[k];
3929 int y_bot = r->ystep >= (r->vs >> 1);
3930 coutput[k] = r->resample(z->img_comp[k].linebuf,
3931 y_bot ? r->line1 : r->line0,
3932 y_bot ? r->line0 : r->line1,
3933 r->w_lores, r->hs);
3934 if (++r->ystep >= r->vs) {
3935 r->ystep = 0;
3936 r->line0 = r->line1;
3937 if (++r->ypos < z->img_comp[k].y)
3938 r->line1 += z->img_comp[k].w2;
3939 }
3940 }
3941 if (n >= 3) {
3942 stbi_uc *y = coutput[0];
3943 if (z->s->img_n == 3) {
3944 if (is_rgb) {
3945 for (i=0; i < z->s->img_x; ++i) {
3946 out[0] = y[i];
3947 out[1] = coutput[1][i];
3948 out[2] = coutput[2][i];
3949 out[3] = 255;
3950 out += n;
3951 }
3952 } else {
3953 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3954 }
3955 } else if (z->s->img_n == 4) {
3956 if (z->app14_color_transform == 0) { // CMYK
3957 for (i=0; i < z->s->img_x; ++i) {
3958 stbi_uc m = coutput[3][i];
3959 out[0] = stbi__blinn_8x8(coutput[0][i], m);
3960 out[1] = stbi__blinn_8x8(coutput[1][i], m);
3961 out[2] = stbi__blinn_8x8(coutput[2][i], m);
3962 out[3] = 255;
3963 out += n;
3964 }
3965 } else if (z->app14_color_transform == 2) { // YCCK
3966 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3967 for (i=0; i < z->s->img_x; ++i) {
3968 stbi_uc m = coutput[3][i];
3969 out[0] = stbi__blinn_8x8(255 - out[0], m);
3970 out[1] = stbi__blinn_8x8(255 - out[1], m);
3971 out[2] = stbi__blinn_8x8(255 - out[2], m);
3972 out += n;
3973 }
3974 } else { // YCbCr + alpha? Ignore the fourth channel for now
3975 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3976 }
3977 } else
3978 for (i=0; i < z->s->img_x; ++i) {
3979 out[0] = out[1] = out[2] = y[i];
3980 out[3] = 255; // not used if n==3
3981 out += n;
3982 }
3983 } else {
3984 if (is_rgb) {
3985 if (n == 1)
3986 for (i=0; i < z->s->img_x; ++i)
3987 *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3988 else {
3989 for (i=0; i < z->s->img_x; ++i, out += 2) {
3990 out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3991 out[1] = 255;
3992 }
3993 }
3994 } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
3995 for (i=0; i < z->s->img_x; ++i) {
3996 stbi_uc m = coutput[3][i];
3997 stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
3998 stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
3999 stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
4000 out[0] = stbi__compute_y(r, g, b);
4001 out[1] = 255;
4002 out += n;
4003 }
4004 } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
4005 for (i=0; i < z->s->img_x; ++i) {
4006 out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
4007 out[1] = 255;
4008 out += n;
4009 }
4010 } else {
4011 stbi_uc *y = coutput[0];
4012 if (n == 1)
4013 for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
4014 else
4015 for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
4016 }
4017 }
4018 }
4019 stbi__cleanup_jpeg(z);
4020 *out_x = z->s->img_x;
4021 *out_y = z->s->img_y;
4022 if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
4023 return output;
4024 }
4025}
4027static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
4028{
4029 unsigned char* result;
4030 stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
4031 if (!j) return stbi__errpuc("outofmem", "Out of memory");
4032 memset(j, 0, sizeof(stbi__jpeg));
4033 STBI_NOTUSED(ri);
4034 j->s = s;
4035 stbi__setup_jpeg(j);
4036 result = load_jpeg_image(j, x,y,comp,req_comp);
4037 STBI_FREE(j);
4038 return result;
4039}
4041static int stbi__jpeg_test(stbi__context *s)
4042{
4043 int r;
4044 stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
4045 if (!j) return stbi__err("outofmem", "Out of memory");
4046 memset(j, 0, sizeof(stbi__jpeg));
4047 j->s = s;
4048 stbi__setup_jpeg(j);
4049 r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
4050 stbi__rewind(s);
4051 STBI_FREE(j);
4052 return r;
4053}
4055static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
4056{
4057 if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
4058 stbi__rewind( j->s );
4059 return 0;
4060 }
4061 if (x) *x = j->s->img_x;
4062 if (y) *y = j->s->img_y;
4063 if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
4064 return 1;
4065}
4067static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
4068{
4069 int result;
4070 stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
4071 if (!j) return stbi__err("outofmem", "Out of memory");
4072 memset(j, 0, sizeof(stbi__jpeg));
4073 j->s = s;
4074 result = stbi__jpeg_info_raw(j, x, y, comp);
4075 STBI_FREE(j);
4076 return result;
4077}
4078#endif
4080// public domain zlib decode v0.2 Sean Barrett 2006-11-18
4081// simple implementation
4082// - all input must be provided in an upfront buffer
4083// - all output is written to a single output buffer (can malloc/realloc)
4084// performance
4085// - fast huffman
4087#ifndef STBI_NO_ZLIB
4089// fast-way is faster to check than jpeg huffman, but slow way is slower
4090#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
4091#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
4092#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
4094// zlib-style huffman encoding
4095// (jpegs packs from left, zlib from right, so can't share code)
4096typedef struct
4097{
4098 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
4099 stbi__uint16 firstcode[16];
4100 int maxcode[17];
4101 stbi__uint16 firstsymbol[16];
4102 stbi_uc size[STBI__ZNSYMS];
4103 stbi__uint16 value[STBI__ZNSYMS];
4104} stbi__zhuffman;
4106stbi_inline static int stbi__bitreverse16(int n)
4107{
4108 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
4109 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
4110 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
4111 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
4112 return n;
4113}
4115stbi_inline static int stbi__bit_reverse(int v, int bits)
4116{
4117 STBI_ASSERT(bits <= 16);
4118 // to bit reverse n bits, reverse 16 and shift
4119 // e.g. 11 bits, bit reverse and shift away 5
4120 return stbi__bitreverse16(v) >> (16-bits);
4121}
4123static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
4124{
4125 int i,k=0;
4126 int code, next_code[16], sizes[17];
4128 // DEFLATE spec for generating codes
4129 memset(sizes, 0, sizeof(sizes));
4130 memset(z->fast, 0, sizeof(z->fast));
4131 for (i=0; i < num; ++i)
4132 ++sizes[sizelist[i]];
4133 sizes[0] = 0;
4134 for (i=1; i < 16; ++i)
4135 if (sizes[i] > (1 << i))
4136 return stbi__err("bad sizes", "Corrupt PNG");
4137 code = 0;
4138 for (i=1; i < 16; ++i) {
4139 next_code[i] = code;
4140 z->firstcode[i] = (stbi__uint16) code;
4141 z->firstsymbol[i] = (stbi__uint16) k;
4142 code = (code + sizes[i]);
4143 if (sizes[i])
4144 if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
4145 z->maxcode[i] = code << (16-i); // preshift for inner loop
4146 code <<= 1;
4147 k += sizes[i];
4148 }
4149 z->maxcode[16] = 0x10000; // sentinel
4150 for (i=0; i < num; ++i) {
4151 int s = sizelist[i];
4152 if (s) {
4153 int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
4154 stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
4155 z->size [c] = (stbi_uc ) s;
4156 z->value[c] = (stbi__uint16) i;
4157 if (s <= STBI__ZFAST_BITS) {
4158 int j = stbi__bit_reverse(next_code[s],s);
4159 while (j < (1 << STBI__ZFAST_BITS)) {
4160 z->fast[j] = fastv;
4161 j += (1 << s);
4162 }
4163 }
4164 ++next_code[s];
4165 }
4166 }
4167 return 1;
4168}
4170// zlib-from-memory implementation for PNG reading
4171// because PNG allows splitting the zlib stream arbitrarily,
4172// and it's annoying structurally to have PNG call ZLIB call PNG,
4173// we require PNG read all the IDATs and combine them into a single
4174// memory buffer
4176typedef struct
4177{
4178 stbi_uc *zbuffer, *zbuffer_end;
4179 int num_bits;
4180 int hit_zeof_once;
4181 stbi__uint32 code_buffer;
4183 char *zout;
4184 char *zout_start;
4185 char *zout_end;
4186 int z_expandable;
4188 stbi__zhuffman z_length, z_distance;
4189} stbi__zbuf;
4191stbi_inline static int stbi__zeof(stbi__zbuf *z)
4192{
4193 return (z->zbuffer >= z->zbuffer_end);
4194}
4196stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
4197{
4198 return stbi__zeof(z) ? 0 : *z->zbuffer++;
4199}
4201static void stbi__fill_bits(stbi__zbuf *z)
4202{
4203 do {
4204 if (z->code_buffer >= (1U << z->num_bits)) {
4205 z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
4206 return;
4207 }
4208 z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
4209 z->num_bits += 8;
4210 } while (z->num_bits <= 24);
4211}
4213stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
4214{
4215 unsigned int k;
4216 if (z->num_bits < n) stbi__fill_bits(z);
4217 k = z->code_buffer & ((1 << n) - 1);
4218 z->code_buffer >>= n;
4219 z->num_bits -= n;
4220 return k;
4221}
4223static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
4224{
4225 int b,s,k;
4226 // not resolved by fast table, so compute it the slow way
4227 // use jpeg approach, which requires MSbits at top
4228 k = stbi__bit_reverse(a->code_buffer, 16);
4229 for (s=STBI__ZFAST_BITS+1; ; ++s)
4230 if (k < z->maxcode[s])
4231 break;
4232 if (s >= 16) return -1; // invalid code!
4233 // code size is s, so:
4234 b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
4235 if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
4236 if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.
4237 a->code_buffer >>= s;
4238 a->num_bits -= s;
4239 return z->value[b];
4240}
4242stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
4243{
4244 int b,s;
4245 if (a->num_bits < 16) {
4246 if (stbi__zeof(a)) {
4247 if (!a->hit_zeof_once) {
4248 // This is the first time we hit eof, insert 16 extra padding btis
4249 // to allow us to keep going; if we actually consume any of them
4250 // though, that is invalid data. This is caught later.
4251 a->hit_zeof_once = 1;
4252 a->num_bits += 16; // add 16 implicit zero bits
4253 } else {
4254 // We already inserted our extra 16 padding bits and are again
4255 // out, this stream is actually prematurely terminated.
4256 return -1;
4257 }
4258 } else {
4259 stbi__fill_bits(a);
4260 }
4261 }
4262 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
4263 if (b) {
4264 s = b >> 9;
4265 a->code_buffer >>= s;
4266 a->num_bits -= s;
4267 return b & 511;
4268 }
4269 return stbi__zhuffman_decode_slowpath(a, z);
4270}
4272static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
4273{
4274 char *q;
4275 unsigned int cur, limit, old_limit;
4276 z->zout = zout;
4277 if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
4278 cur = (unsigned int) (z->zout - z->zout_start);
4279 limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
4280 if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
4281 while (cur + n > limit) {
4282 if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
4283 limit *= 2;
4284 }
4285 q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
4286 STBI_NOTUSED(old_limit);
4287 if (q == NULL) return stbi__err("outofmem", "Out of memory");
4288 z->zout_start = q;
4289 z->zout = q + cur;
4290 z->zout_end = q + limit;
4291 return 1;
4292}
4294static const int stbi__zlength_base[31] = {
4295 3,4,5,6,7,8,9,10,11,13,
4296 15,17,19,23,27,31,35,43,51,59,
4297 67,83,99,115,131,163,195,227,258,0,0 };
4299static const int stbi__zlength_extra[31]=
4300{ 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 };
4302static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
4303257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
4305static const int stbi__zdist_extra[32] =
4306{ 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};
4308static int stbi__parse_huffman_block(stbi__zbuf *a)
4309{
4310 char *zout = a->zout;
4311 for(;;) {
4312 int z = stbi__zhuffman_decode(a, &a->z_length);
4313 if (z < 256) {
4314 if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
4315 if (zout >= a->zout_end) {
4316 if (!stbi__zexpand(a, zout, 1)) return 0;
4317 zout = a->zout;
4318 }
4319 *zout++ = (char) z;
4320 } else {
4321 stbi_uc *p;
4322 int len,dist;
4323 if (z == 256) {
4324 a->zout = zout;
4325 if (a->hit_zeof_once && a->num_bits < 16) {
4326 // The first time we hit zeof, we inserted 16 extra zero bits into our bit
4327 // buffer so the decoder can just do its speculative decoding. But if we
4328 // actually consumed any of those bits (which is the case when num_bits < 16),
4329 // the stream actually read past the end so it is malformed.
4330 return stbi__err("unexpected end","Corrupt PNG");
4331 }
4332 return 1;
4333 }
4334 if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
4335 z -= 257;
4336 len = stbi__zlength_base[z];
4337 if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
4338 z = stbi__zhuffman_decode(a, &a->z_distance);
4339 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
4340 dist = stbi__zdist_base[z];
4341 if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
4342 if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
4343 if (len > a->zout_end - zout) {
4344 if (!stbi__zexpand(a, zout, len)) return 0;
4345 zout = a->zout;
4346 }
4347 p = (stbi_uc *) (zout - dist);
4348 if (dist == 1) { // run of one byte; common in images.
4349 stbi_uc v = *p;
4350 if (len) { do *zout++ = v; while (--len); }
4351 } else {
4352 if (len) { do *zout++ = *p++; while (--len); }
4353 }
4354 }
4355 }
4356}
4358static int stbi__compute_huffman_codes(stbi__zbuf *a)
4359{
4360 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 };
4361 stbi__zhuffman z_codelength;
4362 stbi_uc lencodes[286+32+137];//padding for maximum single op
4363 stbi_uc codelength_sizes[19];
4364 int i,n;
4366 int hlit = stbi__zreceive(a,5) + 257;
4367 int hdist = stbi__zreceive(a,5) + 1;
4368 int hclen = stbi__zreceive(a,4) + 4;
4369 int ntot = hlit + hdist;
4371 memset(codelength_sizes, 0, sizeof(codelength_sizes));
4372 for (i=0; i < hclen; ++i) {
4373 int s = stbi__zreceive(a,3);
4374 codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
4375 }
4376 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
4378 n = 0;
4379 while (n < ntot) {
4380 int c = stbi__zhuffman_decode(a, &z_codelength);
4381 if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
4382 if (c < 16)
4383 lencodes[n++] = (stbi_uc) c;
4384 else {
4385 stbi_uc fill = 0;
4386 if (c == 16) {
4387 c = stbi__zreceive(a,2)+3;
4388 if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
4389 fill = lencodes[n-1];
4390 } else if (c == 17) {
4391 c = stbi__zreceive(a,3)+3;
4392 } else if (c == 18) {
4393 c = stbi__zreceive(a,7)+11;
4394 } else {
4395 return stbi__err("bad codelengths", "Corrupt PNG");
4396 }
4397 if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
4398 memset(lencodes+n, fill, c);
4399 n += c;
4400 }
4401 }
4402 if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
4403 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
4404 if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
4405 return 1;
4406}
4408static int stbi__parse_uncompressed_block(stbi__zbuf *a)
4409{
4410 stbi_uc header[4];
4411 int len,nlen,k;
4412 if (a->num_bits & 7)
4413 stbi__zreceive(a, a->num_bits & 7); // discard
4414 // drain the bit-packed data into header
4415 k = 0;
4416 while (a->num_bits > 0) {
4417 header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
4418 a->code_buffer >>= 8;
4419 a->num_bits -= 8;
4420 }
4421 if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
4422 // now fill header the normal way
4423 while (k < 4)
4424 header[k++] = stbi__zget8(a);
4425 len = header[1] * 256 + header[0];
4426 nlen = header[3] * 256 + header[2];
4427 if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
4428 if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
4429 if (a->zout + len > a->zout_end)
4430 if (!stbi__zexpand(a, a->zout, len)) return 0;
4431 memcpy(a->zout, a->zbuffer, len);
4432 a->zbuffer += len;
4433 a->zout += len;
4434 return 1;
4435}
4437static int stbi__parse_zlib_header(stbi__zbuf *a)
4438{
4439 int cmf = stbi__zget8(a);
4440 int cm = cmf & 15;
4441 /* int cinfo = cmf >> 4; */
4442 int flg = stbi__zget8(a);
4443 if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
4444 if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
4445 if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
4446 if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
4447 // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
4448 return 1;
4449}
4451static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
4452{
4453 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,
4454 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,
4455 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,
4456 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,
4457 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,
4458 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,
4459 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,
4460 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,
4461 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
4462};
4463static const stbi_uc stbi__zdefault_distance[32] =
4464{
4465 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
4466};
4467/*
4468Init algorithm:
4469{
4470 int i; // use <= to match clearly with spec
4471 for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;
4472 for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;
4473 for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;
4474 for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;
4476 for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;
4477}
4478*/
4480static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
4481{
4482 int final, type;
4483 if (parse_header)
4484 if (!stbi__parse_zlib_header(a)) return 0;
4485 a->num_bits = 0;
4486 a->code_buffer = 0;
4487 a->hit_zeof_once = 0;
4488 do {
4489 final = stbi__zreceive(a,1);
4490 type = stbi__zreceive(a,2);
4491 if (type == 0) {
4492 if (!stbi__parse_uncompressed_block(a)) return 0;
4493 } else if (type == 3) {
4494 return 0;
4495 } else {
4496 if (type == 1) {
4497 // use fixed code lengths
4498 if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0;
4499 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;
4500 } else {
4501 if (!stbi__compute_huffman_codes(a)) return 0;
4502 }
4503 if (!stbi__parse_huffman_block(a)) return 0;
4504 }
4505 } while (!final);
4506 return 1;
4507}
4509static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
4510{
4511 a->zout_start = obuf;
4512 a->zout = obuf;
4513 a->zout_end = obuf + olen;
4514 a->z_expandable = exp;
4516 return stbi__parse_zlib(a, parse_header);
4517}
4519STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
4520{
4521 stbi__zbuf a;
4522 char *p = (char *) stbi__malloc(initial_size);
4523 if (p == NULL) return NULL;
4524 a.zbuffer = (stbi_uc *) buffer;
4525 a.zbuffer_end = (stbi_uc *) buffer + len;
4526 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
4527 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4528 return a.zout_start;
4529 } else {
4530 STBI_FREE(a.zout_start);
4531 return NULL;
4532 }
4533}
4535STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
4536{
4537 return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
4538}
4540STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
4541{
4542 stbi__zbuf a;
4543 char *p = (char *) stbi__malloc(initial_size);
4544 if (p == NULL) return NULL;
4545 a.zbuffer = (stbi_uc *) buffer;
4546 a.zbuffer_end = (stbi_uc *) buffer + len;
4547 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
4548 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4549 return a.zout_start;
4550 } else {
4551 STBI_FREE(a.zout_start);
4552 return NULL;
4553 }
4554}
4556STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
4557{
4558 stbi__zbuf a;
4559 a.zbuffer = (stbi_uc *) ibuffer;
4560 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
4561 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
4562 return (int) (a.zout - a.zout_start);
4563 else
4564 return -1;
4565}
4567STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
4568{
4569 stbi__zbuf a;
4570 char *p = (char *) stbi__malloc(16384);
4571 if (p == NULL) return NULL;
4572 a.zbuffer = (stbi_uc *) buffer;
4573 a.zbuffer_end = (stbi_uc *) buffer+len;
4574 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
4575 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4576 return a.zout_start;
4577 } else {
4578 STBI_FREE(a.zout_start);
4579 return NULL;
4580 }
4581}
4583STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
4584{
4585 stbi__zbuf a;
4586 a.zbuffer = (stbi_uc *) ibuffer;
4587 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
4588 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
4589 return (int) (a.zout - a.zout_start);
4590 else
4591 return -1;
4592}
4593#endif
4595// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
4596// simple implementation
4597// - only 8-bit samples
4598// - no CRC checking
4599// - allocates lots of intermediate memory
4600// - avoids problem of streaming data between subsystems
4601// - avoids explicit window management
4602// performance
4603// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
4605#ifndef STBI_NO_PNG
4606typedef struct
4607{
4608 stbi__uint32 length;
4609 stbi__uint32 type;
4610} stbi__pngchunk;
4612static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
4613{
4614 stbi__pngchunk c;
4615 c.length = stbi__get32be(s);
4616 c.type = stbi__get32be(s);
4617 return c;
4618}
4620static int stbi__check_png_header(stbi__context *s)
4621{
4622 static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
4623 int i;
4624 for (i=0; i < 8; ++i)
4625 if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
4626 return 1;
4627}
4629typedef struct
4630{
4631 stbi__context *s;
4632 stbi_uc *idata, *expanded, *out;
4633 int depth;
4634} stbi__png;
4637enum {
4638 STBI__F_none=0,
4639 STBI__F_sub=1,
4640 STBI__F_up=2,
4641 STBI__F_avg=3,
4642 STBI__F_paeth=4,
4643 // synthetic filter used for first scanline to avoid needing a dummy row of 0s
4644 STBI__F_avg_first
4645};
4647static stbi_uc first_row_filter[5] =
4648{
4649 STBI__F_none,
4650 STBI__F_sub,
4651 STBI__F_none,
4652 STBI__F_avg_first,
4653 STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
4654};
4656static int stbi__paeth(int a, int b, int c)
4657{
4658 // This formulation looks very different from the reference in the PNG spec, but is
4659 // actually equivalent and has favorable data dependencies and admits straightforward
4660 // generation of branch-free code, which helps performance significantly.
4661 int thresh = c*3 - (a + b);
4662 int lo = a < b ? a : b;
4663 int hi = a < b ? b : a;
4664 int t0 = (hi <= thresh) ? lo : c;
4665 int t1 = (thresh <= lo) ? hi : t0;
4666 return t1;
4667}
4669static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
4671// adds an extra all-255 alpha channel
4672// dest == src is legal
4673// img_n must be 1 or 3
4674static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
4675{
4676 int i;
4677 // must process data backwards since we allow dest==src
4678 if (img_n == 1) {
4679 for (i=x-1; i >= 0; --i) {
4680 dest[i*2+1] = 255;
4681 dest[i*2+0] = src[i];
4682 }
4683 } else {
4684 STBI_ASSERT(img_n == 3);
4685 for (i=x-1; i >= 0; --i) {
4686 dest[i*4+3] = 255;
4687 dest[i*4+2] = src[i*3+2];
4688 dest[i*4+1] = src[i*3+1];
4689 dest[i*4+0] = src[i*3+0];
4690 }
4691 }
4692}
4694// create the png data from post-deflated data
4695static 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)
4696{
4697 int bytes = (depth == 16 ? 2 : 1);
4698 stbi__context *s = a->s;
4699 stbi__uint32 i,j,stride = x*out_n*bytes;
4700 stbi__uint32 img_len, img_width_bytes;
4701 stbi_uc *filter_buf;
4702 int all_ok = 1;
4703 int k;
4704 int img_n = s->img_n; // copy it into a local for later
4706 int output_bytes = out_n*bytes;
4707 int filter_bytes = img_n*bytes;
4708 int width = x;
4710 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
4711 a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
4712 if (!a->out) return stbi__err("outofmem", "Out of memory");
4714 // note: error exits here don't need to clean up a->out individually,
4715 // stbi__do_png always does on error.
4716 if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
4717 img_width_bytes = (((img_n * x * depth) + 7) >> 3);
4718 if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");
4719 img_len = (img_width_bytes + 1) * y;
4721 // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
4722 // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
4723 // so just check for raw_len < img_len always.
4724 if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
4726 // Allocate two scan lines worth of filter workspace buffer.
4727 filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);
4728 if (!filter_buf) return stbi__err("outofmem", "Out of memory");
4730 // Filtering for low-bit-depth images
4731 if (depth < 8) {
4732 filter_bytes = 1;
4733 width = img_width_bytes;
4734 }
4736 for (j=0; j < y; ++j) {
4737 // cur/prior filter buffers alternate
4738 stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;
4739 stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;
4740 stbi_uc *dest = a->out + stride*j;
4741 int nk = width * filter_bytes;
4742 int filter = *raw++;
4744 // check filter type
4745 if (filter > 4) {
4746 all_ok = stbi__err("invalid filter","Corrupt PNG");
4747 break;
4748 }
4750 // if first row, use special filter that doesn't sample previous row
4751 if (j == 0) filter = first_row_filter[filter];
4753 // perform actual filtering
4754 switch (filter) {
4755 case STBI__F_none:
4756 memcpy(cur, raw, nk);
4757 break;
4758 case STBI__F_sub:
4759 memcpy(cur, raw, filter_bytes);
4760 for (k = filter_bytes; k < nk; ++k)
4761 cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);
4762 break;
4763 case STBI__F_up:
4764 for (k = 0; k < nk; ++k)
4765 cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
4766 break;
4767 case STBI__F_avg:
4768 for (k = 0; k < filter_bytes; ++k)
4769 cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
4770 for (k = filter_bytes; k < nk; ++k)
4771 cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));
4772 break;
4773 case STBI__F_paeth:
4774 for (k = 0; k < filter_bytes; ++k)
4775 cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)
4776 for (k = filter_bytes; k < nk; ++k)
4777 cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));
4778 break;
4779 case STBI__F_avg_first:
4780 memcpy(cur, raw, filter_bytes);
4781 for (k = filter_bytes; k < nk; ++k)
4782 cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));
4783 break;
4784 }
4786 raw += nk;
4788 // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
4789 if (depth < 8) {
4790 stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
4791 stbi_uc *in = cur;
4792 stbi_uc *out = dest;
4793 stbi_uc inb = 0;
4794 stbi__uint32 nsmp = x*img_n;
4796 // expand bits to bytes first
4797 if (depth == 4) {
4798 for (i=0; i < nsmp; ++i) {
4799 if ((i & 1) == 0) inb = *in++;
4800 *out++ = scale * (inb >> 4);
4801 inb <<= 4;
4802 }
4803 } else if (depth == 2) {
4804 for (i=0; i < nsmp; ++i) {
4805 if ((i & 3) == 0) inb = *in++;
4806 *out++ = scale * (inb >> 6);
4807 inb <<= 2;
4808 }
4809 } else {
4810 STBI_ASSERT(depth == 1);
4811 for (i=0; i < nsmp; ++i) {
4812 if ((i & 7) == 0) inb = *in++;
4813 *out++ = scale * (inb >> 7);
4814 inb <<= 1;
4815 }
4816 }
4818 // insert alpha=255 values if desired
4819 if (img_n != out_n)
4820 stbi__create_png_alpha_expand8(dest, dest, x, img_n);
4821 } else if (depth == 8) {
4822 if (img_n == out_n)
4823 memcpy(dest, cur, x*img_n);
4824 else
4825 stbi__create_png_alpha_expand8(dest, cur, x, img_n);
4826 } else if (depth == 16) {
4827 // convert the image data from big-endian to platform-native
4828 stbi__uint16 *dest16 = (stbi__uint16*)dest;
4829 stbi__uint32 nsmp = x*img_n;
4831 if (img_n == out_n) {
4832 for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)
4833 *dest16 = (cur[0] << 8) | cur[1];
4834 } else {
4835 STBI_ASSERT(img_n+1 == out_n);
4836 if (img_n == 1) {
4837 for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {
4838 dest16[0] = (cur[0] << 8) | cur[1];
4839 dest16[1] = 0xffff;
4840 }
4841 } else {
4842 STBI_ASSERT(img_n == 3);
4843 for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {
4844 dest16[0] = (cur[0] << 8) | cur[1];
4845 dest16[1] = (cur[2] << 8) | cur[3];
4846 dest16[2] = (cur[4] << 8) | cur[5];
4847 dest16[3] = 0xffff;
4848 }
4849 }
4850 }
4851 }
4852 }
4854 STBI_FREE(filter_buf);
4855 if (!all_ok) return 0;
4857 return 1;
4858}
4860static 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)
4861{
4862 int bytes = (depth == 16 ? 2 : 1);
4863 int out_bytes = out_n * bytes;
4864 stbi_uc *final;
4865 int p;
4866 if (!interlaced)
4867 return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
4869 // de-interlacing
4870 final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
4871 if (!final) return stbi__err("outofmem", "Out of memory");
4872 for (p=0; p < 7; ++p) {
4873 int xorig[] = { 0,4,0,2,0,1,0 };
4874 int yorig[] = { 0,0,4,0,2,0,1 };
4875 int xspc[] = { 8,8,4,4,2,2,1 };
4876 int yspc[] = { 8,8,8,4,4,2,2 };
4877 int i,j,x,y;
4878 // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
4879 x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
4880 y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
4881 if (x && y) {
4882 stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
4883 if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
4884 STBI_FREE(final);
4885 return 0;
4886 }
4887 for (j=0; j < y; ++j) {
4888 for (i=0; i < x; ++i) {
4889 int out_y = j*yspc[p]+yorig[p];
4890 int out_x = i*xspc[p]+xorig[p];
4891 memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
4892 a->out + (j*x+i)*out_bytes, out_bytes);
4893 }
4894 }
4895 STBI_FREE(a->out);
4896 image_data += img_len;
4897 image_data_len -= img_len;
4898 }
4899 }
4900 a->out = final;
4902 return 1;
4903}
4905static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
4906{
4907 stbi__context *s = z->s;
4908 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4909 stbi_uc *p = z->out;
4911 // compute color-based transparency, assuming we've
4912 // already got 255 as the alpha value in the output
4913 STBI_ASSERT(out_n == 2 || out_n == 4);
4915 if (out_n == 2) {
4916 for (i=0; i < pixel_count; ++i) {
4917 p[1] = (p[0] == tc[0] ? 0 : 255);
4918 p += 2;
4919 }
4920 } else {
4921 for (i=0; i < pixel_count; ++i) {
4922 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4923 p[3] = 0;
4924 p += 4;
4925 }
4926 }
4927 return 1;
4928}
4930static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
4931{
4932 stbi__context *s = z->s;
4933 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4934 stbi__uint16 *p = (stbi__uint16*) z->out;
4936 // compute color-based transparency, assuming we've
4937 // already got 65535 as the alpha value in the output
4938 STBI_ASSERT(out_n == 2 || out_n == 4);
4940 if (out_n == 2) {
4941 for (i = 0; i < pixel_count; ++i) {
4942 p[1] = (p[0] == tc[0] ? 0 : 65535);
4943 p += 2;
4944 }
4945 } else {
4946 for (i = 0; i < pixel_count; ++i) {
4947 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4948 p[3] = 0;
4949 p += 4;
4950 }
4951 }
4952 return 1;
4953}
4955static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
4956{
4957 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
4958 stbi_uc *p, *temp_out, *orig = a->out;
4960 p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
4961 if (p == NULL) return stbi__err("outofmem", "Out of memory");
4963 // between here and free(out) below, exitting would leak
4964 temp_out = p;
4966 if (pal_img_n == 3) {
4967 for (i=0; i < pixel_count; ++i) {
4968 int n = orig[i]*4;
4969 p[0] = palette[n ];
4970 p[1] = palette[n+1];
4971 p[2] = palette[n+2];
4972 p += 3;
4973 }
4974 } else {
4975 for (i=0; i < pixel_count; ++i) {
4976 int n = orig[i]*4;
4977 p[0] = palette[n ];
4978 p[1] = palette[n+1];
4979 p[2] = palette[n+2];
4980 p[3] = palette[n+3];
4981 p += 4;
4982 }
4983 }
4984 STBI_FREE(a->out);
4985 a->out = temp_out;
4987 STBI_NOTUSED(len);
4989 return 1;
4990}
4992static int stbi__unpremultiply_on_load_global = 0;
4993static int stbi__de_iphone_flag_global = 0;
4995STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
4996{
4997 stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
4998}
5000STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
5001{
5002 stbi__de_iphone_flag_global = flag_true_if_should_convert;
5003}
5005#ifndef STBI_THREAD_LOCAL
5006#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global
5007#define stbi__de_iphone_flag stbi__de_iphone_flag_global
5008#else
5009static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
5010static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
5012STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
5013{
5014 stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
5015 stbi__unpremultiply_on_load_set = 1;
5016}
5018STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
5019{
5020 stbi__de_iphone_flag_local = flag_true_if_should_convert;
5021 stbi__de_iphone_flag_set = 1;
5022}
5024#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \
5025 ? stbi__unpremultiply_on_load_local \
5026 : stbi__unpremultiply_on_load_global)
5027#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \
5028 ? stbi__de_iphone_flag_local \
5029 : stbi__de_iphone_flag_global)
5030#endif // STBI_THREAD_LOCAL
5032static void stbi__de_iphone(stbi__png *z)
5033{
5034 stbi__context *s = z->s;
5035 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
5036 stbi_uc *p = z->out;
5038 if (s->img_out_n == 3) { // convert bgr to rgb
5039 for (i=0; i < pixel_count; ++i) {
5040 stbi_uc t = p[0];
5041 p[0] = p[2];
5042 p[2] = t;
5043 p += 3;
5044 }
5045 } else {
5046 STBI_ASSERT(s->img_out_n == 4);
5047 if (stbi__unpremultiply_on_load) {
5048 // convert bgr to rgb and unpremultiply
5049 for (i=0; i < pixel_count; ++i) {
5050 stbi_uc a = p[3];
5051 stbi_uc t = p[0];
5052 if (a) {
5053 stbi_uc half = a / 2;
5054 p[0] = (p[2] * 255 + half) / a;
5055 p[1] = (p[1] * 255 + half) / a;
5056 p[2] = ( t * 255 + half) / a;
5057 } else {
5058 p[0] = p[2];
5059 p[2] = t;
5060 }
5061 p += 4;
5062 }
5063 } else {
5064 // convert bgr to rgb
5065 for (i=0; i < pixel_count; ++i) {
5066 stbi_uc t = p[0];
5067 p[0] = p[2];
5068 p[2] = t;
5069 p += 4;
5070 }
5071 }
5072 }
5073}
5075#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
5077static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
5078{
5079 stbi_uc palette[1024], pal_img_n=0;
5080 stbi_uc has_trans=0, tc[3]={0};
5081 stbi__uint16 tc16[3];
5082 stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
5083 int first=1,k,interlace=0, color=0, is_iphone=0;
5084 stbi__context *s = z->s;
5086 z->expanded = NULL;
5087 z->idata = NULL;
5088 z->out = NULL;
5090 if (!stbi__check_png_header(s)) return 0;
5092 if (scan == STBI__SCAN_type) return 1;
5094 for (;;) {
5095 stbi__pngchunk c = stbi__get_chunk_header(s);
5096 switch (c.type) {
5097 case STBI__PNG_TYPE('C','g','B','I'):
5098 is_iphone = 1;
5099 stbi__skip(s, c.length);
5100 break;
5101 case STBI__PNG_TYPE('I','H','D','R'): {
5102 int comp,filter;
5103 if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
5104 first = 0;
5105 if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
5106 s->img_x = stbi__get32be(s);
5107 s->img_y = stbi__get32be(s);
5108 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
5109 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
5110 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");
5111 color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");
5112 if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG");
5113 if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
5114 comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");
5115 filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");
5116 interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
5117 if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
5118 if (!pal_img_n) {
5119 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
5120 if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
5121 } else {
5122 // if paletted, then pal_n is our final components, and
5123 // img_n is # components to decompress/filter.
5124 s->img_n = 1;
5125 if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
5126 }
5127 // even with SCAN_header, have to scan to see if we have a tRNS
5128 break;
5129 }
5131 case STBI__PNG_TYPE('P','L','T','E'): {
5132 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5133 if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
5134 pal_len = c.length / 3;
5135 if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
5136 for (i=0; i < pal_len; ++i) {
5137 palette[i*4+0] = stbi__get8(s);
5138 palette[i*4+1] = stbi__get8(s);
5139 palette[i*4+2] = stbi__get8(s);
5140 palette[i*4+3] = 255;
5141 }
5142 break;
5143 }
5145 case STBI__PNG_TYPE('t','R','N','S'): {
5146 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5147 if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
5148 if (pal_img_n) {
5149 if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
5150 if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
5151 if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
5152 pal_img_n = 4;
5153 for (i=0; i < c.length; ++i)
5154 palette[i*4+3] = stbi__get8(s);
5155 } else {
5156 if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
5157 if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
5158 has_trans = 1;
5159 // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
5160 if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
5161 if (z->depth == 16) {
5162 for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
5163 tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
5164 } else {
5165 for (k = 0; k < s->img_n && k < 3; ++k)
5166 tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
5167 }
5168 }
5169 break;
5170 }
5172 case STBI__PNG_TYPE('I','D','A','T'): {
5173 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5174 if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
5175 if (scan == STBI__SCAN_header) {
5176 // header scan definitely stops at first IDAT
5177 if (pal_img_n)
5178 s->img_n = pal_img_n;
5179 return 1;
5180 }
5181 if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
5182 if ((int)(ioff + c.length) < (int)ioff) return 0;
5183 if (ioff + c.length > idata_limit) {
5184 stbi__uint32 idata_limit_old = idata_limit;
5185 stbi_uc *p;
5186 if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
5187 while (ioff + c.length > idata_limit)
5188 idata_limit *= 2;
5189 STBI_NOTUSED(idata_limit_old);
5190 p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
5191 z->idata = p;
5192 }
5193 if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
5194 ioff += c.length;
5195 break;
5196 }
5198 case STBI__PNG_TYPE('I','E','N','D'): {
5199 stbi__uint32 raw_len, bpl;
5200 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5201 if (scan != STBI__SCAN_load) return 1;
5202 if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
5203 // initial guess for decoded data size to avoid unnecessary reallocs
5204 bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
5205 raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
5206 z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
5207 if (z->expanded == NULL) return 0; // zlib should set error
5208 STBI_FREE(z->idata); z->idata = NULL;
5209 if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
5210 s->img_out_n = s->img_n+1;
5211 else
5212 s->img_out_n = s->img_n;
5213 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
5214 if (has_trans) {
5215 if (z->depth == 16) {
5216 if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
5217 } else {
5218 if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
5219 }
5220 }
5221 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
5222 stbi__de_iphone(z);
5223 if (pal_img_n) {
5224 // pal_img_n == 3 or 4
5225 s->img_n = pal_img_n; // record the actual colors we had
5226 s->img_out_n = pal_img_n;
5227 if (req_comp >= 3) s->img_out_n = req_comp;
5228 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
5229 return 0;
5230 } else if (has_trans) {
5231 // non-paletted image with tRNS -> source image has (constant) alpha
5232 ++s->img_n;
5233 }
5234 STBI_FREE(z->expanded); z->expanded = NULL;
5235 // end of PNG chunk, read and skip CRC
5236 stbi__get32be(s);
5237 return 1;
5238 }
5240 default:
5241 // if critical, fail
5242 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5243 if ((c.type & (1 << 29)) == 0) {
5244 #ifndef STBI_NO_FAILURE_STRINGS
5245 // not threadsafe
5246 static char invalid_chunk[] = "XXXX PNG chunk not known";
5247 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
5248 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
5249 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
5250 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
5251 #endif
5252 return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
5253 }
5254 stbi__skip(s, c.length);
5255 break;
5256 }
5257 // end of PNG chunk, read and skip CRC
5258 stbi__get32be(s);
5259 }
5260}
5262static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
5263{
5264 void *result=NULL;
5265 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
5266 if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
5267 if (p->depth <= 8)
5268 ri->bits_per_channel = 8;
5269 else if (p->depth == 16)
5270 ri->bits_per_channel = 16;
5271 else
5272 return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
5273 result = p->out;
5274 p->out = NULL;
5275 if (req_comp && req_comp != p->s->img_out_n) {
5276 if (ri->bits_per_channel == 8)
5277 result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5278 else
5279 result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5280 p->s->img_out_n = req_comp;
5281 if (result == NULL) return result;
5282 }
5283 *x = p->s->img_x;
5284 *y = p->s->img_y;
5285 if (n) *n = p->s->img_n;
5286 }
5287 STBI_FREE(p->out); p->out = NULL;
5288 STBI_FREE(p->expanded); p->expanded = NULL;
5289 STBI_FREE(p->idata); p->idata = NULL;
5291 return result;
5292}
5294static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5295{
5296 stbi__png p;
5297 p.s = s;
5298 return stbi__do_png(&p, x,y,comp,req_comp, ri);
5299}
5301static int stbi__png_test(stbi__context *s)
5302{
5303 int r;
5304 r = stbi__check_png_header(s);
5305 stbi__rewind(s);
5306 return r;
5307}
5309static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
5310{
5311 if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
5312 stbi__rewind( p->s );
5313 return 0;
5314 }
5315 if (x) *x = p->s->img_x;
5316 if (y) *y = p->s->img_y;
5317 if (comp) *comp = p->s->img_n;
5318 return 1;
5319}
5321static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
5322{
5323 stbi__png p;
5324 p.s = s;
5325 return stbi__png_info_raw(&p, x, y, comp);
5326}
5328static int stbi__png_is16(stbi__context *s)
5329{
5330 stbi__png p;
5331 p.s = s;
5332 if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
5333 return 0;
5334 if (p.depth != 16) {
5335 stbi__rewind(p.s);
5336 return 0;
5337 }
5338 return 1;
5339}
5340#endif
5342// Microsoft/Windows BMP image
5344#ifndef STBI_NO_BMP
5345static int stbi__bmp_test_raw(stbi__context *s)
5346{
5347 int r;
5348 int sz;
5349 if (stbi__get8(s) != 'B') return 0;
5350 if (stbi__get8(s) != 'M') return 0;
5351 stbi__get32le(s); // discard filesize
5352 stbi__get16le(s); // discard reserved
5353 stbi__get16le(s); // discard reserved
5354 stbi__get32le(s); // discard data offset
5355 sz = stbi__get32le(s);
5356 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
5357 return r;
5358}
5360static int stbi__bmp_test(stbi__context *s)
5361{
5362 int r = stbi__bmp_test_raw(s);
5363 stbi__rewind(s);
5364 return r;
5365}
5368// returns 0..31 for the highest set bit
5369static int stbi__high_bit(unsigned int z)
5370{
5371 int n=0;
5372 if (z == 0) return -1;
5373 if (z >= 0x10000) { n += 16; z >>= 16; }
5374 if (z >= 0x00100) { n += 8; z >>= 8; }
5375 if (z >= 0x00010) { n += 4; z >>= 4; }
5376 if (z >= 0x00004) { n += 2; z >>= 2; }
5377 if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
5378 return n;
5379}
5381static int stbi__bitcount(unsigned int a)
5382{
5383 a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
5384 a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
5385 a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
5386 a = (a + (a >> 8)); // max 16 per 8 bits
5387 a = (a + (a >> 16)); // max 32 per 8 bits
5388 return a & 0xff;
5389}
5391// extract an arbitrarily-aligned N-bit value (N=bits)
5392// from v, and then make it 8-bits long and fractionally
5393// extend it to full full range.
5394static int stbi__shiftsigned(unsigned int v, int shift, int bits)
5395{
5396 static unsigned int mul_table[9] = {
5397 0,
5398 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
5399 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
5400 };
5401 static unsigned int shift_table[9] = {
5402 0, 0,0,1,0,2,4,6,0,
5403 };
5404 if (shift < 0)
5405 v <<= -shift;
5406 else
5407 v >>= shift;
5408 STBI_ASSERT(v < 256);
5409 v >>= (8-bits);
5410 STBI_ASSERT(bits >= 0 && bits <= 8);
5411 return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
5412}
5414typedef struct
5415{
5416 int bpp, offset, hsz;
5417 unsigned int mr,mg,mb,ma, all_a;
5418 int extra_read;
5419} stbi__bmp_data;
5421static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
5422{
5423 // BI_BITFIELDS specifies masks explicitly, don't override
5424 if (compress == 3)
5425 return 1;
5427 if (compress == 0) {
5428 if (info->bpp == 16) {
5429 info->mr = 31u << 10;
5430 info->mg = 31u << 5;
5431 info->mb = 31u << 0;
5432 } else if (info->bpp == 32) {
5433 info->mr = 0xffu << 16;
5434 info->mg = 0xffu << 8;
5435 info->mb = 0xffu << 0;
5436 info->ma = 0xffu << 24;
5437 info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
5438 } else {
5439 // otherwise, use defaults, which is all-0
5440 info->mr = info->mg = info->mb = info->ma = 0;
5441 }
5442 return 1;
5443 }
5444 return 0; // error
5445}
5447static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
5448{
5449 int hsz;
5450 if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
5451 stbi__get32le(s); // discard filesize
5452 stbi__get16le(s); // discard reserved
5453 stbi__get16le(s); // discard reserved
5454 info->offset = stbi__get32le(s);
5455 info->hsz = hsz = stbi__get32le(s);
5456 info->mr = info->mg = info->mb = info->ma = 0;
5457 info->extra_read = 14;
5459 if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
5461 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
5462 if (hsz == 12) {
5463 s->img_x = stbi__get16le(s);
5464 s->img_y = stbi__get16le(s);
5465 } else {
5466 s->img_x = stbi__get32le(s);
5467 s->img_y = stbi__get32le(s);
5468 }
5469 if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
5470 info->bpp = stbi__get16le(s);
5471 if (hsz != 12) {
5472 int compress = stbi__get32le(s);
5473 if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
5474 if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
5475 if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
5476 stbi__get32le(s); // discard sizeof
5477 stbi__get32le(s); // discard hres
5478 stbi__get32le(s); // discard vres
5479 stbi__get32le(s); // discard colorsused
5480 stbi__get32le(s); // discard max important
5481 if (hsz == 40 || hsz == 56) {
5482 if (hsz == 56) {
5483 stbi__get32le(s);
5484 stbi__get32le(s);
5485 stbi__get32le(s);
5486 stbi__get32le(s);
5487 }
5488 if (info->bpp == 16 || info->bpp == 32) {
5489 if (compress == 0) {
5490 stbi__bmp_set_mask_defaults(info, compress);
5491 } else if (compress == 3) {
5492 info->mr = stbi__get32le(s);
5493 info->mg = stbi__get32le(s);
5494 info->mb = stbi__get32le(s);
5495 info->extra_read += 12;
5496 // not documented, but generated by photoshop and handled by mspaint
5497 if (info->mr == info->mg && info->mg == info->mb) {
5498 // ?!?!?
5499 return stbi__errpuc("bad BMP", "bad BMP");
5500 }
5501 } else
5502 return stbi__errpuc("bad BMP", "bad BMP");
5503 }
5504 } else {
5505 // V4/V5 header
5506 int i;
5507 if (hsz != 108 && hsz != 124)
5508 return stbi__errpuc("bad BMP", "bad BMP");
5509 info->mr = stbi__get32le(s);
5510 info->mg = stbi__get32le(s);
5511 info->mb = stbi__get32le(s);
5512 info->ma = stbi__get32le(s);
5513 if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
5514 stbi__bmp_set_mask_defaults(info, compress);
5515 stbi__get32le(s); // discard color space
5516 for (i=0; i < 12; ++i)
5517 stbi__get32le(s); // discard color space parameters
5518 if (hsz == 124) {
5519 stbi__get32le(s); // discard rendering intent
5520 stbi__get32le(s); // discard offset of profile data
5521 stbi__get32le(s); // discard size of profile data
5522 stbi__get32le(s); // discard reserved
5523 }
5524 }
5525 }
5526 return (void *) 1;
5527}
5530static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5531{
5532 stbi_uc *out;
5533 unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
5534 stbi_uc pal[256][4];
5535 int psize=0,i,j,width;
5536 int flip_vertically, pad, target;
5537 stbi__bmp_data info;
5538 STBI_NOTUSED(ri);
5540 info.all_a = 255;
5541 if (stbi__bmp_parse_header(s, &info) == NULL)
5542 return NULL; // error code already set
5544 flip_vertically = ((int) s->img_y) > 0;
5545 s->img_y = abs((int) s->img_y);
5547 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5548 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5550 mr = info.mr;
5551 mg = info.mg;
5552 mb = info.mb;
5553 ma = info.ma;
5554 all_a = info.all_a;
5556 if (info.hsz == 12) {
5557 if (info.bpp < 24)
5558 psize = (info.offset - info.extra_read - 24) / 3;
5559 } else {
5560 if (info.bpp < 16)
5561 psize = (info.offset - info.extra_read - info.hsz) >> 2;
5562 }
5563 if (psize == 0) {
5564 // accept some number of extra bytes after the header, but if the offset points either to before
5565 // the header ends or implies a large amount of extra data, reject the file as malformed
5566 int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
5567 int header_limit = 1024; // max we actually read is below 256 bytes currently.
5568 int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
5569 if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
5570 return stbi__errpuc("bad header", "Corrupt BMP");
5571 }
5572 // we established that bytes_read_so_far is positive and sensible.
5573 // the first half of this test rejects offsets that are either too small positives, or
5574 // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
5575 // ensures the number computed in the second half of the test can't overflow.
5576 if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
5577 return stbi__errpuc("bad offset", "Corrupt BMP");
5578 } else {
5579 stbi__skip(s, info.offset - bytes_read_so_far);
5580 }
5581 }
5583 if (info.bpp == 24 && ma == 0xff000000)
5584 s->img_n = 3;
5585 else
5586 s->img_n = ma ? 4 : 3;
5587 if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
5588 target = req_comp;
5589 else
5590 target = s->img_n; // if they want monochrome, we'll post-convert
5592 // sanity-check size
5593 if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
5594 return stbi__errpuc("too large", "Corrupt BMP");
5596 out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
5597 if (!out) return stbi__errpuc("outofmem", "Out of memory");
5598 if (info.bpp < 16) {
5599 int z=0;
5600 if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
5601 for (i=0; i < psize; ++i) {
5602 pal[i][2] = stbi__get8(s);
5603 pal[i][1] = stbi__get8(s);
5604 pal[i][0] = stbi__get8(s);
5605 if (info.hsz != 12) stbi__get8(s);
5606 pal[i][3] = 255;
5607 }
5608 stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
5609 if (info.bpp == 1) width = (s->img_x + 7) >> 3;
5610 else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
5611 else if (info.bpp == 8) width = s->img_x;
5612 else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
5613 pad = (-width)&3;
5614 if (info.bpp == 1) {
5615 for (j=0; j < (int) s->img_y; ++j) {
5616 int bit_offset = 7, v = stbi__get8(s);
5617 for (i=0; i < (int) s->img_x; ++i) {
5618 int color = (v>>bit_offset)&0x1;
5619 out[z++] = pal[color][0];
5620 out[z++] = pal[color][1];
5621 out[z++] = pal[color][2];
5622 if (target == 4) out[z++] = 255;
5623 if (i+1 == (int) s->img_x) break;
5624 if((--bit_offset) < 0) {
5625 bit_offset = 7;
5626 v = stbi__get8(s);
5627 }
5628 }
5629 stbi__skip(s, pad);
5630 }
5631 } else {
5632 for (j=0; j < (int) s->img_y; ++j) {
5633 for (i=0; i < (int) s->img_x; i += 2) {
5634 int v=stbi__get8(s),v2=0;
5635 if (info.bpp == 4) {
5636 v2 = v & 15;
5637 v >>= 4;
5638 }
5639 out[z++] = pal[v][0];
5640 out[z++] = pal[v][1];
5641 out[z++] = pal[v][2];
5642 if (target == 4) out[z++] = 255;
5643 if (i+1 == (int) s->img_x) break;
5644 v = (info.bpp == 8) ? stbi__get8(s) : v2;
5645 out[z++] = pal[v][0];
5646 out[z++] = pal[v][1];
5647 out[z++] = pal[v][2];
5648 if (target == 4) out[z++] = 255;
5649 }
5650 stbi__skip(s, pad);
5651 }
5652 }
5653 } else {
5654 int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
5655 int z = 0;
5656 int easy=0;
5657 stbi__skip(s, info.offset - info.extra_read - info.hsz);
5658 if (info.bpp == 24) width = 3 * s->img_x;
5659 else if (info.bpp == 16) width = 2*s->img_x;
5660 else /* bpp = 32 and pad = 0 */ width=0;
5661 pad = (-width) & 3;
5662 if (info.bpp == 24) {
5663 easy = 1;
5664 } else if (info.bpp == 32) {
5665 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
5666 easy = 2;
5667 }
5668 if (!easy) {
5669 if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
5670 // right shift amt to put high bit in position #7
5671 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
5672 gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
5673 bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
5674 ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
5675 if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
5676 }
5677 for (j=0; j < (int) s->img_y; ++j) {
5678 if (easy) {
5679 for (i=0; i < (int) s->img_x; ++i) {
5680 unsigned char a;
5681 out[z+2] = stbi__get8(s);
5682 out[z+1] = stbi__get8(s);
5683 out[z+0] = stbi__get8(s);
5684 z += 3;
5685 a = (easy == 2 ? stbi__get8(s) : 255);
5686 all_a |= a;
5687 if (target == 4) out[z++] = a;
5688 }
5689 } else {
5690 int bpp = info.bpp;
5691 for (i=0; i < (int) s->img_x; ++i) {
5692 stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
5693 unsigned int a;
5694 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
5695 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
5696 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
5697 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
5698 all_a |= a;
5699 if (target == 4) out[z++] = STBI__BYTECAST(a);
5700 }
5701 }
5702 stbi__skip(s, pad);
5703 }
5704 }
5706 // if alpha channel is all 0s, replace with all 255s
5707 if (target == 4 && all_a == 0)
5708 for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
5709 out[i] = 255;
5711 if (flip_vertically) {
5712 stbi_uc t;
5713 for (j=0; j < (int) s->img_y>>1; ++j) {
5714 stbi_uc *p1 = out + j *s->img_x*target;
5715 stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
5716 for (i=0; i < (int) s->img_x*target; ++i) {
5717 t = p1[i]; p1[i] = p2[i]; p2[i] = t;
5718 }
5719 }
5720 }
5722 if (req_comp && req_comp != target) {
5723 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
5724 if (out == NULL) return out; // stbi__convert_format frees input on failure
5725 }
5727 *x = s->img_x;
5728 *y = s->img_y;
5729 if (comp) *comp = s->img_n;
5730 return out;
5731}
5732#endif
5734// Targa Truevision - TGA
5735// by Jonathan Dummer
5736#ifndef STBI_NO_TGA
5737// returns STBI_rgb or whatever, 0 on error
5738static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
5739{
5740 // only RGB or RGBA (incl. 16bit) or grey allowed
5741 if (is_rgb16) *is_rgb16 = 0;
5742 switch(bits_per_pixel) {
5743 case 8: return STBI_grey;
5744 case 16: if(is_grey) return STBI_grey_alpha;
5745 // fallthrough
5746 case 15: if(is_rgb16) *is_rgb16 = 1;
5747 return STBI_rgb;
5748 case 24: // fallthrough
5749 case 32: return bits_per_pixel/8;
5750 default: return 0;
5751 }
5752}
5754static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
5755{
5756 int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
5757 int sz, tga_colormap_type;
5758 stbi__get8(s); // discard Offset
5759 tga_colormap_type = stbi__get8(s); // colormap type
5760 if( tga_colormap_type > 1 ) {
5761 stbi__rewind(s);
5762 return 0; // only RGB or indexed allowed
5763 }
5764 tga_image_type = stbi__get8(s); // image type
5765 if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
5766 if (tga_image_type != 1 && tga_image_type != 9) {
5767 stbi__rewind(s);
5768 return 0;
5769 }
5770 stbi__skip(s,4); // skip index of first colormap entry and number of entries
5771 sz = stbi__get8(s); // check bits per palette color entry
5772 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
5773 stbi__rewind(s);
5774 return 0;
5775 }
5776 stbi__skip(s,4); // skip image x and y origin
5777 tga_colormap_bpp = sz;
5778 } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
5779 if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
5780 stbi__rewind(s);
5781 return 0; // only RGB or grey allowed, +/- RLE
5782 }
5783 stbi__skip(s,9); // skip colormap specification and image x/y origin
5784 tga_colormap_bpp = 0;
5785 }
5786 tga_w = stbi__get16le(s);
5787 if( tga_w < 1 ) {
5788 stbi__rewind(s);
5789 return 0; // test width
5790 }
5791 tga_h = stbi__get16le(s);
5792 if( tga_h < 1 ) {
5793 stbi__rewind(s);
5794 return 0; // test height
5795 }
5796 tga_bits_per_pixel = stbi__get8(s); // bits per pixel
5797 stbi__get8(s); // ignore alpha bits
5798 if (tga_colormap_bpp != 0) {
5799 if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
5800 // when using a colormap, tga_bits_per_pixel is the size of the indexes
5801 // I don't think anything but 8 or 16bit indexes makes sense
5802 stbi__rewind(s);
5803 return 0;
5804 }
5805 tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
5806 } else {
5807 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
5808 }
5809 if(!tga_comp) {
5810 stbi__rewind(s);
5811 return 0;
5812 }
5813 if (x) *x = tga_w;
5814 if (y) *y = tga_h;
5815 if (comp) *comp = tga_comp;
5816 return 1; // seems to have passed everything
5817}
5819static int stbi__tga_test(stbi__context *s)
5820{
5821 int res = 0;
5822 int sz, tga_color_type;
5823 stbi__get8(s); // discard Offset
5824 tga_color_type = stbi__get8(s); // color type
5825 if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed
5826 sz = stbi__get8(s); // image type
5827 if ( tga_color_type == 1 ) { // colormapped (paletted) image
5828 if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
5829 stbi__skip(s,4); // skip index of first colormap entry and number of entries
5830 sz = stbi__get8(s); // check bits per palette color entry
5831 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
5832 stbi__skip(s,4); // skip image x and y origin
5833 } else { // "normal" image w/o colormap
5834 if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
5835 stbi__skip(s,9); // skip colormap specification and image x/y origin
5836 }
5837 if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width
5838 if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height
5839 sz = stbi__get8(s); // bits per pixel
5840 if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
5841 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
5843 res = 1; // if we got this far, everything's good and we can return 1 instead of 0
5845errorEnd:
5846 stbi__rewind(s);
5847 return res;
5848}
5850// read 16bit value and convert to 24bit RGB
5851static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
5852{
5853 stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
5854 stbi__uint16 fiveBitMask = 31;
5855 // we have 3 channels with 5bits each
5856 int r = (px >> 10) & fiveBitMask;
5857 int g = (px >> 5) & fiveBitMask;
5858 int b = px & fiveBitMask;
5859 // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
5860 out[0] = (stbi_uc)((r * 255)/31);
5861 out[1] = (stbi_uc)((g * 255)/31);
5862 out[2] = (stbi_uc)((b * 255)/31);
5864 // some people claim that the most significant bit might be used for alpha
5865 // (possibly if an alpha-bit is set in the "image descriptor byte")
5866 // but that only made 16bit test images completely translucent..
5867 // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
5868}
5870static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5871{
5872 // read in the TGA header stuff
5873 int tga_offset = stbi__get8(s);
5874 int tga_indexed = stbi__get8(s);
5875 int tga_image_type = stbi__get8(s);
5876 int tga_is_RLE = 0;
5877 int tga_palette_start = stbi__get16le(s);
5878 int tga_palette_len = stbi__get16le(s);
5879 int tga_palette_bits = stbi__get8(s);
5880 int tga_x_origin = stbi__get16le(s);
5881 int tga_y_origin = stbi__get16le(s);
5882 int tga_width = stbi__get16le(s);
5883 int tga_height = stbi__get16le(s);
5884 int tga_bits_per_pixel = stbi__get8(s);
5885 int tga_comp, tga_rgb16=0;
5886 int tga_inverted = stbi__get8(s);
5887 // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
5888 // image data
5889 unsigned char *tga_data;
5890 unsigned char *tga_palette = NULL;
5891 int i, j;
5892 unsigned char raw_data[4] = {0};
5893 int RLE_count = 0;
5894 int RLE_repeating = 0;
5895 int read_next_pixel = 1;
5896 STBI_NOTUSED(ri);
5897 STBI_NOTUSED(tga_x_origin); // @TODO
5898 STBI_NOTUSED(tga_y_origin); // @TODO
5900 if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5901 if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5903 // do a tiny bit of precessing
5904 if ( tga_image_type >= 8 )
5905 {
5906 tga_image_type -= 8;
5907 tga_is_RLE = 1;
5908 }
5909 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
5911 // If I'm paletted, then I'll use the number of bits from the palette
5912 if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
5913 else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
5915 if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
5916 return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
5918 // tga info
5919 *x = tga_width;
5920 *y = tga_height;
5921 if (comp) *comp = tga_comp;
5923 if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
5924 return stbi__errpuc("too large", "Corrupt TGA");
5926 tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
5927 if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
5929 // skip to the data's starting position (offset usually = 0)
5930 stbi__skip(s, tga_offset );
5932 if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
5933 for (i=0; i < tga_height; ++i) {
5934 int row = tga_inverted ? tga_height -i - 1 : i;
5935 stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
5936 stbi__getn(s, tga_row, tga_width * tga_comp);
5937 }
5938 } else {
5939 // do I need to load a palette?
5940 if ( tga_indexed)
5941 {
5942 if (tga_palette_len == 0) { /* you have to have at least one entry! */
5943 STBI_FREE(tga_data);
5944 return stbi__errpuc("bad palette", "Corrupt TGA");
5945 }
5947 // any data to skip? (offset usually = 0)
5948 stbi__skip(s, tga_palette_start );
5949 // load the palette
5950 tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
5951 if (!tga_palette) {
5952 STBI_FREE(tga_data);
5953 return stbi__errpuc("outofmem", "Out of memory");
5954 }
5955 if (tga_rgb16) {
5956 stbi_uc *pal_entry = tga_palette;
5957 STBI_ASSERT(tga_comp == STBI_rgb);
5958 for (i=0; i < tga_palette_len; ++i) {
5959 stbi__tga_read_rgb16(s, pal_entry);
5960 pal_entry += tga_comp;
5961 }
5962 } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
5963 STBI_FREE(tga_data);
5964 STBI_FREE(tga_palette);
5965 return stbi__errpuc("bad palette", "Corrupt TGA");
5966 }
5967 }
5968 // load the data
5969 for (i=0; i < tga_width * tga_height; ++i)
5970 {
5971 // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
5972 if ( tga_is_RLE )
5973 {
5974 if ( RLE_count == 0 )
5975 {
5976 // yep, get the next byte as a RLE command
5977 int RLE_cmd = stbi__get8(s);
5978 RLE_count = 1 + (RLE_cmd & 127);
5979 RLE_repeating = RLE_cmd >> 7;
5980 read_next_pixel = 1;
5981 } else if ( !RLE_repeating )
5982 {
5983 read_next_pixel = 1;
5984 }
5985 } else
5986 {
5987 read_next_pixel = 1;
5988 }
5989 // OK, if I need to read a pixel, do it now
5990 if ( read_next_pixel )
5991 {
5992 // load however much data we did have
5993 if ( tga_indexed )
5994 {
5995 // read in index, then perform the lookup
5996 int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
5997 if ( pal_idx >= tga_palette_len ) {
5998 // invalid index
5999 pal_idx = 0;
6000 }
6001 pal_idx *= tga_comp;
6002 for (j = 0; j < tga_comp; ++j) {
6003 raw_data[j] = tga_palette[pal_idx+j];
6004 }
6005 } else if(tga_rgb16) {
6006 STBI_ASSERT(tga_comp == STBI_rgb);
6007 stbi__tga_read_rgb16(s, raw_data);
6008 } else {
6009 // read in the data raw
6010 for (j = 0; j < tga_comp; ++j) {
6011 raw_data[j] = stbi__get8(s);
6012 }
6013 }
6014 // clear the reading flag for the next pixel
6015 read_next_pixel = 0;
6016 } // end of reading a pixel
6018 // copy data
6019 for (j = 0; j < tga_comp; ++j)
6020 tga_data[i*tga_comp+j] = raw_data[j];
6022 // in case we're in RLE mode, keep counting down
6023 --RLE_count;
6024 }
6025 // do I need to invert the image?
6026 if ( tga_inverted )
6027 {
6028 for (j = 0; j*2 < tga_height; ++j)
6029 {
6030 int index1 = j * tga_width * tga_comp;
6031 int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
6032 for (i = tga_width * tga_comp; i > 0; --i)
6033 {
6034 unsigned char temp = tga_data[index1];
6035 tga_data[index1] = tga_data[index2];
6036 tga_data[index2] = temp;
6037 ++index1;
6038 ++index2;
6039 }
6040 }
6041 }
6042 // clear my palette, if I had one
6043 if ( tga_palette != NULL )
6044 {
6045 STBI_FREE( tga_palette );
6046 }
6047 }
6049 // swap RGB - if the source data was RGB16, it already is in the right order
6050 if (tga_comp >= 3 && !tga_rgb16)
6051 {
6052 unsigned char* tga_pixel = tga_data;
6053 for (i=0; i < tga_width * tga_height; ++i)
6054 {
6055 unsigned char temp = tga_pixel[0];
6056 tga_pixel[0] = tga_pixel[2];
6057 tga_pixel[2] = temp;
6058 tga_pixel += tga_comp;
6059 }
6060 }
6062 // convert to target component count
6063 if (req_comp && req_comp != tga_comp)
6064 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
6066 // the things I do to get rid of an error message, and yet keep
6067 // Microsoft's C compilers happy... [8^(
6068 tga_palette_start = tga_palette_len = tga_palette_bits =
6069 tga_x_origin = tga_y_origin = 0;
6070 STBI_NOTUSED(tga_palette_start);
6071 // OK, done
6072 return tga_data;
6073}
6074#endif
6076// *************************************************************************************************
6077// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
6079#ifndef STBI_NO_PSD
6080static int stbi__psd_test(stbi__context *s)
6081{
6082 int r = (stbi__get32be(s) == 0x38425053);
6083 stbi__rewind(s);
6084 return r;
6085}
6087static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
6088{
6089 int count, nleft, len;
6091 count = 0;
6092 while ((nleft = pixelCount - count) > 0) {
6093 len = stbi__get8(s);
6094 if (len == 128) {
6095 // No-op.
6096 } else if (len < 128) {
6097 // Copy next len+1 bytes literally.
6098 len++;
6099 if (len > nleft) return 0; // corrupt data
6100 count += len;
6101 while (len) {
6102 *p = stbi__get8(s);
6103 p += 4;
6104 len--;
6105 }
6106 } else if (len > 128) {
6107 stbi_uc val;
6108 // Next -len+1 bytes in the dest are replicated from next source byte.
6109 // (Interpret len as a negative 8-bit int.)
6110 len = 257 - len;
6111 if (len > nleft) return 0; // corrupt data
6112 val = stbi__get8(s);
6113 count += len;
6114 while (len) {
6115 *p = val;
6116 p += 4;
6117 len--;
6118 }
6119 }
6120 }
6122 return 1;
6123}
6125static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
6126{
6127 int pixelCount;
6128 int channelCount, compression;
6129 int channel, i;
6130 int bitdepth;
6131 int w,h;
6132 stbi_uc *out;
6133 STBI_NOTUSED(ri);
6135 // Check identifier
6136 if (stbi__get32be(s) != 0x38425053) // "8BPS"
6137 return stbi__errpuc("not PSD", "Corrupt PSD image");
6139 // Check file type version.
6140 if (stbi__get16be(s) != 1)
6141 return stbi__errpuc("wrong version", "Unsupported version of PSD image");
6143 // Skip 6 reserved bytes.
6144 stbi__skip(s, 6 );
6146 // Read the number of channels (R, G, B, A, etc).
6147 channelCount = stbi__get16be(s);
6148 if (channelCount < 0 || channelCount > 16)
6149 return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
6151 // Read the rows and columns of the image.
6152 h = stbi__get32be(s);
6153 w = stbi__get32be(s);
6155 if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6156 if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6158 // Make sure the depth is 8 bits.
6159 bitdepth = stbi__get16be(s);
6160 if (bitdepth != 8 && bitdepth != 16)
6161 return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
6163 // Make sure the color mode is RGB.
6164 // Valid options are:
6165 // 0: Bitmap
6166 // 1: Grayscale
6167 // 2: Indexed color
6168 // 3: RGB color
6169 // 4: CMYK color
6170 // 7: Multichannel
6171 // 8: Duotone
6172 // 9: Lab color
6173 if (stbi__get16be(s) != 3)
6174 return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
6176 // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
6177 stbi__skip(s,stbi__get32be(s) );
6179 // Skip the image resources. (resolution, pen tool paths, etc)
6180 stbi__skip(s, stbi__get32be(s) );
6182 // Skip the reserved data.
6183 stbi__skip(s, stbi__get32be(s) );
6185 // Find out if the data is compressed.
6186 // Known values:
6187 // 0: no compression
6188 // 1: RLE compressed
6189 compression = stbi__get16be(s);
6190 if (compression > 1)
6191 return stbi__errpuc("bad compression", "PSD has an unknown compression format");
6193 // Check size
6194 if (!stbi__mad3sizes_valid(4, w, h, 0))
6195 return stbi__errpuc("too large", "Corrupt PSD");
6197 // Create the destination image.
6199 if (!compression && bitdepth == 16 && bpc == 16) {
6200 out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
6201 ri->bits_per_channel = 16;
6202 } else
6203 out = (stbi_uc *) stbi__malloc(4 * w*h);
6205 if (!out) return stbi__errpuc("outofmem", "Out of memory");
6206 pixelCount = w*h;
6208 // Initialize the data to zero.
6209 //memset( out, 0, pixelCount * 4 );
6211 // Finally, the image data.
6212 if (compression) {
6213 // RLE as used by .PSD and .TIFF
6214 // Loop until you get the number of unpacked bytes you are expecting:
6215 // Read the next source byte into n.
6216 // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
6217 // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
6218 // Else if n is 128, noop.
6219 // Endloop
6221 // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
6222 // which we're going to just skip.
6223 stbi__skip(s, h * channelCount * 2 );
6225 // Read the RLE data by channel.
6226 for (channel = 0; channel < 4; channel++) {
6227 stbi_uc *p;
6229 p = out+channel;
6230 if (channel >= channelCount) {
6231 // Fill this channel with default data.
6232 for (i = 0; i < pixelCount; i++, p += 4)
6233 *p = (channel == 3 ? 255 : 0);
6234 } else {
6235 // Read the RLE data.
6236 if (!stbi__psd_decode_rle(s, p, pixelCount)) {
6237 STBI_FREE(out);
6238 return stbi__errpuc("corrupt", "bad RLE data");
6239 }
6240 }
6241 }
6243 } else {
6244 // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
6245 // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
6247 // Read the data by channel.
6248 for (channel = 0; channel < 4; channel++) {
6249 if (channel >= channelCount) {
6250 // Fill this channel with default data.
6251 if (bitdepth == 16 && bpc == 16) {
6252 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
6253 stbi__uint16 val = channel == 3 ? 65535 : 0;
6254 for (i = 0; i < pixelCount; i++, q += 4)
6255 *q = val;
6256 } else {
6257 stbi_uc *p = out+channel;
6258 stbi_uc val = channel == 3 ? 255 : 0;
6259 for (i = 0; i < pixelCount; i++, p += 4)
6260 *p = val;
6261 }
6262 } else {
6263 if (ri->bits_per_channel == 16) { // output bpc
6264 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
6265 for (i = 0; i < pixelCount; i++, q += 4)
6266 *q = (stbi__uint16) stbi__get16be(s);
6267 } else {
6268 stbi_uc *p = out+channel;
6269 if (bitdepth == 16) { // input bpc
6270 for (i = 0; i < pixelCount; i++, p += 4)
6271 *p = (stbi_uc) (stbi__get16be(s) >> 8);
6272 } else {
6273 for (i = 0; i < pixelCount; i++, p += 4)
6274 *p = stbi__get8(s);
6275 }
6276 }
6277 }
6278 }
6279 }
6281 // remove weird white matte from PSD
6282 if (channelCount >= 4) {
6283 if (ri->bits_per_channel == 16) {
6284 for (i=0; i < w*h; ++i) {
6285 stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
6286 if (pixel[3] != 0 && pixel[3] != 65535) {
6287 float a = pixel[3] / 65535.0f;
6288 float ra = 1.0f / a;
6289 float inv_a = 65535.0f * (1 - ra);
6290 pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
6291 pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
6292 pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
6293 }
6294 }
6295 } else {
6296 for (i=0; i < w*h; ++i) {
6297 unsigned char *pixel = out + 4*i;
6298 if (pixel[3] != 0 && pixel[3] != 255) {
6299 float a = pixel[3] / 255.0f;
6300 float ra = 1.0f / a;
6301 float inv_a = 255.0f * (1 - ra);
6302 pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
6303 pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
6304 pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
6305 }
6306 }
6307 }
6308 }
6310 // convert to desired output format
6311 if (req_comp && req_comp != 4) {
6312 if (ri->bits_per_channel == 16)
6313 out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
6314 else
6315 out = stbi__convert_format(out, 4, req_comp, w, h);
6316 if (out == NULL) return out; // stbi__convert_format frees input on failure
6317 }
6319 if (comp) *comp = 4;
6320 *y = h;
6321 *x = w;
6323 return out;
6324}
6325#endif
6327// *************************************************************************************************
6328// Softimage PIC loader
6329// by Tom Seddon
6330//
6331// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
6332// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
6334#ifndef STBI_NO_PIC
6335static int stbi__pic_is4(stbi__context *s,const char *str)
6336{
6337 int i;
6338 for (i=0; i<4; ++i)
6339 if (stbi__get8(s) != (stbi_uc)str[i])
6340 return 0;
6342 return 1;
6343}
6345static int stbi__pic_test_core(stbi__context *s)
6346{
6347 int i;
6349 if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
6350 return 0;
6352 for(i=0;i<84;++i)
6353 stbi__get8(s);
6355 if (!stbi__pic_is4(s,"PICT"))
6356 return 0;
6358 return 1;
6359}
6361typedef struct
6362{
6363 stbi_uc size,type,channel;
6364} stbi__pic_packet;
6366static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
6367{
6368 int mask=0x80, i;
6370 for (i=0; i<4; ++i, mask>>=1) {
6371 if (channel & mask) {
6372 if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
6373 dest[i]=stbi__get8(s);
6374 }
6375 }
6377 return dest;
6378}
6380static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
6381{
6382 int mask=0x80,i;
6384 for (i=0;i<4; ++i, mask>>=1)
6385 if (channel&mask)
6386 dest[i]=src[i];
6387}
6389static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
6390{
6391 int act_comp=0,num_packets=0,y,chained;
6392 stbi__pic_packet packets[10];
6394 // this will (should...) cater for even some bizarre stuff like having data
6395 // for the same channel in multiple packets.
6396 do {
6397 stbi__pic_packet *packet;
6399 if (num_packets==sizeof(packets)/sizeof(packets[0]))
6400 return stbi__errpuc("bad format","too many packets");
6402 packet = &packets[num_packets++];
6404 chained = stbi__get8(s);
6405 packet->size = stbi__get8(s);
6406 packet->type = stbi__get8(s);
6407 packet->channel = stbi__get8(s);
6409 act_comp |= packet->channel;
6411 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");
6412 if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");
6413 } while (chained);
6415 *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
6417 for(y=0; y<height; ++y) {
6418 int packet_idx;
6420 for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
6421 stbi__pic_packet *packet = &packets[packet_idx];
6422 stbi_uc *dest = result+y*width*4;
6424 switch (packet->type) {
6425 default:
6426 return stbi__errpuc("bad format","packet has bad compression type");
6428 case 0: {//uncompressed
6429 int x;
6431 for(x=0;x<width;++x, dest+=4)
6432 if (!stbi__readval(s,packet->channel,dest))
6433 return 0;
6434 break;
6435 }
6437 case 1://Pure RLE
6438 {
6439 int left=width, i;
6441 while (left>0) {
6442 stbi_uc count,value[4];
6444 count=stbi__get8(s);
6445 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");
6447 if (count > left)
6448 count = (stbi_uc) left;
6450 if (!stbi__readval(s,packet->channel,value)) return 0;
6452 for(i=0; i<count; ++i,dest+=4)
6453 stbi__copyval(packet->channel,dest,value);
6454 left -= count;
6455 }
6456 }
6457 break;
6459 case 2: {//Mixed RLE
6460 int left=width;
6461 while (left>0) {
6462 int count = stbi__get8(s), i;
6463 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");
6465 if (count >= 128) { // Repeated
6466 stbi_uc value[4];
6468 if (count==128)
6469 count = stbi__get16be(s);
6470 else
6471 count -= 127;
6472 if (count > left)
6473 return stbi__errpuc("bad file","scanline overrun");
6475 if (!stbi__readval(s,packet->channel,value))
6476 return 0;
6478 for(i=0;i<count;++i, dest += 4)
6479 stbi__copyval(packet->channel,dest,value);
6480 } else { // Raw
6481 ++count;
6482 if (count>left) return stbi__errpuc("bad file","scanline overrun");
6484 for(i=0;i<count;++i, dest+=4)
6485 if (!stbi__readval(s,packet->channel,dest))
6486 return 0;
6487 }
6488 left-=count;
6489 }
6490 break;
6491 }
6492 }
6493 }
6494 }
6496 return result;
6497}
6499static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
6500{
6501 stbi_uc *result;
6502 int i, x,y, internal_comp;
6503 STBI_NOTUSED(ri);
6505 if (!comp) comp = &internal_comp;
6507 for (i=0; i<92; ++i)
6508 stbi__get8(s);
6510 x = stbi__get16be(s);
6511 y = stbi__get16be(s);
6513 if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6514 if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6516 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");
6517 if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
6519 stbi__get32be(s); //skip `ratio'
6520 stbi__get16be(s); //skip `fields'
6521 stbi__get16be(s); //skip `pad'
6523 // intermediate buffer is RGBA
6524 result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
6525 if (!result) return stbi__errpuc("outofmem", "Out of memory");
6526 memset(result, 0xff, x*y*4);
6528 if (!stbi__pic_load_core(s,x,y,comp, result)) {
6529 STBI_FREE(result);
6530 result=0;
6531 }
6532 *px = x;
6533 *py = y;
6534 if (req_comp == 0) req_comp = *comp;
6535 result=stbi__convert_format(result,4,req_comp,x,y);
6537 return result;
6538}
6540static int stbi__pic_test(stbi__context *s)
6541{
6542 int r = stbi__pic_test_core(s);
6543 stbi__rewind(s);
6544 return r;
6545}
6546#endif
6548// *************************************************************************************************
6549// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
6551#ifndef STBI_NO_GIF
6552typedef struct
6553{
6554 stbi__int16 prefix;
6555 stbi_uc first;
6556 stbi_uc suffix;
6557} stbi__gif_lzw;
6559typedef struct
6560{
6561 int w,h;
6562 stbi_uc *out; // output buffer (always 4 components)
6563 stbi_uc *background; // The current "background" as far as a gif is concerned
6564 stbi_uc *history;
6565 int flags, bgindex, ratio, transparent, eflags;
6566 stbi_uc pal[256][4];
6567 stbi_uc lpal[256][4];
6568 stbi__gif_lzw codes[8192];
6569 stbi_uc *color_table;
6570 int parse, step;
6571 int lflags;
6572 int start_x, start_y;
6573 int max_x, max_y;
6574 int cur_x, cur_y;
6575 int line_size;
6576 int delay;
6577} stbi__gif;
6579static int stbi__gif_test_raw(stbi__context *s)
6580{
6581 int sz;
6582 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
6583 sz = stbi__get8(s);
6584 if (sz != '9' && sz != '7') return 0;
6585 if (stbi__get8(s) != 'a') return 0;
6586 return 1;
6587}
6589static int stbi__gif_test(stbi__context *s)
6590{
6591 int r = stbi__gif_test_raw(s);
6592 stbi__rewind(s);
6593 return r;
6594}
6596static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
6597{
6598 int i;
6599 for (i=0; i < num_entries; ++i) {
6600 pal[i][2] = stbi__get8(s);
6601 pal[i][1] = stbi__get8(s);
6602 pal[i][0] = stbi__get8(s);
6603 pal[i][3] = transp == i ? 0 : 255;
6604 }
6605}
6607static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
6608{
6609 stbi_uc version;
6610 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
6611 return stbi__err("not GIF", "Corrupt GIF");
6613 version = stbi__get8(s);
6614 if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");
6615 if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");
6617 stbi__g_failure_reason = "";
6618 g->w = stbi__get16le(s);
6619 g->h = stbi__get16le(s);
6620 g->flags = stbi__get8(s);
6621 g->bgindex = stbi__get8(s);
6622 g->ratio = stbi__get8(s);
6623 g->transparent = -1;
6625 if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
6626 if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
6628 if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
6630 if (is_info) return 1;
6632 if (g->flags & 0x80)
6633 stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
6635 return 1;
6636}
6638static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
6639{
6640 stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
6641 if (!g) return stbi__err("outofmem", "Out of memory");
6642 if (!stbi__gif_header(s, g, comp, 1)) {
6643 STBI_FREE(g);
6644 stbi__rewind( s );
6645 return 0;
6646 }
6647 if (x) *x = g->w;
6648 if (y) *y = g->h;
6649 STBI_FREE(g);
6650 return 1;
6651}
6653static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
6654{
6655 stbi_uc *p, *c;
6656 int idx;
6658 // recurse to decode the prefixes, since the linked-list is backwards,
6659 // and working backwards through an interleaved image would be nasty
6660 if (g->codes[code].prefix >= 0)
6661 stbi__out_gif_code(g, g->codes[code].prefix);
6663 if (g->cur_y >= g->max_y) return;
6665 idx = g->cur_x + g->cur_y;
6666 p = &g->out[idx];
6667 g->history[idx / 4] = 1;
6669 c = &g->color_table[g->codes[code].suffix * 4];
6670 if (c[3] > 128) { // don't render transparent pixels;
6671 p[0] = c[2];
6672 p[1] = c[1];
6673 p[2] = c[0];
6674 p[3] = c[3];
6675 }
6676 g->cur_x += 4;
6678 if (g->cur_x >= g->max_x) {
6679 g->cur_x = g->start_x;
6680 g->cur_y += g->step;
6682 while (g->cur_y >= g->max_y && g->parse > 0) {
6683 g->step = (1 << g->parse) * g->line_size;
6684 g->cur_y = g->start_y + (g->step >> 1);
6685 --g->parse;
6686 }
6687 }
6688}
6690static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
6691{
6692 stbi_uc lzw_cs;
6693 stbi__int32 len, init_code;
6694 stbi__uint32 first;
6695 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
6696 stbi__gif_lzw *p;
6698 lzw_cs = stbi__get8(s);
6699 if (lzw_cs > 12) return NULL;
6700 clear = 1 << lzw_cs;
6701 first = 1;
6702 codesize = lzw_cs + 1;
6703 codemask = (1 << codesize) - 1;
6704 bits = 0;
6705 valid_bits = 0;
6706 for (init_code = 0; init_code < clear; init_code++) {
6707 g->codes[init_code].prefix = -1;
6708 g->codes[init_code].first = (stbi_uc) init_code;
6709 g->codes[init_code].suffix = (stbi_uc) init_code;
6710 }
6712 // support no starting clear code
6713 avail = clear+2;
6714 oldcode = -1;
6716 len = 0;
6717 for(;;) {
6718 if (valid_bits < codesize) {
6719 if (len == 0) {
6720 len = stbi__get8(s); // start new block
6721 if (len == 0)
6722 return g->out;
6723 }
6724 --len;
6725 bits |= (stbi__int32) stbi__get8(s) << valid_bits;
6726 valid_bits += 8;
6727 } else {
6728 stbi__int32 code = bits & codemask;
6729 bits >>= codesize;
6730 valid_bits -= codesize;
6731 // @OPTIMIZE: is there some way we can accelerate the non-clear path?
6732 if (code == clear) { // clear code
6733 codesize = lzw_cs + 1;
6734 codemask = (1 << codesize) - 1;
6735 avail = clear + 2;
6736 oldcode = -1;
6737 first = 0;
6738 } else if (code == clear + 1) { // end of stream code
6739 stbi__skip(s, len);
6740 while ((len = stbi__get8(s)) > 0)
6741 stbi__skip(s,len);
6742 return g->out;
6743 } else if (code <= avail) {
6744 if (first) {
6745 return stbi__errpuc("no clear code", "Corrupt GIF");
6746 }
6748 if (oldcode >= 0) {
6749 p = &g->codes[avail++];
6750 if (avail > 8192) {
6751 return stbi__errpuc("too many codes", "Corrupt GIF");
6752 }
6754 p->prefix = (stbi__int16) oldcode;
6755 p->first = g->codes[oldcode].first;
6756 p->suffix = (code == avail) ? p->first : g->codes[code].first;
6757 } else if (code == avail)
6758 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
6760 stbi__out_gif_code(g, (stbi__uint16) code);
6762 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
6763 codesize++;
6764 codemask = (1 << codesize) - 1;
6765 }
6767 oldcode = code;
6768 } else {
6769 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
6770 }
6771 }
6772 }
6773}
6775// this function is designed to support animated gifs, although stb_image doesn't support it
6776// two back is the image from two frames ago, used for a very specific disposal format
6777static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
6778{
6779 int dispose;
6780 int first_frame;
6781 int pi;
6782 int pcount;
6783 STBI_NOTUSED(req_comp);
6785 // on first frame, any non-written pixels get the background colour (non-transparent)
6786 first_frame = 0;
6787 if (g->out == 0) {
6788 if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
6789 if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
6790 return stbi__errpuc("too large", "GIF image is too large");
6791 pcount = g->w * g->h;
6792 g->out = (stbi_uc *) stbi__malloc(4 * pcount);
6793 g->background = (stbi_uc *) stbi__malloc(4 * pcount);
6794 g->history = (stbi_uc *) stbi__malloc(pcount);
6795 if (!g->out || !g->background || !g->history)
6796 return stbi__errpuc("outofmem", "Out of memory");
6798 // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
6799 // background colour is only used for pixels that are not rendered first frame, after that "background"
6800 // color refers to the color that was there the previous frame.
6801 memset(g->out, 0x00, 4 * pcount);
6802 memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
6803 memset(g->history, 0x00, pcount); // pixels that were affected previous frame
6804 first_frame = 1;
6805 } else {
6806 // second frame - how do we dispose of the previous one?
6807 dispose = (g->eflags & 0x1C) >> 2;
6808 pcount = g->w * g->h;
6810 if ((dispose == 3) && (two_back == 0)) {
6811 dispose = 2; // if I don't have an image to revert back to, default to the old background
6812 }
6814 if (dispose == 3) { // use previous graphic
6815 for (pi = 0; pi < pcount; ++pi) {
6816 if (g->history[pi]) {
6817 memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
6818 }
6819 }
6820 } else if (dispose == 2) {
6821 // restore what was changed last frame to background before that frame;
6822 for (pi = 0; pi < pcount; ++pi) {
6823 if (g->history[pi]) {
6824 memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
6825 }
6826 }
6827 } else {
6828 // This is a non-disposal case eithe way, so just
6829 // leave the pixels as is, and they will become the new background
6830 // 1: do not dispose
6831 // 0: not specified.
6832 }
6834 // background is what out is after the undoing of the previou frame;
6835 memcpy( g->background, g->out, 4 * g->w * g->h );
6836 }
6838 // clear my history;
6839 memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame
6841 for (;;) {
6842 int tag = stbi__get8(s);
6843 switch (tag) {
6844 case 0x2C: /* Image Descriptor */
6845 {
6846 stbi__int32 x, y, w, h;
6847 stbi_uc *o;
6849 x = stbi__get16le(s);
6850 y = stbi__get16le(s);
6851 w = stbi__get16le(s);
6852 h = stbi__get16le(s);
6853 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
6854 return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
6856 g->line_size = g->w * 4;
6857 g->start_x = x * 4;
6858 g->start_y = y * g->line_size;
6859 g->max_x = g->start_x + w * 4;
6860 g->max_y = g->start_y + h * g->line_size;
6861 g->cur_x = g->start_x;
6862 g->cur_y = g->start_y;
6864 // if the width of the specified rectangle is 0, that means
6865 // we may not see *any* pixels or the image is malformed;
6866 // to make sure this is caught, move the current y down to
6867 // max_y (which is what out_gif_code checks).
6868 if (w == 0)
6869 g->cur_y = g->max_y;
6871 g->lflags = stbi__get8(s);
6873 if (g->lflags & 0x40) {
6874 g->step = 8 * g->line_size; // first interlaced spacing
6875 g->parse = 3;
6876 } else {
6877 g->step = g->line_size;
6878 g->parse = 0;
6879 }
6881 if (g->lflags & 0x80) {
6882 stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
6883 g->color_table = (stbi_uc *) g->lpal;
6884 } else if (g->flags & 0x80) {
6885 g->color_table = (stbi_uc *) g->pal;
6886 } else
6887 return stbi__errpuc("missing color table", "Corrupt GIF");
6889 o = stbi__process_gif_raster(s, g);
6890 if (!o) return NULL;
6892 // if this was the first frame,
6893 pcount = g->w * g->h;
6894 if (first_frame && (g->bgindex > 0)) {
6895 // if first frame, any pixel not drawn to gets the background color
6896 for (pi = 0; pi < pcount; ++pi) {
6897 if (g->history[pi] == 0) {
6898 g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
6899 memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
6900 }
6901 }
6902 }
6904 return o;
6905 }
6907 case 0x21: // Comment Extension.
6908 {
6909 int len;
6910 int ext = stbi__get8(s);
6911 if (ext == 0xF9) { // Graphic Control Extension.
6912 len = stbi__get8(s);
6913 if (len == 4) {
6914 g->eflags = stbi__get8(s);
6915 g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
6917 // unset old transparent
6918 if (g->transparent >= 0) {
6919 g->pal[g->transparent][3] = 255;
6920 }
6921 if (g->eflags & 0x01) {
6922 g->transparent = stbi__get8(s);
6923 if (g->transparent >= 0) {
6924 g->pal[g->transparent][3] = 0;
6925 }
6926 } else {
6927 // don't need transparent
6928 stbi__skip(s, 1);
6929 g->transparent = -1;
6930 }
6931 } else {
6932 stbi__skip(s, len);
6933 break;
6934 }
6935 }
6936 while ((len = stbi__get8(s)) != 0) {
6937 stbi__skip(s, len);
6938 }
6939 break;
6940 }
6942 case 0x3B: // gif stream termination code
6943 return (stbi_uc *) s; // using '1' causes warning on some compilers
6945 default:
6946 return stbi__errpuc("unknown code", "Corrupt GIF");
6947 }
6948 }
6949}
6951static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
6952{
6953 STBI_FREE(g->out);
6954 STBI_FREE(g->history);
6955 STBI_FREE(g->background);
6957 if (out) STBI_FREE(out);
6958 if (delays && *delays) STBI_FREE(*delays);
6959 return stbi__errpuc("outofmem", "Out of memory");
6960}
6962static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
6963{
6964 if (stbi__gif_test(s)) {
6965 int layers = 0;
6966 stbi_uc *u = 0;
6967 stbi_uc *out = 0;
6968 stbi_uc *two_back = 0;
6969 stbi__gif g;
6970 int stride;
6971 int out_size = 0;
6972 int delays_size = 0;
6974 STBI_NOTUSED(out_size);
6975 STBI_NOTUSED(delays_size);
6977 memset(&g, 0, sizeof(g));
6978 if (delays) {
6979 *delays = 0;
6980 }
6982 do {
6983 u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
6984 if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
6986 if (u) {
6987 *x = g.w;
6988 *y = g.h;
6989 ++layers;
6990 stride = g.w * g.h * 4;
6992 if (out) {
6993 void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
6994 if (!tmp)
6995 return stbi__load_gif_main_outofmem(&g, out, delays);
6996 else {
6997 out = (stbi_uc*) tmp;
6998 out_size = layers * stride;
6999 }
7001 if (delays) {
7002 int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
7003 if (!new_delays)
7004 return stbi__load_gif_main_outofmem(&g, out, delays);
7005 *delays = new_delays;
7006 delays_size = layers * sizeof(int);
7007 }
7008 } else {
7009 out = (stbi_uc*)stbi__malloc( layers * stride );
7010 if (!out)
7011 return stbi__load_gif_main_outofmem(&g, out, delays);
7012 out_size = layers * stride;
7013 if (delays) {
7014 *delays = (int*) stbi__malloc( layers * sizeof(int) );
7015 if (!*delays)
7016 return stbi__load_gif_main_outofmem(&g, out, delays);
7017 delays_size = layers * sizeof(int);
7018 }
7019 }
7020 memcpy( out + ((layers - 1) * stride), u, stride );
7021 if (layers >= 2) {
7022 two_back = out - 2 * stride;
7023 }
7025 if (delays) {
7026 (*delays)[layers - 1U] = g.delay;
7027 }
7028 }
7029 } while (u != 0);
7031 // free temp buffer;
7032 STBI_FREE(g.out);
7033 STBI_FREE(g.history);
7034 STBI_FREE(g.background);
7036 // do the final conversion after loading everything;
7037 if (req_comp && req_comp != 4)
7038 out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
7040 *z = layers;
7041 return out;
7042 } else {
7043 return stbi__errpuc("not GIF", "Image was not as a gif type.");
7044 }
7045}
7047static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7048{
7049 stbi_uc *u = 0;
7050 stbi__gif g;
7051 memset(&g, 0, sizeof(g));
7052 STBI_NOTUSED(ri);
7054 u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
7055 if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
7056 if (u) {
7057 *x = g.w;
7058 *y = g.h;
7060 // moved conversion to after successful load so that the same
7061 // can be done for multiple frames.
7062 if (req_comp && req_comp != 4)
7063 u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
7064 } else if (g.out) {
7065 // if there was an error and we allocated an image buffer, free it!
7066 STBI_FREE(g.out);
7067 }
7069 // free buffers needed for multiple frame loading;
7070 STBI_FREE(g.history);
7071 STBI_FREE(g.background);
7073 return u;
7074}
7076static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
7077{
7078 return stbi__gif_info_raw(s,x,y,comp);
7079}
7080#endif
7082// *************************************************************************************************
7083// Radiance RGBE HDR loader
7084// originally by Nicolas Schulz
7085#ifndef STBI_NO_HDR
7086static int stbi__hdr_test_core(stbi__context *s, const char *signature)
7087{
7088 int i;
7089 for (i=0; signature[i]; ++i)
7090 if (stbi__get8(s) != signature[i])
7091 return 0;
7092 stbi__rewind(s);
7093 return 1;
7094}
7096static int stbi__hdr_test(stbi__context* s)
7097{
7098 int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
7099 stbi__rewind(s);
7100 if(!r) {
7101 r = stbi__hdr_test_core(s, "#?RGBE\n");
7102 stbi__rewind(s);
7103 }
7104 return r;
7105}
7107#define STBI__HDR_BUFLEN 1024
7108static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
7109{
7110 int len=0;
7111 char c = '\0';
7113 c = (char) stbi__get8(z);
7115 while (!stbi__at_eof(z) && c != '\n') {
7116 buffer[len++] = c;
7117 if (len == STBI__HDR_BUFLEN-1) {
7118 // flush to end of line
7119 while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
7120 ;
7121 break;
7122 }
7123 c = (char) stbi__get8(z);
7124 }
7126 buffer[len] = 0;
7127 return buffer;
7128}
7130static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
7131{
7132 if ( input[3] != 0 ) {
7133 float f1;
7134 // Exponent
7135 f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
7136 if (req_comp <= 2)
7137 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
7138 else {
7139 output[0] = input[0] * f1;
7140 output[1] = input[1] * f1;
7141 output[2] = input[2] * f1;
7142 }
7143 if (req_comp == 2) output[1] = 1;
7144 if (req_comp == 4) output[3] = 1;
7145 } else {
7146 switch (req_comp) {
7147 case 4: output[3] = 1; /* fallthrough */
7148 case 3: output[0] = output[1] = output[2] = 0;
7149 break;
7150 case 2: output[1] = 1; /* fallthrough */
7151 case 1: output[0] = 0;
7152 break;
7153 }
7154 }
7155}
7157static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7158{
7159 char buffer[STBI__HDR_BUFLEN];
7160 char *token;
7161 int valid = 0;
7162 int width, height;
7163 stbi_uc *scanline;
7164 float *hdr_data;
7165 int len;
7166 unsigned char count, value;
7167 int i, j, k, c1,c2, z;
7168 const char *headerToken;
7169 STBI_NOTUSED(ri);
7171 // Check identifier
7172 headerToken = stbi__hdr_gettoken(s,buffer);
7173 if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
7174 return stbi__errpf("not HDR", "Corrupt HDR image");
7176 // Parse header
7177 for(;;) {
7178 token = stbi__hdr_gettoken(s,buffer);
7179 if (token[0] == 0) break;
7180 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
7181 }
7183 if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");
7185 // Parse width and height
7186 // can't use sscanf() if we're not using stdio!
7187 token = stbi__hdr_gettoken(s,buffer);
7188 if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
7189 token += 3;
7190 height = (int) strtol(token, &token, 10);
7191 while (*token == ' ') ++token;
7192 if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
7193 token += 3;
7194 width = (int) strtol(token, NULL, 10);
7196 if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
7197 if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
7199 *x = width;
7200 *y = height;
7202 if (comp) *comp = 3;
7203 if (req_comp == 0) req_comp = 3;
7205 if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
7206 return stbi__errpf("too large", "HDR image is too large");
7208 // Read data
7209 hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
7210 if (!hdr_data)
7211 return stbi__errpf("outofmem", "Out of memory");
7213 // Load image data
7214 // image data is stored as some number of sca
7215 if ( width < 8 || width >= 32768) {
7216 // Read flat data
7217 for (j=0; j < height; ++j) {
7218 for (i=0; i < width; ++i) {
7219 stbi_uc rgbe[4];
7220 main_decode_loop:
7221 stbi__getn(s, rgbe, 4);
7222 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
7223 }
7224 }
7225 } else {
7226 // Read RLE-encoded data
7227 scanline = NULL;
7229 for (j = 0; j < height; ++j) {
7230 c1 = stbi__get8(s);
7231 c2 = stbi__get8(s);
7232 len = stbi__get8(s);
7233 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
7234 // not run-length encoded, so we have to actually use THIS data as a decoded
7235 // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
7236 stbi_uc rgbe[4];
7237 rgbe[0] = (stbi_uc) c1;
7238 rgbe[1] = (stbi_uc) c2;
7239 rgbe[2] = (stbi_uc) len;
7240 rgbe[3] = (stbi_uc) stbi__get8(s);
7241 stbi__hdr_convert(hdr_data, rgbe, req_comp);
7242 i = 1;
7243 j = 0;
7244 STBI_FREE(scanline);
7245 goto main_decode_loop; // yes, this makes no sense
7246 }
7247 len <<= 8;
7248 len |= stbi__get8(s);
7249 if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
7250 if (scanline == NULL) {
7251 scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
7252 if (!scanline) {
7253 STBI_FREE(hdr_data);
7254 return stbi__errpf("outofmem", "Out of memory");
7255 }
7256 }
7258 for (k = 0; k < 4; ++k) {
7259 int nleft;
7260 i = 0;
7261 while ((nleft = width - i) > 0) {
7262 count = stbi__get8(s);
7263 if (count > 128) {
7264 // Run
7265 value = stbi__get8(s);
7266 count -= 128;
7267 if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
7268 for (z = 0; z < count; ++z)
7269 scanline[i++ * 4 + k] = value;
7270 } else {
7271 // Dump
7272 if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
7273 for (z = 0; z < count; ++z)
7274 scanline[i++ * 4 + k] = stbi__get8(s);
7275 }
7276 }
7277 }
7278 for (i=0; i < width; ++i)
7279 stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
7280 }
7281 if (scanline)
7282 STBI_FREE(scanline);
7283 }
7285 return hdr_data;
7286}
7288static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
7289{
7290 char buffer[STBI__HDR_BUFLEN];
7291 char *token;
7292 int valid = 0;
7293 int dummy;
7295 if (!x) x = &dummy;
7296 if (!y) y = &dummy;
7297 if (!comp) comp = &dummy;
7299 if (stbi__hdr_test(s) == 0) {
7300 stbi__rewind( s );
7301 return 0;
7302 }
7304 for(;;) {
7305 token = stbi__hdr_gettoken(s,buffer);
7306 if (token[0] == 0) break;
7307 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
7308 }
7310 if (!valid) {
7311 stbi__rewind( s );
7312 return 0;
7313 }
7314 token = stbi__hdr_gettoken(s,buffer);
7315 if (strncmp(token, "-Y ", 3)) {
7316 stbi__rewind( s );
7317 return 0;
7318 }
7319 token += 3;
7320 *y = (int) strtol(token, &token, 10);
7321 while (*token == ' ') ++token;
7322 if (strncmp(token, "+X ", 3)) {
7323 stbi__rewind( s );
7324 return 0;
7325 }
7326 token += 3;
7327 *x = (int) strtol(token, NULL, 10);
7328 *comp = 3;
7329 return 1;
7330}
7331#endif // STBI_NO_HDR
7333#ifndef STBI_NO_BMP
7334static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
7335{
7336 void *p;
7337 stbi__bmp_data info;
7339 info.all_a = 255;
7340 p = stbi__bmp_parse_header(s, &info);
7341 if (p == NULL) {
7342 stbi__rewind( s );
7343 return 0;
7344 }
7345 if (x) *x = s->img_x;
7346 if (y) *y = s->img_y;
7347 if (comp) {
7348 if (info.bpp == 24 && info.ma == 0xff000000)
7349 *comp = 3;
7350 else
7351 *comp = info.ma ? 4 : 3;
7352 }
7353 return 1;
7354}
7355#endif
7357#ifndef STBI_NO_PSD
7358static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
7359{
7360 int channelCount, dummy, depth;
7361 if (!x) x = &dummy;
7362 if (!y) y = &dummy;
7363 if (!comp) comp = &dummy;
7364 if (stbi__get32be(s) != 0x38425053) {
7365 stbi__rewind( s );
7366 return 0;
7367 }
7368 if (stbi__get16be(s) != 1) {
7369 stbi__rewind( s );
7370 return 0;
7371 }
7372 stbi__skip(s, 6);
7373 channelCount = stbi__get16be(s);
7374 if (channelCount < 0 || channelCount > 16) {
7375 stbi__rewind( s );
7376 return 0;
7377 }
7378 *y = stbi__get32be(s);
7379 *x = stbi__get32be(s);
7380 depth = stbi__get16be(s);
7381 if (depth != 8 && depth != 16) {
7382 stbi__rewind( s );
7383 return 0;
7384 }
7385 if (stbi__get16be(s) != 3) {
7386 stbi__rewind( s );
7387 return 0;
7388 }
7389 *comp = 4;
7390 return 1;
7391}
7393static int stbi__psd_is16(stbi__context *s)
7394{
7395 int channelCount, depth;
7396 if (stbi__get32be(s) != 0x38425053) {
7397 stbi__rewind( s );
7398 return 0;
7399 }
7400 if (stbi__get16be(s) != 1) {
7401 stbi__rewind( s );
7402 return 0;
7403 }
7404 stbi__skip(s, 6);
7405 channelCount = stbi__get16be(s);
7406 if (channelCount < 0 || channelCount > 16) {
7407 stbi__rewind( s );
7408 return 0;
7409 }
7410 STBI_NOTUSED(stbi__get32be(s));
7411 STBI_NOTUSED(stbi__get32be(s));
7412 depth = stbi__get16be(s);
7413 if (depth != 16) {
7414 stbi__rewind( s );
7415 return 0;
7416 }
7417 return 1;
7418}
7419#endif
7421#ifndef STBI_NO_PIC
7422static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
7423{
7424 int act_comp=0,num_packets=0,chained,dummy;
7425 stbi__pic_packet packets[10];
7427 if (!x) x = &dummy;
7428 if (!y) y = &dummy;
7429 if (!comp) comp = &dummy;
7431 if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
7432 stbi__rewind(s);
7433 return 0;
7434 }
7436 stbi__skip(s, 88);
7438 *x = stbi__get16be(s);
7439 *y = stbi__get16be(s);
7440 if (stbi__at_eof(s)) {
7441 stbi__rewind( s);
7442 return 0;
7443 }
7444 if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
7445 stbi__rewind( s );
7446 return 0;
7447 }
7449 stbi__skip(s, 8);
7451 do {
7452 stbi__pic_packet *packet;
7454 if (num_packets==sizeof(packets)/sizeof(packets[0]))
7455 return 0;
7457 packet = &packets[num_packets++];
7458 chained = stbi__get8(s);
7459 packet->size = stbi__get8(s);
7460 packet->type = stbi__get8(s);
7461 packet->channel = stbi__get8(s);
7462 act_comp |= packet->channel;
7464 if (stbi__at_eof(s)) {
7465 stbi__rewind( s );
7466 return 0;
7467 }
7468 if (packet->size != 8) {
7469 stbi__rewind( s );
7470 return 0;
7471 }
7472 } while (chained);
7474 *comp = (act_comp & 0x10 ? 4 : 3);
7476 return 1;
7477}
7478#endif
7480// *************************************************************************************************
7481// Portable Gray Map and Portable Pixel Map loader
7482// by Ken Miller
7483//
7484// PGM: http://netpbm.sourceforge.net/doc/pgm.html
7485// PPM: http://netpbm.sourceforge.net/doc/ppm.html
7486//
7487// Known limitations:
7488// Does not support comments in the header section
7489// Does not support ASCII image data (formats P2 and P3)
7491#ifndef STBI_NO_PNM
7493static int stbi__pnm_test(stbi__context *s)
7494{
7495 char p, t;
7496 p = (char) stbi__get8(s);
7497 t = (char) stbi__get8(s);
7498 if (p != 'P' || (t != '5' && t != '6')) {
7499 stbi__rewind( s );
7500 return 0;
7501 }
7502 return 1;
7503}
7505static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7506{
7507 stbi_uc *out;
7508 STBI_NOTUSED(ri);
7510 ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
7511 if (ri->bits_per_channel == 0)
7512 return 0;
7514 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
7515 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
7517 *x = s->img_x;
7518 *y = s->img_y;
7519 if (comp) *comp = s->img_n;
7521 if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
7522 return stbi__errpuc("too large", "PNM too large");
7524 out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
7525 if (!out) return stbi__errpuc("outofmem", "Out of memory");
7526 if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
7527 STBI_FREE(out);
7528 return stbi__errpuc("bad PNM", "PNM file truncated");
7529 }
7531 if (req_comp && req_comp != s->img_n) {
7532 if (ri->bits_per_channel == 16) {
7533 out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
7534 } else {
7535 out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
7536 }
7537 if (out == NULL) return out; // stbi__convert_format frees input on failure
7538 }
7539 return out;
7540}
7542static int stbi__pnm_isspace(char c)
7543{
7544 return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
7545}
7547static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
7548{
7549 for (;;) {
7550 while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
7551 *c = (char) stbi__get8(s);
7553 if (stbi__at_eof(s) || *c != '#')
7554 break;
7556 while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
7557 *c = (char) stbi__get8(s);
7558 }
7559}
7561static int stbi__pnm_isdigit(char c)
7562{
7563 return c >= '0' && c <= '9';
7564}
7566static int stbi__pnm_getinteger(stbi__context *s, char *c)
7567{
7568 int value = 0;
7570 while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
7571 value = value*10 + (*c - '0');
7572 *c = (char) stbi__get8(s);
7573 if((value > 214748364) || (value == 214748364 && *c > '7'))
7574 return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
7575 }
7577 return value;
7578}
7580static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
7581{
7582 int maxv, dummy;
7583 char c, p, t;
7585 if (!x) x = &dummy;
7586 if (!y) y = &dummy;
7587 if (!comp) comp = &dummy;
7589 stbi__rewind(s);
7591 // Get identifier
7592 p = (char) stbi__get8(s);
7593 t = (char) stbi__get8(s);
7594 if (p != 'P' || (t != '5' && t != '6')) {
7595 stbi__rewind(s);
7596 return 0;
7597 }
7599 *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm
7601 c = (char) stbi__get8(s);
7602 stbi__pnm_skip_whitespace(s, &c);
7604 *x = stbi__pnm_getinteger(s, &c); // read width
7605 if(*x == 0)
7606 return stbi__err("invalid width", "PPM image header had zero or overflowing width");
7607 stbi__pnm_skip_whitespace(s, &c);
7609 *y = stbi__pnm_getinteger(s, &c); // read height
7610 if (*y == 0)
7611 return stbi__err("invalid width", "PPM image header had zero or overflowing width");
7612 stbi__pnm_skip_whitespace(s, &c);
7614 maxv = stbi__pnm_getinteger(s, &c); // read max value
7615 if (maxv > 65535)
7616 return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
7617 else if (maxv > 255)
7618 return 16;
7619 else
7620 return 8;
7621}
7623static int stbi__pnm_is16(stbi__context *s)
7624{
7625 if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
7626 return 1;
7627 return 0;
7628}
7629#endif
7631static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
7632{
7633 #ifndef STBI_NO_JPEG
7634 if (stbi__jpeg_info(s, x, y, comp)) return 1;
7635 #endif
7637 #ifndef STBI_NO_PNG
7638 if (stbi__png_info(s, x, y, comp)) return 1;
7639 #endif
7641 #ifndef STBI_NO_GIF
7642 if (stbi__gif_info(s, x, y, comp)) return 1;
7643 #endif
7645 #ifndef STBI_NO_BMP
7646 if (stbi__bmp_info(s, x, y, comp)) return 1;
7647 #endif
7649 #ifndef STBI_NO_PSD
7650 if (stbi__psd_info(s, x, y, comp)) return 1;
7651 #endif
7653 #ifndef STBI_NO_PIC
7654 if (stbi__pic_info(s, x, y, comp)) return 1;
7655 #endif
7657 #ifndef STBI_NO_PNM
7658 if (stbi__pnm_info(s, x, y, comp)) return 1;
7659 #endif
7661 #ifndef STBI_NO_HDR
7662 if (stbi__hdr_info(s, x, y, comp)) return 1;
7663 #endif
7665 // test tga last because it's a crappy test!
7666 #ifndef STBI_NO_TGA
7667 if (stbi__tga_info(s, x, y, comp))
7668 return 1;
7669 #endif
7670 return stbi__err("unknown image type", "Image not of any known type, or corrupt");
7671}
7673static int stbi__is_16_main(stbi__context *s)
7674{
7675 #ifndef STBI_NO_PNG
7676 if (stbi__png_is16(s)) return 1;
7677 #endif
7679 #ifndef STBI_NO_PSD
7680 if (stbi__psd_is16(s)) return 1;
7681 #endif
7683 #ifndef STBI_NO_PNM
7684 if (stbi__pnm_is16(s)) return 1;
7685 #endif
7686 return 0;
7687}
7689#ifndef STBI_NO_STDIO
7690STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
7691{
7692 FILE *f = stbi__fopen(filename, "rb");
7693 int result;
7694 if (!f) return stbi__err("can't fopen", "Unable to open file");
7695 result = stbi_info_from_file(f, x, y, comp);
7696 fclose(f);
7697 return result;
7698}
7700STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
7701{
7702 int r;
7703 stbi__context s;
7704 long pos = ftell(f);
7705 stbi__start_file(&s, f);
7706 r = stbi__info_main(&s,x,y,comp);
7707 fseek(f,pos,SEEK_SET);
7708 return r;
7709}
7711STBIDEF int stbi_is_16_bit(char const *filename)
7712{
7713 FILE *f = stbi__fopen(filename, "rb");
7714 int result;
7715 if (!f) return stbi__err("can't fopen", "Unable to open file");
7716 result = stbi_is_16_bit_from_file(f);
7717 fclose(f);
7718 return result;
7719}
7721STBIDEF int stbi_is_16_bit_from_file(FILE *f)
7722{
7723 int r;
7724 stbi__context s;
7725 long pos = ftell(f);
7726 stbi__start_file(&s, f);
7727 r = stbi__is_16_main(&s);
7728 fseek(f,pos,SEEK_SET);
7729 return r;
7730}
7731#endif // !STBI_NO_STDIO
7733STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
7734{
7735 stbi__context s;
7736 stbi__start_mem(&s,buffer,len);
7737 return stbi__info_main(&s,x,y,comp);
7738}
7740STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
7741{
7742 stbi__context s;
7743 stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
7744 return stbi__info_main(&s,x,y,comp);
7745}
7747STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
7748{
7749 stbi__context s;
7750 stbi__start_mem(&s,buffer,len);
7751 return stbi__is_16_main(&s);
7752}
7754STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
7755{
7756 stbi__context s;
7757 stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
7758 return stbi__is_16_main(&s);
7759}
7761#endif // STB_IMAGE_IMPLEMENTATION
7763/*
7764 revision history:
7765 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
7766 2.19 (2018-02-11) fix warning
7767 2.18 (2018-01-30) fix warnings
7768 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
7769 1-bit BMP
7770 *_is_16_bit api
7771 avoid warnings
7772 2.16 (2017-07-23) all functions have 16-bit variants;
7773 STBI_NO_STDIO works again;
7774 compilation fixes;
7775 fix rounding in unpremultiply;
7776 optimize vertical flip;
7777 disable raw_len validation;
7778 documentation fixes
7779 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
7780 warning fixes; disable run-time SSE detection on gcc;
7781 uniform handling of optional "return" values;
7782 thread-safe initialization of zlib tables
7783 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
7784 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now
7785 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
7786 2.11 (2016-04-02) allocate large structures on the stack
7787 remove white matting for transparent PSD
7788 fix reported channel count for PNG & BMP
7789 re-enable SSE2 in non-gcc 64-bit
7790 support RGB-formatted JPEG
7791 read 16-bit PNGs (only as 8-bit)
7792 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
7793 2.09 (2016-01-16) allow comments in PNM files
7794 16-bit-per-pixel TGA (not bit-per-component)
7795 info() for TGA could break due to .hdr handling
7796 info() for BMP to shares code instead of sloppy parse
7797 can use STBI_REALLOC_SIZED if allocator doesn't support realloc
7798 code cleanup
7799 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
7800 2.07 (2015-09-13) fix compiler warnings
7801 partial animated GIF support
7802 limited 16-bpc PSD support
7803 #ifdef unused functions
7804 bug with < 92 byte PIC,PNM,HDR,TGA
7805 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value
7806 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning
7807 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit
7808 2.03 (2015-04-12) extra corruption checking (mmozeiko)
7809 stbi_set_flip_vertically_on_load (nguillemot)
7810 fix NEON support; fix mingw support
7811 2.02 (2015-01-19) fix incorrect assert, fix warning
7812 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
7813 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
7814 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
7815 progressive JPEG (stb)
7816 PGM/PPM support (Ken Miller)
7817 STBI_MALLOC,STBI_REALLOC,STBI_FREE
7818 GIF bugfix -- seemingly never worked
7819 STBI_NO_*, STBI_ONLY_*
7820 1.48 (2014-12-14) fix incorrectly-named assert()
7821 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
7822 optimize PNG (ryg)
7823 fix bug in interlaced PNG with user-specified channel count (stb)
7824 1.46 (2014-08-26)
7825 fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
7826 1.45 (2014-08-16)
7827 fix MSVC-ARM internal compiler error by wrapping malloc
7828 1.44 (2014-08-07)
7829 various warning fixes from Ronny Chevalier
7830 1.43 (2014-07-15)
7831 fix MSVC-only compiler problem in code changed in 1.42
7832 1.42 (2014-07-09)
7833 don't define _CRT_SECURE_NO_WARNINGS (affects user code)
7834 fixes to stbi__cleanup_jpeg path
7835 added STBI_ASSERT to avoid requiring assert.h
7836 1.41 (2014-06-25)
7837 fix search&replace from 1.36 that messed up comments/error messages
7838 1.40 (2014-06-22)
7839 fix gcc struct-initialization warning
7840 1.39 (2014-06-15)
7841 fix to TGA optimization when req_comp != number of components in TGA;
7842 fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
7843 add support for BMP version 5 (more ignored fields)
7844 1.38 (2014-06-06)
7845 suppress MSVC warnings on integer casts truncating values
7846 fix accidental rename of 'skip' field of I/O
7847 1.37 (2014-06-04)
7848 remove duplicate typedef
7849 1.36 (2014-06-03)
7850 convert to header file single-file library
7851 if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
7852 1.35 (2014-05-27)
7853 various warnings
7854 fix broken STBI_SIMD path
7855 fix bug where stbi_load_from_file no longer left file pointer in correct place
7856 fix broken non-easy path for 32-bit BMP (possibly never used)
7857 TGA optimization by Arseny Kapoulkine
7858 1.34 (unknown)
7859 use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
7860 1.33 (2011-07-14)
7861 make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
7862 1.32 (2011-07-13)
7863 support for "info" function for all supported filetypes (SpartanJ)
7864 1.31 (2011-06-20)
7865 a few more leak fixes, bug in PNG handling (SpartanJ)
7866 1.30 (2011-06-11)
7867 added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
7868 removed deprecated format-specific test/load functions
7869 removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
7870 error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
7871 fix inefficiency in decoding 32-bit BMP (David Woo)
7872 1.29 (2010-08-16)
7873 various warning fixes from Aurelien Pocheville
7874 1.28 (2010-08-01)
7875 fix bug in GIF palette transparency (SpartanJ)
7876 1.27 (2010-08-01)
7877 cast-to-stbi_uc to fix warnings
7878 1.26 (2010-07-24)
7879 fix bug in file buffering for PNG reported by SpartanJ
7880 1.25 (2010-07-17)
7881 refix trans_data warning (Won Chun)
7882 1.24 (2010-07-12)
7883 perf improvements reading from files on platforms with lock-heavy fgetc()
7884 minor perf improvements for jpeg
7885 deprecated type-specific functions so we'll get feedback if they're needed
7886 attempt to fix trans_data warning (Won Chun)
7887 1.23 fixed bug in iPhone support
7888 1.22 (2010-07-10)
7889 removed image *writing* support
7890 stbi_info support from Jetro Lauha
7891 GIF support from Jean-Marc Lienher
7892 iPhone PNG-extensions from James Brown
7893 warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
7894 1.21 fix use of 'stbi_uc' in header (reported by jon blow)
7895 1.20 added support for Softimage PIC, by Tom Seddon
7896 1.19 bug in interlaced PNG corruption check (found by ryg)
7897 1.18 (2008-08-02)
7898 fix a threading bug (local mutable static)
7899 1.17 support interlaced PNG
7900 1.16 major bugfix - stbi__convert_format converted one too many pixels
7901 1.15 initialize some fields for thread safety
7902 1.14 fix threadsafe conversion bug
7903 header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
7904 1.13 threadsafe
7905 1.12 const qualifiers in the API
7906 1.11 Support installable IDCT, colorspace conversion routines
7907 1.10 Fixes for 64-bit (don't use "unsigned long")
7908 optimized upsampling by Fabian "ryg" Giesen
7909 1.09 Fix format-conversion for PSD code (bad global variables!)
7910 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
7911 1.07 attempt to fix C++ warning/errors again
7912 1.06 attempt to fix C++ warning/errors again
7913 1.05 fix TGA loading to return correct *comp and use good luminance calc
7914 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
7915 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
7916 1.02 support for (subset of) HDR files, float interface for preferred access to them
7917 1.01 fix bug: possible bug in handling right-side up bmps... not sure
7918 fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
7919 1.00 interface to zlib that skips zlib header
7920 0.99 correct handling of alpha in palette
7921 0.98 TGA loader by lonesock; dynamically add loaders (untested)
7922 0.97 jpeg errors on too large a file; also catch another malloc failure
7923 0.96 fix detection of invalid v value - particleman@mollyrocket forum
7924 0.95 during header scan, seek to markers in case of padding
7925 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
7926 0.93 handle jpegtran output; verbose errors
7927 0.92 read 4,8,16,24,32-bit BMP files of several formats
7928 0.91 output 24-bit Windows 3.0 BMP files
7929 0.90 fix a few more warnings; bump version number to approach 1.0
7930 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
7931 0.60 fix compiling as c++
7932 0.59 fix warnings: merge Dave Moore's -Wall fixes
7933 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
7934 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
7935 0.56 fix bug: zlib uncompressed mode len vs. nlen
7936 0.55 fix bug: restart_interval not initialized to 0
7937 0.54 allow NULL for 'int *comp'
7938 0.53 fix bug in png 3->4; speedup png decoding
7939 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
7940 0.51 obey req_comp requests, 1-component jpegs return as 1-component,
7941 on 'test' only check type, not whether we support this variant
7942 0.50 (2006-11-19)
7943 first released version
7944*/
7947/*
7948------------------------------------------------------------------------------
7949This software is available under 2 licenses -- choose whichever you prefer.
7950------------------------------------------------------------------------------
7951ALTERNATIVE A - MIT License
7952Copyright (c) 2017 Sean Barrett
7953Permission is hereby granted, free of charge, to any person obtaining a copy of
7954this software and associated documentation files (the "Software"), to deal in
7955the Software without restriction, including without limitation the rights to
7956use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
7957of the Software, and to permit persons to whom the Software is furnished to do
7958so, subject to the following conditions:
7959The above copyright notice and this permission notice shall be included in all
7960copies or substantial portions of the Software.
7961THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
7962IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
7963FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
7964AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
7965LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
7966OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
7967SOFTWARE.
7968------------------------------------------------------------------------------
7969ALTERNATIVE B - Public Domain (www.unlicense.org)
7970This is free and unencumbered software released into the public domain.
7971Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
7972software, either in source code form or as a compiled binary, for any purpose,
7973commercial or non-commercial, and by any means.
7974In jurisdictions that recognize copyright laws, the author or authors of this
7975software dedicate any and all copyright interest in the software to the public
7976domain. We make this dedication for the benefit of the public at large and to
7977the detriment of our heirs and successors. We intend this dedication to be an
7978overt act of relinquishment in perpetuity of all present and future rights to
7979this software under copyright law.
7980THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
7981IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
7982FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
7983AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
7984ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
7985WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
7986------------------------------------------------------------------------------
7987*/
index : raylib-jai
---