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