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