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