1 /* stb_image - v1.39 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
2 when you control the images you're loading
3 no warranty implied; use at your own risk
4
5 Do this:
6 #define STB_IMAGE_IMPLEMENTATION
7 before you include this file in *one* C or C++ file to create the implementation.
8
9 QUICK NOTES:
10 Primarily of interest to game developers and other people who can
11 avoid problematic images and only need the trivial interface
12
13 JPEG baseline (no JPEG progressive)
14 PNG 8-bit-per-channel only
15
16 TGA (not sure what subset, if a subset)
17 BMP non-1bpp, non-RLE
18 PSD (composited view only, no extra channels)
19
20 GIF (*comp always reports as 4-channel)
21 HDR (radiance rgbE format)
22 PIC (Softimage PIC)
23
24 - stbi__jpeg_huff_decode from memory or through FILE (define STBI_NO_STDIO to remove code)
25 - stbi__jpeg_huff_decode from arbitrary I/O callbacks
26 - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
27
28 Latest revisions:
29 1.39 (2014-06-15) TGA optimization fix, multiple BMP fixes
30 1.38 (2014-06-06) suppress MSVC run-time warnings, fix accidental rename of 'skip'
31 1.37 (2014-06-04) remove duplicate typedef
32 1.36 (2014-06-03) converted to header file, allow reading incorrect iphoned-images without iphone flag
33 1.35 (2014-05-27) warnings, bugfixes, TGA optimization, etc
34 1.34 (unknown ) warning fix
35 1.33 (2011-07-14) minor fixes suggested by Dave Moore
36
37 See end of file for full revision history.
38
39 TODO:
40 stbi_info support for BMP,PSD,HDR,PIC
41
42
43 ============================ Contributors =========================
44
45 Image formats Bug fixes & warning fixes
46 Sean Barrett (jpeg, png, bmp) Marc LeBlanc
47 Nicolas Schulz (hdr, psd) Christpher Lloyd
48 Jonathan Dummer (tga) Dave Moore
49 Jean-Marc Lienher (gif) Won Chun
50 Tom Seddon (pic) the Horde3D community
51 Thatcher Ulrich (psd) Janez Zemva
52 Jonathan Blow
53 Laurent Gomila
54 Extensions, features Aruelien Pocheville
55 Jetro Lauha (stbi_info) Ryamond Barbiero
56 James "moose2000" Brown (iPhone PNG) David Woo
57 Ben "Disch" Wenger (io callbacks) Roy Eltham
58 Martin "SpartanJ" Golini Luke Graham
59 Thomas Ruf
60 John Bartholomew
61 Optimizations & bugfixes Ken Hamada
62 Fabian "ryg" Giesen Cort Stratton
63 Arseny Kapoulkine Blazej Dariusz Roszkowski
64 Thibault Reuille
65 If your name should be here but Paul Du Bois
66 isn't, let Sean know. Guillaume George
67 Jerry Jansson
68 Hayaki Saito
69 */
70
71 #ifndef STBI_INCLUDE_STB_IMAGE_H
72 #define STBI_INCLUDE_STB_IMAGE_H
73
74 // Limitations:
75 // - no jpeg progressive support
76 // - non-HDR formats support 8-bit samples only (jpeg, png)
77 // - no delayed line count (jpeg) -- IJG doesn't support either
78 // - no 1-bit BMP
79 // - GIF always returns *comp=4
80 //
81 // Basic usage (see HDR discussion below):
82 // int x,y,n;
83 // unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
84 // // ... process data if not NULL ...
85 // // ... x = width, y = height, n = # 8-bit components per pixel ...
86 // // ... replace '0' with '1'..'4' to force that many components per pixel
87 // // ... but 'n' will always be the number that it would have been if you said 0
88 // stbi_image_free(data)
89 //
90 // Standard parameters:
91 // int *x -- outputs image width in pixels
92 // int *y -- outputs image height in pixels
93 // int *comp -- outputs # of image components in image file
94 // int req_comp -- if non-zero, # of image components requested in result
95 //
96 // The return value from an image loader is an 'unsigned char *' which points
97 // to the pixel data. The pixel data consists of *y scanlines of *x pixels,
98 // with each pixel consisting of N interleaved 8-bit components; the first
99 // pixel pointed to is top-left-most in the image. There is no padding between
100 // image scanlines or between pixels, regardless of format. The number of
101 // components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
102 // If req_comp is non-zero, *comp has the number of components that _would_
103 // have been output otherwise. E.g. if you set req_comp to 4, you will always
104 // get RGBA output, but you can check *comp to easily see if it's opaque.
105 //
106 // An output image with N components has the following components interleaved
107 // in this order in each pixel:
108 //
109 // N=#comp components
110 // 1 grey
111 // 2 grey, alpha
112 // 3 red, green, blue
113 // 4 red, green, blue, alpha
114 //
115 // If image loading fails for any reason, the return value will be NULL,
116 // and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
117 // can be queried for an extremely brief, end-user unfriendly explanation
118 // of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
119 // compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
120 // more user-friendly ones.
121 //
122 // Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
123 //
124 // ===========================================================================
125 //
126 // iPhone PNG support:
127 //
128 // By default we convert iphone-formatted PNGs back to RGB; nominally they
129 // would silently load as BGR, except the existing code should have just
130 // failed on such iPhone PNGs. But you can disable this conversion by
131 // by calling stbi_convert_iphone_png_to_rgb(0), in which case
132 // you will always just get the native iphone "format" through.
133 //
134 // Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
135 // pixel to remove any premultiplied alpha *only* if the image file explicitly
136 // says there's premultiplied data (currently only happens in iPhone images,
137 // and only if iPhone convert-to-rgb processing is on).
138 //
139 // ===========================================================================
140 //
141 // HDR image support (disable by defining STBI_NO_HDR)
142 //
143 // stb_image now supports loading HDR images in general, and currently
144 // the Radiance .HDR file format, although the support is provided
145 // generically. You can still load any file through the existing interface;
146 // if you attempt to load an HDR file, it will be automatically remapped to
147 // LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
148 // both of these constants can be reconfigured through this interface:
149 //
150 // stbi_hdr_to_ldr_gamma(2.2f);
151 // stbi_hdr_to_ldr_scale(1.0f);
152 //
153 // (note, do not use _inverse_ constants; stbi_image will invert them
154 // appropriately).
155 //
156 // Additionally, there is a new, parallel interface for loading files as
157 // (linear) floats to preserve the full dynamic range:
158 //
159 // float *data = stbi_loadf(filename, &x, &y, &n, 0);
160 //
161 // If you load LDR images through this interface, those images will
162 // be promoted to floating point values, run through the inverse of
163 // constants corresponding to the above:
164 //
165 // stbi_ldr_to_hdr_scale(1.0f);
166 // stbi_ldr_to_hdr_gamma(2.2f);
167 //
168 // Finally, given a filename (or an open file or memory block--see header
169 // file for details) containing image data, you can query for the "most
170 // appropriate" interface to use (that is, whether the image is HDR or
171 // not), using:
172 //
173 // stbi_is_hdr(char *filename);
174 //
175 // ===========================================================================
176 //
177 // I/O callbacks
178 //
179 // I/O callbacks allow you to read from arbitrary sources, like packaged
180 // files or some other source. Data read from callbacks are processed
181 // through a small internal buffer (currently 128 bytes) to try to reduce
182 // overhead.
183 //
184 // The three functions you must define are "read" (reads some bytes of data),
185 // "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
186
187
188 #ifndef STBI_NO_STDIO
189
190 #if defined(_MSC_VER) && _MSC_VER >= 1400
191 #define _CRT_SECURE_NO_WARNINGS // suppress warnings about fopen()
192 #pragma warning(push)
193 #pragma warning(disable:4996) // suppress even more warnings about fopen()
194 #endif
195 #include <stdio.h>
196 #endif // STBI_NO_STDIO
197
198 #define STBI_VERSION 1
199
200 enum
201 {
202 STBI_default = 0, // only used for req_comp
203
204 STBI_grey = 1,
205 STBI_grey_alpha = 2,
206 STBI_rgb = 3,
207 STBI_rgb_alpha = 4
208 };
209
210 typedef unsigned char stbi_uc;
211
212 #ifdef __cplusplus
213 extern "C" {
214 #endif
215
216 #ifdef STB_IMAGE_STATIC
217 #define STBIDEF static
218 #else
219 #define STBIDEF extern
220 #endif
221
222 //////////////////////////////////////////////////////////////////////////////
223 //
224 // PRIMARY API - works on images of any type
225 //
226
227 //
228 // load image by filename, open file, or memory buffer
229 //
230
231 STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
232
233 #ifndef STBI_NO_STDIO
234 STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp);
235 STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
236 // for stbi_load_from_file, file pointer is left pointing immediately after image
237 #endif
238
239 typedef struct
240 {
241 int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
242 void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
243 int (*eof) (void *user); // returns nonzero if we are at end of file/data
244 } stbi_io_callbacks;
245
246 STBIDEF stbi_uc *stbi_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
247
248 #ifndef STBI_NO_HDR
249 STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
250
251 #ifndef STBI_NO_STDIO
252 STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp);
253 STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
254 #endif
255
256 STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
257
258 STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
259 STBIDEF void stbi_hdr_to_ldr_scale(float scale);
260
261 STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
262 STBIDEF void stbi_ldr_to_hdr_scale(float scale);
263 #endif // STBI_NO_HDR
264
265 // stbi_is_hdr is always defined
266 STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
267 STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
268 #ifndef STBI_NO_STDIO
269 STBIDEF int stbi_is_hdr (char const *filename);
270 STBIDEF int stbi_is_hdr_from_file(FILE *f);
271 #endif // STBI_NO_STDIO
272
273
274 // get a VERY brief reason for failure
275 // NOT THREADSAFE
276 STBIDEF const char *stbi_failure_reason (void);
277
278 // free the loaded image -- this is just free()
279 STBIDEF void stbi_image_free (void *retval_from_stbi_load);
280
281 // get image dimensions & components without fully decoding
282 STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
283 STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
284
285 #ifndef STBI_NO_STDIO
286 STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);
287 STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
288
289 #endif
290
291
292
293 // for image formats that explicitly notate that they have premultiplied alpha,
294 // we just return the colors as stored in the file. set this flag to force
295 // unpremultiplication. results are undefined if the unpremultiply overflow.
296 STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
297
298 // indicate whether we should process iphone images back to canonical format,
299 // or just pass them through "as-is"
300 STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
301
302
303 // ZLIB client - used by PNG, available for other purposes
304
305 STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
306 STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
307 STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
308 STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
309
310 STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
311 STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
312
313
314 // define faster low-level operations (typically SIMD support)
315 #ifdef STBI_SIMD
316 typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
317 // compute an integer IDCT on "input"
318 // input[x] = data[x] * dequantize[x]
319 // write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
320 // CLAMP results to 0..255
321 typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
322 // compute a conversion from YCbCr to RGB
323 // 'count' pixels
324 // write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
325 // y: Y input channel
326 // cb: Cb input channel; scale/biased to be 0..255
327 // cr: Cr input channel; scale/biased to be 0..255
328
329 STBIDEF void stbi_install_idct(stbi_idct_8x8 func);
330 STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
331 #endif // STBI_SIMD
332
333
334 #ifdef __cplusplus
335 }
336 #endif
337
338 //
339 //
340 //// end header file /////////////////////////////////////////////////////
341 #endif // STBI_INCLUDE_STB_IMAGE_H
342
343 #ifdef STB_IMAGE_IMPLEMENTATION
344
345 #ifndef STBI_NO_HDR
346 #include <math.h> // ldexp
347 #include <string.h> // strcmp, strtok
348 #endif
349
350 #ifndef STBI_NO_STDIO
351 #include <stdio.h>
352 #endif
353 #include <stdlib.h>
354 #include <memory.h>
355 #include <assert.h>
356 #include <stdarg.h>
357 #include <stddef.h> // ptrdiff_t on osx
358
359 #ifndef _MSC_VER
360 #ifdef __cplusplus
361 #define stbi_inline inline
362 #else
363 #define stbi_inline
364 #endif
365 #else
366 #define stbi_inline __forceinline
367 #endif
368
369
370 #ifdef _MSC_VER
371 typedef unsigned short stbi__uint16;
372 typedef signed short stbi__int16;
373 typedef unsigned int stbi__uint32;
374 typedef signed int stbi__int32;
375 #else
376 #include <stdint.h>
377 typedef uint16_t stbi__uint16;
378 typedef int16_t stbi__int16;
379 typedef uint32_t stbi__uint32;
380 typedef int32_t stbi__int32;
381 #endif
382
383 // should produce compiler error if size is wrong
384 typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
385
386 #ifdef _MSC_VER
387 #define STBI_NOTUSED(v) (void)(v)
388 #else
389 #define STBI_NOTUSED(v) (void)sizeof(v)
390 #endif
391
392 #ifdef _MSC_VER
393 #define STBI_HAS_LROTL
394 #endif
395
396 #ifdef STBI_HAS_LROTL
397 #define stbi_lrot(x,y) _lrotl(x,y)
398 #else
399 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
400 #endif
401
402 ///////////////////////////////////////////////
403 //
404 // stbi__context struct and start_xxx functions
405
406 // stbi__context structure is our basic context used by all images, so it
407 // contains all the IO context, plus some basic image information
408 typedef struct
409 {
410 stbi__uint32 img_x, img_y;
411 int img_n, img_out_n;
412
413 stbi_io_callbacks io;
414 void *io_user_data;
415
416 int read_from_callbacks;
417 int buflen;
418 stbi_uc buffer_start[128];
419
420 stbi_uc *img_buffer, *img_buffer_end;
421 stbi_uc *img_buffer_original;
422 } stbi__context;
423
424
425 static void stbi__refill_buffer(stbi__context *s);
426
427 // initialize a memory-stbi__jpeg_huff_decode context
stbi__start_mem(stbi__context * s,stbi_uc const * buffer,int len)428 static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
429 {
430 s->io.read = NULL;
431 s->read_from_callbacks = 0;
432 s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
433 s->img_buffer_end = (stbi_uc *) buffer+len;
434 }
435
436 // initialize a callback-based context
stbi__start_callbacks(stbi__context * s,stbi_io_callbacks * c,void * user)437 static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
438 {
439 s->io = *c;
440 s->io_user_data = user;
441 s->buflen = sizeof(s->buffer_start);
442 s->read_from_callbacks = 1;
443 s->img_buffer_original = s->buffer_start;
444 stbi__refill_buffer(s);
445 }
446
447 #ifndef STBI_NO_STDIO
448
stbi__stdio_read(void * user,char * data,int size)449 static int stbi__stdio_read(void *user, char *data, int size)
450 {
451 return (int) fread(data,1,size,(FILE*) user);
452 }
453
stbi__stdio_skip(void * user,int n)454 static void stbi__stdio_skip(void *user, int n)
455 {
456 fseek((FILE*) user, n, SEEK_CUR);
457 }
458
stbi__stdio_eof(void * user)459 static int stbi__stdio_eof(void *user)
460 {
461 return feof((FILE*) user);
462 }
463
464 static stbi_io_callbacks stbi__stdio_callbacks =
465 {
466 stbi__stdio_read,
467 stbi__stdio_skip,
468 stbi__stdio_eof,
469 };
470
stbi__start_file(stbi__context * s,FILE * f)471 static void stbi__start_file(stbi__context *s, FILE *f)
472 {
473 stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
474 }
475
476 //static void stop_file(stbi__context *s) { }
477
478 #endif // !STBI_NO_STDIO
479
stbi__rewind(stbi__context * s)480 static void stbi__rewind(stbi__context *s)
481 {
482 // conceptually rewind SHOULD rewind to the beginning of the stream,
483 // but we just rewind to the beginning of the initial buffer, because
484 // we only use it after doing 'test', which only ever looks at at most 92 bytes
485 s->img_buffer = s->img_buffer_original;
486 }
487
488 static int stbi__jpeg_test(stbi__context *s);
489 static stbi_uc *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
490 static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
491 static int stbi__png_test(stbi__context *s);
492 static stbi_uc *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
493 static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
494 static int stbi__bmp_test(stbi__context *s);
495 static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
496 static int stbi__tga_test(stbi__context *s);
497 static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
498 static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
499 static int stbi__psd_test(stbi__context *s);
500 static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
501 #ifndef STBI_NO_HDR
502 static int stbi__hdr_test(stbi__context *s);
503 static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
504 #endif
505 static int stbi__pic_test(stbi__context *s);
506 static stbi_uc *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
507 static int stbi__gif_test(stbi__context *s);
508 static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp);
509 static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
510
511
512 // this is not threadsafe
513 static const char *stbi__g_failure_reason;
514
stbi_failure_reason(void)515 STBIDEF const char *stbi_failure_reason(void)
516 {
517 return stbi__g_failure_reason;
518 }
519
stbi__err(const char * str)520 static int stbi__err(const char *str)
521 {
522 stbi__g_failure_reason = str;
523 return 0;
524 }
525
526 // stbi__err - error
527 // stbi__errpf - error returning pointer to float
528 // stbi__errpuc - error returning pointer to unsigned char
529
530 #ifdef STBI_NO_FAILURE_STRINGS
531 #define stbi__err(x,y) 0
532 #elif defined(STBI_FAILURE_USERMSG)
533 #define stbi__err(x,y) stbi__err(y)
534 #else
535 #define stbi__err(x,y) stbi__err(x)
536 #endif
537
538 #define stbi__errpf(x,y) ((float *) (stbi__err(x,y)?NULL:NULL))
539 #define stbi__errpuc(x,y) ((unsigned char *) (stbi__err(x,y)?NULL:NULL))
540
stbi_image_free(void * retval_from_stbi_load)541 STBIDEF void stbi_image_free(void *retval_from_stbi_load)
542 {
543 free(retval_from_stbi_load);
544 }
545
546 #ifndef STBI_NO_HDR
547 static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
548 static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
549 #endif
550
stbi_load_main(stbi__context * s,int * x,int * y,int * comp,int req_comp)551 static unsigned char *stbi_load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
552 {
553 if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp);
554 if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp);
555 if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp);
556 if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp);
557 if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp);
558 if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp);
559
560 #ifndef STBI_NO_HDR
561 if (stbi__hdr_test(s)) {
562 float *hdr = stbi__hdr_load(s, x,y,comp,req_comp);
563 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
564 }
565 #endif
566
567 // test tga last because it's a crappy test!
568 if (stbi__tga_test(s))
569 return stbi__tga_load(s,x,y,comp,req_comp);
570 return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
571 }
572
573 #ifndef STBI_NO_STDIO
stbi_load(char const * filename,int * x,int * y,int * comp,int req_comp)574 STBIDEF unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
575 {
576 FILE *f = fopen(filename, "rb");
577 unsigned char *result;
578 if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
579 result = stbi_load_from_file(f,x,y,comp,req_comp);
580 fclose(f);
581 return result;
582 }
583
stbi_load_from_file(FILE * f,int * x,int * y,int * comp,int req_comp)584 STBIDEF unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
585 {
586 unsigned char *result;
587 stbi__context s;
588 stbi__start_file(&s,f);
589 result = stbi_load_main(&s,x,y,comp,req_comp);
590 if (result) {
591 // need to 'unget' all the characters in the IO buffer
592 fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
593 }
594 return result;
595 }
596 #endif //!STBI_NO_STDIO
597
stbi_load_from_memory(stbi_uc const * buffer,int len,int * x,int * y,int * comp,int req_comp)598 STBIDEF unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
599 {
600 stbi__context s;
601 stbi__start_mem(&s,buffer,len);
602 return stbi_load_main(&s,x,y,comp,req_comp);
603 }
604
stbi_load_from_callbacks(stbi_io_callbacks const * clbk,void * user,int * x,int * y,int * comp,int req_comp)605 unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
606 {
607 stbi__context s;
608 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
609 return stbi_load_main(&s,x,y,comp,req_comp);
610 }
611
612 #ifndef STBI_NO_HDR
613
stbi_loadf_main(stbi__context * s,int * x,int * y,int * comp,int req_comp)614 float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
615 {
616 unsigned char *data;
617 #ifndef STBI_NO_HDR
618 if (stbi__hdr_test(s))
619 return stbi__hdr_load(s,x,y,comp,req_comp);
620 #endif
621 data = stbi_load_main(s, x, y, comp, req_comp);
622 if (data)
623 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
624 return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
625 }
626
stbi_loadf_from_memory(stbi_uc const * buffer,int len,int * x,int * y,int * comp,int req_comp)627 float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
628 {
629 stbi__context s;
630 stbi__start_mem(&s,buffer,len);
631 return stbi_loadf_main(&s,x,y,comp,req_comp);
632 }
633
stbi_loadf_from_callbacks(stbi_io_callbacks const * clbk,void * user,int * x,int * y,int * comp,int req_comp)634 float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
635 {
636 stbi__context s;
637 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
638 return stbi_loadf_main(&s,x,y,comp,req_comp);
639 }
640
641 #ifndef STBI_NO_STDIO
stbi_loadf(char const * filename,int * x,int * y,int * comp,int req_comp)642 float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
643 {
644 FILE *f = fopen(filename, "rb");
645 float *result;
646 if (!f) return stbi__errpf("can't fopen", "Unable to open file");
647 result = stbi_loadf_from_file(f,x,y,comp,req_comp);
648 fclose(f);
649 return result;
650 }
651
stbi_loadf_from_file(FILE * f,int * x,int * y,int * comp,int req_comp)652 float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
653 {
654 stbi__context s;
655 stbi__start_file(&s,f);
656 return stbi_loadf_main(&s,x,y,comp,req_comp);
657 }
658 #endif // !STBI_NO_STDIO
659
660 #endif // !STBI_NO_HDR
661
662 // these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
663 // defined, for API simplicity; if STBI_NO_HDR is defined, it always
664 // reports false!
665
stbi_is_hdr_from_memory(stbi_uc const * buffer,int len)666 int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
667 {
668 #ifndef STBI_NO_HDR
669 stbi__context s;
670 stbi__start_mem(&s,buffer,len);
671 return stbi__hdr_test(&s);
672 #else
673 STBI_NOTUSED(buffer);
674 STBI_NOTUSED(len);
675 return 0;
676 #endif
677 }
678
679 #ifndef STBI_NO_STDIO
stbi_is_hdr(char const * filename)680 STBIDEF int stbi_is_hdr (char const *filename)
681 {
682 FILE *f = fopen(filename, "rb");
683 int result=0;
684 if (f) {
685 result = stbi_is_hdr_from_file(f);
686 fclose(f);
687 }
688 return result;
689 }
690
stbi_is_hdr_from_file(FILE * f)691 STBIDEF int stbi_is_hdr_from_file(FILE *f)
692 {
693 #ifndef STBI_NO_HDR
694 stbi__context s;
695 stbi__start_file(&s,f);
696 return stbi__hdr_test(&s);
697 #else
698 return 0;
699 #endif
700 }
701 #endif // !STBI_NO_STDIO
702
stbi_is_hdr_from_callbacks(stbi_io_callbacks const * clbk,void * user)703 STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
704 {
705 #ifndef STBI_NO_HDR
706 stbi__context s;
707 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
708 return stbi__hdr_test(&s);
709 #else
710 return 0;
711 #endif
712 }
713
714 #ifndef STBI_NO_HDR
715 static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
716 static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
717
stbi_hdr_to_ldr_gamma(float gamma)718 void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
stbi_hdr_to_ldr_scale(float scale)719 void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
720
stbi_ldr_to_hdr_gamma(float gamma)721 void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
stbi_ldr_to_hdr_scale(float scale)722 void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
723 #endif
724
725
726 //////////////////////////////////////////////////////////////////////////////
727 //
728 // Common code used by all image loaders
729 //
730
731 enum
732 {
733 SCAN_load=0,
734 SCAN_type,
735 SCAN_header
736 };
737
stbi__refill_buffer(stbi__context * s)738 static void stbi__refill_buffer(stbi__context *s)
739 {
740 int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
741 if (n == 0) {
742 // at end of file, treat same as if from memory, but need to handle case
743 // where s->img_buffer isn't pointing to safe memory, stbi__err.g. 0-byte file
744 s->read_from_callbacks = 0;
745 s->img_buffer = s->buffer_start;
746 s->img_buffer_end = s->buffer_start+1;
747 *s->img_buffer = 0;
748 } else {
749 s->img_buffer = s->buffer_start;
750 s->img_buffer_end = s->buffer_start + n;
751 }
752 }
753
stbi__get8(stbi__context * s)754 stbi_inline static stbi_uc stbi__get8(stbi__context *s)
755 {
756 if (s->img_buffer < s->img_buffer_end)
757 return *s->img_buffer++;
758 if (s->read_from_callbacks) {
759 stbi__refill_buffer(s);
760 return *s->img_buffer++;
761 }
762 return 0;
763 }
764
stbi__at_eof(stbi__context * s)765 stbi_inline static int stbi__at_eof(stbi__context *s)
766 {
767 if (s->io.read) {
768 if (!(s->io.eof)(s->io_user_data)) return 0;
769 // if feof() is true, check if buffer = end
770 // special case: we've only got the special 0 character at the end
771 if (s->read_from_callbacks == 0) return 1;
772 }
773
774 return s->img_buffer >= s->img_buffer_end;
775 }
776
stbi__skip(stbi__context * s,int n)777 static void stbi__skip(stbi__context *s, int n)
778 {
779 if (s->io.read) {
780 int blen = (int) (s->img_buffer_end - s->img_buffer);
781 if (blen < n) {
782 s->img_buffer = s->img_buffer_end;
783 (s->io.skip)(s->io_user_data, n - blen);
784 return;
785 }
786 }
787 s->img_buffer += n;
788 }
789
stbi__getn(stbi__context * s,stbi_uc * buffer,int n)790 static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
791 {
792 if (s->io.read) {
793 int blen = (int) (s->img_buffer_end - s->img_buffer);
794 if (blen < n) {
795 int res, count;
796
797 memcpy(buffer, s->img_buffer, blen);
798
799 count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
800 res = (count == (n-blen));
801 s->img_buffer = s->img_buffer_end;
802 return res;
803 }
804 }
805
806 if (s->img_buffer+n <= s->img_buffer_end) {
807 memcpy(buffer, s->img_buffer, n);
808 s->img_buffer += n;
809 return 1;
810 } else
811 return 0;
812 }
813
stbi__get16be(stbi__context * s)814 static int stbi__get16be(stbi__context *s)
815 {
816 int z = stbi__get8(s);
817 return (z << 8) + stbi__get8(s);
818 }
819
stbi__get32be(stbi__context * s)820 static stbi__uint32 stbi__get32be(stbi__context *s)
821 {
822 stbi__uint32 z = stbi__get16be(s);
823 return (z << 16) + stbi__get16be(s);
824 }
825
stbi__get16le(stbi__context * s)826 static int stbi__get16le(stbi__context *s)
827 {
828 int z = stbi__get8(s);
829 return z + (stbi__get8(s) << 8);
830 }
831
stbi__get32le(stbi__context * s)832 static stbi__uint32 stbi__get32le(stbi__context *s)
833 {
834 stbi__uint32 z = stbi__get16le(s);
835 return z + (stbi__get16le(s) << 16);
836 }
837
838 //////////////////////////////////////////////////////////////////////////////
839 //
840 // generic converter from built-in img_n to req_comp
841 // individual types do this automatically as much as possible (stbi__err.g. jpeg
842 // does all cases internally since it needs to colorspace convert anyway,
843 // and it never has alpha, so very few cases ). png can automatically
844 // interleave an alpha=255 channel, but falls back to this for other cases
845 //
846 // assume data buffer is malloced, so malloc a new one and free that one
847 // only failure mode is malloc failing
848
stbi__compute_y(int r,int g,int b)849 static stbi_uc stbi__compute_y(int r, int g, int b)
850 {
851 return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
852 }
853
stbi__convert_format(unsigned char * data,int img_n,int req_comp,unsigned int x,unsigned int y)854 static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
855 {
856 int i,j;
857 unsigned char *good;
858
859 if (req_comp == img_n) return data;
860 assert(req_comp >= 1 && req_comp <= 4);
861
862 good = (unsigned char *) malloc(req_comp * x * y);
863 if (good == NULL) {
864 free(data);
865 return stbi__errpuc("outofmem", "Out of memory");
866 }
867
868 for (j=0; j < (int) y; ++j) {
869 unsigned char *src = data + j * x * img_n ;
870 unsigned char *dest = good + j * x * req_comp;
871
872 #define COMBO(a,b) ((a)*8+(b))
873 #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
874 // convert source image with img_n components to one with req_comp components;
875 // avoid switch per pixel, so use switch per scanline and massive macros
876 switch (COMBO(img_n, req_comp)) {
877 CASE(1,2) dest[0]=src[0], dest[1]=255; break;
878 CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
879 CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
880 CASE(2,1) dest[0]=src[0]; break;
881 CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
882 CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
883 CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
884 CASE(3,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
885 CASE(3,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
886 CASE(4,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
887 CASE(4,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
888 CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
889 default: assert(0);
890 }
891 #undef CASE
892 }
893
894 free(data);
895 return good;
896 }
897
898 #ifndef STBI_NO_HDR
stbi__ldr_to_hdr(stbi_uc * data,int x,int y,int comp)899 static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
900 {
901 int i,k,n;
902 float *output = (float *) malloc(x * y * comp * sizeof(float));
903 if (output == NULL) { free(data); return stbi__errpf("outofmem", "Out of memory"); }
904 // compute number of non-alpha components
905 if (comp & 1) n = comp; else n = comp-1;
906 for (i=0; i < x*y; ++i) {
907 for (k=0; k < n; ++k) {
908 output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
909 }
910 if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
911 }
912 free(data);
913 return output;
914 }
915
916 #define stbi__float2int(x) ((int) (x))
stbi__hdr_to_ldr(float * data,int x,int y,int comp)917 static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
918 {
919 int i,k,n;
920 stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
921 if (output == NULL) { free(data); return stbi__errpuc("outofmem", "Out of memory"); }
922 // compute number of non-alpha components
923 if (comp & 1) n = comp; else n = comp-1;
924 for (i=0; i < x*y; ++i) {
925 for (k=0; k < n; ++k) {
926 float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
927 if (z < 0) z = 0;
928 if (z > 255) z = 255;
929 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
930 }
931 if (k < comp) {
932 float z = data[i*comp+k] * 255 + 0.5f;
933 if (z < 0) z = 0;
934 if (z > 255) z = 255;
935 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
936 }
937 }
938 free(data);
939 return output;
940 }
941 #endif
942
943 //////////////////////////////////////////////////////////////////////////////
944 //
945 // "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
946 //
947 // simple implementation
948 // - channel subsampling of at most 2 in each dimension
949 // - doesn't support delayed output of y-dimension
950 // - simple interface (only one output format: 8-bit interleaved RGB)
951 // - doesn't try to recover corrupt jpegs
952 // - doesn't allow partial loading, loading multiple at once
953 // - still fast on x86 (copying globals into locals doesn't help x86)
954 // - allocates lots of intermediate memory (full size of all components)
955 // - non-interleaved case requires this anyway
956 // - allows good upsampling (see next)
957 // high-quality
958 // - upsampled channels are bilinearly interpolated, even across blocks
959 // - quality integer IDCT derived from IJG's 'slow'
960 // performance
961 // - fast huffman; reasonable integer IDCT
962 // - uses a lot of intermediate memory, could cache poorly
963 // - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
964 // stb_jpeg: 1.34 seconds (MSVC6, default release build)
965 // stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro)
966 // IJL11.dll: 1.08 seconds (compiled by intel)
967 // IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG)
968 // IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro)
969
970 // huffman decoding acceleration
971 #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
972
973 typedef struct
974 {
975 stbi_uc fast[1 << FAST_BITS];
976 // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
977 stbi__uint16 code[256];
978 stbi_uc values[256];
979 stbi_uc size[257];
980 unsigned int maxcode[18];
981 int delta[17]; // old 'firstsymbol' - old 'firstcode'
982 } stbi__huffman;
983
984 typedef struct
985 {
986 #ifdef STBI_SIMD
987 unsigned short dequant2[4][64];
988 #endif
989 stbi__context *s;
990 stbi__huffman huff_dc[4];
991 stbi__huffman huff_ac[4];
992 stbi_uc dequant[4][64];
993
994 // sizes for components, interleaved MCUs
995 int img_h_max, img_v_max;
996 int img_mcu_x, img_mcu_y;
997 int img_mcu_w, img_mcu_h;
998
999 // definition of jpeg image component
1000 struct
1001 {
1002 int id;
1003 int h,v;
1004 int tq;
1005 int hd,ha;
1006 int dc_pred;
1007
1008 int x,y,w2,h2;
1009 stbi_uc *data;
1010 void *raw_data;
1011 stbi_uc *linebuf;
1012 } img_comp[4];
1013
1014 stbi__uint32 code_buffer; // jpeg entropy-coded buffer
1015 int code_bits; // number of valid bits
1016 unsigned char marker; // marker seen while filling entropy buffer
1017 int nomore; // flag if we saw a marker so must stop
1018
1019 int scan_n, order[4];
1020 int restart_interval, todo;
1021 } stbi__jpeg;
1022
stbi__build_huffman(stbi__huffman * h,int * count)1023 static int stbi__build_huffman(stbi__huffman *h, int *count)
1024 {
1025 int i,j,k=0,code;
1026 // build size list for each symbol (from JPEG spec)
1027 for (i=0; i < 16; ++i)
1028 for (j=0; j < count[i]; ++j)
1029 h->size[k++] = (stbi_uc) (i+1);
1030 h->size[k] = 0;
1031
1032 // compute actual symbols (from jpeg spec)
1033 code = 0;
1034 k = 0;
1035 for(j=1; j <= 16; ++j) {
1036 // compute delta to add to code to compute symbol id
1037 h->delta[j] = k - code;
1038 if (h->size[k] == j) {
1039 while (h->size[k] == j)
1040 h->code[k++] = (stbi__uint16) (code++);
1041 if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG");
1042 }
1043 // compute largest code + 1 for this size, preshifted as needed later
1044 h->maxcode[j] = code << (16-j);
1045 code <<= 1;
1046 }
1047 h->maxcode[j] = 0xffffffff;
1048
1049 // build non-spec acceleration table; 255 is flag for not-accelerated
1050 memset(h->fast, 255, 1 << FAST_BITS);
1051 for (i=0; i < k; ++i) {
1052 int s = h->size[i];
1053 if (s <= FAST_BITS) {
1054 int c = h->code[i] << (FAST_BITS-s);
1055 int m = 1 << (FAST_BITS-s);
1056 for (j=0; j < m; ++j) {
1057 h->fast[c+j] = (stbi_uc) i;
1058 }
1059 }
1060 }
1061 return 1;
1062 }
1063
stbi__grow_buffer_unsafe(stbi__jpeg * j)1064 static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
1065 {
1066 do {
1067 int b = j->nomore ? 0 : stbi__get8(j->s);
1068 if (b == 0xff) {
1069 int c = stbi__get8(j->s);
1070 if (c != 0) {
1071 j->marker = (unsigned char) c;
1072 j->nomore = 1;
1073 return;
1074 }
1075 }
1076 j->code_buffer |= b << (24 - j->code_bits);
1077 j->code_bits += 8;
1078 } while (j->code_bits <= 24);
1079 }
1080
1081 // (1 << n) - 1
1082 static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
1083
1084 // stbi__jpeg_huff_decode a jpeg huffman value from the bitstream
stbi__jpeg_huff_decode(stbi__jpeg * j,stbi__huffman * h)1085 stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
1086 {
1087 unsigned int temp;
1088 int c,k;
1089
1090 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
1091
1092 // look at the top FAST_BITS and determine what symbol ID it is,
1093 // if the code is <= FAST_BITS
1094 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
1095 k = h->fast[c];
1096 if (k < 255) {
1097 int s = h->size[k];
1098 if (s > j->code_bits)
1099 return -1;
1100 j->code_buffer <<= s;
1101 j->code_bits -= s;
1102 return h->values[k];
1103 }
1104
1105 // naive test is to shift the code_buffer down so k bits are
1106 // valid, then test against maxcode. To speed this up, we've
1107 // preshifted maxcode left so that it has (16-k) 0s at the
1108 // end; in other words, regardless of the number of bits, it
1109 // wants to be compared against something shifted to have 16;
1110 // that way we don't need to shift inside the loop.
1111 temp = j->code_buffer >> 16;
1112 for (k=FAST_BITS+1 ; ; ++k)
1113 if (temp < h->maxcode[k])
1114 break;
1115 if (k == 17) {
1116 // error! code not found
1117 j->code_bits -= 16;
1118 return -1;
1119 }
1120
1121 if (k > j->code_bits)
1122 return -1;
1123
1124 // convert the huffman code to the symbol id
1125 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
1126 assert((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
1127
1128 // convert the id to a symbol
1129 j->code_bits -= k;
1130 j->code_buffer <<= k;
1131 return h->values[c];
1132 }
1133
1134 // combined JPEG 'receive' and JPEG 'extend', since baseline
1135 // always extends everything it receives.
stbi__extend_receive(stbi__jpeg * j,int n)1136 stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
1137 {
1138 unsigned int m = 1 << (n-1);
1139 unsigned int k;
1140 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
1141
1142 #if 1
1143 k = stbi_lrot(j->code_buffer, n);
1144 j->code_buffer = k & ~stbi__bmask[n];
1145 k &= stbi__bmask[n];
1146 j->code_bits -= n;
1147 #else
1148 k = (j->code_buffer >> (32 - n)) & stbi__bmask[n];
1149 j->code_bits -= n;
1150 j->code_buffer <<= n;
1151 #endif
1152 // the following test is probably a random branch that won't
1153 // predict well. I tried to table accelerate it but failed.
1154 // maybe it's compiling as a conditional move?
1155 if (k < m)
1156 return (-1 << n) + k + 1;
1157 else
1158 return k;
1159 }
1160
1161 // given a value that's at position X in the zigzag stream,
1162 // where does it appear in the 8x8 matrix coded as row-major?
1163 static stbi_uc stbi__jpeg_dezigzag[64+15] =
1164 {
1165 0, 1, 8, 16, 9, 2, 3, 10,
1166 17, 24, 32, 25, 18, 11, 4, 5,
1167 12, 19, 26, 33, 40, 48, 41, 34,
1168 27, 20, 13, 6, 7, 14, 21, 28,
1169 35, 42, 49, 56, 57, 50, 43, 36,
1170 29, 22, 15, 23, 30, 37, 44, 51,
1171 58, 59, 52, 45, 38, 31, 39, 46,
1172 53, 60, 61, 54, 47, 55, 62, 63,
1173 // let corrupt input sample past end
1174 63, 63, 63, 63, 63, 63, 63, 63,
1175 63, 63, 63, 63, 63, 63, 63
1176 };
1177
1178 // stbi__jpeg_huff_decode one 64-entry block--
stbi__jpeg_decode_block(stbi__jpeg * j,short data[64],stbi__huffman * hdc,stbi__huffman * hac,int b)1179 static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, int b)
1180 {
1181 int diff,dc,k;
1182 int t = stbi__jpeg_huff_decode(j, hdc);
1183 if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
1184
1185 // 0 all the ac values now so we can do it 32-bits at a time
1186 memset(data,0,64*sizeof(data[0]));
1187
1188 diff = t ? stbi__extend_receive(j, t) : 0;
1189 dc = j->img_comp[b].dc_pred + diff;
1190 j->img_comp[b].dc_pred = dc;
1191 data[0] = (short) dc;
1192
1193 // stbi__jpeg_huff_decode AC components, see JPEG spec
1194 k = 1;
1195 do {
1196 int r,s;
1197 int rs = stbi__jpeg_huff_decode(j, hac);
1198 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
1199 s = rs & 15;
1200 r = rs >> 4;
1201 if (s == 0) {
1202 if (rs != 0xf0) break; // end block
1203 k += 16;
1204 } else {
1205 k += r;
1206 // stbi__jpeg_huff_decode into unzigzag'd location
1207 data[stbi__jpeg_dezigzag[k++]] = (short) stbi__extend_receive(j,s);
1208 }
1209 } while (k < 64);
1210 return 1;
1211 }
1212
1213 // take a -128..127 value and stbi__clamp it and convert to 0..255
stbi__clamp(int x)1214 stbi_inline static stbi_uc stbi__clamp(int x)
1215 {
1216 // trick to use a single test to catch both cases
1217 if ((unsigned int) x > 255) {
1218 if (x < 0) return 0;
1219 if (x > 255) return 255;
1220 }
1221 return (stbi_uc) x;
1222 }
1223
1224 #define stbi__f2f(x) (int) (((x) * 4096 + 0.5))
1225 #define stbi__fsh(x) ((x) << 12)
1226
1227 // derived from jidctint -- DCT_ISLOW
1228 #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
1229 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
1230 p2 = s2; \
1231 p3 = s6; \
1232 p1 = (p2+p3) * stbi__f2f(0.5411961f); \
1233 t2 = p1 + p3*stbi__f2f(-1.847759065f); \
1234 t3 = p1 + p2*stbi__f2f( 0.765366865f); \
1235 p2 = s0; \
1236 p3 = s4; \
1237 t0 = stbi__fsh(p2+p3); \
1238 t1 = stbi__fsh(p2-p3); \
1239 x0 = t0+t3; \
1240 x3 = t0-t3; \
1241 x1 = t1+t2; \
1242 x2 = t1-t2; \
1243 t0 = s7; \
1244 t1 = s5; \
1245 t2 = s3; \
1246 t3 = s1; \
1247 p3 = t0+t2; \
1248 p4 = t1+t3; \
1249 p1 = t0+t3; \
1250 p2 = t1+t2; \
1251 p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
1252 t0 = t0*stbi__f2f( 0.298631336f); \
1253 t1 = t1*stbi__f2f( 2.053119869f); \
1254 t2 = t2*stbi__f2f( 3.072711026f); \
1255 t3 = t3*stbi__f2f( 1.501321110f); \
1256 p1 = p5 + p1*stbi__f2f(-0.899976223f); \
1257 p2 = p5 + p2*stbi__f2f(-2.562915447f); \
1258 p3 = p3*stbi__f2f(-1.961570560f); \
1259 p4 = p4*stbi__f2f(-0.390180644f); \
1260 t3 += p1+p4; \
1261 t2 += p2+p3; \
1262 t1 += p2+p4; \
1263 t0 += p1+p3;
1264
1265 #ifdef STBI_SIMD
1266 typedef unsigned short stbi_dequantize_t;
1267 #else
1268 typedef stbi_uc stbi_dequantize_t;
1269 #endif
1270
1271 // .344 seconds on 3*anemones.jpg
stbi__idct_block(stbi_uc * out,int out_stride,short data[64],stbi_dequantize_t * dequantize)1272 static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64], stbi_dequantize_t *dequantize)
1273 {
1274 int i,val[64],*v=val;
1275 stbi_dequantize_t *dq = dequantize;
1276 stbi_uc *o;
1277 short *d = data;
1278
1279 // columns
1280 for (i=0; i < 8; ++i,++d,++dq, ++v) {
1281 // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
1282 if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
1283 && d[40]==0 && d[48]==0 && d[56]==0) {
1284 // no shortcut 0 seconds
1285 // (1|2|3|4|5|6|7)==0 0 seconds
1286 // all separate -0.047 seconds
1287 // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
1288 int dcterm = d[0] * dq[0] << 2;
1289 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
1290 } else {
1291 STBI__IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
1292 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56])
1293 // constants scaled things up by 1<<12; let's bring them back
1294 // down, but keep 2 extra bits of precision
1295 x0 += 512; x1 += 512; x2 += 512; x3 += 512;
1296 v[ 0] = (x0+t3) >> 10;
1297 v[56] = (x0-t3) >> 10;
1298 v[ 8] = (x1+t2) >> 10;
1299 v[48] = (x1-t2) >> 10;
1300 v[16] = (x2+t1) >> 10;
1301 v[40] = (x2-t1) >> 10;
1302 v[24] = (x3+t0) >> 10;
1303 v[32] = (x3-t0) >> 10;
1304 }
1305 }
1306
1307 for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
1308 // no fast case since the first 1D IDCT spread components out
1309 STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
1310 // constants scaled things up by 1<<12, plus we had 1<<2 from first
1311 // loop, plus horizontal and vertical each scale by sqrt(8) so together
1312 // we've got an extra 1<<3, so 1<<17 total we need to remove.
1313 // so we want to round that, which means adding 0.5 * 1<<17,
1314 // aka 65536. Also, we'll end up with -128 to 127 that we want
1315 // to encode as 0..255 by adding 128, so we'll add that before the shift
1316 x0 += 65536 + (128<<17);
1317 x1 += 65536 + (128<<17);
1318 x2 += 65536 + (128<<17);
1319 x3 += 65536 + (128<<17);
1320 // tried computing the shifts into temps, or'ing the temps to see
1321 // if any were out of range, but that was slower
1322 o[0] = stbi__clamp((x0+t3) >> 17);
1323 o[7] = stbi__clamp((x0-t3) >> 17);
1324 o[1] = stbi__clamp((x1+t2) >> 17);
1325 o[6] = stbi__clamp((x1-t2) >> 17);
1326 o[2] = stbi__clamp((x2+t1) >> 17);
1327 o[5] = stbi__clamp((x2-t1) >> 17);
1328 o[3] = stbi__clamp((x3+t0) >> 17);
1329 o[4] = stbi__clamp((x3-t0) >> 17);
1330 }
1331 }
1332
1333 #ifdef STBI_SIMD
1334 static stbi_idct_8x8 stbi__idct_installed = stbi__idct_block;
1335
stbi_install_idct(stbi_idct_8x8 func)1336 STBIDEF void stbi_install_idct(stbi_idct_8x8 func)
1337 {
1338 stbi__idct_installed = func;
1339 }
1340 #endif
1341
1342 #define STBI__MARKER_none 0xff
1343 // if there's a pending marker from the entropy stream, return that
1344 // otherwise, fetch from the stream and get a marker. if there's no
1345 // marker, return 0xff, which is never a valid marker value
stbi__get_marker(stbi__jpeg * j)1346 static stbi_uc stbi__get_marker(stbi__jpeg *j)
1347 {
1348 stbi_uc x;
1349 if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
1350 x = stbi__get8(j->s);
1351 if (x != 0xff) return STBI__MARKER_none;
1352 while (x == 0xff)
1353 x = stbi__get8(j->s);
1354 return x;
1355 }
1356
1357 // in each scan, we'll have scan_n components, and the order
1358 // of the components is specified by order[]
1359 #define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
1360
1361 // after a restart interval, stbi__jpeg_reset the entropy decoder and
1362 // the dc prediction
stbi__jpeg_reset(stbi__jpeg * j)1363 static void stbi__jpeg_reset(stbi__jpeg *j)
1364 {
1365 j->code_bits = 0;
1366 j->code_buffer = 0;
1367 j->nomore = 0;
1368 j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
1369 j->marker = STBI__MARKER_none;
1370 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
1371 // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
1372 // since we don't even allow 1<<30 pixels
1373 }
1374
stbi__parse_entropy_coded_data(stbi__jpeg * z)1375 static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
1376 {
1377 stbi__jpeg_reset(z);
1378 if (z->scan_n == 1) {
1379 int i,j;
1380 #ifdef STBI_SIMD
1381 __declspec(align(16))
1382 #endif
1383 short data[64];
1384 int n = z->order[0];
1385 // non-interleaved data, we just need to process one block at a time,
1386 // in trivial scanline order
1387 // number of blocks to do just depends on how many actual "pixels" this
1388 // component has, independent of interleaved MCU blocking and such
1389 int w = (z->img_comp[n].x+7) >> 3;
1390 int h = (z->img_comp[n].y+7) >> 3;
1391 for (j=0; j < h; ++j) {
1392 for (i=0; i < w; ++i) {
1393 if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
1394 #ifdef STBI_SIMD
1395 stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
1396 #else
1397 stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
1398 #endif
1399 // every data block is an MCU, so countdown the restart interval
1400 if (--z->todo <= 0) {
1401 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
1402 // if it's NOT a restart, then just bail, so we get corrupt data
1403 // rather than no data
1404 if (!STBI__RESTART(z->marker)) return 1;
1405 stbi__jpeg_reset(z);
1406 }
1407 }
1408 }
1409 } else { // interleaved!
1410 int i,j,k,x,y;
1411 short data[64];
1412 for (j=0; j < z->img_mcu_y; ++j) {
1413 for (i=0; i < z->img_mcu_x; ++i) {
1414 // scan an interleaved mcu... process scan_n components in order
1415 for (k=0; k < z->scan_n; ++k) {
1416 int n = z->order[k];
1417 // scan out an mcu's worth of this component; that's just determined
1418 // by the basic H and V specified for the component
1419 for (y=0; y < z->img_comp[n].v; ++y) {
1420 for (x=0; x < z->img_comp[n].h; ++x) {
1421 int x2 = (i*z->img_comp[n].h + x)*8;
1422 int y2 = (j*z->img_comp[n].v + y)*8;
1423 if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
1424 #ifdef STBI_SIMD
1425 stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
1426 #else
1427 stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
1428 #endif
1429 }
1430 }
1431 }
1432 // after all interleaved components, that's an interleaved MCU,
1433 // so now count down the restart interval
1434 if (--z->todo <= 0) {
1435 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
1436 // if it's NOT a restart, then just bail, so we get corrupt data
1437 // rather than no data
1438 if (!STBI__RESTART(z->marker)) return 1;
1439 stbi__jpeg_reset(z);
1440 }
1441 }
1442 }
1443 }
1444 return 1;
1445 }
1446
stbi__process_marker(stbi__jpeg * z,int m)1447 static int stbi__process_marker(stbi__jpeg *z, int m)
1448 {
1449 int L;
1450 switch (m) {
1451 case STBI__MARKER_none: // no marker found
1452 return stbi__err("expected marker","Corrupt JPEG");
1453
1454 case 0xC2: // stbi__SOF - progressive
1455 return stbi__err("progressive jpeg","JPEG format not supported (progressive)");
1456
1457 case 0xDD: // DRI - specify restart interval
1458 if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
1459 z->restart_interval = stbi__get16be(z->s);
1460 return 1;
1461
1462 case 0xDB: // DQT - define quantization table
1463 L = stbi__get16be(z->s)-2;
1464 while (L > 0) {
1465 int q = stbi__get8(z->s);
1466 int p = q >> 4;
1467 int t = q & 15,i;
1468 if (p != 0) return stbi__err("bad DQT type","Corrupt JPEG");
1469 if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
1470 for (i=0; i < 64; ++i)
1471 z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8(z->s);
1472 #ifdef STBI_SIMD
1473 for (i=0; i < 64; ++i)
1474 z->dequant2[t][i] = z->dequant[t][i];
1475 #endif
1476 L -= 65;
1477 }
1478 return L==0;
1479
1480 case 0xC4: // DHT - define huffman table
1481 L = stbi__get16be(z->s)-2;
1482 while (L > 0) {
1483 stbi_uc *v;
1484 int sizes[16],i,n=0;
1485 int q = stbi__get8(z->s);
1486 int tc = q >> 4;
1487 int th = q & 15;
1488 if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
1489 for (i=0; i < 16; ++i) {
1490 sizes[i] = stbi__get8(z->s);
1491 n += sizes[i];
1492 }
1493 L -= 17;
1494 if (tc == 0) {
1495 if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
1496 v = z->huff_dc[th].values;
1497 } else {
1498 if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
1499 v = z->huff_ac[th].values;
1500 }
1501 for (i=0; i < n; ++i)
1502 v[i] = stbi__get8(z->s);
1503 L -= n;
1504 }
1505 return L==0;
1506 }
1507 // check for comment block or APP blocks
1508 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
1509 stbi__skip(z->s, stbi__get16be(z->s)-2);
1510 return 1;
1511 }
1512 return 0;
1513 }
1514
1515 // after we see stbi__SOS
stbi__process_scan_header(stbi__jpeg * z)1516 static int stbi__process_scan_header(stbi__jpeg *z)
1517 {
1518 int i;
1519 int Ls = stbi__get16be(z->s);
1520 z->scan_n = stbi__get8(z->s);
1521 if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad stbi__SOS component count","Corrupt JPEG");
1522 if (Ls != 6+2*z->scan_n) return stbi__err("bad stbi__SOS len","Corrupt JPEG");
1523 for (i=0; i < z->scan_n; ++i) {
1524 int id = stbi__get8(z->s), which;
1525 int q = stbi__get8(z->s);
1526 for (which = 0; which < z->s->img_n; ++which)
1527 if (z->img_comp[which].id == id)
1528 break;
1529 if (which == z->s->img_n) return 0;
1530 z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
1531 z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
1532 z->order[i] = which;
1533 }
1534 if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG");
1535 stbi__get8(z->s); // should be 63, but might be 0
1536 if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG");
1537
1538 return 1;
1539 }
1540
stbi__process_frame_header(stbi__jpeg * z,int scan)1541 static int stbi__process_frame_header(stbi__jpeg *z, int scan)
1542 {
1543 stbi__context *s = z->s;
1544 int Lf,p,i,q, h_max=1,v_max=1,c;
1545 Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad stbi__SOF len","Corrupt JPEG"); // JPEG
1546 p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
1547 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
1548 s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
1549 c = stbi__get8(s);
1550 if (c != 3 && c != 1) return stbi__err("bad component count","Corrupt JPEG"); // JFIF requires
1551 s->img_n = c;
1552 for (i=0; i < c; ++i) {
1553 z->img_comp[i].data = NULL;
1554 z->img_comp[i].linebuf = NULL;
1555 }
1556
1557 if (Lf != 8+3*s->img_n) return stbi__err("bad stbi__SOF len","Corrupt JPEG");
1558
1559 for (i=0; i < s->img_n; ++i) {
1560 z->img_comp[i].id = stbi__get8(s);
1561 if (z->img_comp[i].id != i+1) // JFIF requires
1562 if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files!
1563 return stbi__err("bad component ID","Corrupt JPEG");
1564 q = stbi__get8(s);
1565 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");
1566 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");
1567 z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
1568 }
1569
1570 if (scan != SCAN_load) return 1;
1571
1572 if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to stbi__jpeg_huff_decode");
1573
1574 for (i=0; i < s->img_n; ++i) {
1575 if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
1576 if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
1577 }
1578
1579 // compute interleaved mcu info
1580 z->img_h_max = h_max;
1581 z->img_v_max = v_max;
1582 z->img_mcu_w = h_max * 8;
1583 z->img_mcu_h = v_max * 8;
1584 z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
1585 z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
1586
1587 for (i=0; i < s->img_n; ++i) {
1588 // number of effective pixels (stbi__err.g. for non-interleaved MCU)
1589 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
1590 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
1591 // to simplify generation, we'll allocate enough memory to stbi__jpeg_huff_decode
1592 // the bogus oversized data from using interleaved MCUs and their
1593 // big blocks (stbi__err.g. a 16x16 iMCU on an image of width 33); we won't
1594 // discard the extra data until colorspace conversion
1595 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
1596 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
1597 z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
1598 if (z->img_comp[i].raw_data == NULL) {
1599 for(--i; i >= 0; --i) {
1600 free(z->img_comp[i].raw_data);
1601 z->img_comp[i].data = NULL;
1602 }
1603 return stbi__err("outofmem", "Out of memory");
1604 }
1605 // align blocks for installable-idct using mmx/sse
1606 z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
1607 z->img_comp[i].linebuf = NULL;
1608 }
1609
1610 return 1;
1611 }
1612
1613 // use comparisons since in some cases we handle more than one case (stbi__err.g. stbi__SOF)
1614 #define stbi__DNL(x) ((x) == 0xdc)
1615 #define stbi__SOI(x) ((x) == 0xd8)
1616 #define stbi__EOI(x) ((x) == 0xd9)
1617 #define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1)
1618 #define stbi__SOS(x) ((x) == 0xda)
1619
decode_jpeg_header(stbi__jpeg * z,int scan)1620 static int decode_jpeg_header(stbi__jpeg *z, int scan)
1621 {
1622 int m;
1623 z->marker = STBI__MARKER_none; // initialize cached marker to empty
1624 m = stbi__get_marker(z);
1625 if (!stbi__SOI(m)) return stbi__err("no stbi__SOI","Corrupt JPEG");
1626 if (scan == SCAN_type) return 1;
1627 m = stbi__get_marker(z);
1628 while (!stbi__SOF(m)) {
1629 if (!stbi__process_marker(z,m)) return 0;
1630 m = stbi__get_marker(z);
1631 while (m == STBI__MARKER_none) {
1632 // some files have extra padding after their blocks, so ok, we'll scan
1633 if (stbi__at_eof(z->s)) return stbi__err("no stbi__SOF", "Corrupt JPEG");
1634 m = stbi__get_marker(z);
1635 }
1636 }
1637 if (!stbi__process_frame_header(z, scan)) return 0;
1638 return 1;
1639 }
1640
decode_jpeg_image(stbi__jpeg * j)1641 static int decode_jpeg_image(stbi__jpeg *j)
1642 {
1643 int m;
1644 j->restart_interval = 0;
1645 if (!decode_jpeg_header(j, SCAN_load)) return 0;
1646 m = stbi__get_marker(j);
1647 while (!stbi__EOI(m)) {
1648 if (stbi__SOS(m)) {
1649 if (!stbi__process_scan_header(j)) return 0;
1650 if (!stbi__parse_entropy_coded_data(j)) return 0;
1651 if (j->marker == STBI__MARKER_none ) {
1652 // handle 0s at the end of image data from IP Kamera 9060
1653 while (!stbi__at_eof(j->s)) {
1654 int x = stbi__get8(j->s);
1655 if (x == 255) {
1656 j->marker = stbi__get8(j->s);
1657 break;
1658 } else if (x != 0) {
1659 return 0;
1660 }
1661 }
1662 // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
1663 }
1664 } else {
1665 if (!stbi__process_marker(j, m)) return 0;
1666 }
1667 m = stbi__get_marker(j);
1668 }
1669 return 1;
1670 }
1671
1672 // static jfif-centered resampling (across block boundaries)
1673
1674 typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
1675 int w, int hs);
1676
1677 #define stbi__div4(x) ((stbi_uc) ((x) >> 2))
1678
resample_row_1(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)1679 static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
1680 {
1681 STBI_NOTUSED(out);
1682 STBI_NOTUSED(in_far);
1683 STBI_NOTUSED(w);
1684 STBI_NOTUSED(hs);
1685 return in_near;
1686 }
1687
stbi__resample_row_v_2(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)1688 static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
1689 {
1690 // need to generate two samples vertically for every one in input
1691 int i;
1692 STBI_NOTUSED(hs);
1693 for (i=0; i < w; ++i)
1694 out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
1695 return out;
1696 }
1697
stbi__resample_row_h_2(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)1698 static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
1699 {
1700 // need to generate two samples horizontally for every one in input
1701 int i;
1702 stbi_uc *input = in_near;
1703
1704 if (w == 1) {
1705 // if only one sample, can't do any interpolation
1706 out[0] = out[1] = input[0];
1707 return out;
1708 }
1709
1710 out[0] = input[0];
1711 out[1] = stbi__div4(input[0]*3 + input[1] + 2);
1712 for (i=1; i < w-1; ++i) {
1713 int n = 3*input[i]+2;
1714 out[i*2+0] = stbi__div4(n+input[i-1]);
1715 out[i*2+1] = stbi__div4(n+input[i+1]);
1716 }
1717 out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
1718 out[i*2+1] = input[w-1];
1719
1720 STBI_NOTUSED(in_far);
1721 STBI_NOTUSED(hs);
1722
1723 return out;
1724 }
1725
1726 #define stbi__div16(x) ((stbi_uc) ((x) >> 4))
1727
stbi__resample_row_hv_2(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)1728 static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
1729 {
1730 // need to generate 2x2 samples for every one in input
1731 int i,t0,t1;
1732 if (w == 1) {
1733 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
1734 return out;
1735 }
1736
1737 t1 = 3*in_near[0] + in_far[0];
1738 out[0] = stbi__div4(t1+2);
1739 for (i=1; i < w; ++i) {
1740 t0 = t1;
1741 t1 = 3*in_near[i]+in_far[i];
1742 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
1743 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
1744 }
1745 out[w*2-1] = stbi__div4(t1+2);
1746
1747 STBI_NOTUSED(hs);
1748
1749 return out;
1750 }
1751
stbi__resample_row_generic(stbi_uc * out,stbi_uc * in_near,stbi_uc * in_far,int w,int hs)1752 static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
1753 {
1754 // resample with nearest-neighbor
1755 int i,j;
1756 STBI_NOTUSED(in_far);
1757 for (i=0; i < w; ++i)
1758 for (j=0; j < hs; ++j)
1759 out[i*hs+j] = in_near[i];
1760 return out;
1761 }
1762
1763 #define float2fixed(x) ((int) ((x) * 65536 + 0.5))
1764
1765 // 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro)
1766 // VC6 without processor=Pro is generating multiple LEAs per multiply!
stbi__YCbCr_to_RGB_row(stbi_uc * out,const stbi_uc * y,const stbi_uc * pcb,const stbi_uc * pcr,int count,int step)1767 static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
1768 {
1769 int i;
1770 for (i=0; i < count; ++i) {
1771 int y_fixed = (y[i] << 16) + 32768; // rounding
1772 int r,g,b;
1773 int cr = pcr[i] - 128;
1774 int cb = pcb[i] - 128;
1775 r = y_fixed + cr*float2fixed(1.40200f);
1776 g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
1777 b = y_fixed + cb*float2fixed(1.77200f);
1778 r >>= 16;
1779 g >>= 16;
1780 b >>= 16;
1781 if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
1782 if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
1783 if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
1784 out[0] = (stbi_uc)r;
1785 out[1] = (stbi_uc)g;
1786 out[2] = (stbi_uc)b;
1787 out[3] = 255;
1788 out += step;
1789 }
1790 }
1791
1792 #ifdef STBI_SIMD
1793 static stbi_YCbCr_to_RGB_run stbi__YCbCr_installed = stbi__YCbCr_to_RGB_row;
1794
stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)1795 STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
1796 {
1797 stbi__YCbCr_installed = func;
1798 }
1799 #endif
1800
1801
1802 // clean up the temporary component buffers
stbi__cleanup_jpeg(stbi__jpeg * j)1803 static void stbi__cleanup_jpeg(stbi__jpeg *j)
1804 {
1805 int i;
1806 for (i=0; i < j->s->img_n; ++i) {
1807 if (j->img_comp[i].data) {
1808 free(j->img_comp[i].raw_data);
1809 j->img_comp[i].data = NULL;
1810 }
1811 if (j->img_comp[i].linebuf) {
1812 free(j->img_comp[i].linebuf);
1813 j->img_comp[i].linebuf = NULL;
1814 }
1815 }
1816 }
1817
1818 typedef struct
1819 {
1820 resample_row_func resample;
1821 stbi_uc *line0,*line1;
1822 int hs,vs; // expansion factor in each axis
1823 int w_lores; // horizontal pixels pre-expansion
1824 int ystep; // how far through vertical expansion we are
1825 int ypos; // which pre-expansion row we're on
1826 } stbi__resample;
1827
load_jpeg_image(stbi__jpeg * z,int * out_x,int * out_y,int * comp,int req_comp)1828 static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
1829 {
1830 int n, decode_n;
1831 // validate req_comp
1832 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
1833 z->s->img_n = 0;
1834
1835 // load a jpeg image from whichever source
1836 if (!decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
1837
1838 // determine actual number of components to generate
1839 n = req_comp ? req_comp : z->s->img_n;
1840
1841 if (z->s->img_n == 3 && n < 3)
1842 decode_n = 1;
1843 else
1844 decode_n = z->s->img_n;
1845
1846 // resample and color-convert
1847 {
1848 int k;
1849 unsigned int i,j;
1850 stbi_uc *output;
1851 stbi_uc *coutput[4];
1852
1853 stbi__resample res_comp[4];
1854
1855 for (k=0; k < decode_n; ++k) {
1856 stbi__resample *r = &res_comp[k];
1857
1858 // allocate line buffer big enough for upsampling off the edges
1859 // with upsample factor of 4
1860 z->img_comp[k].linebuf = (stbi_uc *) malloc(z->s->img_x + 3);
1861 if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
1862
1863 r->hs = z->img_h_max / z->img_comp[k].h;
1864 r->vs = z->img_v_max / z->img_comp[k].v;
1865 r->ystep = r->vs >> 1;
1866 r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
1867 r->ypos = 0;
1868 r->line0 = r->line1 = z->img_comp[k].data;
1869
1870 if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
1871 else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
1872 else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
1873 else if (r->hs == 2 && r->vs == 2) r->resample = stbi__resample_row_hv_2;
1874 else r->resample = stbi__resample_row_generic;
1875 }
1876
1877 // can't error after this so, this is safe
1878 output = (stbi_uc *) malloc(n * z->s->img_x * z->s->img_y + 1);
1879 if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
1880
1881 // now go ahead and resample
1882 for (j=0; j < z->s->img_y; ++j) {
1883 stbi_uc *out = output + n * z->s->img_x * j;
1884 for (k=0; k < decode_n; ++k) {
1885 stbi__resample *r = &res_comp[k];
1886 int y_bot = r->ystep >= (r->vs >> 1);
1887 coutput[k] = r->resample(z->img_comp[k].linebuf,
1888 y_bot ? r->line1 : r->line0,
1889 y_bot ? r->line0 : r->line1,
1890 r->w_lores, r->hs);
1891 if (++r->ystep >= r->vs) {
1892 r->ystep = 0;
1893 r->line0 = r->line1;
1894 if (++r->ypos < z->img_comp[k].y)
1895 r->line1 += z->img_comp[k].w2;
1896 }
1897 }
1898 if (n >= 3) {
1899 stbi_uc *y = coutput[0];
1900 if (z->s->img_n == 3) {
1901 #ifdef STBI_SIMD
1902 stbi__YCbCr_installed(out, y, coutput[1], coutput[2], z->s->img_x, n);
1903 #else
1904 stbi__YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n);
1905 #endif
1906 } else
1907 for (i=0; i < z->s->img_x; ++i) {
1908 out[0] = out[1] = out[2] = y[i];
1909 out[3] = 255; // not used if n==3
1910 out += n;
1911 }
1912 } else {
1913 stbi_uc *y = coutput[0];
1914 if (n == 1)
1915 for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
1916 else
1917 for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
1918 }
1919 }
1920 stbi__cleanup_jpeg(z);
1921 *out_x = z->s->img_x;
1922 *out_y = z->s->img_y;
1923 if (comp) *comp = z->s->img_n; // report original components, not output
1924 return output;
1925 }
1926 }
1927
stbi__jpeg_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)1928 static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1929 {
1930 stbi__jpeg j;
1931 j.s = s;
1932 return load_jpeg_image(&j, x,y,comp,req_comp);
1933 }
1934
stbi__jpeg_test(stbi__context * s)1935 static int stbi__jpeg_test(stbi__context *s)
1936 {
1937 int r;
1938 stbi__jpeg j;
1939 j.s = s;
1940 r = decode_jpeg_header(&j, SCAN_type);
1941 stbi__rewind(s);
1942 return r;
1943 }
1944
stbi__jpeg_info_raw(stbi__jpeg * j,int * x,int * y,int * comp)1945 static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
1946 {
1947 if (!decode_jpeg_header(j, SCAN_header)) {
1948 stbi__rewind( j->s );
1949 return 0;
1950 }
1951 if (x) *x = j->s->img_x;
1952 if (y) *y = j->s->img_y;
1953 if (comp) *comp = j->s->img_n;
1954 return 1;
1955 }
1956
stbi__jpeg_info(stbi__context * s,int * x,int * y,int * comp)1957 static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
1958 {
1959 stbi__jpeg j;
1960 j.s = s;
1961 return stbi__jpeg_info_raw(&j, x, y, comp);
1962 }
1963
1964 // public domain zlib stbi__jpeg_huff_decode v0.2 Sean Barrett 2006-11-18
1965 // simple implementation
1966 // - all input must be provided in an upfront buffer
1967 // - all output is written to a single output buffer (can malloc/realloc)
1968 // performance
1969 // - fast huffman
1970
1971 // fast-way is faster to check than jpeg huffman, but slow way is slower
1972 #define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
1973 #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
1974
1975 // zlib-style huffman encoding
1976 // (jpegs packs from left, zlib from right, so can't share code)
1977 typedef struct
1978 {
1979 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
1980 stbi__uint16 firstcode[16];
1981 int maxcode[17];
1982 stbi__uint16 firstsymbol[16];
1983 stbi_uc size[288];
1984 stbi__uint16 value[288];
1985 } stbi__zhuffman;
1986
stbi__bitreverse16(int n)1987 stbi_inline static int stbi__bitreverse16(int n)
1988 {
1989 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
1990 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
1991 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
1992 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
1993 return n;
1994 }
1995
stbi__bit_reverse(int v,int bits)1996 stbi_inline static int stbi__bit_reverse(int v, int bits)
1997 {
1998 assert(bits <= 16);
1999 // to bit reverse n bits, reverse 16 and shift
2000 // stbi__err.g. 11 bits, bit reverse and shift away 5
2001 return stbi__bitreverse16(v) >> (16-bits);
2002 }
2003
stbi__zbuild_huffman(stbi__zhuffman * z,stbi_uc * sizelist,int num)2004 static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num)
2005 {
2006 int i,k=0;
2007 int code, next_code[16], sizes[17];
2008
2009 // DEFLATE spec for generating codes
2010 memset(sizes, 0, sizeof(sizes));
2011 memset(z->fast, 255, sizeof(z->fast));
2012 for (i=0; i < num; ++i)
2013 ++sizes[sizelist[i]];
2014 sizes[0] = 0;
2015 for (i=1; i < 16; ++i)
2016 assert(sizes[i] <= (1 << i));
2017 code = 0;
2018 for (i=1; i < 16; ++i) {
2019 next_code[i] = code;
2020 z->firstcode[i] = (stbi__uint16) code;
2021 z->firstsymbol[i] = (stbi__uint16) k;
2022 code = (code + sizes[i]);
2023 if (sizes[i])
2024 if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt JPEG");
2025 z->maxcode[i] = code << (16-i); // preshift for inner loop
2026 code <<= 1;
2027 k += sizes[i];
2028 }
2029 z->maxcode[16] = 0x10000; // sentinel
2030 for (i=0; i < num; ++i) {
2031 int s = sizelist[i];
2032 if (s) {
2033 int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
2034 z->size [c] = (stbi_uc ) s;
2035 z->value[c] = (stbi__uint16) i;
2036 if (s <= STBI__ZFAST_BITS) {
2037 int k = stbi__bit_reverse(next_code[s],s);
2038 while (k < (1 << STBI__ZFAST_BITS)) {
2039 z->fast[k] = (stbi__uint16) c;
2040 k += (1 << s);
2041 }
2042 }
2043 ++next_code[s];
2044 }
2045 }
2046 return 1;
2047 }
2048
2049 // zlib-from-memory implementation for PNG reading
2050 // because PNG allows splitting the zlib stream arbitrarily,
2051 // and it's annoying structurally to have PNG call ZLIB call PNG,
2052 // we require PNG read all the IDATs and combine them into a single
2053 // memory buffer
2054
2055 typedef struct
2056 {
2057 stbi_uc *zbuffer, *zbuffer_end;
2058 int num_bits;
2059 stbi__uint32 code_buffer;
2060
2061 char *zout;
2062 char *zout_start;
2063 char *zout_end;
2064 int z_expandable;
2065
2066 stbi__zhuffman z_length, z_distance;
2067 } stbi__zbuf;
2068
stbi__zget8(stbi__zbuf * z)2069 stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
2070 {
2071 if (z->zbuffer >= z->zbuffer_end) return 0;
2072 return *z->zbuffer++;
2073 }
2074
stbi__fill_bits(stbi__zbuf * z)2075 static void stbi__fill_bits(stbi__zbuf *z)
2076 {
2077 do {
2078 assert(z->code_buffer < (1U << z->num_bits));
2079 z->code_buffer |= stbi__zget8(z) << z->num_bits;
2080 z->num_bits += 8;
2081 } while (z->num_bits <= 24);
2082 }
2083
stbi__zreceive(stbi__zbuf * z,int n)2084 stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
2085 {
2086 unsigned int k;
2087 if (z->num_bits < n) stbi__fill_bits(z);
2088 k = z->code_buffer & ((1 << n) - 1);
2089 z->code_buffer >>= n;
2090 z->num_bits -= n;
2091 return k;
2092 }
2093
stbi__zhuffman_decode(stbi__zbuf * a,stbi__zhuffman * z)2094 stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
2095 {
2096 int b,s,k;
2097 if (a->num_bits < 16) stbi__fill_bits(a);
2098 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
2099 if (b < 0xffff) {
2100 s = z->size[b];
2101 a->code_buffer >>= s;
2102 a->num_bits -= s;
2103 return z->value[b];
2104 }
2105
2106 // not resolved by fast table, so compute it the slow way
2107 // use jpeg approach, which requires MSbits at top
2108 k = stbi__bit_reverse(a->code_buffer, 16);
2109 for (s=STBI__ZFAST_BITS+1; ; ++s)
2110 if (k < z->maxcode[s])
2111 break;
2112 if (s == 16) return -1; // invalid code!
2113 // code size is s, so:
2114 b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
2115 assert(z->size[b] == s);
2116 a->code_buffer >>= s;
2117 a->num_bits -= s;
2118 return z->value[b];
2119 }
2120
stbi__zexpand(stbi__zbuf * z,int n)2121 static int stbi__zexpand(stbi__zbuf *z, int n) // need to make room for n bytes
2122 {
2123 char *q;
2124 int cur, limit;
2125 if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
2126 cur = (int) (z->zout - z->zout_start);
2127 limit = (int) (z->zout_end - z->zout_start);
2128 while (cur + n > limit)
2129 limit *= 2;
2130 q = (char *) realloc(z->zout_start, limit);
2131 if (q == NULL) return stbi__err("outofmem", "Out of memory");
2132 z->zout_start = q;
2133 z->zout = q + cur;
2134 z->zout_end = q + limit;
2135 return 1;
2136 }
2137
2138 static int stbi__zlength_base[31] = {
2139 3,4,5,6,7,8,9,10,11,13,
2140 15,17,19,23,27,31,35,43,51,59,
2141 67,83,99,115,131,163,195,227,258,0,0 };
2142
2143 static int stbi__zlength_extra[31]=
2144 { 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 };
2145
2146 static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
2147 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
2148
2149 static int stbi__zdist_extra[32] =
2150 { 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};
2151
stbi__parse_huffman_block(stbi__zbuf * a)2152 static int stbi__parse_huffman_block(stbi__zbuf *a)
2153 {
2154 for(;;) {
2155 int z = stbi__zhuffman_decode(a, &a->z_length);
2156 if (z < 256) {
2157 if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
2158 if (a->zout >= a->zout_end) if (!stbi__zexpand(a, 1)) return 0;
2159 *a->zout++ = (char) z;
2160 } else {
2161 stbi_uc *p;
2162 int len,dist;
2163 if (z == 256) return 1;
2164 z -= 257;
2165 len = stbi__zlength_base[z];
2166 if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
2167 z = stbi__zhuffman_decode(a, &a->z_distance);
2168 if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");
2169 dist = stbi__zdist_base[z];
2170 if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
2171 if (a->zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
2172 if (a->zout + len > a->zout_end) if (!stbi__zexpand(a, len)) return 0;
2173 p = (stbi_uc *) (a->zout - dist);
2174 while (len--)
2175 *a->zout++ = *p++;
2176 }
2177 }
2178 }
2179
stbi__compute_huffman_codes(stbi__zbuf * a)2180 static int stbi__compute_huffman_codes(stbi__zbuf *a)
2181 {
2182 static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
2183 stbi__zhuffman z_codelength;
2184 stbi_uc lencodes[286+32+137];//padding for maximum single op
2185 stbi_uc codelength_sizes[19];
2186 int i,n;
2187
2188 int hlit = stbi__zreceive(a,5) + 257;
2189 int hdist = stbi__zreceive(a,5) + 1;
2190 int hclen = stbi__zreceive(a,4) + 4;
2191
2192 memset(codelength_sizes, 0, sizeof(codelength_sizes));
2193 for (i=0; i < hclen; ++i) {
2194 int s = stbi__zreceive(a,3);
2195 codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
2196 }
2197 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
2198
2199 n = 0;
2200 while (n < hlit + hdist) {
2201 int c = stbi__zhuffman_decode(a, &z_codelength);
2202 assert(c >= 0 && c < 19);
2203 if (c < 16)
2204 lencodes[n++] = (stbi_uc) c;
2205 else if (c == 16) {
2206 c = stbi__zreceive(a,2)+3;
2207 memset(lencodes+n, lencodes[n-1], c);
2208 n += c;
2209 } else if (c == 17) {
2210 c = stbi__zreceive(a,3)+3;
2211 memset(lencodes+n, 0, c);
2212 n += c;
2213 } else {
2214 assert(c == 18);
2215 c = stbi__zreceive(a,7)+11;
2216 memset(lencodes+n, 0, c);
2217 n += c;
2218 }
2219 }
2220 if (n != hlit+hdist) return stbi__err("bad codelengths","Corrupt PNG");
2221 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
2222 if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
2223 return 1;
2224 }
2225
stbi__parse_uncomperssed_block(stbi__zbuf * a)2226 static int stbi__parse_uncomperssed_block(stbi__zbuf *a)
2227 {
2228 stbi_uc header[4];
2229 int len,nlen,k;
2230 if (a->num_bits & 7)
2231 stbi__zreceive(a, a->num_bits & 7); // discard
2232 // drain the bit-packed data into header
2233 k = 0;
2234 while (a->num_bits > 0) {
2235 header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
2236 a->code_buffer >>= 8;
2237 a->num_bits -= 8;
2238 }
2239 assert(a->num_bits == 0);
2240 // now fill header the normal way
2241 while (k < 4)
2242 header[k++] = stbi__zget8(a);
2243 len = header[1] * 256 + header[0];
2244 nlen = header[3] * 256 + header[2];
2245 if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
2246 if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
2247 if (a->zout + len > a->zout_end)
2248 if (!stbi__zexpand(a, len)) return 0;
2249 memcpy(a->zout, a->zbuffer, len);
2250 a->zbuffer += len;
2251 a->zout += len;
2252 return 1;
2253 }
2254
stbi__parse_zlib_header(stbi__zbuf * a)2255 static int stbi__parse_zlib_header(stbi__zbuf *a)
2256 {
2257 int cmf = stbi__zget8(a);
2258 int cm = cmf & 15;
2259 /* int cinfo = cmf >> 4; */
2260 int flg = stbi__zget8(a);
2261 if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
2262 if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
2263 if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
2264 // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
2265 return 1;
2266 }
2267
2268 // @TODO: should statically initialize these for optimal thread safety
2269 static stbi_uc stbi__zdefault_length[288], stbi__zdefault_distance[32];
stbi__init_zdefaults(void)2270 static void stbi__init_zdefaults(void)
2271 {
2272 int i; // use <= to match clearly with spec
2273 for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;
2274 for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;
2275 for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;
2276 for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;
2277
2278 for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;
2279 }
2280
stbi__parse_zlib(stbi__zbuf * a,int parse_header)2281 static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
2282 {
2283 int final_, type;
2284 if (parse_header)
2285 if (!stbi__parse_zlib_header(a)) return 0;
2286 a->num_bits = 0;
2287 a->code_buffer = 0;
2288 do {
2289 final_ = stbi__zreceive(a,1);
2290 type = stbi__zreceive(a,2);
2291 if (type == 0) {
2292 if (!stbi__parse_uncomperssed_block(a)) return 0;
2293 } else if (type == 3) {
2294 return 0;
2295 } else {
2296 if (type == 1) {
2297 // use fixed code lengths
2298 if (!stbi__zdefault_distance[31]) stbi__init_zdefaults();
2299 if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0;
2300 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;
2301 } else {
2302 if (!stbi__compute_huffman_codes(a)) return 0;
2303 }
2304 if (!stbi__parse_huffman_block(a)) return 0;
2305 }
2306 } while (!final_);
2307 return 1;
2308 }
2309
stbi__do_zlib(stbi__zbuf * a,char * obuf,int olen,int exp,int parse_header)2310 static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
2311 {
2312 a->zout_start = obuf;
2313 a->zout = obuf;
2314 a->zout_end = obuf + olen;
2315 a->z_expandable = exp;
2316
2317 return stbi__parse_zlib(a, parse_header);
2318 }
2319
stbi_zlib_decode_malloc_guesssize(const char * buffer,int len,int initial_size,int * outlen)2320 STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
2321 {
2322 stbi__zbuf a;
2323 char *p = (char *) malloc(initial_size);
2324 if (p == NULL) return NULL;
2325 a.zbuffer = (stbi_uc *) buffer;
2326 a.zbuffer_end = (stbi_uc *) buffer + len;
2327 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
2328 if (outlen) *outlen = (int) (a.zout - a.zout_start);
2329 return a.zout_start;
2330 } else {
2331 free(a.zout_start);
2332 return NULL;
2333 }
2334 }
2335
stbi_zlib_decode_malloc(char const * buffer,int len,int * outlen)2336 STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
2337 {
2338 return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
2339 }
2340
stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer,int len,int initial_size,int * outlen,int parse_header)2341 STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
2342 {
2343 stbi__zbuf a;
2344 char *p = (char *) malloc(initial_size);
2345 if (p == NULL) return NULL;
2346 a.zbuffer = (stbi_uc *) buffer;
2347 a.zbuffer_end = (stbi_uc *) buffer + len;
2348 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
2349 if (outlen) *outlen = (int) (a.zout - a.zout_start);
2350 return a.zout_start;
2351 } else {
2352 free(a.zout_start);
2353 return NULL;
2354 }
2355 }
2356
stbi_zlib_decode_buffer(char * obuffer,int olen,char const * ibuffer,int ilen)2357 STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
2358 {
2359 stbi__zbuf a;
2360 a.zbuffer = (stbi_uc *) ibuffer;
2361 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
2362 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
2363 return (int) (a.zout - a.zout_start);
2364 else
2365 return -1;
2366 }
2367
stbi_zlib_decode_noheader_malloc(char const * buffer,int len,int * outlen)2368 STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
2369 {
2370 stbi__zbuf a;
2371 char *p = (char *) malloc(16384);
2372 if (p == NULL) return NULL;
2373 a.zbuffer = (stbi_uc *) buffer;
2374 a.zbuffer_end = (stbi_uc *) buffer+len;
2375 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
2376 if (outlen) *outlen = (int) (a.zout - a.zout_start);
2377 return a.zout_start;
2378 } else {
2379 free(a.zout_start);
2380 return NULL;
2381 }
2382 }
2383
stbi_zlib_decode_noheader_buffer(char * obuffer,int olen,const char * ibuffer,int ilen)2384 STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
2385 {
2386 stbi__zbuf a;
2387 a.zbuffer = (stbi_uc *) ibuffer;
2388 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
2389 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
2390 return (int) (a.zout - a.zout_start);
2391 else
2392 return -1;
2393 }
2394
2395 // public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
2396 // simple implementation
2397 // - only 8-bit samples
2398 // - no CRC checking
2399 // - allocates lots of intermediate memory
2400 // - avoids problem of streaming data between subsystems
2401 // - avoids explicit window management
2402 // performance
2403 // - uses stb_zlib, a PD zlib implementation with fast huffman decoding
2404
2405
2406 typedef struct
2407 {
2408 stbi__uint32 length;
2409 stbi__uint32 type;
2410 } stbi__pngchunk;
2411
2412 #define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
2413
stbi__get_chunk_header(stbi__context * s)2414 static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
2415 {
2416 stbi__pngchunk c;
2417 c.length = stbi__get32be(s);
2418 c.type = stbi__get32be(s);
2419 return c;
2420 }
2421
stbi__check_png_header(stbi__context * s)2422 static int stbi__check_png_header(stbi__context *s)
2423 {
2424 static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
2425 int i;
2426 for (i=0; i < 8; ++i)
2427 if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
2428 return 1;
2429 }
2430
2431 typedef struct
2432 {
2433 stbi__context *s;
2434 stbi_uc *idata, *expanded, *out;
2435 } stbi__png;
2436
2437
2438 enum {
2439 STBI__F_none=0, STBI__F_sub=1, STBI__F_up=2, STBI__F_avg=3, STBI__F_paeth=4,
2440 STBI__F_avg_first, STBI__F_paeth_first
2441 };
2442
2443 static stbi_uc first_row_filter[5] =
2444 {
2445 STBI__F_none, STBI__F_sub, STBI__F_none, STBI__F_avg_first, STBI__F_paeth_first
2446 };
2447
stbi__paeth(int a,int b,int c)2448 static int stbi__paeth(int a, int b, int c)
2449 {
2450 int p = a + b - c;
2451 int pa = abs(p-a);
2452 int pb = abs(p-b);
2453 int pc = abs(p-c);
2454 if (pa <= pb && pa <= pc) return a;
2455 if (pb <= pc) return b;
2456 return c;
2457 }
2458
2459 #define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
2460
2461 // create the png data from post-deflated data
stbi__create_png_image_raw(stbi__png * a,stbi_uc * raw,stbi__uint32 raw_len,int out_n,stbi__uint32 x,stbi__uint32 y)2462 static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y)
2463 {
2464 stbi__context *s = a->s;
2465 stbi__uint32 i,j,stride = x*out_n;
2466 int k;
2467 int img_n = s->img_n; // copy it into a local for later
2468 assert(out_n == s->img_n || out_n == s->img_n+1);
2469 a->out = (stbi_uc *) malloc(x * y * out_n);
2470 if (!a->out) return stbi__err("outofmem", "Out of memory");
2471 if (s->img_x == x && s->img_y == y) {
2472 if (raw_len != (img_n * x + 1) * y) return stbi__err("not enough pixels","Corrupt PNG");
2473 } else { // interlaced:
2474 if (raw_len < (img_n * x + 1) * y) return stbi__err("not enough pixels","Corrupt PNG");
2475 }
2476 for (j=0; j < y; ++j) {
2477 stbi_uc *cur = a->out + stride*j;
2478 stbi_uc *prior = cur - stride;
2479 int filter = *raw++;
2480 if (filter > 4) return stbi__err("invalid filter","Corrupt PNG");
2481 // if first row, use special filter that doesn't sample previous row
2482 if (j == 0) filter = first_row_filter[filter];
2483 // handle first pixel explicitly
2484 for (k=0; k < img_n; ++k) {
2485 switch (filter) {
2486 case STBI__F_none : cur[k] = raw[k]; break;
2487 case STBI__F_sub : cur[k] = raw[k]; break;
2488 case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
2489 case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
2490 case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
2491 case STBI__F_avg_first : cur[k] = raw[k]; break;
2492 case STBI__F_paeth_first: cur[k] = raw[k]; break;
2493 }
2494 }
2495 if (img_n != out_n) cur[img_n] = 255;
2496 raw += img_n;
2497 cur += out_n;
2498 prior += out_n;
2499 // this is a little gross, so that we don't switch per-pixel or per-component
2500 if (img_n == out_n) {
2501 #define CASE(f) \
2502 case f: \
2503 for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
2504 for (k=0; k < img_n; ++k)
2505 switch (filter) {
2506 CASE(STBI__F_none) cur[k] = raw[k]; break;
2507 CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-img_n]); break;
2508 CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
2509 CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-img_n])>>1)); break;
2510 CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
2511 CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-img_n] >> 1)); break;
2512 CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-img_n],0,0)); break;
2513 }
2514 #undef CASE
2515 } else {
2516 assert(img_n+1 == out_n);
2517 #define CASE(f) \
2518 case f: \
2519 for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
2520 for (k=0; k < img_n; ++k)
2521 switch (filter) {
2522 CASE(STBI__F_none) cur[k] = raw[k]; break;
2523 CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-out_n]); break;
2524 CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
2525 CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-out_n])>>1)); break;
2526 CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
2527 CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-out_n] >> 1)); break;
2528 CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],0,0)); break;
2529 }
2530 #undef CASE
2531 }
2532 }
2533 return 1;
2534 }
2535
stbi__create_png_image(stbi__png * a,stbi_uc * raw,stbi__uint32 raw_len,int out_n,int interlaced)2536 static int stbi__create_png_image(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, int interlaced)
2537 {
2538 stbi_uc *final_;
2539 int p;
2540 if (!interlaced)
2541 return stbi__create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y);
2542
2543 // de-interlacing
2544 final_ = (stbi_uc *) malloc(a->s->img_x * a->s->img_y * out_n);
2545 for (p=0; p < 7; ++p) {
2546 int xorig[] = { 0,4,0,2,0,1,0 };
2547 int yorig[] = { 0,0,4,0,2,0,1 };
2548 int xspc[] = { 8,8,4,4,2,2,1 };
2549 int yspc[] = { 8,8,8,4,4,2,2 };
2550 int i,j,x,y;
2551 // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
2552 x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
2553 y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
2554 if (x && y) {
2555 if (!stbi__create_png_image_raw(a, raw, raw_len, out_n, x, y)) {
2556 free(final_);
2557 return 0;
2558 }
2559 for (j=0; j < y; ++j)
2560 for (i=0; i < x; ++i)
2561 memcpy(final_ + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n,
2562 a->out + (j*x+i)*out_n, out_n);
2563 free(a->out);
2564 raw += (x*out_n+1)*y;
2565 raw_len -= (x*out_n+1)*y;
2566 }
2567 }
2568 a->out = final_;
2569
2570 return 1;
2571 }
2572
stbi__compute_transparency(stbi__png * z,stbi_uc tc[3],int out_n)2573 static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
2574 {
2575 stbi__context *s = z->s;
2576 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
2577 stbi_uc *p = z->out;
2578
2579 // compute color-based transparency, assuming we've
2580 // already got 255 as the alpha value in the output
2581 assert(out_n == 2 || out_n == 4);
2582
2583 if (out_n == 2) {
2584 for (i=0; i < pixel_count; ++i) {
2585 p[1] = (p[0] == tc[0] ? 0 : 255);
2586 p += 2;
2587 }
2588 } else {
2589 for (i=0; i < pixel_count; ++i) {
2590 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
2591 p[3] = 0;
2592 p += 4;
2593 }
2594 }
2595 return 1;
2596 }
2597
stbi__expand_png_palette(stbi__png * a,stbi_uc * palette,int len,int pal_img_n)2598 static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
2599 {
2600 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
2601 stbi_uc *p, *temp_out, *orig = a->out;
2602
2603 p = (stbi_uc *) malloc(pixel_count * pal_img_n);
2604 if (p == NULL) return stbi__err("outofmem", "Out of memory");
2605
2606 // between here and free(out) below, exitting would leak
2607 temp_out = p;
2608
2609 if (pal_img_n == 3) {
2610 for (i=0; i < pixel_count; ++i) {
2611 int n = orig[i]*4;
2612 p[0] = palette[n ];
2613 p[1] = palette[n+1];
2614 p[2] = palette[n+2];
2615 p += 3;
2616 }
2617 } else {
2618 for (i=0; i < pixel_count; ++i) {
2619 int n = orig[i]*4;
2620 p[0] = palette[n ];
2621 p[1] = palette[n+1];
2622 p[2] = palette[n+2];
2623 p[3] = palette[n+3];
2624 p += 4;
2625 }
2626 }
2627 free(a->out);
2628 a->out = temp_out;
2629
2630 STBI_NOTUSED(len);
2631
2632 return 1;
2633 }
2634
2635 static int stbi__unpremultiply_on_load = 0;
2636 static int stbi__de_iphone_flag = 0;
2637
stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)2638 STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
2639 {
2640 stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
2641 }
2642
stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)2643 STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
2644 {
2645 stbi__de_iphone_flag = flag_true_if_should_convert;
2646 }
2647
stbi__de_iphone(stbi__png * z)2648 static void stbi__de_iphone(stbi__png *z)
2649 {
2650 stbi__context *s = z->s;
2651 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
2652 stbi_uc *p = z->out;
2653
2654 if (s->img_out_n == 3) { // convert bgr to rgb
2655 for (i=0; i < pixel_count; ++i) {
2656 stbi_uc t = p[0];
2657 p[0] = p[2];
2658 p[2] = t;
2659 p += 3;
2660 }
2661 } else {
2662 assert(s->img_out_n == 4);
2663 if (stbi__unpremultiply_on_load) {
2664 // convert bgr to rgb and unpremultiply
2665 for (i=0; i < pixel_count; ++i) {
2666 stbi_uc a = p[3];
2667 stbi_uc t = p[0];
2668 if (a) {
2669 p[0] = p[2] * 255 / a;
2670 p[1] = p[1] * 255 / a;
2671 p[2] = t * 255 / a;
2672 } else {
2673 p[0] = p[2];
2674 p[2] = t;
2675 }
2676 p += 4;
2677 }
2678 } else {
2679 // convert bgr to rgb
2680 for (i=0; i < pixel_count; ++i) {
2681 stbi_uc t = p[0];
2682 p[0] = p[2];
2683 p[2] = t;
2684 p += 4;
2685 }
2686 }
2687 }
2688 }
2689
stbi__parse_png_file(stbi__png * z,int scan,int req_comp)2690 static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
2691 {
2692 stbi_uc palette[1024], pal_img_n=0;
2693 stbi_uc has_trans=0, tc[3];
2694 stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
2695 int first=1,k,interlace=0, is_iphone=0;
2696 stbi__context *s = z->s;
2697
2698 z->expanded = NULL;
2699 z->idata = NULL;
2700 z->out = NULL;
2701
2702 if (!stbi__check_png_header(s)) return 0;
2703
2704 if (scan == SCAN_type) return 1;
2705
2706 for (;;) {
2707 stbi__pngchunk c = stbi__get_chunk_header(s);
2708 switch (c.type) {
2709 case PNG_TYPE('C','g','B','I'):
2710 is_iphone = 1;
2711 stbi__skip(s, c.length);
2712 break;
2713 case PNG_TYPE('I','H','D','R'): {
2714 int depth,color,comp,filter;
2715 if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
2716 first = 0;
2717 if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
2718 s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
2719 s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)");
2720 depth = stbi__get8(s); if (depth != 8) return stbi__err("8bit only","PNG not supported: 8-bit only");
2721 color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");
2722 if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
2723 comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");
2724 filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");
2725 interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
2726 if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
2727 if (!pal_img_n) {
2728 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
2729 if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to stbi__jpeg_huff_decode");
2730 if (scan == SCAN_header) return 1;
2731 } else {
2732 // if paletted, then pal_n is our final components, and
2733 // img_n is # components to decompress/filter.
2734 s->img_n = 1;
2735 if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
2736 // if SCAN_header, have to scan to see if we have a tRNS
2737 }
2738 break;
2739 }
2740
2741 case PNG_TYPE('P','L','T','E'): {
2742 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
2743 if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
2744 pal_len = c.length / 3;
2745 if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
2746 for (i=0; i < pal_len; ++i) {
2747 palette[i*4+0] = stbi__get8(s);
2748 palette[i*4+1] = stbi__get8(s);
2749 palette[i*4+2] = stbi__get8(s);
2750 palette[i*4+3] = 255;
2751 }
2752 break;
2753 }
2754
2755 case PNG_TYPE('t','R','N','S'): {
2756 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
2757 if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
2758 if (pal_img_n) {
2759 if (scan == SCAN_header) { s->img_n = 4; return 1; }
2760 if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
2761 if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
2762 pal_img_n = 4;
2763 for (i=0; i < c.length; ++i)
2764 palette[i*4+3] = stbi__get8(s);
2765 } else {
2766 if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
2767 if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
2768 has_trans = 1;
2769 for (k=0; k < s->img_n; ++k)
2770 tc[k] = (stbi_uc) (stbi__get16be(s) & 255); // non 8-bit images will be larger
2771 }
2772 break;
2773 }
2774
2775 case PNG_TYPE('I','D','A','T'): {
2776 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
2777 if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
2778 if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
2779 if (ioff + c.length > idata_limit) {
2780 stbi_uc *p;
2781 if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
2782 while (ioff + c.length > idata_limit)
2783 idata_limit *= 2;
2784 p = (stbi_uc *) realloc(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
2785 z->idata = p;
2786 }
2787 if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
2788 ioff += c.length;
2789 break;
2790 }
2791
2792 case PNG_TYPE('I','E','N','D'): {
2793 stbi__uint32 raw_len;
2794 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
2795 if (scan != SCAN_load) return 1;
2796 if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
2797 z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !is_iphone);
2798 if (z->expanded == NULL) return 0; // zlib should set error
2799 free(z->idata); z->idata = NULL;
2800 if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
2801 s->img_out_n = s->img_n+1;
2802 else
2803 s->img_out_n = s->img_n;
2804 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0;
2805 if (has_trans)
2806 if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
2807 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
2808 stbi__de_iphone(z);
2809 if (pal_img_n) {
2810 // pal_img_n == 3 or 4
2811 s->img_n = pal_img_n; // record the actual colors we had
2812 s->img_out_n = pal_img_n;
2813 if (req_comp >= 3) s->img_out_n = req_comp;
2814 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
2815 return 0;
2816 }
2817 free(z->expanded); z->expanded = NULL;
2818 return 1;
2819 }
2820
2821 default:
2822 // if critical, fail
2823 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
2824 if ((c.type & (1 << 29)) == 0) {
2825 #ifndef STBI_NO_FAILURE_STRINGS
2826 // not threadsafe
2827 static char invalid_chunk[] = "XXXX PNG chunk not known";
2828 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
2829 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
2830 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
2831 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
2832 #endif
2833 return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
2834 }
2835 stbi__skip(s, c.length);
2836 break;
2837 }
2838 // end of PNG chunk, read and skip CRC
2839 stbi__get32be(s);
2840 }
2841 }
2842
stbi__do_png(stbi__png * p,int * x,int * y,int * n,int req_comp)2843 static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp)
2844 {
2845 unsigned char *result=NULL;
2846 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
2847 if (stbi__parse_png_file(p, SCAN_load, req_comp)) {
2848 result = p->out;
2849 p->out = NULL;
2850 if (req_comp && req_comp != p->s->img_out_n) {
2851 result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
2852 p->s->img_out_n = req_comp;
2853 if (result == NULL) return result;
2854 }
2855 *x = p->s->img_x;
2856 *y = p->s->img_y;
2857 if (n) *n = p->s->img_n;
2858 }
2859 free(p->out); p->out = NULL;
2860 free(p->expanded); p->expanded = NULL;
2861 free(p->idata); p->idata = NULL;
2862
2863 return result;
2864 }
2865
stbi__png_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)2866 static unsigned char *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
2867 {
2868 stbi__png p;
2869 p.s = s;
2870 return stbi__do_png(&p, x,y,comp,req_comp);
2871 }
2872
stbi__png_test(stbi__context * s)2873 static int stbi__png_test(stbi__context *s)
2874 {
2875 int r;
2876 r = stbi__check_png_header(s);
2877 stbi__rewind(s);
2878 return r;
2879 }
2880
stbi__png_info_raw(stbi__png * p,int * x,int * y,int * comp)2881 static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
2882 {
2883 if (!stbi__parse_png_file(p, SCAN_header, 0)) {
2884 stbi__rewind( p->s );
2885 return 0;
2886 }
2887 if (x) *x = p->s->img_x;
2888 if (y) *y = p->s->img_y;
2889 if (comp) *comp = p->s->img_n;
2890 return 1;
2891 }
2892
stbi__png_info(stbi__context * s,int * x,int * y,int * comp)2893 static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
2894 {
2895 stbi__png p;
2896 p.s = s;
2897 return stbi__png_info_raw(&p, x, y, comp);
2898 }
2899
2900 // Microsoft/Windows BMP image
stbi__bmp_test_raw(stbi__context * s)2901 static int stbi__bmp_test_raw(stbi__context *s)
2902 {
2903 int r;
2904 int sz;
2905 if (stbi__get8(s) != 'B') return 0;
2906 if (stbi__get8(s) != 'M') return 0;
2907 stbi__get32le(s); // discard filesize
2908 stbi__get16le(s); // discard reserved
2909 stbi__get16le(s); // discard reserved
2910 stbi__get32le(s); // discard data offset
2911 sz = stbi__get32le(s);
2912 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
2913 return r;
2914 }
2915
stbi__bmp_test(stbi__context * s)2916 static int stbi__bmp_test(stbi__context *s)
2917 {
2918 int r = stbi__bmp_test_raw(s);
2919 stbi__rewind(s);
2920 return r;
2921 }
2922
2923
2924 // returns 0..31 for the highest set bit
stbi__high_bit(unsigned int z)2925 static int stbi__high_bit(unsigned int z)
2926 {
2927 int n=0;
2928 if (z == 0) return -1;
2929 if (z >= 0x10000) n += 16, z >>= 16;
2930 if (z >= 0x00100) n += 8, z >>= 8;
2931 if (z >= 0x00010) n += 4, z >>= 4;
2932 if (z >= 0x00004) n += 2, z >>= 2;
2933 if (z >= 0x00002) n += 1, z >>= 1;
2934 return n;
2935 }
2936
stbi__bitcount(unsigned int a)2937 static int stbi__bitcount(unsigned int a)
2938 {
2939 a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
2940 a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
2941 a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
2942 a = (a + (a >> 8)); // max 16 per 8 bits
2943 a = (a + (a >> 16)); // max 32 per 8 bits
2944 return a & 0xff;
2945 }
2946
stbi__shiftsigned(int v,int shift,int bits)2947 static int stbi__shiftsigned(int v, int shift, int bits)
2948 {
2949 int result;
2950 int z=0;
2951
2952 if (shift < 0) v <<= -shift;
2953 else v >>= shift;
2954 result = v;
2955
2956 z = bits;
2957 while (z < 8) {
2958 result += v >> z;
2959 z += bits;
2960 }
2961 return result;
2962 }
2963
stbi__bmp_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)2964 static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
2965 {
2966 stbi_uc *out;
2967 unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0;
2968 stbi_uc pal[256][4];
2969 int psize=0,i,j,compress=0,width;
2970 int bpp, flip_vertically, pad, target, offset, hsz;
2971 if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
2972 stbi__get32le(s); // discard filesize
2973 stbi__get16le(s); // discard reserved
2974 stbi__get16le(s); // discard reserved
2975 offset = stbi__get32le(s);
2976 hsz = stbi__get32le(s);
2977 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
2978 if (hsz == 12) {
2979 s->img_x = stbi__get16le(s);
2980 s->img_y = stbi__get16le(s);
2981 } else {
2982 s->img_x = stbi__get32le(s);
2983 s->img_y = stbi__get32le(s);
2984 }
2985 if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
2986 bpp = stbi__get16le(s);
2987 if (bpp == 1) return stbi__errpuc("monochrome", "BMP type not supported: 1-bit");
2988 flip_vertically = ((int) s->img_y) > 0;
2989 s->img_y = abs((int) s->img_y);
2990 if (hsz == 12) {
2991 if (bpp < 24)
2992 psize = (offset - 14 - 24) / 3;
2993 } else {
2994 compress = stbi__get32le(s);
2995 if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
2996 stbi__get32le(s); // discard sizeof
2997 stbi__get32le(s); // discard hres
2998 stbi__get32le(s); // discard vres
2999 stbi__get32le(s); // discard colorsused
3000 stbi__get32le(s); // discard max important
3001 if (hsz == 40 || hsz == 56) {
3002 if (hsz == 56) {
3003 stbi__get32le(s);
3004 stbi__get32le(s);
3005 stbi__get32le(s);
3006 stbi__get32le(s);
3007 }
3008 if (bpp == 16 || bpp == 32) {
3009 mr = mg = mb = 0;
3010 if (compress == 0) {
3011 if (bpp == 32) {
3012 mr = 0xffu << 16;
3013 mg = 0xffu << 8;
3014 mb = 0xffu << 0;
3015 ma = 0xffu << 24;
3016 fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255
3017 STBI_NOTUSED(fake_a);
3018 } else {
3019 mr = 31u << 10;
3020 mg = 31u << 5;
3021 mb = 31u << 0;
3022 }
3023 } else if (compress == 3) {
3024 mr = stbi__get32le(s);
3025 mg = stbi__get32le(s);
3026 mb = stbi__get32le(s);
3027 // not documented, but generated by photoshop and handled by mspaint
3028 if (mr == mg && mg == mb) {
3029 // ?!?!?
3030 return stbi__errpuc("bad BMP", "bad BMP");
3031 }
3032 } else
3033 return stbi__errpuc("bad BMP", "bad BMP");
3034 }
3035 } else {
3036 assert(hsz == 108 || hsz == 124);
3037 mr = stbi__get32le(s);
3038 mg = stbi__get32le(s);
3039 mb = stbi__get32le(s);
3040 ma = stbi__get32le(s);
3041 stbi__get32le(s); // discard color space
3042 for (i=0; i < 12; ++i)
3043 stbi__get32le(s); // discard color space parameters
3044 if (hsz == 124) {
3045 stbi__get32le(s); // discard rendering intent
3046 stbi__get32le(s); // discard offset of profile data
3047 stbi__get32le(s); // discard size of profile data
3048 stbi__get32le(s); // discard reserved
3049 }
3050 }
3051 if (bpp < 16)
3052 psize = (offset - 14 - hsz) >> 2;
3053 }
3054 s->img_n = ma ? 4 : 3;
3055 if (req_comp && req_comp >= 3) // we can directly stbi__jpeg_huff_decode 3 or 4
3056 target = req_comp;
3057 else
3058 target = s->img_n; // if they want monochrome, we'll post-convert
3059 out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
3060 if (!out) return stbi__errpuc("outofmem", "Out of memory");
3061 if (bpp < 16) {
3062 int z=0;
3063 if (psize == 0 || psize > 256) { free(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
3064 for (i=0; i < psize; ++i) {
3065 pal[i][2] = stbi__get8(s);
3066 pal[i][1] = stbi__get8(s);
3067 pal[i][0] = stbi__get8(s);
3068 if (hsz != 12) stbi__get8(s);
3069 pal[i][3] = 255;
3070 }
3071 stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
3072 if (bpp == 4) width = (s->img_x + 1) >> 1;
3073 else if (bpp == 8) width = s->img_x;
3074 else { free(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
3075 pad = (-width)&3;
3076 for (j=0; j < (int) s->img_y; ++j) {
3077 for (i=0; i < (int) s->img_x; i += 2) {
3078 int v=stbi__get8(s),v2=0;
3079 if (bpp == 4) {
3080 v2 = v & 15;
3081 v >>= 4;
3082 }
3083 out[z++] = pal[v][0];
3084 out[z++] = pal[v][1];
3085 out[z++] = pal[v][2];
3086 if (target == 4) out[z++] = 255;
3087 if (i+1 == (int) s->img_x) break;
3088 v = (bpp == 8) ? stbi__get8(s) : v2;
3089 out[z++] = pal[v][0];
3090 out[z++] = pal[v][1];
3091 out[z++] = pal[v][2];
3092 if (target == 4) out[z++] = 255;
3093 }
3094 stbi__skip(s, pad);
3095 }
3096 } else {
3097 int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
3098 int z = 0;
3099 int easy=0;
3100 stbi__skip(s, offset - 14 - hsz);
3101 if (bpp == 24) width = 3 * s->img_x;
3102 else if (bpp == 16) width = 2*s->img_x;
3103 else /* bpp = 32 and pad = 0 */ width=0;
3104 pad = (-width) & 3;
3105 if (bpp == 24) {
3106 easy = 1;
3107 } else if (bpp == 32) {
3108 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
3109 easy = 2;
3110 }
3111 if (!easy) {
3112 if (!mr || !mg || !mb) { free(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
3113 // right shift amt to put high bit in position #7
3114 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
3115 gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
3116 bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
3117 ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
3118 }
3119 for (j=0; j < (int) s->img_y; ++j) {
3120 if (easy) {
3121 for (i=0; i < (int) s->img_x; ++i) {
3122 unsigned char a;
3123 out[z+2] = stbi__get8(s);
3124 out[z+1] = stbi__get8(s);
3125 out[z+0] = stbi__get8(s);
3126 z += 3;
3127 a = (easy == 2 ? stbi__get8(s) : 255);
3128 if (target == 4) out[z++] = a;
3129 }
3130 } else {
3131 for (i=0; i < (int) s->img_x; ++i) {
3132 stbi__uint32 v = (stbi__uint32) (bpp == 16 ? stbi__get16le(s) : stbi__get32le(s));
3133 int a;
3134 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
3135 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
3136 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
3137 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
3138 if (target == 4) out[z++] = STBI__BYTECAST(a);
3139 }
3140 }
3141 stbi__skip(s, pad);
3142 }
3143 }
3144 if (flip_vertically) {
3145 stbi_uc t;
3146 for (j=0; j < (int) s->img_y>>1; ++j) {
3147 stbi_uc *p1 = out + j *s->img_x*target;
3148 stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
3149 for (i=0; i < (int) s->img_x*target; ++i) {
3150 t = p1[i], p1[i] = p2[i], p2[i] = t;
3151 }
3152 }
3153 }
3154
3155 if (req_comp && req_comp != target) {
3156 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
3157 if (out == NULL) return out; // stbi__convert_format frees input on failure
3158 }
3159
3160 *x = s->img_x;
3161 *y = s->img_y;
3162 if (comp) *comp = s->img_n;
3163 return out;
3164 }
3165
3166 // Targa Truevision - TGA
3167 // by Jonathan Dummer
3168
stbi__tga_info(stbi__context * s,int * x,int * y,int * comp)3169 static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
3170 {
3171 int tga_w, tga_h, tga_comp;
3172 int sz;
3173 stbi__get8(s); // discard Offset
3174 sz = stbi__get8(s); // color type
3175 if( sz > 1 ) {
3176 stbi__rewind(s);
3177 return 0; // only RGB or indexed allowed
3178 }
3179 sz = stbi__get8(s); // image type
3180 // only RGB or grey allowed, +/- RLE
3181 if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
3182 stbi__skip(s,9);
3183 tga_w = stbi__get16le(s);
3184 if( tga_w < 1 ) {
3185 stbi__rewind(s);
3186 return 0; // test width
3187 }
3188 tga_h = stbi__get16le(s);
3189 if( tga_h < 1 ) {
3190 stbi__rewind(s);
3191 return 0; // test height
3192 }
3193 sz = stbi__get8(s); // bits per pixel
3194 // only RGB or RGBA or grey allowed
3195 if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
3196 stbi__rewind(s);
3197 return 0;
3198 }
3199 tga_comp = sz;
3200 if (x) *x = tga_w;
3201 if (y) *y = tga_h;
3202 if (comp) *comp = tga_comp / 8;
3203 return 1; // seems to have passed everything
3204 }
3205
stbi__tga_test(stbi__context * s)3206 static int stbi__tga_test(stbi__context *s)
3207 {
3208 int res;
3209 int sz;
3210 stbi__get8(s); // discard Offset
3211 sz = stbi__get8(s); // color type
3212 if ( sz > 1 ) return 0; // only RGB or indexed allowed
3213 sz = stbi__get8(s); // image type
3214 if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE
3215 stbi__get16be(s); // discard palette start
3216 stbi__get16be(s); // discard palette length
3217 stbi__get8(s); // discard bits per palette color entry
3218 stbi__get16be(s); // discard x origin
3219 stbi__get16be(s); // discard y origin
3220 if ( stbi__get16be(s) < 1 ) return 0; // test width
3221 if ( stbi__get16be(s) < 1 ) return 0; // test height
3222 sz = stbi__get8(s); // bits per pixel
3223 if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) )
3224 res = 0;
3225 else
3226 res = 1;
3227 stbi__rewind(s);
3228 return res;
3229 }
3230
stbi__tga_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)3231 static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
3232 {
3233 // read in the TGA header stuff
3234 int tga_offset = stbi__get8(s);
3235 int tga_indexed = stbi__get8(s);
3236 int tga_image_type = stbi__get8(s);
3237 int tga_is_RLE = 0;
3238 int tga_palette_start = stbi__get16le(s);
3239 int tga_palette_len = stbi__get16le(s);
3240 int tga_palette_bits = stbi__get8(s);
3241 int tga_x_origin = stbi__get16le(s);
3242 int tga_y_origin = stbi__get16le(s);
3243 int tga_width = stbi__get16le(s);
3244 int tga_height = stbi__get16le(s);
3245 int tga_bits_per_pixel = stbi__get8(s);
3246 int tga_comp = tga_bits_per_pixel / 8;
3247 int tga_inverted = stbi__get8(s);
3248 // image data
3249 unsigned char *tga_data;
3250 unsigned char *tga_palette = NULL;
3251 int i, j;
3252 unsigned char raw_data[4];
3253 int RLE_count = 0;
3254 int RLE_repeating = 0;
3255 int read_next_pixel = 1;
3256
3257 // do a tiny bit of precessing
3258 if ( tga_image_type >= 8 )
3259 {
3260 tga_image_type -= 8;
3261 tga_is_RLE = 1;
3262 }
3263 /* int tga_alpha_bits = tga_inverted & 15; */
3264 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
3265
3266 // error check
3267 if ( //(tga_indexed) ||
3268 (tga_width < 1) || (tga_height < 1) ||
3269 (tga_image_type < 1) || (tga_image_type > 3) ||
3270 ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
3271 (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
3272 )
3273 {
3274 return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA
3275 }
3276
3277 // If I'm paletted, then I'll use the number of bits from the palette
3278 if ( tga_indexed )
3279 {
3280 tga_comp = tga_palette_bits / 8;
3281 }
3282
3283 // tga info
3284 *x = tga_width;
3285 *y = tga_height;
3286 if (comp) *comp = tga_comp;
3287
3288 tga_data = (unsigned char*)malloc( tga_width * tga_height * tga_comp );
3289 if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
3290
3291 // skip to the data's starting position (offset usually = 0)
3292 stbi__skip(s, tga_offset );
3293
3294 if ( !tga_indexed && !tga_is_RLE) {
3295 for (i=0; i < tga_height; ++i) {
3296 int y = tga_inverted ? tga_height -i - 1 : i;
3297 stbi_uc *tga_row = tga_data + y*tga_width*tga_comp;
3298 stbi__getn(s, tga_row, tga_width * tga_comp);
3299 }
3300 } else {
3301 // do I need to load a palette?
3302 if ( tga_indexed)
3303 {
3304 // any data to skip? (offset usually = 0)
3305 stbi__skip(s, tga_palette_start );
3306 // load the palette
3307 tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
3308 if (!tga_palette) {
3309 free(tga_data);
3310 return stbi__errpuc("outofmem", "Out of memory");
3311 }
3312 if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
3313 free(tga_data);
3314 free(tga_palette);
3315 return stbi__errpuc("bad palette", "Corrupt TGA");
3316 }
3317 }
3318 // load the data
3319 for (i=0; i < tga_width * tga_height; ++i)
3320 {
3321 // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
3322 if ( tga_is_RLE )
3323 {
3324 if ( RLE_count == 0 )
3325 {
3326 // yep, get the next byte as a RLE command
3327 int RLE_cmd = stbi__get8(s);
3328 RLE_count = 1 + (RLE_cmd & 127);
3329 RLE_repeating = RLE_cmd >> 7;
3330 read_next_pixel = 1;
3331 } else if ( !RLE_repeating )
3332 {
3333 read_next_pixel = 1;
3334 }
3335 } else
3336 {
3337 read_next_pixel = 1;
3338 }
3339 // OK, if I need to read a pixel, do it now
3340 if ( read_next_pixel )
3341 {
3342 // load however much data we did have
3343 if ( tga_indexed )
3344 {
3345 // read in 1 byte, then perform the lookup
3346 int pal_idx = stbi__get8(s);
3347 if ( pal_idx >= tga_palette_len )
3348 {
3349 // invalid index
3350 pal_idx = 0;
3351 }
3352 pal_idx *= tga_bits_per_pixel / 8;
3353 for (j = 0; j*8 < tga_bits_per_pixel; ++j)
3354 {
3355 raw_data[j] = tga_palette[pal_idx+j];
3356 }
3357 } else
3358 {
3359 // read in the data raw
3360 for (j = 0; j*8 < tga_bits_per_pixel; ++j)
3361 {
3362 raw_data[j] = stbi__get8(s);
3363 }
3364 }
3365 // clear the reading flag for the next pixel
3366 read_next_pixel = 0;
3367 } // end of reading a pixel
3368
3369 // copy data
3370 for (j = 0; j < tga_comp; ++j)
3371 tga_data[i*tga_comp+j] = raw_data[j];
3372
3373 // in case we're in RLE mode, keep counting down
3374 --RLE_count;
3375 }
3376 // do I need to invert the image?
3377 if ( tga_inverted )
3378 {
3379 for (j = 0; j*2 < tga_height; ++j)
3380 {
3381 int index1 = j * tga_width * tga_comp;
3382 int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
3383 for (i = tga_width * tga_comp; i > 0; --i)
3384 {
3385 unsigned char temp = tga_data[index1];
3386 tga_data[index1] = tga_data[index2];
3387 tga_data[index2] = temp;
3388 ++index1;
3389 ++index2;
3390 }
3391 }
3392 }
3393 // clear my palette, if I had one
3394 if ( tga_palette != NULL )
3395 {
3396 free( tga_palette );
3397 }
3398 }
3399
3400 // swap RGB
3401 if (tga_comp >= 3)
3402 {
3403 unsigned char* tga_pixel = tga_data;
3404 for (i=0; i < tga_width * tga_height; ++i)
3405 {
3406 unsigned char temp = tga_pixel[0];
3407 tga_pixel[0] = tga_pixel[2];
3408 tga_pixel[2] = temp;
3409 tga_pixel += tga_comp;
3410 }
3411 }
3412
3413 // convert to target component count
3414 if (req_comp && req_comp != tga_comp)
3415 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
3416
3417 // the things I do to get rid of an error message, and yet keep
3418 // Microsoft's C compilers happy... [8^(
3419 tga_palette_start = tga_palette_len = tga_palette_bits =
3420 tga_x_origin = tga_y_origin = 0;
3421 // OK, done
3422 return tga_data;
3423 }
3424
3425 // *************************************************************************************************
3426 // Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
3427
stbi__psd_test(stbi__context * s)3428 static int stbi__psd_test(stbi__context *s)
3429 {
3430 int r = (stbi__get32be(s) == 0x38425053);
3431 stbi__rewind(s);
3432 return r;
3433 }
3434
stbi__psd_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)3435 static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
3436 {
3437 int pixelCount;
3438 int channelCount, compression;
3439 int channel, i, count, len;
3440 int w,h;
3441 stbi_uc *out;
3442
3443 // Check identifier
3444 if (stbi__get32be(s) != 0x38425053) // "8BPS"
3445 return stbi__errpuc("not PSD", "Corrupt PSD image");
3446
3447 // Check file type version.
3448 if (stbi__get16be(s) != 1)
3449 return stbi__errpuc("wrong version", "Unsupported version of PSD image");
3450
3451 // Skip 6 reserved bytes.
3452 stbi__skip(s, 6 );
3453
3454 // Read the number of channels (R, G, B, A, etc).
3455 channelCount = stbi__get16be(s);
3456 if (channelCount < 0 || channelCount > 16)
3457 return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
3458
3459 // Read the rows and columns of the image.
3460 h = stbi__get32be(s);
3461 w = stbi__get32be(s);
3462
3463 // Make sure the depth is 8 bits.
3464 if (stbi__get16be(s) != 8)
3465 return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 bit");
3466
3467 // Make sure the color mode is RGB.
3468 // Valid options are:
3469 // 0: Bitmap
3470 // 1: Grayscale
3471 // 2: Indexed color
3472 // 3: RGB color
3473 // 4: CMYK color
3474 // 7: Multichannel
3475 // 8: Duotone
3476 // 9: Lab color
3477 if (stbi__get16be(s) != 3)
3478 return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
3479
3480 // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
3481 stbi__skip(s,stbi__get32be(s) );
3482
3483 // Skip the image resources. (resolution, pen tool paths, etc)
3484 stbi__skip(s, stbi__get32be(s) );
3485
3486 // Skip the reserved data.
3487 stbi__skip(s, stbi__get32be(s) );
3488
3489 // Find out if the data is compressed.
3490 // Known values:
3491 // 0: no compression
3492 // 1: RLE compressed
3493 compression = stbi__get16be(s);
3494 if (compression > 1)
3495 return stbi__errpuc("bad compression", "PSD has an unknown compression format");
3496
3497 // Create the destination image.
3498 out = (stbi_uc *) malloc(4 * w*h);
3499 if (!out) return stbi__errpuc("outofmem", "Out of memory");
3500 pixelCount = w*h;
3501
3502 // Initialize the data to zero.
3503 //memset( out, 0, pixelCount * 4 );
3504
3505 // Finally, the image data.
3506 if (compression) {
3507 // RLE as used by .PSD and .TIFF
3508 // Loop until you get the number of unpacked bytes you are expecting:
3509 // Read the next source byte into n.
3510 // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
3511 // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
3512 // Else if n is 128, noop.
3513 // Endloop
3514
3515 // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
3516 // which we're going to just skip.
3517 stbi__skip(s, h * channelCount * 2 );
3518
3519 // Read the RLE data by channel.
3520 for (channel = 0; channel < 4; channel++) {
3521 stbi_uc *p;
3522
3523 p = out+channel;
3524 if (channel >= channelCount) {
3525 // Fill this channel with default data.
3526 for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
3527 } else {
3528 // Read the RLE data.
3529 count = 0;
3530 while (count < pixelCount) {
3531 len = stbi__get8(s);
3532 if (len == 128) {
3533 // No-op.
3534 } else if (len < 128) {
3535 // Copy next len+1 bytes literally.
3536 len++;
3537 count += len;
3538 while (len) {
3539 *p = stbi__get8(s);
3540 p += 4;
3541 len--;
3542 }
3543 } else if (len > 128) {
3544 stbi_uc val;
3545 // Next -len+1 bytes in the dest are replicated from next source byte.
3546 // (Interpret len as a negative 8-bit int.)
3547 len ^= 0x0FF;
3548 len += 2;
3549 val = stbi__get8(s);
3550 count += len;
3551 while (len) {
3552 *p = val;
3553 p += 4;
3554 len--;
3555 }
3556 }
3557 }
3558 }
3559 }
3560
3561 } else {
3562 // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
3563 // where each channel consists of an 8-bit value for each pixel in the image.
3564
3565 // Read the data by channel.
3566 for (channel = 0; channel < 4; channel++) {
3567 stbi_uc *p;
3568
3569 p = out + channel;
3570 if (channel > channelCount) {
3571 // Fill this channel with default data.
3572 for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
3573 } else {
3574 // Read the data.
3575 for (i = 0; i < pixelCount; i++)
3576 *p = stbi__get8(s), p += 4;
3577 }
3578 }
3579 }
3580
3581 if (req_comp && req_comp != 4) {
3582 out = stbi__convert_format(out, 4, req_comp, w, h);
3583 if (out == NULL) return out; // stbi__convert_format frees input on failure
3584 }
3585
3586 if (comp) *comp = channelCount;
3587 *y = h;
3588 *x = w;
3589
3590 return out;
3591 }
3592
3593 // *************************************************************************************************
3594 // Softimage PIC loader
3595 // by Tom Seddon
3596 //
3597 // See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
3598 // See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
3599
stbi__pic_is4(stbi__context * s,const char * str)3600 static int stbi__pic_is4(stbi__context *s,const char *str)
3601 {
3602 int i;
3603 for (i=0; i<4; ++i)
3604 if (stbi__get8(s) != (stbi_uc)str[i])
3605 return 0;
3606
3607 return 1;
3608 }
3609
stbi__pic_test_core(stbi__context * s)3610 static int stbi__pic_test_core(stbi__context *s)
3611 {
3612 int i;
3613
3614 if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
3615 return 0;
3616
3617 for(i=0;i<84;++i)
3618 stbi__get8(s);
3619
3620 if (!stbi__pic_is4(s,"PICT"))
3621 return 0;
3622
3623 return 1;
3624 }
3625
3626 typedef struct
3627 {
3628 stbi_uc size,type,channel;
3629 } stbi__pic_packet;
3630
stbi__readval(stbi__context * s,int channel,stbi_uc * dest)3631 static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
3632 {
3633 int mask=0x80, i;
3634
3635 for (i=0; i<4; ++i, mask>>=1) {
3636 if (channel & mask) {
3637 if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
3638 dest[i]=stbi__get8(s);
3639 }
3640 }
3641
3642 return dest;
3643 }
3644
stbi__copyval(int channel,stbi_uc * dest,const stbi_uc * src)3645 static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
3646 {
3647 int mask=0x80,i;
3648
3649 for (i=0;i<4; ++i, mask>>=1)
3650 if (channel&mask)
3651 dest[i]=src[i];
3652 }
3653
stbi__pic_load_core(stbi__context * s,int width,int height,int * comp,stbi_uc * result)3654 static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
3655 {
3656 int act_comp=0,num_packets=0,y,chained;
3657 stbi__pic_packet packets[10];
3658
3659 // this will (should...) cater for even some bizarre stuff like having data
3660 // for the same channel in multiple packets.
3661 do {
3662 stbi__pic_packet *packet;
3663
3664 if (num_packets==sizeof(packets)/sizeof(packets[0]))
3665 return stbi__errpuc("bad format","too many packets");
3666
3667 packet = &packets[num_packets++];
3668
3669 chained = stbi__get8(s);
3670 packet->size = stbi__get8(s);
3671 packet->type = stbi__get8(s);
3672 packet->channel = stbi__get8(s);
3673
3674 act_comp |= packet->channel;
3675
3676 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");
3677 if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");
3678 } while (chained);
3679
3680 *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
3681
3682 for(y=0; y<height; ++y) {
3683 int packet_idx;
3684
3685 for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
3686 stbi__pic_packet *packet = &packets[packet_idx];
3687 stbi_uc *dest = result+y*width*4;
3688
3689 switch (packet->type) {
3690 default:
3691 return stbi__errpuc("bad format","packet has bad compression type");
3692
3693 case 0: {//uncompressed
3694 int x;
3695
3696 for(x=0;x<width;++x, dest+=4)
3697 if (!stbi__readval(s,packet->channel,dest))
3698 return 0;
3699 break;
3700 }
3701
3702 case 1://Pure RLE
3703 {
3704 int left=width, i;
3705
3706 while (left>0) {
3707 stbi_uc count,value[4];
3708
3709 count=stbi__get8(s);
3710 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");
3711
3712 if (count > left)
3713 count = (stbi_uc) left;
3714
3715 if (!stbi__readval(s,packet->channel,value)) return 0;
3716
3717 for(i=0; i<count; ++i,dest+=4)
3718 stbi__copyval(packet->channel,dest,value);
3719 left -= count;
3720 }
3721 }
3722 break;
3723
3724 case 2: {//Mixed RLE
3725 int left=width;
3726 while (left>0) {
3727 int count = stbi__get8(s), i;
3728 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");
3729
3730 if (count >= 128) { // Repeated
3731 stbi_uc value[4];
3732 int i;
3733
3734 if (count==128)
3735 count = stbi__get16be(s);
3736 else
3737 count -= 127;
3738 if (count > left)
3739 return stbi__errpuc("bad file","scanline overrun");
3740
3741 if (!stbi__readval(s,packet->channel,value))
3742 return 0;
3743
3744 for(i=0;i<count;++i, dest += 4)
3745 stbi__copyval(packet->channel,dest,value);
3746 } else { // Raw
3747 ++count;
3748 if (count>left) return stbi__errpuc("bad file","scanline overrun");
3749
3750 for(i=0;i<count;++i, dest+=4)
3751 if (!stbi__readval(s,packet->channel,dest))
3752 return 0;
3753 }
3754 left-=count;
3755 }
3756 break;
3757 }
3758 }
3759 }
3760 }
3761
3762 return result;
3763 }
3764
stbi__pic_load(stbi__context * s,int * px,int * py,int * comp,int req_comp)3765 static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp)
3766 {
3767 stbi_uc *result;
3768 int i, x,y;
3769
3770 for (i=0; i<92; ++i)
3771 stbi__get8(s);
3772
3773 x = stbi__get16be(s);
3774 y = stbi__get16be(s);
3775 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");
3776 if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to stbi__jpeg_huff_decode");
3777
3778 stbi__get32be(s); //skip `ratio'
3779 stbi__get16be(s); //skip `fields'
3780 stbi__get16be(s); //skip `pad'
3781
3782 // intermediate buffer is RGBA
3783 result = (stbi_uc *) malloc(x*y*4);
3784 memset(result, 0xff, x*y*4);
3785
3786 if (!stbi__pic_load_core(s,x,y,comp, result)) {
3787 free(result);
3788 result=0;
3789 }
3790 *px = x;
3791 *py = y;
3792 if (req_comp == 0) req_comp = *comp;
3793 result=stbi__convert_format(result,4,req_comp,x,y);
3794
3795 return result;
3796 }
3797
stbi__pic_test(stbi__context * s)3798 static int stbi__pic_test(stbi__context *s)
3799 {
3800 int r = stbi__pic_test_core(s);
3801 stbi__rewind(s);
3802 return r;
3803 }
3804
3805 // *************************************************************************************************
3806 // GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
3807 typedef struct
3808 {
3809 stbi__int16 prefix;
3810 stbi_uc first;
3811 stbi_uc suffix;
3812 } stbi__gif_lzw;
3813
3814 typedef struct
3815 {
3816 int w,h;
3817 stbi_uc *out; // output buffer (always 4 components)
3818 int flags, bgindex, ratio, transparent, eflags;
3819 stbi_uc pal[256][4];
3820 stbi_uc lpal[256][4];
3821 stbi__gif_lzw codes[4096];
3822 stbi_uc *color_table;
3823 int parse, step;
3824 int lflags;
3825 int start_x, start_y;
3826 int max_x, max_y;
3827 int cur_x, cur_y;
3828 int line_size;
3829 } stbi__gif;
3830
stbi__gif_test_raw(stbi__context * s)3831 static int stbi__gif_test_raw(stbi__context *s)
3832 {
3833 int sz;
3834 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
3835 sz = stbi__get8(s);
3836 if (sz != '9' && sz != '7') return 0;
3837 if (stbi__get8(s) != 'a') return 0;
3838 return 1;
3839 }
3840
stbi__gif_test(stbi__context * s)3841 static int stbi__gif_test(stbi__context *s)
3842 {
3843 int r = stbi__gif_test_raw(s);
3844 stbi__rewind(s);
3845 return r;
3846 }
3847
stbi__gif_parse_colortable(stbi__context * s,stbi_uc pal[256][4],int num_entries,int transp)3848 static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
3849 {
3850 int i;
3851 for (i=0; i < num_entries; ++i) {
3852 pal[i][2] = stbi__get8(s);
3853 pal[i][1] = stbi__get8(s);
3854 pal[i][0] = stbi__get8(s);
3855 pal[i][3] = transp ? 0 : 255;
3856 }
3857 }
3858
stbi__gif_header(stbi__context * s,stbi__gif * g,int * comp,int is_info)3859 static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
3860 {
3861 stbi_uc version;
3862 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
3863 return stbi__err("not GIF", "Corrupt GIF");
3864
3865 version = stbi__get8(s);
3866 if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");
3867 if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");
3868
3869 stbi__g_failure_reason = "";
3870 g->w = stbi__get16le(s);
3871 g->h = stbi__get16le(s);
3872 g->flags = stbi__get8(s);
3873 g->bgindex = stbi__get8(s);
3874 g->ratio = stbi__get8(s);
3875 g->transparent = -1;
3876
3877 if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
3878
3879 if (is_info) return 1;
3880
3881 if (g->flags & 0x80)
3882 stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
3883
3884 return 1;
3885 }
3886
stbi__gif_info_raw(stbi__context * s,int * x,int * y,int * comp)3887 static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
3888 {
3889 stbi__gif g;
3890 if (!stbi__gif_header(s, &g, comp, 1)) {
3891 stbi__rewind( s );
3892 return 0;
3893 }
3894 if (x) *x = g.w;
3895 if (y) *y = g.h;
3896 return 1;
3897 }
3898
stbi__out_gif_code(stbi__gif * g,stbi__uint16 code)3899 static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
3900 {
3901 stbi_uc *p, *c;
3902
3903 // recurse to stbi__jpeg_huff_decode the prefixes, since the linked-list is backwards,
3904 // and working backwards through an interleaved image would be nasty
3905 if (g->codes[code].prefix >= 0)
3906 stbi__out_gif_code(g, g->codes[code].prefix);
3907
3908 if (g->cur_y >= g->max_y) return;
3909
3910 p = &g->out[g->cur_x + g->cur_y];
3911 c = &g->color_table[g->codes[code].suffix * 4];
3912
3913 if (c[3] >= 128) {
3914 p[0] = c[2];
3915 p[1] = c[1];
3916 p[2] = c[0];
3917 p[3] = c[3];
3918 }
3919 g->cur_x += 4;
3920
3921 if (g->cur_x >= g->max_x) {
3922 g->cur_x = g->start_x;
3923 g->cur_y += g->step;
3924
3925 while (g->cur_y >= g->max_y && g->parse > 0) {
3926 g->step = (1 << g->parse) * g->line_size;
3927 g->cur_y = g->start_y + (g->step >> 1);
3928 --g->parse;
3929 }
3930 }
3931 }
3932
stbi__process_gif_raster(stbi__context * s,stbi__gif * g)3933 static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
3934 {
3935 stbi_uc lzw_cs;
3936 stbi__int32 len, code;
3937 stbi__uint32 first;
3938 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
3939 stbi__gif_lzw *p;
3940
3941 lzw_cs = stbi__get8(s);
3942 clear = 1 << lzw_cs;
3943 first = 1;
3944 codesize = lzw_cs + 1;
3945 codemask = (1 << codesize) - 1;
3946 bits = 0;
3947 valid_bits = 0;
3948 for (code = 0; code < clear; code++) {
3949 g->codes[code].prefix = -1;
3950 g->codes[code].first = (stbi_uc) code;
3951 g->codes[code].suffix = (stbi_uc) code;
3952 }
3953
3954 // support no starting clear code
3955 avail = clear+2;
3956 oldcode = -1;
3957
3958 len = 0;
3959 for(;;) {
3960 if (valid_bits < codesize) {
3961 if (len == 0) {
3962 len = stbi__get8(s); // start new block
3963 if (len == 0)
3964 return g->out;
3965 }
3966 --len;
3967 bits |= (stbi__int32) stbi__get8(s) << valid_bits;
3968 valid_bits += 8;
3969 } else {
3970 stbi__int32 code = bits & codemask;
3971 bits >>= codesize;
3972 valid_bits -= codesize;
3973 // @OPTIMIZE: is there some way we can accelerate the non-clear path?
3974 if (code == clear) { // clear code
3975 codesize = lzw_cs + 1;
3976 codemask = (1 << codesize) - 1;
3977 avail = clear + 2;
3978 oldcode = -1;
3979 first = 0;
3980 } else if (code == clear + 1) { // end of stream code
3981 stbi__skip(s, len);
3982 while ((len = stbi__get8(s)) > 0)
3983 stbi__skip(s,len);
3984 return g->out;
3985 } else if (code <= avail) {
3986 if (first) return stbi__errpuc("no clear code", "Corrupt GIF");
3987
3988 if (oldcode >= 0) {
3989 p = &g->codes[avail++];
3990 if (avail > 4096) return stbi__errpuc("too many codes", "Corrupt GIF");
3991 p->prefix = (stbi__int16) oldcode;
3992 p->first = g->codes[oldcode].first;
3993 p->suffix = (code == avail) ? p->first : g->codes[code].first;
3994 } else if (code == avail)
3995 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
3996
3997 stbi__out_gif_code(g, (stbi__uint16) code);
3998
3999 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
4000 codesize++;
4001 codemask = (1 << codesize) - 1;
4002 }
4003
4004 oldcode = code;
4005 } else {
4006 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
4007 }
4008 }
4009 }
4010 }
4011
stbi__fill_gif_background(stbi__gif * g)4012 static void stbi__fill_gif_background(stbi__gif *g)
4013 {
4014 int i;
4015 stbi_uc *c = g->pal[g->bgindex];
4016 // @OPTIMIZE: write a dword at a time
4017 for (i = 0; i < g->w * g->h * 4; i += 4) {
4018 stbi_uc *p = &g->out[i];
4019 p[0] = c[2];
4020 p[1] = c[1];
4021 p[2] = c[0];
4022 p[3] = c[3];
4023 }
4024 }
4025
4026 // this function is designed to support animated gifs, although stb_image doesn't support it
stbi__gif_load_next(stbi__context * s,stbi__gif * g,int * comp,int req_comp)4027 static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp)
4028 {
4029 int i;
4030 stbi_uc *old_out = 0;
4031
4032 if (g->out == 0) {
4033 if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
4034 g->out = (stbi_uc *) malloc(4 * g->w * g->h);
4035 if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory");
4036 stbi__fill_gif_background(g);
4037 } else {
4038 // animated-gif-only path
4039 if (((g->eflags & 0x1C) >> 2) == 3) {
4040 old_out = g->out;
4041 g->out = (stbi_uc *) malloc(4 * g->w * g->h);
4042 if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory");
4043 memcpy(g->out, old_out, g->w*g->h*4);
4044 }
4045 }
4046
4047 for (;;) {
4048 switch (stbi__get8(s)) {
4049 case 0x2C: /* Image Descriptor */
4050 {
4051 stbi__int32 x, y, w, h;
4052 stbi_uc *o;
4053
4054 x = stbi__get16le(s);
4055 y = stbi__get16le(s);
4056 w = stbi__get16le(s);
4057 h = stbi__get16le(s);
4058 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
4059 return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
4060
4061 g->line_size = g->w * 4;
4062 g->start_x = x * 4;
4063 g->start_y = y * g->line_size;
4064 g->max_x = g->start_x + w * 4;
4065 g->max_y = g->start_y + h * g->line_size;
4066 g->cur_x = g->start_x;
4067 g->cur_y = g->start_y;
4068
4069 g->lflags = stbi__get8(s);
4070
4071 if (g->lflags & 0x40) {
4072 g->step = 8 * g->line_size; // first interlaced spacing
4073 g->parse = 3;
4074 } else {
4075 g->step = g->line_size;
4076 g->parse = 0;
4077 }
4078
4079 if (g->lflags & 0x80) {
4080 stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
4081 g->color_table = (stbi_uc *) g->lpal;
4082 } else if (g->flags & 0x80) {
4083 for (i=0; i < 256; ++i) // @OPTIMIZE: stbi__jpeg_reset only the previous transparent
4084 g->pal[i][3] = 255;
4085 if (g->transparent >= 0 && (g->eflags & 0x01))
4086 g->pal[g->transparent][3] = 0;
4087 g->color_table = (stbi_uc *) g->pal;
4088 } else
4089 return stbi__errpuc("missing color table", "Corrupt GIF");
4090
4091 o = stbi__process_gif_raster(s, g);
4092 if (o == NULL) return NULL;
4093
4094 if (req_comp && req_comp != 4)
4095 o = stbi__convert_format(o, 4, req_comp, g->w, g->h);
4096 return o;
4097 }
4098
4099 case 0x21: // Comment Extension.
4100 {
4101 int len;
4102 if (stbi__get8(s) == 0xF9) { // Graphic Control Extension.
4103 len = stbi__get8(s);
4104 if (len == 4) {
4105 g->eflags = stbi__get8(s);
4106 stbi__get16le(s); // delay
4107 g->transparent = stbi__get8(s);
4108 } else {
4109 stbi__skip(s, len);
4110 break;
4111 }
4112 }
4113 while ((len = stbi__get8(s)) != 0)
4114 stbi__skip(s, len);
4115 break;
4116 }
4117
4118 case 0x3B: // gif stream termination code
4119 return (stbi_uc *) 1;
4120
4121 default:
4122 return stbi__errpuc("unknown code", "Corrupt GIF");
4123 }
4124 }
4125 }
4126
stbi__gif_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)4127 static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
4128 {
4129 stbi_uc *u = 0;
4130 stbi__gif g;
4131 memset(&g, 0, sizeof(stbi__gif));
4132
4133 u = stbi__gif_load_next(s, &g, comp, req_comp);
4134 if (u == (void *) 1) u = 0; // end of animated gif marker
4135 if (u) {
4136 *x = g.w;
4137 *y = g.h;
4138 }
4139
4140 return u;
4141 }
4142
stbi__gif_info(stbi__context * s,int * x,int * y,int * comp)4143 static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
4144 {
4145 return stbi__gif_info_raw(s,x,y,comp);
4146 }
4147
4148
4149 // *************************************************************************************************
4150 // Radiance RGBE HDR loader
4151 // originally by Nicolas Schulz
4152 #ifndef STBI_NO_HDR
stbi__hdr_test_core(stbi__context * s)4153 static int stbi__hdr_test_core(stbi__context *s)
4154 {
4155 const char *signature = "#?RADIANCE\n";
4156 int i;
4157 for (i=0; signature[i]; ++i)
4158 if (stbi__get8(s) != signature[i])
4159 return 0;
4160 return 1;
4161 }
4162
stbi__hdr_test(stbi__context * s)4163 static int stbi__hdr_test(stbi__context* s)
4164 {
4165 int r = stbi__hdr_test_core(s);
4166 stbi__rewind(s);
4167 return r;
4168 }
4169
4170 #define STBI__HDR_BUFLEN 1024
stbi__hdr_gettoken(stbi__context * z,char * buffer)4171 static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
4172 {
4173 int len=0;
4174 char c = '\0';
4175
4176 c = (char) stbi__get8(z);
4177
4178 while (!stbi__at_eof(z) && c != '\n') {
4179 buffer[len++] = c;
4180 if (len == STBI__HDR_BUFLEN-1) {
4181 // flush to end of line
4182 while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
4183 ;
4184 break;
4185 }
4186 c = (char) stbi__get8(z);
4187 }
4188
4189 buffer[len] = 0;
4190 return buffer;
4191 }
4192
stbi__hdr_convert(float * output,stbi_uc * input,int req_comp)4193 static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
4194 {
4195 if ( input[3] != 0 ) {
4196 float f1;
4197 // Exponent
4198 f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
4199 if (req_comp <= 2)
4200 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
4201 else {
4202 output[0] = input[0] * f1;
4203 output[1] = input[1] * f1;
4204 output[2] = input[2] * f1;
4205 }
4206 if (req_comp == 2) output[1] = 1;
4207 if (req_comp == 4) output[3] = 1;
4208 } else {
4209 switch (req_comp) {
4210 case 4: output[3] = 1; /* fallthrough */
4211 case 3: output[0] = output[1] = output[2] = 0;
4212 break;
4213 case 2: output[1] = 1; /* fallthrough */
4214 case 1: output[0] = 0;
4215 break;
4216 }
4217 }
4218 }
4219
stbi__hdr_load(stbi__context * s,int * x,int * y,int * comp,int req_comp)4220 static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
4221 {
4222 char buffer[STBI__HDR_BUFLEN];
4223 char *token;
4224 int valid = 0;
4225 int width, height;
4226 stbi_uc *scanline;
4227 float *hdr_data;
4228 int len;
4229 unsigned char count, value;
4230 int i, j, k, c1,c2, z;
4231
4232
4233 // Check identifier
4234 if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
4235 return stbi__errpf("not HDR", "Corrupt HDR image");
4236
4237 // Parse header
4238 for(;;) {
4239 token = stbi__hdr_gettoken(s,buffer);
4240 if (token[0] == 0) break;
4241 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
4242 }
4243
4244 if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");
4245
4246 // Parse width and height
4247 // can't use sscanf() if we're not using stdio!
4248 token = stbi__hdr_gettoken(s,buffer);
4249 if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
4250 token += 3;
4251 height = (int) strtol(token, &token, 10);
4252 while (*token == ' ') ++token;
4253 if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
4254 token += 3;
4255 width = (int) strtol(token, NULL, 10);
4256
4257 *x = width;
4258 *y = height;
4259
4260 if (comp) *comp = 3;
4261 if (req_comp == 0) req_comp = 3;
4262
4263 // Read data
4264 hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
4265
4266 // Load image data
4267 // image data is stored as some number of sca
4268 if ( width < 8 || width >= 32768) {
4269 // Read flat data
4270 for (j=0; j < height; ++j) {
4271 for (i=0; i < width; ++i) {
4272 stbi_uc rgbe[4];
4273 main_decode_loop:
4274 stbi__getn(s, rgbe, 4);
4275 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
4276 }
4277 }
4278 } else {
4279 // Read RLE-encoded data
4280 scanline = NULL;
4281
4282 for (j = 0; j < height; ++j) {
4283 c1 = stbi__get8(s);
4284 c2 = stbi__get8(s);
4285 len = stbi__get8(s);
4286 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
4287 // not run-length encoded, so we have to actually use THIS data as a decoded
4288 // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
4289 stbi_uc rgbe[4];
4290 rgbe[0] = (stbi_uc) c1;
4291 rgbe[1] = (stbi_uc) c2;
4292 rgbe[2] = (stbi_uc) len;
4293 rgbe[3] = (stbi_uc) stbi__get8(s);
4294 stbi__hdr_convert(hdr_data, rgbe, req_comp);
4295 i = 1;
4296 j = 0;
4297 free(scanline);
4298 goto main_decode_loop; // yes, this makes no sense
4299 }
4300 len <<= 8;
4301 len |= stbi__get8(s);
4302 if (len != width) { free(hdr_data); free(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
4303 if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
4304
4305 for (k = 0; k < 4; ++k) {
4306 i = 0;
4307 while (i < width) {
4308 count = stbi__get8(s);
4309 if (count > 128) {
4310 // Run
4311 value = stbi__get8(s);
4312 count -= 128;
4313 for (z = 0; z < count; ++z)
4314 scanline[i++ * 4 + k] = value;
4315 } else {
4316 // Dump
4317 for (z = 0; z < count; ++z)
4318 scanline[i++ * 4 + k] = stbi__get8(s);
4319 }
4320 }
4321 }
4322 for (i=0; i < width; ++i)
4323 stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
4324 }
4325 free(scanline);
4326 }
4327
4328 return hdr_data;
4329 }
4330
stbi__hdr_info(stbi__context * s,int * x,int * y,int * comp)4331 static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
4332 {
4333 char buffer[STBI__HDR_BUFLEN];
4334 char *token;
4335 int valid = 0;
4336
4337 if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
4338 stbi__rewind( s );
4339 return 0;
4340 }
4341
4342 for(;;) {
4343 token = stbi__hdr_gettoken(s,buffer);
4344 if (token[0] == 0) break;
4345 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
4346 }
4347
4348 if (!valid) {
4349 stbi__rewind( s );
4350 return 0;
4351 }
4352 token = stbi__hdr_gettoken(s,buffer);
4353 if (strncmp(token, "-Y ", 3)) {
4354 stbi__rewind( s );
4355 return 0;
4356 }
4357 token += 3;
4358 *y = (int) strtol(token, &token, 10);
4359 while (*token == ' ') ++token;
4360 if (strncmp(token, "+X ", 3)) {
4361 stbi__rewind( s );
4362 return 0;
4363 }
4364 token += 3;
4365 *x = (int) strtol(token, NULL, 10);
4366 *comp = 3;
4367 return 1;
4368 }
4369 #endif // STBI_NO_HDR
4370
stbi__bmp_info(stbi__context * s,int * x,int * y,int * comp)4371 static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
4372 {
4373 int hsz;
4374 if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') {
4375 stbi__rewind( s );
4376 return 0;
4377 }
4378 stbi__skip(s,12);
4379 hsz = stbi__get32le(s);
4380 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) {
4381 stbi__rewind( s );
4382 return 0;
4383 }
4384 if (hsz == 12) {
4385 *x = stbi__get16le(s);
4386 *y = stbi__get16le(s);
4387 } else {
4388 *x = stbi__get32le(s);
4389 *y = stbi__get32le(s);
4390 }
4391 if (stbi__get16le(s) != 1) {
4392 stbi__rewind( s );
4393 return 0;
4394 }
4395 *comp = stbi__get16le(s) / 8;
4396 return 1;
4397 }
4398
stbi__psd_info(stbi__context * s,int * x,int * y,int * comp)4399 static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
4400 {
4401 int channelCount;
4402 if (stbi__get32be(s) != 0x38425053) {
4403 stbi__rewind( s );
4404 return 0;
4405 }
4406 if (stbi__get16be(s) != 1) {
4407 stbi__rewind( s );
4408 return 0;
4409 }
4410 stbi__skip(s, 6);
4411 channelCount = stbi__get16be(s);
4412 if (channelCount < 0 || channelCount > 16) {
4413 stbi__rewind( s );
4414 return 0;
4415 }
4416 *y = stbi__get32be(s);
4417 *x = stbi__get32be(s);
4418 if (stbi__get16be(s) != 8) {
4419 stbi__rewind( s );
4420 return 0;
4421 }
4422 if (stbi__get16be(s) != 3) {
4423 stbi__rewind( s );
4424 return 0;
4425 }
4426 *comp = 4;
4427 return 1;
4428 }
4429
stbi__pic_info(stbi__context * s,int * x,int * y,int * comp)4430 static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
4431 {
4432 int act_comp=0,num_packets=0,chained;
4433 stbi__pic_packet packets[10];
4434
4435 stbi__skip(s, 92);
4436
4437 *x = stbi__get16be(s);
4438 *y = stbi__get16be(s);
4439 if (stbi__at_eof(s)) return 0;
4440 if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
4441 stbi__rewind( s );
4442 return 0;
4443 }
4444
4445 stbi__skip(s, 8);
4446
4447 do {
4448 stbi__pic_packet *packet;
4449
4450 if (num_packets==sizeof(packets)/sizeof(packets[0]))
4451 return 0;
4452
4453 packet = &packets[num_packets++];
4454 chained = stbi__get8(s);
4455 packet->size = stbi__get8(s);
4456 packet->type = stbi__get8(s);
4457 packet->channel = stbi__get8(s);
4458 act_comp |= packet->channel;
4459
4460 if (stbi__at_eof(s)) {
4461 stbi__rewind( s );
4462 return 0;
4463 }
4464 if (packet->size != 8) {
4465 stbi__rewind( s );
4466 return 0;
4467 }
4468 } while (chained);
4469
4470 *comp = (act_comp & 0x10 ? 4 : 3);
4471
4472 return 1;
4473 }
4474
stbi__info_main(stbi__context * s,int * x,int * y,int * comp)4475 static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
4476 {
4477 if (stbi__jpeg_info(s, x, y, comp))
4478 return 1;
4479 if (stbi__png_info(s, x, y, comp))
4480 return 1;
4481 if (stbi__gif_info(s, x, y, comp))
4482 return 1;
4483 if (stbi__bmp_info(s, x, y, comp))
4484 return 1;
4485 if (stbi__psd_info(s, x, y, comp))
4486 return 1;
4487 if (stbi__pic_info(s, x, y, comp))
4488 return 1;
4489 #ifndef STBI_NO_HDR
4490 if (stbi__hdr_info(s, x, y, comp))
4491 return 1;
4492 #endif
4493 // test tga last because it's a crappy test!
4494 if (stbi__tga_info(s, x, y, comp))
4495 return 1;
4496 return stbi__err("unknown image type", "Image not of any known type, or corrupt");
4497 }
4498
4499 #ifndef STBI_NO_STDIO
stbi_info(char const * filename,int * x,int * y,int * comp)4500 STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
4501 {
4502 FILE *f = fopen(filename, "rb");
4503 int result;
4504 if (!f) return stbi__err("can't fopen", "Unable to open file");
4505 result = stbi_info_from_file(f, x, y, comp);
4506 fclose(f);
4507 return result;
4508 }
4509
stbi_info_from_file(FILE * f,int * x,int * y,int * comp)4510 STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
4511 {
4512 int r;
4513 stbi__context s;
4514 long pos = ftell(f);
4515 stbi__start_file(&s, f);
4516 r = stbi__info_main(&s,x,y,comp);
4517 fseek(f,pos,SEEK_SET);
4518 return r;
4519 }
4520 #endif // !STBI_NO_STDIO
4521
stbi_info_from_memory(stbi_uc const * buffer,int len,int * x,int * y,int * comp)4522 STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
4523 {
4524 stbi__context s;
4525 stbi__start_mem(&s,buffer,len);
4526 return stbi__info_main(&s,x,y,comp);
4527 }
4528
stbi_info_from_callbacks(stbi_io_callbacks const * c,void * user,int * x,int * y,int * comp)4529 STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
4530 {
4531 stbi__context s;
4532 stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
4533 return stbi__info_main(&s,x,y,comp);
4534 }
4535
4536 #endif // STB_IMAGE_IMPLEMENTATION
4537
4538 #if !defined(STBI_NO_STDIO) && defined(_MSC_VER) && _MSC_VER >= 1400
4539 #pragma warning(pop)
4540 #endif
4541
4542
4543 /*
4544 revision history:
4545 1.39 (2014-06-15)
4546 fix to TGA optimization when req_comp != number of components in TGA;
4547 fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
4548 add support for BMP version 5 (more ignored fields)
4549 1.38 (2014-06-06)
4550 suppress MSVC warnings on integer casts truncating values
4551 fix accidental rename of 'skip' field of I/O
4552 1.37 (2014-06-04)
4553 remove duplicate typedef
4554 1.36 (2014-06-03)
4555 convert to header file single-file library
4556 if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
4557 1.35 (2014-05-27)
4558 various warnings
4559 fix broken STBI_SIMD path
4560 fix bug where stbi_load_from_file no longer left file pointer in correct place
4561 fix broken non-easy path for 32-bit BMP (possibly never used)
4562 TGA optimization by Arseny Kapoulkine
4563 1.34 (unknown)
4564 use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
4565 1.33 (2011-07-14)
4566 make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
4567 1.32 (2011-07-13)
4568 support for "info" function for all supported filetypes (SpartanJ)
4569 1.31 (2011-06-20)
4570 a few more leak fixes, bug in PNG handling (SpartanJ)
4571 1.30 (2011-06-11)
4572 added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
4573 removed deprecated format-specific test/load functions
4574 removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
4575 error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
4576 fix inefficiency in decoding 32-bit BMP (David Woo)
4577 1.29 (2010-08-16)
4578 various warning fixes from Aurelien Pocheville
4579 1.28 (2010-08-01)
4580 fix bug in GIF palette transparency (SpartanJ)
4581 1.27 (2010-08-01)
4582 cast-to-stbi_uc to fix warnings
4583 1.26 (2010-07-24)
4584 fix bug in file buffering for PNG reported by SpartanJ
4585 1.25 (2010-07-17)
4586 refix trans_data warning (Won Chun)
4587 1.24 (2010-07-12)
4588 perf improvements reading from files on platforms with lock-heavy fgetc()
4589 minor perf improvements for jpeg
4590 deprecated type-specific functions so we'll get feedback if they're needed
4591 attempt to fix trans_data warning (Won Chun)
4592 1.23 fixed bug in iPhone support
4593 1.22 (2010-07-10)
4594 removed image *writing* support
4595 stbi_info support from Jetro Lauha
4596 GIF support from Jean-Marc Lienher
4597 iPhone PNG-extensions from James Brown
4598 warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
4599 1.21 fix use of 'stbi_uc' in header (reported by jon blow)
4600 1.20 added support for Softimage PIC, by Tom Seddon
4601 1.19 bug in interlaced PNG corruption check (found by ryg)
4602 1.18 2008-08-02
4603 fix a threading bug (local mutable static)
4604 1.17 support interlaced PNG
4605 1.16 major bugfix - stbi__convert_format converted one too many pixels
4606 1.15 initialize some fields for thread safety
4607 1.14 fix threadsafe conversion bug
4608 header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
4609 1.13 threadsafe
4610 1.12 const qualifiers in the API
4611 1.11 Support installable IDCT, colorspace conversion routines
4612 1.10 Fixes for 64-bit (don't use "unsigned long")
4613 optimized upsampling by Fabian "ryg" Giesen
4614 1.09 Fix format-conversion for PSD code (bad global variables!)
4615 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
4616 1.07 attempt to fix C++ warning/errors again
4617 1.06 attempt to fix C++ warning/errors again
4618 1.05 fix TGA loading to return correct *comp and use good luminance calc
4619 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
4620 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
4621 1.02 support for (subset of) HDR files, float interface for preferred access to them
4622 1.01 fix bug: possible bug in handling right-side up bmps... not sure
4623 fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
4624 1.00 interface to zlib that skips zlib header
4625 0.99 correct handling of alpha in palette
4626 0.98 TGA loader by lonesock; dynamically add loaders (untested)
4627 0.97 jpeg errors on too large a file; also catch another malloc failure
4628 0.96 fix detection of invalid v value - particleman@mollyrocket forum
4629 0.95 during header scan, seek to markers in case of padding
4630 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
4631 0.93 handle jpegtran output; verbose errors
4632 0.92 read 4,8,16,24,32-bit BMP files of several formats
4633 0.91 output 24-bit Windows 3.0 BMP files
4634 0.90 fix a few more warnings; bump version number to approach 1.0
4635 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
4636 0.60 fix compiling as c++
4637 0.59 fix warnings: merge Dave Moore's -Wall fixes
4638 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
4639 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
4640 0.56 fix bug: zlib uncompressed mode len vs. nlen
4641 0.55 fix bug: restart_interval not initialized to 0
4642 0.54 allow NULL for 'int *comp'
4643 0.53 fix bug in png 3->4; speedup png decoding
4644 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
4645 0.51 obey req_comp requests, 1-component jpegs return as 1-component,
4646 on 'test' only check type, not whether we support this variant
4647 0.50 first released version
4648 */
4649