AtlatestRepositorysigil-image
sigil-image / tree / vendor / stbstb_image.h
1
/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb2
no warranty implied; use at your own risk4
Do this:5
#define STB_IMAGE_IMPLEMENTATION6
before you include this file in *one* C or C++ file to create the implementation.8
// i.e. it should look like this:9
#include ...10
#include ...11
#include ...12
#define STB_IMAGE_IMPLEMENTATION13
#include "stb_image.h"15
You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.16
And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free19
QUICK NOTES:20
Primarily of interest to game developers and other people who can21
avoid problematic images and only need the trivial interface23
JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)24
PNG 1/2/4/8/16-bit-per-channel26
TGA (not sure what subset, if a subset)27
BMP non-1bpp, non-RLE28
PSD (composited view only, no extra channels, 8/16 bit-per-channel)30
GIF (*comp always reports as 4-channel)31
HDR (radiance rgbE format)32
PIC (Softimage PIC)33
PNM (PPM and PGM binary only)35
Animated GIF still needs a proper API, but here's one way to do it:36
http://gist.github.com/urraka/685d9a6340b26b830d4938
- decode from memory or through FILE (define STBI_NO_STDIO to remove code)39
- decode from arbitrary I/O callbacks40
- SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)42
Full documentation under "DOCUMENTATION" below.45
LICENSE47
See end of file for license information.49
RECENT REVISION HISTORY:51
2.30 (2024-05-31) avoid erroneous gcc warning52
2.29 (2023-05-xx) optimizations53
2.28 (2023-01-29) many error fixes, security errors, just tons of stuff54
2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes55
2.26 (2020-07-13) many minor fixes56
2.25 (2020-02-02) fix warnings57
2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically58
2.23 (2019-08-11) fix clang static analysis warning59
2.22 (2019-03-04) gif fixes, fix warnings60
2.21 (2019-02-25) fix typo in comment61
2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs62
2.19 (2018-02-11) fix warning63
2.18 (2018-01-30) fix warnings64
2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings65
2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes66
2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC67
2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs68
2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes69
2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes70
2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x6471
RGB-format JPEG; remove white matting in PSD;72
allocate large structures on the stack;73
correct channel count for PNG & BMP74
2.10 (2016-01-22) avoid warning introduced in 2.0975
2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED77
See end of file for full revision history.80
============================ Contributors =========================82
Image formats Extensions, features83
Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info)84
Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info)85
Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG)86
Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks)87
Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG)88
Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)89
Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)90
github:urraka (animated gif) Junggon Kim (PNM comments)91
Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)92
socks-the-fox (16-bit PNG)93
Jeremy Sawicki (handle all ImageNet JPGs)94
Optimizations & bugfixes Mikhail Morozov (1-bit BMP)95
Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query)96
Arseny Kapoulkine Simon Breuss (16-bit PNM)97
John-Mark Allen98
Carmelo J Fdez-Aguera100
Bug & warning fixes101
Marc LeBlanc David Woo Guillaume George Martins Mozeiko102
Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski103
Phil Jordan Dave Moore Roy Eltham104
Hayaki Saito Nathan Reed Won Chun105
Luke Graham Johan Duparc Nick Verigakis the Horde3D community106
Thomas Ruf Ronny Chevalier github:rlyeh107
Janez Zemva John Bartholomew Michal Cichon github:romigrou108
Jonathan Blow Ken Hamada Tero Hanninen github:svdijk109
Eugene Golushkov Laurent Gomila Cort Stratton github:snagar110
Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex111
Cass Everitt Ryamond Barbiero github:grim210112
Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw113
Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus114
Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo115
Julian Raschke Gregory Mullen Christian Floisand github:darealshinji116
Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007117
Brad Weinberger Matvey Cherevko github:mosra118
Luca Sas Alexander Veselov Zack Middleton [reserved]119
Ryan C. Gordon [reserved] [reserved]120
DO NOT ADD YOUR NAME HERE122
Jacko Dirks124
To add your name to the credits, pick a random blank space in the middle and fill it.125
80% of merge conflicts on stb PRs are due to people adding their name at the end126
of the credits.127
*/129
#ifndef STBI_INCLUDE_STB_IMAGE_H130
#define STBI_INCLUDE_STB_IMAGE_H132
// DOCUMENTATION133
//134
// Limitations:135
// - no 12-bit-per-channel JPEG136
// - no JPEGs with arithmetic coding137
// - GIF always returns *comp=4138
//139
// Basic usage (see HDR discussion below for HDR usage):140
// int x,y,n;141
// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);142
// // ... process data if not NULL ...143
// // ... x = width, y = height, n = # 8-bit components per pixel ...144
// // ... replace '0' with '1'..'4' to force that many components per pixel145
// // ... but 'n' will always be the number that it would have been if you said 0146
// stbi_image_free(data);147
//148
// Standard parameters:149
// int *x -- outputs image width in pixels150
// int *y -- outputs image height in pixels151
// int *channels_in_file -- outputs # of image components in image file152
// int desired_channels -- if non-zero, # of image components requested in result153
//154
// The return value from an image loader is an 'unsigned char *' which points155
// to the pixel data, or NULL on an allocation failure or if the image is156
// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,157
// with each pixel consisting of N interleaved 8-bit components; the first158
// pixel pointed to is top-left-most in the image. There is no padding between159
// image scanlines or between pixels, regardless of format. The number of160
// components N is 'desired_channels' if desired_channels is non-zero, or161
// *channels_in_file otherwise. If desired_channels is non-zero,162
// *channels_in_file has the number of components that _would_ have been163
// output otherwise. E.g. if you set desired_channels to 4, you will always164
// get RGBA output, but you can check *channels_in_file to see if it's trivially165
// opaque because e.g. there were only 3 channels in the source image.166
//167
// An output image with N components has the following components interleaved168
// in this order in each pixel:169
//170
// N=#comp components171
// 1 grey172
// 2 grey, alpha173
// 3 red, green, blue174
// 4 red, green, blue, alpha175
//176
// If image loading fails for any reason, the return value will be NULL,177
// and *x, *y, *channels_in_file will be unchanged. The function178
// stbi_failure_reason() can be queried for an extremely brief, end-user179
// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS180
// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly181
// more user-friendly ones.182
//183
// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.184
//185
// To query the width, height and component count of an image without having to186
// decode the full file, you can use the stbi_info family of functions:187
//188
// int x,y,n,ok;189
// ok = stbi_info(filename, &x, &y, &n);190
// // returns ok=1 and sets x, y, n if image is a supported format,191
// // 0 otherwise.192
//193
// Note that stb_image pervasively uses ints in its public API for sizes,194
// including sizes of memory buffers. This is now part of the API and thus195
// hard to change without causing breakage. As a result, the various image196
// loaders all have certain limits on image size; these differ somewhat197
// by format but generally boil down to either just under 2GB or just under198
// 1GB. When the decoded image would be larger than this, stb_image decoding199
// will fail.200
//201
// Additionally, stb_image will reject image files that have any of their202
// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,203
// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,204
// the only way to have an image with such dimensions load correctly205
// is for it to have a rather extreme aspect ratio. Either way, the206
// assumption here is that such larger images are likely to be malformed207
// or malicious. If you do need to load an image with individual dimensions208
// larger than that, and it still fits in the overall size limit, you can209
// #define STBI_MAX_DIMENSIONS on your own to be something larger.210
//211
// ===========================================================================212
//213
// UNICODE:214
//215
// If compiling for Windows and you wish to use Unicode filenames, compile216
// with217
// #define STBI_WINDOWS_UTF8218
// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert219
// Windows wchar_t filenames to utf8.220
//221
// ===========================================================================222
//223
// Philosophy224
//225
// stb libraries are designed with the following priorities:226
//227
// 1. easy to use228
// 2. easy to maintain229
// 3. good performance230
//231
// Sometimes I let "good performance" creep up in priority over "easy to maintain",232
// and for best performance I may provide less-easy-to-use APIs that give higher233
// performance, in addition to the easy-to-use ones. Nevertheless, it's important234
// to keep in mind that from the standpoint of you, a client of this library,235
// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.236
//237
// Some secondary priorities arise directly from the first two, some of which238
// provide more explicit reasons why performance can't be emphasized.239
//240
// - Portable ("ease of use")241
// - Small source code footprint ("easy to maintain")242
// - No dependencies ("ease of use")243
//244
// ===========================================================================245
//246
// I/O callbacks247
//248
// I/O callbacks allow you to read from arbitrary sources, like packaged249
// files or some other source. Data read from callbacks are processed250
// through a small internal buffer (currently 128 bytes) to try to reduce251
// overhead.252
//253
// The three functions you must define are "read" (reads some bytes of data),254
// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).255
//256
// ===========================================================================257
//258
// SIMD support259
//260
// The JPEG decoder will try to automatically use SIMD kernels on x86 when261
// supported by the compiler. For ARM Neon support, you must explicitly262
// request it.263
//264
// (The old do-it-yourself SIMD API is no longer supported in the current265
// code.)266
//267
// On x86, SSE2 will automatically be used when available based on a run-time268
// test; if not, the generic C versions are used as a fall-back. On ARM targets,269
// the typical path is to have separate builds for NEON and non-NEON devices270
// (at least this is true for iOS and Android). Therefore, the NEON support is271
// toggled by a build flag: define STBI_NEON to get NEON loops.272
//273
// If for some reason you do not want to use any of SIMD code, or if274
// you have issues compiling it, you can disable it entirely by275
// defining STBI_NO_SIMD.276
//277
// ===========================================================================278
//279
// HDR image support (disable by defining STBI_NO_HDR)280
//281
// stb_image supports loading HDR images in general, and currently the Radiance282
// .HDR file format specifically. You can still load any file through the existing283
// interface; if you attempt to load an HDR file, it will be automatically remapped284
// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;285
// both of these constants can be reconfigured through this interface:286
//287
// stbi_hdr_to_ldr_gamma(2.2f);288
// stbi_hdr_to_ldr_scale(1.0f);289
//290
// (note, do not use _inverse_ constants; stbi_image will invert them291
// appropriately).292
//293
// Additionally, there is a new, parallel interface for loading files as294
// (linear) floats to preserve the full dynamic range:295
//296
// float *data = stbi_loadf(filename, &x, &y, &n, 0);297
//298
// If you load LDR images through this interface, those images will299
// be promoted to floating point values, run through the inverse of300
// constants corresponding to the above:301
//302
// stbi_ldr_to_hdr_scale(1.0f);303
// stbi_ldr_to_hdr_gamma(2.2f);304
//305
// Finally, given a filename (or an open file or memory block--see header306
// file for details) containing image data, you can query for the "most307
// appropriate" interface to use (that is, whether the image is HDR or308
// not), using:309
//310
// stbi_is_hdr(char *filename);311
//312
// ===========================================================================313
//314
// iPhone PNG support:315
//316
// We optionally support converting iPhone-formatted PNGs (which store317
// premultiplied BGRA) back to RGB, even though they're internally encoded318
// differently. To enable this conversion, call319
// stbi_convert_iphone_png_to_rgb(1).320
//321
// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per322
// pixel to remove any premultiplied alpha *only* if the image file explicitly323
// says there's premultiplied data (currently only happens in iPhone images,324
// and only if iPhone convert-to-rgb processing is on).325
//326
// ===========================================================================327
//328
// ADDITIONAL CONFIGURATION329
//330
// - You can suppress implementation of any of the decoders to reduce331
// your code footprint by #defining one or more of the following332
// symbols before creating the implementation.333
//334
// STBI_NO_JPEG335
// STBI_NO_PNG336
// STBI_NO_BMP337
// STBI_NO_PSD338
// STBI_NO_TGA339
// STBI_NO_GIF340
// STBI_NO_HDR341
// STBI_NO_PIC342
// STBI_NO_PNM (.ppm and .pgm)343
//344
// - You can request *only* certain decoders and suppress all other ones345
// (this will be more forward-compatible, as addition of new decoders346
// doesn't require you to disable them explicitly):347
//348
// STBI_ONLY_JPEG349
// STBI_ONLY_PNG350
// STBI_ONLY_BMP351
// STBI_ONLY_PSD352
// STBI_ONLY_TGA353
// STBI_ONLY_GIF354
// STBI_ONLY_HDR355
// STBI_ONLY_PIC356
// STBI_ONLY_PNM (.ppm and .pgm)357
//358
// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still359
// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB360
//361
// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater362
// than that size (in either width or height) without further processing.363
// This is to let programs in the wild set an upper bound to prevent364
// denial-of-service attacks on untrusted data, as one could generate a365
// valid image of gigantic dimensions and force stb_image to allocate a366
// huge block of memory and spend disproportionate time decoding it. By367
// default this is set to (1 << 24), which is 16777216, but that's still368
// very big.370
#ifndef STBI_NO_STDIO371
#include <stdio.h>372
#endif // STBI_NO_STDIO374
#define STBI_VERSION 1376
enum377
{378
STBI_default = 0, // only used for desired_channels380
STBI_grey = 1,381
STBI_grey_alpha = 2,382
STBI_rgb = 3,383
STBI_rgb_alpha = 4384
};386
#include <stdlib.h>387
typedef unsigned char stbi_uc;388
typedef unsigned short stbi_us;390
#ifdef __cplusplus391
extern "C" {392
#endif394
#ifndef STBIDEF395
#ifdef STB_IMAGE_STATIC396
#define STBIDEF static397
#else398
#define STBIDEF extern399
#endif400
#endif402
//////////////////////////////////////////////////////////////////////////////403
//404
// PRIMARY API - works on images of any type405
//407
//408
// load image by filename, open file, or memory buffer409
//411
typedef struct412
{413
int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read414
void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative415
int (*eof) (void *user); // returns nonzero if we are at end of file/data416
} stbi_io_callbacks;418
////////////////////////////////////419
//420
// 8-bits-per-channel interface421
//423
STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels);424
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels);426
#ifndef STBI_NO_STDIO427
STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);428
STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);429
// for stbi_load_from_file, file pointer is left pointing immediately after image430
#endif432
#ifndef STBI_NO_GIF433
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);434
#endif436
#ifdef STBI_WINDOWS_UTF8437
STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);438
#endif440
////////////////////////////////////441
//442
// 16-bits-per-channel interface443
//445
STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);446
STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);448
#ifndef STBI_NO_STDIO449
STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);450
STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);451
#endif453
////////////////////////////////////454
//455
// float-per-channel interface456
//457
#ifndef STBI_NO_LINEAR458
STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);459
STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);461
#ifndef STBI_NO_STDIO462
STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);463
STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);464
#endif465
#endif467
#ifndef STBI_NO_HDR468
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);469
STBIDEF void stbi_hdr_to_ldr_scale(float scale);470
#endif // STBI_NO_HDR472
#ifndef STBI_NO_LINEAR473
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);474
STBIDEF void stbi_ldr_to_hdr_scale(float scale);475
#endif // STBI_NO_LINEAR477
// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR478
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);479
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);480
#ifndef STBI_NO_STDIO481
STBIDEF int stbi_is_hdr (char const *filename);482
STBIDEF int stbi_is_hdr_from_file(FILE *f);483
#endif // STBI_NO_STDIO486
// get a VERY brief reason for failure487
// on most compilers (and ALL modern mainstream compilers) this is threadsafe488
STBIDEF const char *stbi_failure_reason (void);490
// free the loaded image -- this is just free()491
STBIDEF void stbi_image_free (void *retval_from_stbi_load);493
// get image dimensions & components without fully decoding494
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);495
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);496
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);497
STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);499
#ifndef STBI_NO_STDIO500
STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);501
STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);502
STBIDEF int stbi_is_16_bit (char const *filename);503
STBIDEF int stbi_is_16_bit_from_file(FILE *f);504
#endif508
// for image formats that explicitly notate that they have premultiplied alpha,509
// we just return the colors as stored in the file. set this flag to force510
// unpremultiplication. results are undefined if the unpremultiply overflow.511
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);513
// indicate whether we should process iphone images back to canonical format,514
// or just pass them through "as-is"515
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);517
// flip the image vertically, so the first pixel in the output array is the bottom left518
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);520
// as above, but only applies to images loaded on the thread that calls the function521
// this function is only available if your compiler supports thread-local variables;522
// calling it will fail to link if your compiler doesn't523
STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);524
STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);525
STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);527
// ZLIB client - used by PNG, available for other purposes529
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);530
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);531
STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);532
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);534
STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);535
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);538
#ifdef __cplusplus539
}540
#endif542
//543
//544
//// end header file /////////////////////////////////////////////////////545
#endif // STBI_INCLUDE_STB_IMAGE_H547
#ifdef STB_IMAGE_IMPLEMENTATION549
#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \550
|| defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \551
|| defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \552
|| defined(STBI_ONLY_ZLIB)553
#ifndef STBI_ONLY_JPEG554
#define STBI_NO_JPEG555
#endif556
#ifndef STBI_ONLY_PNG557
#define STBI_NO_PNG558
#endif559
#ifndef STBI_ONLY_BMP560
#define STBI_NO_BMP561
#endif562
#ifndef STBI_ONLY_PSD563
#define STBI_NO_PSD564
#endif565
#ifndef STBI_ONLY_TGA566
#define STBI_NO_TGA567
#endif568
#ifndef STBI_ONLY_GIF569
#define STBI_NO_GIF570
#endif571
#ifndef STBI_ONLY_HDR572
#define STBI_NO_HDR573
#endif574
#ifndef STBI_ONLY_PIC575
#define STBI_NO_PIC576
#endif577
#ifndef STBI_ONLY_PNM578
#define STBI_NO_PNM579
#endif580
#endif582
#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)583
#define STBI_NO_ZLIB584
#endif587
#include <stdarg.h>588
#include <stddef.h> // ptrdiff_t on osx589
#include <stdlib.h>590
#include <string.h>591
#include <limits.h>593
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)594
#include <math.h> // ldexp, pow595
#endif597
#ifndef STBI_NO_STDIO598
#include <stdio.h>599
#endif601
#ifndef STBI_ASSERT602
#include <assert.h>603
#define STBI_ASSERT(x) assert(x)604
#endif606
#ifdef __cplusplus607
#define STBI_EXTERN extern "C"608
#else609
#define STBI_EXTERN extern610
#endif613
#ifndef _MSC_VER614
#ifdef __cplusplus615
#define stbi_inline inline616
#else617
#define stbi_inline618
#endif619
#else620
#define stbi_inline __forceinline621
#endif623
#ifndef STBI_NO_THREAD_LOCALS624
#if defined(__cplusplus) && __cplusplus >= 201103L625
#define STBI_THREAD_LOCAL thread_local626
#elif defined(__GNUC__) && __GNUC__ < 5627
#define STBI_THREAD_LOCAL __thread628
#elif defined(_MSC_VER)629
#define STBI_THREAD_LOCAL __declspec(thread)630
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)631
#define STBI_THREAD_LOCAL _Thread_local632
#endif634
#ifndef STBI_THREAD_LOCAL635
#if defined(__GNUC__)636
#define STBI_THREAD_LOCAL __thread637
#endif638
#endif639
#endif641
#if defined(_MSC_VER) || defined(__SYMBIAN32__)642
typedef unsigned short stbi__uint16;643
typedef signed short stbi__int16;644
typedef unsigned int stbi__uint32;645
typedef signed int stbi__int32;646
#else647
#include <stdint.h>648
typedef uint16_t stbi__uint16;649
typedef int16_t stbi__int16;650
typedef uint32_t stbi__uint32;651
typedef int32_t stbi__int32;652
#endif654
// should produce compiler error if size is wrong655
typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];657
#ifdef _MSC_VER658
#define STBI_NOTUSED(v) (void)(v)659
#else660
#define STBI_NOTUSED(v) (void)sizeof(v)661
#endif663
#ifdef _MSC_VER664
#define STBI_HAS_LROTL665
#endif667
#ifdef STBI_HAS_LROTL668
#define stbi_lrot(x,y) _lrotl(x,y)669
#else670
#define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))671
#endif673
#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))674
// ok675
#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)676
// ok677
#else678
#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."679
#endif681
#ifndef STBI_MALLOC682
#define STBI_MALLOC(sz) malloc(sz)683
#define STBI_REALLOC(p,newsz) realloc(p,newsz)684
#define STBI_FREE(p) free(p)685
#endif687
#ifndef STBI_REALLOC_SIZED688
#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)689
#endif691
// x86/x64 detection692
#if defined(__x86_64__) || defined(_M_X64)693
#define STBI__X64_TARGET694
#elif defined(__i386) || defined(_M_IX86)695
#define STBI__X86_TARGET696
#endif698
#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)699
// gcc doesn't support sse2 intrinsics unless you compile with -msse2,700
// which in turn means it gets to use SSE2 everywhere. This is unfortunate,701
// but previous attempts to provide the SSE2 functions with runtime702
// detection caused numerous issues. The way architecture extensions are703
// exposed in GCC/Clang is, sadly, not really suited for one-file libs.704
// New behavior: if compiled with -msse2, we use SSE2 without any705
// detection; if not, we don't use it at all.706
#define STBI_NO_SIMD707
#endif709
#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)710
// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET711
//712
// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the713
// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.714
// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not715
// simultaneously enabling "-mstackrealign".716
//717
// See https://github.com/nothings/stb/issues/81 for more information.718
//719
// So default to no SSE2 on 32-bit MinGW. If you've read this far and added720
// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.721
#define STBI_NO_SIMD722
#endif724
#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))725
#define STBI_SSE2726
#include <emmintrin.h>728
#ifdef _MSC_VER730
#if _MSC_VER >= 1400 // not VC6731
#include <intrin.h> // __cpuid732
static int stbi__cpuid3(void)733
{734
int info[4];735
__cpuid(info,1);736
return info[3];737
}738
#else739
static int stbi__cpuid3(void)740
{741
int res;742
__asm {743
mov eax,1744
cpuid745
mov res,edx746
}747
return res;748
}749
#endif751
#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name753
#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)754
static int stbi__sse2_available(void)755
{756
int info3 = stbi__cpuid3();757
return ((info3 >> 26) & 1) != 0;758
}759
#endif761
#else // assume GCC-style if not VC++762
#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))764
#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)765
static int stbi__sse2_available(void)766
{767
// If we're even attempting to compile this on GCC/Clang, that means768
// -msse2 is on, which means the compiler is allowed to use SSE2769
// instructions at will, and so are we.770
return 1;771
}772
#endif774
#endif775
#endif777
// ARM NEON778
#if defined(STBI_NO_SIMD) && defined(STBI_NEON)779
#undef STBI_NEON780
#endif782
#ifdef STBI_NEON783
#include <arm_neon.h>784
#ifdef _MSC_VER785
#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name786
#else787
#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))788
#endif789
#endif791
#ifndef STBI_SIMD_ALIGN792
#define STBI_SIMD_ALIGN(type, name) type name793
#endif795
#ifndef STBI_MAX_DIMENSIONS796
#define STBI_MAX_DIMENSIONS (1 << 24)797
#endif799
///////////////////////////////////////////////800
//801
// stbi__context struct and start_xxx functions803
// stbi__context structure is our basic context used by all images, so it804
// contains all the IO context, plus some basic image information805
typedef struct806
{807
stbi__uint32 img_x, img_y;808
int img_n, img_out_n;810
stbi_io_callbacks io;811
void *io_user_data;813
int read_from_callbacks;814
int buflen;815
stbi_uc buffer_start[128];816
int callback_already_read;818
stbi_uc *img_buffer, *img_buffer_end;819
stbi_uc *img_buffer_original, *img_buffer_original_end;820
} stbi__context;823
static void stbi__refill_buffer(stbi__context *s);825
// initialize a memory-decode context826
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)827
{828
s->io.read = NULL;829
s->read_from_callbacks = 0;830
s->callback_already_read = 0;831
s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;832
s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;833
}835
// initialize a callback-based context836
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)837
{838
s->io = *c;839
s->io_user_data = user;840
s->buflen = sizeof(s->buffer_start);841
s->read_from_callbacks = 1;842
s->callback_already_read = 0;843
s->img_buffer = s->img_buffer_original = s->buffer_start;844
stbi__refill_buffer(s);845
s->img_buffer_original_end = s->img_buffer_end;846
}848
#ifndef STBI_NO_STDIO850
static int stbi__stdio_read(void *user, char *data, int size)851
{852
return (int) fread(data,1,size,(FILE*) user);853
}855
static void stbi__stdio_skip(void *user, int n)856
{857
int ch;858
fseek((FILE*) user, n, SEEK_CUR);859
ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */860
if (ch != EOF) {861
ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */862
}863
}865
static int stbi__stdio_eof(void *user)866
{867
return feof((FILE*) user) || ferror((FILE *) user);868
}870
static stbi_io_callbacks stbi__stdio_callbacks =871
{872
stbi__stdio_read,873
stbi__stdio_skip,874
stbi__stdio_eof,875
};877
static void stbi__start_file(stbi__context *s, FILE *f)878
{879
stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);880
}882
//static void stop_file(stbi__context *s) { }884
#endif // !STBI_NO_STDIO886
static void stbi__rewind(stbi__context *s)887
{888
// conceptually rewind SHOULD rewind to the beginning of the stream,889
// but we just rewind to the beginning of the initial buffer, because890
// we only use it after doing 'test', which only ever looks at at most 92 bytes891
s->img_buffer = s->img_buffer_original;892
s->img_buffer_end = s->img_buffer_original_end;893
}895
enum896
{897
STBI_ORDER_RGB,898
STBI_ORDER_BGR899
};901
typedef struct902
{903
int bits_per_channel;904
int num_channels;905
int channel_order;906
} stbi__result_info;908
#ifndef STBI_NO_JPEG909
static int stbi__jpeg_test(stbi__context *s);910
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);911
static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);912
#endif914
#ifndef STBI_NO_PNG915
static int stbi__png_test(stbi__context *s);916
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);917
static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);918
static int stbi__png_is16(stbi__context *s);919
#endif921
#ifndef STBI_NO_BMP922
static int stbi__bmp_test(stbi__context *s);923
static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);924
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);925
#endif927
#ifndef STBI_NO_TGA928
static int stbi__tga_test(stbi__context *s);929
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);930
static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);931
#endif933
#ifndef STBI_NO_PSD934
static int stbi__psd_test(stbi__context *s);935
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);936
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);937
static int stbi__psd_is16(stbi__context *s);938
#endif940
#ifndef STBI_NO_HDR941
static int stbi__hdr_test(stbi__context *s);942
static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);943
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);944
#endif946
#ifndef STBI_NO_PIC947
static int stbi__pic_test(stbi__context *s);948
static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);949
static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);950
#endif952
#ifndef STBI_NO_GIF953
static int stbi__gif_test(stbi__context *s);954
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);955
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);956
static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);957
#endif959
#ifndef STBI_NO_PNM960
static int stbi__pnm_test(stbi__context *s);961
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);962
static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);963
static int stbi__pnm_is16(stbi__context *s);964
#endif966
static967
#ifdef STBI_THREAD_LOCAL968
STBI_THREAD_LOCAL969
#endif970
const char *stbi__g_failure_reason;972
STBIDEF const char *stbi_failure_reason(void)973
{974
return stbi__g_failure_reason;975
}977
#ifndef STBI_NO_FAILURE_STRINGS978
static int stbi__err(const char *str)979
{980
stbi__g_failure_reason = str;981
return 0;982
}983
#endif985
static void *stbi__malloc(size_t size)986
{987
return STBI_MALLOC(size);988
}990
// stb_image uses ints pervasively, including for offset calculations.991
// therefore the largest decoded image size we can support with the992
// current code, even on 64-bit targets, is INT_MAX. this is not a993
// significant limitation for the intended use case.994
//995
// we do, however, need to make sure our size calculations don't996
// overflow. hence a few helper functions for size calculations that997
// multiply integers together, making sure that they're non-negative998
// and no overflow occurs.1000
// return 1 if the sum is valid, 0 on overflow.1001
// negative terms are considered invalid.1002
static int stbi__addsizes_valid(int a, int b)1003
{1004
if (b < 0) return 0;1005
// now 0 <= b <= INT_MAX, hence also1006
// 0 <= INT_MAX - b <= INTMAX.1007
// And "a + b <= INT_MAX" (which might overflow) is the1008
// same as a <= INT_MAX - b (no overflow)1009
return a <= INT_MAX - b;1010
}1012
// returns 1 if the product is valid, 0 on overflow.1013
// negative factors are considered invalid.1014
static int stbi__mul2sizes_valid(int a, int b)1015
{1016
if (a < 0 || b < 0) return 0;1017
if (b == 0) return 1; // mul-by-0 is always safe1018
// portable way to check for no overflows in a*b1019
return a <= INT_MAX/b;1020
}1022
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)1023
// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow1024
static int stbi__mad2sizes_valid(int a, int b, int add)1025
{1026
return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);1027
}1028
#endif1030
// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow1031
static int stbi__mad3sizes_valid(int a, int b, int c, int add)1032
{1033
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&1034
stbi__addsizes_valid(a*b*c, add);1035
}1037
// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow1038
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)1039
static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)1040
{1041
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&1042
stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);1043
}1044
#endif1046
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)1047
// mallocs with size overflow checking1048
static void *stbi__malloc_mad2(int a, int b, int add)1049
{1050
if (!stbi__mad2sizes_valid(a, b, add)) return NULL;1051
return stbi__malloc(a*b + add);1052
}1053
#endif1055
static void *stbi__malloc_mad3(int a, int b, int c, int add)1056
{1057
if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;1058
return stbi__malloc(a*b*c + add);1059
}1061
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)1062
static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)1063
{1064
if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;1065
return stbi__malloc(a*b*c*d + add);1066
}1067
#endif1069
// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.1070
static int stbi__addints_valid(int a, int b)1071
{1072
if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow1073
if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.1074
return a <= INT_MAX - b;1075
}1077
// returns 1 if the product of two ints fits in a signed short, 0 on overflow.1078
static int stbi__mul2shorts_valid(int a, int b)1079
{1080
if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow1081
if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid1082
if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN1083
return a >= SHRT_MIN / b;1084
}1086
// stbi__err - error1087
// stbi__errpf - error returning pointer to float1088
// stbi__errpuc - error returning pointer to unsigned char1090
#ifdef STBI_NO_FAILURE_STRINGS1091
#define stbi__err(x,y) 01092
#elif defined(STBI_FAILURE_USERMSG)1093
#define stbi__err(x,y) stbi__err(y)1094
#else1095
#define stbi__err(x,y) stbi__err(x)1096
#endif1098
#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))1099
#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))1101
STBIDEF void stbi_image_free(void *retval_from_stbi_load)1102
{1103
STBI_FREE(retval_from_stbi_load);1104
}1106
#ifndef STBI_NO_LINEAR1107
static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);1108
#endif1110
#ifndef STBI_NO_HDR1111
static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);1112
#endif1114
static int stbi__vertically_flip_on_load_global = 0;1116
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)1117
{1118
stbi__vertically_flip_on_load_global = flag_true_if_should_flip;1119
}1121
#ifndef STBI_THREAD_LOCAL1122
#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global1123
#else1124
static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;1126
STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)1127
{1128
stbi__vertically_flip_on_load_local = flag_true_if_should_flip;1129
stbi__vertically_flip_on_load_set = 1;1130
}1132
#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \1133
? stbi__vertically_flip_on_load_local \1134
: stbi__vertically_flip_on_load_global)1135
#endif // STBI_THREAD_LOCAL1137
static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)1138
{1139
memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields1140
ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed1141
ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order1142
ri->num_channels = 0;1144
// test the formats with a very explicit header first (at least a FOURCC1145
// or distinctive magic number first)1146
#ifndef STBI_NO_PNG1147
if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);1148
#endif1149
#ifndef STBI_NO_BMP1150
if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);1151
#endif1152
#ifndef STBI_NO_GIF1153
if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);1154
#endif1155
#ifndef STBI_NO_PSD1156
if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);1157
#else1158
STBI_NOTUSED(bpc);1159
#endif1160
#ifndef STBI_NO_PIC1161
if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);1162
#endif1164
// then the formats that can end up attempting to load with just 1 or 21165
// bytes matching expectations; these are prone to false positives, so1166
// try them later1167
#ifndef STBI_NO_JPEG1168
if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);1169
#endif1170
#ifndef STBI_NO_PNM1171
if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);1172
#endif1174
#ifndef STBI_NO_HDR1175
if (stbi__hdr_test(s)) {1176
float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);1177
return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);1178
}1179
#endif1181
#ifndef STBI_NO_TGA1182
// test tga last because it's a crappy test!1183
if (stbi__tga_test(s))1184
return stbi__tga_load(s,x,y,comp,req_comp, ri);1185
#endif1187
return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");1188
}1190
static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)1191
{1192
int i;1193
int img_len = w * h * channels;1194
stbi_uc *reduced;1196
reduced = (stbi_uc *) stbi__malloc(img_len);1197
if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");1199
for (i = 0; i < img_len; ++i)1200
reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling1202
STBI_FREE(orig);1203
return reduced;1204
}1206
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)1207
{1208
int i;1209
int img_len = w * h * channels;1210
stbi__uint16 *enlarged;1212
enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);1213
if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");1215
for (i = 0; i < img_len; ++i)1216
enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff1218
STBI_FREE(orig);1219
return enlarged;1220
}1222
static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)1223
{1224
int row;1225
size_t bytes_per_row = (size_t)w * bytes_per_pixel;1226
stbi_uc temp[2048];1227
stbi_uc *bytes = (stbi_uc *)image;1229
for (row = 0; row < (h>>1); row++) {1230
stbi_uc *row0 = bytes + row*bytes_per_row;1231
stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;1232
// swap row0 with row11233
size_t bytes_left = bytes_per_row;1234
while (bytes_left) {1235
size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);1236
memcpy(temp, row0, bytes_copy);1237
memcpy(row0, row1, bytes_copy);1238
memcpy(row1, temp, bytes_copy);1239
row0 += bytes_copy;1240
row1 += bytes_copy;1241
bytes_left -= bytes_copy;1242
}1243
}1244
}1246
#ifndef STBI_NO_GIF1247
static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)1248
{1249
int slice;1250
int slice_size = w * h * bytes_per_pixel;1252
stbi_uc *bytes = (stbi_uc *)image;1253
for (slice = 0; slice < z; ++slice) {1254
stbi__vertical_flip(bytes, w, h, bytes_per_pixel);1255
bytes += slice_size;1256
}1257
}1258
#endif1260
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)1261
{1262
stbi__result_info ri;1263
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);1265
if (result == NULL)1266
return NULL;1268
// it is the responsibility of the loaders to make sure we get either 8 or 16 bit.1269
STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);1271
if (ri.bits_per_channel != 8) {1272
result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);1273
ri.bits_per_channel = 8;1274
}1276
// @TODO: move stbi__convert_format to here1278
if (stbi__vertically_flip_on_load) {1279
int channels = req_comp ? req_comp : *comp;1280
stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));1281
}1283
return (unsigned char *) result;1284
}1286
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)1287
{1288
stbi__result_info ri;1289
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);1291
if (result == NULL)1292
return NULL;1294
// it is the responsibility of the loaders to make sure we get either 8 or 16 bit.1295
STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);1297
if (ri.bits_per_channel != 16) {1298
result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);1299
ri.bits_per_channel = 16;1300
}1302
// @TODO: move stbi__convert_format16 to here1303
// @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision1305
if (stbi__vertically_flip_on_load) {1306
int channels = req_comp ? req_comp : *comp;1307
stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));1308
}1310
return (stbi__uint16 *) result;1311
}1313
#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)1314
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)1315
{1316
if (stbi__vertically_flip_on_load && result != NULL) {1317
int channels = req_comp ? req_comp : *comp;1318
stbi__vertical_flip(result, *x, *y, channels * sizeof(float));1319
}1320
}1321
#endif1323
#ifndef STBI_NO_STDIO1325
#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)1326
STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);1327
STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);1328
#endif1330
#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)1331
STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)1332
{1333
return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);1334
}1335
#endif1337
static FILE *stbi__fopen(char const *filename, char const *mode)1338
{1339
FILE *f;1340
#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)1341
wchar_t wMode[64];1342
wchar_t wFilename[1024];1343
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))1344
return 0;1346
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))1347
return 0;1349
#if defined(_MSC_VER) && _MSC_VER >= 14001350
if (0 != _wfopen_s(&f, wFilename, wMode))1351
f = 0;1352
#else1353
f = _wfopen(wFilename, wMode);1354
#endif1356
#elif defined(_MSC_VER) && _MSC_VER >= 14001357
if (0 != fopen_s(&f, filename, mode))1358
f=0;1359
#else1360
f = fopen(filename, mode);1361
#endif1362
return f;1363
}1366
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)1367
{1368
FILE *f = stbi__fopen(filename, "rb");1369
unsigned char *result;1370
if (!f) return stbi__errpuc("can't fopen", "Unable to open file");1371
result = stbi_load_from_file(f,x,y,comp,req_comp);1372
fclose(f);1373
return result;1374
}1376
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)1377
{1378
unsigned char *result;1379
stbi__context s;1380
stbi__start_file(&s,f);1381
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);1382
if (result) {1383
// need to 'unget' all the characters in the IO buffer1384
fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);1385
}1386
return result;1387
}1389
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)1390
{1391
stbi__uint16 *result;1392
stbi__context s;1393
stbi__start_file(&s,f);1394
result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);1395
if (result) {1396
// need to 'unget' all the characters in the IO buffer1397
fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);1398
}1399
return result;1400
}1402
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)1403
{1404
FILE *f = stbi__fopen(filename, "rb");1405
stbi__uint16 *result;1406
if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");1407
result = stbi_load_from_file_16(f,x,y,comp,req_comp);1408
fclose(f);1409
return result;1410
}1413
#endif //!STBI_NO_STDIO1415
STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)1416
{1417
stbi__context s;1418
stbi__start_mem(&s,buffer,len);1419
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);1420
}1422
STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)1423
{1424
stbi__context s;1425
stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);1426
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);1427
}1429
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)1430
{1431
stbi__context s;1432
stbi__start_mem(&s,buffer,len);1433
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);1434
}1436
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)1437
{1438
stbi__context s;1439
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);1440
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);1441
}1443
#ifndef STBI_NO_GIF1444
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)1445
{1446
unsigned char *result;1447
stbi__context s;1448
stbi__start_mem(&s,buffer,len);1450
result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);1451
if (stbi__vertically_flip_on_load) {1452
stbi__vertical_flip_slices( result, *x, *y, *z, *comp );1453
}1455
return result;1456
}1457
#endif1459
#ifndef STBI_NO_LINEAR1460
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)1461
{1462
unsigned char *data;1463
#ifndef STBI_NO_HDR1464
if (stbi__hdr_test(s)) {1465
stbi__result_info ri;1466
float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);1467
if (hdr_data)1468
stbi__float_postprocess(hdr_data,x,y,comp,req_comp);1469
return hdr_data;1470
}1471
#endif1472
data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);1473
if (data)1474
return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);1475
return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");1476
}1478
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)1479
{1480
stbi__context s;1481
stbi__start_mem(&s,buffer,len);1482
return stbi__loadf_main(&s,x,y,comp,req_comp);1483
}1485
STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)1486
{1487
stbi__context s;1488
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);1489
return stbi__loadf_main(&s,x,y,comp,req_comp);1490
}1492
#ifndef STBI_NO_STDIO1493
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)1494
{1495
float *result;1496
FILE *f = stbi__fopen(filename, "rb");1497
if (!f) return stbi__errpf("can't fopen", "Unable to open file");1498
result = stbi_loadf_from_file(f,x,y,comp,req_comp);1499
fclose(f);1500
return result;1501
}1503
STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)1504
{1505
stbi__context s;1506
stbi__start_file(&s,f);1507
return stbi__loadf_main(&s,x,y,comp,req_comp);1508
}1509
#endif // !STBI_NO_STDIO1511
#endif // !STBI_NO_LINEAR1513
// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is1514
// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always1515
// reports false!1517
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)1518
{1519
#ifndef STBI_NO_HDR1520
stbi__context s;1521
stbi__start_mem(&s,buffer,len);1522
return stbi__hdr_test(&s);1523
#else1524
STBI_NOTUSED(buffer);1525
STBI_NOTUSED(len);1526
return 0;1527
#endif1528
}1530
#ifndef STBI_NO_STDIO1531
STBIDEF int stbi_is_hdr (char const *filename)1532
{1533
FILE *f = stbi__fopen(filename, "rb");1534
int result=0;1535
if (f) {1536
result = stbi_is_hdr_from_file(f);1537
fclose(f);1538
}1539
return result;1540
}1542
STBIDEF int stbi_is_hdr_from_file(FILE *f)1543
{1544
#ifndef STBI_NO_HDR1545
long pos = ftell(f);1546
int res;1547
stbi__context s;1548
stbi__start_file(&s,f);1549
res = stbi__hdr_test(&s);1550
fseek(f, pos, SEEK_SET);1551
return res;1552
#else1553
STBI_NOTUSED(f);1554
return 0;1555
#endif1556
}1557
#endif // !STBI_NO_STDIO1559
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)1560
{1561
#ifndef STBI_NO_HDR1562
stbi__context s;1563
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);1564
return stbi__hdr_test(&s);1565
#else1566
STBI_NOTUSED(clbk);1567
STBI_NOTUSED(user);1568
return 0;1569
#endif1570
}1572
#ifndef STBI_NO_LINEAR1573
static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;1575
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }1576
STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }1577
#endif1579
static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;1581
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }1582
STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }1585
//////////////////////////////////////////////////////////////////////////////1586
//1587
// Common code used by all image loaders1588
//1590
enum1591
{1592
STBI__SCAN_load=0,1593
STBI__SCAN_type,1594
STBI__SCAN_header1595
};1597
static void stbi__refill_buffer(stbi__context *s)1598
{1599
int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);1600
s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);1601
if (n == 0) {1602
// at end of file, treat same as if from memory, but need to handle case1603
// where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file1604
s->read_from_callbacks = 0;1605
s->img_buffer = s->buffer_start;1606
s->img_buffer_end = s->buffer_start+1;1607
*s->img_buffer = 0;1608
} else {1609
s->img_buffer = s->buffer_start;1610
s->img_buffer_end = s->buffer_start + n;1611
}1612
}1614
stbi_inline static stbi_uc stbi__get8(stbi__context *s)1615
{1616
if (s->img_buffer < s->img_buffer_end)1617
return *s->img_buffer++;1618
if (s->read_from_callbacks) {1619
stbi__refill_buffer(s);1620
return *s->img_buffer++;1621
}1622
return 0;1623
}1625
#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)1626
// nothing1627
#else1628
stbi_inline static int stbi__at_eof(stbi__context *s)1629
{1630
if (s->io.read) {1631
if (!(s->io.eof)(s->io_user_data)) return 0;1632
// if feof() is true, check if buffer = end1633
// special case: we've only got the special 0 character at the end1634
if (s->read_from_callbacks == 0) return 1;1635
}1637
return s->img_buffer >= s->img_buffer_end;1638
}1639
#endif1641
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)1642
// nothing1643
#else1644
static void stbi__skip(stbi__context *s, int n)1645
{1646
if (n == 0) return; // already there!1647
if (n < 0) {1648
s->img_buffer = s->img_buffer_end;1649
return;1650
}1651
if (s->io.read) {1652
int blen = (int) (s->img_buffer_end - s->img_buffer);1653
if (blen < n) {1654
s->img_buffer = s->img_buffer_end;1655
(s->io.skip)(s->io_user_data, n - blen);1656
return;1657
}1658
}1659
s->img_buffer += n;1660
}1661
#endif1663
#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)1664
// nothing1665
#else1666
static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)1667
{1668
if (s->io.read) {1669
int blen = (int) (s->img_buffer_end - s->img_buffer);1670
if (blen < n) {1671
int res, count;1673
memcpy(buffer, s->img_buffer, blen);1675
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);1676
res = (count == (n-blen));1677
s->img_buffer = s->img_buffer_end;1678
return res;1679
}1680
}1682
if (s->img_buffer+n <= s->img_buffer_end) {1683
memcpy(buffer, s->img_buffer, n);1684
s->img_buffer += n;1685
return 1;1686
} else1687
return 0;1688
}1689
#endif1691
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)1692
// nothing1693
#else1694
static int stbi__get16be(stbi__context *s)1695
{1696
int z = stbi__get8(s);1697
return (z << 8) + stbi__get8(s);1698
}1699
#endif1701
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)1702
// nothing1703
#else1704
static stbi__uint32 stbi__get32be(stbi__context *s)1705
{1706
stbi__uint32 z = stbi__get16be(s);1707
return (z << 16) + stbi__get16be(s);1708
}1709
#endif1711
#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)1712
// nothing1713
#else1714
static int stbi__get16le(stbi__context *s)1715
{1716
int z = stbi__get8(s);1717
return z + (stbi__get8(s) << 8);1718
}1719
#endif1721
#ifndef STBI_NO_BMP1722
static stbi__uint32 stbi__get32le(stbi__context *s)1723
{1724
stbi__uint32 z = stbi__get16le(s);1725
z += (stbi__uint32)stbi__get16le(s) << 16;1726
return z;1727
}1728
#endif1730
#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings1732
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)1733
// nothing1734
#else1735
//////////////////////////////////////////////////////////////////////////////1736
//1737
// generic converter from built-in img_n to req_comp1738
// individual types do this automatically as much as possible (e.g. jpeg1739
// does all cases internally since it needs to colorspace convert anyway,1740
// and it never has alpha, so very few cases ). png can automatically1741
// interleave an alpha=255 channel, but falls back to this for other cases1742
//1743
// assume data buffer is malloced, so malloc a new one and free that one1744
// only failure mode is malloc failing1746
static stbi_uc stbi__compute_y(int r, int g, int b)1747
{1748
return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);1749
}1750
#endif1752
#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)1753
// nothing1754
#else1755
static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)1756
{1757
int i,j;1758
unsigned char *good;1760
if (req_comp == img_n) return data;1761
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);1763
good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);1764
if (good == NULL) {1765
STBI_FREE(data);1766
return stbi__errpuc("outofmem", "Out of memory");1767
}1769
for (j=0; j < (int) y; ++j) {1770
unsigned char *src = data + j * x * img_n ;1771
unsigned char *dest = good + j * x * req_comp;1773
#define STBI__COMBO(a,b) ((a)*8+(b))1774
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)1775
// convert source image with img_n components to one with req_comp components;1776
// avoid switch per pixel, so use switch per scanline and massive macros1777
switch (STBI__COMBO(img_n, req_comp)) {1778
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;1779
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;1780
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;1781
STBI__CASE(2,1) { dest[0]=src[0]; } break;1782
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;1783
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;1784
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;1785
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;1786
STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;1787
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;1788
STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;1789
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;1790
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");1791
}1792
#undef STBI__CASE1793
}1795
STBI_FREE(data);1796
return good;1797
}1798
#endif1800
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)1801
// nothing1802
#else1803
static stbi__uint16 stbi__compute_y_16(int r, int g, int b)1804
{1805
return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);1806
}1807
#endif1809
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)1810
// nothing1811
#else1812
static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)1813
{1814
int i,j;1815
stbi__uint16 *good;1817
if (req_comp == img_n) return data;1818
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);1820
good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);1821
if (good == NULL) {1822
STBI_FREE(data);1823
return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");1824
}1826
for (j=0; j < (int) y; ++j) {1827
stbi__uint16 *src = data + j * x * img_n ;1828
stbi__uint16 *dest = good + j * x * req_comp;1830
#define STBI__COMBO(a,b) ((a)*8+(b))1831
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)1832
// convert source image with img_n components to one with req_comp components;1833
// avoid switch per pixel, so use switch per scanline and massive macros1834
switch (STBI__COMBO(img_n, req_comp)) {1835
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;1836
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;1837
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;1838
STBI__CASE(2,1) { dest[0]=src[0]; } break;1839
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;1840
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;1841
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;1842
STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;1843
STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;1844
STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;1845
STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;1846
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;1847
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");1848
}1849
#undef STBI__CASE1850
}1852
STBI_FREE(data);1853
return good;1854
}1855
#endif1857
#ifndef STBI_NO_LINEAR1858
static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)1859
{1860
int i,k,n;1861
float *output;1862
if (!data) return NULL;1863
output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);1864
if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }1865
// compute number of non-alpha components1866
if (comp & 1) n = comp; else n = comp-1;1867
for (i=0; i < x*y; ++i) {1868
for (k=0; k < n; ++k) {1869
output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);1870
}1871
}1872
if (n < comp) {1873
for (i=0; i < x*y; ++i) {1874
output[i*comp + n] = data[i*comp + n]/255.0f;1875
}1876
}1877
STBI_FREE(data);1878
return output;1879
}1880
#endif1882
#ifndef STBI_NO_HDR1883
#define stbi__float2int(x) ((int) (x))1884
static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)1885
{1886
int i,k,n;1887
stbi_uc *output;1888
if (!data) return NULL;1889
output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);1890
if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }1891
// compute number of non-alpha components1892
if (comp & 1) n = comp; else n = comp-1;1893
for (i=0; i < x*y; ++i) {1894
for (k=0; k < n; ++k) {1895
float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;1896
if (z < 0) z = 0;1897
if (z > 255) z = 255;1898
output[i*comp + k] = (stbi_uc) stbi__float2int(z);1899
}1900
if (k < comp) {1901
float z = data[i*comp+k] * 255 + 0.5f;1902
if (z < 0) z = 0;1903
if (z > 255) z = 255;1904
output[i*comp + k] = (stbi_uc) stbi__float2int(z);1905
}1906
}1907
STBI_FREE(data);1908
return output;1909
}1910
#endif1912
//////////////////////////////////////////////////////////////////////////////1913
//1914
// "baseline" JPEG/JFIF decoder1915
//1916
// simple implementation1917
// - doesn't support delayed output of y-dimension1918
// - simple interface (only one output format: 8-bit interleaved RGB)1919
// - doesn't try to recover corrupt jpegs1920
// - doesn't allow partial loading, loading multiple at once1921
// - still fast on x86 (copying globals into locals doesn't help x86)1922
// - allocates lots of intermediate memory (full size of all components)1923
// - non-interleaved case requires this anyway1924
// - allows good upsampling (see next)1925
// high-quality1926
// - upsampled channels are bilinearly interpolated, even across blocks1927
// - quality integer IDCT derived from IJG's 'slow'1928
// performance1929
// - fast huffman; reasonable integer IDCT1930
// - some SIMD kernels for common paths on targets with SSE2/NEON1931
// - uses a lot of intermediate memory, could cache poorly1933
#ifndef STBI_NO_JPEG1935
// huffman decoding acceleration1936
#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache1938
typedef struct1939
{1940
stbi_uc fast[1 << FAST_BITS];1941
// weirdly, repacking this into AoS is a 10% speed loss, instead of a win1942
stbi__uint16 code[256];1943
stbi_uc values[256];1944
stbi_uc size[257];1945
unsigned int maxcode[18];1946
int delta[17]; // old 'firstsymbol' - old 'firstcode'1947
} stbi__huffman;1949
typedef struct1950
{1951
stbi__context *s;1952
stbi__huffman huff_dc[4];1953
stbi__huffman huff_ac[4];1954
stbi__uint16 dequant[4][64];1955
stbi__int16 fast_ac[4][1 << FAST_BITS];1957
// sizes for components, interleaved MCUs1958
int img_h_max, img_v_max;1959
int img_mcu_x, img_mcu_y;1960
int img_mcu_w, img_mcu_h;1962
// definition of jpeg image component1963
struct1964
{1965
int id;1966
int h,v;1967
int tq;1968
int hd,ha;1969
int dc_pred;1971
int x,y,w2,h2;1972
stbi_uc *data;1973
void *raw_data, *raw_coeff;1974
stbi_uc *linebuf;1975
short *coeff; // progressive only1976
int coeff_w, coeff_h; // number of 8x8 coefficient blocks1977
} img_comp[4];1979
stbi__uint32 code_buffer; // jpeg entropy-coded buffer1980
int code_bits; // number of valid bits1981
unsigned char marker; // marker seen while filling entropy buffer1982
int nomore; // flag if we saw a marker so must stop1984
int progressive;1985
int spec_start;1986
int spec_end;1987
int succ_high;1988
int succ_low;1989
int eob_run;1990
int jfif;1991
int app14_color_transform; // Adobe APP14 tag1992
int rgb;1994
int scan_n, order[4];1995
int restart_interval, todo;1997
// kernels1998
void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);1999
void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);2000
stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);2001
} stbi__jpeg;2003
static int stbi__build_huffman(stbi__huffman *h, int *count)2004
{2005
int i,j,k=0;2006
unsigned int code;2007
// build size list for each symbol (from JPEG spec)2008
for (i=0; i < 16; ++i) {2009
for (j=0; j < count[i]; ++j) {2010
h->size[k++] = (stbi_uc) (i+1);2011
if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");2012
}2013
}2014
h->size[k] = 0;2016
// compute actual symbols (from jpeg spec)2017
code = 0;2018
k = 0;2019
for(j=1; j <= 16; ++j) {2020
// compute delta to add to code to compute symbol id2021
h->delta[j] = k - code;2022
if (h->size[k] == j) {2023
while (h->size[k] == j)2024
h->code[k++] = (stbi__uint16) (code++);2025
if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");2026
}2027
// compute largest code + 1 for this size, preshifted as needed later2028
h->maxcode[j] = code << (16-j);2029
code <<= 1;2030
}2031
h->maxcode[j] = 0xffffffff;2033
// build non-spec acceleration table; 255 is flag for not-accelerated2034
memset(h->fast, 255, 1 << FAST_BITS);2035
for (i=0; i < k; ++i) {2036
int s = h->size[i];2037
if (s <= FAST_BITS) {2038
int c = h->code[i] << (FAST_BITS-s);2039
int m = 1 << (FAST_BITS-s);2040
for (j=0; j < m; ++j) {2041
h->fast[c+j] = (stbi_uc) i;2042
}2043
}2044
}2045
return 1;2046
}2048
// build a table that decodes both magnitude and value of small ACs in2049
// one go.2050
static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)2051
{2052
int i;2053
for (i=0; i < (1 << FAST_BITS); ++i) {2054
stbi_uc fast = h->fast[i];2055
fast_ac[i] = 0;2056
if (fast < 255) {2057
int rs = h->values[fast];2058
int run = (rs >> 4) & 15;2059
int magbits = rs & 15;2060
int len = h->size[fast];2062
if (magbits && len + magbits <= FAST_BITS) {2063
// magnitude code followed by receive_extend code2064
int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);2065
int m = 1 << (magbits - 1);2066
if (k < m) k += (~0U << magbits) + 1;2067
// if the result is small enough, we can fit it in fast_ac table2068
if (k >= -128 && k <= 127)2069
fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));2070
}2071
}2072
}2073
}2075
static void stbi__grow_buffer_unsafe(stbi__jpeg *j)2076
{2077
do {2078
unsigned int b = j->nomore ? 0 : stbi__get8(j->s);2079
if (b == 0xff) {2080
int c = stbi__get8(j->s);2081
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes2082
if (c != 0) {2083
j->marker = (unsigned char) c;2084
j->nomore = 1;2085
return;2086
}2087
}2088
j->code_buffer |= b << (24 - j->code_bits);2089
j->code_bits += 8;2090
} while (j->code_bits <= 24);2091
}2093
// (1 << n) - 12094
static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};2096
// decode a jpeg huffman value from the bitstream2097
stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)2098
{2099
unsigned int temp;2100
int c,k;2102
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);2104
// look at the top FAST_BITS and determine what symbol ID it is,2105
// if the code is <= FAST_BITS2106
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);2107
k = h->fast[c];2108
if (k < 255) {2109
int s = h->size[k];2110
if (s > j->code_bits)2111
return -1;2112
j->code_buffer <<= s;2113
j->code_bits -= s;2114
return h->values[k];2115
}2117
// naive test is to shift the code_buffer down so k bits are2118
// valid, then test against maxcode. To speed this up, we've2119
// preshifted maxcode left so that it has (16-k) 0s at the2120
// end; in other words, regardless of the number of bits, it2121
// wants to be compared against something shifted to have 16;2122
// that way we don't need to shift inside the loop.2123
temp = j->code_buffer >> 16;2124
for (k=FAST_BITS+1 ; ; ++k)2125
if (temp < h->maxcode[k])2126
break;2127
if (k == 17) {2128
// error! code not found2129
j->code_bits -= 16;2130
return -1;2131
}2133
if (k > j->code_bits)2134
return -1;2136
// convert the huffman code to the symbol id2137
c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];2138
if(c < 0 || c >= 256) // symbol id out of bounds!2139
return -1;2140
STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);2142
// convert the id to a symbol2143
j->code_bits -= k;2144
j->code_buffer <<= k;2145
return h->values[c];2146
}2148
// bias[n] = (-1<<n) + 12149
static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};2151
// combined JPEG 'receive' and JPEG 'extend', since baseline2152
// always extends everything it receives.2153
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)2154
{2155
unsigned int k;2156
int sgn;2157
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);2158
if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing2160
sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)2161
k = stbi_lrot(j->code_buffer, n);2162
j->code_buffer = k & ~stbi__bmask[n];2163
k &= stbi__bmask[n];2164
j->code_bits -= n;2165
return k + (stbi__jbias[n] & (sgn - 1));2166
}2168
// get some unsigned bits2169
stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)2170
{2171
unsigned int k;2172
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);2173
if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing2174
k = stbi_lrot(j->code_buffer, n);2175
j->code_buffer = k & ~stbi__bmask[n];2176
k &= stbi__bmask[n];2177
j->code_bits -= n;2178
return k;2179
}2181
stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)2182
{2183
unsigned int k;2184
if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);2185
if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing2186
k = j->code_buffer;2187
j->code_buffer <<= 1;2188
--j->code_bits;2189
return k & 0x80000000;2190
}2192
// given a value that's at position X in the zigzag stream,2193
// where does it appear in the 8x8 matrix coded as row-major?2194
static const stbi_uc stbi__jpeg_dezigzag[64+15] =2195
{2196
0, 1, 8, 16, 9, 2, 3, 10,2197
17, 24, 32, 25, 18, 11, 4, 5,2198
12, 19, 26, 33, 40, 48, 41, 34,2199
27, 20, 13, 6, 7, 14, 21, 28,2200
35, 42, 49, 56, 57, 50, 43, 36,2201
29, 22, 15, 23, 30, 37, 44, 51,2202
58, 59, 52, 45, 38, 31, 39, 46,2203
53, 60, 61, 54, 47, 55, 62, 63,2204
// let corrupt input sample past end2205
63, 63, 63, 63, 63, 63, 63, 63,2206
63, 63, 63, 63, 63, 63, 632207
};2209
// decode one 64-entry block--2210
static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)2211
{2212
int diff,dc,k;2213
int t;2215
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);2216
t = stbi__jpeg_huff_decode(j, hdc);2217
if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");2219
// 0 all the ac values now so we can do it 32-bits at a time2220
memset(data,0,64*sizeof(data[0]));2222
diff = t ? stbi__extend_receive(j, t) : 0;2223
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");2224
dc = j->img_comp[b].dc_pred + diff;2225
j->img_comp[b].dc_pred = dc;2226
if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");2227
data[0] = (short) (dc * dequant[0]);2229
// decode AC components, see JPEG spec2230
k = 1;2231
do {2232
unsigned int zig;2233
int c,r,s;2234
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);2235
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);2236
r = fac[c];2237
if (r) { // fast-AC path2238
k += (r >> 4) & 15; // run2239
s = r & 15; // combined length2240
if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");2241
j->code_buffer <<= s;2242
j->code_bits -= s;2243
// decode into unzigzag'd location2244
zig = stbi__jpeg_dezigzag[k++];2245
data[zig] = (short) ((r >> 8) * dequant[zig]);2246
} else {2247
int rs = stbi__jpeg_huff_decode(j, hac);2248
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");2249
s = rs & 15;2250
r = rs >> 4;2251
if (s == 0) {2252
if (rs != 0xf0) break; // end block2253
k += 16;2254
} else {2255
k += r;2256
// decode into unzigzag'd location2257
zig = stbi__jpeg_dezigzag[k++];2258
data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);2259
}2260
}2261
} while (k < 64);2262
return 1;2263
}2265
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)2266
{2267
int diff,dc;2268
int t;2269
if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");2271
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);2273
if (j->succ_high == 0) {2274
// first scan for DC coefficient, must be first2275
memset(data,0,64*sizeof(data[0])); // 0 all the ac values now2276
t = stbi__jpeg_huff_decode(j, hdc);2277
if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");2278
diff = t ? stbi__extend_receive(j, t) : 0;2280
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");2281
dc = j->img_comp[b].dc_pred + diff;2282
j->img_comp[b].dc_pred = dc;2283
if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");2284
data[0] = (short) (dc * (1 << j->succ_low));2285
} else {2286
// refinement scan for DC coefficient2287
if (stbi__jpeg_get_bit(j))2288
data[0] += (short) (1 << j->succ_low);2289
}2290
return 1;2291
}2293
// @OPTIMIZE: store non-zigzagged during the decode passes,2294
// and only de-zigzag when dequantizing2295
static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)2296
{2297
int k;2298
if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");2300
if (j->succ_high == 0) {2301
int shift = j->succ_low;2303
if (j->eob_run) {2304
--j->eob_run;2305
return 1;2306
}2308
k = j->spec_start;2309
do {2310
unsigned int zig;2311
int c,r,s;2312
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);2313
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);2314
r = fac[c];2315
if (r) { // fast-AC path2316
k += (r >> 4) & 15; // run2317
s = r & 15; // combined length2318
if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");2319
j->code_buffer <<= s;2320
j->code_bits -= s;2321
zig = stbi__jpeg_dezigzag[k++];2322
data[zig] = (short) ((r >> 8) * (1 << shift));2323
} else {2324
int rs = stbi__jpeg_huff_decode(j, hac);2325
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");2326
s = rs & 15;2327
r = rs >> 4;2328
if (s == 0) {2329
if (r < 15) {2330
j->eob_run = (1 << r);2331
if (r)2332
j->eob_run += stbi__jpeg_get_bits(j, r);2333
--j->eob_run;2334
break;2335
}2336
k += 16;2337
} else {2338
k += r;2339
zig = stbi__jpeg_dezigzag[k++];2340
data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));2341
}2342
}2343
} while (k <= j->spec_end);2344
} else {2345
// refinement scan for these AC coefficients2347
short bit = (short) (1 << j->succ_low);2349
if (j->eob_run) {2350
--j->eob_run;2351
for (k = j->spec_start; k <= j->spec_end; ++k) {2352
short *p = &data[stbi__jpeg_dezigzag[k]];2353
if (*p != 0)2354
if (stbi__jpeg_get_bit(j))2355
if ((*p & bit)==0) {2356
if (*p > 0)2357
*p += bit;2358
else2359
*p -= bit;2360
}2361
}2362
} else {2363
k = j->spec_start;2364
do {2365
int r,s;2366
int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh2367
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");2368
s = rs & 15;2369
r = rs >> 4;2370
if (s == 0) {2371
if (r < 15) {2372
j->eob_run = (1 << r) - 1;2373
if (r)2374
j->eob_run += stbi__jpeg_get_bits(j, r);2375
r = 64; // force end of block2376
} else {2377
// r=15 s=0 should write 16 0s, so we just do2378
// a run of 15 0s and then write s (which is 0),2379
// so we don't have to do anything special here2380
}2381
} else {2382
if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");2383
// sign bit2384
if (stbi__jpeg_get_bit(j))2385
s = bit;2386
else2387
s = -bit;2388
}2390
// advance by r2391
while (k <= j->spec_end) {2392
short *p = &data[stbi__jpeg_dezigzag[k++]];2393
if (*p != 0) {2394
if (stbi__jpeg_get_bit(j))2395
if ((*p & bit)==0) {2396
if (*p > 0)2397
*p += bit;2398
else2399
*p -= bit;2400
}2401
} else {2402
if (r == 0) {2403
*p = (short) s;2404
break;2405
}2406
--r;2407
}2408
}2409
} while (k <= j->spec_end);2410
}2411
}2412
return 1;2413
}2415
// take a -128..127 value and stbi__clamp it and convert to 0..2552416
stbi_inline static stbi_uc stbi__clamp(int x)2417
{2418
// trick to use a single test to catch both cases2419
if ((unsigned int) x > 255) {2420
if (x < 0) return 0;2421
if (x > 255) return 255;2422
}2423
return (stbi_uc) x;2424
}2426
#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))2427
#define stbi__fsh(x) ((x) * 4096)2429
// derived from jidctint -- DCT_ISLOW2430
#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \2431
int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \2432
p2 = s2; \2433
p3 = s6; \2434
p1 = (p2+p3) * stbi__f2f(0.5411961f); \2435
t2 = p1 + p3*stbi__f2f(-1.847759065f); \2436
t3 = p1 + p2*stbi__f2f( 0.765366865f); \2437
p2 = s0; \2438
p3 = s4; \2439
t0 = stbi__fsh(p2+p3); \2440
t1 = stbi__fsh(p2-p3); \2441
x0 = t0+t3; \2442
x3 = t0-t3; \2443
x1 = t1+t2; \2444
x2 = t1-t2; \2445
t0 = s7; \2446
t1 = s5; \2447
t2 = s3; \2448
t3 = s1; \2449
p3 = t0+t2; \2450
p4 = t1+t3; \2451
p1 = t0+t3; \2452
p2 = t1+t2; \2453
p5 = (p3+p4)*stbi__f2f( 1.175875602f); \2454
t0 = t0*stbi__f2f( 0.298631336f); \2455
t1 = t1*stbi__f2f( 2.053119869f); \2456
t2 = t2*stbi__f2f( 3.072711026f); \2457
t3 = t3*stbi__f2f( 1.501321110f); \2458
p1 = p5 + p1*stbi__f2f(-0.899976223f); \2459
p2 = p5 + p2*stbi__f2f(-2.562915447f); \2460
p3 = p3*stbi__f2f(-1.961570560f); \2461
p4 = p4*stbi__f2f(-0.390180644f); \2462
t3 += p1+p4; \2463
t2 += p2+p3; \2464
t1 += p2+p4; \2465
t0 += p1+p3;2467
static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])2468
{2469
int i,val[64],*v=val;2470
stbi_uc *o;2471
short *d = data;2473
// columns2474
for (i=0; i < 8; ++i,++d, ++v) {2475
// if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing2476
if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==02477
&& d[40]==0 && d[48]==0 && d[56]==0) {2478
// no shortcut 0 seconds2479
// (1|2|3|4|5|6|7)==0 0 seconds2480
// all separate -0.047 seconds2481
// 1 && 2|3 && 4|5 && 6|7: -0.047 seconds2482
int dcterm = d[0]*4;2483
v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;2484
} else {2485
STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])2486
// constants scaled things up by 1<<12; let's bring them back2487
// down, but keep 2 extra bits of precision2488
x0 += 512; x1 += 512; x2 += 512; x3 += 512;2489
v[ 0] = (x0+t3) >> 10;2490
v[56] = (x0-t3) >> 10;2491
v[ 8] = (x1+t2) >> 10;2492
v[48] = (x1-t2) >> 10;2493
v[16] = (x2+t1) >> 10;2494
v[40] = (x2-t1) >> 10;2495
v[24] = (x3+t0) >> 10;2496
v[32] = (x3-t0) >> 10;2497
}2498
}2500
for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {2501
// no fast case since the first 1D IDCT spread components out2502
STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])2503
// constants scaled things up by 1<<12, plus we had 1<<2 from first2504
// loop, plus horizontal and vertical each scale by sqrt(8) so together2505
// we've got an extra 1<<3, so 1<<17 total we need to remove.2506
// so we want to round that, which means adding 0.5 * 1<<17,2507
// aka 65536. Also, we'll end up with -128 to 127 that we want2508
// to encode as 0..255 by adding 128, so we'll add that before the shift2509
x0 += 65536 + (128<<17);2510
x1 += 65536 + (128<<17);2511
x2 += 65536 + (128<<17);2512
x3 += 65536 + (128<<17);2513
// tried computing the shifts into temps, or'ing the temps to see2514
// if any were out of range, but that was slower2515
o[0] = stbi__clamp((x0+t3) >> 17);2516
o[7] = stbi__clamp((x0-t3) >> 17);2517
o[1] = stbi__clamp((x1+t2) >> 17);2518
o[6] = stbi__clamp((x1-t2) >> 17);2519
o[2] = stbi__clamp((x2+t1) >> 17);2520
o[5] = stbi__clamp((x2-t1) >> 17);2521
o[3] = stbi__clamp((x3+t0) >> 17);2522
o[4] = stbi__clamp((x3-t0) >> 17);2523
}2524
}2526
#ifdef STBI_SSE22527
// sse2 integer IDCT. not the fastest possible implementation but it2528
// produces bit-identical results to the generic C version so it's2529
// fully "transparent".2530
static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])2531
{2532
// This is constructed to match our regular (generic) integer IDCT exactly.2533
__m128i row0, row1, row2, row3, row4, row5, row6, row7;2534
__m128i tmp;2536
// dot product constant: even elems=x, odd elems=y2537
#define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))2539
// out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)2540
// out(1) = c1[even]*x + c1[odd]*y2541
#define dct_rot(out0,out1, x,y,c0,c1) \2542
__m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \2543
__m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \2544
__m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \2545
__m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \2546
__m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \2547
__m128i out1##_h = _mm_madd_epi16(c0##hi, c1)2549
// out = in << 12 (in 16-bit, out 32-bit)2550
#define dct_widen(out, in) \2551
__m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \2552
__m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)2554
// wide add2555
#define dct_wadd(out, a, b) \2556
__m128i out##_l = _mm_add_epi32(a##_l, b##_l); \2557
__m128i out##_h = _mm_add_epi32(a##_h, b##_h)2559
// wide sub2560
#define dct_wsub(out, a, b) \2561
__m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \2562
__m128i out##_h = _mm_sub_epi32(a##_h, b##_h)2564
// butterfly a/b, add bias, then shift by "s" and pack2565
#define dct_bfly32o(out0, out1, a,b,bias,s) \2566
{ \2567
__m128i abiased_l = _mm_add_epi32(a##_l, bias); \2568
__m128i abiased_h = _mm_add_epi32(a##_h, bias); \2569
dct_wadd(sum, abiased, b); \2570
dct_wsub(dif, abiased, b); \2571
out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \2572
out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \2573
}2575
// 8-bit interleave step (for transposes)2576
#define dct_interleave8(a, b) \2577
tmp = a; \2578
a = _mm_unpacklo_epi8(a, b); \2579
b = _mm_unpackhi_epi8(tmp, b)2581
// 16-bit interleave step (for transposes)2582
#define dct_interleave16(a, b) \2583
tmp = a; \2584
a = _mm_unpacklo_epi16(a, b); \2585
b = _mm_unpackhi_epi16(tmp, b)2587
#define dct_pass(bias,shift) \2588
{ \2589
/* even part */ \2590
dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \2591
__m128i sum04 = _mm_add_epi16(row0, row4); \2592
__m128i dif04 = _mm_sub_epi16(row0, row4); \2593
dct_widen(t0e, sum04); \2594
dct_widen(t1e, dif04); \2595
dct_wadd(x0, t0e, t3e); \2596
dct_wsub(x3, t0e, t3e); \2597
dct_wadd(x1, t1e, t2e); \2598
dct_wsub(x2, t1e, t2e); \2599
/* odd part */ \2600
dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \2601
dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \2602
__m128i sum17 = _mm_add_epi16(row1, row7); \2603
__m128i sum35 = _mm_add_epi16(row3, row5); \2604
dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \2605
dct_wadd(x4, y0o, y4o); \2606
dct_wadd(x5, y1o, y5o); \2607
dct_wadd(x6, y2o, y5o); \2608
dct_wadd(x7, y3o, y4o); \2609
dct_bfly32o(row0,row7, x0,x7,bias,shift); \2610
dct_bfly32o(row1,row6, x1,x6,bias,shift); \2611
dct_bfly32o(row2,row5, x2,x5,bias,shift); \2612
dct_bfly32o(row3,row4, x3,x4,bias,shift); \2613
}2615
__m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));2616
__m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));2617
__m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));2618
__m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));2619
__m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));2620
__m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));2621
__m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));2622
__m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));2624
// rounding biases in column/row passes, see stbi__idct_block for explanation.2625
__m128i bias_0 = _mm_set1_epi32(512);2626
__m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));2628
// load2629
row0 = _mm_load_si128((const __m128i *) (data + 0*8));2630
row1 = _mm_load_si128((const __m128i *) (data + 1*8));2631
row2 = _mm_load_si128((const __m128i *) (data + 2*8));2632
row3 = _mm_load_si128((const __m128i *) (data + 3*8));2633
row4 = _mm_load_si128((const __m128i *) (data + 4*8));2634
row5 = _mm_load_si128((const __m128i *) (data + 5*8));2635
row6 = _mm_load_si128((const __m128i *) (data + 6*8));2636
row7 = _mm_load_si128((const __m128i *) (data + 7*8));2638
// column pass2639
dct_pass(bias_0, 10);2641
{2642
// 16bit 8x8 transpose pass 12643
dct_interleave16(row0, row4);2644
dct_interleave16(row1, row5);2645
dct_interleave16(row2, row6);2646
dct_interleave16(row3, row7);2648
// transpose pass 22649
dct_interleave16(row0, row2);2650
dct_interleave16(row1, row3);2651
dct_interleave16(row4, row6);2652
dct_interleave16(row5, row7);2654
// transpose pass 32655
dct_interleave16(row0, row1);2656
dct_interleave16(row2, row3);2657
dct_interleave16(row4, row5);2658
dct_interleave16(row6, row7);2659
}2661
// row pass2662
dct_pass(bias_1, 17);2664
{2665
// pack2666
__m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b72667
__m128i p1 = _mm_packus_epi16(row2, row3);2668
__m128i p2 = _mm_packus_epi16(row4, row5);2669
__m128i p3 = _mm_packus_epi16(row6, row7);2671
// 8bit 8x8 transpose pass 12672
dct_interleave8(p0, p2); // a0e0a1e1...2673
dct_interleave8(p1, p3); // c0g0c1g1...2675
// transpose pass 22676
dct_interleave8(p0, p1); // a0c0e0g0...2677
dct_interleave8(p2, p3); // b0d0f0h0...2679
// transpose pass 32680
dct_interleave8(p0, p2); // a0b0c0d0...2681
dct_interleave8(p1, p3); // a4b4c4d4...2683
// store2684
_mm_storel_epi64((__m128i *) out, p0); out += out_stride;2685
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;2686
_mm_storel_epi64((__m128i *) out, p2); out += out_stride;2687
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;2688
_mm_storel_epi64((__m128i *) out, p1); out += out_stride;2689
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;2690
_mm_storel_epi64((__m128i *) out, p3); out += out_stride;2691
_mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));2692
}2694
#undef dct_const2695
#undef dct_rot2696
#undef dct_widen2697
#undef dct_wadd2698
#undef dct_wsub2699
#undef dct_bfly32o2700
#undef dct_interleave82701
#undef dct_interleave162702
#undef dct_pass2703
}2705
#endif // STBI_SSE22707
#ifdef STBI_NEON2709
// NEON integer IDCT. should produce bit-identical2710
// results to the generic C version.2711
static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])2712
{2713
int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;2715
int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));2716
int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));2717
int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));2718
int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));2719
int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));2720
int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));2721
int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));2722
int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));2723
int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));2724
int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));2725
int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));2726
int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));2728
#define dct_long_mul(out, inq, coeff) \2729
int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \2730
int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)2732
#define dct_long_mac(out, acc, inq, coeff) \2733
int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \2734
int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)2736
#define dct_widen(out, inq) \2737
int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \2738
int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)2740
// wide add2741
#define dct_wadd(out, a, b) \2742
int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \2743
int32x4_t out##_h = vaddq_s32(a##_h, b##_h)2745
// wide sub2746
#define dct_wsub(out, a, b) \2747
int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \2748
int32x4_t out##_h = vsubq_s32(a##_h, b##_h)2750
// butterfly a/b, then shift using "shiftop" by "s" and pack2751
#define dct_bfly32o(out0,out1, a,b,shiftop,s) \2752
{ \2753
dct_wadd(sum, a, b); \2754
dct_wsub(dif, a, b); \2755
out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \2756
out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \2757
}2759
#define dct_pass(shiftop, shift) \2760
{ \2761
/* even part */ \2762
int16x8_t sum26 = vaddq_s16(row2, row6); \2763
dct_long_mul(p1e, sum26, rot0_0); \2764
dct_long_mac(t2e, p1e, row6, rot0_1); \2765
dct_long_mac(t3e, p1e, row2, rot0_2); \2766
int16x8_t sum04 = vaddq_s16(row0, row4); \2767
int16x8_t dif04 = vsubq_s16(row0, row4); \2768
dct_widen(t0e, sum04); \2769
dct_widen(t1e, dif04); \2770
dct_wadd(x0, t0e, t3e); \2771
dct_wsub(x3, t0e, t3e); \2772
dct_wadd(x1, t1e, t2e); \2773
dct_wsub(x2, t1e, t2e); \2774
/* odd part */ \2775
int16x8_t sum15 = vaddq_s16(row1, row5); \2776
int16x8_t sum17 = vaddq_s16(row1, row7); \2777
int16x8_t sum35 = vaddq_s16(row3, row5); \2778
int16x8_t sum37 = vaddq_s16(row3, row7); \2779
int16x8_t sumodd = vaddq_s16(sum17, sum35); \2780
dct_long_mul(p5o, sumodd, rot1_0); \2781
dct_long_mac(p1o, p5o, sum17, rot1_1); \2782
dct_long_mac(p2o, p5o, sum35, rot1_2); \2783
dct_long_mul(p3o, sum37, rot2_0); \2784
dct_long_mul(p4o, sum15, rot2_1); \2785
dct_wadd(sump13o, p1o, p3o); \2786
dct_wadd(sump24o, p2o, p4o); \2787
dct_wadd(sump23o, p2o, p3o); \2788
dct_wadd(sump14o, p1o, p4o); \2789
dct_long_mac(x4, sump13o, row7, rot3_0); \2790
dct_long_mac(x5, sump24o, row5, rot3_1); \2791
dct_long_mac(x6, sump23o, row3, rot3_2); \2792
dct_long_mac(x7, sump14o, row1, rot3_3); \2793
dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \2794
dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \2795
dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \2796
dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \2797
}2799
// load2800
row0 = vld1q_s16(data + 0*8);2801
row1 = vld1q_s16(data + 1*8);2802
row2 = vld1q_s16(data + 2*8);2803
row3 = vld1q_s16(data + 3*8);2804
row4 = vld1q_s16(data + 4*8);2805
row5 = vld1q_s16(data + 5*8);2806
row6 = vld1q_s16(data + 6*8);2807
row7 = vld1q_s16(data + 7*8);2809
// add DC bias2810
row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));2812
// column pass2813
dct_pass(vrshrn_n_s32, 10);2815
// 16bit 8x8 transpose2816
{2817
// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.2818
// whether compilers actually get this is another story, sadly.2819
#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }2820
#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }2821
#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }2823
// pass 12824
dct_trn16(row0, row1); // a0b0a2b2a4b4a6b62825
dct_trn16(row2, row3);2826
dct_trn16(row4, row5);2827
dct_trn16(row6, row7);2829
// pass 22830
dct_trn32(row0, row2); // a0b0c0d0a4b4c4d42831
dct_trn32(row1, row3);2832
dct_trn32(row4, row6);2833
dct_trn32(row5, row7);2835
// pass 32836
dct_trn64(row0, row4); // a0b0c0d0e0f0g0h02837
dct_trn64(row1, row5);2838
dct_trn64(row2, row6);2839
dct_trn64(row3, row7);2841
#undef dct_trn162842
#undef dct_trn322843
#undef dct_trn642844
}2846
// row pass2847
// vrshrn_n_s32 only supports shifts up to 16, we need2848
// 17. so do a non-rounding shift of 16 first then follow2849
// up with a rounding shift by 1.2850
dct_pass(vshrn_n_s32, 16);2852
{2853
// pack and round2854
uint8x8_t p0 = vqrshrun_n_s16(row0, 1);2855
uint8x8_t p1 = vqrshrun_n_s16(row1, 1);2856
uint8x8_t p2 = vqrshrun_n_s16(row2, 1);2857
uint8x8_t p3 = vqrshrun_n_s16(row3, 1);2858
uint8x8_t p4 = vqrshrun_n_s16(row4, 1);2859
uint8x8_t p5 = vqrshrun_n_s16(row5, 1);2860
uint8x8_t p6 = vqrshrun_n_s16(row6, 1);2861
uint8x8_t p7 = vqrshrun_n_s16(row7, 1);2863
// again, these can translate into one instruction, but often don't.2864
#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }2865
#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }2866
#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }2868
// sadly can't use interleaved stores here since we only write2869
// 8 bytes to each scan line!2871
// 8x8 8-bit transpose pass 12872
dct_trn8_8(p0, p1);2873
dct_trn8_8(p2, p3);2874
dct_trn8_8(p4, p5);2875
dct_trn8_8(p6, p7);2877
// pass 22878
dct_trn8_16(p0, p2);2879
dct_trn8_16(p1, p3);2880
dct_trn8_16(p4, p6);2881
dct_trn8_16(p5, p7);2883
// pass 32884
dct_trn8_32(p0, p4);2885
dct_trn8_32(p1, p5);2886
dct_trn8_32(p2, p6);2887
dct_trn8_32(p3, p7);2889
// store2890
vst1_u8(out, p0); out += out_stride;2891
vst1_u8(out, p1); out += out_stride;2892
vst1_u8(out, p2); out += out_stride;2893
vst1_u8(out, p3); out += out_stride;2894
vst1_u8(out, p4); out += out_stride;2895
vst1_u8(out, p5); out += out_stride;2896
vst1_u8(out, p6); out += out_stride;2897
vst1_u8(out, p7);2899
#undef dct_trn8_82900
#undef dct_trn8_162901
#undef dct_trn8_322902
}2904
#undef dct_long_mul2905
#undef dct_long_mac2906
#undef dct_widen2907
#undef dct_wadd2908
#undef dct_wsub2909
#undef dct_bfly32o2910
#undef dct_pass2911
}2913
#endif // STBI_NEON2915
#define STBI__MARKER_none 0xff2916
// if there's a pending marker from the entropy stream, return that2917
// otherwise, fetch from the stream and get a marker. if there's no2918
// marker, return 0xff, which is never a valid marker value2919
static stbi_uc stbi__get_marker(stbi__jpeg *j)2920
{2921
stbi_uc x;2922
if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }2923
x = stbi__get8(j->s);2924
if (x != 0xff) return STBI__MARKER_none;2925
while (x == 0xff)2926
x = stbi__get8(j->s); // consume repeated 0xff fill bytes2927
return x;2928
}2930
// in each scan, we'll have scan_n components, and the order2931
// of the components is specified by order[]2932
#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)2934
// after a restart interval, stbi__jpeg_reset the entropy decoder and2935
// the dc prediction2936
static void stbi__jpeg_reset(stbi__jpeg *j)2937
{2938
j->code_bits = 0;2939
j->code_buffer = 0;2940
j->nomore = 0;2941
j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;2942
j->marker = STBI__MARKER_none;2943
j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;2944
j->eob_run = 0;2945
// no more than 1<<31 MCUs if no restart_interal? that's plenty safe,2946
// since we don't even allow 1<<30 pixels2947
}2949
static int stbi__parse_entropy_coded_data(stbi__jpeg *z)2950
{2951
stbi__jpeg_reset(z);2952
if (!z->progressive) {2953
if (z->scan_n == 1) {2954
int i,j;2955
STBI_SIMD_ALIGN(short, data[64]);2956
int n = z->order[0];2957
// non-interleaved data, we just need to process one block at a time,2958
// in trivial scanline order2959
// number of blocks to do just depends on how many actual "pixels" this2960
// component has, independent of interleaved MCU blocking and such2961
int w = (z->img_comp[n].x+7) >> 3;2962
int h = (z->img_comp[n].y+7) >> 3;2963
for (j=0; j < h; ++j) {2964
for (i=0; i < w; ++i) {2965
int ha = z->img_comp[n].ha;2966
if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;2967
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);2968
// every data block is an MCU, so countdown the restart interval2969
if (--z->todo <= 0) {2970
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);2971
// if it's NOT a restart, then just bail, so we get corrupt data2972
// rather than no data2973
if (!STBI__RESTART(z->marker)) return 1;2974
stbi__jpeg_reset(z);2975
}2976
}2977
}2978
return 1;2979
} else { // interleaved2980
int i,j,k,x,y;2981
STBI_SIMD_ALIGN(short, data[64]);2982
for (j=0; j < z->img_mcu_y; ++j) {2983
for (i=0; i < z->img_mcu_x; ++i) {2984
// scan an interleaved mcu... process scan_n components in order2985
for (k=0; k < z->scan_n; ++k) {2986
int n = z->order[k];2987
// scan out an mcu's worth of this component; that's just determined2988
// by the basic H and V specified for the component2989
for (y=0; y < z->img_comp[n].v; ++y) {2990
for (x=0; x < z->img_comp[n].h; ++x) {2991
int x2 = (i*z->img_comp[n].h + x)*8;2992
int y2 = (j*z->img_comp[n].v + y)*8;2993
int ha = z->img_comp[n].ha;2994
if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;2995
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);2996
}2997
}2998
}2999
// after all interleaved components, that's an interleaved MCU,3000
// so now count down the restart interval3001
if (--z->todo <= 0) {3002
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);3003
if (!STBI__RESTART(z->marker)) return 1;3004
stbi__jpeg_reset(z);3005
}3006
}3007
}3008
return 1;3009
}3010
} else {3011
if (z->scan_n == 1) {3012
int i,j;3013
int n = z->order[0];3014
// non-interleaved data, we just need to process one block at a time,3015
// in trivial scanline order3016
// number of blocks to do just depends on how many actual "pixels" this3017
// component has, independent of interleaved MCU blocking and such3018
int w = (z->img_comp[n].x+7) >> 3;3019
int h = (z->img_comp[n].y+7) >> 3;3020
for (j=0; j < h; ++j) {3021
for (i=0; i < w; ++i) {3022
short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);3023
if (z->spec_start == 0) {3024
if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))3025
return 0;3026
} else {3027
int ha = z->img_comp[n].ha;3028
if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))3029
return 0;3030
}3031
// every data block is an MCU, so countdown the restart interval3032
if (--z->todo <= 0) {3033
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);3034
if (!STBI__RESTART(z->marker)) return 1;3035
stbi__jpeg_reset(z);3036
}3037
}3038
}3039
return 1;3040
} else { // interleaved3041
int i,j,k,x,y;3042
for (j=0; j < z->img_mcu_y; ++j) {3043
for (i=0; i < z->img_mcu_x; ++i) {3044
// scan an interleaved mcu... process scan_n components in order3045
for (k=0; k < z->scan_n; ++k) {3046
int n = z->order[k];3047
// scan out an mcu's worth of this component; that's just determined3048
// by the basic H and V specified for the component3049
for (y=0; y < z->img_comp[n].v; ++y) {3050
for (x=0; x < z->img_comp[n].h; ++x) {3051
int x2 = (i*z->img_comp[n].h + x);3052
int y2 = (j*z->img_comp[n].v + y);3053
short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);3054
if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))3055
return 0;3056
}3057
}3058
}3059
// after all interleaved components, that's an interleaved MCU,3060
// so now count down the restart interval3061
if (--z->todo <= 0) {3062
if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);3063
if (!STBI__RESTART(z->marker)) return 1;3064
stbi__jpeg_reset(z);3065
}3066
}3067
}3068
return 1;3069
}3070
}3071
}3073
static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)3074
{3075
int i;3076
for (i=0; i < 64; ++i)3077
data[i] *= dequant[i];3078
}3080
static void stbi__jpeg_finish(stbi__jpeg *z)3081
{3082
if (z->progressive) {3083
// dequantize and idct the data3084
int i,j,n;3085
for (n=0; n < z->s->img_n; ++n) {3086
int w = (z->img_comp[n].x+7) >> 3;3087
int h = (z->img_comp[n].y+7) >> 3;3088
for (j=0; j < h; ++j) {3089
for (i=0; i < w; ++i) {3090
short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);3091
stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);3092
z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);3093
}3094
}3095
}3096
}3097
}3099
static int stbi__process_marker(stbi__jpeg *z, int m)3100
{3101
int L;3102
switch (m) {3103
case STBI__MARKER_none: // no marker found3104
return stbi__err("expected marker","Corrupt JPEG");3106
case 0xDD: // DRI - specify restart interval3107
if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");3108
z->restart_interval = stbi__get16be(z->s);3109
return 1;3111
case 0xDB: // DQT - define quantization table3112
L = stbi__get16be(z->s)-2;3113
while (L > 0) {3114
int q = stbi__get8(z->s);3115
int p = q >> 4, sixteen = (p != 0);3116
int t = q & 15,i;3117
if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");3118
if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");3120
for (i=0; i < 64; ++i)3121
z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));3122
L -= (sixteen ? 129 : 65);3123
}3124
return L==0;3126
case 0xC4: // DHT - define huffman table3127
L = stbi__get16be(z->s)-2;3128
while (L > 0) {3129
stbi_uc *v;3130
int sizes[16],i,n=0;3131
int q = stbi__get8(z->s);3132
int tc = q >> 4;3133
int th = q & 15;3134
if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");3135
for (i=0; i < 16; ++i) {3136
sizes[i] = stbi__get8(z->s);3137
n += sizes[i];3138
}3139
if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!3140
L -= 17;3141
if (tc == 0) {3142
if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;3143
v = z->huff_dc[th].values;3144
} else {3145
if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;3146
v = z->huff_ac[th].values;3147
}3148
for (i=0; i < n; ++i)3149
v[i] = stbi__get8(z->s);3150
if (tc != 0)3151
stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);3152
L -= n;3153
}3154
return L==0;3155
}3157
// check for comment block or APP blocks3158
if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {3159
L = stbi__get16be(z->s);3160
if (L < 2) {3161
if (m == 0xFE)3162
return stbi__err("bad COM len","Corrupt JPEG");3163
else3164
return stbi__err("bad APP len","Corrupt JPEG");3165
}3166
L -= 2;3168
if (m == 0xE0 && L >= 5) { // JFIF APP0 segment3169
static const unsigned char tag[5] = {'J','F','I','F','\0'};3170
int ok = 1;3171
int i;3172
for (i=0; i < 5; ++i)3173
if (stbi__get8(z->s) != tag[i])3174
ok = 0;3175
L -= 5;3176
if (ok)3177
z->jfif = 1;3178
} else if (m == 0xEE && L >= 12) { // Adobe APP14 segment3179
static const unsigned char tag[6] = {'A','d','o','b','e','\0'};3180
int ok = 1;3181
int i;3182
for (i=0; i < 6; ++i)3183
if (stbi__get8(z->s) != tag[i])3184
ok = 0;3185
L -= 6;3186
if (ok) {3187
stbi__get8(z->s); // version3188
stbi__get16be(z->s); // flags03189
stbi__get16be(z->s); // flags13190
z->app14_color_transform = stbi__get8(z->s); // color transform3191
L -= 6;3192
}3193
}3195
stbi__skip(z->s, L);3196
return 1;3197
}3199
return stbi__err("unknown marker","Corrupt JPEG");3200
}3202
// after we see SOS3203
static int stbi__process_scan_header(stbi__jpeg *z)3204
{3205
int i;3206
int Ls = stbi__get16be(z->s);3207
z->scan_n = stbi__get8(z->s);3208
if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");3209
if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");3210
for (i=0; i < z->scan_n; ++i) {3211
int id = stbi__get8(z->s), which;3212
int q = stbi__get8(z->s);3213
for (which = 0; which < z->s->img_n; ++which)3214
if (z->img_comp[which].id == id)3215
break;3216
if (which == z->s->img_n) return 0; // no match3217
z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");3218
z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");3219
z->order[i] = which;3220
}3222
{3223
int aa;3224
z->spec_start = stbi__get8(z->s);3225
z->spec_end = stbi__get8(z->s); // should be 63, but might be 03226
aa = stbi__get8(z->s);3227
z->succ_high = (aa >> 4);3228
z->succ_low = (aa & 15);3229
if (z->progressive) {3230
if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)3231
return stbi__err("bad SOS", "Corrupt JPEG");3232
} else {3233
if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");3234
if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");3235
z->spec_end = 63;3236
}3237
}3239
return 1;3240
}3242
static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)3243
{3244
int i;3245
for (i=0; i < ncomp; ++i) {3246
if (z->img_comp[i].raw_data) {3247
STBI_FREE(z->img_comp[i].raw_data);3248
z->img_comp[i].raw_data = NULL;3249
z->img_comp[i].data = NULL;3250
}3251
if (z->img_comp[i].raw_coeff) {3252
STBI_FREE(z->img_comp[i].raw_coeff);3253
z->img_comp[i].raw_coeff = 0;3254
z->img_comp[i].coeff = 0;3255
}3256
if (z->img_comp[i].linebuf) {3257
STBI_FREE(z->img_comp[i].linebuf);3258
z->img_comp[i].linebuf = NULL;3259
}3260
}3261
return why;3262
}3264
static int stbi__process_frame_header(stbi__jpeg *z, int scan)3265
{3266
stbi__context *s = z->s;3267
int Lf,p,i,q, h_max=1,v_max=1,c;3268
Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG3269
p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline3270
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 IJG3271
s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires3272
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");3273
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");3274
c = stbi__get8(s);3275
if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");3276
s->img_n = c;3277
for (i=0; i < c; ++i) {3278
z->img_comp[i].data = NULL;3279
z->img_comp[i].linebuf = NULL;3280
}3282
if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");3284
z->rgb = 0;3285
for (i=0; i < s->img_n; ++i) {3286
static const unsigned char rgb[3] = { 'R', 'G', 'B' };3287
z->img_comp[i].id = stbi__get8(s);3288
if (s->img_n == 3 && z->img_comp[i].id == rgb[i])3289
++z->rgb;3290
q = stbi__get8(s);3291
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");3292
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");3293
z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");3294
}3296
if (scan != STBI__SCAN_load) return 1;3298
if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");3300
for (i=0; i < s->img_n; ++i) {3301
if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;3302
if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;3303
}3305
// check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios3306
// and I've never seen a non-corrupted JPEG file actually use them3307
for (i=0; i < s->img_n; ++i) {3308
if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");3309
if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");3310
}3312
// compute interleaved mcu info3313
z->img_h_max = h_max;3314
z->img_v_max = v_max;3315
z->img_mcu_w = h_max * 8;3316
z->img_mcu_h = v_max * 8;3317
// these sizes can't be more than 17 bits3318
z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;3319
z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;3321
for (i=0; i < s->img_n; ++i) {3322
// number of effective pixels (e.g. for non-interleaved MCU)3323
z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;3324
z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;3325
// to simplify generation, we'll allocate enough memory to decode3326
// the bogus oversized data from using interleaved MCUs and their3327
// big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't3328
// discard the extra data until colorspace conversion3329
//3330
// img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)3331
// so these muls can't overflow with 32-bit ints (which we require)3332
z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;3333
z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;3334
z->img_comp[i].coeff = 0;3335
z->img_comp[i].raw_coeff = 0;3336
z->img_comp[i].linebuf = NULL;3337
z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);3338
if (z->img_comp[i].raw_data == NULL)3339
return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));3340
// align blocks for idct using mmx/sse3341
z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);3342
if (z->progressive) {3343
// w2, h2 are multiples of 8 (see above)3344
z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;3345
z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;3346
z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);3347
if (z->img_comp[i].raw_coeff == NULL)3348
return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));3349
z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);3350
}3351
}3353
return 1;3354
}3356
// use comparisons since in some cases we handle more than one case (e.g. SOF)3357
#define stbi__DNL(x) ((x) == 0xdc)3358
#define stbi__SOI(x) ((x) == 0xd8)3359
#define stbi__EOI(x) ((x) == 0xd9)3360
#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)3361
#define stbi__SOS(x) ((x) == 0xda)3363
#define stbi__SOF_progressive(x) ((x) == 0xc2)3365
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)3366
{3367
int m;3368
z->jfif = 0;3369
z->app14_color_transform = -1; // valid values are 0,1,23370
z->marker = STBI__MARKER_none; // initialize cached marker to empty3371
m = stbi__get_marker(z);3372
if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");3373
if (scan == STBI__SCAN_type) return 1;3374
m = stbi__get_marker(z);3375
while (!stbi__SOF(m)) {3376
if (!stbi__process_marker(z,m)) return 0;3377
m = stbi__get_marker(z);3378
while (m == STBI__MARKER_none) {3379
// some files have extra padding after their blocks, so ok, we'll scan3380
if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");3381
m = stbi__get_marker(z);3382
}3383
}3384
z->progressive = stbi__SOF_progressive(m);3385
if (!stbi__process_frame_header(z, scan)) return 0;3386
return 1;3387
}3389
static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)3390
{3391
// some JPEGs have junk at end, skip over it but if we find what looks3392
// like a valid marker, resume there3393
while (!stbi__at_eof(j->s)) {3394
stbi_uc x = stbi__get8(j->s);3395
while (x == 0xff) { // might be a marker3396
if (stbi__at_eof(j->s)) return STBI__MARKER_none;3397
x = stbi__get8(j->s);3398
if (x != 0x00 && x != 0xff) {3399
// not a stuffed zero or lead-in to another marker, looks3400
// like an actual marker, return it3401
return x;3402
}3403
// stuffed zero has x=0 now which ends the loop, meaning we go3404
// back to regular scan loop.3405
// repeated 0xff keeps trying to read the next byte of the marker.3406
}3407
}3408
return STBI__MARKER_none;3409
}3411
// decode image to YCbCr format3412
static int stbi__decode_jpeg_image(stbi__jpeg *j)3413
{3414
int m;3415
for (m = 0; m < 4; m++) {3416
j->img_comp[m].raw_data = NULL;3417
j->img_comp[m].raw_coeff = NULL;3418
}3419
j->restart_interval = 0;3420
if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;3421
m = stbi__get_marker(j);3422
while (!stbi__EOI(m)) {3423
if (stbi__SOS(m)) {3424
if (!stbi__process_scan_header(j)) return 0;3425
if (!stbi__parse_entropy_coded_data(j)) return 0;3426
if (j->marker == STBI__MARKER_none ) {3427
j->marker = stbi__skip_jpeg_junk_at_end(j);3428
// if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 03429
}3430
m = stbi__get_marker(j);3431
if (STBI__RESTART(m))3432
m = stbi__get_marker(j);3433
} else if (stbi__DNL(m)) {3434
int Ld = stbi__get16be(j->s);3435
stbi__uint32 NL = stbi__get16be(j->s);3436
if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");3437
if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");3438
m = stbi__get_marker(j);3439
} else {3440
if (!stbi__process_marker(j, m)) return 1;3441
m = stbi__get_marker(j);3442
}3443
}3444
if (j->progressive)3445
stbi__jpeg_finish(j);3446
return 1;3447
}3449
// static jfif-centered resampling (across block boundaries)3451
typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,3452
int w, int hs);3454
#define stbi__div4(x) ((stbi_uc) ((x) >> 2))3456
static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3457
{3458
STBI_NOTUSED(out);3459
STBI_NOTUSED(in_far);3460
STBI_NOTUSED(w);3461
STBI_NOTUSED(hs);3462
return in_near;3463
}3465
static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3466
{3467
// need to generate two samples vertically for every one in input3468
int i;3469
STBI_NOTUSED(hs);3470
for (i=0; i < w; ++i)3471
out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);3472
return out;3473
}3475
static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3476
{3477
// need to generate two samples horizontally for every one in input3478
int i;3479
stbi_uc *input = in_near;3481
if (w == 1) {3482
// if only one sample, can't do any interpolation3483
out[0] = out[1] = input[0];3484
return out;3485
}3487
out[0] = input[0];3488
out[1] = stbi__div4(input[0]*3 + input[1] + 2);3489
for (i=1; i < w-1; ++i) {3490
int n = 3*input[i]+2;3491
out[i*2+0] = stbi__div4(n+input[i-1]);3492
out[i*2+1] = stbi__div4(n+input[i+1]);3493
}3494
out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);3495
out[i*2+1] = input[w-1];3497
STBI_NOTUSED(in_far);3498
STBI_NOTUSED(hs);3500
return out;3501
}3503
#define stbi__div16(x) ((stbi_uc) ((x) >> 4))3505
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3506
{3507
// need to generate 2x2 samples for every one in input3508
int i,t0,t1;3509
if (w == 1) {3510
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);3511
return out;3512
}3514
t1 = 3*in_near[0] + in_far[0];3515
out[0] = stbi__div4(t1+2);3516
for (i=1; i < w; ++i) {3517
t0 = t1;3518
t1 = 3*in_near[i]+in_far[i];3519
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);3520
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);3521
}3522
out[w*2-1] = stbi__div4(t1+2);3524
STBI_NOTUSED(hs);3526
return out;3527
}3529
#if defined(STBI_SSE2) || defined(STBI_NEON)3530
static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3531
{3532
// need to generate 2x2 samples for every one in input3533
int i=0,t0,t1;3535
if (w == 1) {3536
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);3537
return out;3538
}3540
t1 = 3*in_near[0] + in_far[0];3541
// process groups of 8 pixels for as long as we can.3542
// note we can't handle the last pixel in a row in this loop3543
// because we need to handle the filter boundary conditions.3544
for (; i < ((w-1) & ~7); i += 8) {3545
#if defined(STBI_SSE2)3546
// load and perform the vertical filtering pass3547
// this uses 3*x + y = 4*x + (y - x)3548
__m128i zero = _mm_setzero_si128();3549
__m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));3550
__m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));3551
__m128i farw = _mm_unpacklo_epi8(farb, zero);3552
__m128i nearw = _mm_unpacklo_epi8(nearb, zero);3553
__m128i diff = _mm_sub_epi16(farw, nearw);3554
__m128i nears = _mm_slli_epi16(nearw, 2);3555
__m128i curr = _mm_add_epi16(nears, diff); // current row3557
// horizontal filter works the same based on shifted vers of current3558
// row. "prev" is current row shifted right by 1 pixel; we need to3559
// insert the previous pixel value (from t1).3560
// "next" is current row shifted left by 1 pixel, with first pixel3561
// of next block of 8 pixels added in.3562
__m128i prv0 = _mm_slli_si128(curr, 2);3563
__m128i nxt0 = _mm_srli_si128(curr, 2);3564
__m128i prev = _mm_insert_epi16(prv0, t1, 0);3565
__m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);3567
// horizontal filter, polyphase implementation since it's convenient:3568
// even pixels = 3*cur + prev = cur*4 + (prev - cur)3569
// odd pixels = 3*cur + next = cur*4 + (next - cur)3570
// note the shared term.3571
__m128i bias = _mm_set1_epi16(8);3572
__m128i curs = _mm_slli_epi16(curr, 2);3573
__m128i prvd = _mm_sub_epi16(prev, curr);3574
__m128i nxtd = _mm_sub_epi16(next, curr);3575
__m128i curb = _mm_add_epi16(curs, bias);3576
__m128i even = _mm_add_epi16(prvd, curb);3577
__m128i odd = _mm_add_epi16(nxtd, curb);3579
// interleave even and odd pixels, then undo scaling.3580
__m128i int0 = _mm_unpacklo_epi16(even, odd);3581
__m128i int1 = _mm_unpackhi_epi16(even, odd);3582
__m128i de0 = _mm_srli_epi16(int0, 4);3583
__m128i de1 = _mm_srli_epi16(int1, 4);3585
// pack and write output3586
__m128i outv = _mm_packus_epi16(de0, de1);3587
_mm_storeu_si128((__m128i *) (out + i*2), outv);3588
#elif defined(STBI_NEON)3589
// load and perform the vertical filtering pass3590
// this uses 3*x + y = 4*x + (y - x)3591
uint8x8_t farb = vld1_u8(in_far + i);3592
uint8x8_t nearb = vld1_u8(in_near + i);3593
int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));3594
int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));3595
int16x8_t curr = vaddq_s16(nears, diff); // current row3597
// horizontal filter works the same based on shifted vers of current3598
// row. "prev" is current row shifted right by 1 pixel; we need to3599
// insert the previous pixel value (from t1).3600
// "next" is current row shifted left by 1 pixel, with first pixel3601
// of next block of 8 pixels added in.3602
int16x8_t prv0 = vextq_s16(curr, curr, 7);3603
int16x8_t nxt0 = vextq_s16(curr, curr, 1);3604
int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);3605
int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);3607
// horizontal filter, polyphase implementation since it's convenient:3608
// even pixels = 3*cur + prev = cur*4 + (prev - cur)3609
// odd pixels = 3*cur + next = cur*4 + (next - cur)3610
// note the shared term.3611
int16x8_t curs = vshlq_n_s16(curr, 2);3612
int16x8_t prvd = vsubq_s16(prev, curr);3613
int16x8_t nxtd = vsubq_s16(next, curr);3614
int16x8_t even = vaddq_s16(curs, prvd);3615
int16x8_t odd = vaddq_s16(curs, nxtd);3617
// undo scaling and round, then store with even/odd phases interleaved3618
uint8x8x2_t o;3619
o.val[0] = vqrshrun_n_s16(even, 4);3620
o.val[1] = vqrshrun_n_s16(odd, 4);3621
vst2_u8(out + i*2, o);3622
#endif3624
// "previous" value for next iter3625
t1 = 3*in_near[i+7] + in_far[i+7];3626
}3628
t0 = t1;3629
t1 = 3*in_near[i] + in_far[i];3630
out[i*2] = stbi__div16(3*t1 + t0 + 8);3632
for (++i; i < w; ++i) {3633
t0 = t1;3634
t1 = 3*in_near[i]+in_far[i];3635
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);3636
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);3637
}3638
out[w*2-1] = stbi__div4(t1+2);3640
STBI_NOTUSED(hs);3642
return out;3643
}3644
#endif3646
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)3647
{3648
// resample with nearest-neighbor3649
int i,j;3650
STBI_NOTUSED(in_far);3651
for (i=0; i < w; ++i)3652
for (j=0; j < hs; ++j)3653
out[i*hs+j] = in_near[i];3654
return out;3655
}3657
// this is a reduced-precision calculation of YCbCr-to-RGB introduced3658
// to make sure the code produces the same results in both SIMD and scalar3659
#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)3660
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)3661
{3662
int i;3663
for (i=0; i < count; ++i) {3664
int y_fixed = (y[i] << 20) + (1<<19); // rounding3665
int r,g,b;3666
int cr = pcr[i] - 128;3667
int cb = pcb[i] - 128;3668
r = y_fixed + cr* stbi__float2fixed(1.40200f);3669
g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);3670
b = y_fixed + cb* stbi__float2fixed(1.77200f);3671
r >>= 20;3672
g >>= 20;3673
b >>= 20;3674
if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }3675
if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }3676
if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }3677
out[0] = (stbi_uc)r;3678
out[1] = (stbi_uc)g;3679
out[2] = (stbi_uc)b;3680
out[3] = 255;3681
out += step;3682
}3683
}3685
#if defined(STBI_SSE2) || defined(STBI_NEON)3686
static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)3687
{3688
int i = 0;3690
#ifdef STBI_SSE23691
// step == 3 is pretty ugly on the final interleave, and i'm not convinced3692
// it's useful in practice (you wouldn't use it for textures, for example).3693
// so just accelerate step == 4 case.3694
if (step == 4) {3695
// this is a fairly straightforward implementation and not super-optimized.3696
__m128i signflip = _mm_set1_epi8(-0x80);3697
__m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));3698
__m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));3699
__m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));3700
__m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));3701
__m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);3702
__m128i xw = _mm_set1_epi16(255); // alpha channel3704
for (; i+7 < count; i += 8) {3705
// load3706
__m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));3707
__m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));3708
__m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));3709
__m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -1283710
__m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -1283712
// unpack to short (and left-shift cr, cb by 8)3713
__m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);3714
__m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);3715
__m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);3717
// color transform3718
__m128i yws = _mm_srli_epi16(yw, 4);3719
__m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);3720
__m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);3721
__m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);3722
__m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);3723
__m128i rws = _mm_add_epi16(cr0, yws);3724
__m128i gwt = _mm_add_epi16(cb0, yws);3725
__m128i bws = _mm_add_epi16(yws, cb1);3726
__m128i gws = _mm_add_epi16(gwt, cr1);3728
// descale3729
__m128i rw = _mm_srai_epi16(rws, 4);3730
__m128i bw = _mm_srai_epi16(bws, 4);3731
__m128i gw = _mm_srai_epi16(gws, 4);3733
// back to byte, set up for transpose3734
__m128i brb = _mm_packus_epi16(rw, bw);3735
__m128i gxb = _mm_packus_epi16(gw, xw);3737
// transpose to interleave channels3738
__m128i t0 = _mm_unpacklo_epi8(brb, gxb);3739
__m128i t1 = _mm_unpackhi_epi8(brb, gxb);3740
__m128i o0 = _mm_unpacklo_epi16(t0, t1);3741
__m128i o1 = _mm_unpackhi_epi16(t0, t1);3743
// store3744
_mm_storeu_si128((__m128i *) (out + 0), o0);3745
_mm_storeu_si128((__m128i *) (out + 16), o1);3746
out += 32;3747
}3748
}3749
#endif3751
#ifdef STBI_NEON3752
// in this version, step=3 support would be easy to add. but is there demand?3753
if (step == 4) {3754
// this is a fairly straightforward implementation and not super-optimized.3755
uint8x8_t signflip = vdup_n_u8(0x80);3756
int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));3757
int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));3758
int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));3759
int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));3761
for (; i+7 < count; i += 8) {3762
// load3763
uint8x8_t y_bytes = vld1_u8(y + i);3764
uint8x8_t cr_bytes = vld1_u8(pcr + i);3765
uint8x8_t cb_bytes = vld1_u8(pcb + i);3766
int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));3767
int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));3769
// expand to s163770
int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));3771
int16x8_t crw = vshll_n_s8(cr_biased, 7);3772
int16x8_t cbw = vshll_n_s8(cb_biased, 7);3774
// color transform3775
int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);3776
int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);3777
int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);3778
int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);3779
int16x8_t rws = vaddq_s16(yws, cr0);3780
int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);3781
int16x8_t bws = vaddq_s16(yws, cb1);3783
// undo scaling, round, convert to byte3784
uint8x8x4_t o;3785
o.val[0] = vqrshrun_n_s16(rws, 4);3786
o.val[1] = vqrshrun_n_s16(gws, 4);3787
o.val[2] = vqrshrun_n_s16(bws, 4);3788
o.val[3] = vdup_n_u8(255);3790
// store, interleaving r/g/b/a3791
vst4_u8(out, o);3792
out += 8*4;3793
}3794
}3795
#endif3797
for (; i < count; ++i) {3798
int y_fixed = (y[i] << 20) + (1<<19); // rounding3799
int r,g,b;3800
int cr = pcr[i] - 128;3801
int cb = pcb[i] - 128;3802
r = y_fixed + cr* stbi__float2fixed(1.40200f);3803
g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);3804
b = y_fixed + cb* stbi__float2fixed(1.77200f);3805
r >>= 20;3806
g >>= 20;3807
b >>= 20;3808
if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }3809
if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }3810
if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }3811
out[0] = (stbi_uc)r;3812
out[1] = (stbi_uc)g;3813
out[2] = (stbi_uc)b;3814
out[3] = 255;3815
out += step;3816
}3817
}3818
#endif3820
// set up the kernels3821
static void stbi__setup_jpeg(stbi__jpeg *j)3822
{3823
j->idct_block_kernel = stbi__idct_block;3824
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;3825
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;3827
#ifdef STBI_SSE23828
if (stbi__sse2_available()) {3829
j->idct_block_kernel = stbi__idct_simd;3830
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;3831
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;3832
}3833
#endif3835
#ifdef STBI_NEON3836
j->idct_block_kernel = stbi__idct_simd;3837
j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;3838
j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;3839
#endif3840
}3842
// clean up the temporary component buffers3843
static void stbi__cleanup_jpeg(stbi__jpeg *j)3844
{3845
stbi__free_jpeg_components(j, j->s->img_n, 0);3846
}3848
typedef struct3849
{3850
resample_row_func resample;3851
stbi_uc *line0,*line1;3852
int hs,vs; // expansion factor in each axis3853
int w_lores; // horizontal pixels pre-expansion3854
int ystep; // how far through vertical expansion we are3855
int ypos; // which pre-expansion row we're on3856
} stbi__resample;3858
// fast 0..255 * 0..255 => 0..255 rounded multiplication3859
static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)3860
{3861
unsigned int t = x*y + 128;3862
return (stbi_uc) ((t + (t >>8)) >> 8);3863
}3865
static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)3866
{3867
int n, decode_n, is_rgb;3868
z->s->img_n = 0; // make stbi__cleanup_jpeg safe3870
// validate req_comp3871
if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");3873
// load a jpeg image from whichever source, but leave in YCbCr format3874
if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }3876
// determine actual number of components to generate3877
n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;3879
is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));3881
if (z->s->img_n == 3 && n < 3 && !is_rgb)3882
decode_n = 1;3883
else3884
decode_n = z->s->img_n;3886
// nothing to do if no components requested; check this now to avoid3887
// accessing uninitialized coutput[0] later3888
if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }3890
// resample and color-convert3891
{3892
int k;3893
unsigned int i,j;3894
stbi_uc *output;3895
stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };3897
stbi__resample res_comp[4];3899
for (k=0; k < decode_n; ++k) {3900
stbi__resample *r = &res_comp[k];3902
// allocate line buffer big enough for upsampling off the edges3903
// with upsample factor of 43904
z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);3905
if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }3907
r->hs = z->img_h_max / z->img_comp[k].h;3908
r->vs = z->img_v_max / z->img_comp[k].v;3909
r->ystep = r->vs >> 1;3910
r->w_lores = (z->s->img_x + r->hs-1) / r->hs;3911
r->ypos = 0;3912
r->line0 = r->line1 = z->img_comp[k].data;3914
if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;3915
else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;3916
else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;3917
else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;3918
else r->resample = stbi__resample_row_generic;3919
}3921
// can't error after this so, this is safe3922
output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);3923
if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }3925
// now go ahead and resample3926
for (j=0; j < z->s->img_y; ++j) {3927
stbi_uc *out = output + n * z->s->img_x * j;3928
for (k=0; k < decode_n; ++k) {3929
stbi__resample *r = &res_comp[k];3930
int y_bot = r->ystep >= (r->vs >> 1);3931
coutput[k] = r->resample(z->img_comp[k].linebuf,3932
y_bot ? r->line1 : r->line0,3933
y_bot ? r->line0 : r->line1,3934
r->w_lores, r->hs);3935
if (++r->ystep >= r->vs) {3936
r->ystep = 0;3937
r->line0 = r->line1;3938
if (++r->ypos < z->img_comp[k].y)3939
r->line1 += z->img_comp[k].w2;3940
}3941
}3942
if (n >= 3) {3943
stbi_uc *y = coutput[0];3944
if (z->s->img_n == 3) {3945
if (is_rgb) {3946
for (i=0; i < z->s->img_x; ++i) {3947
out[0] = y[i];3948
out[1] = coutput[1][i];3949
out[2] = coutput[2][i];3950
out[3] = 255;3951
out += n;3952
}3953
} else {3954
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);3955
}3956
} else if (z->s->img_n == 4) {3957
if (z->app14_color_transform == 0) { // CMYK3958
for (i=0; i < z->s->img_x; ++i) {3959
stbi_uc m = coutput[3][i];3960
out[0] = stbi__blinn_8x8(coutput[0][i], m);3961
out[1] = stbi__blinn_8x8(coutput[1][i], m);3962
out[2] = stbi__blinn_8x8(coutput[2][i], m);3963
out[3] = 255;3964
out += n;3965
}3966
} else if (z->app14_color_transform == 2) { // YCCK3967
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);3968
for (i=0; i < z->s->img_x; ++i) {3969
stbi_uc m = coutput[3][i];3970
out[0] = stbi__blinn_8x8(255 - out[0], m);3971
out[1] = stbi__blinn_8x8(255 - out[1], m);3972
out[2] = stbi__blinn_8x8(255 - out[2], m);3973
out += n;3974
}3975
} else { // YCbCr + alpha? Ignore the fourth channel for now3976
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);3977
}3978
} else3979
for (i=0; i < z->s->img_x; ++i) {3980
out[0] = out[1] = out[2] = y[i];3981
out[3] = 255; // not used if n==33982
out += n;3983
}3984
} else {3985
if (is_rgb) {3986
if (n == 1)3987
for (i=0; i < z->s->img_x; ++i)3988
*out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);3989
else {3990
for (i=0; i < z->s->img_x; ++i, out += 2) {3991
out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);3992
out[1] = 255;3993
}3994
}3995
} else if (z->s->img_n == 4 && z->app14_color_transform == 0) {3996
for (i=0; i < z->s->img_x; ++i) {3997
stbi_uc m = coutput[3][i];3998
stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);3999
stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);4000
stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);4001
out[0] = stbi__compute_y(r, g, b);4002
out[1] = 255;4003
out += n;4004
}4005
} else if (z->s->img_n == 4 && z->app14_color_transform == 2) {4006
for (i=0; i < z->s->img_x; ++i) {4007
out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);4008
out[1] = 255;4009
out += n;4010
}4011
} else {4012
stbi_uc *y = coutput[0];4013
if (n == 1)4014
for (i=0; i < z->s->img_x; ++i) out[i] = y[i];4015
else4016
for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }4017
}4018
}4019
}4020
stbi__cleanup_jpeg(z);4021
*out_x = z->s->img_x;4022
*out_y = z->s->img_y;4023
if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output4024
return output;4025
}4026
}4028
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)4029
{4030
unsigned char* result;4031
stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));4032
if (!j) return stbi__errpuc("outofmem", "Out of memory");4033
memset(j, 0, sizeof(stbi__jpeg));4034
STBI_NOTUSED(ri);4035
j->s = s;4036
stbi__setup_jpeg(j);4037
result = load_jpeg_image(j, x,y,comp,req_comp);4038
STBI_FREE(j);4039
return result;4040
}4042
static int stbi__jpeg_test(stbi__context *s)4043
{4044
int r;4045
stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));4046
if (!j) return stbi__err("outofmem", "Out of memory");4047
memset(j, 0, sizeof(stbi__jpeg));4048
j->s = s;4049
stbi__setup_jpeg(j);4050
r = stbi__decode_jpeg_header(j, STBI__SCAN_type);4051
stbi__rewind(s);4052
STBI_FREE(j);4053
return r;4054
}4056
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)4057
{4058
if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {4059
stbi__rewind( j->s );4060
return 0;4061
}4062
if (x) *x = j->s->img_x;4063
if (y) *y = j->s->img_y;4064
if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;4065
return 1;4066
}4068
static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)4069
{4070
int result;4071
stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));4072
if (!j) return stbi__err("outofmem", "Out of memory");4073
memset(j, 0, sizeof(stbi__jpeg));4074
j->s = s;4075
result = stbi__jpeg_info_raw(j, x, y, comp);4076
STBI_FREE(j);4077
return result;4078
}4079
#endif4081
// public domain zlib decode v0.2 Sean Barrett 2006-11-184082
// simple implementation4083
// - all input must be provided in an upfront buffer4084
// - all output is written to a single output buffer (can malloc/realloc)4085
// performance4086
// - fast huffman4088
#ifndef STBI_NO_ZLIB4090
// fast-way is faster to check than jpeg huffman, but slow way is slower4091
#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables4092
#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)4093
#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet4095
// zlib-style huffman encoding4096
// (jpegs packs from left, zlib from right, so can't share code)4097
typedef struct4098
{4099
stbi__uint16 fast[1 << STBI__ZFAST_BITS];4100
stbi__uint16 firstcode[16];4101
int maxcode[17];4102
stbi__uint16 firstsymbol[16];4103
stbi_uc size[STBI__ZNSYMS];4104
stbi__uint16 value[STBI__ZNSYMS];4105
} stbi__zhuffman;4107
stbi_inline static int stbi__bitreverse16(int n)4108
{4109
n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);4110
n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);4111
n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);4112
n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);4113
return n;4114
}4116
stbi_inline static int stbi__bit_reverse(int v, int bits)4117
{4118
STBI_ASSERT(bits <= 16);4119
// to bit reverse n bits, reverse 16 and shift4120
// e.g. 11 bits, bit reverse and shift away 54121
return stbi__bitreverse16(v) >> (16-bits);4122
}4124
static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)4125
{4126
int i,k=0;4127
int code, next_code[16], sizes[17];4129
// DEFLATE spec for generating codes4130
memset(sizes, 0, sizeof(sizes));4131
memset(z->fast, 0, sizeof(z->fast));4132
for (i=0; i < num; ++i)4133
++sizes[sizelist[i]];4134
sizes[0] = 0;4135
for (i=1; i < 16; ++i)4136
if (sizes[i] > (1 << i))4137
return stbi__err("bad sizes", "Corrupt PNG");4138
code = 0;4139
for (i=1; i < 16; ++i) {4140
next_code[i] = code;4141
z->firstcode[i] = (stbi__uint16) code;4142
z->firstsymbol[i] = (stbi__uint16) k;4143
code = (code + sizes[i]);4144
if (sizes[i])4145
if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");4146
z->maxcode[i] = code << (16-i); // preshift for inner loop4147
code <<= 1;4148
k += sizes[i];4149
}4150
z->maxcode[16] = 0x10000; // sentinel4151
for (i=0; i < num; ++i) {4152
int s = sizelist[i];4153
if (s) {4154
int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];4155
stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);4156
z->size [c] = (stbi_uc ) s;4157
z->value[c] = (stbi__uint16) i;4158
if (s <= STBI__ZFAST_BITS) {4159
int j = stbi__bit_reverse(next_code[s],s);4160
while (j < (1 << STBI__ZFAST_BITS)) {4161
z->fast[j] = fastv;4162
j += (1 << s);4163
}4164
}4165
++next_code[s];4166
}4167
}4168
return 1;4169
}4171
// zlib-from-memory implementation for PNG reading4172
// because PNG allows splitting the zlib stream arbitrarily,4173
// and it's annoying structurally to have PNG call ZLIB call PNG,4174
// we require PNG read all the IDATs and combine them into a single4175
// memory buffer4177
typedef struct4178
{4179
stbi_uc *zbuffer, *zbuffer_end;4180
int num_bits;4181
int hit_zeof_once;4182
stbi__uint32 code_buffer;4184
char *zout;4185
char *zout_start;4186
char *zout_end;4187
int z_expandable;4189
stbi__zhuffman z_length, z_distance;4190
} stbi__zbuf;4192
stbi_inline static int stbi__zeof(stbi__zbuf *z)4193
{4194
return (z->zbuffer >= z->zbuffer_end);4195
}4197
stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)4198
{4199
return stbi__zeof(z) ? 0 : *z->zbuffer++;4200
}4202
static void stbi__fill_bits(stbi__zbuf *z)4203
{4204
do {4205
if (z->code_buffer >= (1U << z->num_bits)) {4206
z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */4207
return;4208
}4209
z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;4210
z->num_bits += 8;4211
} while (z->num_bits <= 24);4212
}4214
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)4215
{4216
unsigned int k;4217
if (z->num_bits < n) stbi__fill_bits(z);4218
k = z->code_buffer & ((1 << n) - 1);4219
z->code_buffer >>= n;4220
z->num_bits -= n;4221
return k;4222
}4224
static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)4225
{4226
int b,s,k;4227
// not resolved by fast table, so compute it the slow way4228
// use jpeg approach, which requires MSbits at top4229
k = stbi__bit_reverse(a->code_buffer, 16);4230
for (s=STBI__ZFAST_BITS+1; ; ++s)4231
if (k < z->maxcode[s])4232
break;4233
if (s >= 16) return -1; // invalid code!4234
// code size is s, so:4235
b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];4236
if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!4237
if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.4238
a->code_buffer >>= s;4239
a->num_bits -= s;4240
return z->value[b];4241
}4243
stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)4244
{4245
int b,s;4246
if (a->num_bits < 16) {4247
if (stbi__zeof(a)) {4248
if (!a->hit_zeof_once) {4249
// This is the first time we hit eof, insert 16 extra padding btis4250
// to allow us to keep going; if we actually consume any of them4251
// though, that is invalid data. This is caught later.4252
a->hit_zeof_once = 1;4253
a->num_bits += 16; // add 16 implicit zero bits4254
} else {4255
// We already inserted our extra 16 padding bits and are again4256
// out, this stream is actually prematurely terminated.4257
return -1;4258
}4259
} else {4260
stbi__fill_bits(a);4261
}4262
}4263
b = z->fast[a->code_buffer & STBI__ZFAST_MASK];4264
if (b) {4265
s = b >> 9;4266
a->code_buffer >>= s;4267
a->num_bits -= s;4268
return b & 511;4269
}4270
return stbi__zhuffman_decode_slowpath(a, z);4271
}4273
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes4274
{4275
char *q;4276
unsigned int cur, limit, old_limit;4277
z->zout = zout;4278
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");4279
cur = (unsigned int) (z->zout - z->zout_start);4280
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);4281
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");4282
while (cur + n > limit) {4283
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");4284
limit *= 2;4285
}4286
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);4287
STBI_NOTUSED(old_limit);4288
if (q == NULL) return stbi__err("outofmem", "Out of memory");4289
z->zout_start = q;4290
z->zout = q + cur;4291
z->zout_end = q + limit;4292
return 1;4293
}4295
static const int stbi__zlength_base[31] = {4296
3,4,5,6,7,8,9,10,11,13,4297
15,17,19,23,27,31,35,43,51,59,4298
67,83,99,115,131,163,195,227,258,0,0 };4300
static const int stbi__zlength_extra[31]=4301
{ 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 };4303
static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,4304
257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};4306
static const int stbi__zdist_extra[32] =4307
{ 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};4309
static int stbi__parse_huffman_block(stbi__zbuf *a)4310
{4311
char *zout = a->zout;4312
for(;;) {4313
int z = stbi__zhuffman_decode(a, &a->z_length);4314
if (z < 256) {4315
if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes4316
if (zout >= a->zout_end) {4317
if (!stbi__zexpand(a, zout, 1)) return 0;4318
zout = a->zout;4319
}4320
*zout++ = (char) z;4321
} else {4322
stbi_uc *p;4323
int len,dist;4324
if (z == 256) {4325
a->zout = zout;4326
if (a->hit_zeof_once && a->num_bits < 16) {4327
// The first time we hit zeof, we inserted 16 extra zero bits into our bit4328
// buffer so the decoder can just do its speculative decoding. But if we4329
// actually consumed any of those bits (which is the case when num_bits < 16),4330
// the stream actually read past the end so it is malformed.4331
return stbi__err("unexpected end","Corrupt PNG");4332
}4333
return 1;4334
}4335
if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data4336
z -= 257;4337
len = stbi__zlength_base[z];4338
if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);4339
z = stbi__zhuffman_decode(a, &a->z_distance);4340
if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data4341
dist = stbi__zdist_base[z];4342
if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);4343
if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");4344
if (len > a->zout_end - zout) {4345
if (!stbi__zexpand(a, zout, len)) return 0;4346
zout = a->zout;4347
}4348
p = (stbi_uc *) (zout - dist);4349
if (dist == 1) { // run of one byte; common in images.4350
stbi_uc v = *p;4351
if (len) { do *zout++ = v; while (--len); }4352
} else {4353
if (len) { do *zout++ = *p++; while (--len); }4354
}4355
}4356
}4357
}4359
static int stbi__compute_huffman_codes(stbi__zbuf *a)4360
{4361
static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };4362
stbi__zhuffman z_codelength;4363
stbi_uc lencodes[286+32+137];//padding for maximum single op4364
stbi_uc codelength_sizes[19];4365
int i,n;4367
int hlit = stbi__zreceive(a,5) + 257;4368
int hdist = stbi__zreceive(a,5) + 1;4369
int hclen = stbi__zreceive(a,4) + 4;4370
int ntot = hlit + hdist;4372
memset(codelength_sizes, 0, sizeof(codelength_sizes));4373
for (i=0; i < hclen; ++i) {4374
int s = stbi__zreceive(a,3);4375
codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;4376
}4377
if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;4379
n = 0;4380
while (n < ntot) {4381
int c = stbi__zhuffman_decode(a, &z_codelength);4382
if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");4383
if (c < 16)4384
lencodes[n++] = (stbi_uc) c;4385
else {4386
stbi_uc fill = 0;4387
if (c == 16) {4388
c = stbi__zreceive(a,2)+3;4389
if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");4390
fill = lencodes[n-1];4391
} else if (c == 17) {4392
c = stbi__zreceive(a,3)+3;4393
} else if (c == 18) {4394
c = stbi__zreceive(a,7)+11;4395
} else {4396
return stbi__err("bad codelengths", "Corrupt PNG");4397
}4398
if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");4399
memset(lencodes+n, fill, c);4400
n += c;4401
}4402
}4403
if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");4404
if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;4405
if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;4406
return 1;4407
}4409
static int stbi__parse_uncompressed_block(stbi__zbuf *a)4410
{4411
stbi_uc header[4];4412
int len,nlen,k;4413
if (a->num_bits & 7)4414
stbi__zreceive(a, a->num_bits & 7); // discard4415
// drain the bit-packed data into header4416
k = 0;4417
while (a->num_bits > 0) {4418
header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check4419
a->code_buffer >>= 8;4420
a->num_bits -= 8;4421
}4422
if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");4423
// now fill header the normal way4424
while (k < 4)4425
header[k++] = stbi__zget8(a);4426
len = header[1] * 256 + header[0];4427
nlen = header[3] * 256 + header[2];4428
if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");4429
if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");4430
if (a->zout + len > a->zout_end)4431
if (!stbi__zexpand(a, a->zout, len)) return 0;4432
memcpy(a->zout, a->zbuffer, len);4433
a->zbuffer += len;4434
a->zout += len;4435
return 1;4436
}4438
static int stbi__parse_zlib_header(stbi__zbuf *a)4439
{4440
int cmf = stbi__zget8(a);4441
int cm = cmf & 15;4442
/* int cinfo = cmf >> 4; */4443
int flg = stbi__zget8(a);4444
if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec4445
if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec4446
if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png4447
if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png4448
// window = 1 << (8 + cinfo)... but who cares, we fully buffer output4449
return 1;4450
}4452
static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =4453
{4454
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,4455
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,4456
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,4457
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,4458
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4459
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4460
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4461
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4462
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,84463
};4464
static const stbi_uc stbi__zdefault_distance[32] =4465
{4466
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,54467
};4468
/*4469
Init algorithm:4470
{4471
int i; // use <= to match clearly with spec4472
for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;4473
for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;4474
for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;4475
for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;4477
for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;4478
}4479
*/4481
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)4482
{4483
int final, type;4484
if (parse_header)4485
if (!stbi__parse_zlib_header(a)) return 0;4486
a->num_bits = 0;4487
a->code_buffer = 0;4488
a->hit_zeof_once = 0;4489
do {4490
final = stbi__zreceive(a,1);4491
type = stbi__zreceive(a,2);4492
if (type == 0) {4493
if (!stbi__parse_uncompressed_block(a)) return 0;4494
} else if (type == 3) {4495
return 0;4496
} else {4497
if (type == 1) {4498
// use fixed code lengths4499
if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0;4500
if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;4501
} else {4502
if (!stbi__compute_huffman_codes(a)) return 0;4503
}4504
if (!stbi__parse_huffman_block(a)) return 0;4505
}4506
} while (!final);4507
return 1;4508
}4510
static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)4511
{4512
a->zout_start = obuf;4513
a->zout = obuf;4514
a->zout_end = obuf + olen;4515
a->z_expandable = exp;4517
return stbi__parse_zlib(a, parse_header);4518
}4520
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)4521
{4522
stbi__zbuf a;4523
char *p = (char *) stbi__malloc(initial_size);4524
if (p == NULL) return NULL;4525
a.zbuffer = (stbi_uc *) buffer;4526
a.zbuffer_end = (stbi_uc *) buffer + len;4527
if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {4528
if (outlen) *outlen = (int) (a.zout - a.zout_start);4529
return a.zout_start;4530
} else {4531
STBI_FREE(a.zout_start);4532
return NULL;4533
}4534
}4536
STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)4537
{4538
return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);4539
}4541
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)4542
{4543
stbi__zbuf a;4544
char *p = (char *) stbi__malloc(initial_size);4545
if (p == NULL) return NULL;4546
a.zbuffer = (stbi_uc *) buffer;4547
a.zbuffer_end = (stbi_uc *) buffer + len;4548
if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {4549
if (outlen) *outlen = (int) (a.zout - a.zout_start);4550
return a.zout_start;4551
} else {4552
STBI_FREE(a.zout_start);4553
return NULL;4554
}4555
}4557
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)4558
{4559
stbi__zbuf a;4560
a.zbuffer = (stbi_uc *) ibuffer;4561
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;4562
if (stbi__do_zlib(&a, obuffer, olen, 0, 1))4563
return (int) (a.zout - a.zout_start);4564
else4565
return -1;4566
}4568
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)4569
{4570
stbi__zbuf a;4571
char *p = (char *) stbi__malloc(16384);4572
if (p == NULL) return NULL;4573
a.zbuffer = (stbi_uc *) buffer;4574
a.zbuffer_end = (stbi_uc *) buffer+len;4575
if (stbi__do_zlib(&a, p, 16384, 1, 0)) {4576
if (outlen) *outlen = (int) (a.zout - a.zout_start);4577
return a.zout_start;4578
} else {4579
STBI_FREE(a.zout_start);4580
return NULL;4581
}4582
}4584
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)4585
{4586
stbi__zbuf a;4587
a.zbuffer = (stbi_uc *) ibuffer;4588
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;4589
if (stbi__do_zlib(&a, obuffer, olen, 0, 0))4590
return (int) (a.zout - a.zout_start);4591
else4592
return -1;4593
}4594
#endif4596
// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-184597
// simple implementation4598
// - only 8-bit samples4599
// - no CRC checking4600
// - allocates lots of intermediate memory4601
// - avoids problem of streaming data between subsystems4602
// - avoids explicit window management4603
// performance4604
// - uses stb_zlib, a PD zlib implementation with fast huffman decoding4606
#ifndef STBI_NO_PNG4607
typedef struct4608
{4609
stbi__uint32 length;4610
stbi__uint32 type;4611
} stbi__pngchunk;4613
static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)4614
{4615
stbi__pngchunk c;4616
c.length = stbi__get32be(s);4617
c.type = stbi__get32be(s);4618
return c;4619
}4621
static int stbi__check_png_header(stbi__context *s)4622
{4623
static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };4624
int i;4625
for (i=0; i < 8; ++i)4626
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");4627
return 1;4628
}4630
typedef struct4631
{4632
stbi__context *s;4633
stbi_uc *idata, *expanded, *out;4634
int depth;4635
} stbi__png;4638
enum {4639
STBI__F_none=0,4640
STBI__F_sub=1,4641
STBI__F_up=2,4642
STBI__F_avg=3,4643
STBI__F_paeth=4,4644
// synthetic filter used for first scanline to avoid needing a dummy row of 0s4645
STBI__F_avg_first4646
};4648
static stbi_uc first_row_filter[5] =4649
{4650
STBI__F_none,4651
STBI__F_sub,4652
STBI__F_none,4653
STBI__F_avg_first,4654
STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub4655
};4657
static int stbi__paeth(int a, int b, int c)4658
{4659
// This formulation looks very different from the reference in the PNG spec, but is4660
// actually equivalent and has favorable data dependencies and admits straightforward4661
// generation of branch-free code, which helps performance significantly.4662
int thresh = c*3 - (a + b);4663
int lo = a < b ? a : b;4664
int hi = a < b ? b : a;4665
int t0 = (hi <= thresh) ? lo : c;4666
int t1 = (thresh <= lo) ? hi : t0;4667
return t1;4668
}4670
static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };4672
// adds an extra all-255 alpha channel4673
// dest == src is legal4674
// img_n must be 1 or 34675
static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)4676
{4677
int i;4678
// must process data backwards since we allow dest==src4679
if (img_n == 1) {4680
for (i=x-1; i >= 0; --i) {4681
dest[i*2+1] = 255;4682
dest[i*2+0] = src[i];4683
}4684
} else {4685
STBI_ASSERT(img_n == 3);4686
for (i=x-1; i >= 0; --i) {4687
dest[i*4+3] = 255;4688
dest[i*4+2] = src[i*3+2];4689
dest[i*4+1] = src[i*3+1];4690
dest[i*4+0] = src[i*3+0];4691
}4692
}4693
}4695
// create the png data from post-deflated data4696
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, int depth, int color)4697
{4698
int bytes = (depth == 16 ? 2 : 1);4699
stbi__context *s = a->s;4700
stbi__uint32 i,j,stride = x*out_n*bytes;4701
stbi__uint32 img_len, img_width_bytes;4702
stbi_uc *filter_buf;4703
int all_ok = 1;4704
int k;4705
int img_n = s->img_n; // copy it into a local for later4707
int output_bytes = out_n*bytes;4708
int filter_bytes = img_n*bytes;4709
int width = x;4711
STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);4712
a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into4713
if (!a->out) return stbi__err("outofmem", "Out of memory");4715
// note: error exits here don't need to clean up a->out individually,4716
// stbi__do_png always does on error.4717
if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");4718
img_width_bytes = (((img_n * x * depth) + 7) >> 3);4719
if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");4720
img_len = (img_width_bytes + 1) * y;4722
// we used to check for exact match between raw_len and img_len on non-interlaced PNGs,4723
// but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),4724
// so just check for raw_len < img_len always.4725
if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");4727
// Allocate two scan lines worth of filter workspace buffer.4728
filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);4729
if (!filter_buf) return stbi__err("outofmem", "Out of memory");4731
// Filtering for low-bit-depth images4732
if (depth < 8) {4733
filter_bytes = 1;4734
width = img_width_bytes;4735
}4737
for (j=0; j < y; ++j) {4738
// cur/prior filter buffers alternate4739
stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;4740
stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;4741
stbi_uc *dest = a->out + stride*j;4742
int nk = width * filter_bytes;4743
int filter = *raw++;4745
// check filter type4746
if (filter > 4) {4747
all_ok = stbi__err("invalid filter","Corrupt PNG");4748
break;4749
}4751
// if first row, use special filter that doesn't sample previous row4752
if (j == 0) filter = first_row_filter[filter];4754
// perform actual filtering4755
switch (filter) {4756
case STBI__F_none:4757
memcpy(cur, raw, nk);4758
break;4759
case STBI__F_sub:4760
memcpy(cur, raw, filter_bytes);4761
for (k = filter_bytes; k < nk; ++k)4762
cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);4763
break;4764
case STBI__F_up:4765
for (k = 0; k < nk; ++k)4766
cur[k] = STBI__BYTECAST(raw[k] + prior[k]);4767
break;4768
case STBI__F_avg:4769
for (k = 0; k < filter_bytes; ++k)4770
cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));4771
for (k = filter_bytes; k < nk; ++k)4772
cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));4773
break;4774
case STBI__F_paeth:4775
for (k = 0; k < filter_bytes; ++k)4776
cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)4777
for (k = filter_bytes; k < nk; ++k)4778
cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));4779
break;4780
case STBI__F_avg_first:4781
memcpy(cur, raw, filter_bytes);4782
for (k = filter_bytes; k < nk; ++k)4783
cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));4784
break;4785
}4787
raw += nk;4789
// expand decoded bits in cur to dest, also adding an extra alpha channel if desired4790
if (depth < 8) {4791
stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range4792
stbi_uc *in = cur;4793
stbi_uc *out = dest;4794
stbi_uc inb = 0;4795
stbi__uint32 nsmp = x*img_n;4797
// expand bits to bytes first4798
if (depth == 4) {4799
for (i=0; i < nsmp; ++i) {4800
if ((i & 1) == 0) inb = *in++;4801
*out++ = scale * (inb >> 4);4802
inb <<= 4;4803
}4804
} else if (depth == 2) {4805
for (i=0; i < nsmp; ++i) {4806
if ((i & 3) == 0) inb = *in++;4807
*out++ = scale * (inb >> 6);4808
inb <<= 2;4809
}4810
} else {4811
STBI_ASSERT(depth == 1);4812
for (i=0; i < nsmp; ++i) {4813
if ((i & 7) == 0) inb = *in++;4814
*out++ = scale * (inb >> 7);4815
inb <<= 1;4816
}4817
}4819
// insert alpha=255 values if desired4820
if (img_n != out_n)4821
stbi__create_png_alpha_expand8(dest, dest, x, img_n);4822
} else if (depth == 8) {4823
if (img_n == out_n)4824
memcpy(dest, cur, x*img_n);4825
else4826
stbi__create_png_alpha_expand8(dest, cur, x, img_n);4827
} else if (depth == 16) {4828
// convert the image data from big-endian to platform-native4829
stbi__uint16 *dest16 = (stbi__uint16*)dest;4830
stbi__uint32 nsmp = x*img_n;4832
if (img_n == out_n) {4833
for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)4834
*dest16 = (cur[0] << 8) | cur[1];4835
} else {4836
STBI_ASSERT(img_n+1 == out_n);4837
if (img_n == 1) {4838
for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {4839
dest16[0] = (cur[0] << 8) | cur[1];4840
dest16[1] = 0xffff;4841
}4842
} else {4843
STBI_ASSERT(img_n == 3);4844
for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {4845
dest16[0] = (cur[0] << 8) | cur[1];4846
dest16[1] = (cur[2] << 8) | cur[3];4847
dest16[2] = (cur[4] << 8) | cur[5];4848
dest16[3] = 0xffff;4849
}4850
}4851
}4852
}4853
}4855
STBI_FREE(filter_buf);4856
if (!all_ok) return 0;4858
return 1;4859
}4861
static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)4862
{4863
int bytes = (depth == 16 ? 2 : 1);4864
int out_bytes = out_n * bytes;4865
stbi_uc *final;4866
int p;4867
if (!interlaced)4868
return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);4870
// de-interlacing4871
final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);4872
if (!final) return stbi__err("outofmem", "Out of memory");4873
for (p=0; p < 7; ++p) {4874
int xorig[] = { 0,4,0,2,0,1,0 };4875
int yorig[] = { 0,0,4,0,2,0,1 };4876
int xspc[] = { 8,8,4,4,2,2,1 };4877
int yspc[] = { 8,8,8,4,4,2,2 };4878
int i,j,x,y;4879
// pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 14880
x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];4881
y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];4882
if (x && y) {4883
stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;4884
if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {4885
STBI_FREE(final);4886
return 0;4887
}4888
for (j=0; j < y; ++j) {4889
for (i=0; i < x; ++i) {4890
int out_y = j*yspc[p]+yorig[p];4891
int out_x = i*xspc[p]+xorig[p];4892
memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,4893
a->out + (j*x+i)*out_bytes, out_bytes);4894
}4895
}4896
STBI_FREE(a->out);4897
image_data += img_len;4898
image_data_len -= img_len;4899
}4900
}4901
a->out = final;4903
return 1;4904
}4906
static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)4907
{4908
stbi__context *s = z->s;4909
stbi__uint32 i, pixel_count = s->img_x * s->img_y;4910
stbi_uc *p = z->out;4912
// compute color-based transparency, assuming we've4913
// already got 255 as the alpha value in the output4914
STBI_ASSERT(out_n == 2 || out_n == 4);4916
if (out_n == 2) {4917
for (i=0; i < pixel_count; ++i) {4918
p[1] = (p[0] == tc[0] ? 0 : 255);4919
p += 2;4920
}4921
} else {4922
for (i=0; i < pixel_count; ++i) {4923
if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])4924
p[3] = 0;4925
p += 4;4926
}4927
}4928
return 1;4929
}4931
static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)4932
{4933
stbi__context *s = z->s;4934
stbi__uint32 i, pixel_count = s->img_x * s->img_y;4935
stbi__uint16 *p = (stbi__uint16*) z->out;4937
// compute color-based transparency, assuming we've4938
// already got 65535 as the alpha value in the output4939
STBI_ASSERT(out_n == 2 || out_n == 4);4941
if (out_n == 2) {4942
for (i = 0; i < pixel_count; ++i) {4943
p[1] = (p[0] == tc[0] ? 0 : 65535);4944
p += 2;4945
}4946
} else {4947
for (i = 0; i < pixel_count; ++i) {4948
if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])4949
p[3] = 0;4950
p += 4;4951
}4952
}4953
return 1;4954
}4956
static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)4957
{4958
stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;4959
stbi_uc *p, *temp_out, *orig = a->out;4961
p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);4962
if (p == NULL) return stbi__err("outofmem", "Out of memory");4964
// between here and free(out) below, exitting would leak4965
temp_out = p;4967
if (pal_img_n == 3) {4968
for (i=0; i < pixel_count; ++i) {4969
int n = orig[i]*4;4970
p[0] = palette[n ];4971
p[1] = palette[n+1];4972
p[2] = palette[n+2];4973
p += 3;4974
}4975
} else {4976
for (i=0; i < pixel_count; ++i) {4977
int n = orig[i]*4;4978
p[0] = palette[n ];4979
p[1] = palette[n+1];4980
p[2] = palette[n+2];4981
p[3] = palette[n+3];4982
p += 4;4983
}4984
}4985
STBI_FREE(a->out);4986
a->out = temp_out;4988
STBI_NOTUSED(len);4990
return 1;4991
}4993
static int stbi__unpremultiply_on_load_global = 0;4994
static int stbi__de_iphone_flag_global = 0;4996
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)4997
{4998
stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;4999
}5001
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)5002
{5003
stbi__de_iphone_flag_global = flag_true_if_should_convert;5004
}5006
#ifndef STBI_THREAD_LOCAL5007
#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global5008
#define stbi__de_iphone_flag stbi__de_iphone_flag_global5009
#else5010
static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;5011
static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;5013
STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)5014
{5015
stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;5016
stbi__unpremultiply_on_load_set = 1;5017
}5019
STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)5020
{5021
stbi__de_iphone_flag_local = flag_true_if_should_convert;5022
stbi__de_iphone_flag_set = 1;5023
}5025
#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \5026
? stbi__unpremultiply_on_load_local \5027
: stbi__unpremultiply_on_load_global)5028
#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \5029
? stbi__de_iphone_flag_local \5030
: stbi__de_iphone_flag_global)5031
#endif // STBI_THREAD_LOCAL5033
static void stbi__de_iphone(stbi__png *z)5034
{5035
stbi__context *s = z->s;5036
stbi__uint32 i, pixel_count = s->img_x * s->img_y;5037
stbi_uc *p = z->out;5039
if (s->img_out_n == 3) { // convert bgr to rgb5040
for (i=0; i < pixel_count; ++i) {5041
stbi_uc t = p[0];5042
p[0] = p[2];5043
p[2] = t;5044
p += 3;5045
}5046
} else {5047
STBI_ASSERT(s->img_out_n == 4);5048
if (stbi__unpremultiply_on_load) {5049
// convert bgr to rgb and unpremultiply5050
for (i=0; i < pixel_count; ++i) {5051
stbi_uc a = p[3];5052
stbi_uc t = p[0];5053
if (a) {5054
stbi_uc half = a / 2;5055
p[0] = (p[2] * 255 + half) / a;5056
p[1] = (p[1] * 255 + half) / a;5057
p[2] = ( t * 255 + half) / a;5058
} else {5059
p[0] = p[2];5060
p[2] = t;5061
}5062
p += 4;5063
}5064
} else {5065
// convert bgr to rgb5066
for (i=0; i < pixel_count; ++i) {5067
stbi_uc t = p[0];5068
p[0] = p[2];5069
p[2] = t;5070
p += 4;5071
}5072
}5073
}5074
}5076
#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))5078
static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)5079
{5080
stbi_uc palette[1024], pal_img_n=0;5081
stbi_uc has_trans=0, tc[3]={0};5082
stbi__uint16 tc16[3];5083
stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;5084
int first=1,k,interlace=0, color=0, is_iphone=0;5085
stbi__context *s = z->s;5087
z->expanded = NULL;5088
z->idata = NULL;5089
z->out = NULL;5091
if (!stbi__check_png_header(s)) return 0;5093
if (scan == STBI__SCAN_type) return 1;5095
for (;;) {5096
stbi__pngchunk c = stbi__get_chunk_header(s);5097
switch (c.type) {5098
case STBI__PNG_TYPE('C','g','B','I'):5099
is_iphone = 1;5100
stbi__skip(s, c.length);5101
break;5102
case STBI__PNG_TYPE('I','H','D','R'): {5103
int comp,filter;5104
if (!first) return stbi__err("multiple IHDR","Corrupt PNG");5105
first = 0;5106
if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");5107
s->img_x = stbi__get32be(s);5108
s->img_y = stbi__get32be(s);5109
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");5110
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");5111
z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");5112
color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");5113
if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG");5114
if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");5115
comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");5116
filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");5117
interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");5118
if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");5119
if (!pal_img_n) {5120
s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);5121
if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");5122
} else {5123
// if paletted, then pal_n is our final components, and5124
// img_n is # components to decompress/filter.5125
s->img_n = 1;5126
if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");5127
}5128
// even with SCAN_header, have to scan to see if we have a tRNS5129
break;5130
}5132
case STBI__PNG_TYPE('P','L','T','E'): {5133
if (first) return stbi__err("first not IHDR", "Corrupt PNG");5134
if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");5135
pal_len = c.length / 3;5136
if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");5137
for (i=0; i < pal_len; ++i) {5138
palette[i*4+0] = stbi__get8(s);5139
palette[i*4+1] = stbi__get8(s);5140
palette[i*4+2] = stbi__get8(s);5141
palette[i*4+3] = 255;5142
}5143
break;5144
}5146
case STBI__PNG_TYPE('t','R','N','S'): {5147
if (first) return stbi__err("first not IHDR", "Corrupt PNG");5148
if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");5149
if (pal_img_n) {5150
if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }5151
if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");5152
if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");5153
pal_img_n = 4;5154
for (i=0; i < c.length; ++i)5155
palette[i*4+3] = stbi__get8(s);5156
} else {5157
if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");5158
if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");5159
has_trans = 1;5160
// non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.5161
if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }5162
if (z->depth == 16) {5163
for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning5164
tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is5165
} else {5166
for (k = 0; k < s->img_n && k < 3; ++k)5167
tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger5168
}5169
}5170
break;5171
}5173
case STBI__PNG_TYPE('I','D','A','T'): {5174
if (first) return stbi__err("first not IHDR", "Corrupt PNG");5175
if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");5176
if (scan == STBI__SCAN_header) {5177
// header scan definitely stops at first IDAT5178
if (pal_img_n)5179
s->img_n = pal_img_n;5180
return 1;5181
}5182
if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");5183
if ((int)(ioff + c.length) < (int)ioff) return 0;5184
if (ioff + c.length > idata_limit) {5185
stbi__uint32 idata_limit_old = idata_limit;5186
stbi_uc *p;5187
if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;5188
while (ioff + c.length > idata_limit)5189
idata_limit *= 2;5190
STBI_NOTUSED(idata_limit_old);5191
p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");5192
z->idata = p;5193
}5194
if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");5195
ioff += c.length;5196
break;5197
}5199
case STBI__PNG_TYPE('I','E','N','D'): {5200
stbi__uint32 raw_len, bpl;5201
if (first) return stbi__err("first not IHDR", "Corrupt PNG");5202
if (scan != STBI__SCAN_load) return 1;5203
if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");5204
// initial guess for decoded data size to avoid unnecessary reallocs5205
bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component5206
raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;5207
z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);5208
if (z->expanded == NULL) return 0; // zlib should set error5209
STBI_FREE(z->idata); z->idata = NULL;5210
if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)5211
s->img_out_n = s->img_n+1;5212
else5213
s->img_out_n = s->img_n;5214
if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;5215
if (has_trans) {5216
if (z->depth == 16) {5217
if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;5218
} else {5219
if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;5220
}5221
}5222
if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)5223
stbi__de_iphone(z);5224
if (pal_img_n) {5225
// pal_img_n == 3 or 45226
s->img_n = pal_img_n; // record the actual colors we had5227
s->img_out_n = pal_img_n;5228
if (req_comp >= 3) s->img_out_n = req_comp;5229
if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))5230
return 0;5231
} else if (has_trans) {5232
// non-paletted image with tRNS -> source image has (constant) alpha5233
++s->img_n;5234
}5235
STBI_FREE(z->expanded); z->expanded = NULL;5236
// end of PNG chunk, read and skip CRC5237
stbi__get32be(s);5238
return 1;5239
}5241
default:5242
// if critical, fail5243
if (first) return stbi__err("first not IHDR", "Corrupt PNG");5244
if ((c.type & (1 << 29)) == 0) {5245
#ifndef STBI_NO_FAILURE_STRINGS5246
// not threadsafe5247
static char invalid_chunk[] = "XXXX PNG chunk not known";5248
invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);5249
invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);5250
invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);5251
invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);5252
#endif5253
return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");5254
}5255
stbi__skip(s, c.length);5256
break;5257
}5258
// end of PNG chunk, read and skip CRC5259
stbi__get32be(s);5260
}5261
}5263
static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)5264
{5265
void *result=NULL;5266
if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");5267
if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {5268
if (p->depth <= 8)5269
ri->bits_per_channel = 8;5270
else if (p->depth == 16)5271
ri->bits_per_channel = 16;5272
else5273
return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");5274
result = p->out;5275
p->out = NULL;5276
if (req_comp && req_comp != p->s->img_out_n) {5277
if (ri->bits_per_channel == 8)5278
result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);5279
else5280
result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);5281
p->s->img_out_n = req_comp;5282
if (result == NULL) return result;5283
}5284
*x = p->s->img_x;5285
*y = p->s->img_y;5286
if (n) *n = p->s->img_n;5287
}5288
STBI_FREE(p->out); p->out = NULL;5289
STBI_FREE(p->expanded); p->expanded = NULL;5290
STBI_FREE(p->idata); p->idata = NULL;5292
return result;5293
}5295
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)5296
{5297
stbi__png p;5298
p.s = s;5299
return stbi__do_png(&p, x,y,comp,req_comp, ri);5300
}5302
static int stbi__png_test(stbi__context *s)5303
{5304
int r;5305
r = stbi__check_png_header(s);5306
stbi__rewind(s);5307
return r;5308
}5310
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)5311
{5312
if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {5313
stbi__rewind( p->s );5314
return 0;5315
}5316
if (x) *x = p->s->img_x;5317
if (y) *y = p->s->img_y;5318
if (comp) *comp = p->s->img_n;5319
return 1;5320
}5322
static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)5323
{5324
stbi__png p;5325
p.s = s;5326
return stbi__png_info_raw(&p, x, y, comp);5327
}5329
static int stbi__png_is16(stbi__context *s)5330
{5331
stbi__png p;5332
p.s = s;5333
if (!stbi__png_info_raw(&p, NULL, NULL, NULL))5334
return 0;5335
if (p.depth != 16) {5336
stbi__rewind(p.s);5337
return 0;5338
}5339
return 1;5340
}5341
#endif5343
// Microsoft/Windows BMP image5345
#ifndef STBI_NO_BMP5346
static int stbi__bmp_test_raw(stbi__context *s)5347
{5348
int r;5349
int sz;5350
if (stbi__get8(s) != 'B') return 0;5351
if (stbi__get8(s) != 'M') return 0;5352
stbi__get32le(s); // discard filesize5353
stbi__get16le(s); // discard reserved5354
stbi__get16le(s); // discard reserved5355
stbi__get32le(s); // discard data offset5356
sz = stbi__get32le(s);5357
r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);5358
return r;5359
}5361
static int stbi__bmp_test(stbi__context *s)5362
{5363
int r = stbi__bmp_test_raw(s);5364
stbi__rewind(s);5365
return r;5366
}5369
// returns 0..31 for the highest set bit5370
static int stbi__high_bit(unsigned int z)5371
{5372
int n=0;5373
if (z == 0) return -1;5374
if (z >= 0x10000) { n += 16; z >>= 16; }5375
if (z >= 0x00100) { n += 8; z >>= 8; }5376
if (z >= 0x00010) { n += 4; z >>= 4; }5377
if (z >= 0x00004) { n += 2; z >>= 2; }5378
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }5379
return n;5380
}5382
static int stbi__bitcount(unsigned int a)5383
{5384
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 25385
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 45386
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits5387
a = (a + (a >> 8)); // max 16 per 8 bits5388
a = (a + (a >> 16)); // max 32 per 8 bits5389
return a & 0xff;5390
}5392
// extract an arbitrarily-aligned N-bit value (N=bits)5393
// from v, and then make it 8-bits long and fractionally5394
// extend it to full full range.5395
static int stbi__shiftsigned(unsigned int v, int shift, int bits)5396
{5397
static unsigned int mul_table[9] = {5398
0,5399
0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,5400
0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,5401
};5402
static unsigned int shift_table[9] = {5403
0, 0,0,1,0,2,4,6,0,5404
};5405
if (shift < 0)5406
v <<= -shift;5407
else5408
v >>= shift;5409
STBI_ASSERT(v < 256);5410
v >>= (8-bits);5411
STBI_ASSERT(bits >= 0 && bits <= 8);5412
return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];5413
}5415
typedef struct5416
{5417
int bpp, offset, hsz;5418
unsigned int mr,mg,mb,ma, all_a;5419
int extra_read;5420
} stbi__bmp_data;5422
static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)5423
{5424
// BI_BITFIELDS specifies masks explicitly, don't override5425
if (compress == 3)5426
return 1;5428
if (compress == 0) {5429
if (info->bpp == 16) {5430
info->mr = 31u << 10;5431
info->mg = 31u << 5;5432
info->mb = 31u << 0;5433
} else if (info->bpp == 32) {5434
info->mr = 0xffu << 16;5435
info->mg = 0xffu << 8;5436
info->mb = 0xffu << 0;5437
info->ma = 0xffu << 24;5438
info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 05439
} else {5440
// otherwise, use defaults, which is all-05441
info->mr = info->mg = info->mb = info->ma = 0;5442
}5443
return 1;5444
}5445
return 0; // error5446
}5448
static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)5449
{5450
int hsz;5451
if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");5452
stbi__get32le(s); // discard filesize5453
stbi__get16le(s); // discard reserved5454
stbi__get16le(s); // discard reserved5455
info->offset = stbi__get32le(s);5456
info->hsz = hsz = stbi__get32le(s);5457
info->mr = info->mg = info->mb = info->ma = 0;5458
info->extra_read = 14;5460
if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");5462
if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");5463
if (hsz == 12) {5464
s->img_x = stbi__get16le(s);5465
s->img_y = stbi__get16le(s);5466
} else {5467
s->img_x = stbi__get32le(s);5468
s->img_y = stbi__get32le(s);5469
}5470
if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");5471
info->bpp = stbi__get16le(s);5472
if (hsz != 12) {5473
int compress = stbi__get32le(s);5474
if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");5475
if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes5476
if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel5477
stbi__get32le(s); // discard sizeof5478
stbi__get32le(s); // discard hres5479
stbi__get32le(s); // discard vres5480
stbi__get32le(s); // discard colorsused5481
stbi__get32le(s); // discard max important5482
if (hsz == 40 || hsz == 56) {5483
if (hsz == 56) {5484
stbi__get32le(s);5485
stbi__get32le(s);5486
stbi__get32le(s);5487
stbi__get32le(s);5488
}5489
if (info->bpp == 16 || info->bpp == 32) {5490
if (compress == 0) {5491
stbi__bmp_set_mask_defaults(info, compress);5492
} else if (compress == 3) {5493
info->mr = stbi__get32le(s);5494
info->mg = stbi__get32le(s);5495
info->mb = stbi__get32le(s);5496
info->extra_read += 12;5497
// not documented, but generated by photoshop and handled by mspaint5498
if (info->mr == info->mg && info->mg == info->mb) {5499
// ?!?!?5500
return stbi__errpuc("bad BMP", "bad BMP");5501
}5502
} else5503
return stbi__errpuc("bad BMP", "bad BMP");5504
}5505
} else {5506
// V4/V5 header5507
int i;5508
if (hsz != 108 && hsz != 124)5509
return stbi__errpuc("bad BMP", "bad BMP");5510
info->mr = stbi__get32le(s);5511
info->mg = stbi__get32le(s);5512
info->mb = stbi__get32le(s);5513
info->ma = stbi__get32le(s);5514
if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs5515
stbi__bmp_set_mask_defaults(info, compress);5516
stbi__get32le(s); // discard color space5517
for (i=0; i < 12; ++i)5518
stbi__get32le(s); // discard color space parameters5519
if (hsz == 124) {5520
stbi__get32le(s); // discard rendering intent5521
stbi__get32le(s); // discard offset of profile data5522
stbi__get32le(s); // discard size of profile data5523
stbi__get32le(s); // discard reserved5524
}5525
}5526
}5527
return (void *) 1;5528
}5531
static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)5532
{5533
stbi_uc *out;5534
unsigned int mr=0,mg=0,mb=0,ma=0, all_a;5535
stbi_uc pal[256][4];5536
int psize=0,i,j,width;5537
int flip_vertically, pad, target;5538
stbi__bmp_data info;5539
STBI_NOTUSED(ri);5541
info.all_a = 255;5542
if (stbi__bmp_parse_header(s, &info) == NULL)5543
return NULL; // error code already set5545
flip_vertically = ((int) s->img_y) > 0;5546
s->img_y = abs((int) s->img_y);5548
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");5549
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");5551
mr = info.mr;5552
mg = info.mg;5553
mb = info.mb;5554
ma = info.ma;5555
all_a = info.all_a;5557
if (info.hsz == 12) {5558
if (info.bpp < 24)5559
psize = (info.offset - info.extra_read - 24) / 3;5560
} else {5561
if (info.bpp < 16)5562
psize = (info.offset - info.extra_read - info.hsz) >> 2;5563
}5564
if (psize == 0) {5565
// accept some number of extra bytes after the header, but if the offset points either to before5566
// the header ends or implies a large amount of extra data, reject the file as malformed5567
int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);5568
int header_limit = 1024; // max we actually read is below 256 bytes currently.5569
int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.5570
if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {5571
return stbi__errpuc("bad header", "Corrupt BMP");5572
}5573
// we established that bytes_read_so_far is positive and sensible.5574
// the first half of this test rejects offsets that are either too small positives, or5575
// negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn5576
// ensures the number computed in the second half of the test can't overflow.5577
if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {5578
return stbi__errpuc("bad offset", "Corrupt BMP");5579
} else {5580
stbi__skip(s, info.offset - bytes_read_so_far);5581
}5582
}5584
if (info.bpp == 24 && ma == 0xff000000)5585
s->img_n = 3;5586
else5587
s->img_n = ma ? 4 : 3;5588
if (req_comp && req_comp >= 3) // we can directly decode 3 or 45589
target = req_comp;5590
else5591
target = s->img_n; // if they want monochrome, we'll post-convert5593
// sanity-check size5594
if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))5595
return stbi__errpuc("too large", "Corrupt BMP");5597
out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);5598
if (!out) return stbi__errpuc("outofmem", "Out of memory");5599
if (info.bpp < 16) {5600
int z=0;5601
if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }5602
for (i=0; i < psize; ++i) {5603
pal[i][2] = stbi__get8(s);5604
pal[i][1] = stbi__get8(s);5605
pal[i][0] = stbi__get8(s);5606
if (info.hsz != 12) stbi__get8(s);5607
pal[i][3] = 255;5608
}5609
stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));5610
if (info.bpp == 1) width = (s->img_x + 7) >> 3;5611
else if (info.bpp == 4) width = (s->img_x + 1) >> 1;5612
else if (info.bpp == 8) width = s->img_x;5613
else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }5614
pad = (-width)&3;5615
if (info.bpp == 1) {5616
for (j=0; j < (int) s->img_y; ++j) {5617
int bit_offset = 7, v = stbi__get8(s);5618
for (i=0; i < (int) s->img_x; ++i) {5619
int color = (v>>bit_offset)&0x1;5620
out[z++] = pal[color][0];5621
out[z++] = pal[color][1];5622
out[z++] = pal[color][2];5623
if (target == 4) out[z++] = 255;5624
if (i+1 == (int) s->img_x) break;5625
if((--bit_offset) < 0) {5626
bit_offset = 7;5627
v = stbi__get8(s);5628
}5629
}5630
stbi__skip(s, pad);5631
}5632
} else {5633
for (j=0; j < (int) s->img_y; ++j) {5634
for (i=0; i < (int) s->img_x; i += 2) {5635
int v=stbi__get8(s),v2=0;5636
if (info.bpp == 4) {5637
v2 = v & 15;5638
v >>= 4;5639
}5640
out[z++] = pal[v][0];5641
out[z++] = pal[v][1];5642
out[z++] = pal[v][2];5643
if (target == 4) out[z++] = 255;5644
if (i+1 == (int) s->img_x) break;5645
v = (info.bpp == 8) ? stbi__get8(s) : v2;5646
out[z++] = pal[v][0];5647
out[z++] = pal[v][1];5648
out[z++] = pal[v][2];5649
if (target == 4) out[z++] = 255;5650
}5651
stbi__skip(s, pad);5652
}5653
}5654
} else {5655
int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;5656
int z = 0;5657
int easy=0;5658
stbi__skip(s, info.offset - info.extra_read - info.hsz);5659
if (info.bpp == 24) width = 3 * s->img_x;5660
else if (info.bpp == 16) width = 2*s->img_x;5661
else /* bpp = 32 and pad = 0 */ width=0;5662
pad = (-width) & 3;5663
if (info.bpp == 24) {5664
easy = 1;5665
} else if (info.bpp == 32) {5666
if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)5667
easy = 2;5668
}5669
if (!easy) {5670
if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }5671
// right shift amt to put high bit in position #75672
rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);5673
gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);5674
bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);5675
ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);5676
if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }5677
}5678
for (j=0; j < (int) s->img_y; ++j) {5679
if (easy) {5680
for (i=0; i < (int) s->img_x; ++i) {5681
unsigned char a;5682
out[z+2] = stbi__get8(s);5683
out[z+1] = stbi__get8(s);5684
out[z+0] = stbi__get8(s);5685
z += 3;5686
a = (easy == 2 ? stbi__get8(s) : 255);5687
all_a |= a;5688
if (target == 4) out[z++] = a;5689
}5690
} else {5691
int bpp = info.bpp;5692
for (i=0; i < (int) s->img_x; ++i) {5693
stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));5694
unsigned int a;5695
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));5696
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));5697
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));5698
a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);5699
all_a |= a;5700
if (target == 4) out[z++] = STBI__BYTECAST(a);5701
}5702
}5703
stbi__skip(s, pad);5704
}5705
}5707
// if alpha channel is all 0s, replace with all 255s5708
if (target == 4 && all_a == 0)5709
for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)5710
out[i] = 255;5712
if (flip_vertically) {5713
stbi_uc t;5714
for (j=0; j < (int) s->img_y>>1; ++j) {5715
stbi_uc *p1 = out + j *s->img_x*target;5716
stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;5717
for (i=0; i < (int) s->img_x*target; ++i) {5718
t = p1[i]; p1[i] = p2[i]; p2[i] = t;5719
}5720
}5721
}5723
if (req_comp && req_comp != target) {5724
out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);5725
if (out == NULL) return out; // stbi__convert_format frees input on failure5726
}5728
*x = s->img_x;5729
*y = s->img_y;5730
if (comp) *comp = s->img_n;5731
return out;5732
}5733
#endif5735
// Targa Truevision - TGA5736
// by Jonathan Dummer5737
#ifndef STBI_NO_TGA5738
// returns STBI_rgb or whatever, 0 on error5739
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)5740
{5741
// only RGB or RGBA (incl. 16bit) or grey allowed5742
if (is_rgb16) *is_rgb16 = 0;5743
switch(bits_per_pixel) {5744
case 8: return STBI_grey;5745
case 16: if(is_grey) return STBI_grey_alpha;5746
// fallthrough5747
case 15: if(is_rgb16) *is_rgb16 = 1;5748
return STBI_rgb;5749
case 24: // fallthrough5750
case 32: return bits_per_pixel/8;5751
default: return 0;5752
}5753
}5755
static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)5756
{5757
int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;5758
int sz, tga_colormap_type;5759
stbi__get8(s); // discard Offset5760
tga_colormap_type = stbi__get8(s); // colormap type5761
if( tga_colormap_type > 1 ) {5762
stbi__rewind(s);5763
return 0; // only RGB or indexed allowed5764
}5765
tga_image_type = stbi__get8(s); // image type5766
if ( tga_colormap_type == 1 ) { // colormapped (paletted) image5767
if (tga_image_type != 1 && tga_image_type != 9) {5768
stbi__rewind(s);5769
return 0;5770
}5771
stbi__skip(s,4); // skip index of first colormap entry and number of entries5772
sz = stbi__get8(s); // check bits per palette color entry5773
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {5774
stbi__rewind(s);5775
return 0;5776
}5777
stbi__skip(s,4); // skip image x and y origin5778
tga_colormap_bpp = sz;5779
} else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE5780
if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {5781
stbi__rewind(s);5782
return 0; // only RGB or grey allowed, +/- RLE5783
}5784
stbi__skip(s,9); // skip colormap specification and image x/y origin5785
tga_colormap_bpp = 0;5786
}5787
tga_w = stbi__get16le(s);5788
if( tga_w < 1 ) {5789
stbi__rewind(s);5790
return 0; // test width5791
}5792
tga_h = stbi__get16le(s);5793
if( tga_h < 1 ) {5794
stbi__rewind(s);5795
return 0; // test height5796
}5797
tga_bits_per_pixel = stbi__get8(s); // bits per pixel5798
stbi__get8(s); // ignore alpha bits5799
if (tga_colormap_bpp != 0) {5800
if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {5801
// when using a colormap, tga_bits_per_pixel is the size of the indexes5802
// I don't think anything but 8 or 16bit indexes makes sense5803
stbi__rewind(s);5804
return 0;5805
}5806
tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);5807
} else {5808
tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);5809
}5810
if(!tga_comp) {5811
stbi__rewind(s);5812
return 0;5813
}5814
if (x) *x = tga_w;5815
if (y) *y = tga_h;5816
if (comp) *comp = tga_comp;5817
return 1; // seems to have passed everything5818
}5820
static int stbi__tga_test(stbi__context *s)5821
{5822
int res = 0;5823
int sz, tga_color_type;5824
stbi__get8(s); // discard Offset5825
tga_color_type = stbi__get8(s); // color type5826
if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed5827
sz = stbi__get8(s); // image type5828
if ( tga_color_type == 1 ) { // colormapped (paletted) image5829
if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 95830
stbi__skip(s,4); // skip index of first colormap entry and number of entries5831
sz = stbi__get8(s); // check bits per palette color entry5832
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;5833
stbi__skip(s,4); // skip image x and y origin5834
} else { // "normal" image w/o colormap5835
if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE5836
stbi__skip(s,9); // skip colormap specification and image x/y origin5837
}5838
if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width5839
if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height5840
sz = stbi__get8(s); // bits per pixel5841
if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index5842
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;5844
res = 1; // if we got this far, everything's good and we can return 1 instead of 05846
errorEnd:5847
stbi__rewind(s);5848
return res;5849
}5851
// read 16bit value and convert to 24bit RGB5852
static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)5853
{5854
stbi__uint16 px = (stbi__uint16)stbi__get16le(s);5855
stbi__uint16 fiveBitMask = 31;5856
// we have 3 channels with 5bits each5857
int r = (px >> 10) & fiveBitMask;5858
int g = (px >> 5) & fiveBitMask;5859
int b = px & fiveBitMask;5860
// Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later5861
out[0] = (stbi_uc)((r * 255)/31);5862
out[1] = (stbi_uc)((g * 255)/31);5863
out[2] = (stbi_uc)((b * 255)/31);5865
// some people claim that the most significant bit might be used for alpha5866
// (possibly if an alpha-bit is set in the "image descriptor byte")5867
// but that only made 16bit test images completely translucent..5868
// so let's treat all 15 and 16bit TGAs as RGB with no alpha.5869
}5871
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)5872
{5873
// read in the TGA header stuff5874
int tga_offset = stbi__get8(s);5875
int tga_indexed = stbi__get8(s);5876
int tga_image_type = stbi__get8(s);5877
int tga_is_RLE = 0;5878
int tga_palette_start = stbi__get16le(s);5879
int tga_palette_len = stbi__get16le(s);5880
int tga_palette_bits = stbi__get8(s);5881
int tga_x_origin = stbi__get16le(s);5882
int tga_y_origin = stbi__get16le(s);5883
int tga_width = stbi__get16le(s);5884
int tga_height = stbi__get16le(s);5885
int tga_bits_per_pixel = stbi__get8(s);5886
int tga_comp, tga_rgb16=0;5887
int tga_inverted = stbi__get8(s);5888
// int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)5889
// image data5890
unsigned char *tga_data;5891
unsigned char *tga_palette = NULL;5892
int i, j;5893
unsigned char raw_data[4] = {0};5894
int RLE_count = 0;5895
int RLE_repeating = 0;5896
int read_next_pixel = 1;5897
STBI_NOTUSED(ri);5898
STBI_NOTUSED(tga_x_origin); // @TODO5899
STBI_NOTUSED(tga_y_origin); // @TODO5901
if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");5902
if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");5904
// do a tiny bit of precessing5905
if ( tga_image_type >= 8 )5906
{5907
tga_image_type -= 8;5908
tga_is_RLE = 1;5909
}5910
tga_inverted = 1 - ((tga_inverted >> 5) & 1);5912
// If I'm paletted, then I'll use the number of bits from the palette5913
if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);5914
else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);5916
if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency5917
return stbi__errpuc("bad format", "Can't find out TGA pixelformat");5919
// tga info5920
*x = tga_width;5921
*y = tga_height;5922
if (comp) *comp = tga_comp;5924
if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))5925
return stbi__errpuc("too large", "Corrupt TGA");5927
tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);5928
if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");5930
// skip to the data's starting position (offset usually = 0)5931
stbi__skip(s, tga_offset );5933
if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {5934
for (i=0; i < tga_height; ++i) {5935
int row = tga_inverted ? tga_height -i - 1 : i;5936
stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;5937
stbi__getn(s, tga_row, tga_width * tga_comp);5938
}5939
} else {5940
// do I need to load a palette?5941
if ( tga_indexed)5942
{5943
if (tga_palette_len == 0) { /* you have to have at least one entry! */5944
STBI_FREE(tga_data);5945
return stbi__errpuc("bad palette", "Corrupt TGA");5946
}5948
// any data to skip? (offset usually = 0)5949
stbi__skip(s, tga_palette_start );5950
// load the palette5951
tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);5952
if (!tga_palette) {5953
STBI_FREE(tga_data);5954
return stbi__errpuc("outofmem", "Out of memory");5955
}5956
if (tga_rgb16) {5957
stbi_uc *pal_entry = tga_palette;5958
STBI_ASSERT(tga_comp == STBI_rgb);5959
for (i=0; i < tga_palette_len; ++i) {5960
stbi__tga_read_rgb16(s, pal_entry);5961
pal_entry += tga_comp;5962
}5963
} else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {5964
STBI_FREE(tga_data);5965
STBI_FREE(tga_palette);5966
return stbi__errpuc("bad palette", "Corrupt TGA");5967
}5968
}5969
// load the data5970
for (i=0; i < tga_width * tga_height; ++i)5971
{5972
// if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?5973
if ( tga_is_RLE )5974
{5975
if ( RLE_count == 0 )5976
{5977
// yep, get the next byte as a RLE command5978
int RLE_cmd = stbi__get8(s);5979
RLE_count = 1 + (RLE_cmd & 127);5980
RLE_repeating = RLE_cmd >> 7;5981
read_next_pixel = 1;5982
} else if ( !RLE_repeating )5983
{5984
read_next_pixel = 1;5985
}5986
} else5987
{5988
read_next_pixel = 1;5989
}5990
// OK, if I need to read a pixel, do it now5991
if ( read_next_pixel )5992
{5993
// load however much data we did have5994
if ( tga_indexed )5995
{5996
// read in index, then perform the lookup5997
int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);5998
if ( pal_idx >= tga_palette_len ) {5999
// invalid index6000
pal_idx = 0;6001
}6002
pal_idx *= tga_comp;6003
for (j = 0; j < tga_comp; ++j) {6004
raw_data[j] = tga_palette[pal_idx+j];6005
}6006
} else if(tga_rgb16) {6007
STBI_ASSERT(tga_comp == STBI_rgb);6008
stbi__tga_read_rgb16(s, raw_data);6009
} else {6010
// read in the data raw6011
for (j = 0; j < tga_comp; ++j) {6012
raw_data[j] = stbi__get8(s);6013
}6014
}6015
// clear the reading flag for the next pixel6016
read_next_pixel = 0;6017
} // end of reading a pixel6019
// copy data6020
for (j = 0; j < tga_comp; ++j)6021
tga_data[i*tga_comp+j] = raw_data[j];6023
// in case we're in RLE mode, keep counting down6024
--RLE_count;6025
}6026
// do I need to invert the image?6027
if ( tga_inverted )6028
{6029
for (j = 0; j*2 < tga_height; ++j)6030
{6031
int index1 = j * tga_width * tga_comp;6032
int index2 = (tga_height - 1 - j) * tga_width * tga_comp;6033
for (i = tga_width * tga_comp; i > 0; --i)6034
{6035
unsigned char temp = tga_data[index1];6036
tga_data[index1] = tga_data[index2];6037
tga_data[index2] = temp;6038
++index1;6039
++index2;6040
}6041
}6042
}6043
// clear my palette, if I had one6044
if ( tga_palette != NULL )6045
{6046
STBI_FREE( tga_palette );6047
}6048
}6050
// swap RGB - if the source data was RGB16, it already is in the right order6051
if (tga_comp >= 3 && !tga_rgb16)6052
{6053
unsigned char* tga_pixel = tga_data;6054
for (i=0; i < tga_width * tga_height; ++i)6055
{6056
unsigned char temp = tga_pixel[0];6057
tga_pixel[0] = tga_pixel[2];6058
tga_pixel[2] = temp;6059
tga_pixel += tga_comp;6060
}6061
}6063
// convert to target component count6064
if (req_comp && req_comp != tga_comp)6065
tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);6067
// the things I do to get rid of an error message, and yet keep6068
// Microsoft's C compilers happy... [8^(6069
tga_palette_start = tga_palette_len = tga_palette_bits =6070
tga_x_origin = tga_y_origin = 0;6071
STBI_NOTUSED(tga_palette_start);6072
// OK, done6073
return tga_data;6074
}6075
#endif6077
// *************************************************************************************************6078
// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB6080
#ifndef STBI_NO_PSD6081
static int stbi__psd_test(stbi__context *s)6082
{6083
int r = (stbi__get32be(s) == 0x38425053);6084
stbi__rewind(s);6085
return r;6086
}6088
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)6089
{6090
int count, nleft, len;6092
count = 0;6093
while ((nleft = pixelCount - count) > 0) {6094
len = stbi__get8(s);6095
if (len == 128) {6096
// No-op.6097
} else if (len < 128) {6098
// Copy next len+1 bytes literally.6099
len++;6100
if (len > nleft) return 0; // corrupt data6101
count += len;6102
while (len) {6103
*p = stbi__get8(s);6104
p += 4;6105
len--;6106
}6107
} else if (len > 128) {6108
stbi_uc val;6109
// Next -len+1 bytes in the dest are replicated from next source byte.6110
// (Interpret len as a negative 8-bit int.)6111
len = 257 - len;6112
if (len > nleft) return 0; // corrupt data6113
val = stbi__get8(s);6114
count += len;6115
while (len) {6116
*p = val;6117
p += 4;6118
len--;6119
}6120
}6121
}6123
return 1;6124
}6126
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)6127
{6128
int pixelCount;6129
int channelCount, compression;6130
int channel, i;6131
int bitdepth;6132
int w,h;6133
stbi_uc *out;6134
STBI_NOTUSED(ri);6136
// Check identifier6137
if (stbi__get32be(s) != 0x38425053) // "8BPS"6138
return stbi__errpuc("not PSD", "Corrupt PSD image");6140
// Check file type version.6141
if (stbi__get16be(s) != 1)6142
return stbi__errpuc("wrong version", "Unsupported version of PSD image");6144
// Skip 6 reserved bytes.6145
stbi__skip(s, 6 );6147
// Read the number of channels (R, G, B, A, etc).6148
channelCount = stbi__get16be(s);6149
if (channelCount < 0 || channelCount > 16)6150
return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");6152
// Read the rows and columns of the image.6153
h = stbi__get32be(s);6154
w = stbi__get32be(s);6156
if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");6157
if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");6159
// Make sure the depth is 8 bits.6160
bitdepth = stbi__get16be(s);6161
if (bitdepth != 8 && bitdepth != 16)6162
return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");6164
// Make sure the color mode is RGB.6165
// Valid options are:6166
// 0: Bitmap6167
// 1: Grayscale6168
// 2: Indexed color6169
// 3: RGB color6170
// 4: CMYK color6171
// 7: Multichannel6172
// 8: Duotone6173
// 9: Lab color6174
if (stbi__get16be(s) != 3)6175
return stbi__errpuc("wrong color format", "PSD is not in RGB color format");6177
// Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)6178
stbi__skip(s,stbi__get32be(s) );6180
// Skip the image resources. (resolution, pen tool paths, etc)6181
stbi__skip(s, stbi__get32be(s) );6183
// Skip the reserved data.6184
stbi__skip(s, stbi__get32be(s) );6186
// Find out if the data is compressed.6187
// Known values:6188
// 0: no compression6189
// 1: RLE compressed6190
compression = stbi__get16be(s);6191
if (compression > 1)6192
return stbi__errpuc("bad compression", "PSD has an unknown compression format");6194
// Check size6195
if (!stbi__mad3sizes_valid(4, w, h, 0))6196
return stbi__errpuc("too large", "Corrupt PSD");6198
// Create the destination image.6200
if (!compression && bitdepth == 16 && bpc == 16) {6201
out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);6202
ri->bits_per_channel = 16;6203
} else6204
out = (stbi_uc *) stbi__malloc(4 * w*h);6206
if (!out) return stbi__errpuc("outofmem", "Out of memory");6207
pixelCount = w*h;6209
// Initialize the data to zero.6210
//memset( out, 0, pixelCount * 4 );6212
// Finally, the image data.6213
if (compression) {6214
// RLE as used by .PSD and .TIFF6215
// Loop until you get the number of unpacked bytes you are expecting:6216
// Read the next source byte into n.6217
// If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.6218
// Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.6219
// Else if n is 128, noop.6220
// Endloop6222
// The RLE-compressed data is preceded by a 2-byte data count for each row in the data,6223
// which we're going to just skip.6224
stbi__skip(s, h * channelCount * 2 );6226
// Read the RLE data by channel.6227
for (channel = 0; channel < 4; channel++) {6228
stbi_uc *p;6230
p = out+channel;6231
if (channel >= channelCount) {6232
// Fill this channel with default data.6233
for (i = 0; i < pixelCount; i++, p += 4)6234
*p = (channel == 3 ? 255 : 0);6235
} else {6236
// Read the RLE data.6237
if (!stbi__psd_decode_rle(s, p, pixelCount)) {6238
STBI_FREE(out);6239
return stbi__errpuc("corrupt", "bad RLE data");6240
}6241
}6242
}6244
} else {6245
// We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)6246
// where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.6248
// Read the data by channel.6249
for (channel = 0; channel < 4; channel++) {6250
if (channel >= channelCount) {6251
// Fill this channel with default data.6252
if (bitdepth == 16 && bpc == 16) {6253
stbi__uint16 *q = ((stbi__uint16 *) out) + channel;6254
stbi__uint16 val = channel == 3 ? 65535 : 0;6255
for (i = 0; i < pixelCount; i++, q += 4)6256
*q = val;6257
} else {6258
stbi_uc *p = out+channel;6259
stbi_uc val = channel == 3 ? 255 : 0;6260
for (i = 0; i < pixelCount; i++, p += 4)6261
*p = val;6262
}6263
} else {6264
if (ri->bits_per_channel == 16) { // output bpc6265
stbi__uint16 *q = ((stbi__uint16 *) out) + channel;6266
for (i = 0; i < pixelCount; i++, q += 4)6267
*q = (stbi__uint16) stbi__get16be(s);6268
} else {6269
stbi_uc *p = out+channel;6270
if (bitdepth == 16) { // input bpc6271
for (i = 0; i < pixelCount; i++, p += 4)6272
*p = (stbi_uc) (stbi__get16be(s) >> 8);6273
} else {6274
for (i = 0; i < pixelCount; i++, p += 4)6275
*p = stbi__get8(s);6276
}6277
}6278
}6279
}6280
}6282
// remove weird white matte from PSD6283
if (channelCount >= 4) {6284
if (ri->bits_per_channel == 16) {6285
for (i=0; i < w*h; ++i) {6286
stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;6287
if (pixel[3] != 0 && pixel[3] != 65535) {6288
float a = pixel[3] / 65535.0f;6289
float ra = 1.0f / a;6290
float inv_a = 65535.0f * (1 - ra);6291
pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);6292
pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);6293
pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);6294
}6295
}6296
} else {6297
for (i=0; i < w*h; ++i) {6298
unsigned char *pixel = out + 4*i;6299
if (pixel[3] != 0 && pixel[3] != 255) {6300
float a = pixel[3] / 255.0f;6301
float ra = 1.0f / a;6302
float inv_a = 255.0f * (1 - ra);6303
pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);6304
pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);6305
pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);6306
}6307
}6308
}6309
}6311
// convert to desired output format6312
if (req_comp && req_comp != 4) {6313
if (ri->bits_per_channel == 16)6314
out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);6315
else6316
out = stbi__convert_format(out, 4, req_comp, w, h);6317
if (out == NULL) return out; // stbi__convert_format frees input on failure6318
}6320
if (comp) *comp = 4;6321
*y = h;6322
*x = w;6324
return out;6325
}6326
#endif6328
// *************************************************************************************************6329
// Softimage PIC loader6330
// by Tom Seddon6331
//6332
// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format6333
// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/6335
#ifndef STBI_NO_PIC6336
static int stbi__pic_is4(stbi__context *s,const char *str)6337
{6338
int i;6339
for (i=0; i<4; ++i)6340
if (stbi__get8(s) != (stbi_uc)str[i])6341
return 0;6343
return 1;6344
}6346
static int stbi__pic_test_core(stbi__context *s)6347
{6348
int i;6350
if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))6351
return 0;6353
for(i=0;i<84;++i)6354
stbi__get8(s);6356
if (!stbi__pic_is4(s,"PICT"))6357
return 0;6359
return 1;6360
}6362
typedef struct6363
{6364
stbi_uc size,type,channel;6365
} stbi__pic_packet;6367
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)6368
{6369
int mask=0x80, i;6371
for (i=0; i<4; ++i, mask>>=1) {6372
if (channel & mask) {6373
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");6374
dest[i]=stbi__get8(s);6375
}6376
}6378
return dest;6379
}6381
static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)6382
{6383
int mask=0x80,i;6385
for (i=0;i<4; ++i, mask>>=1)6386
if (channel&mask)6387
dest[i]=src[i];6388
}6390
static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)6391
{6392
int act_comp=0,num_packets=0,y,chained;6393
stbi__pic_packet packets[10];6395
// this will (should...) cater for even some bizarre stuff like having data6396
// for the same channel in multiple packets.6397
do {6398
stbi__pic_packet *packet;6400
if (num_packets==sizeof(packets)/sizeof(packets[0]))6401
return stbi__errpuc("bad format","too many packets");6403
packet = &packets[num_packets++];6405
chained = stbi__get8(s);6406
packet->size = stbi__get8(s);6407
packet->type = stbi__get8(s);6408
packet->channel = stbi__get8(s);6410
act_comp |= packet->channel;6412
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");6413
if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");6414
} while (chained);6416
*comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?6418
for(y=0; y<height; ++y) {6419
int packet_idx;6421
for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {6422
stbi__pic_packet *packet = &packets[packet_idx];6423
stbi_uc *dest = result+y*width*4;6425
switch (packet->type) {6426
default:6427
return stbi__errpuc("bad format","packet has bad compression type");6429
case 0: {//uncompressed6430
int x;6432
for(x=0;x<width;++x, dest+=4)6433
if (!stbi__readval(s,packet->channel,dest))6434
return 0;6435
break;6436
}6438
case 1://Pure RLE6439
{6440
int left=width, i;6442
while (left>0) {6443
stbi_uc count,value[4];6445
count=stbi__get8(s);6446
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");6448
if (count > left)6449
count = (stbi_uc) left;6451
if (!stbi__readval(s,packet->channel,value)) return 0;6453
for(i=0; i<count; ++i,dest+=4)6454
stbi__copyval(packet->channel,dest,value);6455
left -= count;6456
}6457
}6458
break;6460
case 2: {//Mixed RLE6461
int left=width;6462
while (left>0) {6463
int count = stbi__get8(s), i;6464
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");6466
if (count >= 128) { // Repeated6467
stbi_uc value[4];6469
if (count==128)6470
count = stbi__get16be(s);6471
else6472
count -= 127;6473
if (count > left)6474
return stbi__errpuc("bad file","scanline overrun");6476
if (!stbi__readval(s,packet->channel,value))6477
return 0;6479
for(i=0;i<count;++i, dest += 4)6480
stbi__copyval(packet->channel,dest,value);6481
} else { // Raw6482
++count;6483
if (count>left) return stbi__errpuc("bad file","scanline overrun");6485
for(i=0;i<count;++i, dest+=4)6486
if (!stbi__readval(s,packet->channel,dest))6487
return 0;6488
}6489
left-=count;6490
}6491
break;6492
}6493
}6494
}6495
}6497
return result;6498
}6500
static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)6501
{6502
stbi_uc *result;6503
int i, x,y, internal_comp;6504
STBI_NOTUSED(ri);6506
if (!comp) comp = &internal_comp;6508
for (i=0; i<92; ++i)6509
stbi__get8(s);6511
x = stbi__get16be(s);6512
y = stbi__get16be(s);6514
if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");6515
if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");6517
if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");6518
if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");6520
stbi__get32be(s); //skip `ratio'6521
stbi__get16be(s); //skip `fields'6522
stbi__get16be(s); //skip `pad'6524
// intermediate buffer is RGBA6525
result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);6526
if (!result) return stbi__errpuc("outofmem", "Out of memory");6527
memset(result, 0xff, x*y*4);6529
if (!stbi__pic_load_core(s,x,y,comp, result)) {6530
STBI_FREE(result);6531
result=0;6532
}6533
*px = x;6534
*py = y;6535
if (req_comp == 0) req_comp = *comp;6536
result=stbi__convert_format(result,4,req_comp,x,y);6538
return result;6539
}6541
static int stbi__pic_test(stbi__context *s)6542
{6543
int r = stbi__pic_test_core(s);6544
stbi__rewind(s);6545
return r;6546
}6547
#endif6549
// *************************************************************************************************6550
// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb6552
#ifndef STBI_NO_GIF6553
typedef struct6554
{6555
stbi__int16 prefix;6556
stbi_uc first;6557
stbi_uc suffix;6558
} stbi__gif_lzw;6560
typedef struct6561
{6562
int w,h;6563
stbi_uc *out; // output buffer (always 4 components)6564
stbi_uc *background; // The current "background" as far as a gif is concerned6565
stbi_uc *history;6566
int flags, bgindex, ratio, transparent, eflags;6567
stbi_uc pal[256][4];6568
stbi_uc lpal[256][4];6569
stbi__gif_lzw codes[8192];6570
stbi_uc *color_table;6571
int parse, step;6572
int lflags;6573
int start_x, start_y;6574
int max_x, max_y;6575
int cur_x, cur_y;6576
int line_size;6577
int delay;6578
} stbi__gif;6580
static int stbi__gif_test_raw(stbi__context *s)6581
{6582
int sz;6583
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;6584
sz = stbi__get8(s);6585
if (sz != '9' && sz != '7') return 0;6586
if (stbi__get8(s) != 'a') return 0;6587
return 1;6588
}6590
static int stbi__gif_test(stbi__context *s)6591
{6592
int r = stbi__gif_test_raw(s);6593
stbi__rewind(s);6594
return r;6595
}6597
static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)6598
{6599
int i;6600
for (i=0; i < num_entries; ++i) {6601
pal[i][2] = stbi__get8(s);6602
pal[i][1] = stbi__get8(s);6603
pal[i][0] = stbi__get8(s);6604
pal[i][3] = transp == i ? 0 : 255;6605
}6606
}6608
static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)6609
{6610
stbi_uc version;6611
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')6612
return stbi__err("not GIF", "Corrupt GIF");6614
version = stbi__get8(s);6615
if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");6616
if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");6618
stbi__g_failure_reason = "";6619
g->w = stbi__get16le(s);6620
g->h = stbi__get16le(s);6621
g->flags = stbi__get8(s);6622
g->bgindex = stbi__get8(s);6623
g->ratio = stbi__get8(s);6624
g->transparent = -1;6626
if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");6627
if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");6629
if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments6631
if (is_info) return 1;6633
if (g->flags & 0x80)6634
stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);6636
return 1;6637
}6639
static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)6640
{6641
stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));6642
if (!g) return stbi__err("outofmem", "Out of memory");6643
if (!stbi__gif_header(s, g, comp, 1)) {6644
STBI_FREE(g);6645
stbi__rewind( s );6646
return 0;6647
}6648
if (x) *x = g->w;6649
if (y) *y = g->h;6650
STBI_FREE(g);6651
return 1;6652
}6654
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)6655
{6656
stbi_uc *p, *c;6657
int idx;6659
// recurse to decode the prefixes, since the linked-list is backwards,6660
// and working backwards through an interleaved image would be nasty6661
if (g->codes[code].prefix >= 0)6662
stbi__out_gif_code(g, g->codes[code].prefix);6664
if (g->cur_y >= g->max_y) return;6666
idx = g->cur_x + g->cur_y;6667
p = &g->out[idx];6668
g->history[idx / 4] = 1;6670
c = &g->color_table[g->codes[code].suffix * 4];6671
if (c[3] > 128) { // don't render transparent pixels;6672
p[0] = c[2];6673
p[1] = c[1];6674
p[2] = c[0];6675
p[3] = c[3];6676
}6677
g->cur_x += 4;6679
if (g->cur_x >= g->max_x) {6680
g->cur_x = g->start_x;6681
g->cur_y += g->step;6683
while (g->cur_y >= g->max_y && g->parse > 0) {6684
g->step = (1 << g->parse) * g->line_size;6685
g->cur_y = g->start_y + (g->step >> 1);6686
--g->parse;6687
}6688
}6689
}6691
static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)6692
{6693
stbi_uc lzw_cs;6694
stbi__int32 len, init_code;6695
stbi__uint32 first;6696
stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;6697
stbi__gif_lzw *p;6699
lzw_cs = stbi__get8(s);6700
if (lzw_cs > 12) return NULL;6701
clear = 1 << lzw_cs;6702
first = 1;6703
codesize = lzw_cs + 1;6704
codemask = (1 << codesize) - 1;6705
bits = 0;6706
valid_bits = 0;6707
for (init_code = 0; init_code < clear; init_code++) {6708
g->codes[init_code].prefix = -1;6709
g->codes[init_code].first = (stbi_uc) init_code;6710
g->codes[init_code].suffix = (stbi_uc) init_code;6711
}6713
// support no starting clear code6714
avail = clear+2;6715
oldcode = -1;6717
len = 0;6718
for(;;) {6719
if (valid_bits < codesize) {6720
if (len == 0) {6721
len = stbi__get8(s); // start new block6722
if (len == 0)6723
return g->out;6724
}6725
--len;6726
bits |= (stbi__int32) stbi__get8(s) << valid_bits;6727
valid_bits += 8;6728
} else {6729
stbi__int32 code = bits & codemask;6730
bits >>= codesize;6731
valid_bits -= codesize;6732
// @OPTIMIZE: is there some way we can accelerate the non-clear path?6733
if (code == clear) { // clear code6734
codesize = lzw_cs + 1;6735
codemask = (1 << codesize) - 1;6736
avail = clear + 2;6737
oldcode = -1;6738
first = 0;6739
} else if (code == clear + 1) { // end of stream code6740
stbi__skip(s, len);6741
while ((len = stbi__get8(s)) > 0)6742
stbi__skip(s,len);6743
return g->out;6744
} else if (code <= avail) {6745
if (first) {6746
return stbi__errpuc("no clear code", "Corrupt GIF");6747
}6749
if (oldcode >= 0) {6750
p = &g->codes[avail++];6751
if (avail > 8192) {6752
return stbi__errpuc("too many codes", "Corrupt GIF");6753
}6755
p->prefix = (stbi__int16) oldcode;6756
p->first = g->codes[oldcode].first;6757
p->suffix = (code == avail) ? p->first : g->codes[code].first;6758
} else if (code == avail)6759
return stbi__errpuc("illegal code in raster", "Corrupt GIF");6761
stbi__out_gif_code(g, (stbi__uint16) code);6763
if ((avail & codemask) == 0 && avail <= 0x0FFF) {6764
codesize++;6765
codemask = (1 << codesize) - 1;6766
}6768
oldcode = code;6769
} else {6770
return stbi__errpuc("illegal code in raster", "Corrupt GIF");6771
}6772
}6773
}6774
}6776
// this function is designed to support animated gifs, although stb_image doesn't support it6777
// two back is the image from two frames ago, used for a very specific disposal format6778
static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)6779
{6780
int dispose;6781
int first_frame;6782
int pi;6783
int pcount;6784
STBI_NOTUSED(req_comp);6786
// on first frame, any non-written pixels get the background colour (non-transparent)6787
first_frame = 0;6788
if (g->out == 0) {6789
if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header6790
if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))6791
return stbi__errpuc("too large", "GIF image is too large");6792
pcount = g->w * g->h;6793
g->out = (stbi_uc *) stbi__malloc(4 * pcount);6794
g->background = (stbi_uc *) stbi__malloc(4 * pcount);6795
g->history = (stbi_uc *) stbi__malloc(pcount);6796
if (!g->out || !g->background || !g->history)6797
return stbi__errpuc("outofmem", "Out of memory");6799
// image is treated as "transparent" at the start - ie, nothing overwrites the current background;6800
// background colour is only used for pixels that are not rendered first frame, after that "background"6801
// color refers to the color that was there the previous frame.6802
memset(g->out, 0x00, 4 * pcount);6803
memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)6804
memset(g->history, 0x00, pcount); // pixels that were affected previous frame6805
first_frame = 1;6806
} else {6807
// second frame - how do we dispose of the previous one?6808
dispose = (g->eflags & 0x1C) >> 2;6809
pcount = g->w * g->h;6811
if ((dispose == 3) && (two_back == 0)) {6812
dispose = 2; // if I don't have an image to revert back to, default to the old background6813
}6815
if (dispose == 3) { // use previous graphic6816
for (pi = 0; pi < pcount; ++pi) {6817
if (g->history[pi]) {6818
memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );6819
}6820
}6821
} else if (dispose == 2) {6822
// restore what was changed last frame to background before that frame;6823
for (pi = 0; pi < pcount; ++pi) {6824
if (g->history[pi]) {6825
memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );6826
}6827
}6828
} else {6829
// This is a non-disposal case eithe way, so just6830
// leave the pixels as is, and they will become the new background6831
// 1: do not dispose6832
// 0: not specified.6833
}6835
// background is what out is after the undoing of the previou frame;6836
memcpy( g->background, g->out, 4 * g->w * g->h );6837
}6839
// clear my history;6840
memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame6842
for (;;) {6843
int tag = stbi__get8(s);6844
switch (tag) {6845
case 0x2C: /* Image Descriptor */6846
{6847
stbi__int32 x, y, w, h;6848
stbi_uc *o;6850
x = stbi__get16le(s);6851
y = stbi__get16le(s);6852
w = stbi__get16le(s);6853
h = stbi__get16le(s);6854
if (((x + w) > (g->w)) || ((y + h) > (g->h)))6855
return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");6857
g->line_size = g->w * 4;6858
g->start_x = x * 4;6859
g->start_y = y * g->line_size;6860
g->max_x = g->start_x + w * 4;6861
g->max_y = g->start_y + h * g->line_size;6862
g->cur_x = g->start_x;6863
g->cur_y = g->start_y;6865
// if the width of the specified rectangle is 0, that means6866
// we may not see *any* pixels or the image is malformed;6867
// to make sure this is caught, move the current y down to6868
// max_y (which is what out_gif_code checks).6869
if (w == 0)6870
g->cur_y = g->max_y;6872
g->lflags = stbi__get8(s);6874
if (g->lflags & 0x40) {6875
g->step = 8 * g->line_size; // first interlaced spacing6876
g->parse = 3;6877
} else {6878
g->step = g->line_size;6879
g->parse = 0;6880
}6882
if (g->lflags & 0x80) {6883
stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);6884
g->color_table = (stbi_uc *) g->lpal;6885
} else if (g->flags & 0x80) {6886
g->color_table = (stbi_uc *) g->pal;6887
} else6888
return stbi__errpuc("missing color table", "Corrupt GIF");6890
o = stbi__process_gif_raster(s, g);6891
if (!o) return NULL;6893
// if this was the first frame,6894
pcount = g->w * g->h;6895
if (first_frame && (g->bgindex > 0)) {6896
// if first frame, any pixel not drawn to gets the background color6897
for (pi = 0; pi < pcount; ++pi) {6898
if (g->history[pi] == 0) {6899
g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;6900
memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );6901
}6902
}6903
}6905
return o;6906
}6908
case 0x21: // Comment Extension.6909
{6910
int len;6911
int ext = stbi__get8(s);6912
if (ext == 0xF9) { // Graphic Control Extension.6913
len = stbi__get8(s);6914
if (len == 4) {6915
g->eflags = stbi__get8(s);6916
g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.6918
// unset old transparent6919
if (g->transparent >= 0) {6920
g->pal[g->transparent][3] = 255;6921
}6922
if (g->eflags & 0x01) {6923
g->transparent = stbi__get8(s);6924
if (g->transparent >= 0) {6925
g->pal[g->transparent][3] = 0;6926
}6927
} else {6928
// don't need transparent6929
stbi__skip(s, 1);6930
g->transparent = -1;6931
}6932
} else {6933
stbi__skip(s, len);6934
break;6935
}6936
}6937
while ((len = stbi__get8(s)) != 0) {6938
stbi__skip(s, len);6939
}6940
break;6941
}6943
case 0x3B: // gif stream termination code6944
return (stbi_uc *) s; // using '1' causes warning on some compilers6946
default:6947
return stbi__errpuc("unknown code", "Corrupt GIF");6948
}6949
}6950
}6952
static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)6953
{6954
STBI_FREE(g->out);6955
STBI_FREE(g->history);6956
STBI_FREE(g->background);6958
if (out) STBI_FREE(out);6959
if (delays && *delays) STBI_FREE(*delays);6960
return stbi__errpuc("outofmem", "Out of memory");6961
}6963
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)6964
{6965
if (stbi__gif_test(s)) {6966
int layers = 0;6967
stbi_uc *u = 0;6968
stbi_uc *out = 0;6969
stbi_uc *two_back = 0;6970
stbi__gif g;6971
int stride;6972
int out_size = 0;6973
int delays_size = 0;6975
STBI_NOTUSED(out_size);6976
STBI_NOTUSED(delays_size);6978
memset(&g, 0, sizeof(g));6979
if (delays) {6980
*delays = 0;6981
}6983
do {6984
u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);6985
if (u == (stbi_uc *) s) u = 0; // end of animated gif marker6987
if (u) {6988
*x = g.w;6989
*y = g.h;6990
++layers;6991
stride = g.w * g.h * 4;6993
if (out) {6994
void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );6995
if (!tmp)6996
return stbi__load_gif_main_outofmem(&g, out, delays);6997
else {6998
out = (stbi_uc*) tmp;6999
out_size = layers * stride;7000
}7002
if (delays) {7003
int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );7004
if (!new_delays)7005
return stbi__load_gif_main_outofmem(&g, out, delays);7006
*delays = new_delays;7007
delays_size = layers * sizeof(int);7008
}7009
} else {7010
out = (stbi_uc*)stbi__malloc( layers * stride );7011
if (!out)7012
return stbi__load_gif_main_outofmem(&g, out, delays);7013
out_size = layers * stride;7014
if (delays) {7015
*delays = (int*) stbi__malloc( layers * sizeof(int) );7016
if (!*delays)7017
return stbi__load_gif_main_outofmem(&g, out, delays);7018
delays_size = layers * sizeof(int);7019
}7020
}7021
memcpy( out + ((layers - 1) * stride), u, stride );7022
if (layers >= 2) {7023
two_back = out - 2 * stride;7024
}7026
if (delays) {7027
(*delays)[layers - 1U] = g.delay;7028
}7029
}7030
} while (u != 0);7032
// free temp buffer;7033
STBI_FREE(g.out);7034
STBI_FREE(g.history);7035
STBI_FREE(g.background);7037
// do the final conversion after loading everything;7038
if (req_comp && req_comp != 4)7039
out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);7041
*z = layers;7042
return out;7043
} else {7044
return stbi__errpuc("not GIF", "Image was not as a gif type.");7045
}7046
}7048
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)7049
{7050
stbi_uc *u = 0;7051
stbi__gif g;7052
memset(&g, 0, sizeof(g));7053
STBI_NOTUSED(ri);7055
u = stbi__gif_load_next(s, &g, comp, req_comp, 0);7056
if (u == (stbi_uc *) s) u = 0; // end of animated gif marker7057
if (u) {7058
*x = g.w;7059
*y = g.h;7061
// moved conversion to after successful load so that the same7062
// can be done for multiple frames.7063
if (req_comp && req_comp != 4)7064
u = stbi__convert_format(u, 4, req_comp, g.w, g.h);7065
} else if (g.out) {7066
// if there was an error and we allocated an image buffer, free it!7067
STBI_FREE(g.out);7068
}7070
// free buffers needed for multiple frame loading;7071
STBI_FREE(g.history);7072
STBI_FREE(g.background);7074
return u;7075
}7077
static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)7078
{7079
return stbi__gif_info_raw(s,x,y,comp);7080
}7081
#endif7083
// *************************************************************************************************7084
// Radiance RGBE HDR loader7085
// originally by Nicolas Schulz7086
#ifndef STBI_NO_HDR7087
static int stbi__hdr_test_core(stbi__context *s, const char *signature)7088
{7089
int i;7090
for (i=0; signature[i]; ++i)7091
if (stbi__get8(s) != signature[i])7092
return 0;7093
stbi__rewind(s);7094
return 1;7095
}7097
static int stbi__hdr_test(stbi__context* s)7098
{7099
int r = stbi__hdr_test_core(s, "#?RADIANCE\n");7100
stbi__rewind(s);7101
if(!r) {7102
r = stbi__hdr_test_core(s, "#?RGBE\n");7103
stbi__rewind(s);7104
}7105
return r;7106
}7108
#define STBI__HDR_BUFLEN 10247109
static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)7110
{7111
int len=0;7112
char c = '\0';7114
c = (char) stbi__get8(z);7116
while (!stbi__at_eof(z) && c != '\n') {7117
buffer[len++] = c;7118
if (len == STBI__HDR_BUFLEN-1) {7119
// flush to end of line7120
while (!stbi__at_eof(z) && stbi__get8(z) != '\n')7121
;7122
break;7123
}7124
c = (char) stbi__get8(z);7125
}7127
buffer[len] = 0;7128
return buffer;7129
}7131
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)7132
{7133
if ( input[3] != 0 ) {7134
float f1;7135
// Exponent7136
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));7137
if (req_comp <= 2)7138
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;7139
else {7140
output[0] = input[0] * f1;7141
output[1] = input[1] * f1;7142
output[2] = input[2] * f1;7143
}7144
if (req_comp == 2) output[1] = 1;7145
if (req_comp == 4) output[3] = 1;7146
} else {7147
switch (req_comp) {7148
case 4: output[3] = 1; /* fallthrough */7149
case 3: output[0] = output[1] = output[2] = 0;7150
break;7151
case 2: output[1] = 1; /* fallthrough */7152
case 1: output[0] = 0;7153
break;7154
}7155
}7156
}7158
static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)7159
{7160
char buffer[STBI__HDR_BUFLEN];7161
char *token;7162
int valid = 0;7163
int width, height;7164
stbi_uc *scanline;7165
float *hdr_data;7166
int len;7167
unsigned char count, value;7168
int i, j, k, c1,c2, z;7169
const char *headerToken;7170
STBI_NOTUSED(ri);7172
// Check identifier7173
headerToken = stbi__hdr_gettoken(s,buffer);7174
if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)7175
return stbi__errpf("not HDR", "Corrupt HDR image");7177
// Parse header7178
for(;;) {7179
token = stbi__hdr_gettoken(s,buffer);7180
if (token[0] == 0) break;7181
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;7182
}7184
if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");7186
// Parse width and height7187
// can't use sscanf() if we're not using stdio!7188
token = stbi__hdr_gettoken(s,buffer);7189
if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");7190
token += 3;7191
height = (int) strtol(token, &token, 10);7192
while (*token == ' ') ++token;7193
if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");7194
token += 3;7195
width = (int) strtol(token, NULL, 10);7197
if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");7198
if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");7200
*x = width;7201
*y = height;7203
if (comp) *comp = 3;7204
if (req_comp == 0) req_comp = 3;7206
if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))7207
return stbi__errpf("too large", "HDR image is too large");7209
// Read data7210
hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);7211
if (!hdr_data)7212
return stbi__errpf("outofmem", "Out of memory");7214
// Load image data7215
// image data is stored as some number of sca7216
if ( width < 8 || width >= 32768) {7217
// Read flat data7218
for (j=0; j < height; ++j) {7219
for (i=0; i < width; ++i) {7220
stbi_uc rgbe[4];7221
main_decode_loop:7222
stbi__getn(s, rgbe, 4);7223
stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);7224
}7225
}7226
} else {7227
// Read RLE-encoded data7228
scanline = NULL;7230
for (j = 0; j < height; ++j) {7231
c1 = stbi__get8(s);7232
c2 = stbi__get8(s);7233
len = stbi__get8(s);7234
if (c1 != 2 || c2 != 2 || (len & 0x80)) {7235
// not run-length encoded, so we have to actually use THIS data as a decoded7236
// pixel (note this can't be a valid pixel--one of RGB must be >= 128)7237
stbi_uc rgbe[4];7238
rgbe[0] = (stbi_uc) c1;7239
rgbe[1] = (stbi_uc) c2;7240
rgbe[2] = (stbi_uc) len;7241
rgbe[3] = (stbi_uc) stbi__get8(s);7242
stbi__hdr_convert(hdr_data, rgbe, req_comp);7243
i = 1;7244
j = 0;7245
STBI_FREE(scanline);7246
goto main_decode_loop; // yes, this makes no sense7247
}7248
len <<= 8;7249
len |= stbi__get8(s);7250
if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }7251
if (scanline == NULL) {7252
scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);7253
if (!scanline) {7254
STBI_FREE(hdr_data);7255
return stbi__errpf("outofmem", "Out of memory");7256
}7257
}7259
for (k = 0; k < 4; ++k) {7260
int nleft;7261
i = 0;7262
while ((nleft = width - i) > 0) {7263
count = stbi__get8(s);7264
if (count > 128) {7265
// Run7266
value = stbi__get8(s);7267
count -= 128;7268
if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }7269
for (z = 0; z < count; ++z)7270
scanline[i++ * 4 + k] = value;7271
} else {7272
// Dump7273
if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }7274
for (z = 0; z < count; ++z)7275
scanline[i++ * 4 + k] = stbi__get8(s);7276
}7277
}7278
}7279
for (i=0; i < width; ++i)7280
stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);7281
}7282
if (scanline)7283
STBI_FREE(scanline);7284
}7286
return hdr_data;7287
}7289
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)7290
{7291
char buffer[STBI__HDR_BUFLEN];7292
char *token;7293
int valid = 0;7294
int dummy;7296
if (!x) x = &dummy;7297
if (!y) y = &dummy;7298
if (!comp) comp = &dummy;7300
if (stbi__hdr_test(s) == 0) {7301
stbi__rewind( s );7302
return 0;7303
}7305
for(;;) {7306
token = stbi__hdr_gettoken(s,buffer);7307
if (token[0] == 0) break;7308
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;7309
}7311
if (!valid) {7312
stbi__rewind( s );7313
return 0;7314
}7315
token = stbi__hdr_gettoken(s,buffer);7316
if (strncmp(token, "-Y ", 3)) {7317
stbi__rewind( s );7318
return 0;7319
}7320
token += 3;7321
*y = (int) strtol(token, &token, 10);7322
while (*token == ' ') ++token;7323
if (strncmp(token, "+X ", 3)) {7324
stbi__rewind( s );7325
return 0;7326
}7327
token += 3;7328
*x = (int) strtol(token, NULL, 10);7329
*comp = 3;7330
return 1;7331
}7332
#endif // STBI_NO_HDR7334
#ifndef STBI_NO_BMP7335
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)7336
{7337
void *p;7338
stbi__bmp_data info;7340
info.all_a = 255;7341
p = stbi__bmp_parse_header(s, &info);7342
if (p == NULL) {7343
stbi__rewind( s );7344
return 0;7345
}7346
if (x) *x = s->img_x;7347
if (y) *y = s->img_y;7348
if (comp) {7349
if (info.bpp == 24 && info.ma == 0xff000000)7350
*comp = 3;7351
else7352
*comp = info.ma ? 4 : 3;7353
}7354
return 1;7355
}7356
#endif7358
#ifndef STBI_NO_PSD7359
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)7360
{7361
int channelCount, dummy, depth;7362
if (!x) x = &dummy;7363
if (!y) y = &dummy;7364
if (!comp) comp = &dummy;7365
if (stbi__get32be(s) != 0x38425053) {7366
stbi__rewind( s );7367
return 0;7368
}7369
if (stbi__get16be(s) != 1) {7370
stbi__rewind( s );7371
return 0;7372
}7373
stbi__skip(s, 6);7374
channelCount = stbi__get16be(s);7375
if (channelCount < 0 || channelCount > 16) {7376
stbi__rewind( s );7377
return 0;7378
}7379
*y = stbi__get32be(s);7380
*x = stbi__get32be(s);7381
depth = stbi__get16be(s);7382
if (depth != 8 && depth != 16) {7383
stbi__rewind( s );7384
return 0;7385
}7386
if (stbi__get16be(s) != 3) {7387
stbi__rewind( s );7388
return 0;7389
}7390
*comp = 4;7391
return 1;7392
}7394
static int stbi__psd_is16(stbi__context *s)7395
{7396
int channelCount, depth;7397
if (stbi__get32be(s) != 0x38425053) {7398
stbi__rewind( s );7399
return 0;7400
}7401
if (stbi__get16be(s) != 1) {7402
stbi__rewind( s );7403
return 0;7404
}7405
stbi__skip(s, 6);7406
channelCount = stbi__get16be(s);7407
if (channelCount < 0 || channelCount > 16) {7408
stbi__rewind( s );7409
return 0;7410
}7411
STBI_NOTUSED(stbi__get32be(s));7412
STBI_NOTUSED(stbi__get32be(s));7413
depth = stbi__get16be(s);7414
if (depth != 16) {7415
stbi__rewind( s );7416
return 0;7417
}7418
return 1;7419
}7420
#endif7422
#ifndef STBI_NO_PIC7423
static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)7424
{7425
int act_comp=0,num_packets=0,chained,dummy;7426
stbi__pic_packet packets[10];7428
if (!x) x = &dummy;7429
if (!y) y = &dummy;7430
if (!comp) comp = &dummy;7432
if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {7433
stbi__rewind(s);7434
return 0;7435
}7437
stbi__skip(s, 88);7439
*x = stbi__get16be(s);7440
*y = stbi__get16be(s);7441
if (stbi__at_eof(s)) {7442
stbi__rewind( s);7443
return 0;7444
}7445
if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {7446
stbi__rewind( s );7447
return 0;7448
}7450
stbi__skip(s, 8);7452
do {7453
stbi__pic_packet *packet;7455
if (num_packets==sizeof(packets)/sizeof(packets[0]))7456
return 0;7458
packet = &packets[num_packets++];7459
chained = stbi__get8(s);7460
packet->size = stbi__get8(s);7461
packet->type = stbi__get8(s);7462
packet->channel = stbi__get8(s);7463
act_comp |= packet->channel;7465
if (stbi__at_eof(s)) {7466
stbi__rewind( s );7467
return 0;7468
}7469
if (packet->size != 8) {7470
stbi__rewind( s );7471
return 0;7472
}7473
} while (chained);7475
*comp = (act_comp & 0x10 ? 4 : 3);7477
return 1;7478
}7479
#endif7481
// *************************************************************************************************7482
// Portable Gray Map and Portable Pixel Map loader7483
// by Ken Miller7484
//7485
// PGM: http://netpbm.sourceforge.net/doc/pgm.html7486
// PPM: http://netpbm.sourceforge.net/doc/ppm.html7487
//7488
// Known limitations:7489
// Does not support comments in the header section7490
// Does not support ASCII image data (formats P2 and P3)7492
#ifndef STBI_NO_PNM7494
static int stbi__pnm_test(stbi__context *s)7495
{7496
char p, t;7497
p = (char) stbi__get8(s);7498
t = (char) stbi__get8(s);7499
if (p != 'P' || (t != '5' && t != '6')) {7500
stbi__rewind( s );7501
return 0;7502
}7503
return 1;7504
}7506
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)7507
{7508
stbi_uc *out;7509
STBI_NOTUSED(ri);7511
ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);7512
if (ri->bits_per_channel == 0)7513
return 0;7515
if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");7516
if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");7518
*x = s->img_x;7519
*y = s->img_y;7520
if (comp) *comp = s->img_n;7522
if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))7523
return stbi__errpuc("too large", "PNM too large");7525
out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);7526
if (!out) return stbi__errpuc("outofmem", "Out of memory");7527
if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {7528
STBI_FREE(out);7529
return stbi__errpuc("bad PNM", "PNM file truncated");7530
}7532
if (req_comp && req_comp != s->img_n) {7533
if (ri->bits_per_channel == 16) {7534
out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);7535
} else {7536
out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);7537
}7538
if (out == NULL) return out; // stbi__convert_format frees input on failure7539
}7540
return out;7541
}7543
static int stbi__pnm_isspace(char c)7544
{7545
return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';7546
}7548
static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)7549
{7550
for (;;) {7551
while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))7552
*c = (char) stbi__get8(s);7554
if (stbi__at_eof(s) || *c != '#')7555
break;7557
while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )7558
*c = (char) stbi__get8(s);7559
}7560
}7562
static int stbi__pnm_isdigit(char c)7563
{7564
return c >= '0' && c <= '9';7565
}7567
static int stbi__pnm_getinteger(stbi__context *s, char *c)7568
{7569
int value = 0;7571
while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {7572
value = value*10 + (*c - '0');7573
*c = (char) stbi__get8(s);7574
if((value > 214748364) || (value == 214748364 && *c > '7'))7575
return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");7576
}7578
return value;7579
}7581
static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)7582
{7583
int maxv, dummy;7584
char c, p, t;7586
if (!x) x = &dummy;7587
if (!y) y = &dummy;7588
if (!comp) comp = &dummy;7590
stbi__rewind(s);7592
// Get identifier7593
p = (char) stbi__get8(s);7594
t = (char) stbi__get8(s);7595
if (p != 'P' || (t != '5' && t != '6')) {7596
stbi__rewind(s);7597
return 0;7598
}7600
*comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm7602
c = (char) stbi__get8(s);7603
stbi__pnm_skip_whitespace(s, &c);7605
*x = stbi__pnm_getinteger(s, &c); // read width7606
if(*x == 0)7607
return stbi__err("invalid width", "PPM image header had zero or overflowing width");7608
stbi__pnm_skip_whitespace(s, &c);7610
*y = stbi__pnm_getinteger(s, &c); // read height7611
if (*y == 0)7612
return stbi__err("invalid width", "PPM image header had zero or overflowing width");7613
stbi__pnm_skip_whitespace(s, &c);7615
maxv = stbi__pnm_getinteger(s, &c); // read max value7616
if (maxv > 65535)7617
return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");7618
else if (maxv > 255)7619
return 16;7620
else7621
return 8;7622
}7624
static int stbi__pnm_is16(stbi__context *s)7625
{7626
if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)7627
return 1;7628
return 0;7629
}7630
#endif7632
static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)7633
{7634
#ifndef STBI_NO_JPEG7635
if (stbi__jpeg_info(s, x, y, comp)) return 1;7636
#endif7638
#ifndef STBI_NO_PNG7639
if (stbi__png_info(s, x, y, comp)) return 1;7640
#endif7642
#ifndef STBI_NO_GIF7643
if (stbi__gif_info(s, x, y, comp)) return 1;7644
#endif7646
#ifndef STBI_NO_BMP7647
if (stbi__bmp_info(s, x, y, comp)) return 1;7648
#endif7650
#ifndef STBI_NO_PSD7651
if (stbi__psd_info(s, x, y, comp)) return 1;7652
#endif7654
#ifndef STBI_NO_PIC7655
if (stbi__pic_info(s, x, y, comp)) return 1;7656
#endif7658
#ifndef STBI_NO_PNM7659
if (stbi__pnm_info(s, x, y, comp)) return 1;7660
#endif7662
#ifndef STBI_NO_HDR7663
if (stbi__hdr_info(s, x, y, comp)) return 1;7664
#endif7666
// test tga last because it's a crappy test!7667
#ifndef STBI_NO_TGA7668
if (stbi__tga_info(s, x, y, comp))7669
return 1;7670
#endif7671
return stbi__err("unknown image type", "Image not of any known type, or corrupt");7672
}7674
static int stbi__is_16_main(stbi__context *s)7675
{7676
#ifndef STBI_NO_PNG7677
if (stbi__png_is16(s)) return 1;7678
#endif7680
#ifndef STBI_NO_PSD7681
if (stbi__psd_is16(s)) return 1;7682
#endif7684
#ifndef STBI_NO_PNM7685
if (stbi__pnm_is16(s)) return 1;7686
#endif7687
return 0;7688
}7690
#ifndef STBI_NO_STDIO7691
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)7692
{7693
FILE *f = stbi__fopen(filename, "rb");7694
int result;7695
if (!f) return stbi__err("can't fopen", "Unable to open file");7696
result = stbi_info_from_file(f, x, y, comp);7697
fclose(f);7698
return result;7699
}7701
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)7702
{7703
int r;7704
stbi__context s;7705
long pos = ftell(f);7706
stbi__start_file(&s, f);7707
r = stbi__info_main(&s,x,y,comp);7708
fseek(f,pos,SEEK_SET);7709
return r;7710
}7712
STBIDEF int stbi_is_16_bit(char const *filename)7713
{7714
FILE *f = stbi__fopen(filename, "rb");7715
int result;7716
if (!f) return stbi__err("can't fopen", "Unable to open file");7717
result = stbi_is_16_bit_from_file(f);7718
fclose(f);7719
return result;7720
}7722
STBIDEF int stbi_is_16_bit_from_file(FILE *f)7723
{7724
int r;7725
stbi__context s;7726
long pos = ftell(f);7727
stbi__start_file(&s, f);7728
r = stbi__is_16_main(&s);7729
fseek(f,pos,SEEK_SET);7730
return r;7731
}7732
#endif // !STBI_NO_STDIO7734
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)7735
{7736
stbi__context s;7737
stbi__start_mem(&s,buffer,len);7738
return stbi__info_main(&s,x,y,comp);7739
}7741
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)7742
{7743
stbi__context s;7744
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);7745
return stbi__info_main(&s,x,y,comp);7746
}7748
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)7749
{7750
stbi__context s;7751
stbi__start_mem(&s,buffer,len);7752
return stbi__is_16_main(&s);7753
}7755
STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)7756
{7757
stbi__context s;7758
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);7759
return stbi__is_16_main(&s);7760
}7762
#endif // STB_IMAGE_IMPLEMENTATION7764
/*7765
revision history:7766
2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs7767
2.19 (2018-02-11) fix warning7768
2.18 (2018-01-30) fix warnings7769
2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug7770
1-bit BMP7771
*_is_16_bit api7772
avoid warnings7773
2.16 (2017-07-23) all functions have 16-bit variants;7774
STBI_NO_STDIO works again;7775
compilation fixes;7776
fix rounding in unpremultiply;7777
optimize vertical flip;7778
disable raw_len validation;7779
documentation fixes7780
2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;7781
warning fixes; disable run-time SSE detection on gcc;7782
uniform handling of optional "return" values;7783
thread-safe initialization of zlib tables7784
2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs7785
2.13 (2016-11-29) add 16-bit API, only supported for PNG right now7786
2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes7787
2.11 (2016-04-02) allocate large structures on the stack7788
remove white matting for transparent PSD7789
fix reported channel count for PNG & BMP7790
re-enable SSE2 in non-gcc 64-bit7791
support RGB-formatted JPEG7792
read 16-bit PNGs (only as 8-bit)7793
2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED7794
2.09 (2016-01-16) allow comments in PNM files7795
16-bit-per-pixel TGA (not bit-per-component)7796
info() for TGA could break due to .hdr handling7797
info() for BMP to shares code instead of sloppy parse7798
can use STBI_REALLOC_SIZED if allocator doesn't support realloc7799
code cleanup7800
2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA7801
2.07 (2015-09-13) fix compiler warnings7802
partial animated GIF support7803
limited 16-bpc PSD support7804
#ifdef unused functions7805
bug with < 92 byte PIC,PNM,HDR,TGA7806
2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value7807
2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning7808
2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit7809
2.03 (2015-04-12) extra corruption checking (mmozeiko)7810
stbi_set_flip_vertically_on_load (nguillemot)7811
fix NEON support; fix mingw support7812
2.02 (2015-01-19) fix incorrect assert, fix warning7813
2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse27814
2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG7815
2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)7816
progressive JPEG (stb)7817
PGM/PPM support (Ken Miller)7818
STBI_MALLOC,STBI_REALLOC,STBI_FREE7819
GIF bugfix -- seemingly never worked7820
STBI_NO_*, STBI_ONLY_*7821
1.48 (2014-12-14) fix incorrectly-named assert()7822
1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)7823
optimize PNG (ryg)7824
fix bug in interlaced PNG with user-specified channel count (stb)7825
1.46 (2014-08-26)7826
fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG7827
1.45 (2014-08-16)7828
fix MSVC-ARM internal compiler error by wrapping malloc7829
1.44 (2014-08-07)7830
various warning fixes from Ronny Chevalier7831
1.43 (2014-07-15)7832
fix MSVC-only compiler problem in code changed in 1.427833
1.42 (2014-07-09)7834
don't define _CRT_SECURE_NO_WARNINGS (affects user code)7835
fixes to stbi__cleanup_jpeg path7836
added STBI_ASSERT to avoid requiring assert.h7837
1.41 (2014-06-25)7838
fix search&replace from 1.36 that messed up comments/error messages7839
1.40 (2014-06-22)7840
fix gcc struct-initialization warning7841
1.39 (2014-06-15)7842
fix to TGA optimization when req_comp != number of components in TGA;7843
fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)7844
add support for BMP version 5 (more ignored fields)7845
1.38 (2014-06-06)7846
suppress MSVC warnings on integer casts truncating values7847
fix accidental rename of 'skip' field of I/O7848
1.37 (2014-06-04)7849
remove duplicate typedef7850
1.36 (2014-06-03)7851
convert to header file single-file library7852
if de-iphone isn't set, load iphone images color-swapped instead of returning NULL7853
1.35 (2014-05-27)7854
various warnings7855
fix broken STBI_SIMD path7856
fix bug where stbi_load_from_file no longer left file pointer in correct place7857
fix broken non-easy path for 32-bit BMP (possibly never used)7858
TGA optimization by Arseny Kapoulkine7859
1.34 (unknown)7860
use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case7861
1.33 (2011-07-14)7862
make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements7863
1.32 (2011-07-13)7864
support for "info" function for all supported filetypes (SpartanJ)7865
1.31 (2011-06-20)7866
a few more leak fixes, bug in PNG handling (SpartanJ)7867
1.30 (2011-06-11)7868
added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)7869
removed deprecated format-specific test/load functions7870
removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway7871
error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)7872
fix inefficiency in decoding 32-bit BMP (David Woo)7873
1.29 (2010-08-16)7874
various warning fixes from Aurelien Pocheville7875
1.28 (2010-08-01)7876
fix bug in GIF palette transparency (SpartanJ)7877
1.27 (2010-08-01)7878
cast-to-stbi_uc to fix warnings7879
1.26 (2010-07-24)7880
fix bug in file buffering for PNG reported by SpartanJ7881
1.25 (2010-07-17)7882
refix trans_data warning (Won Chun)7883
1.24 (2010-07-12)7884
perf improvements reading from files on platforms with lock-heavy fgetc()7885
minor perf improvements for jpeg7886
deprecated type-specific functions so we'll get feedback if they're needed7887
attempt to fix trans_data warning (Won Chun)7888
1.23 fixed bug in iPhone support7889
1.22 (2010-07-10)7890
removed image *writing* support7891
stbi_info support from Jetro Lauha7892
GIF support from Jean-Marc Lienher7893
iPhone PNG-extensions from James Brown7894
warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)7895
1.21 fix use of 'stbi_uc' in header (reported by jon blow)7896
1.20 added support for Softimage PIC, by Tom Seddon7897
1.19 bug in interlaced PNG corruption check (found by ryg)7898
1.18 (2008-08-02)7899
fix a threading bug (local mutable static)7900
1.17 support interlaced PNG7901
1.16 major bugfix - stbi__convert_format converted one too many pixels7902
1.15 initialize some fields for thread safety7903
1.14 fix threadsafe conversion bug7904
header-file-only version (#define STBI_HEADER_FILE_ONLY before including)7905
1.13 threadsafe7906
1.12 const qualifiers in the API7907
1.11 Support installable IDCT, colorspace conversion routines7908
1.10 Fixes for 64-bit (don't use "unsigned long")7909
optimized upsampling by Fabian "ryg" Giesen7910
1.09 Fix format-conversion for PSD code (bad global variables!)7911
1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz7912
1.07 attempt to fix C++ warning/errors again7913
1.06 attempt to fix C++ warning/errors again7914
1.05 fix TGA loading to return correct *comp and use good luminance calc7915
1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free7916
1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR7917
1.02 support for (subset of) HDR files, float interface for preferred access to them7918
1.01 fix bug: possible bug in handling right-side up bmps... not sure7919
fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all7920
1.00 interface to zlib that skips zlib header7921
0.99 correct handling of alpha in palette7922
0.98 TGA loader by lonesock; dynamically add loaders (untested)7923
0.97 jpeg errors on too large a file; also catch another malloc failure7924
0.96 fix detection of invalid v value - particleman@mollyrocket forum7925
0.95 during header scan, seek to markers in case of padding7926
0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same7927
0.93 handle jpegtran output; verbose errors7928
0.92 read 4,8,16,24,32-bit BMP files of several formats7929
0.91 output 24-bit Windows 3.0 BMP files7930
0.90 fix a few more warnings; bump version number to approach 1.07931
0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd7932
0.60 fix compiling as c++7933
0.59 fix warnings: merge Dave Moore's -Wall fixes7934
0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian7935
0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available7936
0.56 fix bug: zlib uncompressed mode len vs. nlen7937
0.55 fix bug: restart_interval not initialized to 07938
0.54 allow NULL for 'int *comp'7939
0.53 fix bug in png 3->4; speedup png decoding7940
0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments7941
0.51 obey req_comp requests, 1-component jpegs return as 1-component,7942
on 'test' only check type, not whether we support this variant7943
0.50 (2006-11-19)7944
first released version7945
*/7948
/*7949
------------------------------------------------------------------------------7950
This software is available under 2 licenses -- choose whichever you prefer.7951
------------------------------------------------------------------------------7952
ALTERNATIVE A - MIT License7953
Copyright (c) 2017 Sean Barrett7954
Permission is hereby granted, free of charge, to any person obtaining a copy of7955
this software and associated documentation files (the "Software"), to deal in7956
the Software without restriction, including without limitation the rights to7957
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies7958
of the Software, and to permit persons to whom the Software is furnished to do7959
so, subject to the following conditions:7960
The above copyright notice and this permission notice shall be included in all7961
copies or substantial portions of the Software.7962
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR7963
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,7964
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE7965
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER7966
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,7967
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE7968
SOFTWARE.7969
------------------------------------------------------------------------------7970
ALTERNATIVE B - Public Domain (www.unlicense.org)7971
This is free and unencumbered software released into the public domain.7972
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this7973
software, either in source code form or as a compiled binary, for any purpose,7974
commercial or non-commercial, and by any means.7975
In jurisdictions that recognize copyright laws, the author or authors of this7976
software dedicate any and all copyright interest in the software to the public7977
domain. We make this dedication for the benefit of the public at large and to7978
the detriment of our heirs and successors. We intend this dedication to be an7979
overt act of relinquishment in perpetuity of all present and future rights to7980
this software under copyright law.7981
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR7982
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,7983
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE7984
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN7985
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION7986
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.7987
------------------------------------------------------------------------------7988
*/