suwako / ShaderPlayground

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