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