1 /* stbi-1.29 - 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
6 Primarily of interest to game developers and other people who can
7 avoid problematic images and only need the trivial interface
9 JPEG baseline (no JPEG progressive)
12 TGA (not sure what subset, if a subset)
14 PSD (composited view only, no extra channels)
16 GIF (*comp always reports as 4-channel)
17 HDR (radiance rgbE format)
20 - decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)
21 - supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
24 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville
25 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
26 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila)
27 allow trailing 0s at end of image data (Laurent Gomila)
28 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ
29 1.25 (2010-07-17) refix trans_data warning (Won Chun)
30 1.24 (2010-07-12) perf improvements reading from files
31 minor perf improvements for jpeg
32 deprecated type-specific functions in hope of feedback
33 attempt to fix trans_data warning (Won Chun)
34 1.23 fixed bug in iPhone support
35 1.22 (2010-07-10) removed image *writing* support to stb_image_write.h
36 stbi_info support from Jetro Lauha
37 GIF support from Jean-Marc Lienher
38 iPhone PNG-extensions from James Brown
39 warning-fixes from Nicolas Schulz and Janez Zemva
40 1.21 fix use of 'uint8' in header (reported by jon blow)
41 1.20 added support for Softimage PIC, by Tom Seddon
43 See end of file for full revision history.
46 stbi_info support for BMP,PSD,HDR,PIC
47 rewrite stbi_info and load_file variations to share file handling code
48 (current system allows individual functions to be called directly,
49 since each does all the work, but I doubt anyone uses this in practice)
52 ============================ Contributors =========================
54 Image formats Optimizations & bugfixes
55 Sean Barrett (jpeg, png, bmp) Fabian "ryg" Giesen
56 Nicolas Schulz (hdr, psd)
57 Jonathan Dummer (tga) Bug fixes & warning fixes
58 Jean-Marc Lienher (gif) Marc LeBlanc
59 Tom Seddon (pic) Christpher Lloyd
60 Thatcher Ulrich (psd) Dave Moore
63 Extensions, features Janez Zemva
64 Jetro Lauha (stbi_info) Jonathan Blow
65 James "moose2000" Brown (iPhone PNG) Laurent Gomila
68 If your name should be here but isn't, let Sean know.
73 #include <dev/stbi/stbiconfig.h>
76 #ifndef STBI_INCLUDE_STB_IMAGE_H
77 #define STBI_INCLUDE_STB_IMAGE_H
79 // To get a header file for this, either cut and paste the header,
80 // or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and
81 // then include stb_image.c from it.
83 //// begin header file ////////////////////////////////////////////////////
86 // - no jpeg progressive support
87 // - non-HDR formats support 8-bit samples only (jpeg, png)
88 // - no delayed line count (jpeg) -- IJG doesn't support either
90 // - GIF always returns *comp=4
92 // Basic usage (see HDR discussion below):
94 // unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
95 // // ... process data if not NULL ...
96 // // ... x = width, y = height, n = # 8-bit components per pixel ...
97 // // ... replace '0' with '1'..'4' to force that many components per pixel
98 // stbi_image_free(data)
100 // Standard parameters:
101 // int *x -- outputs image width in pixels
102 // int *y -- outputs image height in pixels
103 // int *comp -- outputs # of image components in image file
104 // int req_comp -- if non-zero, # of image components requested in result
106 // The return value from an image loader is an 'unsigned char *' which points
107 // to the pixel data. The pixel data consists of *y scanlines of *x pixels,
108 // with each pixel consisting of N interleaved 8-bit components; the first
109 // pixel pointed to is top-left-most in the image. There is no padding between
110 // image scanlines or between pixels, regardless of format. The number of
111 // components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
112 // If req_comp is non-zero, *comp has the number of components that _would_
113 // have been output otherwise. E.g. if you set req_comp to 4, you will always
114 // get RGBA output, but you can check *comp to easily see if it's opaque.
116 // An output image with N components has the following components interleaved
117 // in this order in each pixel:
119 // N=#comp components
122 // 3 red, green, blue
123 // 4 red, green, blue, alpha
125 // If image loading fails for any reason, the return value will be NULL,
126 // and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
127 // can be queried for an extremely brief, end-user unfriendly explanation
128 // of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
129 // compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
130 // more user-friendly ones.
132 // Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
134 // ===========================================================================
136 // iPhone PNG support:
138 // By default we convert iphone-formatted PNGs back to RGB; nominally they
139 // would silently load as BGR, except the existing code should have just
140 // failed on such iPhone PNGs. But you can disable this conversion by
141 // by calling stbi_convert_iphone_png_to_rgb(0), in which case
142 // you will always just get the native iphone "format" through.
144 // Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
145 // pixel to remove any premultiplied alpha *only* if the image file explicitly
146 // says there's premultiplied data (currently only happens in iPhone images,
147 // and only if iPhone convert-to-rgb processing is on).
149 // ===========================================================================
151 // HDR image support (disable by defining STBI_NO_HDR)
153 // stb_image now supports loading HDR images in general, and currently
154 // the Radiance .HDR file format, although the support is provided
155 // generically. You can still load any file through the existing interface;
156 // if you attempt to load an HDR file, it will be automatically remapped to
157 // LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
158 // both of these constants can be reconfigured through this interface:
160 // stbi_hdr_to_ldr_gamma(2.2f);
161 // stbi_hdr_to_ldr_scale(1.0f);
163 // (note, do not use _inverse_ constants; stbi_image will invert them
166 // Additionally, there is a new, parallel interface for loading files as
167 // (linear) floats to preserve the full dynamic range:
169 // float *data = stbi_loadf(filename, &x, &y, &n, 0);
171 // If you load LDR images through this interface, those images will
172 // be promoted to floating point values, run through the inverse of
173 // constants corresponding to the above:
175 // stbi_ldr_to_hdr_scale(1.0f);
176 // stbi_ldr_to_hdr_gamma(2.2f);
178 // Finally, given a filename (or an open file or memory block--see header
179 // file for details) containing image data, you can query for the "most
180 // appropriate" interface to use (that is, whether the image is HDR or
183 // stbi_is_hdr(char *filename);
185 #ifndef STBI_NO_STDIO
189 #define STBI_VERSION 1
193 STBI_default
= 0, // only used for req_comp
201 typedef unsigned char stbi_uc
;
207 // PRIMARY API - works on images of any type
209 // load image by filename, open file, or memory buffer
210 extern stbi_uc
*stbi_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
212 #ifndef STBI_NO_STDIO
213 extern stbi_uc
*stbi_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
214 extern stbi_uc
*stbi_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
215 // for stbi_load_from_file, file pointer is left pointing immediately after image
219 extern float *stbi_loadf_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
221 #ifndef STBI_NO_STDIO
222 extern float *stbi_loadf (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
223 extern float *stbi_loadf_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
226 extern void stbi_hdr_to_ldr_gamma(float gamma
);
227 extern void stbi_hdr_to_ldr_scale(float scale
);
229 extern void stbi_ldr_to_hdr_gamma(float gamma
);
230 extern void stbi_ldr_to_hdr_scale(float scale
);
231 #endif // STBI_NO_HDR
233 // get a VERY brief reason for failure
235 extern const char *stbi_failure_reason (void);
237 // free the loaded image -- this is just free()
238 extern void stbi_image_free (void *retval_from_stbi_load
);
240 // get image dimensions & components without fully decoding
241 extern int stbi_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
242 extern int stbi_is_hdr_from_memory(stbi_uc
const *buffer
, int len
);
244 #ifndef STBI_NO_STDIO
245 extern int stbi_info (char const *filename
, int *x
, int *y
, int *comp
);
246 extern int stbi_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
248 extern int stbi_is_hdr (char const *filename
);
249 extern int stbi_is_hdr_from_file(FILE *f
);
252 // for image formats that explicitly notate that they have premultiplied alpha,
253 // we just return the colors as stored in the file. set this flag to force
254 // unpremultiplication. results are undefined if the unpremultiply overflow.
255 extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply
);
257 // indicate whether we should process iphone images back to canonical format,
258 // or just pass them through "as-is"
259 extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert
);
262 // ZLIB client - used by PNG, available for other purposes
264 extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer
, int len
, int initial_size
, int *outlen
);
265 extern char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer
, int len
, int initial_size
, int *outlen
, int parse_header
);
266 extern char *stbi_zlib_decode_malloc(const char *buffer
, int len
, int *outlen
);
267 extern int stbi_zlib_decode_buffer(char *obuffer
, int olen
, const char *ibuffer
, int ilen
);
269 extern char *stbi_zlib_decode_noheader_malloc(const char *buffer
, int len
, int *outlen
);
270 extern int stbi_zlib_decode_noheader_buffer(char *obuffer
, int olen
, const char *ibuffer
, int ilen
);
272 // define new loaders
275 int (*test_memory
)(stbi_uc
const *buffer
, int len
);
276 stbi_uc
* (*load_from_memory
)(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
277 #ifndef STBI_NO_STDIO
278 int (*test_file
)(FILE *f
);
279 stbi_uc
* (*load_from_file
)(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
283 // register a loader by filling out the above structure (you must define ALL functions)
284 // returns 1 if added or already added, 0 if not added (too many loaders)
286 extern int stbi_register_loader(stbi_loader
*loader
);
288 // define faster low-level operations (typically SIMD support)
290 typedef void (*stbi_idct_8x8
)(stbi_uc
*out
, int out_stride
, short data
[64], unsigned short *dequantize
);
291 // compute an integer IDCT on "input"
292 // input[x] = data[x] * dequantize[x]
293 // write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
294 // CLAMP results to 0..255
295 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
);
296 // compute a conversion from YCbCr to RGB
298 // write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
299 // y: Y input channel
300 // cb: Cb input channel; scale/biased to be 0..255
301 // cr: Cr input channel; scale/biased to be 0..255
303 extern void stbi_install_idct(stbi_idct_8x8 func
);
304 extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func
);
310 // TYPE-SPECIFIC ACCESS
312 #ifdef STBI_TYPE_SPECIFIC_FUNCTIONS
315 extern int stbi_jpeg_test_memory (stbi_uc
const *buffer
, int len
);
316 extern stbi_uc
*stbi_jpeg_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
317 extern int stbi_jpeg_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
319 #ifndef STBI_NO_STDIO
320 extern stbi_uc
*stbi_jpeg_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
321 extern int stbi_jpeg_test_file (FILE *f
);
322 extern stbi_uc
*stbi_jpeg_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
324 extern int stbi_jpeg_info (char const *filename
, int *x
, int *y
, int *comp
);
325 extern int stbi_jpeg_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
329 extern int stbi_png_test_memory (stbi_uc
const *buffer
, int len
);
330 extern stbi_uc
*stbi_png_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
331 extern int stbi_png_info_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
333 #ifndef STBI_NO_STDIO
334 extern stbi_uc
*stbi_png_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
335 extern int stbi_png_info (char const *filename
, int *x
, int *y
, int *comp
);
336 extern int stbi_png_test_file (FILE *f
);
337 extern stbi_uc
*stbi_png_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
338 extern int stbi_png_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
342 extern int stbi_bmp_test_memory (stbi_uc
const *buffer
, int len
);
344 extern stbi_uc
*stbi_bmp_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
345 extern stbi_uc
*stbi_bmp_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
346 #ifndef STBI_NO_STDIO
347 extern int stbi_bmp_test_file (FILE *f
);
348 extern stbi_uc
*stbi_bmp_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
352 extern int stbi_tga_test_memory (stbi_uc
const *buffer
, int len
);
354 extern stbi_uc
*stbi_tga_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
355 extern stbi_uc
*stbi_tga_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
356 extern int stbi_tga_info_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
357 #ifndef STBI_NO_STDIO
358 extern int stbi_tga_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
359 extern int stbi_tga_test_file (FILE *f
);
360 extern stbi_uc
*stbi_tga_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
364 extern int stbi_psd_test_memory (stbi_uc
const *buffer
, int len
);
366 extern stbi_uc
*stbi_psd_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
367 extern stbi_uc
*stbi_psd_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
368 #ifndef STBI_NO_STDIO
369 extern int stbi_psd_test_file (FILE *f
);
370 extern stbi_uc
*stbi_psd_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
374 extern int stbi_hdr_test_memory (stbi_uc
const *buffer
, int len
);
376 extern float * stbi_hdr_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
377 extern float * stbi_hdr_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
378 #ifndef STBI_NO_STDIO
379 extern int stbi_hdr_test_file (FILE *f
);
380 extern float * stbi_hdr_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
384 extern int stbi_pic_test_memory (stbi_uc
const *buffer
, int len
);
386 extern stbi_uc
*stbi_pic_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
387 extern stbi_uc
*stbi_pic_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
388 #ifndef STBI_NO_STDIO
389 extern int stbi_pic_test_file (FILE *f
);
390 extern stbi_uc
*stbi_pic_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
394 extern int stbi_gif_test_memory (stbi_uc
const *buffer
, int len
);
396 extern stbi_uc
*stbi_gif_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
397 extern stbi_uc
*stbi_gif_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
398 extern int stbi_gif_info_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
400 #ifndef STBI_NO_STDIO
401 extern int stbi_gif_test_file (FILE *f
);
402 extern stbi_uc
*stbi_gif_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
403 extern int stbi_gif_info (char const *filename
, int *x
, int *y
, int *comp
);
404 extern int stbi_gif_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
407 #endif//STBI_TYPE_SPECIFIC_FUNCTIONS
418 //// end header file /////////////////////////////////////////////////////
419 #endif // STBI_INCLUDE_STB_IMAGE_H
421 #ifndef STBI_HEADER_FILE_ONLY
424 #include <math.h> // ldexp
425 #include <string.h> // strcmp
428 #ifndef STBI_NO_STDIO
432 #include <sys/cdefs.h>
433 __KERNEL_RCSID(0, "$NetBSD: stb_image.c,v 1.6 2013/09/15 14:06:10 martin Exp $");
434 #include <sys/param.h>
435 #include <sys/systm.h>
436 #include <sys/kernel.h>
437 #include <sys/types.h>
438 #include <sys/malloc.h>
447 #define MALLOC(size) malloc((size), M_TEMP, M_WAITOK)
448 #define REALLOC(ptr, size) realloc((ptr), (size), M_TEMP, M_WAITOK)
450 do { if (ptr) free((ptr), M_TEMP); } while (/*CONSTCOND*/0)
452 #define MALLOC(size) malloc((size))
453 #define REALLOC(ptr, size) realloc((ptr), (size))
454 #define FREE(ptr) free((ptr))
459 #define __forceinline inline
461 #define __forceinline
467 typedef unsigned char uint8
;
468 typedef unsigned short uint16
;
469 typedef signed short int16
;
470 typedef unsigned int uint32
;
471 typedef signed int int32
;
473 typedef unsigned int uint
;
476 // should produce compiler error if size is wrong
477 typedef unsigned char validate_uint32
[sizeof(uint32
)==4 ? 1 : -1];
479 #if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
480 #define STBI_NO_WRITE
483 #define STBI_NOTUSED(v) v=v
486 #define STBI_HAS_LRTOL
489 #ifdef STBI_HAS_LRTOL
490 #define stbi_lrot(x,y) _lrotl(x,y)
492 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
495 //////////////////////////////////////////////////////////////////////////////
497 // Generic API that works on all image types
500 // deprecated functions
503 extern int stbi_jpeg_test_memory (stbi_uc
const *buffer
, int len
);
504 extern stbi_uc
*stbi_jpeg_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
505 extern int stbi_jpeg_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
507 #ifndef STBI_NO_STDIO
508 extern stbi_uc
*stbi_jpeg_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
509 extern int stbi_jpeg_test_file (FILE *f
);
510 extern stbi_uc
*stbi_jpeg_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
512 extern int stbi_jpeg_info (char const *filename
, int *x
, int *y
, int *comp
);
513 extern int stbi_jpeg_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
517 extern int stbi_png_test_memory (stbi_uc
const *buffer
, int len
);
518 extern stbi_uc
*stbi_png_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
519 extern int stbi_png_info_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
521 #ifndef STBI_NO_STDIO
522 extern stbi_uc
*stbi_png_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
523 extern int stbi_png_info (char const *filename
, int *x
, int *y
, int *comp
);
524 extern int stbi_png_test_file (FILE *f
);
525 extern stbi_uc
*stbi_png_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
526 extern int stbi_png_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
530 extern int stbi_bmp_test_memory (stbi_uc
const *buffer
, int len
);
532 extern stbi_uc
*stbi_bmp_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
533 extern stbi_uc
*stbi_bmp_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
534 #ifndef STBI_NO_STDIO
535 extern int stbi_bmp_test_file (FILE *f
);
536 extern stbi_uc
*stbi_bmp_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
540 extern int stbi_tga_test_memory (stbi_uc
const *buffer
, int len
);
542 extern stbi_uc
*stbi_tga_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
543 extern stbi_uc
*stbi_tga_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
544 #ifndef STBI_NO_STDIO
545 extern int stbi_tga_test_file (FILE *f
);
546 extern stbi_uc
*stbi_tga_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
550 extern int stbi_psd_test_memory (stbi_uc
const *buffer
, int len
);
552 extern stbi_uc
*stbi_psd_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
553 extern stbi_uc
*stbi_psd_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
554 #ifndef STBI_NO_STDIO
555 extern int stbi_psd_test_file (FILE *f
);
556 extern stbi_uc
*stbi_psd_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
560 extern int stbi_hdr_test_memory (stbi_uc
const *buffer
, int len
);
562 extern float * stbi_hdr_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
563 extern float * stbi_hdr_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
564 #ifndef STBI_NO_STDIO
565 extern int stbi_hdr_test_file (FILE *f
);
566 extern float * stbi_hdr_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
570 extern int stbi_pic_test_memory (stbi_uc
const *buffer
, int len
);
572 extern stbi_uc
*stbi_pic_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
573 extern stbi_uc
*stbi_pic_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
574 #ifndef STBI_NO_STDIO
575 extern int stbi_pic_test_file (FILE *f
);
576 extern stbi_uc
*stbi_pic_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
580 extern int stbi_gif_test_memory (stbi_uc
const *buffer
, int len
);
582 extern stbi_uc
*stbi_gif_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
);
583 extern stbi_uc
*stbi_gif_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
);
584 extern int stbi_gif_info_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
586 #ifndef STBI_NO_STDIO
587 extern int stbi_gif_test_file (FILE *f
);
588 extern stbi_uc
*stbi_gif_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
);
589 extern int stbi_gif_info (char const *filename
, int *x
, int *y
, int *comp
);
590 extern int stbi_gif_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
594 // this is not threadsafe
595 static const char *failure_reason
;
597 const char *stbi_failure_reason(void)
599 return failure_reason
;
602 #ifndef STBI_NO_FAILURE_STRINGS
603 static int e(const char *str
)
605 failure_reason
= str
;
610 #ifdef STBI_NO_FAILURE_STRINGS
612 #elif defined(STBI_FAILURE_USERMSG)
618 #define epf(x,y) ((float *) (e(x,y)?NULL:NULL))
619 #define epuc(x,y) ((unsigned char *) (e(x,y)?NULL:NULL))
621 void stbi_image_free(void *retval_from_stbi_load
)
623 FREE(retval_from_stbi_load
);
626 #define MAX_LOADERS 32
627 stbi_loader
*loaders
[MAX_LOADERS
];
628 static int max_loaders
= 0;
630 int stbi_register_loader(stbi_loader
*loader
)
633 for (i
=0; i
< MAX_LOADERS
; ++i
) {
635 if (loaders
[i
] == loader
)
638 if (loaders
[i
] == NULL
) {
649 static float *ldr_to_hdr(stbi_uc
*data
, int x
, int y
, int comp
);
650 static stbi_uc
*hdr_to_ldr(float *data
, int x
, int y
, int comp
);
653 #ifndef STBI_NO_STDIO
654 unsigned char *stbi_load(char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
656 FILE *f
= fopen(filename
, "rb");
657 unsigned char *result
;
658 if (!f
) return epuc("can't fopen", "Unable to open file");
659 result
= stbi_load_from_file(f
,x
,y
,comp
,req_comp
);
664 unsigned char *stbi_load_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
667 if (stbi_jpeg_test_file(f
)) return stbi_jpeg_load_from_file(f
,x
,y
,comp
,req_comp
);
668 if (stbi_png_test_file(f
)) return stbi_png_load_from_file(f
,x
,y
,comp
,req_comp
);
669 if (stbi_bmp_test_file(f
)) return stbi_bmp_load_from_file(f
,x
,y
,comp
,req_comp
);
670 if (stbi_gif_test_file(f
)) return stbi_gif_load_from_file(f
,x
,y
,comp
,req_comp
);
671 if (stbi_psd_test_file(f
)) return stbi_psd_load_from_file(f
,x
,y
,comp
,req_comp
);
672 if (stbi_pic_test_file(f
)) return stbi_pic_load_from_file(f
,x
,y
,comp
,req_comp
);
675 if (stbi_hdr_test_file(f
)) {
676 float *hdr
= stbi_hdr_load_from_file(f
, x
,y
,comp
,req_comp
);
677 return hdr_to_ldr(hdr
, *x
, *y
, req_comp
? req_comp
: *comp
);
681 for (i
=0; i
< max_loaders
; ++i
)
682 if (loaders
[i
]->test_file(f
))
683 return loaders
[i
]->load_from_file(f
,x
,y
,comp
,req_comp
);
684 // test tga last because it's a crappy test!
685 if (stbi_tga_test_file(f
))
686 return stbi_tga_load_from_file(f
,x
,y
,comp
,req_comp
);
687 return epuc("unknown image type", "Image not of any known type, or corrupt");
691 unsigned char *stbi_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
694 if (stbi_jpeg_test_memory(buffer
,len
)) return stbi_jpeg_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
695 if (stbi_png_test_memory(buffer
,len
)) return stbi_png_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
696 if (stbi_bmp_test_memory(buffer
,len
)) return stbi_bmp_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
697 if (stbi_gif_test_memory(buffer
,len
)) return stbi_gif_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
698 if (stbi_psd_test_memory(buffer
,len
)) return stbi_psd_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
699 if (stbi_pic_test_memory(buffer
,len
)) return stbi_pic_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
702 if (stbi_hdr_test_memory(buffer
, len
)) {
703 float *hdr
= stbi_hdr_load_from_memory(buffer
, len
,x
,y
,comp
,req_comp
);
704 return hdr_to_ldr(hdr
, *x
, *y
, req_comp
? req_comp
: *comp
);
708 for (i
=0; i
< max_loaders
; ++i
)
709 if (loaders
[i
]->test_memory(buffer
,len
))
710 return loaders
[i
]->load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
711 // test tga last because it's a crappy test!
712 if (stbi_tga_test_memory(buffer
,len
))
713 return stbi_tga_load_from_memory(buffer
,len
,x
,y
,comp
,req_comp
);
714 return epuc("unknown image type", "Image not of any known type, or corrupt");
719 #ifndef STBI_NO_STDIO
720 float *stbi_loadf(char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
722 FILE *f
= fopen(filename
, "rb");
724 if (!f
) return epf("can't fopen", "Unable to open file");
725 result
= stbi_loadf_from_file(f
,x
,y
,comp
,req_comp
);
730 float *stbi_loadf_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
734 if (stbi_hdr_test_file(f
))
735 return stbi_hdr_load_from_file(f
,x
,y
,comp
,req_comp
);
737 data
= stbi_load_from_file(f
, x
, y
, comp
, req_comp
);
739 return ldr_to_hdr(data
, *x
, *y
, req_comp
? req_comp
: *comp
);
740 return epf("unknown image type", "Image not of any known type, or corrupt");
744 float *stbi_loadf_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
748 if (stbi_hdr_test_memory(buffer
, len
))
749 return stbi_hdr_load_from_memory(buffer
, len
,x
,y
,comp
,req_comp
);
751 data
= stbi_load_from_memory(buffer
, len
, x
, y
, comp
, req_comp
);
753 return ldr_to_hdr(data
, *x
, *y
, req_comp
? req_comp
: *comp
);
754 return epf("unknown image type", "Image not of any known type, or corrupt");
758 // these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
759 // defined, for API simplicity; if STBI_NO_HDR is defined, it always
762 int stbi_is_hdr_from_memory(stbi_uc
const *buffer
, int len
)
765 return stbi_hdr_test_memory(buffer
, len
);
767 STBI_NOTUSED(buffer
);
773 #ifndef STBI_NO_STDIO
774 extern int stbi_is_hdr (char const *filename
)
776 FILE *f
= fopen(filename
, "rb");
779 result
= stbi_is_hdr_from_file(f
);
785 extern int stbi_is_hdr_from_file(FILE *f
)
788 return stbi_hdr_test_file(f
);
797 static float h2l_gamma_i
=1.0f
/2.2f
, h2l_scale_i
=1.0f
;
798 static float l2h_gamma
=2.2f
, l2h_scale
=1.0f
;
800 void stbi_hdr_to_ldr_gamma(float gamma
) { h2l_gamma_i
= 1/gamma
; }
801 void stbi_hdr_to_ldr_scale(float scale
) { h2l_scale_i
= 1/scale
; }
803 void stbi_ldr_to_hdr_gamma(float gamma
) { l2h_gamma
= gamma
; }
804 void stbi_ldr_to_hdr_scale(float scale
) { l2h_scale
= scale
; }
808 //////////////////////////////////////////////////////////////////////////////
810 // Common code used by all image loaders
823 int img_n
, img_out_n
;
825 #ifndef STBI_NO_STDIO
828 uint8 buffer_start
[128];
831 uint8
const *img_buffer
, *img_buffer_end
;
834 #ifndef STBI_NO_STDIO
835 static void start_file(stbi
*s
, FILE *f
)
838 s
->buflen
= sizeof(s
->buffer_start
);
839 s
->img_buffer_end
= s
->buffer_start
+ s
->buflen
;
840 s
->img_buffer
= s
->img_buffer_end
;
845 static void start_mem(stbi
*s
, uint8
const *buffer
, int len
)
847 #ifndef STBI_NO_STDIO
851 s
->img_buffer
= (uint8
const *) buffer
;
852 s
->img_buffer_end
= (uint8
const *) buffer
+len
;
855 #ifndef STBI_NO_STDIO
856 static void refill_buffer(stbi
*s
)
858 int n
= fread(s
->buffer_start
, 1, s
->buflen
, s
->img_file
);
861 s
->img_buffer
= s
->img_buffer_end
-1;
866 s
->img_buffer
= s
->buffer_start
;
867 s
->img_buffer_end
= s
->buffer_start
+ n
;
872 __forceinline
static int get8(stbi
*s
)
874 if (s
->img_buffer
< s
->img_buffer_end
)
875 return *s
->img_buffer
++;
876 #ifndef STBI_NO_STDIO
879 return *s
->img_buffer
++;
885 __forceinline
static int at_eof(stbi
*s
)
887 #ifndef STBI_NO_STDIO
889 if (!feof(s
->img_file
)) return 0;
890 // if feof() is true, check if buffer = end
891 // special case: we've only got the special 0 character at the end
892 if (s
->from_file
== 0) return 1;
895 return s
->img_buffer
>= s
->img_buffer_end
;
898 __forceinline
static uint8
get8u(stbi
*s
)
900 return (uint8
) get8(s
);
903 static void skip(stbi
*s
, int n
)
905 #ifndef STBI_NO_STDIO
907 int blen
= s
->img_buffer_end
- s
->img_buffer
;
909 s
->img_buffer
= s
->img_buffer_end
;
910 fseek(s
->img_file
, n
- blen
, SEEK_CUR
);
918 static int getn(stbi
*s
, stbi_uc
*buffer
, int n
)
920 #ifndef STBI_NO_STDIO
922 int blen
= s
->img_buffer_end
- s
->img_buffer
;
925 memcpy(buffer
, s
->img_buffer
, blen
);
926 res
= ((int) fread(buffer
+ blen
, 1, n
- blen
, s
->img_file
) == (n
-blen
));
927 s
->img_buffer
= s
->img_buffer_end
;
932 if (s
->img_buffer
+n
<= s
->img_buffer_end
) {
933 memcpy(buffer
, s
->img_buffer
, n
);
940 static int get16(stbi
*s
)
943 return (z
<< 8) + get8(s
);
946 static uint32
get32(stbi
*s
)
949 return (z
<< 16) + get16(s
);
952 static int get16le(stbi
*s
)
955 return z
+ (get8(s
) << 8);
958 static uint32
get32le(stbi
*s
)
960 uint32 z
= get16le(s
);
961 return z
+ (get16le(s
) << 16);
964 //////////////////////////////////////////////////////////////////////////////
966 // generic converter from built-in img_n to req_comp
967 // individual types do this automatically as much as possible (e.g. jpeg
968 // does all cases internally since it needs to colorspace convert anyway,
969 // and it never has alpha, so very few cases ). png can automatically
970 // interleave an alpha=255 channel, but falls back to this for other cases
972 // assume data buffer is malloced, so malloc a new one and free that one
973 // only failure mode is malloc failing
975 static uint8
compute_y(int r
, int g
, int b
)
977 return (uint8
) (((r
*77) + (g
*150) + (29*b
)) >> 8);
980 static unsigned char *convert_format(unsigned char *data
, int img_n
, int req_comp
, uint x
, uint y
)
985 if (req_comp
== img_n
) return data
;
986 assert(req_comp
>= 1 && req_comp
<= 4);
988 good
= (unsigned char *) MALLOC(req_comp
* x
* y
);
991 return epuc("outofmem", "Out of memory");
994 for (j
=0; j
< (int) y
; ++j
) {
995 unsigned char *src
= data
+ j
* x
* img_n
;
996 unsigned char *dest
= good
+ j
* x
* req_comp
;
998 #define COMBO(a,b) ((a)*8+(b))
999 #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1000 // convert source image with img_n components to one with req_comp components;
1001 // avoid switch per pixel, so use switch per scanline and massive macros
1002 switch (COMBO(img_n
, req_comp
)) {
1003 CASE(1,2) dest
[0]=src
[0], dest
[1]=255; break;
1004 CASE(1,3) dest
[0]=dest
[1]=dest
[2]=src
[0]; break;
1005 CASE(1,4) dest
[0]=dest
[1]=dest
[2]=src
[0], dest
[3]=255; break;
1006 CASE(2,1) dest
[0]=src
[0]; break;
1007 CASE(2,3) dest
[0]=dest
[1]=dest
[2]=src
[0]; break;
1008 CASE(2,4) dest
[0]=dest
[1]=dest
[2]=src
[0], dest
[3]=src
[1]; break;
1009 CASE(3,4) dest
[0]=src
[0],dest
[1]=src
[1],dest
[2]=src
[2],dest
[3]=255; break;
1010 CASE(3,1) dest
[0]=compute_y(src
[0],src
[1],src
[2]); break;
1011 CASE(3,2) dest
[0]=compute_y(src
[0],src
[1],src
[2]), dest
[1] = 255; break;
1012 CASE(4,1) dest
[0]=compute_y(src
[0],src
[1],src
[2]); break;
1013 CASE(4,2) dest
[0]=compute_y(src
[0],src
[1],src
[2]), dest
[1] = src
[3]; break;
1014 CASE(4,3) dest
[0]=src
[0],dest
[1]=src
[1],dest
[2]=src
[2]; break;
1025 static float *ldr_to_hdr(stbi_uc
*data
, int x
, int y
, int comp
)
1028 float *output
= (float *) MALLOC(x
* y
* comp
* sizeof(float));
1029 if (output
== NULL
) { FREE(data
); return epf("outofmem", "Out of memory"); }
1030 // compute number of non-alpha components
1031 if (comp
& 1) n
= comp
; else n
= comp
-1;
1032 for (i
=0; i
< x
*y
; ++i
) {
1033 for (k
=0; k
< n
; ++k
) {
1034 output
[i
*comp
+ k
] = (float) pow(data
[i
*comp
+k
]/255.0f
, l2h_gamma
) * l2h_scale
;
1036 if (k
< comp
) output
[i
*comp
+ k
] = data
[i
*comp
+k
]/255.0f
;
1042 #define float2int(x) ((int) (x))
1043 static stbi_uc
*hdr_to_ldr(float *data
, int x
, int y
, int comp
)
1046 stbi_uc
*output
= (stbi_uc
*) MALLOC(x
* y
* comp
);
1047 if (output
== NULL
) { FREE(data
); return epuc("outofmem", "Out of memory"); }
1048 // compute number of non-alpha components
1049 if (comp
& 1) n
= comp
; else n
= comp
-1;
1050 for (i
=0; i
< x
*y
; ++i
) {
1051 for (k
=0; k
< n
; ++k
) {
1052 float z
= (float) pow(data
[i
*comp
+k
]*h2l_scale_i
, h2l_gamma_i
) * 255 + 0.5f
;
1054 if (z
> 255) z
= 255;
1055 output
[i
*comp
+ k
] = (uint8
) float2int(z
);
1058 float z
= data
[i
*comp
+k
] * 255 + 0.5f
;
1060 if (z
> 255) z
= 255;
1061 output
[i
*comp
+ k
] = (uint8
) float2int(z
);
1069 //////////////////////////////////////////////////////////////////////////////
1071 // "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
1073 // simple implementation
1074 // - channel subsampling of at most 2 in each dimension
1075 // - doesn't support delayed output of y-dimension
1076 // - simple interface (only one output format: 8-bit interleaved RGB)
1077 // - doesn't try to recover corrupt jpegs
1078 // - doesn't allow partial loading, loading multiple at once
1079 // - still fast on x86 (copying globals into locals doesn't help x86)
1080 // - allocates lots of intermediate memory (full size of all components)
1081 // - non-interleaved case requires this anyway
1082 // - allows good upsampling (see next)
1084 // - upsampled channels are bilinearly interpolated, even across blocks
1085 // - quality integer IDCT derived from IJG's 'slow'
1087 // - fast huffman; reasonable integer IDCT
1088 // - uses a lot of intermediate memory, could cache poorly
1089 // - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
1090 // stb_jpeg: 1.34 seconds (MSVC6, default release build)
1091 // stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro)
1092 // IJL11.dll: 1.08 seconds (compiled by intel)
1093 // IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG)
1094 // IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro)
1096 // huffman decoding acceleration
1097 #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
1101 uint8 fast
[1 << FAST_BITS
];
1102 // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
1106 unsigned int maxcode
[18];
1107 int delta
[17]; // old 'firstsymbol' - old 'firstcode'
1113 unsigned short dequant2
[4][64];
1118 uint8 dequant
[4][64];
1120 // sizes for components, interleaved MCUs
1121 int img_h_max
, img_v_max
;
1122 int img_mcu_x
, img_mcu_y
;
1123 int img_mcu_w
, img_mcu_h
;
1125 // definition of jpeg image component
1140 uint32 code_buffer
; // jpeg entropy-coded buffer
1141 int code_bits
; // number of valid bits
1142 unsigned char marker
; // marker seen while filling entropy buffer
1143 int nomore
; // flag if we saw a marker so must stop
1145 int scan_n
, order
[4];
1146 int restart_interval
, todo
;
1149 static int build_huffman(huffman
*h
, int *count
)
1152 // build size list for each symbol (from JPEG spec)
1153 for (i
=0; i
< 16; ++i
)
1154 for (j
=0; j
< count
[i
]; ++j
)
1155 h
->size
[k
++] = (uint8
) (i
+1);
1158 // compute actual symbols (from jpeg spec)
1161 for(j
=1; j
<= 16; ++j
) {
1162 // compute delta to add to code to compute symbol id
1163 h
->delta
[j
] = k
- code
;
1164 if (h
->size
[k
] == j
) {
1165 while (h
->size
[k
] == j
)
1166 h
->code
[k
++] = (uint16
) (code
++);
1167 if (code
-1 >= (1 << j
)) return e("bad code lengths","Corrupt JPEG");
1169 // compute largest code + 1 for this size, preshifted as needed later
1170 h
->maxcode
[j
] = code
<< (16-j
);
1173 h
->maxcode
[j
] = 0xffffffff;
1175 // build non-spec acceleration table; 255 is flag for not-accelerated
1176 memset(h
->fast
, 255, 1 << FAST_BITS
);
1177 for (i
=0; i
< k
; ++i
) {
1179 if (s
<= FAST_BITS
) {
1180 int c
= h
->code
[i
] << (FAST_BITS
-s
);
1181 int m
= 1 << (FAST_BITS
-s
);
1182 for (j
=0; j
< m
; ++j
) {
1183 h
->fast
[c
+j
] = (uint8
) i
;
1190 static void grow_buffer_unsafe(jpeg
*j
)
1193 int b
= j
->nomore
? 0 : get8(&j
->s
);
1195 int c
= get8(&j
->s
);
1197 j
->marker
= (unsigned char) c
;
1202 j
->code_buffer
|= b
<< (24 - j
->code_bits
);
1204 } while (j
->code_bits
<= 24);
1208 static uint32 bmask
[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
1210 // decode a jpeg huffman value from the bitstream
1211 __forceinline
static int decode(jpeg
*j
, huffman
*h
)
1216 if (j
->code_bits
< 16) grow_buffer_unsafe(j
);
1218 // look at the top FAST_BITS and determine what symbol ID it is,
1219 // if the code is <= FAST_BITS
1220 c
= (j
->code_buffer
>> (32 - FAST_BITS
)) & ((1 << FAST_BITS
)-1);
1224 if (s
> j
->code_bits
)
1226 j
->code_buffer
<<= s
;
1228 return h
->values
[k
];
1231 // naive test is to shift the code_buffer down so k bits are
1232 // valid, then test against maxcode. To speed this up, we've
1233 // preshifted maxcode left so that it has (16-k) 0s at the
1234 // end; in other words, regardless of the number of bits, it
1235 // wants to be compared against something shifted to have 16;
1236 // that way we don't need to shift inside the loop.
1237 temp
= j
->code_buffer
>> 16;
1238 for (k
=FAST_BITS
+1 ; ; ++k
)
1239 if (temp
< h
->maxcode
[k
])
1242 // error! code not found
1247 if (k
> j
->code_bits
)
1250 // convert the huffman code to the symbol id
1251 c
= ((j
->code_buffer
>> (32 - k
)) & bmask
[k
]) + h
->delta
[k
];
1252 assert((((j
->code_buffer
) >> (32 - h
->size
[c
])) & bmask
[h
->size
[c
]]) == h
->code
[c
]);
1254 // convert the id to a symbol
1256 j
->code_buffer
<<= k
;
1257 return h
->values
[c
];
1260 // combined JPEG 'receive' and JPEG 'extend', since baseline
1261 // always extends everything it receives.
1262 __forceinline
static int extend_receive(jpeg
*j
, int n
)
1264 unsigned int m
= 1 << (n
-1);
1266 if (j
->code_bits
< n
) grow_buffer_unsafe(j
);
1269 k
= stbi_lrot(j
->code_buffer
, n
);
1270 j
->code_buffer
= k
& ~bmask
[n
];
1274 k
= (j
->code_buffer
>> (32 - n
)) & bmask
[n
];
1276 j
->code_buffer
<<= n
;
1278 // the following test is probably a random branch that won't
1279 // predict well. I tried to table accelerate it but failed.
1280 // maybe it's compiling as a conditional move?
1282 return (-1 << n
) + k
+ 1;
1287 // given a value that's at position X in the zigzag stream,
1288 // where does it appear in the 8x8 matrix coded as row-major?
1289 static uint8 dezigzag
[64+15] =
1291 0, 1, 8, 16, 9, 2, 3, 10,
1292 17, 24, 32, 25, 18, 11, 4, 5,
1293 12, 19, 26, 33, 40, 48, 41, 34,
1294 27, 20, 13, 6, 7, 14, 21, 28,
1295 35, 42, 49, 56, 57, 50, 43, 36,
1296 29, 22, 15, 23, 30, 37, 44, 51,
1297 58, 59, 52, 45, 38, 31, 39, 46,
1298 53, 60, 61, 54, 47, 55, 62, 63,
1299 // let corrupt input sample past end
1300 63, 63, 63, 63, 63, 63, 63, 63,
1301 63, 63, 63, 63, 63, 63, 63
1304 // decode one 64-entry block--
1305 static int decode_block(jpeg
*j
, short data
[64], huffman
*hdc
, huffman
*hac
, int b
)
1308 int t
= decode(j
, hdc
);
1309 if (t
< 0) return e("bad huffman code","Corrupt JPEG");
1311 // 0 all the ac values now so we can do it 32-bits at a time
1312 memset(data
,0,64*sizeof(data
[0]));
1314 diff
= t
? extend_receive(j
, t
) : 0;
1315 dc
= j
->img_comp
[b
].dc_pred
+ diff
;
1316 j
->img_comp
[b
].dc_pred
= dc
;
1317 data
[0] = (short) dc
;
1319 // decode AC components, see JPEG spec
1323 int rs
= decode(j
, hac
);
1324 if (rs
< 0) return e("bad huffman code","Corrupt JPEG");
1328 if (rs
!= 0xf0) break; // end block
1332 // decode into unzigzag'd location
1333 data
[dezigzag
[k
++]] = (short) extend_receive(j
,s
);
1339 // take a -128..127 value and clamp it and convert to 0..255
1340 __forceinline
static uint8
clamp(int x
)
1342 // trick to use a single test to catch both cases
1343 if ((unsigned int) x
> 255) {
1344 if (x
< 0) return 0;
1345 if (x
> 255) return 255;
1350 #define f2f(x) (int) (((x) * 4096 + 0.5))
1351 #define fsh(x) ((x) << 12)
1353 // derived from jidctint -- DCT_ISLOW
1354 #define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
1355 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
1358 p1 = (p2+p3) * f2f(0.5411961f); \
1359 t2 = p1 + p3*f2f(-1.847759065f); \
1360 t3 = p1 + p2*f2f( 0.765366865f); \
1377 p5 = (p3+p4)*f2f( 1.175875602f); \
1378 t0 = t0*f2f( 0.298631336f); \
1379 t1 = t1*f2f( 2.053119869f); \
1380 t2 = t2*f2f( 3.072711026f); \
1381 t3 = t3*f2f( 1.501321110f); \
1382 p1 = p5 + p1*f2f(-0.899976223f); \
1383 p2 = p5 + p2*f2f(-2.562915447f); \
1384 p3 = p3*f2f(-1.961570560f); \
1385 p4 = p4*f2f(-0.390180644f); \
1392 typedef unsigned short stbi_dequantize_t
;
1394 typedef uint8 stbi_dequantize_t
;
1397 // .344 seconds on 3*anemones.jpg
1398 static void idct_block(uint8
*out
, int out_stride
, short data
[64], stbi_dequantize_t
*dequantize
)
1400 int i
,val
[64],*v
=val
;
1401 stbi_dequantize_t
*dq
= dequantize
;
1406 for (i
=0; i
< 8; ++i
,++d
,++dq
, ++v
) {
1407 // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
1408 if (d
[ 8]==0 && d
[16]==0 && d
[24]==0 && d
[32]==0
1409 && d
[40]==0 && d
[48]==0 && d
[56]==0) {
1410 // no shortcut 0 seconds
1411 // (1|2|3|4|5|6|7)==0 0 seconds
1412 // all separate -0.047 seconds
1413 // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
1414 int dcterm
= d
[0] * dq
[0] << 2;
1415 v
[0] = v
[8] = v
[16] = v
[24] = v
[32] = v
[40] = v
[48] = v
[56] = dcterm
;
1417 IDCT_1D(d
[ 0]*dq
[ 0],d
[ 8]*dq
[ 8],d
[16]*dq
[16],d
[24]*dq
[24],
1418 d
[32]*dq
[32],d
[40]*dq
[40],d
[48]*dq
[48],d
[56]*dq
[56])
1419 // constants scaled things up by 1<<12; let's bring them back
1420 // down, but keep 2 extra bits of precision
1421 x0
+= 512; x1
+= 512; x2
+= 512; x3
+= 512;
1422 v
[ 0] = (x0
+t3
) >> 10;
1423 v
[56] = (x0
-t3
) >> 10;
1424 v
[ 8] = (x1
+t2
) >> 10;
1425 v
[48] = (x1
-t2
) >> 10;
1426 v
[16] = (x2
+t1
) >> 10;
1427 v
[40] = (x2
-t1
) >> 10;
1428 v
[24] = (x3
+t0
) >> 10;
1429 v
[32] = (x3
-t0
) >> 10;
1433 for (i
=0, v
=val
, o
=out
; i
< 8; ++i
,v
+=8,o
+=out_stride
) {
1434 // no fast case since the first 1D IDCT spread components out
1435 IDCT_1D(v
[0],v
[1],v
[2],v
[3],v
[4],v
[5],v
[6],v
[7])
1436 // constants scaled things up by 1<<12, plus we had 1<<2 from first
1437 // loop, plus horizontal and vertical each scale by sqrt(8) so together
1438 // we've got an extra 1<<3, so 1<<17 total we need to remove.
1439 // so we want to round that, which means adding 0.5 * 1<<17,
1440 // aka 65536. Also, we'll end up with -128 to 127 that we want
1441 // to encode as 0..255 by adding 128, so we'll add that before the shift
1442 x0
+= 65536 + (128<<17);
1443 x1
+= 65536 + (128<<17);
1444 x2
+= 65536 + (128<<17);
1445 x3
+= 65536 + (128<<17);
1446 // tried computing the shifts into temps, or'ing the temps to see
1447 // if any were out of range, but that was slower
1448 o
[0] = clamp((x0
+t3
) >> 17);
1449 o
[7] = clamp((x0
-t3
) >> 17);
1450 o
[1] = clamp((x1
+t2
) >> 17);
1451 o
[6] = clamp((x1
-t2
) >> 17);
1452 o
[2] = clamp((x2
+t1
) >> 17);
1453 o
[5] = clamp((x2
-t1
) >> 17);
1454 o
[3] = clamp((x3
+t0
) >> 17);
1455 o
[4] = clamp((x3
-t0
) >> 17);
1460 static stbi_idct_8x8 stbi_idct_installed
= idct_block
;
1462 extern void stbi_install_idct(stbi_idct_8x8 func
)
1464 stbi_idct_installed
= func
;
1468 #define MARKER_none 0xff
1469 // if there's a pending marker from the entropy stream, return that
1470 // otherwise, fetch from the stream and get a marker. if there's no
1471 // marker, return 0xff, which is never a valid marker value
1472 static uint8
get_marker(jpeg
*j
)
1475 if (j
->marker
!= MARKER_none
) { x
= j
->marker
; j
->marker
= MARKER_none
; return x
; }
1477 if (x
!= 0xff) return MARKER_none
;
1483 // in each scan, we'll have scan_n components, and the order
1484 // of the components is specified by order[]
1485 #define RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
1487 // after a restart interval, reset the entropy decoder and
1488 // the dc prediction
1489 static void reset(jpeg
*j
)
1494 j
->img_comp
[0].dc_pred
= j
->img_comp
[1].dc_pred
= j
->img_comp
[2].dc_pred
= 0;
1495 j
->marker
= MARKER_none
;
1496 j
->todo
= j
->restart_interval
? j
->restart_interval
: 0x7fffffff;
1497 // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
1498 // since we don't even allow 1<<30 pixels
1501 static int parse_entropy_coded_data(jpeg
*z
)
1504 if (z
->scan_n
== 1) {
1507 __declspec(align(16))
1510 int n
= z
->order
[0];
1511 // non-interleaved data, we just need to process one block at a time,
1512 // in trivial scanline order
1513 // number of blocks to do just depends on how many actual "pixels" this
1514 // component has, independent of interleaved MCU blocking and such
1515 int w
= (z
->img_comp
[n
].x
+7) >> 3;
1516 int h
= (z
->img_comp
[n
].y
+7) >> 3;
1517 for (j
=0; j
< h
; ++j
) {
1518 for (i
=0; i
< w
; ++i
) {
1519 if (!decode_block(z
, data
, z
->huff_dc
+z
->img_comp
[n
].hd
, z
->huff_ac
+z
->img_comp
[n
].ha
, n
)) return 0;
1521 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
]);
1523 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
]);
1525 // every data block is an MCU, so countdown the restart interval
1526 if (--z
->todo
<= 0) {
1527 if (z
->code_bits
< 24) grow_buffer_unsafe(z
);
1528 // if it's NOT a restart, then just bail, so we get corrupt data
1529 // rather than no data
1530 if (!RESTART(z
->marker
)) return 1;
1535 } else { // interleaved!
1538 for (j
=0; j
< z
->img_mcu_y
; ++j
) {
1539 for (i
=0; i
< z
->img_mcu_x
; ++i
) {
1540 // scan an interleaved mcu... process scan_n components in order
1541 for (k
=0; k
< z
->scan_n
; ++k
) {
1542 int n
= z
->order
[k
];
1543 // scan out an mcu's worth of this component; that's just determined
1544 // by the basic H and V specified for the component
1545 for (y
=0; y
< z
->img_comp
[n
].v
; ++y
) {
1546 for (x
=0; x
< z
->img_comp
[n
].h
; ++x
) {
1547 int x2
= (i
*z
->img_comp
[n
].h
+ x
)*8;
1548 int y2
= (j
*z
->img_comp
[n
].v
+ y
)*8;
1549 if (!decode_block(z
, data
, z
->huff_dc
+z
->img_comp
[n
].hd
, z
->huff_ac
+z
->img_comp
[n
].ha
, n
)) return 0;
1551 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
]);
1553 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
]);
1558 // after all interleaved components, that's an interleaved MCU,
1559 // so now count down the restart interval
1560 if (--z
->todo
<= 0) {
1561 if (z
->code_bits
< 24) grow_buffer_unsafe(z
);
1562 // if it's NOT a restart, then just bail, so we get corrupt data
1563 // rather than no data
1564 if (!RESTART(z
->marker
)) return 1;
1573 static int process_marker(jpeg
*z
, int marker
)
1577 case MARKER_none
: // no marker found
1578 return e("expected marker","Corrupt JPEG");
1580 case 0xC2: // SOF - progressive
1581 return e("progressive jpeg","JPEG format not supported (progressive)");
1583 case 0xDD: // DRI - specify restart interval
1584 if (get16(&z
->s
) != 4) return e("bad DRI len","Corrupt JPEG");
1585 z
->restart_interval
= get16(&z
->s
);
1588 case 0xDB: // DQT - define quantization table
1591 int q
= get8(&z
->s
);
1594 if (p
!= 0) return e("bad DQT type","Corrupt JPEG");
1595 if (t
> 3) return e("bad DQT table","Corrupt JPEG");
1596 for (i
=0; i
< 64; ++i
)
1597 z
->dequant
[t
][dezigzag
[i
]] = get8u(&z
->s
);
1599 for (i
=0; i
< 64; ++i
)
1600 z
->dequant2
[t
][i
] = z
->dequant
[t
][i
];
1606 case 0xC4: // DHT - define huffman table
1610 int sizes
[16],i
,m
=0;
1611 int q
= get8(&z
->s
);
1614 if (tc
> 1 || th
> 3) return e("bad DHT header","Corrupt JPEG");
1615 for (i
=0; i
< 16; ++i
) {
1616 sizes
[i
] = get8(&z
->s
);
1621 if (!build_huffman(z
->huff_dc
+th
, sizes
)) return 0;
1622 v
= z
->huff_dc
[th
].values
;
1624 if (!build_huffman(z
->huff_ac
+th
, sizes
)) return 0;
1625 v
= z
->huff_ac
[th
].values
;
1627 for (i
=0; i
< m
; ++i
)
1628 v
[i
] = get8u(&z
->s
);
1633 // check for comment block or APP blocks
1634 if ((marker
>= 0xE0 && marker
<= 0xEF) || marker
== 0xFE) {
1635 skip(&z
->s
, get16(&z
->s
)-2);
1642 static int process_scan_header(jpeg
*z
)
1645 int Ls
= get16(&z
->s
);
1646 z
->scan_n
= get8(&z
->s
);
1647 if (z
->scan_n
< 1 || z
->scan_n
> 4 || z
->scan_n
> (int) z
->s
.img_n
) return e("bad SOS component count","Corrupt JPEG");
1648 if (Ls
!= 6+2*z
->scan_n
) return e("bad SOS len","Corrupt JPEG");
1649 for (i
=0; i
< z
->scan_n
; ++i
) {
1650 int id
= get8(&z
->s
), which
;
1651 int q
= get8(&z
->s
);
1652 for (which
= 0; which
< z
->s
.img_n
; ++which
)
1653 if (z
->img_comp
[which
].id
== id
)
1655 if (which
== z
->s
.img_n
) return 0;
1656 z
->img_comp
[which
].hd
= q
>> 4; if (z
->img_comp
[which
].hd
> 3) return e("bad DC huff","Corrupt JPEG");
1657 z
->img_comp
[which
].ha
= q
& 15; if (z
->img_comp
[which
].ha
> 3) return e("bad AC huff","Corrupt JPEG");
1658 z
->order
[i
] = which
;
1660 if (get8(&z
->s
) != 0) return e("bad SOS","Corrupt JPEG");
1661 get8(&z
->s
); // should be 63, but might be 0
1662 if (get8(&z
->s
) != 0) return e("bad SOS","Corrupt JPEG");
1667 static int process_frame_header(jpeg
*z
, int scan
)
1670 int Lf
,p
,i
,q
, h_max
=1,v_max
=1,c
;
1671 Lf
= get16(s
); if (Lf
< 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
1672 p
= get8(s
); if (p
!= 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
1673 s
->img_y
= get16(s
); if (s
->img_y
== 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
1674 s
->img_x
= get16(s
); if (s
->img_x
== 0) return e("0 width","Corrupt JPEG"); // JPEG requires
1676 if (c
!= 3 && c
!= 1) return e("bad component count","Corrupt JPEG"); // JFIF requires
1678 for (i
=0; i
< c
; ++i
) {
1679 z
->img_comp
[i
].data
= NULL
;
1680 z
->img_comp
[i
].linebuf
= NULL
;
1683 if (Lf
!= 8+3*s
->img_n
) return e("bad SOF len","Corrupt JPEG");
1685 for (i
=0; i
< s
->img_n
; ++i
) {
1686 z
->img_comp
[i
].id
= get8(s
);
1687 if (z
->img_comp
[i
].id
!= i
+1) // JFIF requires
1688 if (z
->img_comp
[i
].id
!= i
) // some version of jpegtran outputs non-JFIF-compliant files!
1689 return e("bad component ID","Corrupt JPEG");
1691 z
->img_comp
[i
].h
= (q
>> 4); if (!z
->img_comp
[i
].h
|| z
->img_comp
[i
].h
> 4) return e("bad H","Corrupt JPEG");
1692 z
->img_comp
[i
].v
= q
& 15; if (!z
->img_comp
[i
].v
|| z
->img_comp
[i
].v
> 4) return e("bad V","Corrupt JPEG");
1693 z
->img_comp
[i
].tq
= get8(s
); if (z
->img_comp
[i
].tq
> 3) return e("bad TQ","Corrupt JPEG");
1696 if (scan
!= SCAN_load
) return 1;
1698 if ((1 << 30) / s
->img_x
/ s
->img_n
< s
->img_y
) return e("too large", "Image too large to decode");
1700 for (i
=0; i
< s
->img_n
; ++i
) {
1701 if (z
->img_comp
[i
].h
> h_max
) h_max
= z
->img_comp
[i
].h
;
1702 if (z
->img_comp
[i
].v
> v_max
) v_max
= z
->img_comp
[i
].v
;
1705 // compute interleaved mcu info
1706 z
->img_h_max
= h_max
;
1707 z
->img_v_max
= v_max
;
1708 z
->img_mcu_w
= h_max
* 8;
1709 z
->img_mcu_h
= v_max
* 8;
1710 z
->img_mcu_x
= (s
->img_x
+ z
->img_mcu_w
-1) / z
->img_mcu_w
;
1711 z
->img_mcu_y
= (s
->img_y
+ z
->img_mcu_h
-1) / z
->img_mcu_h
;
1713 for (i
=0; i
< s
->img_n
; ++i
) {
1714 // number of effective pixels (e.g. for non-interleaved MCU)
1715 z
->img_comp
[i
].x
= (s
->img_x
* z
->img_comp
[i
].h
+ h_max
-1) / h_max
;
1716 z
->img_comp
[i
].y
= (s
->img_y
* z
->img_comp
[i
].v
+ v_max
-1) / v_max
;
1717 // to simplify generation, we'll allocate enough memory to decode
1718 // the bogus oversized data from using interleaved MCUs and their
1719 // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
1720 // discard the extra data until colorspace conversion
1721 z
->img_comp
[i
].w2
= z
->img_mcu_x
* z
->img_comp
[i
].h
* 8;
1722 z
->img_comp
[i
].h2
= z
->img_mcu_y
* z
->img_comp
[i
].v
* 8;
1723 z
->img_comp
[i
].raw_data
= MALLOC(z
->img_comp
[i
].w2
* z
->img_comp
[i
].h2
+15);
1724 if (z
->img_comp
[i
].raw_data
== NULL
) {
1725 for(--i
; i
>= 0; --i
) {
1726 FREE(z
->img_comp
[i
].raw_data
);
1727 z
->img_comp
[i
].data
= NULL
;
1729 return e("outofmem", "Out of memory");
1731 // align blocks for installable-idct using mmx/sse
1732 z
->img_comp
[i
].data
= (uint8
*) (((size_t) z
->img_comp
[i
].raw_data
+ 15) & ~15);
1733 z
->img_comp
[i
].linebuf
= NULL
;
1739 // use comparisons since in some cases we handle more than one case (e.g. SOF)
1740 #define DNL(x) ((x) == 0xdc)
1741 #define SOI(x) ((x) == 0xd8)
1742 #define EOI(x) ((x) == 0xd9)
1743 #define SOF(x) ((x) == 0xc0 || (x) == 0xc1)
1744 #define SOS(x) ((x) == 0xda)
1746 static int decode_jpeg_header(jpeg
*z
, int scan
)
1749 z
->marker
= MARKER_none
; // initialize cached marker to empty
1751 if (!SOI(m
)) return e("no SOI","Corrupt JPEG");
1752 if (scan
== SCAN_type
) return 1;
1755 if (!process_marker(z
,m
)) return 0;
1757 while (m
== MARKER_none
) {
1758 // some files have extra padding after their blocks, so ok, we'll scan
1759 if (at_eof(&z
->s
)) return e("no SOF", "Corrupt JPEG");
1763 if (!process_frame_header(z
, scan
)) return 0;
1767 static int decode_jpeg_image(jpeg
*j
)
1770 j
->restart_interval
= 0;
1771 if (!decode_jpeg_header(j
, SCAN_load
)) return 0;
1775 if (!process_scan_header(j
)) return 0;
1776 if (!parse_entropy_coded_data(j
)) return 0;
1777 if (j
->marker
== MARKER_none
) {
1778 // handle 0s at the end of image data from IP Kamera 9060
1779 while (!at_eof(&j
->s
)) {
1780 int x
= get8(&j
->s
);
1782 j
->marker
= get8u(&j
->s
);
1784 } else if (x
!= 0) {
1788 // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0
1791 if (!process_marker(j
, m
)) return 0;
1798 // static jfif-centered resampling (across block boundaries)
1800 typedef uint8
*(*resample_row_func
)(uint8
*out
, uint8
*in0
, uint8
*in1
,
1803 #define div4(x) ((uint8) ((x) >> 2))
1805 static uint8
*resample_row_1(uint8
*out
, uint8
*in_near
, uint8
*in_far
, int w
, int hs
)
1808 STBI_NOTUSED(in_far
);
1814 static uint8
* resample_row_v_2(uint8
*out
, uint8
*in_near
, uint8
*in_far
, int w
, int hs
)
1816 // need to generate two samples vertically for every one in input
1819 for (i
=0; i
< w
; ++i
)
1820 out
[i
] = div4(3*in_near
[i
] + in_far
[i
] + 2);
1824 static uint8
* resample_row_h_2(uint8
*out
, uint8
*in_near
, uint8
*in_far
, int w
, int hs
)
1826 // need to generate two samples horizontally for every one in input
1828 uint8
*input
= in_near
;
1831 // if only one sample, can't do any interpolation
1832 out
[0] = out
[1] = input
[0];
1837 out
[1] = div4(input
[0]*3 + input
[1] + 2);
1838 for (i
=1; i
< w
-1; ++i
) {
1839 int n
= 3*input
[i
]+2;
1840 out
[i
*2+0] = div4(n
+input
[i
-1]);
1841 out
[i
*2+1] = div4(n
+input
[i
+1]);
1843 out
[i
*2+0] = div4(input
[w
-2]*3 + input
[w
-1] + 2);
1844 out
[i
*2+1] = input
[w
-1];
1846 STBI_NOTUSED(in_far
);
1852 #define div16(x) ((uint8) ((x) >> 4))
1854 static uint8
*resample_row_hv_2(uint8
*out
, uint8
*in_near
, uint8
*in_far
, int w
, int hs
)
1856 // need to generate 2x2 samples for every one in input
1859 out
[0] = out
[1] = div4(3*in_near
[0] + in_far
[0] + 2);
1863 t1
= 3*in_near
[0] + in_far
[0];
1864 out
[0] = div4(t1
+2);
1865 for (i
=1; i
< w
; ++i
) {
1867 t1
= 3*in_near
[i
]+in_far
[i
];
1868 out
[i
*2-1] = div16(3*t0
+ t1
+ 8);
1869 out
[i
*2 ] = div16(3*t1
+ t0
+ 8);
1871 out
[w
*2-1] = div4(t1
+2);
1878 static uint8
*resample_row_generic(uint8
*out
, uint8
*in_near
, uint8
*in_far
, int w
, int hs
)
1880 // resample with nearest-neighbor
1883 for (i
=0; i
< w
; ++i
)
1884 for (j
=0; j
< hs
; ++j
)
1885 out
[i
*hs
+j
] = in_near
[i
];
1889 #define float2fixed(x) ((int) ((x) * 65536 + 0.5))
1891 // 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro)
1892 // VC6 without processor=Pro is generating multiple LEAs per multiply!
1893 static void YCbCr_to_RGB_row(uint8
*out
, const uint8
*y
, const uint8
*pcb
, const uint8
*pcr
, int count
, int step
)
1896 for (i
=0; i
< count
; ++i
) {
1897 int y_fixed
= (y
[i
] << 16) + 32768; // rounding
1899 int cr
= pcr
[i
] - 128;
1900 int cb
= pcb
[i
] - 128;
1901 r
= y_fixed
+ cr
*float2fixed(1.40200f
);
1902 g
= y_fixed
- cr
*float2fixed(0.71414f
) - cb
*float2fixed(0.34414f
);
1903 b
= y_fixed
+ cb
*float2fixed(1.77200f
);
1907 if ((unsigned) r
> 255) { if (r
< 0) r
= 0; else r
= 255; }
1908 if ((unsigned) g
> 255) { if (g
< 0) g
= 0; else g
= 255; }
1909 if ((unsigned) b
> 255) { if (b
< 0) b
= 0; else b
= 255; }
1919 static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed
= YCbCr_to_RGB_row
;
1921 void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func
)
1923 stbi_YCbCr_installed
= func
;
1928 // clean up the temporary component buffers
1929 static void cleanup_jpeg(jpeg
*j
)
1932 for (i
=0; i
< j
->s
.img_n
; ++i
) {
1933 if (j
->img_comp
[i
].data
) {
1934 FREE(j
->img_comp
[i
].raw_data
);
1935 j
->img_comp
[i
].data
= NULL
;
1937 if (j
->img_comp
[i
].linebuf
) {
1938 FREE(j
->img_comp
[i
].linebuf
);
1939 j
->img_comp
[i
].linebuf
= NULL
;
1946 resample_row_func resample
;
1947 uint8
*line0
,*line1
;
1948 int hs
,vs
; // expansion factor in each axis
1949 int w_lores
; // horizontal pixels pre-expansion
1950 int ystep
; // how far through vertical expansion we are
1951 int ypos
; // which pre-expansion row we're on
1954 static uint8
*load_jpeg_image(jpeg
*z
, int *out_x
, int *out_y
, int *comp
, int req_comp
)
1957 // validate req_comp
1958 if (req_comp
< 0 || req_comp
> 4) return epuc("bad req_comp", "Internal error");
1961 // load a jpeg image from whichever source
1962 if (!decode_jpeg_image(z
)) { cleanup_jpeg(z
); return NULL
; }
1964 // determine actual number of components to generate
1965 n
= req_comp
? req_comp
: z
->s
.img_n
;
1967 if (z
->s
.img_n
== 3 && n
< 3)
1970 decode_n
= z
->s
.img_n
;
1972 // resample and color-convert
1979 stbi_resample res_comp
[4];
1981 for (k
=0; k
< decode_n
; ++k
) {
1982 stbi_resample
*r
= &res_comp
[k
];
1984 // allocate line buffer big enough for upsampling off the edges
1985 // with upsample factor of 4
1986 z
->img_comp
[k
].linebuf
= (uint8
*) MALLOC(z
->s
.img_x
+ 3);
1987 if (!z
->img_comp
[k
].linebuf
) { cleanup_jpeg(z
); return epuc("outofmem", "Out of memory"); }
1989 r
->hs
= z
->img_h_max
/ z
->img_comp
[k
].h
;
1990 r
->vs
= z
->img_v_max
/ z
->img_comp
[k
].v
;
1991 r
->ystep
= r
->vs
>> 1;
1992 r
->w_lores
= (z
->s
.img_x
+ r
->hs
-1) / r
->hs
;
1994 r
->line0
= r
->line1
= z
->img_comp
[k
].data
;
1996 if (r
->hs
== 1 && r
->vs
== 1) r
->resample
= resample_row_1
;
1997 else if (r
->hs
== 1 && r
->vs
== 2) r
->resample
= resample_row_v_2
;
1998 else if (r
->hs
== 2 && r
->vs
== 1) r
->resample
= resample_row_h_2
;
1999 else if (r
->hs
== 2 && r
->vs
== 2) r
->resample
= resample_row_hv_2
;
2000 else r
->resample
= resample_row_generic
;
2003 // can't error after this so, this is safe
2004 output
= (uint8
*) MALLOC(n
* z
->s
.img_x
* z
->s
.img_y
+ 1);
2005 if (!output
) { cleanup_jpeg(z
); return epuc("outofmem", "Out of memory"); }
2007 // now go ahead and resample
2008 for (j
=0; j
< z
->s
.img_y
; ++j
) {
2009 uint8
*out
= output
+ n
* z
->s
.img_x
* j
;
2010 for (k
=0; k
< decode_n
; ++k
) {
2011 stbi_resample
*r
= &res_comp
[k
];
2012 int y_bot
= r
->ystep
>= (r
->vs
>> 1);
2013 coutput
[k
] = r
->resample(z
->img_comp
[k
].linebuf
,
2014 y_bot
? r
->line1
: r
->line0
,
2015 y_bot
? r
->line0
: r
->line1
,
2017 if (++r
->ystep
>= r
->vs
) {
2019 r
->line0
= r
->line1
;
2020 if (++r
->ypos
< z
->img_comp
[k
].y
)
2021 r
->line1
+= z
->img_comp
[k
].w2
;
2025 uint8
*y
= coutput
[0];
2026 if (z
->s
.img_n
== 3) {
2028 stbi_YCbCr_installed(out
, y
, coutput
[1], coutput
[2], z
->s
.img_x
, n
);
2030 YCbCr_to_RGB_row(out
, y
, coutput
[1], coutput
[2], z
->s
.img_x
, n
);
2033 for (i
=0; i
< z
->s
.img_x
; ++i
) {
2034 out
[0] = out
[1] = out
[2] = y
[i
];
2035 out
[3] = 255; // not used if n==3
2039 uint8
*y
= coutput
[0];
2041 for (i
=0; i
< z
->s
.img_x
; ++i
) out
[i
] = y
[i
];
2043 for (i
=0; i
< z
->s
.img_x
; ++i
) *out
++ = y
[i
], *out
++ = 255;
2047 *out_x
= z
->s
.img_x
;
2048 *out_y
= z
->s
.img_y
;
2049 if (comp
) *comp
= z
->s
.img_n
; // report original components, not output
2054 #ifndef STBI_NO_STDIO
2055 unsigned char *stbi_jpeg_load_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
2058 start_file(&j
.s
, f
);
2059 return load_jpeg_image(&j
, x
,y
,comp
,req_comp
);
2062 unsigned char *stbi_jpeg_load(char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
2064 unsigned char *data
;
2065 FILE *f
= fopen(filename
, "rb");
2066 if (!f
) return NULL
;
2067 data
= stbi_jpeg_load_from_file(f
,x
,y
,comp
,req_comp
);
2073 unsigned char *stbi_jpeg_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
2075 #ifdef STBI_SMALL_STACK
2076 unsigned char *result
;
2077 jpeg
*j
= (jpeg
*) MALLOC(sizeof(*j
));
2078 start_mem(&j
->s
, buffer
, len
);
2079 result
= load_jpeg_image(j
,x
,y
,comp
,req_comp
);
2084 start_mem(&j
.s
, buffer
,len
);
2085 return load_jpeg_image(&j
, x
,y
,comp
,req_comp
);
2089 static int stbi_jpeg_info_raw(jpeg
*j
, int *x
, int *y
, int *comp
)
2091 if (!decode_jpeg_header(j
, SCAN_header
))
2093 if (x
) *x
= j
->s
.img_x
;
2094 if (y
) *y
= j
->s
.img_y
;
2095 if (comp
) *comp
= j
->s
.img_n
;
2099 #ifndef STBI_NO_STDIO
2100 int stbi_jpeg_test_file(FILE *f
)
2105 start_file(&j
.s
, f
);
2106 r
= decode_jpeg_header(&j
, SCAN_type
);
2107 fseek(f
,n
,SEEK_SET
);
2111 int stbi_jpeg_info_from_file(FILE *f
, int *x
, int *y
, int *comp
)
2116 start_file(&j
.s
, f
);
2117 res
= stbi_jpeg_info_raw(&j
, x
, y
, comp
);
2118 fseek(f
, n
, SEEK_SET
);
2122 int stbi_jpeg_info(char const *filename
, int *x
, int *y
, int *comp
)
2124 FILE *f
= fopen(filename
, "rb");
2126 if (!f
) return e("can't fopen", "Unable to open file");
2127 result
= stbi_jpeg_info_from_file(f
, x
, y
, comp
);
2133 int stbi_jpeg_test_memory(stbi_uc
const *buffer
, int len
)
2136 start_mem(&j
.s
, buffer
,len
);
2137 return decode_jpeg_header(&j
, SCAN_type
);
2140 int stbi_jpeg_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
)
2143 start_mem(&j
.s
, buffer
, len
);
2144 return stbi_jpeg_info_raw(&j
, x
, y
, comp
);
2147 #ifndef STBI_NO_STDIO
2148 extern int stbi_jpeg_info (char const *filename
, int *x
, int *y
, int *comp
);
2149 extern int stbi_jpeg_info_from_file (FILE *f
, int *x
, int *y
, int *comp
);
2151 extern int stbi_jpeg_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
);
2153 // public domain zlib decode v0.2 Sean Barrett 2006-11-18
2154 // simple implementation
2155 // - all input must be provided in an upfront buffer
2156 // - all output is written to a single output buffer (can malloc/realloc)
2160 // fast-way is faster to check than jpeg huffman, but slow way is slower
2161 #define ZFAST_BITS 9 // accelerate all cases in default tables
2162 #define ZFAST_MASK ((1 << ZFAST_BITS) - 1)
2164 // zlib-style huffman encoding
2165 // (jpegs packs from left, zlib from right, so can't share code)
2168 uint16 fast
[1 << ZFAST_BITS
];
2169 uint16 firstcode
[16];
2171 uint16 firstsymbol
[16];
2176 __forceinline
static int bitreverse16(int n
)
2178 n
= ((n
& 0xAAAA) >> 1) | ((n
& 0x5555) << 1);
2179 n
= ((n
& 0xCCCC) >> 2) | ((n
& 0x3333) << 2);
2180 n
= ((n
& 0xF0F0) >> 4) | ((n
& 0x0F0F) << 4);
2181 n
= ((n
& 0xFF00) >> 8) | ((n
& 0x00FF) << 8);
2185 __forceinline
static int bit_reverse(int v
, int bits
)
2188 // to bit reverse n bits, reverse 16 and shift
2189 // e.g. 11 bits, bit reverse and shift away 5
2190 return bitreverse16(v
) >> (16-bits
);
2193 static int zbuild_huffman(zhuffman
*z
, uint8
*sizelist
, int num
)
2196 int code
, next_code
[16], sizes
[17];
2198 // DEFLATE spec for generating codes
2199 memset(sizes
, 0, sizeof(sizes
));
2200 memset(z
->fast
, 255, sizeof(z
->fast
));
2201 for (i
=0; i
< num
; ++i
)
2202 ++sizes
[sizelist
[i
]];
2204 for (i
=1; i
< 16; ++i
)
2205 assert(sizes
[i
] <= (1 << i
));
2207 for (i
=1; i
< 16; ++i
) {
2208 next_code
[i
] = code
;
2209 z
->firstcode
[i
] = (uint16
) code
;
2210 z
->firstsymbol
[i
] = (uint16
) k
;
2211 code
= (code
+ sizes
[i
]);
2213 if (code
-1 >= (1 << i
)) return e("bad codelengths","Corrupt JPEG");
2214 z
->maxcode
[i
] = code
<< (16-i
); // preshift for inner loop
2218 z
->maxcode
[16] = 0x10000; // sentinel
2219 for (i
=0; i
< num
; ++i
) {
2220 int s
= sizelist
[i
];
2222 int c
= next_code
[s
] - z
->firstcode
[s
] + z
->firstsymbol
[s
];
2223 z
->size
[c
] = (uint8
)s
;
2224 z
->value
[c
] = (uint16
)i
;
2225 if (s
<= ZFAST_BITS
) {
2226 int m
= bit_reverse(next_code
[s
],s
);
2227 while (m
< (1 << ZFAST_BITS
)) {
2228 z
->fast
[m
] = (uint16
) c
;
2238 // zlib-from-memory implementation for PNG reading
2239 // because PNG allows splitting the zlib stream arbitrarily,
2240 // and it's annoying structurally to have PNG call ZLIB call PNG,
2241 // we require PNG read all the IDATs and combine them into a single
2246 uint8
const *zbuffer
, *zbuffer_end
;
2255 zhuffman z_length
, z_distance
;
2258 __forceinline
static int zget8(zbuf
*z
)
2260 if (z
->zbuffer
>= z
->zbuffer_end
) return 0;
2261 return *z
->zbuffer
++;
2264 static void fill_bits(zbuf
*z
)
2267 assert(z
->code_buffer
< (1U << z
->num_bits
));
2268 z
->code_buffer
|= zget8(z
) << z
->num_bits
;
2270 } while (z
->num_bits
<= 24);
2273 __forceinline
static unsigned int zreceive(zbuf
*z
, int n
)
2276 if (z
->num_bits
< n
) fill_bits(z
);
2277 k
= z
->code_buffer
& ((1 << n
) - 1);
2278 z
->code_buffer
>>= n
;
2283 __forceinline
static int zhuffman_decode(zbuf
*a
, zhuffman
*z
)
2286 if (a
->num_bits
< 16) fill_bits(a
);
2287 b
= z
->fast
[a
->code_buffer
& ZFAST_MASK
];
2290 a
->code_buffer
>>= s
;
2295 // not resolved by fast table, so compute it the slow way
2296 // use jpeg approach, which requires MSbits at top
2297 k
= bit_reverse(a
->code_buffer
, 16);
2298 for (s
=ZFAST_BITS
+1; ; ++s
)
2299 if (k
< z
->maxcode
[s
])
2301 if (s
== 16) return -1; // invalid code!
2302 // code size is s, so:
2303 b
= (k
>> (16-s
)) - z
->firstcode
[s
] + z
->firstsymbol
[s
];
2304 assert(z
->size
[b
] == s
);
2305 a
->code_buffer
>>= s
;
2310 static int expand(zbuf
*z
, int n
) // need to make room for n bytes
2314 if (!z
->z_expandable
) return e("output buffer limit","Corrupt PNG");
2315 cur
= (int) (z
->zout
- z
->zout_start
);
2316 limit
= (int) (z
->zout_end
- z
->zout_start
);
2317 while (cur
+ n
> limit
)
2319 q
= (char *) REALLOC(z
->zout_start
, limit
);
2320 if (q
== NULL
) return e("outofmem", "Out of memory");
2323 z
->zout_end
= q
+ limit
;
2327 static int length_base
[31] = {
2328 3,4,5,6,7,8,9,10,11,13,
2329 15,17,19,23,27,31,35,43,51,59,
2330 67,83,99,115,131,163,195,227,258,0,0 };
2332 static int length_extra
[31]=
2333 { 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 };
2335 static int dist_base
[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
2336 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
2338 static int dist_extra
[32] =
2339 { 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};
2341 static int parse_huffman_block(zbuf
*a
)
2344 int z
= zhuffman_decode(a
, &a
->z_length
);
2346 if (z
< 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
2347 if (a
->zout
>= a
->zout_end
) if (!expand(a
, 1)) return 0;
2348 *a
->zout
++ = (char) z
;
2352 if (z
== 256) return 1;
2354 len
= length_base
[z
];
2355 if (length_extra
[z
]) len
+= zreceive(a
, length_extra
[z
]);
2356 z
= zhuffman_decode(a
, &a
->z_distance
);
2357 if (z
< 0) return e("bad huffman code","Corrupt PNG");
2358 dist
= dist_base
[z
];
2359 if (dist_extra
[z
]) dist
+= zreceive(a
, dist_extra
[z
]);
2360 if (a
->zout
- a
->zout_start
< dist
) return e("bad dist","Corrupt PNG");
2361 if (a
->zout
+ len
> a
->zout_end
) if (!expand(a
, len
)) return 0;
2362 p
= (uint8
*) (a
->zout
- dist
);
2369 static int compute_huffman_codes(zbuf
*a
)
2371 static uint8 length_dezigzag
[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
2372 zhuffman z_codelength
;
2373 uint8 lencodes
[286+32+137];//padding for maximum single op
2374 uint8 codelength_sizes
[19];
2377 int hlit
= zreceive(a
,5) + 257;
2378 int hdist
= zreceive(a
,5) + 1;
2379 int hclen
= zreceive(a
,4) + 4;
2381 memset(codelength_sizes
, 0, sizeof(codelength_sizes
));
2382 for (i
=0; i
< hclen
; ++i
) {
2383 int s
= zreceive(a
,3);
2384 codelength_sizes
[length_dezigzag
[i
]] = (uint8
) s
;
2386 if (!zbuild_huffman(&z_codelength
, codelength_sizes
, 19)) return 0;
2389 while (n
< hlit
+ hdist
) {
2390 int c
= zhuffman_decode(a
, &z_codelength
);
2391 assert(c
>= 0 && c
< 19);
2393 lencodes
[n
++] = (uint8
) c
;
2395 c
= zreceive(a
,2)+3;
2396 memset(lencodes
+n
, lencodes
[n
-1], c
);
2398 } else if (c
== 17) {
2399 c
= zreceive(a
,3)+3;
2400 memset(lencodes
+n
, 0, c
);
2404 c
= zreceive(a
,7)+11;
2405 memset(lencodes
+n
, 0, c
);
2409 if (n
!= hlit
+hdist
) return e("bad codelengths","Corrupt PNG");
2410 if (!zbuild_huffman(&a
->z_length
, lencodes
, hlit
)) return 0;
2411 if (!zbuild_huffman(&a
->z_distance
, lencodes
+hlit
, hdist
)) return 0;
2415 static int parse_uncompressed_block(zbuf
*a
)
2419 if (a
->num_bits
& 7)
2420 zreceive(a
, a
->num_bits
& 7); // discard
2421 // drain the bit-packed data into header
2423 while (a
->num_bits
> 0) {
2424 header
[k
++] = (uint8
) (a
->code_buffer
& 255); // wtf this warns?
2425 a
->code_buffer
>>= 8;
2428 assert(a
->num_bits
== 0);
2429 // now fill header the normal way
2431 header
[k
++] = (uint8
) zget8(a
);
2432 len
= header
[1] * 256 + header
[0];
2433 nlen
= header
[3] * 256 + header
[2];
2434 if (nlen
!= (len
^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
2435 if (a
->zbuffer
+ len
> a
->zbuffer_end
) return e("read past buffer","Corrupt PNG");
2436 if (a
->zout
+ len
> a
->zout_end
)
2437 if (!expand(a
, len
)) return 0;
2438 memcpy(a
->zout
, a
->zbuffer
, len
);
2444 static int parse_zlib_header(zbuf
*a
)
2448 /* int cinfo = cmf >> 4; */
2450 if ((cmf
*256+flg
) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
2451 if (flg
& 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
2452 if (cm
!= 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
2453 // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
2457 // @TODO: should statically initialize these for optimal thread safety
2458 static uint8 default_length
[288], default_distance
[32];
2459 static void init_defaults(void)
2461 int i
; // use <= to match clearly with spec
2462 for (i
=0; i
<= 143; ++i
) default_length
[i
] = 8;
2463 for ( ; i
<= 255; ++i
) default_length
[i
] = 9;
2464 for ( ; i
<= 279; ++i
) default_length
[i
] = 7;
2465 for ( ; i
<= 287; ++i
) default_length
[i
] = 8;
2467 for (i
=0; i
<= 31; ++i
) default_distance
[i
] = 5;
2470 int stbi_png_partial
; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead
2471 static int parse_zlib(zbuf
*a
, int parse_header
)
2475 if (!parse_zlib_header(a
)) return 0;
2479 final
= zreceive(a
,1);
2480 type
= zreceive(a
,2);
2482 if (!parse_uncompressed_block(a
)) return 0;
2483 } else if (type
== 3) {
2487 // use fixed code lengths
2488 if (!default_distance
[31]) init_defaults();
2489 if (!zbuild_huffman(&a
->z_length
, default_length
, 288)) return 0;
2490 if (!zbuild_huffman(&a
->z_distance
, default_distance
, 32)) return 0;
2492 if (!compute_huffman_codes(a
)) return 0;
2494 if (!parse_huffman_block(a
)) return 0;
2496 if (stbi_png_partial
&& a
->zout
- a
->zout_start
> 65536)
2502 static int do_zlib(zbuf
*a
, char *obuf
, int olen
, int exp
, int parse_header
)
2504 a
->zout_start
= obuf
;
2506 a
->zout_end
= obuf
+ olen
;
2507 a
->z_expandable
= exp
;
2509 return parse_zlib(a
, parse_header
);
2512 char *stbi_zlib_decode_malloc_guesssize(const char * buffer
, int len
, int initial_size
, int *outlen
)
2515 char *p
= (char *) MALLOC(initial_size
);
2516 if (p
== NULL
) return NULL
;
2517 a
.zbuffer
= (uint8
const *) buffer
;
2518 a
.zbuffer_end
= (uint8
const *) buffer
+ len
;
2519 if (do_zlib(&a
, p
, initial_size
, 1, 1)) {
2520 if (outlen
) *outlen
= (int) (a
.zout
- a
.zout_start
);
2521 return a
.zout_start
;
2528 char *stbi_zlib_decode_malloc(char const *buffer
, int len
, int *outlen
)
2530 return stbi_zlib_decode_malloc_guesssize(buffer
, len
, 16384, outlen
);
2533 char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer
, int len
, int initial_size
, int *outlen
, int parse_header
)
2536 char *p
= (char *) MALLOC(initial_size
);
2537 if (p
== NULL
) return NULL
;
2538 a
.zbuffer
= (uint8
const *) buffer
;
2539 a
.zbuffer_end
= (uint8
const *) buffer
+ len
;
2540 if (do_zlib(&a
, p
, initial_size
, 1, parse_header
)) {
2541 if (outlen
) *outlen
= (int) (a
.zout
- a
.zout_start
);
2542 return a
.zout_start
;
2549 int stbi_zlib_decode_buffer(char *obuffer
, int olen
, char const *ibuffer
, int ilen
)
2552 a
.zbuffer
= (uint8
const *) ibuffer
;
2553 a
.zbuffer_end
= (uint8
const *) ibuffer
+ ilen
;
2554 if (do_zlib(&a
, obuffer
, olen
, 0, 1))
2555 return (int) (a
.zout
- a
.zout_start
);
2560 char *stbi_zlib_decode_noheader_malloc(char const *buffer
, int len
, int *outlen
)
2563 char *p
= (char *) MALLOC(16384);
2564 if (p
== NULL
) return NULL
;
2565 a
.zbuffer
= (uint8
const *) buffer
;
2566 a
.zbuffer_end
= (uint8
const *) buffer
+len
;
2567 if (do_zlib(&a
, p
, 16384, 1, 0)) {
2568 if (outlen
) *outlen
= (int) (a
.zout
- a
.zout_start
);
2569 return a
.zout_start
;
2576 int stbi_zlib_decode_noheader_buffer(char *obuffer
, int olen
, const char *ibuffer
, int ilen
)
2579 a
.zbuffer
= (uint8
const *) ibuffer
;
2580 a
.zbuffer_end
= (uint8
const *) ibuffer
+ ilen
;
2581 if (do_zlib(&a
, obuffer
, olen
, 0, 0))
2582 return (int) (a
.zout
- a
.zout_start
);
2587 // public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
2588 // simple implementation
2589 // - only 8-bit samples
2590 // - no CRC checking
2591 // - allocates lots of intermediate memory
2592 // - avoids problem of streaming data between subsystems
2593 // - avoids explicit window management
2595 // - uses stb_zlib, a PD zlib implementation with fast huffman decoding
2604 #define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
2606 static chunk
get_chunk_header(stbi
*s
)
2609 c
.length
= get32(s
);
2614 static int check_png_header(stbi
*s
)
2616 static uint8 png_sig
[8] = { 137,80,78,71,13,10,26,10 };
2618 for (i
=0; i
< 8; ++i
)
2619 if (get8(s
) != png_sig
[i
]) return e("bad png sig","Not a PNG");
2626 uint8
*idata
, *expanded
, *out
;
2631 F_none
=0, F_sub
=1, F_up
=2, F_avg
=3, F_paeth
=4,
2632 F_avg_first
, F_paeth_first
2635 static uint8 first_row_filter
[5] =
2637 F_none
, F_sub
, F_none
, F_avg_first
, F_paeth_first
2640 static int paeth(int a
, int b
, int c
)
2646 if (pa
<= pb
&& pa
<= pc
) return a
;
2647 if (pb
<= pc
) return b
;
2651 // create the png data from post-deflated data
2652 static int create_png_image_raw(png
*a
, uint8
*raw
, uint32 raw_len
, int out_n
, uint32 x
, uint32 y
)
2655 uint32 i
,j
,stride
= x
*out_n
;
2657 int img_n
= s
->img_n
; // copy it into a local for later
2658 assert(out_n
== s
->img_n
|| out_n
== s
->img_n
+1);
2659 if (stbi_png_partial
) y
= 1;
2660 a
->out
= (uint8
*) MALLOC(x
* y
* out_n
);
2661 if (!a
->out
) return e("outofmem", "Out of memory");
2662 if (!stbi_png_partial
) {
2663 if (s
->img_x
== x
&& s
->img_y
== y
) {
2664 if (raw_len
!= (img_n
* x
+ 1) * y
) return e("not enough pixels","Corrupt PNG");
2665 } else { // interlaced:
2666 if (raw_len
< (img_n
* x
+ 1) * y
) return e("not enough pixels","Corrupt PNG");
2669 for (j
=0; j
< y
; ++j
) {
2670 uint8
*cur
= a
->out
+ stride
*j
;
2671 uint8
*prior
= cur
- stride
;
2672 int filter
= *raw
++;
2673 if (filter
> 4) return e("invalid filter","Corrupt PNG");
2674 // if first row, use special filter that doesn't sample previous row
2675 if (j
== 0) filter
= first_row_filter
[filter
];
2676 // handle first pixel explicitly
2677 for (k
=0; k
< img_n
; ++k
) {
2679 case F_none
: cur
[k
] = raw
[k
]; break;
2680 case F_sub
: cur
[k
] = raw
[k
]; break;
2681 case F_up
: cur
[k
] = raw
[k
] + prior
[k
]; break;
2682 case F_avg
: cur
[k
] = raw
[k
] + (prior
[k
]>>1); break;
2683 case F_paeth
: cur
[k
] = (uint8
) (raw
[k
] + paeth(0,prior
[k
],0)); break;
2684 case F_avg_first
: cur
[k
] = raw
[k
]; break;
2685 case F_paeth_first
: cur
[k
] = raw
[k
]; break;
2688 if (img_n
!= out_n
) cur
[img_n
] = 255;
2692 // this is a little gross, so that we don't switch per-pixel or per-component
2693 if (img_n
== out_n
) {
2696 for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
2697 for (k=0; k < img_n; ++k)
2699 CASE(F_none
) cur
[k
] = raw
[k
]; break;
2700 CASE(F_sub
) cur
[k
] = raw
[k
] + cur
[k
-img_n
]; break;
2701 CASE(F_up
) cur
[k
] = raw
[k
] + prior
[k
]; break;
2702 CASE(F_avg
) cur
[k
] = raw
[k
] + ((prior
[k
] + cur
[k
-img_n
])>>1); break;
2703 CASE(F_paeth
) cur
[k
] = (uint8
) (raw
[k
] + paeth(cur
[k
-img_n
],prior
[k
],prior
[k
-img_n
])); break;
2704 CASE(F_avg_first
) cur
[k
] = raw
[k
] + (cur
[k
-img_n
] >> 1); break;
2705 CASE(F_paeth_first
) cur
[k
] = (uint8
) (raw
[k
] + paeth(cur
[k
-img_n
],0,0)); break;
2709 assert(img_n
+1 == out_n
);
2712 for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
2713 for (k=0; k < img_n; ++k)
2715 CASE(F_none
) cur
[k
] = raw
[k
]; break;
2716 CASE(F_sub
) cur
[k
] = raw
[k
] + cur
[k
-out_n
]; break;
2717 CASE(F_up
) cur
[k
] = raw
[k
] + prior
[k
]; break;
2718 CASE(F_avg
) cur
[k
] = raw
[k
] + ((prior
[k
] + cur
[k
-out_n
])>>1); break;
2719 CASE(F_paeth
) cur
[k
] = (uint8
) (raw
[k
] + paeth(cur
[k
-out_n
],prior
[k
],prior
[k
-out_n
])); break;
2720 CASE(F_avg_first
) cur
[k
] = raw
[k
] + (cur
[k
-out_n
] >> 1); break;
2721 CASE(F_paeth_first
) cur
[k
] = (uint8
) (raw
[k
] + paeth(cur
[k
-out_n
],0,0)); break;
2729 static int create_png_image(png
*a
, uint8
*raw
, uint32 raw_len
, int out_n
, int interlaced
)
2735 return create_png_image_raw(a
, raw
, raw_len
, out_n
, a
->s
.img_x
, a
->s
.img_y
);
2736 save
= stbi_png_partial
;
2737 stbi_png_partial
= 0;
2740 final
= (uint8
*) MALLOC(a
->s
.img_x
* a
->s
.img_y
* out_n
);
2741 for (p
=0; p
< 7; ++p
) {
2742 int xorig
[] = { 0,4,0,2,0,1,0 };
2743 int yorig
[] = { 0,0,4,0,2,0,1 };
2744 int xspc
[] = { 8,8,4,4,2,2,1 };
2745 int yspc
[] = { 8,8,8,4,4,2,2 };
2747 // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
2748 x
= (a
->s
.img_x
- xorig
[p
] + xspc
[p
]-1) / xspc
[p
];
2749 y
= (a
->s
.img_y
- yorig
[p
] + yspc
[p
]-1) / yspc
[p
];
2751 if (!create_png_image_raw(a
, raw
, raw_len
, out_n
, x
, y
)) {
2755 for (j
=0; j
< y
; ++j
)
2756 for (i
=0; i
< x
; ++i
)
2757 memcpy(final
+ (j
*yspc
[p
]+yorig
[p
])*a
->s
.img_x
*out_n
+ (i
*xspc
[p
]+xorig
[p
])*out_n
,
2758 a
->out
+ (j
*x
+i
)*out_n
, out_n
);
2760 raw
+= (x
*out_n
+1)*y
;
2761 raw_len
-= (x
*out_n
+1)*y
;
2766 stbi_png_partial
= save
;
2770 static int compute_transparency(png
*z
, uint8 tc
[3], int out_n
)
2773 uint32 i
, pixel_count
= s
->img_x
* s
->img_y
;
2776 // compute color-based transparency, assuming we've
2777 // already got 255 as the alpha value in the output
2778 assert(out_n
== 2 || out_n
== 4);
2781 for (i
=0; i
< pixel_count
; ++i
) {
2782 p
[1] = (p
[0] == tc
[0] ? 0 : 255);
2786 for (i
=0; i
< pixel_count
; ++i
) {
2787 if (p
[0] == tc
[0] && p
[1] == tc
[1] && p
[2] == tc
[2])
2795 static int expand_palette(png
*a
, uint8
*palette
, int len
, int pal_img_n
)
2797 uint32 i
, pixel_count
= a
->s
.img_x
* a
->s
.img_y
;
2798 uint8
*p
, *temp_out
, *orig
= a
->out
;
2800 p
= (uint8
*) MALLOC(pixel_count
* pal_img_n
);
2801 if (p
== NULL
) return e("outofmem", "Out of memory");
2803 // between here and FREE(out) below, exiting would leak
2806 if (pal_img_n
== 3) {
2807 for (i
=0; i
< pixel_count
; ++i
) {
2810 p
[1] = palette
[n
+1];
2811 p
[2] = palette
[n
+2];
2815 for (i
=0; i
< pixel_count
; ++i
) {
2818 p
[1] = palette
[n
+1];
2819 p
[2] = palette
[n
+2];
2820 p
[3] = palette
[n
+3];
2832 static int stbi_unpremultiply_on_load
= 0;
2833 static int stbi_de_iphone_flag
= 0;
2835 void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply
)
2837 stbi_unpremultiply_on_load
= flag_true_if_should_unpremultiply
;
2839 void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert
)
2841 stbi_de_iphone_flag
= flag_true_if_should_convert
;
2844 static void stbi_de_iphone(png
*z
)
2847 uint32 i
, pixel_count
= s
->img_x
* s
->img_y
;
2850 if (s
->img_out_n
== 3) { // convert bgr to rgb
2851 for (i
=0; i
< pixel_count
; ++i
) {
2858 assert(s
->img_out_n
== 4);
2859 if (stbi_unpremultiply_on_load
) {
2860 // convert bgr to rgb and unpremultiply
2861 for (i
=0; i
< pixel_count
; ++i
) {
2865 p
[0] = p
[2] * 255 / a
;
2866 p
[1] = p
[1] * 255 / a
;
2875 // convert bgr to rgb
2876 for (i
=0; i
< pixel_count
; ++i
) {
2886 static int parse_png_file(png
*z
, int scan
, int req_comp
)
2888 uint8 palette
[1024], pal_img_n
=0;
2889 uint8 has_trans
=0, tc
[3];
2890 uint32 ioff
=0, idata_limit
=0, i
, pal_len
=0;
2891 int first
=1,k
,interlace
=0, iphone
=0;
2894 if (!check_png_header(s
)) return 0;
2896 if (scan
== SCAN_type
) return 1;
2899 chunk c
= get_chunk_header(s
);
2901 case PNG_TYPE('C','g','B','I'):
2902 iphone
= stbi_de_iphone_flag
;
2905 case PNG_TYPE('I','H','D','R'): {
2906 int depth
,color
,comp
,filter
;
2907 if (!first
) return e("multiple IHDR","Corrupt PNG");
2909 if (c
.length
!= 13) return e("bad IHDR len","Corrupt PNG");
2910 s
->img_x
= get32(s
); if (s
->img_x
> (1 << 24)) return e("too large","Very large image (corrupt?)");
2911 s
->img_y
= get32(s
); if (s
->img_y
> (1 << 24)) return e("too large","Very large image (corrupt?)");
2912 depth
= get8(s
); if (depth
!= 8) return e("8bit only","PNG not supported: 8-bit only");
2913 color
= get8(s
); if (color
> 6) return e("bad ctype","Corrupt PNG");
2914 if (color
== 3) pal_img_n
= 3; else if (color
& 1) return e("bad ctype","Corrupt PNG");
2915 comp
= get8(s
); if (comp
) return e("bad comp method","Corrupt PNG");
2916 filter
= get8(s
); if (filter
) return e("bad filter method","Corrupt PNG");
2917 interlace
= get8(s
); if (interlace
>1) return e("bad interlace method","Corrupt PNG");
2918 if (!s
->img_x
|| !s
->img_y
) return e("0-pixel image","Corrupt PNG");
2920 s
->img_n
= (color
& 2 ? 3 : 1) + (color
& 4 ? 1 : 0);
2921 if ((1 << 30) / s
->img_x
/ s
->img_n
< s
->img_y
) return e("too large", "Image too large to decode");
2922 if (scan
== SCAN_header
) return 1;
2924 // if paletted, then pal_n is our final components, and
2925 // img_n is # components to decompress/filter.
2927 if ((1 << 30) / s
->img_x
/ 4 < s
->img_y
) return e("too large","Corrupt PNG");
2928 // if SCAN_header, have to scan to see if we have a tRNS
2933 case PNG_TYPE('P','L','T','E'): {
2934 if (first
) return e("first not IHDR", "Corrupt PNG");
2935 if (c
.length
> 256*3) return e("invalid PLTE","Corrupt PNG");
2936 pal_len
= c
.length
/ 3;
2937 if (pal_len
* 3 != c
.length
) return e("invalid PLTE","Corrupt PNG");
2938 for (i
=0; i
< pal_len
; ++i
) {
2939 palette
[i
*4+0] = get8u(s
);
2940 palette
[i
*4+1] = get8u(s
);
2941 palette
[i
*4+2] = get8u(s
);
2942 palette
[i
*4+3] = 255;
2947 case PNG_TYPE('t','R','N','S'): {
2948 if (first
) return e("first not IHDR", "Corrupt PNG");
2949 if (z
->idata
) return e("tRNS after IDAT","Corrupt PNG");
2951 if (scan
== SCAN_header
) { s
->img_n
= 4; return 1; }
2952 if (pal_len
== 0) return e("tRNS before PLTE","Corrupt PNG");
2953 if (c
.length
> pal_len
) return e("bad tRNS len","Corrupt PNG");
2955 for (i
=0; i
< c
.length
; ++i
)
2956 palette
[i
*4+3] = get8u(s
);
2958 if (!(s
->img_n
& 1)) return e("tRNS with alpha","Corrupt PNG");
2959 if (c
.length
!= (uint32
) s
->img_n
*2) return e("bad tRNS len","Corrupt PNG");
2961 for (k
=0; k
< s
->img_n
; ++k
)
2962 tc
[k
] = (uint8
) get16(s
); // non 8-bit images will be larger
2967 case PNG_TYPE('I','D','A','T'): {
2968 if (first
) return e("first not IHDR", "Corrupt PNG");
2969 if (pal_img_n
&& !pal_len
) return e("no PLTE","Corrupt PNG");
2970 if (scan
== SCAN_header
) { s
->img_n
= pal_img_n
; return 1; }
2971 if (ioff
+ c
.length
> idata_limit
) {
2973 if (idata_limit
== 0) idata_limit
= c
.length
> 4096 ? c
.length
: 4096;
2974 while (ioff
+ c
.length
> idata_limit
)
2976 p
= (uint8
*) REALLOC(z
->idata
, idata_limit
); if (p
== NULL
) return e("outofmem", "Out of memory");
2979 if (!getn(s
, z
->idata
+ioff
,c
.length
)) return e("outofdata","Corrupt PNG");
2984 case PNG_TYPE('I','E','N','D'): {
2986 if (first
) return e("first not IHDR", "Corrupt PNG");
2987 if (scan
!= SCAN_load
) return 1;
2988 if (z
->idata
== NULL
) return e("no IDAT","Corrupt PNG");
2989 z
->expanded
= (uint8
*) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z
->idata
, ioff
, 16384, (int *) &raw_len
, !iphone
);
2990 if (z
->expanded
== NULL
) return 0; // zlib should set error
2991 FREE(z
->idata
); z
->idata
= NULL
;
2992 if ((req_comp
== s
->img_n
+1 && req_comp
!= 3 && !pal_img_n
) || has_trans
)
2993 s
->img_out_n
= s
->img_n
+1;
2995 s
->img_out_n
= s
->img_n
;
2996 if (!create_png_image(z
, z
->expanded
, raw_len
, s
->img_out_n
, interlace
)) return 0;
2998 if (!compute_transparency(z
, tc
, s
->img_out_n
)) return 0;
2999 if (iphone
&& s
->img_out_n
> 2)
3002 // pal_img_n == 3 or 4
3003 s
->img_n
= pal_img_n
; // record the actual colors we had
3004 s
->img_out_n
= pal_img_n
;
3005 if (req_comp
>= 3) s
->img_out_n
= req_comp
;
3006 if (!expand_palette(z
, palette
, pal_len
, s
->img_out_n
))
3009 FREE(z
->expanded
); z
->expanded
= NULL
;
3014 // if critical, fail
3015 if (first
) return e("first not IHDR", "Corrupt PNG");
3016 if ((c
.type
& (1 << 29)) == 0) {
3017 #ifndef STBI_NO_FAILURE_STRINGS
3019 static char invalid_chunk
[] = "XXXX chunk not known";
3020 invalid_chunk
[0] = (uint8
) (c
.type
>> 24);
3021 invalid_chunk
[1] = (uint8
) (c
.type
>> 16);
3022 invalid_chunk
[2] = (uint8
) (c
.type
>> 8);
3023 invalid_chunk
[3] = (uint8
) (c
.type
>> 0);
3025 return e(invalid_chunk
, "PNG not supported: unknown chunk type");
3030 // end of chunk, read and skip CRC
3035 static unsigned char *do_png(png
*p
, int *x
, int *y
, int *n
, int req_comp
)
3037 unsigned char *result
=NULL
;
3041 if (req_comp
< 0 || req_comp
> 4) return epuc("bad req_comp", "Internal error");
3042 if (parse_png_file(p
, SCAN_load
, req_comp
)) {
3045 if (req_comp
&& req_comp
!= p
->s
.img_out_n
) {
3046 result
= convert_format(result
, p
->s
.img_out_n
, req_comp
, p
->s
.img_x
, p
->s
.img_y
);
3047 p
->s
.img_out_n
= req_comp
;
3048 if (result
== NULL
) return result
;
3052 if (n
) *n
= p
->s
.img_n
;
3054 FREE(p
->expanded
); p
->expanded
= NULL
;
3055 FREE(p
->idata
); p
->idata
= NULL
;
3060 #ifndef STBI_NO_STDIO
3061 unsigned char *stbi_png_load_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
3064 start_file(&p
.s
, f
);
3065 return do_png(&p
, x
,y
,comp
,req_comp
);
3068 unsigned char *stbi_png_load(char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
3070 unsigned char *data
;
3071 FILE *f
= fopen(filename
, "rb");
3072 if (!f
) return NULL
;
3073 data
= stbi_png_load_from_file(f
,x
,y
,comp
,req_comp
);
3079 unsigned char *stbi_png_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
3082 start_mem(&p
.s
, buffer
,len
);
3083 return do_png(&p
, x
,y
,comp
,req_comp
);
3086 #ifndef STBI_NO_STDIO
3087 int stbi_png_test_file(FILE *f
)
3092 start_file(&p
.s
, f
);
3093 r
= parse_png_file(&p
, SCAN_type
,STBI_default
);
3094 fseek(f
,n
,SEEK_SET
);
3099 int stbi_png_test_memory(stbi_uc
const *buffer
, int len
)
3102 start_mem(&p
.s
, buffer
, len
);
3103 return parse_png_file(&p
, SCAN_type
,STBI_default
);
3106 static int stbi_png_info_raw(png
*p
, int *x
, int *y
, int *comp
)
3108 if (!parse_png_file(p
, SCAN_header
, 0))
3110 if (x
) *x
= p
->s
.img_x
;
3111 if (y
) *y
= p
->s
.img_y
;
3112 if (comp
) *comp
= p
->s
.img_n
;
3116 #ifndef STBI_NO_STDIO
3117 int stbi_png_info (char const *filename
, int *x
, int *y
, int *comp
)
3120 FILE *f
= fopen(filename
, "rb");
3122 res
= stbi_png_info_from_file(f
, x
, y
, comp
);
3127 int stbi_png_info_from_file(FILE *f
, int *x
, int *y
, int *comp
)
3132 start_file(&p
.s
, f
);
3133 res
= stbi_png_info_raw(&p
, x
, y
, comp
);
3134 fseek(f
, n
, SEEK_SET
);
3137 #endif // !STBI_NO_STDIO
3139 int stbi_png_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
)
3142 start_mem(&p
.s
, buffer
, len
);
3143 return stbi_png_info_raw(&p
, x
, y
, comp
);
3146 // Microsoft/Windows BMP image
3148 static int bmp_test(stbi
*s
)
3151 if (get8(s
) != 'B') return 0;
3152 if (get8(s
) != 'M') return 0;
3153 get32le(s
); // discard filesize
3154 get16le(s
); // discard reserved
3155 get16le(s
); // discard reserved
3156 get32le(s
); // discard data offset
3158 if (sz
== 12 || sz
== 40 || sz
== 56 || sz
== 108) return 1;
3162 #ifndef STBI_NO_STDIO
3163 int stbi_bmp_test_file (FILE *f
)
3169 fseek(f
,n
,SEEK_SET
);
3174 int stbi_bmp_test_memory (stbi_uc
const *buffer
, int len
)
3177 start_mem(&s
, buffer
, len
);
3178 return bmp_test(&s
);
3181 // returns 0..31 for the highest set bit
3182 static int high_bit(unsigned int z
)
3185 if (z
== 0) return -1;
3186 if (z
>= 0x10000) n
+= 16, z
>>= 16;
3187 if (z
>= 0x00100) n
+= 8, z
>>= 8;
3188 if (z
>= 0x00010) n
+= 4, z
>>= 4;
3189 if (z
>= 0x00004) n
+= 2, z
>>= 2;
3190 if (z
>= 0x00002) n
+= 1, z
>>= 1;
3194 static int bitcount(unsigned int a
)
3196 a
= (a
& 0x55555555) + ((a
>> 1) & 0x55555555); // max 2
3197 a
= (a
& 0x33333333) + ((a
>> 2) & 0x33333333); // max 4
3198 a
= (a
+ (a
>> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
3199 a
= (a
+ (a
>> 8)); // max 16 per 8 bits
3200 a
= (a
+ (a
>> 16)); // max 32 per 8 bits
3204 static int shiftsigned(int v
, int shift
, int bits
)
3209 if (shift
< 0) v
<<= -shift
;
3221 static stbi_uc
*bmp_load(stbi
*s
, int *x
, int *y
, int *comp
, int req_comp
)
3224 unsigned int mr
=0,mg
=0,mb
=0,ma
=0;
3225 stbi_uc pal
[256][4];
3226 int psize
=0,i
,j
,compress
=0,width
;
3227 int bpp
, flip_vertically
, pad
, target
, offset
, hsz
;
3228 if (get8(s
) != 'B' || get8(s
) != 'M') return epuc("not BMP", "Corrupt BMP");
3229 get32le(s
); // discard filesize
3230 get16le(s
); // discard reserved
3231 get16le(s
); // discard reserved
3232 offset
= get32le(s
);
3234 if (hsz
!= 12 && hsz
!= 40 && hsz
!= 56 && hsz
!= 108) return epuc("unknown BMP", "BMP type not supported: unknown");
3236 s
->img_x
= get16le(s
);
3237 s
->img_y
= get16le(s
);
3239 s
->img_x
= get32le(s
);
3240 s
->img_y
= get32le(s
);
3242 if (get16le(s
) != 1) return epuc("bad BMP", "bad BMP");
3244 if (bpp
== 1) return epuc("monochrome", "BMP type not supported: 1-bit");
3245 flip_vertically
= ((int) s
->img_y
) > 0;
3246 s
->img_y
= abs((int) s
->img_y
);
3249 psize
= (offset
- 14 - 24) / 3;
3251 compress
= get32le(s
);
3252 if (compress
== 1 || compress
== 2) return epuc("BMP RLE", "BMP type not supported: RLE");
3253 get32le(s
); // discard sizeof
3254 get32le(s
); // discard hres
3255 get32le(s
); // discard vres
3256 get32le(s
); // discard colorsused
3257 get32le(s
); // discard max important
3258 if (hsz
== 40 || hsz
== 56) {
3265 if (bpp
== 16 || bpp
== 32) {
3267 if (compress
== 0) {
3278 } else if (compress
== 3) {
3282 // not documented, but generated by photoshop and handled by mspaint
3283 if (mr
== mg
&& mg
== mb
) {
3285 return epuc("bad BMP", "bad BMP");
3288 return epuc("bad BMP", "bad BMP");
3296 get32le(s
); // discard color space
3297 for (i
=0; i
< 12; ++i
)
3298 get32le(s
); // discard color space parameters
3301 psize
= (offset
- 14 - hsz
) >> 2;
3303 s
->img_n
= ma
? 4 : 3;
3304 if (req_comp
&& req_comp
>= 3) // we can directly decode 3 or 4
3307 target
= s
->img_n
; // if they want monochrome, we'll post-convert
3308 out
= (stbi_uc
*) MALLOC(target
* s
->img_x
* s
->img_y
);
3309 if (!out
) return epuc("outofmem", "Out of memory");
3312 if (psize
== 0 || psize
> 256) { FREE(out
); return epuc("invalid", "Corrupt BMP"); }
3313 for (i
=0; i
< psize
; ++i
) {
3314 pal
[i
][2] = get8u(s
);
3315 pal
[i
][1] = get8u(s
);
3316 pal
[i
][0] = get8u(s
);
3317 if (hsz
!= 12) get8(s
);
3320 skip(s
, offset
- 14 - hsz
- psize
* (hsz
== 12 ? 3 : 4));
3321 if (bpp
== 4) width
= (s
->img_x
+ 1) >> 1;
3322 else if (bpp
== 8) width
= s
->img_x
;
3323 else { FREE(out
); return epuc("bad bpp", "Corrupt BMP"); }
3325 for (j
=0; j
< (int) s
->img_y
; ++j
) {
3326 for (i
=0; i
< (int) s
->img_x
; i
+= 2) {
3332 out
[z
++] = pal
[v
][0];
3333 out
[z
++] = pal
[v
][1];
3334 out
[z
++] = pal
[v
][2];
3335 if (target
== 4) out
[z
++] = 255;
3336 if (i
+1 == (int) s
->img_x
) break;
3337 v
= (bpp
== 8) ? get8(s
) : v2
;
3338 out
[z
++] = pal
[v
][0];
3339 out
[z
++] = pal
[v
][1];
3340 out
[z
++] = pal
[v
][2];
3341 if (target
== 4) out
[z
++] = 255;
3346 int rshift
=0,gshift
=0,bshift
=0,ashift
=0,rcount
=0,gcount
=0,bcount
=0,acount
=0;
3349 skip(s
, offset
- 14 - hsz
);
3350 if (bpp
== 24) width
= 3 * s
->img_x
;
3351 else if (bpp
== 16) width
= 2*s
->img_x
;
3352 else /* bpp = 32 and pad = 0 */ width
=0;
3356 } else if (bpp
== 32) {
3357 if (mb
== 0xff && mg
== 0xff00 && mr
== 0xff000000 && ma
== 0xff000000)
3361 if (!mr
|| !mg
|| !mb
) return epuc("bad masks", "Corrupt BMP");
3362 // right shift amt to put high bit in position #7
3363 rshift
= high_bit(mr
)-7; rcount
= bitcount(mr
);
3364 gshift
= high_bit(mg
)-7; gcount
= bitcount(mr
);
3365 bshift
= high_bit(mb
)-7; bcount
= bitcount(mr
);
3366 ashift
= high_bit(ma
)-7; acount
= bitcount(mr
);
3368 for (j
=0; j
< (int) s
->img_y
; ++j
) {
3370 for (i
=0; i
< (int) s
->img_x
; ++i
) {
3372 out
[z
+2] = get8u(s
);
3373 out
[z
+1] = get8u(s
);
3374 out
[z
+0] = get8u(s
);
3376 a
= (easy
== 2 ? get8(s
) : 255);
3377 if (target
== 4) out
[z
++] = (uint8
) a
;
3380 for (i
=0; i
< (int) s
->img_x
; ++i
) {
3381 uint32 v
= (bpp
== 16 ? get16le(s
) : get32le(s
));
3383 out
[z
++] = (uint8
) shiftsigned(v
& mr
, rshift
, rcount
);
3384 out
[z
++] = (uint8
) shiftsigned(v
& mg
, gshift
, gcount
);
3385 out
[z
++] = (uint8
) shiftsigned(v
& mb
, bshift
, bcount
);
3386 a
= (ma
? shiftsigned(v
& ma
, ashift
, acount
) : 255);
3387 if (target
== 4) out
[z
++] = (uint8
) a
;
3393 if (flip_vertically
) {
3395 for (j
=0; j
< (int) s
->img_y
>>1; ++j
) {
3396 stbi_uc
*p1
= out
+ j
*s
->img_x
*target
;
3397 stbi_uc
*p2
= out
+ (s
->img_y
-1-j
)*s
->img_x
*target
;
3398 for (i
=0; i
< (int) s
->img_x
*target
; ++i
) {
3399 t
= p1
[i
], p1
[i
] = p2
[i
], p2
[i
] = t
;
3404 if (req_comp
&& req_comp
!= target
) {
3405 out
= convert_format(out
, target
, req_comp
, s
->img_x
, s
->img_y
);
3406 if (out
== NULL
) return out
; // convert_format frees input on failure
3411 if (comp
) *comp
= target
;
3415 #ifndef STBI_NO_STDIO
3416 stbi_uc
*stbi_bmp_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
3419 FILE *f
= fopen(filename
, "rb");
3420 if (!f
) return NULL
;
3421 data
= stbi_bmp_load_from_file(f
, x
,y
,comp
,req_comp
);
3426 stbi_uc
*stbi_bmp_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
3430 return bmp_load(&s
, x
,y
,comp
,req_comp
);
3434 stbi_uc
*stbi_bmp_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
3437 start_mem(&s
, buffer
, len
);
3438 return bmp_load(&s
, x
,y
,comp
,req_comp
);
3441 // Targa Truevision - TGA
3442 // by Jonathan Dummer
3444 static int tga_info(stbi
*s
, int *x
, int *y
, int *comp
)
3446 int tga_w
, tga_h
, tga_comp
;
3448 get8u(s
); // discard Offset
3449 sz
= get8u(s
); // color type
3450 if( sz
> 1 ) return 0; // only RGB or indexed allowed
3451 sz
= get8u(s
); // image type
3452 // only RGB or grey allowed, +/- RLE
3453 if ((sz
!= 1) && (sz
!= 2) && (sz
!= 3) && (sz
!= 9) && (sz
!= 10) && (sz
!= 11)) return 0;
3454 get16le(s
); // discard palette start
3455 get16le(s
); // discard palette length
3456 get8(s
); // discard bits per palette color entry
3457 get16le(s
); // discard x origin
3458 get16le(s
); // discard y origin
3460 if( tga_w
< 1 ) return 0; // test width
3462 if( tga_h
< 1 ) return 0; // test height
3463 sz
= get8(s
); // bits per pixel
3464 // only RGB or RGBA or grey allowed
3465 if ((sz
!= 8) && (sz
!= 16) && (sz
!= 24) && (sz
!= 32)) return 0;
3469 if (comp
) *comp
= tga_comp
/ 8;
3470 return 1; // seems to have passed everything
3473 #ifndef STBI_NO_STDIO
3474 int stbi_tga_info_from_file(FILE *f
, int *x
, int *y
, int *comp
)
3480 r
= tga_info(&s
, x
, y
, comp
);
3481 fseek(f
, n
, SEEK_SET
);
3486 int stbi_tga_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
)
3489 start_mem(&s
, buffer
, len
);
3490 return tga_info(&s
, x
, y
, comp
);
3493 static int tga_test(stbi
*s
)
3496 get8u(s
); // discard Offset
3497 sz
= get8u(s
); // color type
3498 if ( sz
> 1 ) return 0; // only RGB or indexed allowed
3499 sz
= get8u(s
); // image type
3500 if ( (sz
!= 1) && (sz
!= 2) && (sz
!= 3) && (sz
!= 9) && (sz
!= 10) && (sz
!= 11) ) return 0; // only RGB or grey allowed, +/- RLE
3501 get16(s
); // discard palette start
3502 get16(s
); // discard palette length
3503 get8(s
); // discard bits per palette color entry
3504 get16(s
); // discard x origin
3505 get16(s
); // discard y origin
3506 if ( get16(s
) < 1 ) return 0; // test width
3507 if ( get16(s
) < 1 ) return 0; // test height
3508 sz
= get8(s
); // bits per pixel
3509 if ( (sz
!= 8) && (sz
!= 16) && (sz
!= 24) && (sz
!= 32) ) return 0; // only RGB or RGBA or grey allowed
3510 return 1; // seems to have passed everything
3513 #ifndef STBI_NO_STDIO
3514 int stbi_tga_test_file (FILE *f
)
3520 fseek(f
,n
,SEEK_SET
);
3525 int stbi_tga_test_memory (stbi_uc
const *buffer
, int len
)
3528 start_mem(&s
, buffer
, len
);
3529 return tga_test(&s
);
3532 static stbi_uc
*tga_load(stbi
*s
, int *x
, int *y
, int *comp
, int req_comp
)
3534 // read in the TGA header stuff
3535 int tga_offset
= get8u(s
);
3536 int tga_indexed
= get8u(s
);
3537 int tga_image_type
= get8u(s
);
3539 int tga_palette_start
= get16le(s
);
3540 int tga_palette_len
= get16le(s
);
3541 int tga_palette_bits
= get8u(s
);
3542 int tga_x_origin
= get16le(s
);
3543 int tga_y_origin
= get16le(s
);
3544 int tga_width
= get16le(s
);
3545 int tga_height
= get16le(s
);
3546 int tga_bits_per_pixel
= get8u(s
);
3547 int tga_inverted
= get8u(s
);
3549 unsigned char *tga_data
;
3550 unsigned char *tga_palette
= NULL
;
3552 unsigned char raw_data
[4];
3553 unsigned char trans_data
[4];
3555 int RLE_repeating
= 0;
3556 int read_next_pixel
= 1;
3558 // do a tiny bit of precessing
3559 if ( tga_image_type
>= 8 )
3561 tga_image_type
-= 8;
3564 /* int tga_alpha_bits = tga_inverted & 15; */
3565 tga_inverted
= 1 - ((tga_inverted
>> 5) & 1);
3568 if ( //(tga_indexed) ||
3569 (tga_width
< 1) || (tga_height
< 1) ||
3570 (tga_image_type
< 1) || (tga_image_type
> 3) ||
3571 ((tga_bits_per_pixel
!= 8) && (tga_bits_per_pixel
!= 16) &&
3572 (tga_bits_per_pixel
!= 24) && (tga_bits_per_pixel
!= 32))
3578 // If I'm paletted, then I'll use the number of bits from the palette
3581 tga_bits_per_pixel
= tga_palette_bits
;
3587 if ( (req_comp
< 1) || (req_comp
> 4) )
3589 // just use whatever the file was
3590 req_comp
= tga_bits_per_pixel
/ 8;
3594 // force a new number of components
3595 *comp
= tga_bits_per_pixel
/8;
3597 tga_data
= (unsigned char*)MALLOC( tga_width
* tga_height
* req_comp
);
3599 // skip to the data's starting position (offset usually = 0)
3600 skip(s
, tga_offset
);
3601 // do I need to load a palette?
3604 // any data to skip? (offset usually = 0)
3605 skip(s
, tga_palette_start
);
3607 tga_palette
= (unsigned char*)MALLOC( tga_palette_len
* tga_palette_bits
/ 8 );
3608 if (!getn(s
, tga_palette
, tga_palette_len
* tga_palette_bits
/ 8 ))
3612 trans_data
[0] = trans_data
[1] = trans_data
[2] = trans_data
[3] = 0;
3613 for (i
=0; i
< tga_width
* tga_height
; ++i
)
3615 // if I'm in RLE mode, do I need to get a RLE chunk?
3618 if ( RLE_count
== 0 )
3620 // yep, get the next byte as a RLE command
3621 int RLE_cmd
= get8u(s
);
3622 RLE_count
= 1 + (RLE_cmd
& 127);
3623 RLE_repeating
= RLE_cmd
>> 7;
3624 read_next_pixel
= 1;
3625 } else if ( !RLE_repeating
)
3627 read_next_pixel
= 1;
3631 read_next_pixel
= 1;
3633 // OK, if I need to read a pixel, do it now
3634 if ( read_next_pixel
)
3636 // load however much data we did have
3639 // read in 1 byte, then perform the lookup
3640 int pal_idx
= get8u(s
);
3641 if ( pal_idx
>= tga_palette_len
)
3646 pal_idx
*= tga_bits_per_pixel
/ 8;
3647 for (j
= 0; j
*8 < tga_bits_per_pixel
; ++j
)
3649 raw_data
[j
] = tga_palette
[pal_idx
+j
];
3653 // read in the data raw
3654 for (j
= 0; j
*8 < tga_bits_per_pixel
; ++j
)
3656 raw_data
[j
] = get8u(s
);
3659 // convert raw to the intermediate format
3660 switch (tga_bits_per_pixel
)
3664 trans_data
[0] = raw_data
[0];
3665 trans_data
[1] = raw_data
[0];
3666 trans_data
[2] = raw_data
[0];
3667 trans_data
[3] = 255;
3670 // Luminous,Alpha => RGBA
3671 trans_data
[0] = raw_data
[0];
3672 trans_data
[1] = raw_data
[0];
3673 trans_data
[2] = raw_data
[0];
3674 trans_data
[3] = raw_data
[1];
3678 trans_data
[0] = raw_data
[2];
3679 trans_data
[1] = raw_data
[1];
3680 trans_data
[2] = raw_data
[0];
3681 trans_data
[3] = 255;
3685 trans_data
[0] = raw_data
[2];
3686 trans_data
[1] = raw_data
[1];
3687 trans_data
[2] = raw_data
[0];
3688 trans_data
[3] = raw_data
[3];
3691 // clear the reading flag for the next pixel
3692 read_next_pixel
= 0;
3693 } // end of reading a pixel
3694 // convert to final format
3698 // RGBA => Luminance
3699 tga_data
[i
*req_comp
+0] = compute_y(trans_data
[0],trans_data
[1],trans_data
[2]);
3702 // RGBA => Luminance,Alpha
3703 tga_data
[i
*req_comp
+0] = compute_y(trans_data
[0],trans_data
[1],trans_data
[2]);
3704 tga_data
[i
*req_comp
+1] = trans_data
[3];
3708 tga_data
[i
*req_comp
+0] = trans_data
[0];
3709 tga_data
[i
*req_comp
+1] = trans_data
[1];
3710 tga_data
[i
*req_comp
+2] = trans_data
[2];
3714 tga_data
[i
*req_comp
+0] = trans_data
[0];
3715 tga_data
[i
*req_comp
+1] = trans_data
[1];
3716 tga_data
[i
*req_comp
+2] = trans_data
[2];
3717 tga_data
[i
*req_comp
+3] = trans_data
[3];
3720 // in case we're in RLE mode, keep counting down
3723 // do I need to invert the image?
3726 for (j
= 0; j
*2 < tga_height
; ++j
)
3728 int index1
= j
* tga_width
* req_comp
;
3729 int index2
= (tga_height
- 1 - j
) * tga_width
* req_comp
;
3730 for (i
= tga_width
* req_comp
; i
> 0; --i
)
3732 unsigned char temp
= tga_data
[index1
];
3733 tga_data
[index1
] = tga_data
[index2
];
3734 tga_data
[index2
] = temp
;
3740 // clear my palette, if I had one
3741 if ( tga_palette
!= NULL
)
3743 FREE( tga_palette
);
3745 // the things I do to get rid of an error message, and yet keep
3746 // Microsoft's C compilers happy... [8^(
3747 tga_palette_start
= tga_palette_len
= tga_palette_bits
=
3748 tga_x_origin
= tga_y_origin
= 0;
3753 #ifndef STBI_NO_STDIO
3754 stbi_uc
*stbi_tga_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
3757 FILE *f
= fopen(filename
, "rb");
3758 if (!f
) return NULL
;
3759 data
= stbi_tga_load_from_file(f
, x
,y
,comp
,req_comp
);
3764 stbi_uc
*stbi_tga_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
3768 return tga_load(&s
, x
,y
,comp
,req_comp
);
3772 stbi_uc
*stbi_tga_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
3775 start_mem(&s
, buffer
, len
);
3776 return tga_load(&s
, x
,y
,comp
,req_comp
);
3780 // *************************************************************************************************
3781 // Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
3783 static int psd_test(stbi
*s
)
3785 if (get32(s
) != 0x38425053) return 0; // "8BPS"
3789 #ifndef STBI_NO_STDIO
3790 int stbi_psd_test_file(FILE *f
)
3796 fseek(f
,n
,SEEK_SET
);
3801 int stbi_psd_test_memory(stbi_uc
const *buffer
, int len
)
3804 start_mem(&s
, buffer
, len
);
3805 return psd_test(&s
);
3808 static stbi_uc
*psd_load(stbi
*s
, int *x
, int *y
, int *comp
, int req_comp
)
3811 int channelCount
, compression
;
3812 int channel
, i
, count
, len
;
3817 if (get32(s
) != 0x38425053) // "8BPS"
3818 return epuc("not PSD", "Corrupt PSD image");
3820 // Check file type version.
3822 return epuc("wrong version", "Unsupported version of PSD image");
3824 // Skip 6 reserved bytes.
3827 // Read the number of channels (R, G, B, A, etc).
3828 channelCount
= get16(s
);
3829 if (channelCount
< 0 || channelCount
> 16)
3830 return epuc("wrong channel count", "Unsupported number of channels in PSD image");
3832 // Read the rows and columns of the image.
3836 // Make sure the depth is 8 bits.
3838 return epuc("unsupported bit depth", "PSD bit depth is not 8 bit");
3840 // Make sure the color mode is RGB.
3841 // Valid options are:
3851 return epuc("wrong color format", "PSD is not in RGB color format");
3853 // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
3856 // Skip the image resources. (resolution, pen tool paths, etc)
3859 // Skip the reserved data.
3862 // Find out if the data is compressed.
3864 // 0: no compression
3865 // 1: RLE compressed
3866 compression
= get16(s
);
3867 if (compression
> 1)
3868 return epuc("bad compression", "PSD has an unknown compression format");
3870 // Create the destination image.
3871 out
= (stbi_uc
*) MALLOC(4 * w
*h
);
3872 if (!out
) return epuc("outofmem", "Out of memory");
3875 // Initialize the data to zero.
3876 //memset( out, 0, pixelCount * 4 );
3878 // Finally, the image data.
3880 // RLE as used by .PSD and .TIFF
3881 // Loop until you get the number of unpacked bytes you are expecting:
3882 // Read the next source byte into n.
3883 // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
3884 // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
3885 // Else if n is 128, noop.
3888 // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
3889 // which we're going to just skip.
3890 skip(s
, h
* channelCount
* 2 );
3892 // Read the RLE data by channel.
3893 for (channel
= 0; channel
< 4; channel
++) {
3897 if (channel
>= channelCount
) {
3898 // Fill this channel with default data.
3899 for (i
= 0; i
< pixelCount
; i
++) *p
= (channel
== 3 ? 255 : 0), p
+= 4;
3901 // Read the RLE data.
3903 while (count
< pixelCount
) {
3907 } else if (len
< 128) {
3908 // Copy next len+1 bytes literally.
3916 } else if (len
> 128) {
3918 // Next -len+1 bytes in the dest are replicated from next source byte.
3919 // (Interpret len as a negative 8-bit int.)
3935 // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
3936 // where each channel consists of an 8-bit value for each pixel in the image.
3938 // Read the data by channel.
3939 for (channel
= 0; channel
< 4; channel
++) {
3943 if (channel
> channelCount
) {
3944 // Fill this channel with default data.
3945 for (i
= 0; i
< pixelCount
; i
++) *p
= channel
== 3 ? 255 : 0, p
+= 4;
3948 for (i
= 0; i
< pixelCount
; i
++)
3949 *p
= get8u(s
), p
+= 4;
3954 if (req_comp
&& req_comp
!= 4) {
3955 out
= convert_format(out
, 4, req_comp
, w
, h
);
3956 if (out
== NULL
) return out
; // convert_format frees input on failure
3959 if (comp
) *comp
= channelCount
;
3966 #ifndef STBI_NO_STDIO
3967 stbi_uc
*stbi_psd_load(char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
3970 FILE *f
= fopen(filename
, "rb");
3971 if (!f
) return NULL
;
3972 data
= stbi_psd_load_from_file(f
, x
,y
,comp
,req_comp
);
3977 stbi_uc
*stbi_psd_load_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
3981 return psd_load(&s
, x
,y
,comp
,req_comp
);
3985 stbi_uc
*stbi_psd_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
3988 start_mem(&s
, buffer
, len
);
3989 return psd_load(&s
, x
,y
,comp
,req_comp
);
3992 // *************************************************************************************************
3993 // Softimage PIC loader
3996 // See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
3997 // See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
3999 static int pic_is4(stbi
*s
,const char *str
)
4003 if (get8(s
) != (stbi_uc
)str
[i
])
4009 static int pic_test(stbi
*s
)
4013 if (!pic_is4(s
,"\x53\x80\xF6\x34"))
4019 if (!pic_is4(s
,"PICT"))
4027 stbi_uc size
,type
,channel
;
4030 static stbi_uc
*pic_readval(stbi
*s
, int channel
, stbi_uc
*dest
)
4034 for (i
=0; i
<4; ++i
, mask
>>=1) {
4035 if (channel
& mask
) {
4036 if (at_eof(s
)) return epuc("bad file","PIC file too short");
4044 static void pic_copyval(int channel
,stbi_uc
*dest
,const stbi_uc
*src
)
4048 for (i
=0;i
<4; ++i
, mask
>>=1)
4053 static stbi_uc
*pic_load2(stbi
*s
,int width
,int height
,int *comp
, stbi_uc
*result
)
4055 int act_comp
=0,num_packets
=0,y
,chained
;
4056 pic_packet_t packets
[10];
4058 // this will (should...) cater for even some bizarre stuff like having data
4059 // for the same channel in multiple packets.
4061 pic_packet_t
*packet
;
4063 if (num_packets
==sizeof(packets
)/sizeof(packets
[0]))
4064 return epuc("bad format","too many packets");
4066 packet
= &packets
[num_packets
++];
4069 packet
->size
= get8u(s
);
4070 packet
->type
= get8u(s
);
4071 packet
->channel
= get8u(s
);
4073 act_comp
|= packet
->channel
;
4075 if (at_eof(s
)) return epuc("bad file","file too short (reading packets)");
4076 if (packet
->size
!= 8) return epuc("bad format","packet isn't 8bpp");
4079 *comp
= (act_comp
& 0x10 ? 4 : 3); // has alpha channel?
4081 for(y
=0; y
<height
; ++y
) {
4084 for(packet_idx
=0; packet_idx
< num_packets
; ++packet_idx
) {
4085 pic_packet_t
*packet
= &packets
[packet_idx
];
4086 stbi_uc
*dest
= result
+y
*width
*4;
4088 switch (packet
->type
) {
4090 return epuc("bad format","packet has bad compression type");
4092 case 0: {//uncompressed
4095 for(x
=0;x
<width
;++x
, dest
+=4)
4096 if (!pic_readval(s
,packet
->channel
,dest
))
4106 stbi_uc count
,value
[4];
4109 if (at_eof(s
)) return epuc("bad file","file too short (pure read count)");
4112 count
= (uint8
) left
;
4114 if (!pic_readval(s
,packet
->channel
,value
)) return 0;
4116 for(i
=0; i
<count
; ++i
,dest
+=4)
4117 pic_copyval(packet
->channel
,dest
,value
);
4123 case 2: {//Mixed RLE
4126 int count
= get8(s
), i
;
4127 if (at_eof(s
)) return epuc("bad file","file too short (mixed read count)");
4129 if (count
>= 128) { // Repeated
4137 return epuc("bad file","scanline overrun");
4139 if (!pic_readval(s
,packet
->channel
,value
))
4142 for(i
=0;i
<count
;++i
, dest
+= 4)
4143 pic_copyval(packet
->channel
,dest
,value
);
4146 if (count
>left
) return epuc("bad file","scanline overrun");
4148 for(i
=0;i
<count
;++i
, dest
+=4)
4149 if (!pic_readval(s
,packet
->channel
,dest
))
4163 static stbi_uc
*pic_load(stbi
*s
,int *px
,int *py
,int *comp
,int req_comp
)
4168 for (i
=0; i
<92; ++i
)
4173 if (at_eof(s
)) return epuc("bad file","file too short (pic header)");
4174 if ((1 << 28) / x
< y
) return epuc("too large", "Image too large to decode");
4176 get32(s
); //skip `ratio'
4177 get16(s
); //skip `fields'
4178 get16(s
); //skip `pad'
4180 // intermediate buffer is RGBA
4181 result
= (stbi_uc
*) MALLOC(x
*y
*4);
4182 memset(result
, 0xff, x
*y
*4);
4184 if (!pic_load2(s
,x
,y
,comp
, result
)) {
4190 if (req_comp
== 0) req_comp
= *comp
;
4191 result
=convert_format(result
,4,req_comp
,x
,y
);
4196 int stbi_pic_test_memory(stbi_uc
const *buffer
, int len
)
4199 start_mem(&s
,buffer
,len
);
4200 return pic_test(&s
);
4203 stbi_uc
*stbi_pic_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
4206 start_mem(&s
,buffer
,len
);
4207 return pic_load(&s
,x
,y
,comp
,req_comp
);
4210 #ifndef STBI_NO_STDIO
4211 int stbi_pic_test_file(FILE *f
)
4217 result
= pic_test(&s
);
4218 fseek(f
,l
,SEEK_SET
);
4222 stbi_uc
*stbi_pic_load(char const *filename
,int *x
, int *y
, int *comp
, int req_comp
)
4225 FILE *f
=fopen(filename
,"rb");
4227 result
= stbi_pic_load_from_file(f
,x
,y
,comp
,req_comp
);
4232 stbi_uc
*stbi_pic_load_from_file(FILE *f
,int *x
, int *y
, int *comp
, int req_comp
)
4236 return pic_load(&s
,x
,y
,comp
,req_comp
);
4240 // *************************************************************************************************
4241 // GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
4242 typedef struct stbi_gif_lzw_struct
{
4248 typedef struct stbi_gif_struct
4251 stbi_uc
*out
; // output buffer (always 4 components)
4252 int flags
, bgindex
, ratio
, transparent
, eflags
;
4255 stbi_gif_lzw codes
[4096];
4259 int start_x
, start_y
;
4265 static int gif_test(stbi
*s
)
4268 if (get8(s
) != 'G' || get8(s
) != 'I' || get8(s
) != 'F' || get8(s
) != '8') return 0;
4270 if (sz
!= '9' && sz
!= '7') return 0;
4271 if (get8(s
) != 'a') return 0;
4275 #ifndef STBI_NO_STDIO
4276 int stbi_gif_test_file (FILE *f
)
4282 fseek(f
,n
,SEEK_SET
);
4287 int stbi_gif_test_memory (stbi_uc
const *buffer
, int len
)
4290 start_mem(&s
, buffer
, len
);
4291 return gif_test(&s
);
4294 static void stbi_gif_parse_colortable(stbi
*s
, uint8 pal
[256][4], int num_entries
, int transp
)
4297 for (i
=0; i
< num_entries
; ++i
) {
4298 pal
[i
][2] = get8u(s
);
4299 pal
[i
][1] = get8u(s
);
4300 pal
[i
][0] = get8u(s
);
4301 pal
[i
][3] = transp
? 0 : 255;
4305 static int stbi_gif_header(stbi
*s
, stbi_gif
*g
, int *comp
, int is_info
)
4308 if (get8(s
) != 'G' || get8(s
) != 'I' || get8(s
) != 'F' || get8(s
) != '8')
4309 return e("not GIF", "Corrupt GIF");
4312 if (ver
!= '7' && ver
!= '9') return e("not GIF", "Corrupt GIF");
4313 if (get8(s
) != 'a') return e("not GIF", "Corrupt GIF");
4315 failure_reason
= "";
4319 g
->bgindex
= get8(s
);
4321 g
->transparent
= -1;
4323 if (comp
!= 0) *comp
= 4; // can't actually tell whether it's 3 or 4 until we parse the comments
4325 if (is_info
) return 1;
4327 if (g
->flags
& 0x80)
4328 stbi_gif_parse_colortable(s
,g
->pal
, 2 << (g
->flags
& 7), -1);
4333 static int stbi_gif_info_raw(stbi
*s
, int *x
, int *y
, int *comp
)
4336 if (!stbi_gif_header(s
, &g
, comp
, 1)) return 0;
4342 static void stbi_out_gif_code(stbi_gif
*g
, uint16 code
)
4346 // recurse to decode the prefixes, since the linked-list is backwards,
4347 // and working backwards through an interleaved image would be nasty
4348 if (g
->codes
[code
].prefix
>= 0)
4349 stbi_out_gif_code(g
, g
->codes
[code
].prefix
);
4351 if (g
->cur_y
>= g
->max_y
) return;
4353 p
= &g
->out
[g
->cur_x
+ g
->cur_y
];
4354 c
= &g
->color_table
[g
->codes
[code
].suffix
* 4];
4364 if (g
->cur_x
>= g
->max_x
) {
4365 g
->cur_x
= g
->start_x
;
4366 g
->cur_y
+= g
->step
;
4368 while (g
->cur_y
>= g
->max_y
&& g
->parse
> 0) {
4369 g
->step
= (1 << g
->parse
) * g
->line_size
;
4370 g
->cur_y
= g
->start_y
+ (g
->step
>> 1);
4376 static uint8
*stbi_process_gif_raster(stbi
*s
, stbi_gif
*g
)
4381 int32 codesize
, codemask
, avail
, oldcode
, bits
, valid_bits
, clear
;
4385 clear
= 1 << lzw_cs
;
4387 codesize
= lzw_cs
+ 1;
4388 codemask
= (1 << codesize
) - 1;
4391 for (code
= 0; code
< clear
; code
++) {
4392 g
->codes
[code
].prefix
= -1;
4393 g
->codes
[code
].first
= (uint8
) code
;
4394 g
->codes
[code
].suffix
= (uint8
) code
;
4397 // support no starting clear code
4403 if (valid_bits
< codesize
) {
4405 len
= get8(s
); // start new block
4410 bits
|= (int32
) get8(s
) << valid_bits
;
4413 code
= bits
& codemask
;
4415 valid_bits
-= codesize
;
4416 // @OPTIMIZE: is there some way we can accelerate the non-clear path?
4417 if (code
== clear
) { // clear code
4418 codesize
= lzw_cs
+ 1;
4419 codemask
= (1 << codesize
) - 1;
4423 } else if (code
== clear
+ 1) { // end of stream code
4425 while ((len
= get8(s
)) > 0)
4428 } else if (code
<= avail
) {
4429 if (first
) return epuc("no clear code", "Corrupt GIF");
4432 p
= &g
->codes
[avail
++];
4433 if (avail
> 4096) return epuc("too many codes", "Corrupt GIF");
4434 p
->prefix
= (int16
) oldcode
;
4435 p
->first
= g
->codes
[oldcode
].first
;
4436 p
->suffix
= (code
== avail
) ? p
->first
: g
->codes
[code
].first
;
4437 } else if (code
== avail
)
4438 return epuc("illegal code in raster", "Corrupt GIF");
4440 stbi_out_gif_code(g
, (uint16
) code
);
4442 if ((avail
& codemask
) == 0 && avail
<= 0x0FFF) {
4444 codemask
= (1 << codesize
) - 1;
4449 return epuc("illegal code in raster", "Corrupt GIF");
4455 static void stbi_fill_gif_background(stbi_gif
*g
)
4458 uint8
*c
= g
->pal
[g
->bgindex
];
4459 // @OPTIMIZE: write a dword at a time
4460 for (i
= 0; i
< g
->w
* g
->h
* 4; i
+= 4) {
4461 uint8
*p
= &g
->out
[i
];
4469 // this function is designed to support animated gifs, although stb_image doesn't support it
4470 static uint8
*stbi_gif_load_next(stbi
*s
, stbi_gif
*g
, int *comp
, int req_comp
)
4476 if (!stbi_gif_header(s
, g
, comp
,0)) return 0; // failure_reason set by stbi_gif_header
4477 g
->out
= (uint8
*) MALLOC(4 * g
->w
* g
->h
);
4478 if (g
->out
== 0) return epuc("outofmem", "Out of memory");
4479 stbi_fill_gif_background(g
);
4481 // animated-gif-only path
4482 if (((g
->eflags
& 0x1C) >> 2) == 3) {
4484 g
->out
= (uint8
*) MALLOC(4 * g
->w
* g
->h
);
4485 if (g
->out
== 0) return epuc("outofmem", "Out of memory");
4486 memcpy(g
->out
, old_out
, g
->w
*g
->h
*4);
4492 case 0x2C: /* Image Descriptor */
4501 if (((x
+ w
) > (g
->w
)) || ((y
+ h
) > (g
->h
)))
4502 return epuc("bad Image Descriptor", "Corrupt GIF");
4504 g
->line_size
= g
->w
* 4;
4506 g
->start_y
= y
* g
->line_size
;
4507 g
->max_x
= g
->start_x
+ w
* 4;
4508 g
->max_y
= g
->start_y
+ h
* g
->line_size
;
4509 g
->cur_x
= g
->start_x
;
4510 g
->cur_y
= g
->start_y
;
4512 g
->lflags
= get8(s
);
4514 if (g
->lflags
& 0x40) {
4515 g
->step
= 8 * g
->line_size
; // first interlaced spacing
4518 g
->step
= g
->line_size
;
4522 if (g
->lflags
& 0x80) {
4523 stbi_gif_parse_colortable(s
,g
->lpal
, 2 << (g
->lflags
& 7), g
->eflags
& 0x01 ? g
->transparent
: -1);
4524 g
->color_table
= (uint8
*) g
->lpal
;
4525 } else if (g
->flags
& 0x80) {
4526 for (i
=0; i
< 256; ++i
) // @OPTIMIZE: reset only the previous transparent
4528 if (g
->transparent
>= 0 && (g
->eflags
& 0x01))
4529 g
->pal
[g
->transparent
][3] = 0;
4530 g
->color_table
= (uint8
*) g
->pal
;
4532 return epuc("missing color table", "Corrupt GIF");
4534 o
= stbi_process_gif_raster(s
, g
);
4535 if (o
== NULL
) return NULL
;
4537 if (req_comp
&& req_comp
!= 4)
4538 o
= convert_format(o
, 4, req_comp
, g
->w
, g
->h
);
4542 case 0x21: // Comment Extension.
4545 if (get8(s
) == 0xF9) { // Graphic Control Extension.
4548 g
->eflags
= get8(s
);
4549 get16le(s
); // delay
4550 g
->transparent
= get8(s
);
4556 while ((len
= get8(s
)) != 0)
4561 case 0x3B: // gif stream termination code
4565 return epuc("unknown code", "Corrupt GIF");
4570 #ifndef STBI_NO_STDIO
4571 stbi_uc
*stbi_gif_load (char const *filename
, int *x
, int *y
, int *comp
, int req_comp
)
4574 FILE *f
= fopen(filename
, "rb");
4575 if (!f
) return NULL
;
4576 data
= stbi_gif_load_from_file(f
, x
,y
,comp
,req_comp
);
4581 stbi_uc
*stbi_gif_load_from_file (FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
4588 u
= stbi_gif_load_next(&s
, &g
, comp
, req_comp
);
4589 if (u
== (void *) 1) u
= 0; // end of animated gif marker
4599 stbi_uc
*stbi_gif_load_from_memory (stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
4605 #ifdef STBI_SMALL_STACK
4606 pg
= (stbi_gif
*) MALLOC(sizeof(*pg
));
4614 memset(pg
, 0, sizeof(*pg
));
4615 start_mem(&s
, buffer
, len
);
4616 u
= stbi_gif_load_next(&s
, pg
, comp
, req_comp
);
4617 if (u
== (void *) 1) u
= 0; // end of animated gif marker
4623 #ifdef STBI_SMALL_STACK
4630 #ifndef STBI_NO_STDIO
4631 int stbi_gif_info (char const *filename
, int *x
, int *y
, int *comp
)
4634 FILE *f
= fopen(filename
, "rb");
4636 res
= stbi_gif_info_from_file(f
, x
, y
, comp
);
4641 int stbi_gif_info_from_file(FILE *f
, int *x
, int *y
, int *comp
)
4647 res
= stbi_gif_info_raw(&s
, x
, y
, comp
);
4648 fseek(f
, n
, SEEK_SET
);
4651 #endif // !STBI_NO_STDIO
4653 int stbi_gif_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
)
4656 start_mem(&s
, buffer
, len
);
4657 return stbi_gif_info_raw(&s
, x
, y
, comp
);
4663 // *************************************************************************************************
4664 // Radiance RGBE HDR loader
4665 // originally by Nicolas Schulz
4667 static int hdr_test(stbi
*s
)
4669 const char *signature
= "#?RADIANCE\n";
4671 for (i
=0; signature
[i
]; ++i
)
4672 if (get8(s
) != signature
[i
])
4677 int stbi_hdr_test_memory(stbi_uc
const *buffer
, int len
)
4680 start_mem(&s
, buffer
, len
);
4681 return hdr_test(&s
);
4684 #ifndef STBI_NO_STDIO
4685 int stbi_hdr_test_file(FILE *f
)
4691 fseek(f
,n
,SEEK_SET
);
4696 #define HDR_BUFLEN 1024
4697 static char *hdr_gettoken(stbi
*z
, char *buffer
)
4704 while (!at_eof(z
) && c
!= '\n') {
4706 if (len
== HDR_BUFLEN
-1) {
4707 // flush to end of line
4708 while (!at_eof(z
) && get8(z
) != '\n')
4719 static void hdr_convert(float *output
, stbi_uc
*input
, int req_comp
)
4721 if ( input
[3] != 0 ) {
4724 f1
= (float) ldexp(1.0f
, input
[3] - (int)(128 + 8));
4726 output
[0] = (input
[0] + input
[1] + input
[2]) * f1
/ 3;
4728 output
[0] = input
[0] * f1
;
4729 output
[1] = input
[1] * f1
;
4730 output
[2] = input
[2] * f1
;
4732 if (req_comp
== 2) output
[1] = 1;
4733 if (req_comp
== 4) output
[3] = 1;
4736 case 4: output
[3] = 1; /* fallthrough */
4737 case 3: output
[0] = output
[1] = output
[2] = 0;
4739 case 2: output
[1] = 1; /* fallthrough */
4740 case 1: output
[0] = 0;
4747 static float *hdr_load(stbi
*s
, int *x
, int *y
, int *comp
, int req_comp
)
4749 char buffer
[HDR_BUFLEN
];
4756 unsigned char count
, value
;
4757 int i
, j
, k
, c1
,c2
, z
;
4761 if (strcmp(hdr_gettoken(s
,buffer
), "#?RADIANCE") != 0)
4762 return epf("not HDR", "Corrupt HDR image");
4766 token
= hdr_gettoken(s
,buffer
);
4767 if (token
[0] == 0) break;
4768 if (strcmp(token
, "FORMAT=32-bit_rle_rgbe") == 0) valid
= 1;
4771 if (!valid
) return epf("unsupported format", "Unsupported HDR format");
4773 // Parse width and height
4774 // can't use sscanf() if we're not using stdio!
4775 token
= hdr_gettoken(s
,buffer
);
4776 if (strncmp(token
, "-Y ", 3)) return epf("unsupported data layout", "Unsupported HDR format");
4778 height
= strtol(token
, &token
, 10);
4779 while (*token
== ' ') ++token
;
4780 if (strncmp(token
, "+X ", 3)) return epf("unsupported data layout", "Unsupported HDR format");
4782 width
= strtol(token
, NULL
, 10);
4788 if (req_comp
== 0) req_comp
= 3;
4791 hdr_data
= (float *) MALLOC(height
* width
* req_comp
* sizeof(float));
4794 // image data is stored as some number of sca
4795 if ( width
< 8 || width
>= 32768) {
4797 for (j
=0; j
< height
; ++j
) {
4798 for (i
=0; i
< width
; ++i
) {
4802 hdr_convert(hdr_data
+ j
* width
* req_comp
+ i
* req_comp
, rgbe
, req_comp
);
4806 // Read RLE-encoded data
4809 for (j
= 0; j
< height
; ++j
) {
4813 if (c1
!= 2 || c2
!= 2 || (len
& 0x80)) {
4814 // not run-length encoded, so we have to actually use THIS data as a decoded
4815 // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
4817 rgbe
[0] = (uint8
) c1
;
4818 rgbe
[1] = (uint8
) c2
;
4819 rgbe
[2] = (uint8
) len
;
4820 rgbe
[3] = (uint8
) get8u(s
);
4821 hdr_convert(hdr_data
, rgbe
, req_comp
);
4825 goto main_decode_loop
; // yes, this makes no sense
4829 if (len
!= width
) { FREE(hdr_data
); FREE(scanline
); return epf("invalid decoded scanline length", "corrupt HDR"); }
4830 if (scanline
== NULL
) scanline
= (stbi_uc
*) MALLOC(width
* 4);
4832 for (k
= 0; k
< 4; ++k
) {
4840 for (z
= 0; z
< count
; ++z
)
4841 scanline
[i
++ * 4 + k
] = value
;
4844 for (z
= 0; z
< count
; ++z
)
4845 scanline
[i
++ * 4 + k
] = get8u(s
);
4849 for (i
=0; i
< width
; ++i
)
4850 hdr_convert(hdr_data
+(j
*width
+ i
)*req_comp
, scanline
+ i
*4, req_comp
);
4858 #ifndef STBI_NO_STDIO
4859 float *stbi_hdr_load_from_file(FILE *f
, int *x
, int *y
, int *comp
, int req_comp
)
4863 return hdr_load(&s
,x
,y
,comp
,req_comp
);
4867 float *stbi_hdr_load_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
, int req_comp
)
4870 start_mem(&s
,buffer
, len
);
4871 return hdr_load(&s
,x
,y
,comp
,req_comp
);
4874 #endif // STBI_NO_HDR
4877 #ifndef STBI_NO_STDIO
4878 int stbi_info(char const *filename
, int *x
, int *y
, int *comp
)
4880 FILE *f
= fopen(filename
, "rb");
4882 if (!f
) return e("can't fopen", "Unable to open file");
4883 result
= stbi_info_from_file(f
, x
, y
, comp
);
4888 int stbi_info_from_file(FILE *f
, int *x
, int *y
, int *comp
)
4890 if (stbi_jpeg_info_from_file(f
, x
, y
, comp
))
4892 if (stbi_png_info_from_file(f
, x
, y
, comp
))
4894 if (stbi_gif_info_from_file(f
, x
, y
, comp
))
4896 // @TODO: stbi_bmp_info_from_file
4897 // @TODO: stbi_psd_info_from_file
4899 // @TODO: stbi_hdr_info_from_file
4901 // test tga last because it's a crappy test!
4902 if (stbi_tga_info_from_file(f
, x
, y
, comp
))
4904 return e("unknown image type", "Image not of any known type, or corrupt");
4906 #endif // !STBI_NO_STDIO
4908 int stbi_info_from_memory(stbi_uc
const *buffer
, int len
, int *x
, int *y
, int *comp
)
4910 if (stbi_jpeg_info_from_memory(buffer
, len
, x
, y
, comp
))
4912 if (stbi_png_info_from_memory(buffer
, len
, x
, y
, comp
))
4914 if (stbi_gif_info_from_memory(buffer
, len
, x
, y
, comp
))
4916 // @TODO: stbi_bmp_info_from_memory
4917 // @TODO: stbi_psd_info_from_memory
4919 // @TODO: stbi_hdr_info_from_memory
4921 // test tga last because it's a crappy test!
4922 if (stbi_tga_info_from_memory(buffer
, len
, x
, y
, comp
))
4924 return e("unknown image type", "Image not of any known type, or corrupt");
4927 #endif // STBI_HEADER_FILE_ONLY
4931 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville
4932 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
4934 cast-to-uint8 to fix warnings
4936 fix bug in file buffering for PNG reported by SpartanJ
4938 refix trans_data warning (Won Chun)
4940 perf improvements reading from files on platforms with lock-heavy fgetc()
4941 minor perf improvements for jpeg
4942 deprecated type-specific functions so we'll get feedback if they're needed
4943 attempt to fix trans_data warning (Won Chun)
4944 1.23 fixed bug in iPhone support
4946 removed image *writing* support
4947 removed image *writing* support
4948 stbi_info support from Jetro Lauha
4949 GIF support from Jean-Marc Lienher
4950 iPhone PNG-extensions from James Brown
4951 warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva)
4952 1.21 fix use of 'uint8' in header (reported by jon blow)
4953 1.20 added support for Softimage PIC, by Tom Seddon
4954 1.19 bug in interlaced PNG corruption check (found by ryg)
4956 fix a threading bug (local mutable static)
4957 1.17 support interlaced PNG
4958 1.16 major bugfix - convert_format converted one too many pixels
4959 1.15 initialize some fields for thread safety
4960 1.14 fix threadsafe conversion bug
4961 header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
4963 1.12 const qualifiers in the API
4964 1.11 Support installable IDCT, colorspace conversion routines
4965 1.10 Fixes for 64-bit (don't use "unsigned long")
4966 optimized upsampling by Fabian "ryg" Giesen
4967 1.09 Fix format-conversion for PSD code (bad global variables!)
4968 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
4969 1.07 attempt to fix C++ warning/errors again
4970 1.06 attempt to fix C++ warning/errors again
4971 1.05 fix TGA loading to return correct *comp and use good luminance calc
4972 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
4973 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
4974 1.02 support for (subset of) HDR files, float interface for preferred access to them
4975 1.01 fix bug: possible bug in handling right-side up bmps... not sure
4976 fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
4977 1.00 interface to zlib that skips zlib header
4978 0.99 correct handling of alpha in palette
4979 0.98 TGA loader by lonesock; dynamically add loaders (untested)
4980 0.97 jpeg errors on too large a file; also catch another malloc failure
4981 0.96 fix detection of invalid v value - particleman@mollyrocket forum
4982 0.95 during header scan, seek to markers in case of padding
4983 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
4984 0.93 handle jpegtran output; verbose errors
4985 0.92 read 4,8,16,24,32-bit BMP files of several formats
4986 0.91 output 24-bit Windows 3.0 BMP files
4987 0.90 fix a few more warnings; bump version number to approach 1.0
4988 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
4989 0.60 fix compiling as c++
4990 0.59 fix warnings: merge Dave Moore's -Wall fixes
4991 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
4992 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less
4994 0.56 fix bug: zlib uncompressed mode len vs. nlen
4995 0.55 fix bug: restart_interval not initialized to 0
4996 0.54 allow NULL for 'int *comp'
4997 0.53 fix bug in png 3->4; speedup png decoding
4998 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
4999 0.51 obey req_comp requests, 1-component jpegs return as 1-component,
5000 on 'test' only check type, not whether we support this variant