+8

src/SDL_gpu.c

reviewed

··· 1084 1084 #endif 1085 1085 break; 1086 1086 case 4: 1087 1087 + #if SDL_BYTEORDER == SDL_BIG_ENDIAN 1088 1088 + rmask = 0xff000000; 1089 1089 + gmask = 0x00ff0000; 1090 1090 + bmask = 0x0000ff00; 1091 1091 + amask = 0x000000ff; 1092 1092 + #else 1087 1093 Rmask = 0x000000ff; 1088 1094 Gmask = 0x0000ff00; 1089 1095 Bmask = 0x00ff0000; 1090 1096 Amask = 0xff000000; 1097 1097 + #endif 1091 1098 break; 1092 1099 default: 1093 1100 Rmask = Gmask = Bmask = 0; ··· 1097 1104 } 1098 1105 1099 1106 result = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, channels*8, Rmask, Gmask, Bmask, Amask); 1107 1107 + //result = SDL_CreateRGBSurfaceFrom(data, width, height, channels * 8, width * channels, Rmask, Gmask, Bmask, Amask); 1100 1108 if(result == NULL) 1101 1109 { 1102 1110 GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to create new %dx%d surface", width, height);

+5480 -4323

src/externals/stb_image/stb_image.h

reviewed

··· 1 1 - /* stb_image - v2.08 - public domain image loader - http://nothings.org/stb_image.h 2 2 - no warranty implied; use at your own risk 1 1 + /* stb_image - v2.23 - public domain image loader - http://nothings.org/stb 2 2 + no warranty implied; use at your own risk 3 3 4 4 Do this: 5 5 #define STB_IMAGE_IMPLEMENTATION ··· 21 21 avoid problematic images and only need the trivial interface 22 22 23 23 JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) 24 24 - PNG 1/2/4/8-bit-per-channel (16 bpc not supported) 24 24 + PNG 1/2/4/8/16-bit-per-channel 25 25 26 26 TGA (not sure what subset, if a subset) 27 27 BMP non-1bpp, non-RLE ··· 42 42 Full documentation under "DOCUMENTATION" below. 43 43 44 44 45 45 - Revision 2.00 release notes: 46 46 - 47 47 - - Progressive JPEG is now supported. 48 48 - 49 49 - - PPM and PGM binary formats are now supported, thanks to Ken Miller. 50 50 - 51 51 - - x86 platforms now make use of SSE2 SIMD instructions for 52 52 - JPEG decoding, and ARM platforms can use NEON SIMD if requested. 53 53 - This work was done by Fabian "ryg" Giesen. SSE2 is used by 54 54 - default, but NEON must be enabled explicitly; see docs. 55 55 - 56 56 - With other JPEG optimizations included in this version, we see 57 57 - 2x speedup on a JPEG on an x86 machine, and a 1.5x speedup 58 58 - on a JPEG on an ARM machine, relative to previous versions of this 59 59 - library. The same results will not obtain for all JPGs and for all 60 60 - x86/ARM machines. (Note that progressive JPEGs are significantly 61 61 - slower to decode than regular JPEGs.) This doesn't mean that this 62 62 - is the fastest JPEG decoder in the land; rather, it brings it 63 63 - closer to parity with standard libraries. If you want the fastest 64 64 - decode, look elsewhere. (See "Philosophy" section of docs below.) 65 65 - 66 66 - See final bullet items below for more info on SIMD. 67 67 - 68 68 - - Added STBI_MALLOC, STBI_REALLOC, and STBI_FREE macros for replacing 69 69 - the memory allocator. Unlike other STBI libraries, these macros don't 70 70 - support a context parameter, so if you need to pass a context in to 71 71 - the allocator, you'll have to store it in a global or a thread-local 72 72 - variable. 73 73 - 74 74 - - Split existing STBI_NO_HDR flag into two flags, STBI_NO_HDR and 75 75 - STBI_NO_LINEAR. 76 76 - STBI_NO_HDR: suppress implementation of .hdr reader format 77 77 - STBI_NO_LINEAR: suppress high-dynamic-range light-linear float API 78 78 - 79 79 - - You can suppress implementation of any of the decoders to reduce 80 80 - your code footprint by #defining one or more of the following 81 81 - symbols before creating the implementation. 82 82 - 83 83 - STBI_NO_JPEG 84 84 - STBI_NO_PNG 85 85 - STBI_NO_BMP 86 86 - STBI_NO_PSD 87 87 - STBI_NO_TGA 88 88 - STBI_NO_GIF 89 89 - STBI_NO_HDR 90 90 - STBI_NO_PIC 91 91 - STBI_NO_PNM (.ppm and .pgm) 92 92 - 93 93 - - You can request *only* certain decoders and suppress all other ones 94 94 - (this will be more forward-compatible, as addition of new decoders 95 95 - doesn't require you to disable them explicitly): 96 96 - 97 97 - STBI_ONLY_JPEG 98 98 - STBI_ONLY_PNG 99 99 - STBI_ONLY_BMP 100 100 - STBI_ONLY_PSD 101 101 - STBI_ONLY_TGA 102 102 - STBI_ONLY_GIF 103 103 - STBI_ONLY_HDR 104 104 - STBI_ONLY_PIC 105 105 - STBI_ONLY_PNM (.ppm and .pgm) 106 106 - 107 107 - Note that you can define multiples of these, and you will get all 108 108 - of them ("only x" and "only y" is interpreted to mean "only x&y"). 109 109 - 110 110 - - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still 111 111 - want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB 112 112 - 113 113 - - Compilation of all SIMD code can be suppressed with 114 114 - #define STBI_NO_SIMD 115 115 - It should not be necessary to disable SIMD unless you have issues 116 116 - compiling (e.g. using an x86 compiler which doesn't support SSE 117 117 - intrinsics or that doesn't support the method used to detect 118 118 - SSE2 support at run-time), and even those can be reported as 119 119 - bugs so I can refine the built-in compile-time checking to be 120 120 - smarter. 45 45 + LICENSE 121 46 122 122 - - The old STBI_SIMD system which allowed installing a user-defined 123 123 - IDCT etc. has been removed. If you need this, don't upgrade. My 124 124 - assumption is that almost nobody was doing this, and those who 125 125 - were will find the built-in SIMD more satisfactory anyway. 47 47 + See end of file for license information. 126 48 127 127 - - RGB values computed for JPEG images are slightly different from 128 128 - previous versions of stb_image. (This is due to using less 129 129 - integer precision in SIMD.) The C code has been adjusted so 130 130 - that the same RGB values will be computed regardless of whether 131 131 - SIMD support is available, so your app should always produce 132 132 - consistent results. But these results are slightly different from 133 133 - previous versions. (Specifically, about 3% of available YCbCr values 134 134 - will compute different RGB results from pre-1.49 versions by +-1; 135 135 - most of the deviating values are one smaller in the G channel.) 49 49 + RECENT REVISION HISTORY: 136 50 137 137 - - If you must produce consistent results with previous versions of 138 138 - stb_image, #define STBI_JPEG_OLD and you will get the same results 139 139 - you used to; however, you will not get the SIMD speedups for 140 140 - the YCbCr-to-RGB conversion step (although you should still see 141 141 - significant JPEG speedup from the other changes). 142 142 - 143 143 - Please note that STBI_JPEG_OLD is a temporary feature; it will be 144 144 - removed in future versions of the library. It is only intended for 145 145 - near-term back-compatibility use. 146 146 - 147 147 - 148 148 - Latest revision history: 149 149 - 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA 150 150 - 2.07 (2015-09-13) partial animated GIF support 151 151 - limited 16-bit PSD support 152 152 - minor bugs, code cleanup, and compiler warnings 153 153 - 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value 154 154 - 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning 155 155 - 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit 156 156 - 2.03 (2015-04-12) additional corruption checking 157 157 - stbi_set_flip_vertically_on_load 158 158 - fix NEON support; fix mingw support 159 159 - 2.02 (2015-01-19) fix incorrect assert, fix warning 160 160 - 2.01 (2015-01-17) fix various warnings 161 161 - 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG 162 162 - 2.00 (2014-12-25) optimize JPEG, including x86 SSE2 & ARM NEON SIMD 163 163 - progressive JPEG 164 164 - PGM/PPM support 165 165 - STBI_MALLOC,STBI_REALLOC,STBI_FREE 166 166 - STBI_NO_*, STBI_ONLY_* 167 167 - GIF bugfix 168 168 - 1.48 (2014-12-14) fix incorrectly-named assert() 169 169 - 1.47 (2014-12-14) 1/2/4-bit PNG support (both grayscale and paletted) 170 170 - optimize PNG 171 171 - fix bug in interlaced PNG with user-specified channel count 51 51 + 2.23 (2019-08-11) fix clang static analysis warning 52 52 + 2.22 (2019-03-04) gif fixes, fix warnings 53 53 + 2.21 (2019-02-25) fix typo in comment 54 54 + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 55 55 + 2.19 (2018-02-11) fix warning 56 56 + 2.18 (2018-01-30) fix warnings 57 57 + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings 58 58 + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes 59 59 + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC 60 60 + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs 61 61 + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes 62 62 + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes 63 63 + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 64 64 + RGB-format JPEG; remove white matting in PSD; 65 65 + allocate large structures on the stack; 66 66 + correct channel count for PNG & BMP 67 67 + 2.10 (2016-01-22) avoid warning introduced in 2.09 68 68 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED 172 69 173 70 See end of file for full revision history. 174 71 175 72 176 73 ============================ Contributors ========================= 177 74 178 178 - Image formats Bug fixes & warning fixes 179 179 - Sean Barrett (jpeg, png, bmp) Marc LeBlanc 180 180 - Nicolas Schulz (hdr, psd) Christpher Lloyd 181 181 - Jonathan Dummer (tga) Dave Moore 182 182 - Jean-Marc Lienher (gif) Won Chun 183 183 - Tom Seddon (pic) the Horde3D community 184 184 - Thatcher Ulrich (psd) Janez Zemva 185 185 - Ken Miller (pgm, ppm) Jonathan Blow 186 186 - urraka@github (animated gif) Laurent Gomila 187 187 - Aruelien Pocheville 188 188 - Ryamond Barbiero 189 189 - David Woo 190 190 - Extensions, features Martin Golini 191 191 - Jetro Lauha (stbi_info) Roy Eltham 192 192 - Martin "SpartanJ" Golini (stbi_info) Luke Graham 193 193 - James "moose2000" Brown (iPhone PNG) Thomas Ruf 194 194 - Ben "Disch" Wenger (io callbacks) John Bartholomew 195 195 - Omar Cornut (1/2/4-bit PNG) Ken Hamada 196 196 - Nicolas Guillemot (vertical flip) Cort Stratton 197 197 - Richard Mitton (16-bit PSD) Blazej Dariusz Roszkowski 198 198 - Thibault Reuille 199 199 - Paul Du Bois 200 200 - Guillaume George 201 201 - Jerry Jansson 202 202 - Hayaki Saito 203 203 - Johan Duparc 204 204 - Ronny Chevalier 205 205 - Optimizations & bugfixes Michal Cichon 206 206 - Fabian "ryg" Giesen Tero Hanninen 207 207 - Arseny Kapoulkine Sergio Gonzalez 208 208 - Cass Everitt 209 209 - Engin Manap 210 210 - If your name should be here but Martins Mozeiko 211 211 - isn't, let Sean know. Joseph Thomson 212 212 - Phil Jordan 213 213 - Nathan Reed 214 214 - Michaelangel007@github 215 215 - Nick Verigakis 216 216 - 217 217 - LICENSE 218 218 - 219 219 - This software is in the public domain. Where that dedication is not 220 220 - recognized, you are granted a perpetual, irrevocable license to copy, 221 221 - distribute, and modify this file as you see fit. 75 75 + Image formats Extensions, features 76 76 + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) 77 77 + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) 78 78 + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) 79 79 + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) 80 80 + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) 81 81 + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) 82 82 + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) 83 83 + github:urraka (animated gif) Junggon Kim (PNM comments) 84 84 + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) 85 85 + socks-the-fox (16-bit PNG) 86 86 + Jeremy Sawicki (handle all ImageNet JPGs) 87 87 + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) 88 88 + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) 89 89 + Arseny Kapoulkine 90 90 + John-Mark Allen 91 91 + Carmelo J Fdez-Aguera 222 92 93 93 + Bug & warning fixes 94 94 + Marc LeBlanc David Woo Guillaume George Martins Mozeiko 95 95 + Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan 96 96 + Dave Moore Roy Eltham Hayaki Saito Nathan Reed 97 97 + Won Chun Luke Graham Johan Duparc Nick Verigakis 98 98 + the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh 99 99 + Janez Zemva John Bartholomew Michal Cichon github:romigrou 100 100 + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk 101 101 + Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar 102 102 + Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex 103 103 + Ryamond Barbiero Paul Du Bois Engin Manap github:grim210 104 104 + Aldo Culquicondor Philipp Wiesemann Dale Weiler github:sammyhw 105 105 + Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus 106 106 + Julian Raschke Gregory Mullen Baldur Karlsson github:poppolopoppo 107 107 + Christian Floisand Kevin Schmidt JR Smith github:darealshinji 108 108 + Blazej Dariusz Roszkowski github:Michaelangel007 223 109 */ 224 110 225 111 #ifndef STBI_INCLUDE_STB_IMAGE_H ··· 228 114 // DOCUMENTATION 229 115 // 230 116 // Limitations: 231 231 - // - no 16-bit-per-channel PNG 232 117 // - no 12-bit-per-channel JPEG 233 118 // - no JPEGs with arithmetic coding 234 234 - // - no 1-bit BMP 235 119 // - GIF always returns *comp=4 236 120 // 237 121 // Basic usage (see HDR discussion below for HDR usage): ··· 244 128 // stbi_image_free(data) 245 129 // 246 130 // Standard parameters: 247 247 - // int *x -- outputs image width in pixels 248 248 - // int *y -- outputs image height in pixels 249 249 - // int *comp -- outputs # of image components in image file 250 250 - // int req_comp -- if non-zero, # of image components requested in result 131 131 + // int *x -- outputs image width in pixels 132 132 + // int *y -- outputs image height in pixels 133 133 + // int *channels_in_file -- outputs # of image components in image file 134 134 + // int desired_channels -- if non-zero, # of image components requested in result 251 135 // 252 136 // The return value from an image loader is an 'unsigned char *' which points 253 137 // to the pixel data, or NULL on an allocation failure or if the image is ··· 255 139 // with each pixel consisting of N interleaved 8-bit components; the first 256 140 // pixel pointed to is top-left-most in the image. There is no padding between 257 141 // image scanlines or between pixels, regardless of format. The number of 258 258 - // components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. 259 259 - // If req_comp is non-zero, *comp has the number of components that _would_ 260 260 - // have been output otherwise. E.g. if you set req_comp to 4, you will always 261 261 - // get RGBA output, but you can check *comp to see if it's trivially opaque 262 262 - // because e.g. there were only 3 channels in the source image. 142 142 + // components N is 'desired_channels' if desired_channels is non-zero, or 143 143 + // *channels_in_file otherwise. If desired_channels is non-zero, 144 144 + // *channels_in_file has the number of components that _would_ have been 145 145 + // output otherwise. E.g. if you set desired_channels to 4, you will always 146 146 + // get RGBA output, but you can check *channels_in_file to see if it's trivially 147 147 + // opaque because e.g. there were only 3 channels in the source image. 263 148 // 264 149 // An output image with N components has the following components interleaved 265 150 // in this order in each pixel: ··· 271 156 // 4 red, green, blue, alpha 272 157 // 273 158 // If image loading fails for any reason, the return value will be NULL, 274 274 - // and *x, *y, *comp will be unchanged. The function stbi_failure_reason() 275 275 - // can be queried for an extremely brief, end-user unfriendly explanation 276 276 - // of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid 277 277 - // compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly 159 159 + // and *x, *y, *channels_in_file will be unchanged. The function 160 160 + // stbi_failure_reason() can be queried for an extremely brief, end-user 161 161 + // unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS 162 162 + // to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly 278 163 // more user-friendly ones. 279 164 // 280 165 // Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. 281 166 // 282 167 // =========================================================================== 283 168 // 169 169 + // UNICODE: 170 170 + // 171 171 + // If compiling for Windows and you wish to use Unicode filenames, compile 172 172 + // with 173 173 + // #define STBI_WINDOWS_UTF8 174 174 + // and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert 175 175 + // Windows wchar_t filenames to utf8. 176 176 + // 177 177 + // =========================================================================== 178 178 + // 284 179 // Philosophy 285 180 // 286 181 // stb libraries are designed with the following priorities: ··· 291 186 // 292 187 // Sometimes I let "good performance" creep up in priority over "easy to maintain", 293 188 // and for best performance I may provide less-easy-to-use APIs that give higher 294 294 - // performance, in addition to the easy to use ones. Nevertheless, it's important 189 189 + // performance, in addition to the easy-to-use ones. Nevertheless, it's important 295 190 // to keep in mind that from the standpoint of you, a client of this library, 296 296 - // all you care about is #1 and #3, and stb libraries do not emphasize #3 above all. 191 191 + // all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. 297 192 // 298 193 // Some secondary priorities arise directly from the first two, some of which 299 299 - // make more explicit reasons why performance can't be emphasized. 194 194 + // provide more explicit reasons why performance can't be emphasized. 300 195 // 301 196 // - Portable ("ease of use") 302 302 - // - Small footprint ("easy to maintain") 197 197 + // - Small source code footprint ("easy to maintain") 303 198 // - No dependencies ("ease of use") 304 199 // 305 200 // =========================================================================== ··· 331 226 // (at least this is true for iOS and Android). Therefore, the NEON support is 332 227 // toggled by a build flag: define STBI_NEON to get NEON loops. 333 228 // 334 334 - // The output of the JPEG decoder is slightly different from versions where 335 335 - // SIMD support was introduced (that is, for versions before 1.49). The 336 336 - // difference is only +-1 in the 8-bit RGB channels, and only on a small 337 337 - // fraction of pixels. You can force the pre-1.49 behavior by defining 338 338 - // STBI_JPEG_OLD, but this will disable some of the SIMD decoding path 339 339 - // and hence cost some performance. 340 340 - // 341 229 // If for some reason you do not want to use any of SIMD code, or if 342 230 // you have issues compiling it, you can disable it entirely by 343 231 // defining STBI_NO_SIMD. ··· 346 234 // 347 235 // HDR image support (disable by defining STBI_NO_HDR) 348 236 // 349 349 - // stb_image now supports loading HDR images in general, and currently 350 350 - // the Radiance .HDR file format, although the support is provided 351 351 - // generically. You can still load any file through the existing interface; 352 352 - // if you attempt to load an HDR file, it will be automatically remapped to 353 353 - // LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; 237 237 + // stb_image supports loading HDR images in general, and currently the Radiance 238 238 + // .HDR file format specifically. You can still load any file through the existing 239 239 + // interface; if you attempt to load an HDR file, it will be automatically remapped 240 240 + // to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; 354 241 // both of these constants can be reconfigured through this interface: 355 242 // 356 243 // stbi_hdr_to_ldr_gamma(2.2f); ··· 384 271 // 385 272 // By default we convert iphone-formatted PNGs back to RGB, even though 386 273 // they are internally encoded differently. You can disable this conversion 387 387 - // by by calling stbi_convert_iphone_png_to_rgb(0), in which case 274 274 + // by calling stbi_convert_iphone_png_to_rgb(0), in which case 388 275 // you will always just get the native iphone "format" through (which 389 276 // is BGR stored in RGB). 390 277 // ··· 393 280 // says there's premultiplied data (currently only happens in iPhone images, 394 281 // and only if iPhone convert-to-rgb processing is on). 395 282 // 283 283 + // =========================================================================== 284 284 + // 285 285 + // ADDITIONAL CONFIGURATION 286 286 + // 287 287 + // - You can suppress implementation of any of the decoders to reduce 288 288 + // your code footprint by #defining one or more of the following 289 289 + // symbols before creating the implementation. 290 290 + // 291 291 + // STBI_NO_JPEG 292 292 + // STBI_NO_PNG 293 293 + // STBI_NO_BMP 294 294 + // STBI_NO_PSD 295 295 + // STBI_NO_TGA 296 296 + // STBI_NO_GIF 297 297 + // STBI_NO_HDR 298 298 + // STBI_NO_PIC 299 299 + // STBI_NO_PNM (.ppm and .pgm) 300 300 + // 301 301 + // - You can request *only* certain decoders and suppress all other ones 302 302 + // (this will be more forward-compatible, as addition of new decoders 303 303 + // doesn't require you to disable them explicitly): 304 304 + // 305 305 + // STBI_ONLY_JPEG 306 306 + // STBI_ONLY_PNG 307 307 + // STBI_ONLY_BMP 308 308 + // STBI_ONLY_PSD 309 309 + // STBI_ONLY_TGA 310 310 + // STBI_ONLY_GIF 311 311 + // STBI_ONLY_HDR 312 312 + // STBI_ONLY_PIC 313 313 + // STBI_ONLY_PNM (.ppm and .pgm) 314 314 + // 315 315 + // - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still 316 316 + // want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB 317 317 + // 396 318 397 319 398 320 #ifndef STBI_NO_STDIO ··· 403 325 404 326 enum 405 327 { 406 406 - STBI_default = 0, // only used for req_comp 328 328 + STBI_default = 0, // only used for desired_channels 407 329 408 408 - STBI_grey = 1, 409 409 - STBI_grey_alpha = 2, 410 410 - STBI_rgb = 3, 411 411 - STBI_rgb_alpha = 4 330 330 + STBI_grey = 1, 331 331 + STBI_grey_alpha = 2, 332 332 + STBI_rgb = 3, 333 333 + STBI_rgb_alpha = 4 412 334 }; 413 335 336 336 + #include <stdlib.h> 414 337 typedef unsigned char stbi_uc; 338 338 + typedef unsigned short stbi_us; 415 339 416 340 #ifdef __cplusplus 417 341 extern "C" { 418 342 #endif 419 343 344 344 + #ifndef STBIDEF 420 345 #ifdef STB_IMAGE_STATIC 421 346 #define STBIDEF static 422 347 #else 423 348 #define STBIDEF extern 349 349 + #endif 424 350 #endif 425 351 426 426 - ////////////////////////////////////////////////////////////////////////////// 427 427 - // 428 428 - // PRIMARY API - works on images of any type 429 429 - // 352 352 + ////////////////////////////////////////////////////////////////////////////// 353 353 + // 354 354 + // PRIMARY API - works on images of any type 355 355 + // 356 356 + 357 357 + // 358 358 + // load image by filename, open file, or memory buffer 359 359 + // 360 360 + 361 361 + typedef struct 362 362 + { 363 363 + int (*read) (void* user, char* data, int size); // fill 'data' with 'size' bytes. return number of bytes actually read 364 364 + void (*skip) (void* user, int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative 365 365 + int (*eof) (void* user); // returns nonzero if we are at end of file/data 366 366 + } stbi_io_callbacks; 430 367 431 431 - // 432 432 - // load image by filename, open file, or memory buffer 433 433 - // 368 368 + //////////////////////////////////// 369 369 + // 370 370 + // 8-bits-per-channel interface 371 371 + // 372 372 + 373 373 + STBIDEF stbi_uc* stbi_load_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels); 374 374 + 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); 375 375 + 376 376 + #ifndef STBI_NO_STDIO 377 377 + STBIDEF stbi_uc* stbi_load(char const* filename, int* x, int* y, int* channels_in_file, int desired_channels); 378 378 + STBIDEF stbi_uc* stbi_load_from_file(FILE* f, int* x, int* y, int* channels_in_file, int desired_channels); 379 379 + // for stbi_load_from_file, file pointer is left pointing immediately after image 380 380 + #endif 381 381 + 382 382 + #ifndef STBI_NO_GIF 383 383 + 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); 384 384 + #endif 385 385 + 386 386 + #ifdef STBI_WINDOWS_UTF8 387 387 + STBIDEF int stbi_convert_wchar_to_utf8(char* buffer, size_t bufferlen, const wchar_t* input); 388 388 + #endif 434 389 435 435 - typedef struct 436 436 - { 437 437 - int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read 438 438 - void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative 439 439 - int (*eof) (void *user); // returns nonzero if we are at end of file/data 440 440 - } stbi_io_callbacks; 390 390 + //////////////////////////////////// 391 391 + // 392 392 + // 16-bits-per-channel interface 393 393 + // 441 394 442 442 - STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); 443 443 - STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *comp, int req_comp); 444 444 - STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *comp, int req_comp); 395 395 + 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); 396 396 + 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); 445 397 446 398 #ifndef STBI_NO_STDIO 447 447 - STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); 448 448 - // for stbi_load_from_file, file pointer is left pointing immediately after image 399 399 + STBIDEF stbi_us* stbi_load_16(char const* filename, int* x, int* y, int* channels_in_file, int desired_channels); 400 400 + STBIDEF stbi_us* stbi_load_from_file_16(FILE* f, int* x, int* y, int* channels_in_file, int desired_channels); 449 401 #endif 450 402 403 403 + //////////////////////////////////// 404 404 + // 405 405 + // float-per-channel interface 406 406 + // 451 407 #ifndef STBI_NO_LINEAR 452 452 - STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); 453 453 - STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); 454 454 - STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); 408 408 + STBIDEF float* stbi_loadf_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* channels_in_file, int desired_channels); 409 409 + STBIDEF float* stbi_loadf_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, int* channels_in_file, int desired_channels); 455 410 456 456 - #ifndef STBI_NO_STDIO 457 457 - STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); 458 458 - #endif 411 411 + #ifndef STBI_NO_STDIO 412 412 + STBIDEF float* stbi_loadf(char const* filename, int* x, int* y, int* channels_in_file, int desired_channels); 413 413 + STBIDEF float* stbi_loadf_from_file(FILE* f, int* x, int* y, int* channels_in_file, int desired_channels); 414 414 + #endif 459 415 #endif 460 416 461 417 #ifndef STBI_NO_HDR 462 462 - STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); 463 463 - STBIDEF void stbi_hdr_to_ldr_scale(float scale); 464 464 - #endif 418 418 + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); 419 419 + STBIDEF void stbi_hdr_to_ldr_scale(float scale); 420 420 + #endif // STBI_NO_HDR 465 421 466 422 #ifndef STBI_NO_LINEAR 467 467 - STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); 468 468 - STBIDEF void stbi_ldr_to_hdr_scale(float scale); 469 469 - #endif // STBI_NO_HDR 423 423 + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); 424 424 + STBIDEF void stbi_ldr_to_hdr_scale(float scale); 425 425 + #endif // STBI_NO_LINEAR 470 426 471 471 - // stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR 472 472 - STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); 473 473 - STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); 427 427 + // stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR 428 428 + STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const* clbk, void* user); 429 429 + STBIDEF int stbi_is_hdr_from_memory(stbi_uc const* buffer, int len); 474 430 #ifndef STBI_NO_STDIO 475 475 - STBIDEF int stbi_is_hdr (char const *filename); 476 476 - STBIDEF int stbi_is_hdr_from_file(FILE *f); 431 431 + STBIDEF int stbi_is_hdr(char const* filename); 432 432 + STBIDEF int stbi_is_hdr_from_file(FILE* f); 477 433 #endif // STBI_NO_STDIO 478 434 479 435 480 480 - // get a VERY brief reason for failure 481 481 - // NOT THREADSAFE 482 482 - STBIDEF const char *stbi_failure_reason (void); 436 436 + // get a VERY brief reason for failure 437 437 + // NOT THREADSAFE 438 438 + STBIDEF const char* stbi_failure_reason(void); 483 439 484 484 - // free the loaded image -- this is just free() 485 485 - STBIDEF void stbi_image_free (void *retval_from_stbi_load); 440 440 + // free the loaded image -- this is just free() 441 441 + STBIDEF void stbi_image_free(void* retval_from_stbi_load); 486 442 487 487 - // get image dimensions & components without fully decoding 488 488 - STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); 489 489 - STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); 443 443 + // get image dimensions & components without fully decoding 444 444 + STBIDEF int stbi_info_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp); 445 445 + STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, int* comp); 446 446 + STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const* buffer, int len); 447 447 + STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const* clbk, void* user); 490 448 491 449 #ifndef STBI_NO_STDIO 492 492 - STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); 493 493 - STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); 494 494 - 450 450 + STBIDEF int stbi_info(char const* filename, int* x, int* y, int* comp); 451 451 + STBIDEF int stbi_info_from_file(FILE* f, int* x, int* y, int* comp); 452 452 + STBIDEF int stbi_is_16_bit(char const* filename); 453 453 + STBIDEF int stbi_is_16_bit_from_file(FILE* f); 495 454 #endif 496 455 497 456 498 457 499 499 - // for image formats that explicitly notate that they have premultiplied alpha, 500 500 - // we just return the colors as stored in the file. set this flag to force 501 501 - // unpremultiplication. results are undefined if the unpremultiply overflow. 502 502 - STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); 458 458 + // for image formats that explicitly notate that they have premultiplied alpha, 459 459 + // we just return the colors as stored in the file. set this flag to force 460 460 + // unpremultiplication. results are undefined if the unpremultiply overflow. 461 461 + STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); 503 462 504 504 - // indicate whether we should process iphone images back to canonical format, 505 505 - // or just pass them through "as-is" 506 506 - STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); 463 463 + // indicate whether we should process iphone images back to canonical format, 464 464 + // or just pass them through "as-is" 465 465 + STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); 507 466 508 508 - // flip the image vertically, so the first pixel in the output array is the bottom left 509 509 - STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); 467 467 + // flip the image vertically, so the first pixel in the output array is the bottom left 468 468 + STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); 510 469 511 511 - // ZLIB client - used by PNG, available for other purposes 470 470 + // ZLIB client - used by PNG, available for other purposes 512 471 513 513 - STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); 514 514 - STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); 515 515 - STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); 516 516 - STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); 472 472 + STBIDEF char* stbi_zlib_decode_malloc_guesssize(const char* buffer, int len, int initial_size, int* outlen); 473 473 + STBIDEF char* stbi_zlib_decode_malloc_guesssize_headerflag(const char* buffer, int len, int initial_size, int* outlen, int parse_header); 474 474 + STBIDEF char* stbi_zlib_decode_malloc(const char* buffer, int len, int* outlen); 475 475 + STBIDEF int stbi_zlib_decode_buffer(char* obuffer, int olen, const char* ibuffer, int ilen); 517 476 518 518 - STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); 519 519 - STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); 477 477 + STBIDEF char* stbi_zlib_decode_noheader_malloc(const char* buffer, int len, int* outlen); 478 478 + STBIDEF int stbi_zlib_decode_noheader_buffer(char* obuffer, int olen, const char* ibuffer, int ilen); 520 479 521 480 522 481 #ifdef __cplusplus ··· 534 493 || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ 535 494 || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ 536 495 || defined(STBI_ONLY_ZLIB) 537 537 - #ifndef STBI_ONLY_JPEG 538 538 - #define STBI_NO_JPEG 539 539 - #endif 540 540 - #ifndef STBI_ONLY_PNG 541 541 - #define STBI_NO_PNG 542 542 - #endif 543 543 - #ifndef STBI_ONLY_BMP 544 544 - #define STBI_NO_BMP 545 545 - #endif 546 546 - #ifndef STBI_ONLY_PSD 547 547 - #define STBI_NO_PSD 548 548 - #endif 549 549 - #ifndef STBI_ONLY_TGA 550 550 - #define STBI_NO_TGA 551 551 - #endif 552 552 - #ifndef STBI_ONLY_GIF 553 553 - #define STBI_NO_GIF 554 554 - #endif 555 555 - #ifndef STBI_ONLY_HDR 556 556 - #define STBI_NO_HDR 557 557 - #endif 558 558 - #ifndef STBI_ONLY_PIC 559 559 - #define STBI_NO_PIC 560 560 - #endif 561 561 - #ifndef STBI_ONLY_PNM 562 562 - #define STBI_NO_PNM 563 563 - #endif 496 496 + #ifndef STBI_ONLY_JPEG 497 497 + #define STBI_NO_JPEG 498 498 + #endif 499 499 + #ifndef STBI_ONLY_PNG 500 500 + #define STBI_NO_PNG 501 501 + #endif 502 502 + #ifndef STBI_ONLY_BMP 503 503 + #define STBI_NO_BMP 504 504 + #endif 505 505 + #ifndef STBI_ONLY_PSD 506 506 + #define STBI_NO_PSD 507 507 + #endif 508 508 + #ifndef STBI_ONLY_TGA 509 509 + #define STBI_NO_TGA 510 510 + #endif 511 511 + #ifndef STBI_ONLY_GIF 512 512 + #define STBI_NO_GIF 513 513 + #endif 514 514 + #ifndef STBI_ONLY_HDR 515 515 + #define STBI_NO_HDR 516 516 + #endif 517 517 + #ifndef STBI_ONLY_PIC 518 518 + #define STBI_NO_PIC 519 519 + #endif 520 520 + #ifndef STBI_ONLY_PNM 521 521 + #define STBI_NO_PNM 522 522 + #endif 564 523 #endif 565 524 566 525 #if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) ··· 572 531 #include <stddef.h> // ptrdiff_t on osx 573 532 #include <stdlib.h> 574 533 #include <string.h> 534 534 + #include <limits.h> 575 535 576 536 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) 577 577 - #include <math.h> // ldexp 537 537 + #include <math.h> // ldexp, pow 578 538 #endif 579 539 580 540 #ifndef STBI_NO_STDIO ··· 586 546 #define STBI_ASSERT(x) assert(x) 587 547 #endif 588 548 549 549 + #ifdef __cplusplus 550 550 + #define STBI_EXTERN extern "C" 551 551 + #else 552 552 + #define STBI_EXTERN extern 553 553 + #endif 554 554 + 589 555 590 556 #ifndef _MSC_VER 591 591 - #ifdef __cplusplus 592 592 - #define stbi_inline inline 593 593 - #else 594 594 - #define stbi_inline 595 595 - #endif 557 557 + #ifdef __cplusplus 558 558 + #define stbi_inline inline 559 559 + #else 560 560 + #define stbi_inline 561 561 + #endif 596 562 #else 597 597 - #define stbi_inline __forceinline 563 563 + #define stbi_inline __forceinline 598 564 #endif 599 565 600 566 ··· 612 578 #endif 613 579 614 580 // should produce compiler error if size is wrong 615 615 - typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; 581 581 + typedef unsigned char validate_uint32[sizeof(stbi__uint32) == 4 ? 1 : -1]; 616 582 617 583 #ifdef _MSC_VER 618 584 #define STBI_NOTUSED(v) (void)(v) ··· 625 591 #endif 626 592 627 593 #ifdef STBI_HAS_LROTL 628 628 - #define stbi_lrot(x,y) _lrotl(x,y) 594 594 + #define stbi_lrot(x,y) _lrotl(x,y) 629 595 #else 630 630 - #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) 596 596 + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) 631 597 #endif 632 598 633 633 - #if defined(STBI_MALLOC) && defined(STBI_FREE) && defined(STBI_REALLOC) 599 599 + #if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) 634 600 // ok 635 635 - #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) 601 601 + #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) 636 602 // ok 637 603 #else 638 638 - #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC." 604 604 + #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." 639 605 #endif 640 606 641 607 #ifndef STBI_MALLOC 642 642 - #define STBI_MALLOC(sz) malloc(sz) 643 643 - #define STBI_REALLOC(p,sz) realloc(p,sz) 644 644 - #define STBI_FREE(p) free(p) 608 608 + #define STBI_MALLOC(sz) malloc(sz) 609 609 + #define STBI_REALLOC(p,newsz) realloc(p,newsz) 610 610 + #define STBI_FREE(p) free(p) 611 611 + #endif 612 612 + 613 613 + #ifndef STBI_REALLOC_SIZED 614 614 + #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) 645 615 #endif 646 616 647 617 // x86/x64 detection ··· 651 621 #define STBI__X86_TARGET 652 622 #endif 653 623 654 654 - #if defined(__GNUC__) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) 655 655 - // NOTE: not clear do we actually need this for the 64-bit path? 624 624 + #if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) 656 625 // gcc doesn't support sse2 intrinsics unless you compile with -msse2, 657 657 - // (but compiling with -msse2 allows the compiler to use SSE2 everywhere; 658 658 - // this is just broken and gcc are jerks for not fixing it properly 659 659 - // http://www.virtualdub.org/blog/pivot/entry.php?id=363 ) 626 626 + // which in turn means it gets to use SSE2 everywhere. This is unfortunate, 627 627 + // but previous attempts to provide the SSE2 functions with runtime 628 628 + // detection caused numerous issues. The way architecture extensions are 629 629 + // exposed in GCC/Clang is, sadly, not really suited for one-file libs. 630 630 + // New behavior: if compiled with -msse2, we use SSE2 without any 631 631 + // detection; if not, we don't use it at all. 660 632 #define STBI_NO_SIMD 661 633 #endif 662 634 ··· 675 647 #define STBI_NO_SIMD 676 648 #endif 677 649 678 678 - #if !defined(STBI_NO_SIMD) && defined(STBI__X86_TARGET) 650 650 + #if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) 679 651 #define STBI_SSE2 680 652 #include <emmintrin.h> 681 653 ··· 685 657 #include <intrin.h> // __cpuid 686 658 static int stbi__cpuid3(void) 687 659 { 688 688 - int info[4]; 689 689 - __cpuid(info,1); 690 690 - return info[3]; 660 660 + int info[4]; 661 661 + __cpuid(info, 1); 662 662 + return info[3]; 691 663 } 692 664 #else 693 665 static int stbi__cpuid3(void) 694 666 { 695 695 - int res; 696 696 - __asm { 697 697 - mov eax,1 698 698 - cpuid 699 699 - mov res,edx 700 700 - } 701 701 - return res; 667 667 + int res; 668 668 + __asm { 669 669 + mov eax, 1 670 670 + cpuid 671 671 + mov res, edx 672 672 + } 673 673 + return res; 702 674 } 703 675 #endif 704 676 705 677 #define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name 706 678 707 707 - static int stbi__sse2_available() 679 679 + #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) 680 680 + static int stbi__sse2_available(void) 708 681 { 709 709 - int info3 = stbi__cpuid3(); 710 710 - return ((info3 >> 26) & 1) != 0; 682 682 + int info3 = stbi__cpuid3(); 683 683 + return ((info3 >> 26) & 1) != 0; 711 684 } 685 685 + #endif 686 686 + 712 687 #else // assume GCC-style if not VC++ 713 688 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) 714 689 715 715 - static int stbi__sse2_available() 690 690 + #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) 691 691 + static int stbi__sse2_available(void) 716 692 { 717 717 - #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 // GCC 4.8 or later 718 718 - // GCC 4.8+ has a nice way to do this 719 719 - return __builtin_cpu_supports("sse2"); 720 720 - #else 721 721 - // portable way to do this, preferably without using GCC inline ASM? 722 722 - // just bail for now. 723 723 - return 0; 693 693 + // If we're even attempting to compile this on GCC/Clang, that means 694 694 + // -msse2 is on, which means the compiler is allowed to use SSE2 695 695 + // instructions at will, and so are we. 696 696 + return 1; 697 697 + } 724 698 #endif 725 725 - } 699 699 + 726 700 #endif 727 701 #endif 728 702 ··· 749 723 // contains all the IO context, plus some basic image information 750 724 typedef struct 751 725 { 752 752 - stbi__uint32 img_x, img_y; 753 753 - int img_n, img_out_n; 726 726 + stbi__uint32 img_x, img_y; 727 727 + int img_n, img_out_n; 754 728 755 755 - stbi_io_callbacks io; 756 756 - void *io_user_data; 729 729 + stbi_io_callbacks io; 730 730 + void* io_user_data; 757 731 758 758 - int read_from_callbacks; 759 759 - int buflen; 760 760 - stbi_uc buffer_start[128]; 732 732 + int read_from_callbacks; 733 733 + int buflen; 734 734 + stbi_uc buffer_start[128]; 761 735 762 762 - stbi_uc *img_buffer, *img_buffer_end; 763 763 - stbi_uc *img_buffer_original, *img_buffer_original_end; 736 736 + stbi_uc* img_buffer, * img_buffer_end; 737 737 + stbi_uc* img_buffer_original, * img_buffer_original_end; 764 738 } stbi__context; 765 739 766 740 767 767 - static void stbi__refill_buffer(stbi__context *s); 741 741 + static void stbi__refill_buffer(stbi__context* s); 768 742 769 743 // initialize a memory-decode context 770 770 - static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) 744 744 + static void stbi__start_mem(stbi__context* s, stbi_uc const* buffer, int len) 771 745 { 772 772 - s->io.read = NULL; 773 773 - s->read_from_callbacks = 0; 774 774 - s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; 775 775 - s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; 746 746 + s->io.read = NULL; 747 747 + s->read_from_callbacks = 0; 748 748 + s->img_buffer = s->img_buffer_original = (stbi_uc*)buffer; 749 749 + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc*)buffer + len; 776 750 } 777 751 778 752 // initialize a callback-based context 779 779 - static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) 753 753 + static void stbi__start_callbacks(stbi__context* s, stbi_io_callbacks* c, void* user) 780 754 { 781 781 - s->io = *c; 782 782 - s->io_user_data = user; 783 783 - s->buflen = sizeof(s->buffer_start); 784 784 - s->read_from_callbacks = 1; 785 785 - s->img_buffer_original = s->buffer_start; 786 786 - stbi__refill_buffer(s); 787 787 - s->img_buffer_original_end = s->img_buffer_end; 755 755 + s->io = *c; 756 756 + s->io_user_data = user; 757 757 + s->buflen = sizeof(s->buffer_start); 758 758 + s->read_from_callbacks = 1; 759 759 + s->img_buffer_original = s->buffer_start; 760 760 + stbi__refill_buffer(s); 761 761 + s->img_buffer_original_end = s->img_buffer_end; 788 762 } 789 763 790 764 #ifndef STBI_NO_STDIO 791 765 792 792 - static int stbi__stdio_read(void *user, char *data, int size) 766 766 + static int stbi__stdio_read(void* user, char* data, int size) 793 767 { 794 794 - return (int) fread(data,1,size,(FILE*) user); 768 768 + return (int)fread(data, 1, size, (FILE*)user); 795 769 } 796 770 797 797 - static void stbi__stdio_skip(void *user, int n) 771 771 + static void stbi__stdio_skip(void* user, int n) 798 772 { 799 799 - fseek((FILE*) user, n, SEEK_CUR); 773 773 + fseek((FILE*)user, n, SEEK_CUR); 800 774 } 801 775 802 802 - static int stbi__stdio_eof(void *user) 776 776 + static int stbi__stdio_eof(void* user) 803 777 { 804 804 - return feof((FILE*) user); 778 778 + return feof((FILE*)user); 805 779 } 806 780 807 781 static stbi_io_callbacks stbi__stdio_callbacks = ··· 811 785 stbi__stdio_eof, 812 786 }; 813 787 814 814 - static void stbi__start_file(stbi__context *s, FILE *f) 788 788 + static void stbi__start_file(stbi__context* s, FILE* f) 815 789 { 816 816 - stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); 790 790 + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void*)f); 817 791 } 818 792 819 793 //static void stop_file(stbi__context *s) { } 820 794 821 795 #endif // !STBI_NO_STDIO 822 796 823 823 - static void stbi__rewind(stbi__context *s) 797 797 + static void stbi__rewind(stbi__context* s) 824 798 { 825 825 - // conceptually rewind SHOULD rewind to the beginning of the stream, 826 826 - // but we just rewind to the beginning of the initial buffer, because 827 827 - // we only use it after doing 'test', which only ever looks at at most 92 bytes 828 828 - s->img_buffer = s->img_buffer_original; 829 829 - s->img_buffer_end = s->img_buffer_original_end; 799 799 + // conceptually rewind SHOULD rewind to the beginning of the stream, 800 800 + // but we just rewind to the beginning of the initial buffer, because 801 801 + // we only use it after doing 'test', which only ever looks at at most 92 bytes 802 802 + s->img_buffer = s->img_buffer_original; 803 803 + s->img_buffer_end = s->img_buffer_original_end; 830 804 } 831 805 806 806 + enum 807 807 + { 808 808 + STBI_ORDER_RGB, 809 809 + STBI_ORDER_BGR 810 810 + }; 811 811 + 812 812 + typedef struct 813 813 + { 814 814 + int bits_per_channel; 815 815 + int num_channels; 816 816 + int channel_order; 817 817 + } stbi__result_info; 818 818 + 832 819 #ifndef STBI_NO_JPEG 833 833 - static int stbi__jpeg_test(stbi__context *s); 834 834 - static stbi_uc *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 835 835 - static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); 820 820 + static int stbi__jpeg_test(stbi__context* s); 821 821 + static void* stbi__jpeg_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 822 822 + static int stbi__jpeg_info(stbi__context* s, int* x, int* y, int* comp); 836 823 #endif 837 824 838 825 #ifndef STBI_NO_PNG 839 839 - static int stbi__png_test(stbi__context *s); 840 840 - static stbi_uc *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 841 841 - static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); 826 826 + static int stbi__png_test(stbi__context* s); 827 827 + static void* stbi__png_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 828 828 + static int stbi__png_info(stbi__context* s, int* x, int* y, int* comp); 829 829 + static int stbi__png_is16(stbi__context* s); 842 830 #endif 843 831 844 832 #ifndef STBI_NO_BMP 845 845 - static int stbi__bmp_test(stbi__context *s); 846 846 - static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 847 847 - static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); 833 833 + static int stbi__bmp_test(stbi__context* s); 834 834 + static void* stbi__bmp_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 835 835 + static int stbi__bmp_info(stbi__context* s, int* x, int* y, int* comp); 848 836 #endif 849 837 850 838 #ifndef STBI_NO_TGA 851 851 - static int stbi__tga_test(stbi__context *s); 852 852 - static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 853 853 - static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); 839 839 + static int stbi__tga_test(stbi__context* s); 840 840 + static void* stbi__tga_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 841 841 + static int stbi__tga_info(stbi__context* s, int* x, int* y, int* comp); 854 842 #endif 855 843 856 844 #ifndef STBI_NO_PSD 857 857 - static int stbi__psd_test(stbi__context *s); 858 858 - static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 859 859 - static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); 845 845 + static int stbi__psd_test(stbi__context* s); 846 846 + static void* stbi__psd_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri, int bpc); 847 847 + static int stbi__psd_info(stbi__context* s, int* x, int* y, int* comp); 848 848 + static int stbi__psd_is16(stbi__context* s); 860 849 #endif 861 850 862 851 #ifndef STBI_NO_HDR 863 863 - static int stbi__hdr_test(stbi__context *s); 864 864 - static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 865 865 - static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); 852 852 + static int stbi__hdr_test(stbi__context* s); 853 853 + static float* stbi__hdr_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 854 854 + static int stbi__hdr_info(stbi__context* s, int* x, int* y, int* comp); 866 855 #endif 867 856 868 857 #ifndef STBI_NO_PIC 869 869 - static int stbi__pic_test(stbi__context *s); 870 870 - static stbi_uc *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 871 871 - static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); 858 858 + static int stbi__pic_test(stbi__context* s); 859 859 + static void* stbi__pic_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 860 860 + static int stbi__pic_info(stbi__context* s, int* x, int* y, int* comp); 872 861 #endif 873 862 874 863 #ifndef STBI_NO_GIF 875 875 - static int stbi__gif_test(stbi__context *s); 876 876 - static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 877 877 - static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); 864 864 + static int stbi__gif_test(stbi__context* s); 865 865 + static void* stbi__gif_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 866 866 + static void* stbi__load_gif_main(stbi__context* s, int** delays, int* x, int* y, int* z, int* comp, int req_comp); 867 867 + static int stbi__gif_info(stbi__context* s, int* x, int* y, int* comp); 878 868 #endif 879 869 880 870 #ifndef STBI_NO_PNM 881 881 - static int stbi__pnm_test(stbi__context *s); 882 882 - static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); 883 883 - static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); 871 871 + static int stbi__pnm_test(stbi__context* s); 872 872 + static void* stbi__pnm_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri); 873 873 + static int stbi__pnm_info(stbi__context* s, int* x, int* y, int* comp); 884 874 #endif 885 875 886 876 // this is not threadsafe 887 887 - static const char *stbi__g_failure_reason; 877 877 + static const char* stbi__g_failure_reason; 888 878 889 889 - STBIDEF const char *stbi_failure_reason(void) 879 879 + STBIDEF const char* stbi_failure_reason(void) 890 880 { 891 891 - return stbi__g_failure_reason; 881 881 + return stbi__g_failure_reason; 892 882 } 893 883 894 894 - static int stbi__err(const char *str) 884 884 + static int stbi__err(const char* str) 895 885 { 896 896 - stbi__g_failure_reason = str; 897 897 - return 0; 886 886 + stbi__g_failure_reason = str; 887 887 + return 0; 898 888 } 899 889 900 900 - static void *stbi__malloc(size_t size) 890 890 + static void* stbi__malloc(size_t size) 901 891 { 902 892 return STBI_MALLOC(size); 903 893 } 904 894 895 895 + // stb_image uses ints pervasively, including for offset calculations. 896 896 + // therefore the largest decoded image size we can support with the 897 897 + // current code, even on 64-bit targets, is INT_MAX. this is not a 898 898 + // significant limitation for the intended use case. 899 899 + // 900 900 + // we do, however, need to make sure our size calculations don't 901 901 + // overflow. hence a few helper functions for size calculations that 902 902 + // multiply integers together, making sure that they're non-negative 903 903 + // and no overflow occurs. 904 904 + 905 905 + // return 1 if the sum is valid, 0 on overflow. 906 906 + // negative terms are considered invalid. 907 907 + static int stbi__addsizes_valid(int a, int b) 908 908 + { 909 909 + if (b < 0) return 0; 910 910 + // now 0 <= b <= INT_MAX, hence also 911 911 + // 0 <= INT_MAX - b <= INTMAX. 912 912 + // And "a + b <= INT_MAX" (which might overflow) is the 913 913 + // same as a <= INT_MAX - b (no overflow) 914 914 + return a <= INT_MAX - b; 915 915 + } 916 916 + 917 917 + // returns 1 if the product is valid, 0 on overflow. 918 918 + // negative factors are considered invalid. 919 919 + static int stbi__mul2sizes_valid(int a, int b) 920 920 + { 921 921 + if (a < 0 || b < 0) return 0; 922 922 + if (b == 0) return 1; // mul-by-0 is always safe 923 923 + // portable way to check for no overflows in a*b 924 924 + return a <= INT_MAX / b; 925 925 + } 926 926 + 927 927 + // returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow 928 928 + static int stbi__mad2sizes_valid(int a, int b, int add) 929 929 + { 930 930 + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a * b, add); 931 931 + } 932 932 + 933 933 + // returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow 934 934 + static int stbi__mad3sizes_valid(int a, int b, int c, int add) 935 935 + { 936 936 + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) && 937 937 + stbi__addsizes_valid(a * b * c, add); 938 938 + } 939 939 + 940 940 + // returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow 941 941 + #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) 942 942 + static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) 943 943 + { 944 944 + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) && 945 945 + stbi__mul2sizes_valid(a * b * c, d) && stbi__addsizes_valid(a * b * c * d, add); 946 946 + } 947 947 + #endif 948 948 + 949 949 + // mallocs with size overflow checking 950 950 + static void* stbi__malloc_mad2(int a, int b, int add) 951 951 + { 952 952 + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; 953 953 + return stbi__malloc(a * b + add); 954 954 + } 955 955 + 956 956 + static void* stbi__malloc_mad3(int a, int b, int c, int add) 957 957 + { 958 958 + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; 959 959 + return stbi__malloc(a * b * c + add); 960 960 + } 961 961 + 962 962 + #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) 963 963 + static void* stbi__malloc_mad4(int a, int b, int c, int d, int add) 964 964 + { 965 965 + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; 966 966 + return stbi__malloc(a * b * c * d + add); 967 967 + } 968 968 + #endif 969 969 + 905 970 // stbi__err - error 906 971 // stbi__errpf - error returning pointer to float 907 972 // stbi__errpuc - error returning pointer to unsigned char 908 973 909 974 #ifdef STBI_NO_FAILURE_STRINGS 910 910 - #define stbi__err(x,y) 0 975 975 + #define stbi__err(x,y) 0 911 976 #elif defined(STBI_FAILURE_USERMSG) 912 912 - #define stbi__err(x,y) stbi__err(y) 977 977 + #define stbi__err(x,y) stbi__err(y) 913 978 #else 914 914 - #define stbi__err(x,y) stbi__err(x) 979 979 + #define stbi__err(x,y) stbi__err(x) 915 980 #endif 916 981 917 982 #define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) 918 983 #define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) 919 984 920 920 - STBIDEF void stbi_image_free(void *retval_from_stbi_load) 985 985 + STBIDEF void stbi_image_free(void* retval_from_stbi_load) 921 986 { 922 922 - STBI_FREE(retval_from_stbi_load); 987 987 + STBI_FREE(retval_from_stbi_load); 923 988 } 924 989 925 990 #ifndef STBI_NO_LINEAR 926 926 - static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); 991 991 + static float* stbi__ldr_to_hdr(stbi_uc* data, int x, int y, int comp); 927 992 #endif 928 993 929 994 #ifndef STBI_NO_HDR 930 930 - static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); 995 995 + static stbi_uc* stbi__hdr_to_ldr(float* data, int x, int y, int comp); 931 996 #endif 932 997 933 998 static int stbi__vertically_flip_on_load = 0; ··· 937 1002 stbi__vertically_flip_on_load = flag_true_if_should_flip; 938 1003 } 939 1004 940 940 - static unsigned char *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) 1005 1005 + static void* stbi__load_main(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri, int bpc) 1006 1006 + { 1007 1007 + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields 1008 1008 + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed 1009 1009 + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order 1010 1010 + ri->num_channels = 0; 1011 1011 + 1012 1012 + #ifndef STBI_NO_JPEG 1013 1013 + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s, x, y, comp, req_comp, ri); 1014 1014 + #endif 1015 1015 + #ifndef STBI_NO_PNG 1016 1016 + if (stbi__png_test(s)) return stbi__png_load(s, x, y, comp, req_comp, ri); 1017 1017 + #endif 1018 1018 + #ifndef STBI_NO_BMP 1019 1019 + if (stbi__bmp_test(s)) return stbi__bmp_load(s, x, y, comp, req_comp, ri); 1020 1020 + #endif 1021 1021 + #ifndef STBI_NO_GIF 1022 1022 + if (stbi__gif_test(s)) return stbi__gif_load(s, x, y, comp, req_comp, ri); 1023 1023 + #endif 1024 1024 + #ifndef STBI_NO_PSD 1025 1025 + if (stbi__psd_test(s)) return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc); 1026 1026 + #endif 1027 1027 + #ifndef STBI_NO_PIC 1028 1028 + if (stbi__pic_test(s)) return stbi__pic_load(s, x, y, comp, req_comp, ri); 1029 1029 + #endif 1030 1030 + #ifndef STBI_NO_PNM 1031 1031 + if (stbi__pnm_test(s)) return stbi__pnm_load(s, x, y, comp, req_comp, ri); 1032 1032 + #endif 1033 1033 + 1034 1034 + #ifndef STBI_NO_HDR 1035 1035 + if (stbi__hdr_test(s)) { 1036 1036 + float* hdr = stbi__hdr_load(s, x, y, comp, req_comp, ri); 1037 1037 + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); 1038 1038 + } 1039 1039 + #endif 1040 1040 + 1041 1041 + #ifndef STBI_NO_TGA 1042 1042 + // test tga last because it's a crappy test! 1043 1043 + if (stbi__tga_test(s)) 1044 1044 + return stbi__tga_load(s, x, y, comp, req_comp, ri); 1045 1045 + #endif 1046 1046 + 1047 1047 + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); 1048 1048 + } 1049 1049 + 1050 1050 + static stbi_uc* stbi__convert_16_to_8(stbi__uint16* orig, int w, int h, int channels) 941 1051 { 942 942 - #ifndef STBI_NO_JPEG 943 943 - if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp); 944 944 - #endif 945 945 - #ifndef STBI_NO_PNG 946 946 - if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp); 947 947 - #endif 948 948 - #ifndef STBI_NO_BMP 949 949 - if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp); 950 950 - #endif 951 951 - #ifndef STBI_NO_GIF 952 952 - if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp); 953 953 - #endif 954 954 - #ifndef STBI_NO_PSD 955 955 - if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp); 956 956 - #endif 957 957 - #ifndef STBI_NO_PIC 958 958 - if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp); 959 959 - #endif 960 960 - #ifndef STBI_NO_PNM 961 961 - if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp); 962 962 - #endif 1052 1052 + int i; 1053 1053 + int img_len = w * h * channels; 1054 1054 + stbi_uc* reduced; 963 1055 964 964 - #ifndef STBI_NO_HDR 965 965 - if (stbi__hdr_test(s)) { 966 966 - float *hdr = stbi__hdr_load(s, x,y,comp,req_comp); 967 967 - return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); 968 968 - } 969 969 - #endif 1056 1056 + reduced = (stbi_uc*)stbi__malloc(img_len); 1057 1057 + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); 970 1058 971 971 - #ifndef STBI_NO_TGA 972 972 - // test tga last because it's a crappy test! 973 973 - if (stbi__tga_test(s)) 974 974 - return stbi__tga_load(s,x,y,comp,req_comp); 975 975 - #endif 1059 1059 + for (i = 0; i < img_len; ++i) 1060 1060 + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling 976 1061 977 977 - return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); 1062 1062 + STBI_FREE(orig); 1063 1063 + return reduced; 978 1064 } 979 1065 980 980 - static unsigned char *stbi__load_flip(stbi__context *s, int *x, int *y, int *comp, int req_comp) 1066 1066 + static stbi__uint16* stbi__convert_8_to_16(stbi_uc* orig, int w, int h, int channels) 981 1067 { 982 982 - unsigned char *result = stbi__load_main(s, x, y, comp, req_comp); 1068 1068 + int i; 1069 1069 + int img_len = w * h * channels; 1070 1070 + stbi__uint16* enlarged; 983 1071 984 984 - if (stbi__vertically_flip_on_load && result != NULL) { 985 985 - int w = *x, h = *y; 986 986 - int depth = req_comp ? req_comp : *comp; 987 987 - int row,col,z; 988 988 - stbi_uc temp; 1072 1072 + enlarged = (stbi__uint16*)stbi__malloc(img_len * 2); 1073 1073 + if (enlarged == NULL) return (stbi__uint16*)stbi__errpuc("outofmem", "Out of memory"); 989 1074 990 990 - // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once 991 991 - for (row = 0; row < (h>>1); row++) { 992 992 - for (col = 0; col < w; col++) { 993 993 - for (z = 0; z < depth; z++) { 994 994 - temp = result[(row * w + col) * depth + z]; 995 995 - result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z]; 996 996 - result[((h - row - 1) * w + col) * depth + z] = temp; 997 997 - } 998 998 - } 999 999 - } 1000 1000 - } 1075 1075 + for (i = 0; i < img_len; ++i) 1076 1076 + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff 1001 1077 1002 1002 - return result; 1078 1078 + STBI_FREE(orig); 1079 1079 + return enlarged; 1003 1080 } 1004 1081 1005 1005 - #ifndef STBI_NO_HDR 1006 1006 - static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) 1082 1082 + static void stbi__vertical_flip(void* image, int w, int h, int bytes_per_pixel) 1007 1083 { 1008 1008 - if (stbi__vertically_flip_on_load && result != NULL) { 1009 1009 - int w = *x, h = *y; 1010 1010 - int depth = req_comp ? req_comp : *comp; 1011 1011 - int row,col,z; 1012 1012 - float temp; 1084 1084 + int row; 1085 1085 + size_t bytes_per_row = (size_t)w * bytes_per_pixel; 1086 1086 + stbi_uc temp[2048]; 1087 1087 + stbi_uc* bytes = (stbi_uc*)image; 1013 1088 1014 1014 - // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once 1015 1015 - for (row = 0; row < (h>>1); row++) { 1016 1016 - for (col = 0; col < w; col++) { 1017 1017 - for (z = 0; z < depth; z++) { 1018 1018 - temp = result[(row * w + col) * depth + z]; 1019 1019 - result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z]; 1020 1020 - result[((h - row - 1) * w + col) * depth + z] = temp; 1021 1021 - } 1022 1022 - } 1023 1023 - } 1024 1024 - } 1089 1089 + for (row = 0; row < (h >> 1); row++) { 1090 1090 + stbi_uc* row0 = bytes + row * bytes_per_row; 1091 1091 + stbi_uc* row1 = bytes + (h - row - 1) * bytes_per_row; 1092 1092 + // swap row0 with row1 1093 1093 + size_t bytes_left = bytes_per_row; 1094 1094 + while (bytes_left) { 1095 1095 + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); 1096 1096 + memcpy(temp, row0, bytes_copy); 1097 1097 + memcpy(row0, row1, bytes_copy); 1098 1098 + memcpy(row1, temp, bytes_copy); 1099 1099 + row0 += bytes_copy; 1100 1100 + row1 += bytes_copy; 1101 1101 + bytes_left -= bytes_copy; 1102 1102 + } 1103 1103 + } 1104 1104 + } 1105 1105 + 1106 1106 + #ifndef STBI_NO_GIF 1107 1107 + static void stbi__vertical_flip_slices(void* image, int w, int h, int z, int bytes_per_pixel) 1108 1108 + { 1109 1109 + int slice; 1110 1110 + int slice_size = w * h * bytes_per_pixel; 1111 1111 + 1112 1112 + stbi_uc* bytes = (stbi_uc*)image; 1113 1113 + for (slice = 0; slice < z; ++slice) { 1114 1114 + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 1115 1115 + bytes += slice_size; 1116 1116 + } 1117 1117 + } 1118 1118 + #endif 1119 1119 + 1120 1120 + static unsigned char* stbi__load_and_postprocess_8bit(stbi__context* s, int* x, int* y, int* comp, int req_comp) 1121 1121 + { 1122 1122 + stbi__result_info ri; 1123 1123 + void* result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); 1124 1124 + 1125 1125 + if (result == NULL) 1126 1126 + return NULL; 1127 1127 + 1128 1128 + if (ri.bits_per_channel != 8) { 1129 1129 + STBI_ASSERT(ri.bits_per_channel == 16); 1130 1130 + result = stbi__convert_16_to_8((stbi__uint16*)result, *x, *y, req_comp == 0 ? *comp : req_comp); 1131 1131 + ri.bits_per_channel = 8; 1132 1132 + } 1133 1133 + 1134 1134 + // @TODO: move stbi__convert_format to here 1135 1135 + 1136 1136 + if (stbi__vertically_flip_on_load) { 1137 1137 + int channels = req_comp ? req_comp : *comp; 1138 1138 + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); 1139 1139 + } 1140 1140 + 1141 1141 + return (unsigned char*)result; 1142 1142 + } 1143 1143 + 1144 1144 + static stbi__uint16* stbi__load_and_postprocess_16bit(stbi__context* s, int* x, int* y, int* comp, int req_comp) 1145 1145 + { 1146 1146 + stbi__result_info ri; 1147 1147 + void* result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); 1148 1148 + 1149 1149 + if (result == NULL) 1150 1150 + return NULL; 1151 1151 + 1152 1152 + if (ri.bits_per_channel != 16) { 1153 1153 + STBI_ASSERT(ri.bits_per_channel == 8); 1154 1154 + result = stbi__convert_8_to_16((stbi_uc*)result, *x, *y, req_comp == 0 ? *comp : req_comp); 1155 1155 + ri.bits_per_channel = 16; 1156 1156 + } 1157 1157 + 1158 1158 + // @TODO: move stbi__convert_format16 to here 1159 1159 + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision 1160 1160 + 1161 1161 + if (stbi__vertically_flip_on_load) { 1162 1162 + int channels = req_comp ? req_comp : *comp; 1163 1163 + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); 1164 1164 + } 1165 1165 + 1166 1166 + return (stbi__uint16*)result; 1167 1167 + } 1168 1168 + 1169 1169 + #if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) 1170 1170 + static void stbi__float_postprocess(float* result, int* x, int* y, int* comp, int req_comp) 1171 1171 + { 1172 1172 + if (stbi__vertically_flip_on_load && result != NULL) { 1173 1173 + int channels = req_comp ? req_comp : *comp; 1174 1174 + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); 1175 1175 + } 1025 1176 } 1026 1177 #endif 1027 1178 1028 1179 #ifndef STBI_NO_STDIO 1029 1180 1030 1030 - static FILE *stbi__fopen(char const *filename, char const *mode) 1181 1181 + #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) 1182 1182 + STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char* str, int cbmb, wchar_t* widestr, int cchwide); 1183 1183 + 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); 1184 1184 + #endif 1185 1185 + 1186 1186 + #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) 1187 1187 + STBIDEF int stbi_convert_wchar_to_utf8(char* buffer, size_t bufferlen, const wchar_t* input) 1188 1188 + { 1189 1189 + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int)bufferlen, NULL, NULL); 1190 1190 + } 1191 1191 + #endif 1192 1192 + 1193 1193 + static FILE* stbi__fopen(char const* filename, char const* mode) 1031 1194 { 1032 1032 - FILE *f; 1033 1033 - #if defined(_MSC_VER) && _MSC_VER >= 1400 1034 1034 - if (0 != fopen_s(&f, filename, mode)) 1035 1035 - f=0; 1195 1195 + FILE* f; 1196 1196 + #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8) 1197 1197 + wchar_t wMode[64]; 1198 1198 + wchar_t wFilename[1024]; 1199 1199 + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename))) 1200 1200 + return 0; 1201 1201 + 1202 1202 + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode))) 1203 1203 + return 0; 1204 1204 + 1205 1205 + #if _MSC_VER >= 1400 1206 1206 + if (0 != _wfopen_s(&f, wFilename, wMode)) 1207 1207 + f = 0; 1036 1208 #else 1037 1037 - f = fopen(filename, mode); 1209 1209 + f = _wfopen(wFilename, wMode); 1038 1210 #endif 1039 1039 - return f; 1211 1211 + 1212 1212 + #elif defined(_MSC_VER) && _MSC_VER >= 1400 1213 1213 + if (0 != fopen_s(&f, filename, mode)) 1214 1214 + f = 0; 1215 1215 + #else 1216 1216 + f = fopen(filename, mode); 1217 1217 + #endif 1218 1218 + return f; 1040 1219 } 1041 1220 1042 1221 1043 1043 - STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) 1222 1222 + STBIDEF stbi_uc* stbi_load(char const* filename, int* x, int* y, int* comp, int req_comp) 1044 1223 { 1045 1045 - FILE *f = stbi__fopen(filename, "rb"); 1046 1046 - unsigned char *result; 1047 1047 - if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); 1048 1048 - result = stbi_load_from_file(f,x,y,comp,req_comp); 1049 1049 - fclose(f); 1050 1050 - return result; 1224 1224 + FILE* f = stbi__fopen(filename, "rb"); 1225 1225 + unsigned char* result; 1226 1226 + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); 1227 1227 + result = stbi_load_from_file(f, x, y, comp, req_comp); 1228 1228 + fclose(f); 1229 1229 + return result; 1051 1230 } 1052 1231 1053 1053 - STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) 1232 1232 + STBIDEF stbi_uc* stbi_load_from_file(FILE* f, int* x, int* y, int* comp, int req_comp) 1054 1233 { 1055 1055 - unsigned char *result; 1056 1056 - stbi__context s; 1057 1057 - stbi__start_file(&s,f); 1058 1058 - result = stbi__load_flip(&s,x,y,comp,req_comp); 1059 1059 - if (result) { 1060 1060 - // need to 'unget' all the characters in the IO buffer 1061 1061 - fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); 1062 1062 - } 1063 1063 - return result; 1234 1234 + unsigned char* result; 1235 1235 + stbi__context s; 1236 1236 + stbi__start_file(&s, f); 1237 1237 + result = stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp); 1238 1238 + if (result) { 1239 1239 + // need to 'unget' all the characters in the IO buffer 1240 1240 + fseek(f, -(int)(s.img_buffer_end - s.img_buffer), SEEK_CUR); 1241 1241 + } 1242 1242 + return result; 1243 1243 + } 1244 1244 + 1245 1245 + STBIDEF stbi__uint16* stbi_load_from_file_16(FILE* f, int* x, int* y, int* comp, int req_comp) 1246 1246 + { 1247 1247 + stbi__uint16* result; 1248 1248 + stbi__context s; 1249 1249 + stbi__start_file(&s, f); 1250 1250 + result = stbi__load_and_postprocess_16bit(&s, x, y, comp, req_comp); 1251 1251 + if (result) { 1252 1252 + // need to 'unget' all the characters in the IO buffer 1253 1253 + fseek(f, -(int)(s.img_buffer_end - s.img_buffer), SEEK_CUR); 1254 1254 + } 1255 1255 + return result; 1256 1256 + } 1257 1257 + 1258 1258 + STBIDEF stbi_us* stbi_load_16(char const* filename, int* x, int* y, int* comp, int req_comp) 1259 1259 + { 1260 1260 + FILE* f = stbi__fopen(filename, "rb"); 1261 1261 + stbi__uint16* result; 1262 1262 + if (!f) return (stbi_us*)stbi__errpuc("can't fopen", "Unable to open file"); 1263 1263 + result = stbi_load_from_file_16(f, x, y, comp, req_comp); 1264 1264 + fclose(f); 1265 1265 + return result; 1064 1266 } 1267 1267 + 1268 1268 + 1065 1269 #endif //!STBI_NO_STDIO 1066 1270 1067 1067 - STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) 1271 1271 + 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) 1272 1272 + { 1273 1273 + stbi__context s; 1274 1274 + stbi__start_mem(&s, buffer, len); 1275 1275 + return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels); 1276 1276 + } 1277 1277 + 1278 1278 + 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) 1279 1279 + { 1280 1280 + stbi__context s; 1281 1281 + stbi__start_callbacks(&s, (stbi_io_callbacks*)clbk, user); 1282 1282 + return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels); 1283 1283 + } 1284 1284 + 1285 1285 + STBIDEF stbi_uc* stbi_load_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, int req_comp) 1068 1286 { 1069 1069 - stbi__context s; 1070 1070 - stbi__start_mem(&s,buffer,len); 1071 1071 - return stbi__load_flip(&s,x,y,comp,req_comp); 1287 1287 + stbi__context s; 1288 1288 + stbi__start_mem(&s, buffer, len); 1289 1289 + return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp); 1290 1290 + } 1291 1291 + 1292 1292 + STBIDEF stbi_uc* stbi_load_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, int* comp, int req_comp) 1293 1293 + { 1294 1294 + stbi__context s; 1295 1295 + stbi__start_callbacks(&s, (stbi_io_callbacks*)clbk, user); 1296 1296 + return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp); 1072 1297 } 1073 1298 1074 1074 - STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) 1299 1299 + #ifndef STBI_NO_GIF 1300 1300 + 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) 1075 1301 { 1076 1076 - stbi__context s; 1077 1077 - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); 1078 1078 - return stbi__load_flip(&s,x,y,comp,req_comp); 1302 1302 + unsigned char* result; 1303 1303 + stbi__context s; 1304 1304 + stbi__start_mem(&s, buffer, len); 1305 1305 + 1306 1306 + result = (unsigned char*)stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); 1307 1307 + if (stbi__vertically_flip_on_load) { 1308 1308 + stbi__vertical_flip_slices(result, *x, *y, *z, *comp); 1309 1309 + } 1310 1310 + 1311 1311 + return result; 1079 1312 } 1313 1313 + #endif 1080 1314 1081 1315 #ifndef STBI_NO_LINEAR 1082 1082 - static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) 1316 1316 + static float* stbi__loadf_main(stbi__context* s, int* x, int* y, int* comp, int req_comp) 1083 1317 { 1084 1084 - unsigned char *data; 1085 1085 - #ifndef STBI_NO_HDR 1086 1086 - if (stbi__hdr_test(s)) { 1087 1087 - float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp); 1088 1088 - if (hdr_data) 1089 1089 - stbi__float_postprocess(hdr_data,x,y,comp,req_comp); 1090 1090 - return hdr_data; 1091 1091 - } 1092 1092 - #endif 1093 1093 - data = stbi__load_flip(s, x, y, comp, req_comp); 1094 1094 - if (data) 1095 1095 - return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); 1096 1096 - return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); 1318 1318 + unsigned char* data; 1319 1319 + #ifndef STBI_NO_HDR 1320 1320 + if (stbi__hdr_test(s)) { 1321 1321 + stbi__result_info ri; 1322 1322 + float* hdr_data = stbi__hdr_load(s, x, y, comp, req_comp, &ri); 1323 1323 + if (hdr_data) 1324 1324 + stbi__float_postprocess(hdr_data, x, y, comp, req_comp); 1325 1325 + return hdr_data; 1326 1326 + } 1327 1327 + #endif 1328 1328 + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); 1329 1329 + if (data) 1330 1330 + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); 1331 1331 + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); 1097 1332 } 1098 1333 1099 1099 - STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) 1334 1334 + STBIDEF float* stbi_loadf_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, int req_comp) 1100 1335 { 1101 1101 - stbi__context s; 1102 1102 - stbi__start_mem(&s,buffer,len); 1103 1103 - return stbi__loadf_main(&s,x,y,comp,req_comp); 1336 1336 + stbi__context s; 1337 1337 + stbi__start_mem(&s, buffer, len); 1338 1338 + return stbi__loadf_main(&s, x, y, comp, req_comp); 1104 1339 } 1105 1340 1106 1106 - STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) 1341 1341 + STBIDEF float* stbi_loadf_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, int* comp, int req_comp) 1107 1342 { 1108 1108 - stbi__context s; 1109 1109 - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); 1110 1110 - return stbi__loadf_main(&s,x,y,comp,req_comp); 1343 1343 + stbi__context s; 1344 1344 + stbi__start_callbacks(&s, (stbi_io_callbacks*)clbk, user); 1345 1345 + return stbi__loadf_main(&s, x, y, comp, req_comp); 1111 1346 } 1112 1347 1113 1348 #ifndef STBI_NO_STDIO 1114 1114 - STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) 1349 1349 + STBIDEF float* stbi_loadf(char const* filename, int* x, int* y, int* comp, int req_comp) 1115 1350 { 1116 1116 - float *result; 1117 1117 - FILE *f = stbi__fopen(filename, "rb"); 1118 1118 - if (!f) return stbi__errpf("can't fopen", "Unable to open file"); 1119 1119 - result = stbi_loadf_from_file(f,x,y,comp,req_comp); 1120 1120 - fclose(f); 1121 1121 - return result; 1351 1351 + float* result; 1352 1352 + FILE* f = stbi__fopen(filename, "rb"); 1353 1353 + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); 1354 1354 + result = stbi_loadf_from_file(f, x, y, comp, req_comp); 1355 1355 + fclose(f); 1356 1356 + return result; 1122 1357 } 1123 1358 1124 1124 - STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) 1359 1359 + STBIDEF float* stbi_loadf_from_file(FILE* f, int* x, int* y, int* comp, int req_comp) 1125 1360 { 1126 1126 - stbi__context s; 1127 1127 - stbi__start_file(&s,f); 1128 1128 - return stbi__loadf_main(&s,x,y,comp,req_comp); 1361 1361 + stbi__context s; 1362 1362 + stbi__start_file(&s, f); 1363 1363 + return stbi__loadf_main(&s, x, y, comp, req_comp); 1129 1364 } 1130 1365 #endif // !STBI_NO_STDIO 1131 1366 ··· 1135 1370 // defined, for API simplicity; if STBI_NO_LINEAR is defined, it always 1136 1371 // reports false! 1137 1372 1138 1138 - STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) 1373 1373 + STBIDEF int stbi_is_hdr_from_memory(stbi_uc const* buffer, int len) 1139 1374 { 1140 1140 - #ifndef STBI_NO_HDR 1141 1141 - stbi__context s; 1142 1142 - stbi__start_mem(&s,buffer,len); 1143 1143 - return stbi__hdr_test(&s); 1144 1144 - #else 1145 1145 - STBI_NOTUSED(buffer); 1146 1146 - STBI_NOTUSED(len); 1147 1147 - return 0; 1148 1148 - #endif 1375 1375 + #ifndef STBI_NO_HDR 1376 1376 + stbi__context s; 1377 1377 + stbi__start_mem(&s, buffer, len); 1378 1378 + return stbi__hdr_test(&s); 1379 1379 + #else 1380 1380 + STBI_NOTUSED(buffer); 1381 1381 + STBI_NOTUSED(len); 1382 1382 + return 0; 1383 1383 + #endif 1149 1384 } 1150 1385 1151 1386 #ifndef STBI_NO_STDIO 1152 1152 - STBIDEF int stbi_is_hdr (char const *filename) 1387 1387 + STBIDEF int stbi_is_hdr(char const* filename) 1153 1388 { 1154 1154 - FILE *f = stbi__fopen(filename, "rb"); 1155 1155 - int result=0; 1156 1156 - if (f) { 1157 1157 - result = stbi_is_hdr_from_file(f); 1158 1158 - fclose(f); 1159 1159 - } 1160 1160 - return result; 1389 1389 + FILE* f = stbi__fopen(filename, "rb"); 1390 1390 + int result = 0; 1391 1391 + if (f) { 1392 1392 + result = stbi_is_hdr_from_file(f); 1393 1393 + fclose(f); 1394 1394 + } 1395 1395 + return result; 1161 1396 } 1162 1397 1163 1163 - STBIDEF int stbi_is_hdr_from_file(FILE *f) 1398 1398 + STBIDEF int stbi_is_hdr_from_file(FILE* f) 1164 1399 { 1165 1165 - #ifndef STBI_NO_HDR 1166 1166 - stbi__context s; 1167 1167 - stbi__start_file(&s,f); 1168 1168 - return stbi__hdr_test(&s); 1169 1169 - #else 1170 1170 - STBI_NOTUSED(f); 1171 1171 - return 0; 1172 1172 - #endif 1400 1400 + #ifndef STBI_NO_HDR 1401 1401 + long pos = ftell(f); 1402 1402 + int res; 1403 1403 + stbi__context s; 1404 1404 + stbi__start_file(&s, f); 1405 1405 + res = stbi__hdr_test(&s); 1406 1406 + fseek(f, pos, SEEK_SET); 1407 1407 + return res; 1408 1408 + #else 1409 1409 + STBI_NOTUSED(f); 1410 1410 + return 0; 1411 1411 + #endif 1173 1412 } 1174 1413 #endif // !STBI_NO_STDIO 1175 1414 1176 1176 - STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) 1415 1415 + STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const* clbk, void* user) 1177 1416 { 1178 1178 - #ifndef STBI_NO_HDR 1179 1179 - stbi__context s; 1180 1180 - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); 1181 1181 - return stbi__hdr_test(&s); 1182 1182 - #else 1183 1183 - STBI_NOTUSED(clbk); 1184 1184 - STBI_NOTUSED(user); 1185 1185 - return 0; 1186 1186 - #endif 1417 1417 + #ifndef STBI_NO_HDR 1418 1418 + stbi__context s; 1419 1419 + stbi__start_callbacks(&s, (stbi_io_callbacks*)clbk, user); 1420 1420 + return stbi__hdr_test(&s); 1421 1421 + #else 1422 1422 + STBI_NOTUSED(clbk); 1423 1423 + STBI_NOTUSED(user); 1424 1424 + return 0; 1425 1425 + #endif 1187 1426 } 1188 1427 1189 1189 - static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; 1190 1190 - static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; 1191 1191 - 1192 1428 #ifndef STBI_NO_LINEAR 1429 1429 + static float stbi__l2h_gamma = 2.2f, stbi__l2h_scale = 1.0f; 1430 1430 + 1193 1431 STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } 1194 1432 STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } 1195 1433 #endif 1196 1434 1197 1197 - STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } 1198 1198 - STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } 1435 1435 + static float stbi__h2l_gamma_i = 1.0f / 2.2f, stbi__h2l_scale_i = 1.0f; 1436 1436 + 1437 1437 + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1 / gamma; } 1438 1438 + STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1 / scale; } 1199 1439 1200 1440 1201 1441 ////////////////////////////////////////////////////////////////////////////// ··· 1205 1445 1206 1446 enum 1207 1447 { 1208 1208 - STBI__SCAN_load=0, 1209 1209 - STBI__SCAN_type, 1210 1210 - STBI__SCAN_header 1448 1448 + STBI__SCAN_load = 0, 1449 1449 + STBI__SCAN_type, 1450 1450 + STBI__SCAN_header 1211 1451 }; 1212 1452 1213 1213 - static void stbi__refill_buffer(stbi__context *s) 1453 1453 + static void stbi__refill_buffer(stbi__context* s) 1214 1454 { 1215 1215 - int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); 1216 1216 - if (n == 0) { 1217 1217 - // at end of file, treat same as if from memory, but need to handle case 1218 1218 - // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file 1219 1219 - s->read_from_callbacks = 0; 1220 1220 - s->img_buffer = s->buffer_start; 1221 1221 - s->img_buffer_end = s->buffer_start+1; 1222 1222 - *s->img_buffer = 0; 1223 1223 - } else { 1224 1224 - s->img_buffer = s->buffer_start; 1225 1225 - s->img_buffer_end = s->buffer_start + n; 1226 1226 - } 1455 1455 + int n = (s->io.read)(s->io_user_data, (char*)s->buffer_start, s->buflen); 1456 1456 + if (n == 0) { 1457 1457 + // at end of file, treat same as if from memory, but need to handle case 1458 1458 + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file 1459 1459 + s->read_from_callbacks = 0; 1460 1460 + s->img_buffer = s->buffer_start; 1461 1461 + s->img_buffer_end = s->buffer_start + 1; 1462 1462 + *s->img_buffer = 0; 1463 1463 + } 1464 1464 + else { 1465 1465 + s->img_buffer = s->buffer_start; 1466 1466 + s->img_buffer_end = s->buffer_start + n; 1467 1467 + } 1227 1468 } 1228 1469 1229 1229 - stbi_inline static stbi_uc stbi__get8(stbi__context *s) 1470 1470 + stbi_inline static stbi_uc stbi__get8(stbi__context* s) 1230 1471 { 1231 1231 - if (s->img_buffer < s->img_buffer_end) 1232 1232 - return *s->img_buffer++; 1233 1233 - if (s->read_from_callbacks) { 1234 1234 - stbi__refill_buffer(s); 1235 1235 - return *s->img_buffer++; 1236 1236 - } 1237 1237 - return 0; 1472 1472 + if (s->img_buffer < s->img_buffer_end) 1473 1473 + return *s->img_buffer++; 1474 1474 + if (s->read_from_callbacks) { 1475 1475 + stbi__refill_buffer(s); 1476 1476 + return *s->img_buffer++; 1477 1477 + } 1478 1478 + return 0; 1238 1479 } 1239 1480 1240 1240 - stbi_inline static int stbi__at_eof(stbi__context *s) 1481 1481 + stbi_inline static int stbi__at_eof(stbi__context* s) 1241 1482 { 1242 1242 - if (s->io.read) { 1243 1243 - if (!(s->io.eof)(s->io_user_data)) return 0; 1244 1244 - // if feof() is true, check if buffer = end 1245 1245 - // special case: we've only got the special 0 character at the end 1246 1246 - if (s->read_from_callbacks == 0) return 1; 1247 1247 - } 1483 1483 + if (s->io.read) { 1484 1484 + if (!(s->io.eof)(s->io_user_data)) return 0; 1485 1485 + // if feof() is true, check if buffer = end 1486 1486 + // special case: we've only got the special 0 character at the end 1487 1487 + if (s->read_from_callbacks == 0) return 1; 1488 1488 + } 1248 1489 1249 1249 - return s->img_buffer >= s->img_buffer_end; 1490 1490 + return s->img_buffer >= s->img_buffer_end; 1250 1491 } 1251 1492 1252 1252 - static void stbi__skip(stbi__context *s, int n) 1493 1493 + static void stbi__skip(stbi__context* s, int n) 1253 1494 { 1254 1254 - if (n < 0) { 1255 1255 - s->img_buffer = s->img_buffer_end; 1256 1256 - return; 1257 1257 - } 1258 1258 - if (s->io.read) { 1259 1259 - int blen = (int) (s->img_buffer_end - s->img_buffer); 1260 1260 - if (blen < n) { 1261 1261 - s->img_buffer = s->img_buffer_end; 1262 1262 - (s->io.skip)(s->io_user_data, n - blen); 1263 1263 - return; 1264 1264 - } 1265 1265 - } 1266 1266 - s->img_buffer += n; 1495 1495 + if (n < 0) { 1496 1496 + s->img_buffer = s->img_buffer_end; 1497 1497 + return; 1498 1498 + } 1499 1499 + if (s->io.read) { 1500 1500 + int blen = (int)(s->img_buffer_end - s->img_buffer); 1501 1501 + if (blen < n) { 1502 1502 + s->img_buffer = s->img_buffer_end; 1503 1503 + (s->io.skip)(s->io_user_data, n - blen); 1504 1504 + return; 1505 1505 + } 1506 1506 + } 1507 1507 + s->img_buffer += n; 1267 1508 } 1268 1509 1269 1269 - static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) 1510 1510 + static int stbi__getn(stbi__context* s, stbi_uc* buffer, int n) 1270 1511 { 1271 1271 - if (s->io.read) { 1272 1272 - int blen = (int) (s->img_buffer_end - s->img_buffer); 1273 1273 - if (blen < n) { 1274 1274 - int res, count; 1512 1512 + if (s->io.read) { 1513 1513 + int blen = (int)(s->img_buffer_end - s->img_buffer); 1514 1514 + if (blen < n) { 1515 1515 + int res, count; 1275 1516 1276 1276 - memcpy(buffer, s->img_buffer, blen); 1517 1517 + memcpy(buffer, s->img_buffer, blen); 1277 1518 1278 1278 - count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); 1279 1279 - res = (count == (n-blen)); 1280 1280 - s->img_buffer = s->img_buffer_end; 1281 1281 - return res; 1282 1282 - } 1283 1283 - } 1519 1519 + count = (s->io.read)(s->io_user_data, (char*)buffer + blen, n - blen); 1520 1520 + res = (count == (n - blen)); 1521 1521 + s->img_buffer = s->img_buffer_end; 1522 1522 + return res; 1523 1523 + } 1524 1524 + } 1284 1525 1285 1285 - if (s->img_buffer+n <= s->img_buffer_end) { 1286 1286 - memcpy(buffer, s->img_buffer, n); 1287 1287 - s->img_buffer += n; 1288 1288 - return 1; 1289 1289 - } else 1290 1290 - return 0; 1526 1526 + if (s->img_buffer + n <= s->img_buffer_end) { 1527 1527 + memcpy(buffer, s->img_buffer, n); 1528 1528 + s->img_buffer += n; 1529 1529 + return 1; 1530 1530 + } 1531 1531 + else 1532 1532 + return 0; 1291 1533 } 1292 1534 1293 1293 - static int stbi__get16be(stbi__context *s) 1535 1535 + static int stbi__get16be(stbi__context* s) 1294 1536 { 1295 1295 - int z = stbi__get8(s); 1296 1296 - return (z << 8) + stbi__get8(s); 1537 1537 + int z = stbi__get8(s); 1538 1538 + return (z << 8) + stbi__get8(s); 1297 1539 } 1298 1540 1299 1299 - static stbi__uint32 stbi__get32be(stbi__context *s) 1541 1541 + static stbi__uint32 stbi__get32be(stbi__context* s) 1300 1542 { 1301 1301 - stbi__uint32 z = stbi__get16be(s); 1302 1302 - return (z << 16) + stbi__get16be(s); 1543 1543 + stbi__uint32 z = stbi__get16be(s); 1544 1544 + return (z << 16) + stbi__get16be(s); 1303 1545 } 1304 1546 1305 1547 #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) 1306 1548 // nothing 1307 1549 #else 1308 1308 - static int stbi__get16le(stbi__context *s) 1550 1550 + static int stbi__get16le(stbi__context* s) 1309 1551 { 1310 1310 - int z = stbi__get8(s); 1311 1311 - return z + (stbi__get8(s) << 8); 1552 1552 + int z = stbi__get8(s); 1553 1553 + return z + (stbi__get8(s) << 8); 1312 1554 } 1313 1555 #endif 1314 1556 1315 1557 #ifndef STBI_NO_BMP 1316 1316 - static stbi__uint32 stbi__get32le(stbi__context *s) 1558 1558 + static stbi__uint32 stbi__get32le(stbi__context* s) 1317 1559 { 1318 1318 - stbi__uint32 z = stbi__get16le(s); 1319 1319 - return z + (stbi__get16le(s) << 16); 1560 1560 + stbi__uint32 z = stbi__get16le(s); 1561 1561 + return z + (stbi__get16le(s) << 16); 1320 1562 } 1321 1563 #endif 1322 1564 ··· 1336 1578 1337 1579 static stbi_uc stbi__compute_y(int r, int g, int b) 1338 1580 { 1339 1339 - return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); 1581 1581 + return (stbi_uc)(((r * 77) + (g * 150) + (29 * b)) >> 8); 1340 1582 } 1341 1583 1342 1342 - static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) 1584 1584 + static unsigned char* stbi__convert_format(unsigned char* data, int img_n, int req_comp, unsigned int x, unsigned int y) 1343 1585 { 1344 1344 - int i,j; 1345 1345 - unsigned char *good; 1586 1586 + int i, j; 1587 1587 + unsigned char* good; 1346 1588 1347 1347 - if (req_comp == img_n) return data; 1348 1348 - STBI_ASSERT(req_comp >= 1 && req_comp <= 4); 1589 1589 + if (req_comp == img_n) return data; 1590 1590 + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); 1591 1591 + 1592 1592 + good = (unsigned char*)stbi__malloc_mad3(req_comp, x, y, 0); 1593 1593 + if (good == NULL) { 1594 1594 + STBI_FREE(data); 1595 1595 + return stbi__errpuc("outofmem", "Out of memory"); 1596 1596 + } 1349 1597 1350 1350 - good = (unsigned char *) stbi__malloc(req_comp * x * y); 1351 1351 - if (good == NULL) { 1352 1352 - STBI_FREE(data); 1353 1353 - return stbi__errpuc("outofmem", "Out of memory"); 1354 1354 - } 1598 1598 + for (j = 0; j < (int)y; ++j) { 1599 1599 + unsigned char* src = data + j * x * img_n; 1600 1600 + unsigned char* dest = good + j * x * req_comp; 1355 1601 1356 1356 - for (j=0; j < (int) y; ++j) { 1357 1357 - unsigned char *src = data + j * x * img_n ; 1358 1358 - unsigned char *dest = good + j * x * req_comp; 1602 1602 + #define STBI__COMBO(a,b) ((a)*8+(b)) 1603 1603 + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) 1604 1604 + // convert source image with img_n components to one with req_comp components; 1605 1605 + // avoid switch per pixel, so use switch per scanline and massive macros 1606 1606 + switch (STBI__COMBO(img_n, req_comp)) { 1607 1607 + STBI__CASE(1, 2) { dest[0] = src[0]; dest[1] = 255; } break; 1608 1608 + STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; } break; 1609 1609 + STBI__CASE(1, 4) { dest[0] = dest[1] = dest[2] = src[0]; dest[3] = 255; } break; 1610 1610 + STBI__CASE(2, 1) { dest[0] = src[0]; } break; 1611 1611 + STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; } break; 1612 1612 + STBI__CASE(2, 4) { dest[0] = dest[1] = dest[2] = src[0]; dest[3] = src[1]; } break; 1613 1613 + STBI__CASE(3, 4) { dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; dest[3] = 255; } break; 1614 1614 + STBI__CASE(3, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); } break; 1615 1615 + STBI__CASE(3, 2) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); dest[1] = 255; } break; 1616 1616 + STBI__CASE(4, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); } break; 1617 1617 + STBI__CASE(4, 2) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); dest[1] = src[3]; } break; 1618 1618 + STBI__CASE(4, 3) { dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; } break; 1619 1619 + default: STBI_ASSERT(0); 1620 1620 + } 1621 1621 + #undef STBI__CASE 1622 1622 + } 1359 1623 1360 1360 - #define COMBO(a,b) ((a)*8+(b)) 1361 1361 - #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) 1362 1362 - // convert source image with img_n components to one with req_comp components; 1363 1363 - // avoid switch per pixel, so use switch per scanline and massive macros 1364 1364 - switch (COMBO(img_n, req_comp)) { 1365 1365 - CASE(1,2) dest[0]=src[0], dest[1]=255; break; 1366 1366 - CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break; 1367 1367 - CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break; 1368 1368 - CASE(2,1) dest[0]=src[0]; break; 1369 1369 - CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break; 1370 1370 - CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break; 1371 1371 - CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break; 1372 1372 - CASE(3,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break; 1373 1373 - CASE(3,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; break; 1374 1374 - CASE(4,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break; 1375 1375 - CASE(4,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break; 1376 1376 - CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break; 1377 1377 - default: STBI_ASSERT(0); 1378 1378 - } 1379 1379 - #undef CASE 1380 1380 - } 1624 1624 + STBI_FREE(data); 1625 1625 + return good; 1626 1626 + } 1381 1627 1382 1382 - STBI_FREE(data); 1383 1383 - return good; 1628 1628 + static stbi__uint16 stbi__compute_y_16(int r, int g, int b) 1629 1629 + { 1630 1630 + return (stbi__uint16)(((r * 77) + (g * 150) + (29 * b)) >> 8); 1631 1631 + } 1632 1632 + 1633 1633 + static stbi__uint16* stbi__convert_format16(stbi__uint16* data, int img_n, int req_comp, unsigned int x, unsigned int y) 1634 1634 + { 1635 1635 + int i, j; 1636 1636 + stbi__uint16* good; 1637 1637 + 1638 1638 + if (req_comp == img_n) return data; 1639 1639 + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); 1640 1640 + 1641 1641 + good = (stbi__uint16*)stbi__malloc(req_comp * x * y * 2); 1642 1642 + if (good == NULL) { 1643 1643 + STBI_FREE(data); 1644 1644 + return (stbi__uint16*)stbi__errpuc("outofmem", "Out of memory"); 1645 1645 + } 1646 1646 + 1647 1647 + for (j = 0; j < (int)y; ++j) { 1648 1648 + stbi__uint16* src = data + j * x * img_n; 1649 1649 + stbi__uint16* dest = good + j * x * req_comp; 1650 1650 + 1651 1651 + #define STBI__COMBO(a,b) ((a)*8+(b)) 1652 1652 + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) 1653 1653 + // convert source image with img_n components to one with req_comp components; 1654 1654 + // avoid switch per pixel, so use switch per scanline and massive macros 1655 1655 + switch (STBI__COMBO(img_n, req_comp)) { 1656 1656 + STBI__CASE(1, 2) { dest[0] = src[0]; dest[1] = 0xffff; } break; 1657 1657 + STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; } break; 1658 1658 + STBI__CASE(1, 4) { dest[0] = dest[1] = dest[2] = src[0]; dest[3] = 0xffff; } break; 1659 1659 + STBI__CASE(2, 1) { dest[0] = src[0]; } break; 1660 1660 + STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; } break; 1661 1661 + STBI__CASE(2, 4) { dest[0] = dest[1] = dest[2] = src[0]; dest[3] = src[1]; } break; 1662 1662 + STBI__CASE(3, 4) { dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; dest[3] = 0xffff; } break; 1663 1663 + STBI__CASE(3, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); } break; 1664 1664 + STBI__CASE(3, 2) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); dest[1] = 0xffff; } break; 1665 1665 + STBI__CASE(4, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); } break; 1666 1666 + STBI__CASE(4, 2) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); dest[1] = src[3]; } break; 1667 1667 + STBI__CASE(4, 3) { dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; } break; 1668 1668 + default: STBI_ASSERT(0); 1669 1669 + } 1670 1670 + #undef STBI__CASE 1671 1671 + } 1672 1672 + 1673 1673 + STBI_FREE(data); 1674 1674 + return good; 1384 1675 } 1385 1676 1386 1677 #ifndef STBI_NO_LINEAR 1387 1387 - static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) 1678 1678 + static float* stbi__ldr_to_hdr(stbi_uc* data, int x, int y, int comp) 1388 1679 { 1389 1389 - int i,k,n; 1390 1390 - float *output = (float *) stbi__malloc(x * y * comp * sizeof(float)); 1391 1391 - if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } 1392 1392 - // compute number of non-alpha components 1393 1393 - if (comp & 1) n = comp; else n = comp-1; 1394 1394 - for (i=0; i < x*y; ++i) { 1395 1395 - for (k=0; k < n; ++k) { 1396 1396 - output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); 1397 1397 - } 1398 1398 - if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; 1399 1399 - } 1400 1400 - STBI_FREE(data); 1401 1401 - return output; 1680 1680 + int i, k, n; 1681 1681 + float* output; 1682 1682 + if (!data) return NULL; 1683 1683 + output = (float*)stbi__malloc_mad4(x, y, comp, sizeof(float), 0); 1684 1684 + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } 1685 1685 + // compute number of non-alpha components 1686 1686 + if (comp & 1) n = comp; else n = comp - 1; 1687 1687 + for (i = 0; i < x * y; ++i) { 1688 1688 + for (k = 0; k < n; ++k) { 1689 1689 + output[i * comp + k] = (float)(pow(data[i * comp + k] / 255.0f, stbi__l2h_gamma) * stbi__l2h_scale); 1690 1690 + } 1691 1691 + } 1692 1692 + if (n < comp) { 1693 1693 + for (i = 0; i < x * y; ++i) { 1694 1694 + output[i * comp + n] = data[i * comp + n] / 255.0f; 1695 1695 + } 1696 1696 + } 1697 1697 + STBI_FREE(data); 1698 1698 + return output; 1402 1699 } 1403 1700 #endif 1404 1701 1405 1702 #ifndef STBI_NO_HDR 1406 1703 #define stbi__float2int(x) ((int) (x)) 1407 1407 - static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) 1704 1704 + static stbi_uc* stbi__hdr_to_ldr(float* data, int x, int y, int comp) 1408 1705 { 1409 1409 - int i,k,n; 1410 1410 - stbi_uc *output = (stbi_uc *) stbi__malloc(x * y * comp); 1411 1411 - if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } 1412 1412 - // compute number of non-alpha components 1413 1413 - if (comp & 1) n = comp; else n = comp-1; 1414 1414 - for (i=0; i < x*y; ++i) { 1415 1415 - for (k=0; k < n; ++k) { 1416 1416 - float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; 1417 1417 - if (z < 0) z = 0; 1418 1418 - if (z > 255) z = 255; 1419 1419 - output[i*comp + k] = (stbi_uc) stbi__float2int(z); 1420 1420 - } 1421 1421 - if (k < comp) { 1422 1422 - float z = data[i*comp+k] * 255 + 0.5f; 1423 1423 - if (z < 0) z = 0; 1424 1424 - if (z > 255) z = 255; 1425 1425 - output[i*comp + k] = (stbi_uc) stbi__float2int(z); 1426 1426 - } 1427 1427 - } 1428 1428 - STBI_FREE(data); 1429 1429 - return output; 1706 1706 + int i, k, n; 1707 1707 + stbi_uc* output; 1708 1708 + if (!data) return NULL; 1709 1709 + output = (stbi_uc*)stbi__malloc_mad3(x, y, comp, 0); 1710 1710 + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } 1711 1711 + // compute number of non-alpha components 1712 1712 + if (comp & 1) n = comp; else n = comp - 1; 1713 1713 + for (i = 0; i < x * y; ++i) { 1714 1714 + for (k = 0; k < n; ++k) { 1715 1715 + float z = (float)pow(data[i * comp + k] * stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; 1716 1716 + if (z < 0) z = 0; 1717 1717 + if (z > 255) z = 255; 1718 1718 + output[i * comp + k] = (stbi_uc)stbi__float2int(z); 1719 1719 + } 1720 1720 + if (k < comp) { 1721 1721 + float z = data[i * comp + k] * 255 + 0.5f; 1722 1722 + if (z < 0) z = 0; 1723 1723 + if (z > 255) z = 255; 1724 1724 + output[i * comp + k] = (stbi_uc)stbi__float2int(z); 1725 1725 + } 1726 1726 + } 1727 1727 + STBI_FREE(data); 1728 1728 + return output; 1430 1729 } 1431 1730 #endif 1432 1731 ··· 1458 1757 1459 1758 typedef struct 1460 1759 { 1461 1461 - stbi_uc fast[1 << FAST_BITS]; 1462 1462 - // weirdly, repacking this into AoS is a 10% speed loss, instead of a win 1463 1463 - stbi__uint16 code[256]; 1464 1464 - stbi_uc values[256]; 1465 1465 - stbi_uc size[257]; 1466 1466 - unsigned int maxcode[18]; 1467 1467 - int delta[17]; // old 'firstsymbol' - old 'firstcode' 1760 1760 + stbi_uc fast[1 << FAST_BITS]; 1761 1761 + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win 1762 1762 + stbi__uint16 code[256]; 1763 1763 + stbi_uc values[256]; 1764 1764 + stbi_uc size[257]; 1765 1765 + unsigned int maxcode[18]; 1766 1766 + int delta[17]; // old 'firstsymbol' - old 'firstcode' 1468 1767 } stbi__huffman; 1469 1768 1470 1769 typedef struct 1471 1770 { 1472 1472 - stbi__context *s; 1473 1473 - stbi__huffman huff_dc[4]; 1474 1474 - stbi__huffman huff_ac[4]; 1475 1475 - stbi_uc dequant[4][64]; 1476 1476 - stbi__int16 fast_ac[4][1 << FAST_BITS]; 1771 1771 + stbi__context* s; 1772 1772 + stbi__huffman huff_dc[4]; 1773 1773 + stbi__huffman huff_ac[4]; 1774 1774 + stbi__uint16 dequant[4][64]; 1775 1775 + stbi__int16 fast_ac[4][1 << FAST_BITS]; 1477 1776 1478 1478 - // sizes for components, interleaved MCUs 1479 1479 - int img_h_max, img_v_max; 1480 1480 - int img_mcu_x, img_mcu_y; 1481 1481 - int img_mcu_w, img_mcu_h; 1777 1777 + // sizes for components, interleaved MCUs 1778 1778 + int img_h_max, img_v_max; 1779 1779 + int img_mcu_x, img_mcu_y; 1780 1780 + int img_mcu_w, img_mcu_h; 1482 1781 1483 1483 - // definition of jpeg image component 1484 1484 - struct 1485 1485 - { 1486 1486 - int id; 1487 1487 - int h,v; 1488 1488 - int tq; 1489 1489 - int hd,ha; 1490 1490 - int dc_pred; 1782 1782 + // definition of jpeg image component 1783 1783 + struct 1784 1784 + { 1785 1785 + int id; 1786 1786 + int h, v; 1787 1787 + int tq; 1788 1788 + int hd, ha; 1789 1789 + int dc_pred; 1491 1790 1492 1492 - int x,y,w2,h2; 1493 1493 - stbi_uc *data; 1494 1494 - void *raw_data, *raw_coeff; 1495 1495 - stbi_uc *linebuf; 1496 1496 - short *coeff; // progressive only 1497 1497 - int coeff_w, coeff_h; // number of 8x8 coefficient blocks 1498 1498 - } img_comp[4]; 1791 1791 + int x, y, w2, h2; 1792 1792 + stbi_uc* data; 1793 1793 + void* raw_data, * raw_coeff; 1794 1794 + stbi_uc* linebuf; 1795 1795 + short* coeff; // progressive only 1796 1796 + int coeff_w, coeff_h; // number of 8x8 coefficient blocks 1797 1797 + } img_comp[4]; 1499 1798 1500 1500 - stbi__uint32 code_buffer; // jpeg entropy-coded buffer 1501 1501 - int code_bits; // number of valid bits 1502 1502 - unsigned char marker; // marker seen while filling entropy buffer 1503 1503 - int nomore; // flag if we saw a marker so must stop 1799 1799 + stbi__uint32 code_buffer; // jpeg entropy-coded buffer 1800 1800 + int code_bits; // number of valid bits 1801 1801 + unsigned char marker; // marker seen while filling entropy buffer 1802 1802 + int nomore; // flag if we saw a marker so must stop 1504 1803 1505 1505 - int progressive; 1506 1506 - int spec_start; 1507 1507 - int spec_end; 1508 1508 - int succ_high; 1509 1509 - int succ_low; 1510 1510 - int eob_run; 1804 1804 + int progressive; 1805 1805 + int spec_start; 1806 1806 + int spec_end; 1807 1807 + int succ_high; 1808 1808 + int succ_low; 1809 1809 + int eob_run; 1810 1810 + int jfif; 1811 1811 + int app14_color_transform; // Adobe APP14 tag 1812 1812 + int rgb; 1511 1813 1512 1512 - int scan_n, order[4]; 1513 1513 - int restart_interval, todo; 1814 1814 + int scan_n, order[4]; 1815 1815 + int restart_interval, todo; 1514 1816 1515 1515 - // kernels 1516 1516 - void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); 1517 1517 - void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); 1518 1518 - stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); 1817 1817 + // kernels 1818 1818 + void (*idct_block_kernel)(stbi_uc* out, int out_stride, short data[64]); 1819 1819 + void (*YCbCr_to_RGB_kernel)(stbi_uc* out, const stbi_uc* y, const stbi_uc* pcb, const stbi_uc* pcr, int count, int step); 1820 1820 + stbi_uc* (*resample_row_hv_2_kernel)(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs); 1519 1821 } stbi__jpeg; 1520 1822 1521 1521 - static int stbi__build_huffman(stbi__huffman *h, int *count) 1823 1823 + static int stbi__build_huffman(stbi__huffman* h, int* count) 1522 1824 { 1523 1523 - int i,j,k=0,code; 1524 1524 - // build size list for each symbol (from JPEG spec) 1525 1525 - for (i=0; i < 16; ++i) 1526 1526 - for (j=0; j < count[i]; ++j) 1527 1527 - h->size[k++] = (stbi_uc) (i+1); 1528 1528 - h->size[k] = 0; 1825 1825 + int i, j, k = 0; 1826 1826 + unsigned int code; 1827 1827 + // build size list for each symbol (from JPEG spec) 1828 1828 + for (i = 0; i < 16; ++i) 1829 1829 + for (j = 0; j < count[i]; ++j) 1830 1830 + h->size[k++] = (stbi_uc)(i + 1); 1831 1831 + h->size[k] = 0; 1529 1832 1530 1530 - // compute actual symbols (from jpeg spec) 1531 1531 - code = 0; 1532 1532 - k = 0; 1533 1533 - for(j=1; j <= 16; ++j) { 1534 1534 - // compute delta to add to code to compute symbol id 1535 1535 - h->delta[j] = k - code; 1536 1536 - if (h->size[k] == j) { 1537 1537 - while (h->size[k] == j) 1538 1538 - h->code[k++] = (stbi__uint16) (code++); 1539 1539 - if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG"); 1540 1540 - } 1541 1541 - // compute largest code + 1 for this size, preshifted as needed later 1542 1542 - h->maxcode[j] = code << (16-j); 1543 1543 - code <<= 1; 1544 1544 - } 1545 1545 - h->maxcode[j] = 0xffffffff; 1833 1833 + // compute actual symbols (from jpeg spec) 1834 1834 + code = 0; 1835 1835 + k = 0; 1836 1836 + for (j = 1; j <= 16; ++j) { 1837 1837 + // compute delta to add to code to compute symbol id 1838 1838 + h->delta[j] = k - code; 1839 1839 + if (h->size[k] == j) { 1840 1840 + while (h->size[k] == j) 1841 1841 + h->code[k++] = (stbi__uint16)(code++); 1842 1842 + if (code - 1 >= (1u << j)) return stbi__err("bad code lengths", "Corrupt JPEG"); 1843 1843 + } 1844 1844 + // compute largest code + 1 for this size, preshifted as needed later 1845 1845 + h->maxcode[j] = code << (16 - j); 1846 1846 + code <<= 1; 1847 1847 + } 1848 1848 + h->maxcode[j] = 0xffffffff; 1546 1849 1547 1547 - // build non-spec acceleration table; 255 is flag for not-accelerated 1548 1548 - memset(h->fast, 255, 1 << FAST_BITS); 1549 1549 - for (i=0; i < k; ++i) { 1550 1550 - int s = h->size[i]; 1551 1551 - if (s <= FAST_BITS) { 1552 1552 - int c = h->code[i] << (FAST_BITS-s); 1553 1553 - int m = 1 << (FAST_BITS-s); 1554 1554 - for (j=0; j < m; ++j) { 1555 1555 - h->fast[c+j] = (stbi_uc) i; 1556 1556 - } 1557 1557 - } 1558 1558 - } 1559 1559 - return 1; 1850 1850 + // build non-spec acceleration table; 255 is flag for not-accelerated 1851 1851 + memset(h->fast, 255, 1 << FAST_BITS); 1852 1852 + for (i = 0; i < k; ++i) { 1853 1853 + int s = h->size[i]; 1854 1854 + if (s <= FAST_BITS) { 1855 1855 + int c = h->code[i] << (FAST_BITS - s); 1856 1856 + int m = 1 << (FAST_BITS - s); 1857 1857 + for (j = 0; j < m; ++j) { 1858 1858 + h->fast[c + j] = (stbi_uc)i; 1859 1859 + } 1860 1860 + } 1861 1861 + } 1862 1862 + return 1; 1560 1863 } 1561 1864 1562 1865 // build a table that decodes both magnitude and value of small ACs in 1563 1866 // one go. 1564 1564 - static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) 1867 1867 + static void stbi__build_fast_ac(stbi__int16* fast_ac, stbi__huffman* h) 1565 1868 { 1566 1566 - int i; 1567 1567 - for (i=0; i < (1 << FAST_BITS); ++i) { 1568 1568 - stbi_uc fast = h->fast[i]; 1569 1569 - fast_ac[i] = 0; 1570 1570 - if (fast < 255) { 1571 1571 - int rs = h->values[fast]; 1572 1572 - int run = (rs >> 4) & 15; 1573 1573 - int magbits = rs & 15; 1574 1574 - int len = h->size[fast]; 1869 1869 + int i; 1870 1870 + for (i = 0; i < (1 << FAST_BITS); ++i) { 1871 1871 + stbi_uc fast = h->fast[i]; 1872 1872 + fast_ac[i] = 0; 1873 1873 + if (fast < 255) { 1874 1874 + int rs = h->values[fast]; 1875 1875 + int run = (rs >> 4) & 15; 1876 1876 + int magbits = rs & 15; 1877 1877 + int len = h->size[fast]; 1575 1878 1576 1576 - if (magbits && len + magbits <= FAST_BITS) { 1577 1577 - // magnitude code followed by receive_extend code 1578 1578 - int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); 1579 1579 - int m = 1 << (magbits - 1); 1580 1580 - if (k < m) k += (-1 << magbits) + 1; 1581 1581 - // if the result is small enough, we can fit it in fast_ac table 1582 1582 - if (k >= -128 && k <= 127) 1583 1583 - fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits)); 1584 1584 - } 1585 1585 - } 1586 1586 - } 1879 1879 + if (magbits && len + magbits <= FAST_BITS) { 1880 1880 + // magnitude code followed by receive_extend code 1881 1881 + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); 1882 1882 + int m = 1 << (magbits - 1); 1883 1883 + if (k < m) k += (~0U << magbits) + 1; 1884 1884 + // if the result is small enough, we can fit it in fast_ac table 1885 1885 + if (k >= -128 && k <= 127) 1886 1886 + fast_ac[i] = (stbi__int16)((k * 256) + (run * 16) + (len + magbits)); 1887 1887 + } 1888 1888 + } 1889 1889 + } 1587 1890 } 1588 1891 1589 1589 - static void stbi__grow_buffer_unsafe(stbi__jpeg *j) 1892 1892 + static void stbi__grow_buffer_unsafe(stbi__jpeg* j) 1590 1893 { 1591 1591 - do { 1592 1592 - int b = j->nomore ? 0 : stbi__get8(j->s); 1593 1593 - if (b == 0xff) { 1594 1594 - int c = stbi__get8(j->s); 1595 1595 - if (c != 0) { 1596 1596 - j->marker = (unsigned char) c; 1597 1597 - j->nomore = 1; 1598 1598 - return; 1599 1599 - } 1600 1600 - } 1601 1601 - j->code_buffer |= b << (24 - j->code_bits); 1602 1602 - j->code_bits += 8; 1603 1603 - } while (j->code_bits <= 24); 1894 1894 + do { 1895 1895 + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); 1896 1896 + if (b == 0xff) { 1897 1897 + int c = stbi__get8(j->s); 1898 1898 + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes 1899 1899 + if (c != 0) { 1900 1900 + j->marker = (unsigned char)c; 1901 1901 + j->nomore = 1; 1902 1902 + return; 1903 1903 + } 1904 1904 + } 1905 1905 + j->code_buffer |= b << (24 - j->code_bits); 1906 1906 + j->code_bits += 8; 1907 1907 + } while (j->code_bits <= 24); 1604 1908 } 1605 1909 1606 1910 // (1 << n) - 1 1607 1607 - static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; 1911 1911 + static const stbi__uint32 stbi__bmask[17] = { 0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535 }; 1608 1912 1609 1913 // decode a jpeg huffman value from the bitstream 1610 1610 - stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) 1914 1914 + stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg* j, stbi__huffman* h) 1611 1915 { 1612 1612 - unsigned int temp; 1613 1613 - int c,k; 1916 1916 + unsigned int temp; 1917 1917 + int c, k; 1614 1918 1615 1615 - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1919 1919 + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1616 1920 1617 1617 - // look at the top FAST_BITS and determine what symbol ID it is, 1618 1618 - // if the code is <= FAST_BITS 1619 1619 - c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); 1620 1620 - k = h->fast[c]; 1621 1621 - if (k < 255) { 1622 1622 - int s = h->size[k]; 1623 1623 - if (s > j->code_bits) 1624 1624 - return -1; 1625 1625 - j->code_buffer <<= s; 1626 1626 - j->code_bits -= s; 1627 1627 - return h->values[k]; 1628 1628 - } 1921 1921 + // look at the top FAST_BITS and determine what symbol ID it is, 1922 1922 + // if the code is <= FAST_BITS 1923 1923 + c = (j->code_buffer >> (32 - FAST_BITS))& ((1 << FAST_BITS) - 1); 1924 1924 + k = h->fast[c]; 1925 1925 + if (k < 255) { 1926 1926 + int s = h->size[k]; 1927 1927 + if (s > j->code_bits) 1928 1928 + return -1; 1929 1929 + j->code_buffer <<= s; 1930 1930 + j->code_bits -= s; 1931 1931 + return h->values[k]; 1932 1932 + } 1629 1933 1630 1630 - // naive test is to shift the code_buffer down so k bits are 1631 1631 - // valid, then test against maxcode. To speed this up, we've 1632 1632 - // preshifted maxcode left so that it has (16-k) 0s at the 1633 1633 - // end; in other words, regardless of the number of bits, it 1634 1634 - // wants to be compared against something shifted to have 16; 1635 1635 - // that way we don't need to shift inside the loop. 1636 1636 - temp = j->code_buffer >> 16; 1637 1637 - for (k=FAST_BITS+1 ; ; ++k) 1638 1638 - if (temp < h->maxcode[k]) 1639 1639 - break; 1640 1640 - if (k == 17) { 1641 1641 - // error! code not found 1642 1642 - j->code_bits -= 16; 1643 1643 - return -1; 1644 1644 - } 1934 1934 + // naive test is to shift the code_buffer down so k bits are 1935 1935 + // valid, then test against maxcode. To speed this up, we've 1936 1936 + // preshifted maxcode left so that it has (16-k) 0s at the 1937 1937 + // end; in other words, regardless of the number of bits, it 1938 1938 + // wants to be compared against something shifted to have 16; 1939 1939 + // that way we don't need to shift inside the loop. 1940 1940 + temp = j->code_buffer >> 16; 1941 1941 + for (k = FAST_BITS + 1; ; ++k) 1942 1942 + if (temp < h->maxcode[k]) 1943 1943 + break; 1944 1944 + if (k == 17) { 1945 1945 + // error! code not found 1946 1946 + j->code_bits -= 16; 1947 1947 + return -1; 1948 1948 + } 1645 1949 1646 1646 - if (k > j->code_bits) 1647 1647 - return -1; 1950 1950 + if (k > j->code_bits) 1951 1951 + return -1; 1648 1952 1649 1649 - // convert the huffman code to the symbol id 1650 1650 - c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; 1651 1651 - STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); 1953 1953 + // convert the huffman code to the symbol id 1954 1954 + c = ((j->code_buffer >> (32 - k))& stbi__bmask[k]) + h->delta[k]; 1955 1955 + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c]))& stbi__bmask[h->size[c]]) == h->code[c]); 1652 1956 1653 1653 - // convert the id to a symbol 1654 1654 - j->code_bits -= k; 1655 1655 - j->code_buffer <<= k; 1656 1656 - return h->values[c]; 1957 1957 + // convert the id to a symbol 1958 1958 + j->code_bits -= k; 1959 1959 + j->code_buffer <<= k; 1960 1960 + return h->values[c]; 1657 1961 } 1658 1962 1659 1963 // bias[n] = (-1<<n) + 1 1660 1660 - static int const stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767}; 1964 1964 + static const int stbi__jbias[16] = { 0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767 }; 1661 1965 1662 1966 // combined JPEG 'receive' and JPEG 'extend', since baseline 1663 1967 // always extends everything it receives. 1664 1664 - stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n) 1968 1968 + stbi_inline static int stbi__extend_receive(stbi__jpeg* j, int n) 1665 1969 { 1666 1666 - unsigned int k; 1667 1667 - int sgn; 1668 1668 - if (j->code_bits < n) stbi__grow_buffer_unsafe(j); 1970 1970 + unsigned int k; 1971 1971 + int sgn; 1972 1972 + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); 1669 1973 1670 1670 - sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB 1671 1671 - k = stbi_lrot(j->code_buffer, n); 1672 1672 - STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); 1673 1673 - j->code_buffer = k & ~stbi__bmask[n]; 1674 1674 - k &= stbi__bmask[n]; 1675 1675 - j->code_bits -= n; 1676 1676 - return k + (stbi__jbias[n] & ~sgn); 1974 1974 + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB 1975 1975 + k = stbi_lrot(j->code_buffer, n); 1976 1976 + STBI_ASSERT(n >= 0 && n < (int)(sizeof(stbi__bmask) / sizeof(*stbi__bmask))); 1977 1977 + j->code_buffer = k & ~stbi__bmask[n]; 1978 1978 + k &= stbi__bmask[n]; 1979 1979 + j->code_bits -= n; 1980 1980 + return k + (stbi__jbias[n] & ~sgn); 1677 1981 } 1678 1982 1679 1983 // get some unsigned bits 1680 1680 - stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) 1984 1984 + stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg* j, int n) 1681 1985 { 1682 1682 - unsigned int k; 1683 1683 - if (j->code_bits < n) stbi__grow_buffer_unsafe(j); 1684 1684 - k = stbi_lrot(j->code_buffer, n); 1685 1685 - j->code_buffer = k & ~stbi__bmask[n]; 1686 1686 - k &= stbi__bmask[n]; 1687 1687 - j->code_bits -= n; 1688 1688 - return k; 1986 1986 + unsigned int k; 1987 1987 + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); 1988 1988 + k = stbi_lrot(j->code_buffer, n); 1989 1989 + j->code_buffer = k & ~stbi__bmask[n]; 1990 1990 + k &= stbi__bmask[n]; 1991 1991 + j->code_bits -= n; 1992 1992 + return k; 1689 1993 } 1690 1994 1691 1691 - stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) 1995 1995 + stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg* j) 1692 1996 { 1693 1693 - unsigned int k; 1694 1694 - if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); 1695 1695 - k = j->code_buffer; 1696 1696 - j->code_buffer <<= 1; 1697 1697 - --j->code_bits; 1698 1698 - return k & 0x80000000; 1997 1997 + unsigned int k; 1998 1998 + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); 1999 1999 + k = j->code_buffer; 2000 2000 + j->code_buffer <<= 1; 2001 2001 + --j->code_bits; 2002 2002 + return k & 0x80000000; 1699 2003 } 1700 2004 1701 2005 // given a value that's at position X in the zigzag stream, 1702 2006 // where does it appear in the 8x8 matrix coded as row-major? 1703 1703 - static stbi_uc stbi__jpeg_dezigzag[64+15] = 2007 2007 + static const stbi_uc stbi__jpeg_dezigzag[64 + 15] = 1704 2008 { 1705 2009 0, 1, 8, 16, 9, 2, 3, 10, 1706 2010 17, 24, 32, 25, 18, 11, 4, 5, ··· 1716 2020 }; 1717 2021 1718 2022 // decode one 64-entry block-- 1719 1719 - static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi_uc *dequant) 2023 2023 + 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) 1720 2024 { 1721 1721 - int diff,dc,k; 1722 1722 - int t; 2025 2025 + int diff, dc, k; 2026 2026 + int t; 1723 2027 1724 1724 - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1725 1725 - t = stbi__jpeg_huff_decode(j, hdc); 1726 1726 - if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); 2028 2028 + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 2029 2029 + t = stbi__jpeg_huff_decode(j, hdc); 2030 2030 + if (t < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); 1727 2031 1728 1728 - // 0 all the ac values now so we can do it 32-bits at a time 1729 1729 - memset(data,0,64*sizeof(data[0])); 2032 2032 + // 0 all the ac values now so we can do it 32-bits at a time 2033 2033 + memset(data, 0, 64 * sizeof(data[0])); 1730 2034 1731 1731 - diff = t ? stbi__extend_receive(j, t) : 0; 1732 1732 - dc = j->img_comp[b].dc_pred + diff; 1733 1733 - j->img_comp[b].dc_pred = dc; 1734 1734 - data[0] = (short) (dc * dequant[0]); 2035 2035 + diff = t ? stbi__extend_receive(j, t) : 0; 2036 2036 + dc = j->img_comp[b].dc_pred + diff; 2037 2037 + j->img_comp[b].dc_pred = dc; 2038 2038 + data[0] = (short)(dc * dequant[0]); 1735 2039 1736 1736 - // decode AC components, see JPEG spec 1737 1737 - k = 1; 1738 1738 - do { 1739 1739 - unsigned int zig; 1740 1740 - int c,r,s; 1741 1741 - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1742 1742 - c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); 1743 1743 - r = fac[c]; 1744 1744 - if (r) { // fast-AC path 1745 1745 - k += (r >> 4) & 15; // run 1746 1746 - s = r & 15; // combined length 1747 1747 - j->code_buffer <<= s; 1748 1748 - j->code_bits -= s; 1749 1749 - // decode into unzigzag'd location 1750 1750 - zig = stbi__jpeg_dezigzag[k++]; 1751 1751 - data[zig] = (short) ((r >> 8) * dequant[zig]); 1752 1752 - } else { 1753 1753 - int rs = stbi__jpeg_huff_decode(j, hac); 1754 1754 - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); 1755 1755 - s = rs & 15; 1756 1756 - r = rs >> 4; 1757 1757 - if (s == 0) { 1758 1758 - if (rs != 0xf0) break; // end block 1759 1759 - k += 16; 1760 1760 - } else { 1761 1761 - k += r; 2040 2040 + // decode AC components, see JPEG spec 2041 2041 + k = 1; 2042 2042 + do { 2043 2043 + unsigned int zig; 2044 2044 + int c, r, s; 2045 2045 + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 2046 2046 + c = (j->code_buffer >> (32 - FAST_BITS))& ((1 << FAST_BITS) - 1); 2047 2047 + r = fac[c]; 2048 2048 + if (r) { // fast-AC path 2049 2049 + k += (r >> 4) & 15; // run 2050 2050 + s = r & 15; // combined length 2051 2051 + j->code_buffer <<= s; 2052 2052 + j->code_bits -= s; 1762 2053 // decode into unzigzag'd location 1763 2054 zig = stbi__jpeg_dezigzag[k++]; 1764 1764 - data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); 1765 1765 - } 1766 1766 - } 1767 1767 - } while (k < 64); 1768 1768 - return 1; 2055 2055 + data[zig] = (short)((r >> 8)* dequant[zig]); 2056 2056 + } 2057 2057 + else { 2058 2058 + int rs = stbi__jpeg_huff_decode(j, hac); 2059 2059 + if (rs < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); 2060 2060 + s = rs & 15; 2061 2061 + r = rs >> 4; 2062 2062 + if (s == 0) { 2063 2063 + if (rs != 0xf0) break; // end block 2064 2064 + k += 16; 2065 2065 + } 2066 2066 + else { 2067 2067 + k += r; 2068 2068 + // decode into unzigzag'd location 2069 2069 + zig = stbi__jpeg_dezigzag[k++]; 2070 2070 + data[zig] = (short)(stbi__extend_receive(j, s) * dequant[zig]); 2071 2071 + } 2072 2072 + } 2073 2073 + } while (k < 64); 2074 2074 + return 1; 1769 2075 } 1770 2076 1771 1771 - static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) 2077 2077 + static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg* j, short data[64], stbi__huffman* hdc, int b) 1772 2078 { 1773 1773 - int diff,dc; 1774 1774 - int t; 1775 1775 - if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); 2079 2079 + int diff, dc; 2080 2080 + int t; 2081 2081 + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); 1776 2082 1777 1777 - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 2083 2083 + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1778 2084 1779 1779 - if (j->succ_high == 0) { 1780 1780 - // first scan for DC coefficient, must be first 1781 1781 - memset(data,0,64*sizeof(data[0])); // 0 all the ac values now 1782 1782 - t = stbi__jpeg_huff_decode(j, hdc); 1783 1783 - diff = t ? stbi__extend_receive(j, t) : 0; 2085 2085 + if (j->succ_high == 0) { 2086 2086 + // first scan for DC coefficient, must be first 2087 2087 + memset(data, 0, 64 * sizeof(data[0])); // 0 all the ac values now 2088 2088 + t = stbi__jpeg_huff_decode(j, hdc); 2089 2089 + diff = t ? stbi__extend_receive(j, t) : 0; 1784 2090 1785 1785 - dc = j->img_comp[b].dc_pred + diff; 1786 1786 - j->img_comp[b].dc_pred = dc; 1787 1787 - data[0] = (short) (dc << j->succ_low); 1788 1788 - } else { 1789 1789 - // refinement scan for DC coefficient 1790 1790 - if (stbi__jpeg_get_bit(j)) 1791 1791 - data[0] += (short) (1 << j->succ_low); 1792 1792 - } 1793 1793 - return 1; 2091 2091 + dc = j->img_comp[b].dc_pred + diff; 2092 2092 + j->img_comp[b].dc_pred = dc; 2093 2093 + data[0] = (short)(dc << j->succ_low); 2094 2094 + } 2095 2095 + else { 2096 2096 + // refinement scan for DC coefficient 2097 2097 + if (stbi__jpeg_get_bit(j)) 2098 2098 + data[0] += (short)(1 << j->succ_low); 2099 2099 + } 2100 2100 + return 1; 1794 2101 } 1795 2102 1796 2103 // @OPTIMIZE: store non-zigzagged during the decode passes, 1797 2104 // and only de-zigzag when dequantizing 1798 1798 - static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) 2105 2105 + static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg* j, short data[64], stbi__huffman* hac, stbi__int16* fac) 1799 2106 { 1800 1800 - int k; 1801 1801 - if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); 2107 2107 + int k; 2108 2108 + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); 1802 2109 1803 1803 - if (j->succ_high == 0) { 1804 1804 - int shift = j->succ_low; 2110 2110 + if (j->succ_high == 0) { 2111 2111 + int shift = j->succ_low; 1805 2112 1806 1806 - if (j->eob_run) { 1807 1807 - --j->eob_run; 1808 1808 - return 1; 1809 1809 - } 2113 2113 + if (j->eob_run) { 2114 2114 + --j->eob_run; 2115 2115 + return 1; 2116 2116 + } 1810 2117 1811 1811 - k = j->spec_start; 1812 1812 - do { 1813 1813 - unsigned int zig; 1814 1814 - int c,r,s; 1815 1815 - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 1816 1816 - c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); 1817 1817 - r = fac[c]; 1818 1818 - if (r) { // fast-AC path 1819 1819 - k += (r >> 4) & 15; // run 1820 1820 - s = r & 15; // combined length 1821 1821 - j->code_buffer <<= s; 1822 1822 - j->code_bits -= s; 1823 1823 - zig = stbi__jpeg_dezigzag[k++]; 1824 1824 - data[zig] = (short) ((r >> 8) << shift); 1825 1825 - } else { 1826 1826 - int rs = stbi__jpeg_huff_decode(j, hac); 1827 1827 - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); 1828 1828 - s = rs & 15; 1829 1829 - r = rs >> 4; 1830 1830 - if (s == 0) { 1831 1831 - if (r < 15) { 1832 1832 - j->eob_run = (1 << r); 1833 1833 - if (r) 1834 1834 - j->eob_run += stbi__jpeg_get_bits(j, r); 1835 1835 - --j->eob_run; 1836 1836 - break; 1837 1837 - } 1838 1838 - k += 16; 1839 1839 - } else { 1840 1840 - k += r; 1841 1841 - zig = stbi__jpeg_dezigzag[k++]; 1842 1842 - data[zig] = (short) (stbi__extend_receive(j,s) << shift); 2118 2118 + k = j->spec_start; 2119 2119 + do { 2120 2120 + unsigned int zig; 2121 2121 + int c, r, s; 2122 2122 + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); 2123 2123 + c = (j->code_buffer >> (32 - FAST_BITS))& ((1 << FAST_BITS) - 1); 2124 2124 + r = fac[c]; 2125 2125 + if (r) { // fast-AC path 2126 2126 + k += (r >> 4) & 15; // run 2127 2127 + s = r & 15; // combined length 2128 2128 + j->code_buffer <<= s; 2129 2129 + j->code_bits -= s; 2130 2130 + zig = stbi__jpeg_dezigzag[k++]; 2131 2131 + data[zig] = (short)((r >> 8) << shift); 2132 2132 + } 2133 2133 + else { 2134 2134 + int rs = stbi__jpeg_huff_decode(j, hac); 2135 2135 + if (rs < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); 2136 2136 + s = rs & 15; 2137 2137 + r = rs >> 4; 2138 2138 + if (s == 0) { 2139 2139 + if (r < 15) { 2140 2140 + j->eob_run = (1 << r); 2141 2141 + if (r) 2142 2142 + j->eob_run += stbi__jpeg_get_bits(j, r); 2143 2143 + --j->eob_run; 2144 2144 + break; 2145 2145 + } 2146 2146 + k += 16; 2147 2147 + } 2148 2148 + else { 2149 2149 + k += r; 2150 2150 + zig = stbi__jpeg_dezigzag[k++]; 2151 2151 + data[zig] = (short)(stbi__extend_receive(j, s) << shift); 2152 2152 + } 1843 2153 } 1844 1844 - } 1845 1845 - } while (k <= j->spec_end); 1846 1846 - } else { 1847 1847 - // refinement scan for these AC coefficients 2154 2154 + } while (k <= j->spec_end); 2155 2155 + } 2156 2156 + else { 2157 2157 + // refinement scan for these AC coefficients 1848 2158 1849 1849 - short bit = (short) (1 << j->succ_low); 2159 2159 + short bit = (short)(1 << j->succ_low); 1850 2160 1851 1851 - if (j->eob_run) { 1852 1852 - --j->eob_run; 1853 1853 - for (k = j->spec_start; k <= j->spec_end; ++k) { 1854 1854 - short *p = &data[stbi__jpeg_dezigzag[k]]; 1855 1855 - if (*p != 0) 1856 1856 - if (stbi__jpeg_get_bit(j)) 1857 1857 - if ((*p & bit)==0) { 1858 1858 - if (*p > 0) 1859 1859 - *p += bit; 1860 1860 - else 1861 1861 - *p -= bit; 1862 1862 - } 1863 1863 - } 1864 1864 - } else { 1865 1865 - k = j->spec_start; 1866 1866 - do { 1867 1867 - int r,s; 1868 1868 - 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 1869 1869 - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); 1870 1870 - s = rs & 15; 1871 1871 - r = rs >> 4; 1872 1872 - if (s == 0) { 1873 1873 - if (r < 15) { 1874 1874 - j->eob_run = (1 << r) - 1; 1875 1875 - if (r) 1876 1876 - j->eob_run += stbi__jpeg_get_bits(j, r); 1877 1877 - r = 64; // force end of block 1878 1878 - } else { 1879 1879 - // r=15 s=0 should write 16 0s, so we just do 1880 1880 - // a run of 15 0s and then write s (which is 0), 1881 1881 - // so we don't have to do anything special here 1882 1882 - } 1883 1883 - } else { 1884 1884 - if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); 1885 1885 - // sign bit 1886 1886 - if (stbi__jpeg_get_bit(j)) 1887 1887 - s = bit; 1888 1888 - else 1889 1889 - s = -bit; 2161 2161 + if (j->eob_run) { 2162 2162 + --j->eob_run; 2163 2163 + for (k = j->spec_start; k <= j->spec_end; ++k) { 2164 2164 + short* p = &data[stbi__jpeg_dezigzag[k]]; 2165 2165 + if (*p != 0) 2166 2166 + if (stbi__jpeg_get_bit(j)) 2167 2167 + if ((*p & bit) == 0) { 2168 2168 + if (*p > 0) 2169 2169 + *p += bit; 2170 2170 + else 2171 2171 + *p -= bit; 2172 2172 + } 1890 2173 } 2174 2174 + } 2175 2175 + else { 2176 2176 + k = j->spec_start; 2177 2177 + do { 2178 2178 + int r, s; 2179 2179 + 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 2180 2180 + if (rs < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); 2181 2181 + s = rs & 15; 2182 2182 + r = rs >> 4; 2183 2183 + if (s == 0) { 2184 2184 + if (r < 15) { 2185 2185 + j->eob_run = (1 << r) - 1; 2186 2186 + if (r) 2187 2187 + j->eob_run += stbi__jpeg_get_bits(j, r); 2188 2188 + r = 64; // force end of block 2189 2189 + } 2190 2190 + else { 2191 2191 + // r=15 s=0 should write 16 0s, so we just do 2192 2192 + // a run of 15 0s and then write s (which is 0), 2193 2193 + // so we don't have to do anything special here 2194 2194 + } 2195 2195 + } 2196 2196 + else { 2197 2197 + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); 2198 2198 + // sign bit 2199 2199 + if (stbi__jpeg_get_bit(j)) 2200 2200 + s = bit; 2201 2201 + else 2202 2202 + s = -bit; 2203 2203 + } 1891 2204 1892 1892 - // advance by r 1893 1893 - while (k <= j->spec_end) { 1894 1894 - short *p = &data[stbi__jpeg_dezigzag[k++]]; 1895 1895 - if (*p != 0) { 1896 1896 - if (stbi__jpeg_get_bit(j)) 1897 1897 - if ((*p & bit)==0) { 1898 1898 - if (*p > 0) 1899 1899 - *p += bit; 1900 1900 - else 1901 1901 - *p -= bit; 1902 1902 - } 1903 1903 - } else { 1904 1904 - if (r == 0) { 1905 1905 - *p = (short) s; 1906 1906 - break; 1907 1907 - } 1908 1908 - --r; 1909 1909 - } 1910 1910 - } 1911 1911 - } while (k <= j->spec_end); 1912 1912 - } 1913 1913 - } 1914 1914 - return 1; 2205 2205 + // advance by r 2206 2206 + while (k <= j->spec_end) { 2207 2207 + short* p = &data[stbi__jpeg_dezigzag[k++]]; 2208 2208 + if (*p != 0) { 2209 2209 + if (stbi__jpeg_get_bit(j)) 2210 2210 + if ((*p & bit) == 0) { 2211 2211 + if (*p > 0) 2212 2212 + *p += bit; 2213 2213 + else 2214 2214 + *p -= bit; 2215 2215 + } 2216 2216 + } 2217 2217 + else { 2218 2218 + if (r == 0) { 2219 2219 + *p = (short)s; 2220 2220 + break; 2221 2221 + } 2222 2222 + --r; 2223 2223 + } 2224 2224 + } 2225 2225 + } while (k <= j->spec_end); 2226 2226 + } 2227 2227 + } 2228 2228 + return 1; 1915 2229 } 1916 2230 1917 2231 // take a -128..127 value and stbi__clamp it and convert to 0..255 1918 2232 stbi_inline static stbi_uc stbi__clamp(int x) 1919 2233 { 1920 1920 - // trick to use a single test to catch both cases 1921 1921 - if ((unsigned int) x > 255) { 1922 1922 - if (x < 0) return 0; 1923 1923 - if (x > 255) return 255; 1924 1924 - } 1925 1925 - return (stbi_uc) x; 2234 2234 + // trick to use a single test to catch both cases 2235 2235 + if ((unsigned int)x > 255) { 2236 2236 + if (x < 0) return 0; 2237 2237 + if (x > 255) return 255; 2238 2238 + } 2239 2239 + return (stbi_uc)x; 1926 2240 } 1927 2241 1928 2242 #define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) 1929 1929 - #define stbi__fsh(x) ((x) << 12) 2243 2243 + #define stbi__fsh(x) ((x) * 4096) 1930 2244 1931 2245 // derived from jidctint -- DCT_ISLOW 1932 2246 #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ ··· 1966 2280 t1 += p2+p4; \ 1967 2281 t0 += p1+p3; 1968 2282 1969 1969 - static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) 2283 2283 + static void stbi__idct_block(stbi_uc* out, int out_stride, short data[64]) 1970 2284 { 1971 1971 - int i,val[64],*v=val; 1972 1972 - stbi_uc *o; 1973 1973 - short *d = data; 2285 2285 + int i, val[64], * v = val; 2286 2286 + stbi_uc* o; 2287 2287 + short* d = data; 1974 2288 1975 1975 - // columns 1976 1976 - for (i=0; i < 8; ++i,++d, ++v) { 1977 1977 - // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing 1978 1978 - if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 1979 1979 - && d[40]==0 && d[48]==0 && d[56]==0) { 1980 1980 - // no shortcut 0 seconds 1981 1981 - // (1|2|3|4|5|6|7)==0 0 seconds 1982 1982 - // all separate -0.047 seconds 1983 1983 - // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds 1984 1984 - int dcterm = d[0] << 2; 1985 1985 - v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; 1986 1986 - } else { 1987 1987 - STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) 1988 1988 - // constants scaled things up by 1<<12; let's bring them back 1989 1989 - // down, but keep 2 extra bits of precision 1990 1990 - x0 += 512; x1 += 512; x2 += 512; x3 += 512; 1991 1991 - v[ 0] = (x0+t3) >> 10; 1992 1992 - v[56] = (x0-t3) >> 10; 1993 1993 - v[ 8] = (x1+t2) >> 10; 1994 1994 - v[48] = (x1-t2) >> 10; 1995 1995 - v[16] = (x2+t1) >> 10; 1996 1996 - v[40] = (x2-t1) >> 10; 1997 1997 - v[24] = (x3+t0) >> 10; 1998 1998 - v[32] = (x3-t0) >> 10; 1999 1999 - } 2000 2000 - } 2289 2289 + // columns 2290 2290 + for (i = 0; i < 8; ++i, ++d, ++v) { 2291 2291 + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing 2292 2292 + if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 2293 2293 + && d[40] == 0 && d[48] == 0 && d[56] == 0) { 2294 2294 + // no shortcut 0 seconds 2295 2295 + // (1|2|3|4|5|6|7)==0 0 seconds 2296 2296 + // all separate -0.047 seconds 2297 2297 + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds 2298 2298 + int dcterm = d[0] * 4; 2299 2299 + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; 2300 2300 + } 2301 2301 + else { 2302 2302 + STBI__IDCT_1D(d[0], d[8], d[16], d[24], d[32], d[40], d[48], d[56]) 2303 2303 + // constants scaled things up by 1<<12; let's bring them back 2304 2304 + // down, but keep 2 extra bits of precision 2305 2305 + x0 += 512; x1 += 512; x2 += 512; x3 += 512; 2306 2306 + v[0] = (x0 + t3) >> 10; 2307 2307 + v[56] = (x0 - t3) >> 10; 2308 2308 + v[8] = (x1 + t2) >> 10; 2309 2309 + v[48] = (x1 - t2) >> 10; 2310 2310 + v[16] = (x2 + t1) >> 10; 2311 2311 + v[40] = (x2 - t1) >> 10; 2312 2312 + v[24] = (x3 + t0) >> 10; 2313 2313 + v[32] = (x3 - t0) >> 10; 2314 2314 + } 2315 2315 + } 2001 2316 2002 2002 - for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { 2003 2003 - // no fast case since the first 1D IDCT spread components out 2004 2004 - STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) 2005 2005 - // constants scaled things up by 1<<12, plus we had 1<<2 from first 2006 2006 - // loop, plus horizontal and vertical each scale by sqrt(8) so together 2007 2007 - // we've got an extra 1<<3, so 1<<17 total we need to remove. 2008 2008 - // so we want to round that, which means adding 0.5 * 1<<17, 2009 2009 - // aka 65536. Also, we'll end up with -128 to 127 that we want 2010 2010 - // to encode as 0..255 by adding 128, so we'll add that before the shift 2011 2011 - x0 += 65536 + (128<<17); 2012 2012 - x1 += 65536 + (128<<17); 2013 2013 - x2 += 65536 + (128<<17); 2014 2014 - x3 += 65536 + (128<<17); 2015 2015 - // tried computing the shifts into temps, or'ing the temps to see 2016 2016 - // if any were out of range, but that was slower 2017 2017 - o[0] = stbi__clamp((x0+t3) >> 17); 2018 2018 - o[7] = stbi__clamp((x0-t3) >> 17); 2019 2019 - o[1] = stbi__clamp((x1+t2) >> 17); 2020 2020 - o[6] = stbi__clamp((x1-t2) >> 17); 2021 2021 - o[2] = stbi__clamp((x2+t1) >> 17); 2022 2022 - o[5] = stbi__clamp((x2-t1) >> 17); 2023 2023 - o[3] = stbi__clamp((x3+t0) >> 17); 2024 2024 - o[4] = stbi__clamp((x3-t0) >> 17); 2025 2025 - } 2317 2317 + for (i = 0, v = val, o = out; i < 8; ++i, v += 8, o += out_stride) { 2318 2318 + // no fast case since the first 1D IDCT spread components out 2319 2319 + STBI__IDCT_1D(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]) 2320 2320 + // constants scaled things up by 1<<12, plus we had 1<<2 from first 2321 2321 + // loop, plus horizontal and vertical each scale by sqrt(8) so together 2322 2322 + // we've got an extra 1<<3, so 1<<17 total we need to remove. 2323 2323 + // so we want to round that, which means adding 0.5 * 1<<17, 2324 2324 + // aka 65536. Also, we'll end up with -128 to 127 that we want 2325 2325 + // to encode as 0..255 by adding 128, so we'll add that before the shift 2326 2326 + x0 += 65536 + (128 << 17); 2327 2327 + x1 += 65536 + (128 << 17); 2328 2328 + x2 += 65536 + (128 << 17); 2329 2329 + x3 += 65536 + (128 << 17); 2330 2330 + // tried computing the shifts into temps, or'ing the temps to see 2331 2331 + // if any were out of range, but that was slower 2332 2332 + o[0] = stbi__clamp((x0 + t3) >> 17); 2333 2333 + o[7] = stbi__clamp((x0 - t3) >> 17); 2334 2334 + o[1] = stbi__clamp((x1 + t2) >> 17); 2335 2335 + o[6] = stbi__clamp((x1 - t2) >> 17); 2336 2336 + o[2] = stbi__clamp((x2 + t1) >> 17); 2337 2337 + o[5] = stbi__clamp((x2 - t1) >> 17); 2338 2338 + o[3] = stbi__clamp((x3 + t0) >> 17); 2339 2339 + o[4] = stbi__clamp((x3 - t0) >> 17); 2340 2340 + } 2026 2341 } 2027 2342 2028 2343 #ifdef STBI_SSE2 2029 2344 // sse2 integer IDCT. not the fastest possible implementation but it 2030 2345 // produces bit-identical results to the generic C version so it's 2031 2346 // fully "transparent". 2032 2032 - static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) 2347 2347 + static void stbi__idct_simd(stbi_uc* out, int out_stride, short data[64]) 2033 2348 { 2034 2034 - // This is constructed to match our regular (generic) integer IDCT exactly. 2035 2035 - __m128i row0, row1, row2, row3, row4, row5, row6, row7; 2036 2036 - __m128i tmp; 2349 2349 + // This is constructed to match our regular (generic) integer IDCT exactly. 2350 2350 + __m128i row0, row1, row2, row3, row4, row5, row6, row7; 2351 2351 + __m128i tmp; 2037 2352 2038 2038 - // dot product constant: even elems=x, odd elems=y 2039 2039 - #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) 2353 2353 + // dot product constant: even elems=x, odd elems=y 2354 2354 + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) 2040 2355 2041 2041 - // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) 2042 2042 - // out(1) = c1[even]*x + c1[odd]*y 2043 2043 - #define dct_rot(out0,out1, x,y,c0,c1) \ 2356 2356 + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) 2357 2357 + // out(1) = c1[even]*x + c1[odd]*y 2358 2358 + #define dct_rot(out0,out1, x,y,c0,c1) \ 2044 2359 __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ 2045 2360 __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ 2046 2361 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ ··· 2049 2364 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) 2050 2365 2051 2366 // out = in << 12 (in 16-bit, out 32-bit) 2052 2052 - #define dct_widen(out, in) \ 2367 2367 + #define dct_widen(out, in) \ 2053 2368 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ 2054 2369 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) 2055 2370 2056 2371 // wide add 2057 2057 - #define dct_wadd(out, a, b) \ 2372 2372 + #define dct_wadd(out, a, b) \ 2058 2373 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ 2059 2374 __m128i out##_h = _mm_add_epi32(a##_h, b##_h) 2060 2375 2061 2376 // wide sub 2062 2062 - #define dct_wsub(out, a, b) \ 2377 2377 + #define dct_wsub(out, a, b) \ 2063 2378 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ 2064 2379 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) 2065 2380 2066 2381 // butterfly a/b, add bias, then shift by "s" and pack 2067 2067 - #define dct_bfly32o(out0, out1, a,b,bias,s) \ 2382 2382 + #define dct_bfly32o(out0, out1, a,b,bias,s) \ 2068 2383 { \ 2069 2384 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ 2070 2385 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ ··· 2075 2390 } 2076 2391 2077 2392 // 8-bit interleave step (for transposes) 2078 2078 - #define dct_interleave8(a, b) \ 2393 2393 + #define dct_interleave8(a, b) \ 2079 2394 tmp = a; \ 2080 2395 a = _mm_unpacklo_epi8(a, b); \ 2081 2396 b = _mm_unpackhi_epi8(tmp, b) 2082 2397 2083 2398 // 16-bit interleave step (for transposes) 2084 2084 - #define dct_interleave16(a, b) \ 2399 2399 + #define dct_interleave16(a, b) \ 2085 2400 tmp = a; \ 2086 2401 a = _mm_unpacklo_epi16(a, b); \ 2087 2402 b = _mm_unpackhi_epi16(tmp, b) 2088 2403 2089 2089 - #define dct_pass(bias,shift) \ 2404 2404 + #define dct_pass(bias,shift) \ 2090 2405 { \ 2091 2406 /* even part */ \ 2092 2407 dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ ··· 2114 2429 dct_bfly32o(row3,row4, x3,x4,bias,shift); \ 2115 2430 } 2116 2431 2117 2117 - __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); 2118 2118 - __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); 2119 2119 - __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); 2120 2120 - __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); 2121 2121 - __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); 2122 2122 - __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); 2123 2123 - __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); 2124 2124 - __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); 2432 2432 + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); 2433 2433 + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f(0.765366865f), stbi__f2f(0.5411961f)); 2434 2434 + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); 2435 2435 + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); 2436 2436 + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f(0.298631336f), stbi__f2f(-1.961570560f)); 2437 2437 + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f(3.072711026f)); 2438 2438 + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f(2.053119869f), stbi__f2f(-0.390180644f)); 2439 2439 + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f(1.501321110f)); 2125 2440 2126 2126 - // rounding biases in column/row passes, see stbi__idct_block for explanation. 2127 2127 - __m128i bias_0 = _mm_set1_epi32(512); 2128 2128 - __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); 2441 2441 + // rounding biases in column/row passes, see stbi__idct_block for explanation. 2442 2442 + __m128i bias_0 = _mm_set1_epi32(512); 2443 2443 + __m128i bias_1 = _mm_set1_epi32(65536 + (128 << 17)); 2129 2444 2130 2130 - // load 2131 2131 - row0 = _mm_load_si128((const __m128i *) (data + 0*8)); 2132 2132 - row1 = _mm_load_si128((const __m128i *) (data + 1*8)); 2133 2133 - row2 = _mm_load_si128((const __m128i *) (data + 2*8)); 2134 2134 - row3 = _mm_load_si128((const __m128i *) (data + 3*8)); 2135 2135 - row4 = _mm_load_si128((const __m128i *) (data + 4*8)); 2136 2136 - row5 = _mm_load_si128((const __m128i *) (data + 5*8)); 2137 2137 - row6 = _mm_load_si128((const __m128i *) (data + 6*8)); 2138 2138 - row7 = _mm_load_si128((const __m128i *) (data + 7*8)); 2445 2445 + // load 2446 2446 + row0 = _mm_load_si128((const __m128i*) (data + 0 * 8)); 2447 2447 + row1 = _mm_load_si128((const __m128i*) (data + 1 * 8)); 2448 2448 + row2 = _mm_load_si128((const __m128i*) (data + 2 * 8)); 2449 2449 + row3 = _mm_load_si128((const __m128i*) (data + 3 * 8)); 2450 2450 + row4 = _mm_load_si128((const __m128i*) (data + 4 * 8)); 2451 2451 + row5 = _mm_load_si128((const __m128i*) (data + 5 * 8)); 2452 2452 + row6 = _mm_load_si128((const __m128i*) (data + 6 * 8)); 2453 2453 + row7 = _mm_load_si128((const __m128i*) (data + 7 * 8)); 2139 2454 2140 2140 - // column pass 2141 2141 - dct_pass(bias_0, 10); 2455 2455 + // column pass 2456 2456 + dct_pass(bias_0, 10); 2142 2457 2143 2143 - { 2144 2144 - // 16bit 8x8 transpose pass 1 2145 2145 - dct_interleave16(row0, row4); 2146 2146 - dct_interleave16(row1, row5); 2147 2147 - dct_interleave16(row2, row6); 2148 2148 - dct_interleave16(row3, row7); 2458 2458 + { 2459 2459 + // 16bit 8x8 transpose pass 1 2460 2460 + dct_interleave16(row0, row4); 2461 2461 + dct_interleave16(row1, row5); 2462 2462 + dct_interleave16(row2, row6); 2463 2463 + dct_interleave16(row3, row7); 2149 2464 2150 2150 - // transpose pass 2 2151 2151 - dct_interleave16(row0, row2); 2152 2152 - dct_interleave16(row1, row3); 2153 2153 - dct_interleave16(row4, row6); 2154 2154 - dct_interleave16(row5, row7); 2465 2465 + // transpose pass 2 2466 2466 + dct_interleave16(row0, row2); 2467 2467 + dct_interleave16(row1, row3); 2468 2468 + dct_interleave16(row4, row6); 2469 2469 + dct_interleave16(row5, row7); 2155 2470 2156 2156 - // transpose pass 3 2157 2157 - dct_interleave16(row0, row1); 2158 2158 - dct_interleave16(row2, row3); 2159 2159 - dct_interleave16(row4, row5); 2160 2160 - dct_interleave16(row6, row7); 2161 2161 - } 2471 2471 + // transpose pass 3 2472 2472 + dct_interleave16(row0, row1); 2473 2473 + dct_interleave16(row2, row3); 2474 2474 + dct_interleave16(row4, row5); 2475 2475 + dct_interleave16(row6, row7); 2476 2476 + } 2162 2477 2163 2163 - // row pass 2164 2164 - dct_pass(bias_1, 17); 2478 2478 + // row pass 2479 2479 + dct_pass(bias_1, 17); 2165 2480 2166 2166 - { 2167 2167 - // pack 2168 2168 - __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 2169 2169 - __m128i p1 = _mm_packus_epi16(row2, row3); 2170 2170 - __m128i p2 = _mm_packus_epi16(row4, row5); 2171 2171 - __m128i p3 = _mm_packus_epi16(row6, row7); 2481 2481 + { 2482 2482 + // pack 2483 2483 + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 2484 2484 + __m128i p1 = _mm_packus_epi16(row2, row3); 2485 2485 + __m128i p2 = _mm_packus_epi16(row4, row5); 2486 2486 + __m128i p3 = _mm_packus_epi16(row6, row7); 2172 2487 2173 2173 - // 8bit 8x8 transpose pass 1 2174 2174 - dct_interleave8(p0, p2); // a0e0a1e1... 2175 2175 - dct_interleave8(p1, p3); // c0g0c1g1... 2488 2488 + // 8bit 8x8 transpose pass 1 2489 2489 + dct_interleave8(p0, p2); // a0e0a1e1... 2490 2490 + dct_interleave8(p1, p3); // c0g0c1g1... 2176 2491 2177 2177 - // transpose pass 2 2178 2178 - dct_interleave8(p0, p1); // a0c0e0g0... 2179 2179 - dct_interleave8(p2, p3); // b0d0f0h0... 2492 2492 + // transpose pass 2 2493 2493 + dct_interleave8(p0, p1); // a0c0e0g0... 2494 2494 + dct_interleave8(p2, p3); // b0d0f0h0... 2180 2495 2181 2181 - // transpose pass 3 2182 2182 - dct_interleave8(p0, p2); // a0b0c0d0... 2183 2183 - dct_interleave8(p1, p3); // a4b4c4d4... 2496 2496 + // transpose pass 3 2497 2497 + dct_interleave8(p0, p2); // a0b0c0d0... 2498 2498 + dct_interleave8(p1, p3); // a4b4c4d4... 2184 2499 2185 2185 - // store 2186 2186 - _mm_storel_epi64((__m128i *) out, p0); out += out_stride; 2187 2187 - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; 2188 2188 - _mm_storel_epi64((__m128i *) out, p2); out += out_stride; 2189 2189 - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; 2190 2190 - _mm_storel_epi64((__m128i *) out, p1); out += out_stride; 2191 2191 - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; 2192 2192 - _mm_storel_epi64((__m128i *) out, p3); out += out_stride; 2193 2193 - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); 2194 2194 - } 2500 2500 + // store 2501 2501 + _mm_storel_epi64((__m128i*) out, p0); out += out_stride; 2502 2502 + _mm_storel_epi64((__m128i*) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; 2503 2503 + _mm_storel_epi64((__m128i*) out, p2); out += out_stride; 2504 2504 + _mm_storel_epi64((__m128i*) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; 2505 2505 + _mm_storel_epi64((__m128i*) out, p1); out += out_stride; 2506 2506 + _mm_storel_epi64((__m128i*) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; 2507 2507 + _mm_storel_epi64((__m128i*) out, p3); out += out_stride; 2508 2508 + _mm_storel_epi64((__m128i*) out, _mm_shuffle_epi32(p3, 0x4e)); 2509 2509 + } 2195 2510 2196 2511 #undef dct_const 2197 2512 #undef dct_rot ··· 2210 2525 2211 2526 // NEON integer IDCT. should produce bit-identical 2212 2527 // results to the generic C version. 2213 2213 - static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) 2528 2528 + static void stbi__idct_simd(stbi_uc* out, int out_stride, short data[64]) 2214 2529 { 2215 2215 - int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; 2530 2530 + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; 2216 2531 2217 2217 - int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); 2218 2218 - int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); 2219 2219 - int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); 2220 2220 - int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); 2221 2221 - int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); 2222 2222 - int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); 2223 2223 - int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); 2224 2224 - int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); 2225 2225 - int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); 2226 2226 - int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); 2227 2227 - int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); 2228 2228 - int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); 2532 2532 + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); 2533 2533 + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); 2534 2534 + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f(0.765366865f)); 2535 2535 + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f(1.175875602f)); 2536 2536 + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); 2537 2537 + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); 2538 2538 + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); 2539 2539 + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); 2540 2540 + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f(0.298631336f)); 2541 2541 + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f(2.053119869f)); 2542 2542 + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f(3.072711026f)); 2543 2543 + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f(1.501321110f)); 2229 2544 2230 2545 #define dct_long_mul(out, inq, coeff) \ 2231 2546 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ ··· 2239 2554 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ 2240 2555 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) 2241 2556 2242 2242 - // wide add 2557 2557 + // wide add 2243 2558 #define dct_wadd(out, a, b) \ 2244 2559 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ 2245 2560 int32x4_t out##_h = vaddq_s32(a##_h, b##_h) ··· 2299 2614 } 2300 2615 2301 2616 // load 2302 2302 - row0 = vld1q_s16(data + 0*8); 2303 2303 - row1 = vld1q_s16(data + 1*8); 2304 2304 - row2 = vld1q_s16(data + 2*8); 2305 2305 - row3 = vld1q_s16(data + 3*8); 2306 2306 - row4 = vld1q_s16(data + 4*8); 2307 2307 - row5 = vld1q_s16(data + 5*8); 2308 2308 - row6 = vld1q_s16(data + 6*8); 2309 2309 - row7 = vld1q_s16(data + 7*8); 2617 2617 + row0 = vld1q_s16(data + 0 * 8); 2618 2618 + row1 = vld1q_s16(data + 1 * 8); 2619 2619 + row2 = vld1q_s16(data + 2 * 8); 2620 2620 + row3 = vld1q_s16(data + 3 * 8); 2621 2621 + row4 = vld1q_s16(data + 4 * 8); 2622 2622 + row5 = vld1q_s16(data + 5 * 8); 2623 2623 + row6 = vld1q_s16(data + 6 * 8); 2624 2624 + row7 = vld1q_s16(data + 7 * 8); 2310 2625 2311 2311 - // add DC bias 2312 2312 - row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); 2626 2626 + // add DC bias 2627 2627 + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); 2313 2628 2314 2314 - // column pass 2315 2315 - dct_pass(vrshrn_n_s32, 10); 2629 2629 + // column pass 2630 2630 + dct_pass(vrshrn_n_s32, 10); 2316 2631 2317 2317 - // 16bit 8x8 transpose 2318 2318 - { 2319 2319 - // these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. 2320 2320 - // whether compilers actually get this is another story, sadly. 2632 2632 + // 16bit 8x8 transpose 2633 2633 + { 2634 2634 + // these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. 2635 2635 + // whether compilers actually get this is another story, sadly. 2321 2636 #define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } 2322 2637 #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]); } 2323 2638 #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)); } 2324 2639 2325 2640 // pass 1 2326 2326 - dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 2327 2327 - dct_trn16(row2, row3); 2328 2328 - dct_trn16(row4, row5); 2329 2329 - dct_trn16(row6, row7); 2641 2641 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 2642 2642 + dct_trn16(row2, row3); 2643 2643 + dct_trn16(row4, row5); 2644 2644 + dct_trn16(row6, row7); 2330 2645 2331 2331 - // pass 2 2332 2332 - dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 2333 2333 - dct_trn32(row1, row3); 2334 2334 - dct_trn32(row4, row6); 2335 2335 - dct_trn32(row5, row7); 2646 2646 + // pass 2 2647 2647 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 2648 2648 + dct_trn32(row1, row3); 2649 2649 + dct_trn32(row4, row6); 2650 2650 + dct_trn32(row5, row7); 2336 2651 2337 2337 - // pass 3 2338 2338 - dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 2339 2339 - dct_trn64(row1, row5); 2340 2340 - dct_trn64(row2, row6); 2341 2341 - dct_trn64(row3, row7); 2652 2652 + // pass 3 2653 2653 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 2654 2654 + dct_trn64(row1, row5); 2655 2655 + dct_trn64(row2, row6); 2656 2656 + dct_trn64(row3, row7); 2342 2657 2343 2658 #undef dct_trn16 2344 2659 #undef dct_trn32 2345 2660 #undef dct_trn64 2346 2346 - } 2661 2661 + } 2347 2662 2348 2348 - // row pass 2349 2349 - // vrshrn_n_s32 only supports shifts up to 16, we need 2350 2350 - // 17. so do a non-rounding shift of 16 first then follow 2351 2351 - // up with a rounding shift by 1. 2352 2352 - dct_pass(vshrn_n_s32, 16); 2663 2663 + // row pass 2664 2664 + // vrshrn_n_s32 only supports shifts up to 16, we need 2665 2665 + // 17. so do a non-rounding shift of 16 first then follow 2666 2666 + // up with a rounding shift by 1. 2667 2667 + dct_pass(vshrn_n_s32, 16); 2353 2668 2354 2354 - { 2355 2355 - // pack and round 2356 2356 - uint8x8_t p0 = vqrshrun_n_s16(row0, 1); 2357 2357 - uint8x8_t p1 = vqrshrun_n_s16(row1, 1); 2358 2358 - uint8x8_t p2 = vqrshrun_n_s16(row2, 1); 2359 2359 - uint8x8_t p3 = vqrshrun_n_s16(row3, 1); 2360 2360 - uint8x8_t p4 = vqrshrun_n_s16(row4, 1); 2361 2361 - uint8x8_t p5 = vqrshrun_n_s16(row5, 1); 2362 2362 - uint8x8_t p6 = vqrshrun_n_s16(row6, 1); 2363 2363 - uint8x8_t p7 = vqrshrun_n_s16(row7, 1); 2669 2669 + { 2670 2670 + // pack and round 2671 2671 + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); 2672 2672 + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); 2673 2673 + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); 2674 2674 + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); 2675 2675 + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); 2676 2676 + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); 2677 2677 + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); 2678 2678 + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); 2364 2679 2365 2365 - // again, these can translate into one instruction, but often don't. 2680 2680 + // again, these can translate into one instruction, but often don't. 2366 2681 #define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } 2367 2682 #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]); } 2368 2683 #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]); } ··· 2371 2686 // 8 bytes to each scan line! 2372 2687 2373 2688 // 8x8 8-bit transpose pass 1 2374 2374 - dct_trn8_8(p0, p1); 2375 2375 - dct_trn8_8(p2, p3); 2376 2376 - dct_trn8_8(p4, p5); 2377 2377 - dct_trn8_8(p6, p7); 2689 2689 + dct_trn8_8(p0, p1); 2690 2690 + dct_trn8_8(p2, p3); 2691 2691 + dct_trn8_8(p4, p5); 2692 2692 + dct_trn8_8(p6, p7); 2378 2693 2379 2379 - // pass 2 2380 2380 - dct_trn8_16(p0, p2); 2381 2381 - dct_trn8_16(p1, p3); 2382 2382 - dct_trn8_16(p4, p6); 2383 2383 - dct_trn8_16(p5, p7); 2694 2694 + // pass 2 2695 2695 + dct_trn8_16(p0, p2); 2696 2696 + dct_trn8_16(p1, p3); 2697 2697 + dct_trn8_16(p4, p6); 2698 2698 + dct_trn8_16(p5, p7); 2384 2699 2385 2385 - // pass 3 2386 2386 - dct_trn8_32(p0, p4); 2387 2387 - dct_trn8_32(p1, p5); 2388 2388 - dct_trn8_32(p2, p6); 2389 2389 - dct_trn8_32(p3, p7); 2700 2700 + // pass 3 2701 2701 + dct_trn8_32(p0, p4); 2702 2702 + dct_trn8_32(p1, p5); 2703 2703 + dct_trn8_32(p2, p6); 2704 2704 + dct_trn8_32(p3, p7); 2390 2705 2391 2391 - // store 2392 2392 - vst1_u8(out, p0); out += out_stride; 2393 2393 - vst1_u8(out, p1); out += out_stride; 2394 2394 - vst1_u8(out, p2); out += out_stride; 2395 2395 - vst1_u8(out, p3); out += out_stride; 2396 2396 - vst1_u8(out, p4); out += out_stride; 2397 2397 - vst1_u8(out, p5); out += out_stride; 2398 2398 - vst1_u8(out, p6); out += out_stride; 2399 2399 - vst1_u8(out, p7); 2706 2706 + // store 2707 2707 + vst1_u8(out, p0); out += out_stride; 2708 2708 + vst1_u8(out, p1); out += out_stride; 2709 2709 + vst1_u8(out, p2); out += out_stride; 2710 2710 + vst1_u8(out, p3); out += out_stride; 2711 2711 + vst1_u8(out, p4); out += out_stride; 2712 2712 + vst1_u8(out, p5); out += out_stride; 2713 2713 + vst1_u8(out, p6); out += out_stride; 2714 2714 + vst1_u8(out, p7); 2400 2715 2401 2716 #undef dct_trn8_8 2402 2717 #undef dct_trn8_16 2403 2718 #undef dct_trn8_32 2404 2404 - } 2719 2719 + } 2405 2720 2406 2721 #undef dct_long_mul 2407 2722 #undef dct_long_mac ··· 2418 2733 // if there's a pending marker from the entropy stream, return that 2419 2734 // otherwise, fetch from the stream and get a marker. if there's no 2420 2735 // marker, return 0xff, which is never a valid marker value 2421 2421 - static stbi_uc stbi__get_marker(stbi__jpeg *j) 2736 2736 + static stbi_uc stbi__get_marker(stbi__jpeg* j) 2422 2737 { 2423 2423 - stbi_uc x; 2424 2424 - if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } 2425 2425 - x = stbi__get8(j->s); 2426 2426 - if (x != 0xff) return STBI__MARKER_none; 2427 2427 - while (x == 0xff) 2428 2428 - x = stbi__get8(j->s); 2429 2429 - return x; 2738 2738 + stbi_uc x; 2739 2739 + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } 2740 2740 + x = stbi__get8(j->s); 2741 2741 + if (x != 0xff) return STBI__MARKER_none; 2742 2742 + while (x == 0xff) 2743 2743 + x = stbi__get8(j->s); // consume repeated 0xff fill bytes 2744 2744 + return x; 2430 2745 } 2431 2746 2432 2747 // in each scan, we'll have scan_n components, and the order ··· 2435 2750 2436 2751 // after a restart interval, stbi__jpeg_reset the entropy decoder and 2437 2752 // the dc prediction 2438 2438 - static void stbi__jpeg_reset(stbi__jpeg *j) 2753 2753 + static void stbi__jpeg_reset(stbi__jpeg* j) 2439 2754 { 2440 2440 - j->code_bits = 0; 2441 2441 - j->code_buffer = 0; 2442 2442 - j->nomore = 0; 2443 2443 - j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; 2444 2444 - j->marker = STBI__MARKER_none; 2445 2445 - j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; 2446 2446 - j->eob_run = 0; 2447 2447 - // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, 2448 2448 - // since we don't even allow 1<<30 pixels 2755 2755 + j->code_bits = 0; 2756 2756 + j->code_buffer = 0; 2757 2757 + j->nomore = 0; 2758 2758 + 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; 2759 2759 + j->marker = STBI__MARKER_none; 2760 2760 + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; 2761 2761 + j->eob_run = 0; 2762 2762 + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, 2763 2763 + // since we don't even allow 1<<30 pixels 2449 2764 } 2450 2765 2451 2451 - static int stbi__parse_entropy_coded_data(stbi__jpeg *z) 2766 2766 + static int stbi__parse_entropy_coded_data(stbi__jpeg* z) 2452 2767 { 2453 2453 - stbi__jpeg_reset(z); 2454 2454 - if (!z->progressive) { 2455 2455 - if (z->scan_n == 1) { 2456 2456 - int i,j; 2457 2457 - STBI_SIMD_ALIGN(short, data[64]); 2458 2458 - int n = z->order[0]; 2459 2459 - // non-interleaved data, we just need to process one block at a time, 2460 2460 - // in trivial scanline order 2461 2461 - // number of blocks to do just depends on how many actual "pixels" this 2462 2462 - // component has, independent of interleaved MCU blocking and such 2463 2463 - int w = (z->img_comp[n].x+7) >> 3; 2464 2464 - int h = (z->img_comp[n].y+7) >> 3; 2465 2465 - for (j=0; j < h; ++j) { 2466 2466 - for (i=0; i < w; ++i) { 2467 2467 - int ha = z->img_comp[n].ha; 2468 2468 - 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; 2469 2469 - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); 2470 2470 - // every data block is an MCU, so countdown the restart interval 2471 2471 - if (--z->todo <= 0) { 2472 2472 - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2473 2473 - // if it's NOT a restart, then just bail, so we get corrupt data 2474 2474 - // rather than no data 2475 2475 - if (!STBI__RESTART(z->marker)) return 1; 2476 2476 - stbi__jpeg_reset(z); 2477 2477 - } 2478 2478 - } 2479 2479 - } 2480 2480 - return 1; 2481 2481 - } else { // interleaved 2482 2482 - int i,j,k,x,y; 2483 2483 - STBI_SIMD_ALIGN(short, data[64]); 2484 2484 - for (j=0; j < z->img_mcu_y; ++j) { 2485 2485 - for (i=0; i < z->img_mcu_x; ++i) { 2486 2486 - // scan an interleaved mcu... process scan_n components in order 2487 2487 - for (k=0; k < z->scan_n; ++k) { 2488 2488 - int n = z->order[k]; 2489 2489 - // scan out an mcu's worth of this component; that's just determined 2490 2490 - // by the basic H and V specified for the component 2491 2491 - for (y=0; y < z->img_comp[n].v; ++y) { 2492 2492 - for (x=0; x < z->img_comp[n].h; ++x) { 2493 2493 - int x2 = (i*z->img_comp[n].h + x)*8; 2494 2494 - int y2 = (j*z->img_comp[n].v + y)*8; 2495 2495 - int ha = z->img_comp[n].ha; 2496 2496 - 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; 2497 2497 - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); 2498 2498 - } 2499 2499 - } 2500 2500 - } 2501 2501 - // after all interleaved components, that's an interleaved MCU, 2502 2502 - // so now count down the restart interval 2503 2503 - if (--z->todo <= 0) { 2504 2504 - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2505 2505 - if (!STBI__RESTART(z->marker)) return 1; 2506 2506 - stbi__jpeg_reset(z); 2507 2507 - } 2768 2768 + stbi__jpeg_reset(z); 2769 2769 + if (!z->progressive) { 2770 2770 + if (z->scan_n == 1) { 2771 2771 + int i, j; 2772 2772 + STBI_SIMD_ALIGN(short, data[64]); 2773 2773 + int n = z->order[0]; 2774 2774 + // non-interleaved data, we just need to process one block at a time, 2775 2775 + // in trivial scanline order 2776 2776 + // number of blocks to do just depends on how many actual "pixels" this 2777 2777 + // component has, independent of interleaved MCU blocking and such 2778 2778 + int w = (z->img_comp[n].x + 7) >> 3; 2779 2779 + int h = (z->img_comp[n].y + 7) >> 3; 2780 2780 + for (j = 0; j < h; ++j) { 2781 2781 + for (i = 0; i < w; ++i) { 2782 2782 + int ha = z->img_comp[n].ha; 2783 2783 + 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; 2784 2784 + z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, z->img_comp[n].w2, data); 2785 2785 + // every data block is an MCU, so countdown the restart interval 2786 2786 + if (--z->todo <= 0) { 2787 2787 + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2788 2788 + // if it's NOT a restart, then just bail, so we get corrupt data 2789 2789 + // rather than no data 2790 2790 + if (!STBI__RESTART(z->marker)) return 1; 2791 2791 + stbi__jpeg_reset(z); 2792 2792 + } 2793 2793 + } 2508 2794 } 2509 2509 - } 2510 2510 - return 1; 2511 2511 - } 2512 2512 - } else { 2513 2513 - if (z->scan_n == 1) { 2514 2514 - int i,j; 2515 2515 - int n = z->order[0]; 2516 2516 - // non-interleaved data, we just need to process one block at a time, 2517 2517 - // in trivial scanline order 2518 2518 - // number of blocks to do just depends on how many actual "pixels" this 2519 2519 - // component has, independent of interleaved MCU blocking and such 2520 2520 - int w = (z->img_comp[n].x+7) >> 3; 2521 2521 - int h = (z->img_comp[n].y+7) >> 3; 2522 2522 - for (j=0; j < h; ++j) { 2523 2523 - for (i=0; i < w; ++i) { 2524 2524 - short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); 2525 2525 - if (z->spec_start == 0) { 2526 2526 - if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) 2527 2527 - return 0; 2528 2528 - } else { 2529 2529 - int ha = z->img_comp[n].ha; 2530 2530 - if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) 2531 2531 - return 0; 2532 2532 - } 2533 2533 - // every data block is an MCU, so countdown the restart interval 2534 2534 - if (--z->todo <= 0) { 2535 2535 - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2536 2536 - if (!STBI__RESTART(z->marker)) return 1; 2537 2537 - stbi__jpeg_reset(z); 2538 2538 - } 2795 2795 + return 1; 2796 2796 + } 2797 2797 + else { // interleaved 2798 2798 + int i, j, k, x, y; 2799 2799 + STBI_SIMD_ALIGN(short, data[64]); 2800 2800 + for (j = 0; j < z->img_mcu_y; ++j) { 2801 2801 + for (i = 0; i < z->img_mcu_x; ++i) { 2802 2802 + // scan an interleaved mcu... process scan_n components in order 2803 2803 + for (k = 0; k < z->scan_n; ++k) { 2804 2804 + int n = z->order[k]; 2805 2805 + // scan out an mcu's worth of this component; that's just determined 2806 2806 + // by the basic H and V specified for the component 2807 2807 + for (y = 0; y < z->img_comp[n].v; ++y) { 2808 2808 + for (x = 0; x < z->img_comp[n].h; ++x) { 2809 2809 + int x2 = (i * z->img_comp[n].h + x) * 8; 2810 2810 + int y2 = (j * z->img_comp[n].v + y) * 8; 2811 2811 + int ha = z->img_comp[n].ha; 2812 2812 + 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; 2813 2813 + z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * y2 + x2, z->img_comp[n].w2, data); 2814 2814 + } 2815 2815 + } 2816 2816 + } 2817 2817 + // after all interleaved components, that's an interleaved MCU, 2818 2818 + // so now count down the restart interval 2819 2819 + if (--z->todo <= 0) { 2820 2820 + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2821 2821 + if (!STBI__RESTART(z->marker)) return 1; 2822 2822 + stbi__jpeg_reset(z); 2823 2823 + } 2824 2824 + } 2539 2825 } 2540 2540 - } 2541 2541 - return 1; 2542 2542 - } else { // interleaved 2543 2543 - int i,j,k,x,y; 2544 2544 - for (j=0; j < z->img_mcu_y; ++j) { 2545 2545 - for (i=0; i < z->img_mcu_x; ++i) { 2546 2546 - // scan an interleaved mcu... process scan_n components in order 2547 2547 - for (k=0; k < z->scan_n; ++k) { 2548 2548 - int n = z->order[k]; 2549 2549 - // scan out an mcu's worth of this component; that's just determined 2550 2550 - // by the basic H and V specified for the component 2551 2551 - for (y=0; y < z->img_comp[n].v; ++y) { 2552 2552 - for (x=0; x < z->img_comp[n].h; ++x) { 2553 2553 - int x2 = (i*z->img_comp[n].h + x); 2554 2554 - int y2 = (j*z->img_comp[n].v + y); 2555 2555 - short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); 2826 2826 + return 1; 2827 2827 + } 2828 2828 + } 2829 2829 + else { 2830 2830 + if (z->scan_n == 1) { 2831 2831 + int i, j; 2832 2832 + int n = z->order[0]; 2833 2833 + // non-interleaved data, we just need to process one block at a time, 2834 2834 + // in trivial scanline order 2835 2835 + // number of blocks to do just depends on how many actual "pixels" this 2836 2836 + // component has, independent of interleaved MCU blocking and such 2837 2837 + int w = (z->img_comp[n].x + 7) >> 3; 2838 2838 + int h = (z->img_comp[n].y + 7) >> 3; 2839 2839 + for (j = 0; j < h; ++j) { 2840 2840 + for (i = 0; i < w; ++i) { 2841 2841 + short* data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); 2842 2842 + if (z->spec_start == 0) { 2556 2843 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) 2557 2557 - return 0; 2558 2558 - } 2559 2559 - } 2560 2560 - } 2561 2561 - // after all interleaved components, that's an interleaved MCU, 2562 2562 - // so now count down the restart interval 2563 2563 - if (--z->todo <= 0) { 2564 2564 - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2565 2565 - if (!STBI__RESTART(z->marker)) return 1; 2566 2566 - stbi__jpeg_reset(z); 2567 2567 - } 2844 2844 + return 0; 2845 2845 + } 2846 2846 + else { 2847 2847 + int ha = z->img_comp[n].ha; 2848 2848 + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) 2849 2849 + return 0; 2850 2850 + } 2851 2851 + // every data block is an MCU, so countdown the restart interval 2852 2852 + if (--z->todo <= 0) { 2853 2853 + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2854 2854 + if (!STBI__RESTART(z->marker)) return 1; 2855 2855 + stbi__jpeg_reset(z); 2856 2856 + } 2857 2857 + } 2858 2858 + } 2859 2859 + return 1; 2860 2860 + } 2861 2861 + else { // interleaved 2862 2862 + int i, j, k, x, y; 2863 2863 + for (j = 0; j < z->img_mcu_y; ++j) { 2864 2864 + for (i = 0; i < z->img_mcu_x; ++i) { 2865 2865 + // scan an interleaved mcu... process scan_n components in order 2866 2866 + for (k = 0; k < z->scan_n; ++k) { 2867 2867 + int n = z->order[k]; 2868 2868 + // scan out an mcu's worth of this component; that's just determined 2869 2869 + // by the basic H and V specified for the component 2870 2870 + for (y = 0; y < z->img_comp[n].v; ++y) { 2871 2871 + for (x = 0; x < z->img_comp[n].h; ++x) { 2872 2872 + int x2 = (i * z->img_comp[n].h + x); 2873 2873 + int y2 = (j * z->img_comp[n].v + y); 2874 2874 + short* data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); 2875 2875 + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) 2876 2876 + return 0; 2877 2877 + } 2878 2878 + } 2879 2879 + } 2880 2880 + // after all interleaved components, that's an interleaved MCU, 2881 2881 + // so now count down the restart interval 2882 2882 + if (--z->todo <= 0) { 2883 2883 + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); 2884 2884 + if (!STBI__RESTART(z->marker)) return 1; 2885 2885 + stbi__jpeg_reset(z); 2886 2886 + } 2887 2887 + } 2568 2888 } 2569 2569 - } 2570 2570 - return 1; 2571 2571 - } 2572 2572 - } 2889 2889 + return 1; 2890 2890 + } 2891 2891 + } 2573 2892 } 2574 2893 2575 2575 - static void stbi__jpeg_dequantize(short *data, stbi_uc *dequant) 2894 2894 + static void stbi__jpeg_dequantize(short* data, stbi__uint16* dequant) 2576 2895 { 2577 2577 - int i; 2578 2578 - for (i=0; i < 64; ++i) 2579 2579 - data[i] *= dequant[i]; 2896 2896 + int i; 2897 2897 + for (i = 0; i < 64; ++i) 2898 2898 + data[i] *= dequant[i]; 2580 2899 } 2581 2900 2582 2582 - static void stbi__jpeg_finish(stbi__jpeg *z) 2901 2901 + static void stbi__jpeg_finish(stbi__jpeg* z) 2583 2902 { 2584 2584 - if (z->progressive) { 2585 2585 - // dequantize and idct the data 2586 2586 - int i,j,n; 2587 2587 - for (n=0; n < z->s->img_n; ++n) { 2588 2588 - int w = (z->img_comp[n].x+7) >> 3; 2589 2589 - int h = (z->img_comp[n].y+7) >> 3; 2590 2590 - for (j=0; j < h; ++j) { 2591 2591 - for (i=0; i < w; ++i) { 2592 2592 - short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); 2593 2593 - stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); 2594 2594 - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); 2903 2903 + if (z->progressive) { 2904 2904 + // dequantize and idct the data 2905 2905 + int i, j, n; 2906 2906 + for (n = 0; n < z->s->img_n; ++n) { 2907 2907 + int w = (z->img_comp[n].x + 7) >> 3; 2908 2908 + int h = (z->img_comp[n].y + 7) >> 3; 2909 2909 + for (j = 0; j < h; ++j) { 2910 2910 + for (i = 0; i < w; ++i) { 2911 2911 + short* data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); 2912 2912 + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); 2913 2913 + z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, z->img_comp[n].w2, data); 2914 2914 + } 2595 2915 } 2596 2596 - } 2597 2597 - } 2598 2598 - } 2916 2916 + } 2917 2917 + } 2599 2918 } 2600 2919 2601 2601 - static int stbi__process_marker(stbi__jpeg *z, int m) 2920 2920 + static int stbi__process_marker(stbi__jpeg* z, int m) 2602 2921 { 2603 2603 - int L; 2604 2604 - switch (m) { 2605 2605 - case STBI__MARKER_none: // no marker found 2606 2606 - return stbi__err("expected marker","Corrupt JPEG"); 2922 2922 + int L; 2923 2923 + switch (m) { 2924 2924 + case STBI__MARKER_none: // no marker found 2925 2925 + return stbi__err("expected marker", "Corrupt JPEG"); 2607 2926 2608 2608 - case 0xDD: // DRI - specify restart interval 2609 2609 - if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); 2610 2610 - z->restart_interval = stbi__get16be(z->s); 2611 2611 - return 1; 2927 2927 + case 0xDD: // DRI - specify restart interval 2928 2928 + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len", "Corrupt JPEG"); 2929 2929 + z->restart_interval = stbi__get16be(z->s); 2930 2930 + return 1; 2612 2931 2613 2613 - case 0xDB: // DQT - define quantization table 2614 2614 - L = stbi__get16be(z->s)-2; 2615 2615 - while (L > 0) { 2932 2932 + case 0xDB: // DQT - define quantization table 2933 2933 + L = stbi__get16be(z->s) - 2; 2934 2934 + while (L > 0) { 2616 2935 int q = stbi__get8(z->s); 2617 2617 - int p = q >> 4; 2618 2618 - int t = q & 15,i; 2619 2619 - if (p != 0) return stbi__err("bad DQT type","Corrupt JPEG"); 2620 2620 - if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); 2621 2621 - for (i=0; i < 64; ++i) 2622 2622 - z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8(z->s); 2623 2623 - L -= 65; 2624 2624 - } 2625 2625 - return L==0; 2936 2936 + int p = q >> 4, sixteen = (p != 0); 2937 2937 + int t = q & 15, i; 2938 2938 + if (p != 0 && p != 1) return stbi__err("bad DQT type", "Corrupt JPEG"); 2939 2939 + if (t > 3) return stbi__err("bad DQT table", "Corrupt JPEG"); 2626 2940 2627 2627 - case 0xC4: // DHT - define huffman table 2628 2628 - L = stbi__get16be(z->s)-2; 2629 2629 - while (L > 0) { 2630 2630 - stbi_uc *v; 2631 2631 - int sizes[16],i,n=0; 2941 2941 + for (i = 0; i < 64; ++i) 2942 2942 + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); 2943 2943 + L -= (sixteen ? 129 : 65); 2944 2944 + } 2945 2945 + return L == 0; 2946 2946 + 2947 2947 + case 0xC4: // DHT - define huffman table 2948 2948 + L = stbi__get16be(z->s) - 2; 2949 2949 + while (L > 0) { 2950 2950 + stbi_uc* v; 2951 2951 + int sizes[16], i, n = 0; 2632 2952 int q = stbi__get8(z->s); 2633 2953 int tc = q >> 4; 2634 2954 int th = q & 15; 2635 2635 - if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); 2636 2636 - for (i=0; i < 16; ++i) { 2637 2637 - sizes[i] = stbi__get8(z->s); 2638 2638 - n += sizes[i]; 2955 2955 + if (tc > 1 || th > 3) return stbi__err("bad DHT header", "Corrupt JPEG"); 2956 2956 + for (i = 0; i < 16; ++i) { 2957 2957 + sizes[i] = stbi__get8(z->s); 2958 2958 + n += sizes[i]; 2639 2959 } 2640 2960 L -= 17; 2641 2961 if (tc == 0) { 2642 2642 - if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; 2643 2643 - v = z->huff_dc[th].values; 2644 2644 - } else { 2645 2645 - if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; 2646 2646 - v = z->huff_ac[th].values; 2962 2962 + if (!stbi__build_huffman(z->huff_dc + th, sizes)) return 0; 2963 2963 + v = z->huff_dc[th].values; 2964 2964 + } 2965 2965 + else { 2966 2966 + if (!stbi__build_huffman(z->huff_ac + th, sizes)) return 0; 2967 2967 + v = z->huff_ac[th].values; 2647 2968 } 2648 2648 - for (i=0; i < n; ++i) 2649 2649 - v[i] = stbi__get8(z->s); 2969 2969 + for (i = 0; i < n; ++i) 2970 2970 + v[i] = stbi__get8(z->s); 2650 2971 if (tc != 0) 2651 2651 - stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); 2972 2972 + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); 2652 2973 L -= n; 2653 2653 - } 2654 2654 - return L==0; 2655 2655 - } 2656 2656 - // check for comment block or APP blocks 2657 2657 - if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { 2658 2658 - stbi__skip(z->s, stbi__get16be(z->s)-2); 2659 2659 - return 1; 2660 2660 - } 2661 2661 - return 0; 2974 2974 + } 2975 2975 + return L == 0; 2976 2976 + } 2977 2977 + 2978 2978 + // check for comment block or APP blocks 2979 2979 + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { 2980 2980 + L = stbi__get16be(z->s); 2981 2981 + if (L < 2) { 2982 2982 + if (m == 0xFE) 2983 2983 + return stbi__err("bad COM len", "Corrupt JPEG"); 2984 2984 + else 2985 2985 + return stbi__err("bad APP len", "Corrupt JPEG"); 2986 2986 + } 2987 2987 + L -= 2; 2988 2988 + 2989 2989 + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment 2990 2990 + static const unsigned char tag[5] = { 'J','F','I','F','\0' }; 2991 2991 + int ok = 1; 2992 2992 + int i; 2993 2993 + for (i = 0; i < 5; ++i) 2994 2994 + if (stbi__get8(z->s) != tag[i]) 2995 2995 + ok = 0; 2996 2996 + L -= 5; 2997 2997 + if (ok) 2998 2998 + z->jfif = 1; 2999 2999 + } 3000 3000 + else if (m == 0xEE && L >= 12) { // Adobe APP14 segment 3001 3001 + static const unsigned char tag[6] = { 'A','d','o','b','e','\0' }; 3002 3002 + int ok = 1; 3003 3003 + int i; 3004 3004 + for (i = 0; i < 6; ++i) 3005 3005 + if (stbi__get8(z->s) != tag[i]) 3006 3006 + ok = 0; 3007 3007 + L -= 6; 3008 3008 + if (ok) { 3009 3009 + stbi__get8(z->s); // version 3010 3010 + stbi__get16be(z->s); // flags0 3011 3011 + stbi__get16be(z->s); // flags1 3012 3012 + z->app14_color_transform = stbi__get8(z->s); // color transform 3013 3013 + L -= 6; 3014 3014 + } 3015 3015 + } 3016 3016 + 3017 3017 + stbi__skip(z->s, L); 3018 3018 + return 1; 3019 3019 + } 3020 3020 + 3021 3021 + return stbi__err("unknown marker", "Corrupt JPEG"); 2662 3022 } 2663 3023 2664 3024 // after we see SOS 2665 2665 - static int stbi__process_scan_header(stbi__jpeg *z) 3025 3025 + static int stbi__process_scan_header(stbi__jpeg* z) 2666 3026 { 2667 2667 - int i; 2668 2668 - int Ls = stbi__get16be(z->s); 2669 2669 - z->scan_n = stbi__get8(z->s); 2670 2670 - 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"); 2671 2671 - if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); 2672 2672 - for (i=0; i < z->scan_n; ++i) { 2673 2673 - int id = stbi__get8(z->s), which; 2674 2674 - int q = stbi__get8(z->s); 2675 2675 - for (which = 0; which < z->s->img_n; ++which) 2676 2676 - if (z->img_comp[which].id == id) 2677 2677 - break; 2678 2678 - if (which == z->s->img_n) return 0; // no match 2679 2679 - z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); 2680 2680 - z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); 2681 2681 - z->order[i] = which; 2682 2682 - } 3027 3027 + int i; 3028 3028 + int Ls = stbi__get16be(z->s); 3029 3029 + z->scan_n = stbi__get8(z->s); 3030 3030 + 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"); 3031 3031 + if (Ls != 6 + 2 * z->scan_n) return stbi__err("bad SOS len", "Corrupt JPEG"); 3032 3032 + for (i = 0; i < z->scan_n; ++i) { 3033 3033 + int id = stbi__get8(z->s), which; 3034 3034 + int q = stbi__get8(z->s); 3035 3035 + for (which = 0; which < z->s->img_n; ++which) 3036 3036 + if (z->img_comp[which].id == id) 3037 3037 + break; 3038 3038 + if (which == z->s->img_n) return 0; // no match 3039 3039 + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff", "Corrupt JPEG"); 3040 3040 + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff", "Corrupt JPEG"); 3041 3041 + z->order[i] = which; 3042 3042 + } 2683 3043 2684 2684 - { 2685 2685 - int aa; 2686 2686 - z->spec_start = stbi__get8(z->s); 2687 2687 - z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 2688 2688 - aa = stbi__get8(z->s); 2689 2689 - z->succ_high = (aa >> 4); 2690 2690 - z->succ_low = (aa & 15); 2691 2691 - if (z->progressive) { 2692 2692 - if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) 2693 2693 - return stbi__err("bad SOS", "Corrupt JPEG"); 2694 2694 - } else { 2695 2695 - if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); 2696 2696 - if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); 2697 2697 - z->spec_end = 63; 2698 2698 - } 2699 2699 - } 3044 3044 + { 3045 3045 + int aa; 3046 3046 + z->spec_start = stbi__get8(z->s); 3047 3047 + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 3048 3048 + aa = stbi__get8(z->s); 3049 3049 + z->succ_high = (aa >> 4); 3050 3050 + z->succ_low = (aa & 15); 3051 3051 + if (z->progressive) { 3052 3052 + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) 3053 3053 + return stbi__err("bad SOS", "Corrupt JPEG"); 3054 3054 + } 3055 3055 + else { 3056 3056 + if (z->spec_start != 0) return stbi__err("bad SOS", "Corrupt JPEG"); 3057 3057 + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS", "Corrupt JPEG"); 3058 3058 + z->spec_end = 63; 3059 3059 + } 3060 3060 + } 2700 3061 2701 2701 - return 1; 3062 3062 + return 1; 2702 3063 } 2703 3064 2704 2704 - static int stbi__process_frame_header(stbi__jpeg *z, int scan) 3065 3065 + static int stbi__free_jpeg_components(stbi__jpeg* z, int ncomp, int why) 2705 3066 { 2706 2706 - stbi__context *s = z->s; 2707 2707 - int Lf,p,i,q, h_max=1,v_max=1,c; 2708 2708 - Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG 2709 2709 - p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline 2710 2710 - 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 2711 2711 - s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires 2712 2712 - c = stbi__get8(s); 2713 2713 - if (c != 3 && c != 1) return stbi__err("bad component count","Corrupt JPEG"); // JFIF requires 2714 2714 - s->img_n = c; 2715 2715 - for (i=0; i < c; ++i) { 2716 2716 - z->img_comp[i].data = NULL; 2717 2717 - z->img_comp[i].linebuf = NULL; 2718 2718 - } 3067 3067 + int i; 3068 3068 + for (i = 0; i < ncomp; ++i) { 3069 3069 + if (z->img_comp[i].raw_data) { 3070 3070 + STBI_FREE(z->img_comp[i].raw_data); 3071 3071 + z->img_comp[i].raw_data = NULL; 3072 3072 + z->img_comp[i].data = NULL; 3073 3073 + } 3074 3074 + if (z->img_comp[i].raw_coeff) { 3075 3075 + STBI_FREE(z->img_comp[i].raw_coeff); 3076 3076 + z->img_comp[i].raw_coeff = 0; 3077 3077 + z->img_comp[i].coeff = 0; 3078 3078 + } 3079 3079 + if (z->img_comp[i].linebuf) { 3080 3080 + STBI_FREE(z->img_comp[i].linebuf); 3081 3081 + z->img_comp[i].linebuf = NULL; 3082 3082 + } 3083 3083 + } 3084 3084 + return why; 3085 3085 + } 2719 3086 2720 2720 - if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); 3087 3087 + static int stbi__process_frame_header(stbi__jpeg* z, int scan) 3088 3088 + { 3089 3089 + stbi__context* s = z->s; 3090 3090 + int Lf, p, i, q, h_max = 1, v_max = 1, c; 3091 3091 + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len", "Corrupt JPEG"); // JPEG 3092 3092 + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit", "JPEG format not supported: 8-bit only"); // JPEG baseline 3093 3093 + 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 3094 3094 + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width", "Corrupt JPEG"); // JPEG requires 3095 3095 + c = stbi__get8(s); 3096 3096 + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count", "Corrupt JPEG"); 3097 3097 + s->img_n = c; 3098 3098 + for (i = 0; i < c; ++i) { 3099 3099 + z->img_comp[i].data = NULL; 3100 3100 + z->img_comp[i].linebuf = NULL; 3101 3101 + } 2721 3102 2722 2722 - for (i=0; i < s->img_n; ++i) { 2723 2723 - z->img_comp[i].id = stbi__get8(s); 2724 2724 - if (z->img_comp[i].id != i+1) // JFIF requires 2725 2725 - if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files! 2726 2726 - return stbi__err("bad component ID","Corrupt JPEG"); 2727 2727 - q = stbi__get8(s); 2728 2728 - 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"); 2729 2729 - 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"); 2730 2730 - z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); 2731 2731 - } 3103 3103 + if (Lf != 8 + 3 * s->img_n) return stbi__err("bad SOF len", "Corrupt JPEG"); 2732 3104 2733 2733 - if (scan != STBI__SCAN_load) return 1; 3105 3105 + z->rgb = 0; 3106 3106 + for (i = 0; i < s->img_n; ++i) { 3107 3107 + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; 3108 3108 + z->img_comp[i].id = stbi__get8(s); 3109 3109 + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) 3110 3110 + ++z->rgb; 3111 3111 + q = stbi__get8(s); 3112 3112 + 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"); 3113 3113 + 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"); 3114 3114 + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ", "Corrupt JPEG"); 3115 3115 + } 2734 3116 2735 2735 - if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); 3117 3117 + if (scan != STBI__SCAN_load) return 1; 2736 3118 2737 2737 - for (i=0; i < s->img_n; ++i) { 2738 2738 - if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; 2739 2739 - if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; 2740 2740 - } 3119 3119 + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); 2741 3120 2742 2742 - // compute interleaved mcu info 2743 2743 - z->img_h_max = h_max; 2744 2744 - z->img_v_max = v_max; 2745 2745 - z->img_mcu_w = h_max * 8; 2746 2746 - z->img_mcu_h = v_max * 8; 2747 2747 - z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; 2748 2748 - z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; 3121 3121 + for (i = 0; i < s->img_n; ++i) { 3122 3122 + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; 3123 3123 + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; 3124 3124 + } 2749 3125 2750 2750 - for (i=0; i < s->img_n; ++i) { 2751 2751 - // number of effective pixels (e.g. for non-interleaved MCU) 2752 2752 - z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; 2753 2753 - z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; 2754 2754 - // to simplify generation, we'll allocate enough memory to decode 2755 2755 - // the bogus oversized data from using interleaved MCUs and their 2756 2756 - // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't 2757 2757 - // discard the extra data until colorspace conversion 2758 2758 - z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; 2759 2759 - z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; 2760 2760 - z->img_comp[i].raw_data = stbi__malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); 3126 3126 + // compute interleaved mcu info 3127 3127 + z->img_h_max = h_max; 3128 3128 + z->img_v_max = v_max; 3129 3129 + z->img_mcu_w = h_max * 8; 3130 3130 + z->img_mcu_h = v_max * 8; 3131 3131 + // these sizes can't be more than 17 bits 3132 3132 + z->img_mcu_x = (s->img_x + z->img_mcu_w - 1) / z->img_mcu_w; 3133 3133 + z->img_mcu_y = (s->img_y + z->img_mcu_h - 1) / z->img_mcu_h; 2761 3134 2762 2762 - if (z->img_comp[i].raw_data == NULL) { 2763 2763 - for(--i; i >= 0; --i) { 2764 2764 - STBI_FREE(z->img_comp[i].raw_data); 2765 2765 - z->img_comp[i].raw_data = NULL; 2766 2766 - } 2767 2767 - return stbi__err("outofmem", "Out of memory"); 2768 2768 - } 2769 2769 - // align blocks for idct using mmx/sse 2770 2770 - z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); 2771 2771 - z->img_comp[i].linebuf = NULL; 2772 2772 - if (z->progressive) { 2773 2773 - z->img_comp[i].coeff_w = (z->img_comp[i].w2 + 7) >> 3; 2774 2774 - z->img_comp[i].coeff_h = (z->img_comp[i].h2 + 7) >> 3; 2775 2775 - z->img_comp[i].raw_coeff = STBI_MALLOC(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15); 2776 2776 - z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); 2777 2777 - } else { 2778 2778 - z->img_comp[i].coeff = 0; 2779 2779 - z->img_comp[i].raw_coeff = 0; 2780 2780 - } 2781 2781 - } 3135 3135 + for (i = 0; i < s->img_n; ++i) { 3136 3136 + // number of effective pixels (e.g. for non-interleaved MCU) 3137 3137 + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max - 1) / h_max; 3138 3138 + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max - 1) / v_max; 3139 3139 + // to simplify generation, we'll allocate enough memory to decode 3140 3140 + // the bogus oversized data from using interleaved MCUs and their 3141 3141 + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't 3142 3142 + // discard the extra data until colorspace conversion 3143 3143 + // 3144 3144 + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) 3145 3145 + // so these muls can't overflow with 32-bit ints (which we require) 3146 3146 + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; 3147 3147 + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; 3148 3148 + z->img_comp[i].coeff = 0; 3149 3149 + z->img_comp[i].raw_coeff = 0; 3150 3150 + z->img_comp[i].linebuf = NULL; 3151 3151 + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); 3152 3152 + if (z->img_comp[i].raw_data == NULL) 3153 3153 + return stbi__free_jpeg_components(z, i + 1, stbi__err("outofmem", "Out of memory")); 3154 3154 + // align blocks for idct using mmx/sse 3155 3155 + z->img_comp[i].data = (stbi_uc*)(((size_t)z->img_comp[i].raw_data + 15) & ~15); 3156 3156 + if (z->progressive) { 3157 3157 + // w2, h2 are multiples of 8 (see above) 3158 3158 + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; 3159 3159 + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; 3160 3160 + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); 3161 3161 + if (z->img_comp[i].raw_coeff == NULL) 3162 3162 + return stbi__free_jpeg_components(z, i + 1, stbi__err("outofmem", "Out of memory")); 3163 3163 + z->img_comp[i].coeff = (short*)(((size_t)z->img_comp[i].raw_coeff + 15) & ~15); 3164 3164 + } 3165 3165 + } 2782 3166 2783 2783 - return 1; 3167 3167 + return 1; 2784 3168 } 2785 3169 2786 3170 // use comparisons since in some cases we handle more than one case (e.g. SOF) ··· 2792 3176 2793 3177 #define stbi__SOF_progressive(x) ((x) == 0xc2) 2794 3178 2795 2795 - static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) 3179 3179 + static int stbi__decode_jpeg_header(stbi__jpeg* z, int scan) 2796 3180 { 2797 2797 - int m; 2798 2798 - z->marker = STBI__MARKER_none; // initialize cached marker to empty 2799 2799 - m = stbi__get_marker(z); 2800 2800 - if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); 2801 2801 - if (scan == STBI__SCAN_type) return 1; 2802 2802 - m = stbi__get_marker(z); 2803 2803 - while (!stbi__SOF(m)) { 2804 2804 - if (!stbi__process_marker(z,m)) return 0; 2805 2805 - m = stbi__get_marker(z); 2806 2806 - while (m == STBI__MARKER_none) { 2807 2807 - // some files have extra padding after their blocks, so ok, we'll scan 2808 2808 - if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); 2809 2809 - m = stbi__get_marker(z); 2810 2810 - } 2811 2811 - } 2812 2812 - z->progressive = stbi__SOF_progressive(m); 2813 2813 - if (!stbi__process_frame_header(z, scan)) return 0; 2814 2814 - return 1; 3181 3181 + int m; 3182 3182 + z->jfif = 0; 3183 3183 + z->app14_color_transform = -1; // valid values are 0,1,2 3184 3184 + z->marker = STBI__MARKER_none; // initialize cached marker to empty 3185 3185 + m = stbi__get_marker(z); 3186 3186 + if (!stbi__SOI(m)) return stbi__err("no SOI", "Corrupt JPEG"); 3187 3187 + if (scan == STBI__SCAN_type) return 1; 3188 3188 + m = stbi__get_marker(z); 3189 3189 + while (!stbi__SOF(m)) { 3190 3190 + if (!stbi__process_marker(z, m)) return 0; 3191 3191 + m = stbi__get_marker(z); 3192 3192 + while (m == STBI__MARKER_none) { 3193 3193 + // some files have extra padding after their blocks, so ok, we'll scan 3194 3194 + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); 3195 3195 + m = stbi__get_marker(z); 3196 3196 + } 3197 3197 + } 3198 3198 + z->progressive = stbi__SOF_progressive(m); 3199 3199 + if (!stbi__process_frame_header(z, scan)) return 0; 3200 3200 + return 1; 2815 3201 } 2816 3202 2817 3203 // decode image to YCbCr format 2818 2818 - static int stbi__decode_jpeg_image(stbi__jpeg *j) 3204 3204 + static int stbi__decode_jpeg_image(stbi__jpeg* j) 2819 3205 { 2820 2820 - int m; 2821 2821 - for (m = 0; m < 4; m++) { 2822 2822 - j->img_comp[m].raw_data = NULL; 2823 2823 - j->img_comp[m].raw_coeff = NULL; 2824 2824 - } 2825 2825 - j->restart_interval = 0; 2826 2826 - if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; 2827 2827 - m = stbi__get_marker(j); 2828 2828 - while (!stbi__EOI(m)) { 2829 2829 - if (stbi__SOS(m)) { 2830 2830 - if (!stbi__process_scan_header(j)) return 0; 2831 2831 - if (!stbi__parse_entropy_coded_data(j)) return 0; 2832 2832 - if (j->marker == STBI__MARKER_none ) { 2833 2833 - // handle 0s at the end of image data from IP Kamera 9060 2834 2834 - while (!stbi__at_eof(j->s)) { 2835 2835 - int x = stbi__get8(j->s); 2836 2836 - if (x == 255) { 2837 2837 - j->marker = stbi__get8(j->s); 2838 2838 - break; 2839 2839 - } else if (x != 0) { 2840 2840 - return stbi__err("junk before marker", "Corrupt JPEG"); 2841 2841 - } 3206 3206 + int m; 3207 3207 + for (m = 0; m < 4; m++) { 3208 3208 + j->img_comp[m].raw_data = NULL; 3209 3209 + j->img_comp[m].raw_coeff = NULL; 3210 3210 + } 3211 3211 + j->restart_interval = 0; 3212 3212 + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; 3213 3213 + m = stbi__get_marker(j); 3214 3214 + while (!stbi__EOI(m)) { 3215 3215 + if (stbi__SOS(m)) { 3216 3216 + if (!stbi__process_scan_header(j)) return 0; 3217 3217 + if (!stbi__parse_entropy_coded_data(j)) return 0; 3218 3218 + if (j->marker == STBI__MARKER_none) { 3219 3219 + // handle 0s at the end of image data from IP Kamera 9060 3220 3220 + while (!stbi__at_eof(j->s)) { 3221 3221 + int x = stbi__get8(j->s); 3222 3222 + if (x == 255) { 3223 3223 + j->marker = stbi__get8(j->s); 3224 3224 + break; 3225 3225 + } 3226 3226 + } 3227 3227 + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 2842 3228 } 2843 2843 - // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 2844 2844 - } 2845 2845 - } else { 2846 2846 - if (!stbi__process_marker(j, m)) return 0; 2847 2847 - } 2848 2848 - m = stbi__get_marker(j); 2849 2849 - } 2850 2850 - if (j->progressive) 2851 2851 - stbi__jpeg_finish(j); 2852 2852 - return 1; 3229 3229 + } 3230 3230 + else if (stbi__DNL(m)) { 3231 3231 + int Ld = stbi__get16be(j->s); 3232 3232 + stbi__uint32 NL = stbi__get16be(j->s); 3233 3233 + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); 3234 3234 + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); 3235 3235 + } 3236 3236 + else { 3237 3237 + if (!stbi__process_marker(j, m)) return 0; 3238 3238 + } 3239 3239 + m = stbi__get_marker(j); 3240 3240 + } 3241 3241 + if (j->progressive) 3242 3242 + stbi__jpeg_finish(j); 3243 3243 + return 1; 2853 3244 } 2854 3245 2855 3246 // static jfif-centered resampling (across block boundaries) 2856 3247 2857 2857 - typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, 2858 2858 - int w, int hs); 3248 3248 + typedef stbi_uc* (*resample_row_func)(stbi_uc* out, stbi_uc* in0, stbi_uc* in1, 3249 3249 + int w, int hs); 2859 3250 2860 3251 #define stbi__div4(x) ((stbi_uc) ((x) >> 2)) 2861 3252 2862 2862 - static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3253 3253 + static stbi_uc* resample_row_1(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 2863 3254 { 2864 2864 - STBI_NOTUSED(out); 2865 2865 - STBI_NOTUSED(in_far); 2866 2866 - STBI_NOTUSED(w); 2867 2867 - STBI_NOTUSED(hs); 2868 2868 - return in_near; 3255 3255 + STBI_NOTUSED(out); 3256 3256 + STBI_NOTUSED(in_far); 3257 3257 + STBI_NOTUSED(w); 3258 3258 + STBI_NOTUSED(hs); 3259 3259 + return in_near; 2869 3260 } 2870 3261 2871 2871 - static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3262 3262 + static stbi_uc* stbi__resample_row_v_2(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 2872 3263 { 2873 2873 - // need to generate two samples vertically for every one in input 2874 2874 - int i; 2875 2875 - STBI_NOTUSED(hs); 2876 2876 - for (i=0; i < w; ++i) 2877 2877 - out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); 2878 2878 - return out; 3264 3264 + // need to generate two samples vertically for every one in input 3265 3265 + int i; 3266 3266 + STBI_NOTUSED(hs); 3267 3267 + for (i = 0; i < w; ++i) 3268 3268 + out[i] = stbi__div4(3 * in_near[i] + in_far[i] + 2); 3269 3269 + return out; 2879 3270 } 2880 3271 2881 2881 - static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3272 3272 + static stbi_uc* stbi__resample_row_h_2(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 2882 3273 { 2883 2883 - // need to generate two samples horizontally for every one in input 2884 2884 - int i; 2885 2885 - stbi_uc *input = in_near; 3274 3274 + // need to generate two samples horizontally for every one in input 3275 3275 + int i; 3276 3276 + stbi_uc* input = in_near; 2886 3277 2887 2887 - if (w == 1) { 2888 2888 - // if only one sample, can't do any interpolation 2889 2889 - out[0] = out[1] = input[0]; 2890 2890 - return out; 2891 2891 - } 3278 3278 + if (w == 1) { 3279 3279 + // if only one sample, can't do any interpolation 3280 3280 + out[0] = out[1] = input[0]; 3281 3281 + return out; 3282 3282 + } 2892 3283 2893 2893 - out[0] = input[0]; 2894 2894 - out[1] = stbi__div4(input[0]*3 + input[1] + 2); 2895 2895 - for (i=1; i < w-1; ++i) { 2896 2896 - int n = 3*input[i]+2; 2897 2897 - out[i*2+0] = stbi__div4(n+input[i-1]); 2898 2898 - out[i*2+1] = stbi__div4(n+input[i+1]); 2899 2899 - } 2900 2900 - out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); 2901 2901 - out[i*2+1] = input[w-1]; 3284 3284 + out[0] = input[0]; 3285 3285 + out[1] = stbi__div4(input[0] * 3 + input[1] + 2); 3286 3286 + for (i = 1; i < w - 1; ++i) { 3287 3287 + int n = 3 * input[i] + 2; 3288 3288 + out[i * 2 + 0] = stbi__div4(n + input[i - 1]); 3289 3289 + out[i * 2 + 1] = stbi__div4(n + input[i + 1]); 3290 3290 + } 3291 3291 + out[i * 2 + 0] = stbi__div4(input[w - 2] * 3 + input[w - 1] + 2); 3292 3292 + out[i * 2 + 1] = input[w - 1]; 2902 3293 2903 2903 - STBI_NOTUSED(in_far); 2904 2904 - STBI_NOTUSED(hs); 3294 3294 + STBI_NOTUSED(in_far); 3295 3295 + STBI_NOTUSED(hs); 2905 3296 2906 2906 - return out; 3297 3297 + return out; 2907 3298 } 2908 3299 2909 3300 #define stbi__div16(x) ((stbi_uc) ((x) >> 4)) 2910 3301 2911 2911 - static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3302 3302 + static stbi_uc* stbi__resample_row_hv_2(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 2912 3303 { 2913 2913 - // need to generate 2x2 samples for every one in input 2914 2914 - int i,t0,t1; 2915 2915 - if (w == 1) { 2916 2916 - out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); 2917 2917 - return out; 2918 2918 - } 3304 3304 + // need to generate 2x2 samples for every one in input 3305 3305 + int i, t0, t1; 3306 3306 + if (w == 1) { 3307 3307 + out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2); 3308 3308 + return out; 3309 3309 + } 2919 3310 2920 2920 - t1 = 3*in_near[0] + in_far[0]; 2921 2921 - out[0] = stbi__div4(t1+2); 2922 2922 - for (i=1; i < w; ++i) { 2923 2923 - t0 = t1; 2924 2924 - t1 = 3*in_near[i]+in_far[i]; 2925 2925 - out[i*2-1] = stbi__div16(3*t0 + t1 + 8); 2926 2926 - out[i*2 ] = stbi__div16(3*t1 + t0 + 8); 2927 2927 - } 2928 2928 - out[w*2-1] = stbi__div4(t1+2); 3311 3311 + t1 = 3 * in_near[0] + in_far[0]; 3312 3312 + out[0] = stbi__div4(t1 + 2); 3313 3313 + for (i = 1; i < w; ++i) { 3314 3314 + t0 = t1; 3315 3315 + t1 = 3 * in_near[i] + in_far[i]; 3316 3316 + out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8); 3317 3317 + out[i * 2] = stbi__div16(3 * t1 + t0 + 8); 3318 3318 + } 3319 3319 + out[w * 2 - 1] = stbi__div4(t1 + 2); 2929 3320 2930 2930 - STBI_NOTUSED(hs); 3321 3321 + STBI_NOTUSED(hs); 2931 3322 2932 2932 - return out; 3323 3323 + return out; 2933 3324 } 2934 3325 2935 3326 #if defined(STBI_SSE2) || defined(STBI_NEON) 2936 2936 - static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3327 3327 + static stbi_uc* stbi__resample_row_hv_2_simd(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 2937 3328 { 2938 2938 - // need to generate 2x2 samples for every one in input 2939 2939 - int i=0,t0,t1; 3329 3329 + // need to generate 2x2 samples for every one in input 3330 3330 + int i = 0, t0, t1; 2940 3331 2941 2941 - if (w == 1) { 2942 2942 - out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); 2943 2943 - return out; 2944 2944 - } 3332 3332 + if (w == 1) { 3333 3333 + out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2); 3334 3334 + return out; 3335 3335 + } 2945 3336 2946 2946 - t1 = 3*in_near[0] + in_far[0]; 2947 2947 - // process groups of 8 pixels for as long as we can. 2948 2948 - // note we can't handle the last pixel in a row in this loop 2949 2949 - // because we need to handle the filter boundary conditions. 2950 2950 - for (; i < ((w-1) & ~7); i += 8) { 3337 3337 + t1 = 3 * in_near[0] + in_far[0]; 3338 3338 + // process groups of 8 pixels for as long as we can. 3339 3339 + // note we can't handle the last pixel in a row in this loop 3340 3340 + // because we need to handle the filter boundary conditions. 3341 3341 + for (; i < ((w - 1) & ~7); i += 8) { 2951 3342 #if defined(STBI_SSE2) 2952 2952 - // load and perform the vertical filtering pass 2953 2953 - // this uses 3*x + y = 4*x + (y - x) 2954 2954 - __m128i zero = _mm_setzero_si128(); 2955 2955 - __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); 2956 2956 - __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); 2957 2957 - __m128i farw = _mm_unpacklo_epi8(farb, zero); 2958 2958 - __m128i nearw = _mm_unpacklo_epi8(nearb, zero); 2959 2959 - __m128i diff = _mm_sub_epi16(farw, nearw); 2960 2960 - __m128i nears = _mm_slli_epi16(nearw, 2); 2961 2961 - __m128i curr = _mm_add_epi16(nears, diff); // current row 3343 3343 + // load and perform the vertical filtering pass 3344 3344 + // this uses 3*x + y = 4*x + (y - x) 3345 3345 + __m128i zero = _mm_setzero_si128(); 3346 3346 + __m128i farb = _mm_loadl_epi64((__m128i*) (in_far + i)); 3347 3347 + __m128i nearb = _mm_loadl_epi64((__m128i*) (in_near + i)); 3348 3348 + __m128i farw = _mm_unpacklo_epi8(farb, zero); 3349 3349 + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); 3350 3350 + __m128i diff = _mm_sub_epi16(farw, nearw); 3351 3351 + __m128i nears = _mm_slli_epi16(nearw, 2); 3352 3352 + __m128i curr = _mm_add_epi16(nears, diff); // current row 2962 3353 2963 2963 - // horizontal filter works the same based on shifted vers of current 2964 2964 - // row. "prev" is current row shifted right by 1 pixel; we need to 2965 2965 - // insert the previous pixel value (from t1). 2966 2966 - // "next" is current row shifted left by 1 pixel, with first pixel 2967 2967 - // of next block of 8 pixels added in. 2968 2968 - __m128i prv0 = _mm_slli_si128(curr, 2); 2969 2969 - __m128i nxt0 = _mm_srli_si128(curr, 2); 2970 2970 - __m128i prev = _mm_insert_epi16(prv0, t1, 0); 2971 2971 - __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); 3354 3354 + // horizontal filter works the same based on shifted vers of current 3355 3355 + // row. "prev" is current row shifted right by 1 pixel; we need to 3356 3356 + // insert the previous pixel value (from t1). 3357 3357 + // "next" is current row shifted left by 1 pixel, with first pixel 3358 3358 + // of next block of 8 pixels added in. 3359 3359 + __m128i prv0 = _mm_slli_si128(curr, 2); 3360 3360 + __m128i nxt0 = _mm_srli_si128(curr, 2); 3361 3361 + __m128i prev = _mm_insert_epi16(prv0, t1, 0); 3362 3362 + __m128i next = _mm_insert_epi16(nxt0, 3 * in_near[i + 8] + in_far[i + 8], 7); 2972 3363 2973 2973 - // horizontal filter, polyphase implementation since it's convenient: 2974 2974 - // even pixels = 3*cur + prev = cur*4 + (prev - cur) 2975 2975 - // odd pixels = 3*cur + next = cur*4 + (next - cur) 2976 2976 - // note the shared term. 2977 2977 - __m128i bias = _mm_set1_epi16(8); 2978 2978 - __m128i curs = _mm_slli_epi16(curr, 2); 2979 2979 - __m128i prvd = _mm_sub_epi16(prev, curr); 2980 2980 - __m128i nxtd = _mm_sub_epi16(next, curr); 2981 2981 - __m128i curb = _mm_add_epi16(curs, bias); 2982 2982 - __m128i even = _mm_add_epi16(prvd, curb); 2983 2983 - __m128i odd = _mm_add_epi16(nxtd, curb); 3364 3364 + // horizontal filter, polyphase implementation since it's convenient: 3365 3365 + // even pixels = 3*cur + prev = cur*4 + (prev - cur) 3366 3366 + // odd pixels = 3*cur + next = cur*4 + (next - cur) 3367 3367 + // note the shared term. 3368 3368 + __m128i bias = _mm_set1_epi16(8); 3369 3369 + __m128i curs = _mm_slli_epi16(curr, 2); 3370 3370 + __m128i prvd = _mm_sub_epi16(prev, curr); 3371 3371 + __m128i nxtd = _mm_sub_epi16(next, curr); 3372 3372 + __m128i curb = _mm_add_epi16(curs, bias); 3373 3373 + __m128i even = _mm_add_epi16(prvd, curb); 3374 3374 + __m128i odd = _mm_add_epi16(nxtd, curb); 2984 3375 2985 2985 - // interleave even and odd pixels, then undo scaling. 2986 2986 - __m128i int0 = _mm_unpacklo_epi16(even, odd); 2987 2987 - __m128i int1 = _mm_unpackhi_epi16(even, odd); 2988 2988 - __m128i de0 = _mm_srli_epi16(int0, 4); 2989 2989 - __m128i de1 = _mm_srli_epi16(int1, 4); 3376 3376 + // interleave even and odd pixels, then undo scaling. 3377 3377 + __m128i int0 = _mm_unpacklo_epi16(even, odd); 3378 3378 + __m128i int1 = _mm_unpackhi_epi16(even, odd); 3379 3379 + __m128i de0 = _mm_srli_epi16(int0, 4); 3380 3380 + __m128i de1 = _mm_srli_epi16(int1, 4); 2990 3381 2991 2991 - // pack and write output 2992 2992 - __m128i outv = _mm_packus_epi16(de0, de1); 2993 2993 - _mm_storeu_si128((__m128i *) (out + i*2), outv); 3382 3382 + // pack and write output 3383 3383 + __m128i outv = _mm_packus_epi16(de0, de1); 3384 3384 + _mm_storeu_si128((__m128i*) (out + i * 2), outv); 2994 3385 #elif defined(STBI_NEON) 2995 2995 - // load and perform the vertical filtering pass 2996 2996 - // this uses 3*x + y = 4*x + (y - x) 2997 2997 - uint8x8_t farb = vld1_u8(in_far + i); 2998 2998 - uint8x8_t nearb = vld1_u8(in_near + i); 2999 2999 - int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); 3000 3000 - int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); 3001 3001 - int16x8_t curr = vaddq_s16(nears, diff); // current row 3386 3386 + // load and perform the vertical filtering pass 3387 3387 + // this uses 3*x + y = 4*x + (y - x) 3388 3388 + uint8x8_t farb = vld1_u8(in_far + i); 3389 3389 + uint8x8_t nearb = vld1_u8(in_near + i); 3390 3390 + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); 3391 3391 + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); 3392 3392 + int16x8_t curr = vaddq_s16(nears, diff); // current row 3002 3393 3003 3003 - // horizontal filter works the same based on shifted vers of current 3004 3004 - // row. "prev" is current row shifted right by 1 pixel; we need to 3005 3005 - // insert the previous pixel value (from t1). 3006 3006 - // "next" is current row shifted left by 1 pixel, with first pixel 3007 3007 - // of next block of 8 pixels added in. 3008 3008 - int16x8_t prv0 = vextq_s16(curr, curr, 7); 3009 3009 - int16x8_t nxt0 = vextq_s16(curr, curr, 1); 3010 3010 - int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); 3011 3011 - int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); 3394 3394 + // horizontal filter works the same based on shifted vers of current 3395 3395 + // row. "prev" is current row shifted right by 1 pixel; we need to 3396 3396 + // insert the previous pixel value (from t1). 3397 3397 + // "next" is current row shifted left by 1 pixel, with first pixel 3398 3398 + // of next block of 8 pixels added in. 3399 3399 + int16x8_t prv0 = vextq_s16(curr, curr, 7); 3400 3400 + int16x8_t nxt0 = vextq_s16(curr, curr, 1); 3401 3401 + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); 3402 3402 + int16x8_t next = vsetq_lane_s16(3 * in_near[i + 8] + in_far[i + 8], nxt0, 7); 3012 3403 3013 3013 - // horizontal filter, polyphase implementation since it's convenient: 3014 3014 - // even pixels = 3*cur + prev = cur*4 + (prev - cur) 3015 3015 - // odd pixels = 3*cur + next = cur*4 + (next - cur) 3016 3016 - // note the shared term. 3017 3017 - int16x8_t curs = vshlq_n_s16(curr, 2); 3018 3018 - int16x8_t prvd = vsubq_s16(prev, curr); 3019 3019 - int16x8_t nxtd = vsubq_s16(next, curr); 3020 3020 - int16x8_t even = vaddq_s16(curs, prvd); 3021 3021 - int16x8_t odd = vaddq_s16(curs, nxtd); 3404 3404 + // horizontal filter, polyphase implementation since it's convenient: 3405 3405 + // even pixels = 3*cur + prev = cur*4 + (prev - cur) 3406 3406 + // odd pixels = 3*cur + next = cur*4 + (next - cur) 3407 3407 + // note the shared term. 3408 3408 + int16x8_t curs = vshlq_n_s16(curr, 2); 3409 3409 + int16x8_t prvd = vsubq_s16(prev, curr); 3410 3410 + int16x8_t nxtd = vsubq_s16(next, curr); 3411 3411 + int16x8_t even = vaddq_s16(curs, prvd); 3412 3412 + int16x8_t odd = vaddq_s16(curs, nxtd); 3022 3413 3023 3023 - // undo scaling and round, then store with even/odd phases interleaved 3024 3024 - uint8x8x2_t o; 3025 3025 - o.val[0] = vqrshrun_n_s16(even, 4); 3026 3026 - o.val[1] = vqrshrun_n_s16(odd, 4); 3027 3027 - vst2_u8(out + i*2, o); 3414 3414 + // undo scaling and round, then store with even/odd phases interleaved 3415 3415 + uint8x8x2_t o; 3416 3416 + o.val[0] = vqrshrun_n_s16(even, 4); 3417 3417 + o.val[1] = vqrshrun_n_s16(odd, 4); 3418 3418 + vst2_u8(out + i * 2, o); 3028 3419 #endif 3029 3420 3030 3030 - // "previous" value for next iter 3031 3031 - t1 = 3*in_near[i+7] + in_far[i+7]; 3032 3032 - } 3421 3421 + // "previous" value for next iter 3422 3422 + t1 = 3 * in_near[i + 7] + in_far[i + 7]; 3423 3423 + } 3033 3424 3034 3034 - t0 = t1; 3035 3035 - t1 = 3*in_near[i] + in_far[i]; 3036 3036 - out[i*2] = stbi__div16(3*t1 + t0 + 8); 3425 3425 + t0 = t1; 3426 3426 + t1 = 3 * in_near[i] + in_far[i]; 3427 3427 + out[i * 2] = stbi__div16(3 * t1 + t0 + 8); 3037 3428 3038 3038 - for (++i; i < w; ++i) { 3039 3039 - t0 = t1; 3040 3040 - t1 = 3*in_near[i]+in_far[i]; 3041 3041 - out[i*2-1] = stbi__div16(3*t0 + t1 + 8); 3042 3042 - out[i*2 ] = stbi__div16(3*t1 + t0 + 8); 3043 3043 - } 3044 3044 - out[w*2-1] = stbi__div4(t1+2); 3429 3429 + for (++i; i < w; ++i) { 3430 3430 + t0 = t1; 3431 3431 + t1 = 3 * in_near[i] + in_far[i]; 3432 3432 + out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8); 3433 3433 + out[i * 2] = stbi__div16(3 * t1 + t0 + 8); 3434 3434 + } 3435 3435 + out[w * 2 - 1] = stbi__div4(t1 + 2); 3045 3436 3046 3046 - STBI_NOTUSED(hs); 3437 3437 + STBI_NOTUSED(hs); 3047 3438 3048 3048 - return out; 3439 3439 + return out; 3049 3440 } 3050 3441 #endif 3051 3442 3052 3052 - static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) 3443 3443 + static stbi_uc* stbi__resample_row_generic(stbi_uc* out, stbi_uc* in_near, stbi_uc* in_far, int w, int hs) 3053 3444 { 3054 3054 - // resample with nearest-neighbor 3055 3055 - int i,j; 3056 3056 - STBI_NOTUSED(in_far); 3057 3057 - for (i=0; i < w; ++i) 3058 3058 - for (j=0; j < hs; ++j) 3059 3059 - out[i*hs+j] = in_near[i]; 3060 3060 - return out; 3445 3445 + // resample with nearest-neighbor 3446 3446 + int i, j; 3447 3447 + STBI_NOTUSED(in_far); 3448 3448 + for (i = 0; i < w; ++i) 3449 3449 + for (j = 0; j < hs; ++j) 3450 3450 + out[i * hs + j] = in_near[i]; 3451 3451 + return out; 3061 3452 } 3062 3453 3063 3063 - #ifdef STBI_JPEG_OLD 3064 3064 - // this is the same YCbCr-to-RGB calculation that stb_image has used 3065 3065 - // historically before the algorithm changes in 1.49 3066 3066 - #define float2fixed(x) ((int) ((x) * 65536 + 0.5)) 3067 3067 - 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) 3068 3068 - { 3069 3069 - int i; 3070 3070 - for (i=0; i < count; ++i) { 3071 3071 - int y_fixed = (y[i] << 16) + 32768; // rounding 3072 3072 - int r,g,b; 3073 3073 - int cr = pcr[i] - 128; 3074 3074 - int cb = pcb[i] - 128; 3075 3075 - r = y_fixed + cr*float2fixed(1.40200f); 3076 3076 - g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f); 3077 3077 - b = y_fixed + cb*float2fixed(1.77200f); 3078 3078 - r >>= 16; 3079 3079 - g >>= 16; 3080 3080 - b >>= 16; 3081 3081 - if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } 3082 3082 - if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } 3083 3083 - if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } 3084 3084 - out[0] = (stbi_uc)r; 3085 3085 - out[1] = (stbi_uc)g; 3086 3086 - out[2] = (stbi_uc)b; 3087 3087 - out[3] = 255; 3088 3088 - out += step; 3089 3089 - } 3090 3090 - } 3091 3091 - #else 3092 3454 // this is a reduced-precision calculation of YCbCr-to-RGB introduced 3093 3455 // to make sure the code produces the same results in both SIMD and scalar 3094 3094 - #define float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) 3095 3095 - 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) 3456 3456 + #define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) 3457 3457 + 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) 3096 3458 { 3097 3097 - int i; 3098 3098 - for (i=0; i < count; ++i) { 3099 3099 - int y_fixed = (y[i] << 20) + (1<<19); // rounding 3100 3100 - int r,g,b; 3101 3101 - int cr = pcr[i] - 128; 3102 3102 - int cb = pcb[i] - 128; 3103 3103 - r = y_fixed + cr* float2fixed(1.40200f); 3104 3104 - g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); 3105 3105 - b = y_fixed + cb* float2fixed(1.77200f); 3106 3106 - r >>= 20; 3107 3107 - g >>= 20; 3108 3108 - b >>= 20; 3109 3109 - if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } 3110 3110 - if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } 3111 3111 - if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } 3112 3112 - out[0] = (stbi_uc)r; 3113 3113 - out[1] = (stbi_uc)g; 3114 3114 - out[2] = (stbi_uc)b; 3115 3115 - out[3] = 255; 3116 3116 - out += step; 3117 3117 - } 3459 3459 + int i; 3460 3460 + for (i = 0; i < count; ++i) { 3461 3461 + int y_fixed = (y[i] << 20) + (1 << 19); // rounding 3462 3462 + int r, g, b; 3463 3463 + int cr = pcr[i] - 128; 3464 3464 + int cb = pcb[i] - 128; 3465 3465 + r = y_fixed + cr * stbi__float2fixed(1.40200f); 3466 3466 + g = y_fixed + (cr * -stbi__float2fixed(0.71414f)) + ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000); 3467 3467 + b = y_fixed + cb * stbi__float2fixed(1.77200f); 3468 3468 + r >>= 20; 3469 3469 + g >>= 20; 3470 3470 + b >>= 20; 3471 3471 + if ((unsigned)r > 255) { if (r < 0) r = 0; else r = 255; } 3472 3472 + if ((unsigned)g > 255) { if (g < 0) g = 0; else g = 255; } 3473 3473 + if ((unsigned)b > 255) { if (b < 0) b = 0; else b = 255; } 3474 3474 + out[0] = (stbi_uc)r; 3475 3475 + out[1] = (stbi_uc)g; 3476 3476 + out[2] = (stbi_uc)b; 3477 3477 + out[3] = 255; 3478 3478 + out += step; 3479 3479 + } 3118 3480 } 3119 3119 - #endif 3120 3481 3121 3482 #if defined(STBI_SSE2) || defined(STBI_NEON) 3122 3122 - 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) 3483 3483 + 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) 3123 3484 { 3124 3124 - int i = 0; 3485 3485 + int i = 0; 3125 3486 3126 3487 #ifdef STBI_SSE2 3127 3127 - // step == 3 is pretty ugly on the final interleave, and i'm not convinced 3128 3128 - // it's useful in practice (you wouldn't use it for textures, for example). 3129 3129 - // so just accelerate step == 4 case. 3130 3130 - if (step == 4) { 3131 3131 - // this is a fairly straightforward implementation and not super-optimized. 3132 3132 - __m128i signflip = _mm_set1_epi8(-0x80); 3133 3133 - __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); 3134 3134 - __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); 3135 3135 - __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); 3136 3136 - __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); 3137 3137 - __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); 3138 3138 - __m128i xw = _mm_set1_epi16(255); // alpha channel 3488 3488 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced 3489 3489 + // it's useful in practice (you wouldn't use it for textures, for example). 3490 3490 + // so just accelerate step == 4 case. 3491 3491 + if (step == 4) { 3492 3492 + // this is a fairly straightforward implementation and not super-optimized. 3493 3493 + __m128i signflip = _mm_set1_epi8(-0x80); 3494 3494 + __m128i cr_const0 = _mm_set1_epi16((short)(1.40200f * 4096.0f + 0.5f)); 3495 3495 + __m128i cr_const1 = _mm_set1_epi16(-(short)(0.71414f * 4096.0f + 0.5f)); 3496 3496 + __m128i cb_const0 = _mm_set1_epi16(-(short)(0.34414f * 4096.0f + 0.5f)); 3497 3497 + __m128i cb_const1 = _mm_set1_epi16((short)(1.77200f * 4096.0f + 0.5f)); 3498 3498 + __m128i y_bias = _mm_set1_epi8((char)(unsigned char)128); 3499 3499 + __m128i xw = _mm_set1_epi16(255); // alpha channel 3139 3500 3140 3140 - for (; i+7 < count; i += 8) { 3141 3141 - // load 3142 3142 - __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); 3143 3143 - __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); 3144 3144 - __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); 3145 3145 - __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 3146 3146 - __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 3501 3501 + for (; i + 7 < count; i += 8) { 3502 3502 + // load 3503 3503 + __m128i y_bytes = _mm_loadl_epi64((__m128i*) (y + i)); 3504 3504 + __m128i cr_bytes = _mm_loadl_epi64((__m128i*) (pcr + i)); 3505 3505 + __m128i cb_bytes = _mm_loadl_epi64((__m128i*) (pcb + i)); 3506 3506 + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 3507 3507 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 3147 3508 3148 3148 - // unpack to short (and left-shift cr, cb by 8) 3149 3149 - __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); 3150 3150 - __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); 3151 3151 - __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); 3509 3509 + // unpack to short (and left-shift cr, cb by 8) 3510 3510 + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); 3511 3511 + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); 3512 3512 + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); 3152 3513 3153 3153 - // color transform 3154 3154 - __m128i yws = _mm_srli_epi16(yw, 4); 3155 3155 - __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); 3156 3156 - __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); 3157 3157 - __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); 3158 3158 - __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); 3159 3159 - __m128i rws = _mm_add_epi16(cr0, yws); 3160 3160 - __m128i gwt = _mm_add_epi16(cb0, yws); 3161 3161 - __m128i bws = _mm_add_epi16(yws, cb1); 3162 3162 - __m128i gws = _mm_add_epi16(gwt, cr1); 3514 3514 + // color transform 3515 3515 + __m128i yws = _mm_srli_epi16(yw, 4); 3516 3516 + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); 3517 3517 + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); 3518 3518 + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); 3519 3519 + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); 3520 3520 + __m128i rws = _mm_add_epi16(cr0, yws); 3521 3521 + __m128i gwt = _mm_add_epi16(cb0, yws); 3522 3522 + __m128i bws = _mm_add_epi16(yws, cb1); 3523 3523 + __m128i gws = _mm_add_epi16(gwt, cr1); 3163 3524 3164 3164 - // descale 3165 3165 - __m128i rw = _mm_srai_epi16(rws, 4); 3166 3166 - __m128i bw = _mm_srai_epi16(bws, 4); 3167 3167 - __m128i gw = _mm_srai_epi16(gws, 4); 3525 3525 + // descale 3526 3526 + __m128i rw = _mm_srai_epi16(rws, 4); 3527 3527 + __m128i bw = _mm_srai_epi16(bws, 4); 3528 3528 + __m128i gw = _mm_srai_epi16(gws, 4); 3168 3529 3169 3169 - // back to byte, set up for transpose 3170 3170 - __m128i brb = _mm_packus_epi16(rw, bw); 3171 3171 - __m128i gxb = _mm_packus_epi16(gw, xw); 3530 3530 + // back to byte, set up for transpose 3531 3531 + __m128i brb = _mm_packus_epi16(rw, bw); 3532 3532 + __m128i gxb = _mm_packus_epi16(gw, xw); 3172 3533 3173 3173 - // transpose to interleave channels 3174 3174 - __m128i t0 = _mm_unpacklo_epi8(brb, gxb); 3175 3175 - __m128i t1 = _mm_unpackhi_epi8(brb, gxb); 3176 3176 - __m128i o0 = _mm_unpacklo_epi16(t0, t1); 3177 3177 - __m128i o1 = _mm_unpackhi_epi16(t0, t1); 3534 3534 + // transpose to interleave channels 3535 3535 + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); 3536 3536 + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); 3537 3537 + __m128i o0 = _mm_unpacklo_epi16(t0, t1); 3538 3538 + __m128i o1 = _mm_unpackhi_epi16(t0, t1); 3178 3539 3179 3179 - // store 3180 3180 - _mm_storeu_si128((__m128i *) (out + 0), o0); 3181 3181 - _mm_storeu_si128((__m128i *) (out + 16), o1); 3182 3182 - out += 32; 3183 3183 - } 3184 3184 - } 3540 3540 + // store 3541 3541 + _mm_storeu_si128((__m128i*) (out + 0), o0); 3542 3542 + _mm_storeu_si128((__m128i*) (out + 16), o1); 3543 3543 + out += 32; 3544 3544 + } 3545 3545 + } 3185 3546 #endif 3186 3547 3187 3548 #ifdef STBI_NEON 3188 3188 - // in this version, step=3 support would be easy to add. but is there demand? 3189 3189 - if (step == 4) { 3190 3190 - // this is a fairly straightforward implementation and not super-optimized. 3191 3191 - uint8x8_t signflip = vdup_n_u8(0x80); 3192 3192 - int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); 3193 3193 - int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); 3194 3194 - int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); 3195 3195 - int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); 3549 3549 + // in this version, step=3 support would be easy to add. but is there demand? 3550 3550 + if (step == 4) { 3551 3551 + // this is a fairly straightforward implementation and not super-optimized. 3552 3552 + uint8x8_t signflip = vdup_n_u8(0x80); 3553 3553 + int16x8_t cr_const0 = vdupq_n_s16((short)(1.40200f * 4096.0f + 0.5f)); 3554 3554 + int16x8_t cr_const1 = vdupq_n_s16(-(short)(0.71414f * 4096.0f + 0.5f)); 3555 3555 + int16x8_t cb_const0 = vdupq_n_s16(-(short)(0.34414f * 4096.0f + 0.5f)); 3556 3556 + int16x8_t cb_const1 = vdupq_n_s16((short)(1.77200f * 4096.0f + 0.5f)); 3196 3557 3197 3197 - for (; i+7 < count; i += 8) { 3198 3198 - // load 3199 3199 - uint8x8_t y_bytes = vld1_u8(y + i); 3200 3200 - uint8x8_t cr_bytes = vld1_u8(pcr + i); 3201 3201 - uint8x8_t cb_bytes = vld1_u8(pcb + i); 3202 3202 - int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); 3203 3203 - int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); 3558 3558 + for (; i + 7 < count; i += 8) { 3559 3559 + // load 3560 3560 + uint8x8_t y_bytes = vld1_u8(y + i); 3561 3561 + uint8x8_t cr_bytes = vld1_u8(pcr + i); 3562 3562 + uint8x8_t cb_bytes = vld1_u8(pcb + i); 3563 3563 + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); 3564 3564 + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); 3204 3565 3205 3205 - // expand to s16 3206 3206 - int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); 3207 3207 - int16x8_t crw = vshll_n_s8(cr_biased, 7); 3208 3208 - int16x8_t cbw = vshll_n_s8(cb_biased, 7); 3566 3566 + // expand to s16 3567 3567 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); 3568 3568 + int16x8_t crw = vshll_n_s8(cr_biased, 7); 3569 3569 + int16x8_t cbw = vshll_n_s8(cb_biased, 7); 3209 3570 3210 3210 - // color transform 3211 3211 - int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); 3212 3212 - int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); 3213 3213 - int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); 3214 3214 - int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); 3215 3215 - int16x8_t rws = vaddq_s16(yws, cr0); 3216 3216 - int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); 3217 3217 - int16x8_t bws = vaddq_s16(yws, cb1); 3571 3571 + // color transform 3572 3572 + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); 3573 3573 + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); 3574 3574 + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); 3575 3575 + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); 3576 3576 + int16x8_t rws = vaddq_s16(yws, cr0); 3577 3577 + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); 3578 3578 + int16x8_t bws = vaddq_s16(yws, cb1); 3218 3579 3219 3219 - // undo scaling, round, convert to byte 3220 3220 - uint8x8x4_t o; 3221 3221 - o.val[0] = vqrshrun_n_s16(rws, 4); 3222 3222 - o.val[1] = vqrshrun_n_s16(gws, 4); 3223 3223 - o.val[2] = vqrshrun_n_s16(bws, 4); 3224 3224 - o.val[3] = vdup_n_u8(255); 3580 3580 + // undo scaling, round, convert to byte 3581 3581 + uint8x8x4_t o; 3582 3582 + o.val[0] = vqrshrun_n_s16(rws, 4); 3583 3583 + o.val[1] = vqrshrun_n_s16(gws, 4); 3584 3584 + o.val[2] = vqrshrun_n_s16(bws, 4); 3585 3585 + o.val[3] = vdup_n_u8(255); 3225 3586 3226 3226 - // store, interleaving r/g/b/a 3227 3227 - vst4_u8(out, o); 3228 3228 - out += 8*4; 3229 3229 - } 3230 3230 - } 3587 3587 + // store, interleaving r/g/b/a 3588 3588 + vst4_u8(out, o); 3589 3589 + out += 8 * 4; 3590 3590 + } 3591 3591 + } 3231 3592 #endif 3232 3593 3233 3233 - for (; i < count; ++i) { 3234 3234 - int y_fixed = (y[i] << 20) + (1<<19); // rounding 3235 3235 - int r,g,b; 3236 3236 - int cr = pcr[i] - 128; 3237 3237 - int cb = pcb[i] - 128; 3238 3238 - r = y_fixed + cr* float2fixed(1.40200f); 3239 3239 - g = y_fixed + cr*-float2fixed(0.71414f) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); 3240 3240 - b = y_fixed + cb* float2fixed(1.77200f); 3241 3241 - r >>= 20; 3242 3242 - g >>= 20; 3243 3243 - b >>= 20; 3244 3244 - if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } 3245 3245 - if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } 3246 3246 - if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } 3247 3247 - out[0] = (stbi_uc)r; 3248 3248 - out[1] = (stbi_uc)g; 3249 3249 - out[2] = (stbi_uc)b; 3250 3250 - out[3] = 255; 3251 3251 - out += step; 3252 3252 - } 3594 3594 + for (; i < count; ++i) { 3595 3595 + int y_fixed = (y[i] << 20) + (1 << 19); // rounding 3596 3596 + int r, g, b; 3597 3597 + int cr = pcr[i] - 128; 3598 3598 + int cb = pcb[i] - 128; 3599 3599 + r = y_fixed + cr * stbi__float2fixed(1.40200f); 3600 3600 + g = y_fixed + cr * -stbi__float2fixed(0.71414f) + ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000); 3601 3601 + b = y_fixed + cb * stbi__float2fixed(1.77200f); 3602 3602 + r >>= 20; 3603 3603 + g >>= 20; 3604 3604 + b >>= 20; 3605 3605 + if ((unsigned)r > 255) { if (r < 0) r = 0; else r = 255; } 3606 3606 + if ((unsigned)g > 255) { if (g < 0) g = 0; else g = 255; } 3607 3607 + if ((unsigned)b > 255) { if (b < 0) b = 0; else b = 255; } 3608 3608 + out[0] = (stbi_uc)r; 3609 3609 + out[1] = (stbi_uc)g; 3610 3610 + out[2] = (stbi_uc)b; 3611 3611 + out[3] = 255; 3612 3612 + out += step; 3613 3613 + } 3253 3614 } 3254 3615 #endif 3255 3616 3256 3617 // set up the kernels 3257 3257 - static void stbi__setup_jpeg(stbi__jpeg *j) 3618 3618 + static void stbi__setup_jpeg(stbi__jpeg* j) 3258 3619 { 3259 3259 - j->idct_block_kernel = stbi__idct_block; 3260 3260 - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; 3261 3261 - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; 3620 3620 + j->idct_block_kernel = stbi__idct_block; 3621 3621 + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; 3622 3622 + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; 3262 3623 3263 3624 #ifdef STBI_SSE2 3264 3264 - if (stbi__sse2_available()) { 3265 3265 - j->idct_block_kernel = stbi__idct_simd; 3266 3266 - #ifndef STBI_JPEG_OLD 3267 3267 - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; 3268 3268 - #endif 3269 3269 - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; 3270 3270 - } 3625 3625 + if (stbi__sse2_available()) { 3626 3626 + j->idct_block_kernel = stbi__idct_simd; 3627 3627 + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; 3628 3628 + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; 3629 3629 + } 3271 3630 #endif 3272 3631 3273 3632 #ifdef STBI_NEON 3274 3274 - j->idct_block_kernel = stbi__idct_simd; 3275 3275 - #ifndef STBI_JPEG_OLD 3276 3276 - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; 3277 3277 - #endif 3278 3278 - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; 3633 3633 + j->idct_block_kernel = stbi__idct_simd; 3634 3634 + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; 3635 3635 + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; 3279 3636 #endif 3280 3637 } 3281 3638 3282 3639 // clean up the temporary component buffers 3283 3283 - static void stbi__cleanup_jpeg(stbi__jpeg *j) 3640 3640 + static void stbi__cleanup_jpeg(stbi__jpeg* j) 3284 3641 { 3285 3285 - int i; 3286 3286 - for (i=0; i < j->s->img_n; ++i) { 3287 3287 - if (j->img_comp[i].raw_data) { 3288 3288 - STBI_FREE(j->img_comp[i].raw_data); 3289 3289 - j->img_comp[i].raw_data = NULL; 3290 3290 - j->img_comp[i].data = NULL; 3291 3291 - } 3292 3292 - if (j->img_comp[i].raw_coeff) { 3293 3293 - STBI_FREE(j->img_comp[i].raw_coeff); 3294 3294 - j->img_comp[i].raw_coeff = 0; 3295 3295 - j->img_comp[i].coeff = 0; 3296 3296 - } 3297 3297 - if (j->img_comp[i].linebuf) { 3298 3298 - STBI_FREE(j->img_comp[i].linebuf); 3299 3299 - j->img_comp[i].linebuf = NULL; 3300 3300 - } 3301 3301 - } 3642 3642 + stbi__free_jpeg_components(j, j->s->img_n, 0); 3302 3643 } 3303 3644 3304 3645 typedef struct 3305 3646 { 3306 3306 - resample_row_func resample; 3307 3307 - stbi_uc *line0,*line1; 3308 3308 - int hs,vs; // expansion factor in each axis 3309 3309 - int w_lores; // horizontal pixels pre-expansion 3310 3310 - int ystep; // how far through vertical expansion we are 3311 3311 - int ypos; // which pre-expansion row we're on 3647 3647 + resample_row_func resample; 3648 3648 + stbi_uc* line0, * line1; 3649 3649 + int hs, vs; // expansion factor in each axis 3650 3650 + int w_lores; // horizontal pixels pre-expansion 3651 3651 + int ystep; // how far through vertical expansion we are 3652 3652 + int ypos; // which pre-expansion row we're on 3312 3653 } stbi__resample; 3313 3654 3314 3314 - static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) 3655 3655 + // fast 0..255 * 0..255 => 0..255 rounded multiplication 3656 3656 + static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) 3315 3657 { 3316 3316 - int n, decode_n; 3317 3317 - z->s->img_n = 0; // make stbi__cleanup_jpeg safe 3658 3658 + unsigned int t = x * y + 128; 3659 3659 + return (stbi_uc)((t + (t >> 8)) >> 8); 3660 3660 + } 3318 3661 3319 3319 - // validate req_comp 3320 3320 - if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); 3662 3662 + static stbi_uc* load_jpeg_image(stbi__jpeg* z, int* out_x, int* out_y, int* comp, int req_comp) 3663 3663 + { 3664 3664 + int n, decode_n, is_rgb; 3665 3665 + z->s->img_n = 0; // make stbi__cleanup_jpeg safe 3321 3666 3322 3322 - // load a jpeg image from whichever source, but leave in YCbCr format 3323 3323 - if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } 3667 3667 + // validate req_comp 3668 3668 + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); 3669 3669 + 3670 3670 + // load a jpeg image from whichever source, but leave in YCbCr format 3671 3671 + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } 3672 3672 + 3673 3673 + // determine actual number of components to generate 3674 3674 + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; 3324 3675 3325 3325 - // determine actual number of components to generate 3326 3326 - n = req_comp ? req_comp : z->s->img_n; 3676 3676 + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); 3327 3677 3328 3328 - if (z->s->img_n == 3 && n < 3) 3329 3329 - decode_n = 1; 3330 3330 - else 3331 3331 - decode_n = z->s->img_n; 3678 3678 + if (z->s->img_n == 3 && n < 3 && !is_rgb) 3679 3679 + decode_n = 1; 3680 3680 + else 3681 3681 + decode_n = z->s->img_n; 3332 3682 3333 3333 - // resample and color-convert 3334 3334 - { 3335 3335 - int k; 3336 3336 - unsigned int i,j; 3337 3337 - stbi_uc *output; 3338 3338 - stbi_uc *coutput[4]; 3683 3683 + // resample and color-convert 3684 3684 + { 3685 3685 + int k; 3686 3686 + unsigned int i, j; 3687 3687 + stbi_uc* output; 3688 3688 + stbi_uc* coutput[4] = { NULL, NULL, NULL, NULL }; 3339 3689 3340 3340 - stbi__resample res_comp[4]; 3690 3690 + stbi__resample res_comp[4]; 3341 3691 3342 3342 - for (k=0; k < decode_n; ++k) { 3343 3343 - stbi__resample *r = &res_comp[k]; 3692 3692 + for (k = 0; k < decode_n; ++k) { 3693 3693 + stbi__resample* r = &res_comp[k]; 3344 3694 3345 3345 - // allocate line buffer big enough for upsampling off the edges 3346 3346 - // with upsample factor of 4 3347 3347 - z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); 3348 3348 - if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } 3695 3695 + // allocate line buffer big enough for upsampling off the edges 3696 3696 + // with upsample factor of 4 3697 3697 + z->img_comp[k].linebuf = (stbi_uc*)stbi__malloc(z->s->img_x + 3); 3698 3698 + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } 3349 3699 3350 3350 - r->hs = z->img_h_max / z->img_comp[k].h; 3351 3351 - r->vs = z->img_v_max / z->img_comp[k].v; 3352 3352 - r->ystep = r->vs >> 1; 3353 3353 - r->w_lores = (z->s->img_x + r->hs-1) / r->hs; 3354 3354 - r->ypos = 0; 3355 3355 - r->line0 = r->line1 = z->img_comp[k].data; 3700 3700 + r->hs = z->img_h_max / z->img_comp[k].h; 3701 3701 + r->vs = z->img_v_max / z->img_comp[k].v; 3702 3702 + r->ystep = r->vs >> 1; 3703 3703 + r->w_lores = (z->s->img_x + r->hs - 1) / r->hs; 3704 3704 + r->ypos = 0; 3705 3705 + r->line0 = r->line1 = z->img_comp[k].data; 3356 3706 3357 3357 - if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; 3358 3358 - else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; 3359 3359 - else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; 3360 3360 - else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; 3361 3361 - else r->resample = stbi__resample_row_generic; 3362 3362 - } 3707 3707 + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; 3708 3708 + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; 3709 3709 + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; 3710 3710 + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; 3711 3711 + else r->resample = stbi__resample_row_generic; 3712 3712 + } 3363 3713 3364 3364 - // can't error after this so, this is safe 3365 3365 - output = (stbi_uc *) stbi__malloc(n * z->s->img_x * z->s->img_y + 1); 3366 3366 - if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } 3714 3714 + // can't error after this so, this is safe 3715 3715 + output = (stbi_uc*)stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); 3716 3716 + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } 3367 3717 3368 3368 - // now go ahead and resample 3369 3369 - for (j=0; j < z->s->img_y; ++j) { 3370 3370 - stbi_uc *out = output + n * z->s->img_x * j; 3371 3371 - for (k=0; k < decode_n; ++k) { 3372 3372 - stbi__resample *r = &res_comp[k]; 3373 3373 - int y_bot = r->ystep >= (r->vs >> 1); 3374 3374 - coutput[k] = r->resample(z->img_comp[k].linebuf, 3375 3375 - y_bot ? r->line1 : r->line0, 3376 3376 - y_bot ? r->line0 : r->line1, 3377 3377 - r->w_lores, r->hs); 3378 3378 - if (++r->ystep >= r->vs) { 3379 3379 - r->ystep = 0; 3380 3380 - r->line0 = r->line1; 3381 3381 - if (++r->ypos < z->img_comp[k].y) 3382 3382 - r->line1 += z->img_comp[k].w2; 3718 3718 + // now go ahead and resample 3719 3719 + for (j = 0; j < z->s->img_y; ++j) { 3720 3720 + stbi_uc* out = output + n * z->s->img_x * j; 3721 3721 + for (k = 0; k < decode_n; ++k) { 3722 3722 + stbi__resample* r = &res_comp[k]; 3723 3723 + int y_bot = r->ystep >= (r->vs >> 1); 3724 3724 + coutput[k] = r->resample(z->img_comp[k].linebuf, 3725 3725 + y_bot ? r->line1 : r->line0, 3726 3726 + y_bot ? r->line0 : r->line1, 3727 3727 + r->w_lores, r->hs); 3728 3728 + if (++r->ystep >= r->vs) { 3729 3729 + r->ystep = 0; 3730 3730 + r->line0 = r->line1; 3731 3731 + if (++r->ypos < z->img_comp[k].y) 3732 3732 + r->line1 += z->img_comp[k].w2; 3733 3733 + } 3383 3734 } 3384 3384 - } 3385 3385 - if (n >= 3) { 3386 3386 - stbi_uc *y = coutput[0]; 3387 3387 - if (z->s->img_n == 3) { 3388 3388 - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); 3389 3389 - } else 3390 3390 - for (i=0; i < z->s->img_x; ++i) { 3391 3391 - out[0] = out[1] = out[2] = y[i]; 3392 3392 - out[3] = 255; // not used if n==3 3393 3393 - out += n; 3394 3394 - } 3395 3395 - } else { 3396 3396 - stbi_uc *y = coutput[0]; 3397 3397 - if (n == 1) 3398 3398 - for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; 3399 3399 - else 3400 3400 - for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255; 3401 3401 - } 3402 3402 - } 3403 3403 - stbi__cleanup_jpeg(z); 3404 3404 - *out_x = z->s->img_x; 3405 3405 - *out_y = z->s->img_y; 3406 3406 - if (comp) *comp = z->s->img_n; // report original components, not output 3407 3407 - return output; 3408 3408 - } 3735 3735 + if (n >= 3) { 3736 3736 + stbi_uc* y = coutput[0]; 3737 3737 + if (z->s->img_n == 3) { 3738 3738 + if (is_rgb) { 3739 3739 + for (i = 0; i < z->s->img_x; ++i) { 3740 3740 + out[0] = y[i]; 3741 3741 + out[1] = coutput[1][i]; 3742 3742 + out[2] = coutput[2][i]; 3743 3743 + out[3] = 255; 3744 3744 + out += n; 3745 3745 + } 3746 3746 + } 3747 3747 + else { 3748 3748 + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); 3749 3749 + } 3750 3750 + } 3751 3751 + else if (z->s->img_n == 4) { 3752 3752 + if (z->app14_color_transform == 0) { // CMYK 3753 3753 + for (i = 0; i < z->s->img_x; ++i) { 3754 3754 + stbi_uc m = coutput[3][i]; 3755 3755 + out[0] = stbi__blinn_8x8(coutput[0][i], m); 3756 3756 + out[1] = stbi__blinn_8x8(coutput[1][i], m); 3757 3757 + out[2] = stbi__blinn_8x8(coutput[2][i], m); 3758 3758 + out[3] = 255; 3759 3759 + out += n; 3760 3760 + } 3761 3761 + } 3762 3762 + else if (z->app14_color_transform == 2) { // YCCK 3763 3763 + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); 3764 3764 + for (i = 0; i < z->s->img_x; ++i) { 3765 3765 + stbi_uc m = coutput[3][i]; 3766 3766 + out[0] = stbi__blinn_8x8(255 - out[0], m); 3767 3767 + out[1] = stbi__blinn_8x8(255 - out[1], m); 3768 3768 + out[2] = stbi__blinn_8x8(255 - out[2], m); 3769 3769 + out += n; 3770 3770 + } 3771 3771 + } 3772 3772 + else { // YCbCr + alpha? Ignore the fourth channel for now 3773 3773 + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); 3774 3774 + } 3775 3775 + } 3776 3776 + else 3777 3777 + for (i = 0; i < z->s->img_x; ++i) { 3778 3778 + out[0] = out[1] = out[2] = y[i]; 3779 3779 + out[3] = 255; // not used if n==3 3780 3780 + out += n; 3781 3781 + } 3782 3782 + } 3783 3783 + else { 3784 3784 + if (is_rgb) { 3785 3785 + if (n == 1) 3786 3786 + for (i = 0; i < z->s->img_x; ++i) 3787 3787 + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); 3788 3788 + else { 3789 3789 + for (i = 0; i < z->s->img_x; ++i, out += 2) { 3790 3790 + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); 3791 3791 + out[1] = 255; 3792 3792 + } 3793 3793 + } 3794 3794 + } 3795 3795 + else if (z->s->img_n == 4 && z->app14_color_transform == 0) { 3796 3796 + for (i = 0; i < z->s->img_x; ++i) { 3797 3797 + stbi_uc m = coutput[3][i]; 3798 3798 + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); 3799 3799 + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); 3800 3800 + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); 3801 3801 + out[0] = stbi__compute_y(r, g, b); 3802 3802 + out[1] = 255; 3803 3803 + out += n; 3804 3804 + } 3805 3805 + } 3806 3806 + else if (z->s->img_n == 4 && z->app14_color_transform == 2) { 3807 3807 + for (i = 0; i < z->s->img_x; ++i) { 3808 3808 + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); 3809 3809 + out[1] = 255; 3810 3810 + out += n; 3811 3811 + } 3812 3812 + } 3813 3813 + else { 3814 3814 + stbi_uc* y = coutput[0]; 3815 3815 + if (n == 1) 3816 3816 + for (i = 0; i < z->s->img_x; ++i) out[i] = y[i]; 3817 3817 + else 3818 3818 + for (i = 0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } 3819 3819 + } 3820 3820 + } 3821 3821 + } 3822 3822 + stbi__cleanup_jpeg(z); 3823 3823 + *out_x = z->s->img_x; 3824 3824 + *out_y = z->s->img_y; 3825 3825 + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output 3826 3826 + return output; 3827 3827 + } 3409 3828 } 3410 3829 3411 3411 - static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 3830 3830 + static void* stbi__jpeg_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 3412 3831 { 3413 3413 - stbi__jpeg j; 3414 3414 - j.s = s; 3415 3415 - stbi__setup_jpeg(&j); 3416 3416 - return load_jpeg_image(&j, x,y,comp,req_comp); 3832 3832 + unsigned char* result; 3833 3833 + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); 3834 3834 + STBI_NOTUSED(ri); 3835 3835 + j->s = s; 3836 3836 + stbi__setup_jpeg(j); 3837 3837 + result = load_jpeg_image(j, x, y, comp, req_comp); 3838 3838 + STBI_FREE(j); 3839 3839 + return result; 3417 3840 } 3418 3841 3419 3419 - static int stbi__jpeg_test(stbi__context *s) 3842 3842 + static int stbi__jpeg_test(stbi__context* s) 3420 3843 { 3421 3421 - int r; 3422 3422 - stbi__jpeg j; 3423 3423 - j.s = s; 3424 3424 - stbi__setup_jpeg(&j); 3425 3425 - r = stbi__decode_jpeg_header(&j, STBI__SCAN_type); 3426 3426 - stbi__rewind(s); 3427 3427 - return r; 3844 3844 + int r; 3845 3845 + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); 3846 3846 + j->s = s; 3847 3847 + stbi__setup_jpeg(j); 3848 3848 + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); 3849 3849 + stbi__rewind(s); 3850 3850 + STBI_FREE(j); 3851 3851 + return r; 3428 3852 } 3429 3853 3430 3430 - static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) 3854 3854 + static int stbi__jpeg_info_raw(stbi__jpeg* j, int* x, int* y, int* comp) 3431 3855 { 3432 3432 - if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { 3433 3433 - stbi__rewind( j->s ); 3434 3434 - return 0; 3435 3435 - } 3436 3436 - if (x) *x = j->s->img_x; 3437 3437 - if (y) *y = j->s->img_y; 3438 3438 - if (comp) *comp = j->s->img_n; 3439 3439 - return 1; 3856 3856 + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { 3857 3857 + stbi__rewind(j->s); 3858 3858 + return 0; 3859 3859 + } 3860 3860 + if (x) *x = j->s->img_x; 3861 3861 + if (y) *y = j->s->img_y; 3862 3862 + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; 3863 3863 + return 1; 3440 3864 } 3441 3865 3442 3442 - static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) 3866 3866 + static int stbi__jpeg_info(stbi__context* s, int* x, int* y, int* comp) 3443 3867 { 3444 3444 - stbi__jpeg j; 3445 3445 - j.s = s; 3446 3446 - return stbi__jpeg_info_raw(&j, x, y, comp); 3868 3868 + int result; 3869 3869 + stbi__jpeg* j = (stbi__jpeg*)(stbi__malloc(sizeof(stbi__jpeg))); 3870 3870 + j->s = s; 3871 3871 + result = stbi__jpeg_info_raw(j, x, y, comp); 3872 3872 + STBI_FREE(j); 3873 3873 + return result; 3447 3874 } 3448 3875 #endif 3449 3876 ··· 3464 3891 // (jpegs packs from left, zlib from right, so can't share code) 3465 3892 typedef struct 3466 3893 { 3467 3467 - stbi__uint16 fast[1 << STBI__ZFAST_BITS]; 3468 3468 - stbi__uint16 firstcode[16]; 3469 3469 - int maxcode[17]; 3470 3470 - stbi__uint16 firstsymbol[16]; 3471 3471 - stbi_uc size[288]; 3472 3472 - stbi__uint16 value[288]; 3894 3894 + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; 3895 3895 + stbi__uint16 firstcode[16]; 3896 3896 + int maxcode[17]; 3897 3897 + stbi__uint16 firstsymbol[16]; 3898 3898 + stbi_uc size[288]; 3899 3899 + stbi__uint16 value[288]; 3473 3900 } stbi__zhuffman; 3474 3901 3475 3902 stbi_inline static int stbi__bitreverse16(int n) 3476 3903 { 3477 3477 - n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); 3478 3478 - n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); 3479 3479 - n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); 3480 3480 - n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); 3481 3481 - return n; 3904 3904 + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); 3905 3905 + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); 3906 3906 + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); 3907 3907 + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); 3908 3908 + return n; 3482 3909 } 3483 3910 3484 3911 stbi_inline static int stbi__bit_reverse(int v, int bits) 3485 3912 { 3486 3486 - STBI_ASSERT(bits <= 16); 3487 3487 - // to bit reverse n bits, reverse 16 and shift 3488 3488 - // e.g. 11 bits, bit reverse and shift away 5 3489 3489 - return stbi__bitreverse16(v) >> (16-bits); 3913 3913 + STBI_ASSERT(bits <= 16); 3914 3914 + // to bit reverse n bits, reverse 16 and shift 3915 3915 + // e.g. 11 bits, bit reverse and shift away 5 3916 3916 + return stbi__bitreverse16(v) >> (16 - bits); 3490 3917 } 3491 3918 3492 3492 - static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num) 3919 3919 + static int stbi__zbuild_huffman(stbi__zhuffman* z, const stbi_uc* sizelist, int num) 3493 3920 { 3494 3494 - int i,k=0; 3495 3495 - int code, next_code[16], sizes[17]; 3921 3921 + int i, k = 0; 3922 3922 + int code, next_code[16], sizes[17]; 3496 3923 3497 3497 - // DEFLATE spec for generating codes 3498 3498 - memset(sizes, 0, sizeof(sizes)); 3499 3499 - memset(z->fast, 0, sizeof(z->fast)); 3500 3500 - for (i=0; i < num; ++i) 3501 3501 - ++sizes[sizelist[i]]; 3502 3502 - sizes[0] = 0; 3503 3503 - for (i=1; i < 16; ++i) 3504 3504 - if (sizes[i] > (1 << i)) 3505 3505 - return stbi__err("bad sizes", "Corrupt PNG"); 3506 3506 - code = 0; 3507 3507 - for (i=1; i < 16; ++i) { 3508 3508 - next_code[i] = code; 3509 3509 - z->firstcode[i] = (stbi__uint16) code; 3510 3510 - z->firstsymbol[i] = (stbi__uint16) k; 3511 3511 - code = (code + sizes[i]); 3512 3512 - if (sizes[i]) 3513 3513 - if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); 3514 3514 - z->maxcode[i] = code << (16-i); // preshift for inner loop 3515 3515 - code <<= 1; 3516 3516 - k += sizes[i]; 3517 3517 - } 3518 3518 - z->maxcode[16] = 0x10000; // sentinel 3519 3519 - for (i=0; i < num; ++i) { 3520 3520 - int s = sizelist[i]; 3521 3521 - if (s) { 3522 3522 - int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; 3523 3523 - stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); 3524 3524 - z->size [c] = (stbi_uc ) s; 3525 3525 - z->value[c] = (stbi__uint16) i; 3526 3526 - if (s <= STBI__ZFAST_BITS) { 3527 3527 - int j = stbi__bit_reverse(next_code[s],s); 3528 3528 - while (j < (1 << STBI__ZFAST_BITS)) { 3529 3529 - z->fast[j] = fastv; 3530 3530 - j += (1 << s); 3924 3924 + // DEFLATE spec for generating codes 3925 3925 + memset(sizes, 0, sizeof(sizes)); 3926 3926 + memset(z->fast, 0, sizeof(z->fast)); 3927 3927 + for (i = 0; i < num; ++i) 3928 3928 + ++sizes[sizelist[i]]; 3929 3929 + sizes[0] = 0; 3930 3930 + for (i = 1; i < 16; ++i) 3931 3931 + if (sizes[i] > (1 << i)) 3932 3932 + return stbi__err("bad sizes", "Corrupt PNG"); 3933 3933 + code = 0; 3934 3934 + for (i = 1; i < 16; ++i) { 3935 3935 + next_code[i] = code; 3936 3936 + z->firstcode[i] = (stbi__uint16)code; 3937 3937 + z->firstsymbol[i] = (stbi__uint16)k; 3938 3938 + code = (code + sizes[i]); 3939 3939 + if (sizes[i]) 3940 3940 + if (code - 1 >= (1 << i)) return stbi__err("bad codelengths", "Corrupt PNG"); 3941 3941 + z->maxcode[i] = code << (16 - i); // preshift for inner loop 3942 3942 + code <<= 1; 3943 3943 + k += sizes[i]; 3944 3944 + } 3945 3945 + z->maxcode[16] = 0x10000; // sentinel 3946 3946 + for (i = 0; i < num; ++i) { 3947 3947 + int s = sizelist[i]; 3948 3948 + if (s) { 3949 3949 + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; 3950 3950 + stbi__uint16 fastv = (stbi__uint16)((s << 9) | i); 3951 3951 + z->size[c] = (stbi_uc)s; 3952 3952 + z->value[c] = (stbi__uint16)i; 3953 3953 + if (s <= STBI__ZFAST_BITS) { 3954 3954 + int j = stbi__bit_reverse(next_code[s], s); 3955 3955 + while (j < (1 << STBI__ZFAST_BITS)) { 3956 3956 + z->fast[j] = fastv; 3957 3957 + j += (1 << s); 3958 3958 + } 3531 3959 } 3532 3532 - } 3533 3533 - ++next_code[s]; 3534 3534 - } 3535 3535 - } 3536 3536 - return 1; 3960 3960 + ++next_code[s]; 3961 3961 + } 3962 3962 + } 3963 3963 + return 1; 3537 3964 } 3538 3965 3539 3966 // zlib-from-memory implementation for PNG reading ··· 3544 3971 3545 3972 typedef struct 3546 3973 { 3547 3547 - stbi_uc *zbuffer, *zbuffer_end; 3548 3548 - int num_bits; 3549 3549 - stbi__uint32 code_buffer; 3974 3974 + stbi_uc* zbuffer, * zbuffer_end; 3975 3975 + int num_bits; 3976 3976 + stbi__uint32 code_buffer; 3550 3977 3551 3551 - char *zout; 3552 3552 - char *zout_start; 3553 3553 - char *zout_end; 3554 3554 - int z_expandable; 3978 3978 + char* zout; 3979 3979 + char* zout_start; 3980 3980 + char* zout_end; 3981 3981 + int z_expandable; 3555 3982 3556 3556 - stbi__zhuffman z_length, z_distance; 3983 3983 + stbi__zhuffman z_length, z_distance; 3557 3984 } stbi__zbuf; 3558 3985 3559 3559 - stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) 3986 3986 + stbi_inline static stbi_uc stbi__zget8(stbi__zbuf* z) 3560 3987 { 3561 3561 - if (z->zbuffer >= z->zbuffer_end) return 0; 3562 3562 - return *z->zbuffer++; 3988 3988 + if (z->zbuffer >= z->zbuffer_end) return 0; 3989 3989 + return *z->zbuffer++; 3563 3990 } 3564 3991 3565 3565 - static void stbi__fill_bits(stbi__zbuf *z) 3992 3992 + static void stbi__fill_bits(stbi__zbuf* z) 3566 3993 { 3567 3567 - do { 3568 3568 - STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); 3569 3569 - z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; 3570 3570 - z->num_bits += 8; 3571 3571 - } while (z->num_bits <= 24); 3994 3994 + do { 3995 3995 + STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); 3996 3996 + z->code_buffer |= (unsigned int)stbi__zget8(z) << z->num_bits; 3997 3997 + z->num_bits += 8; 3998 3998 + } while (z->num_bits <= 24); 3572 3999 } 3573 4000 3574 3574 - stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) 4001 4001 + stbi_inline static unsigned int stbi__zreceive(stbi__zbuf* z, int n) 3575 4002 { 3576 3576 - unsigned int k; 3577 3577 - if (z->num_bits < n) stbi__fill_bits(z); 3578 3578 - k = z->code_buffer & ((1 << n) - 1); 3579 3579 - z->code_buffer >>= n; 3580 3580 - z->num_bits -= n; 3581 3581 - return k; 4003 4003 + unsigned int k; 4004 4004 + if (z->num_bits < n) stbi__fill_bits(z); 4005 4005 + k = z->code_buffer & ((1 << n) - 1); 4006 4006 + z->code_buffer >>= n; 4007 4007 + z->num_bits -= n; 4008 4008 + return k; 3582 4009 } 3583 4010 3584 3584 - static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) 4011 4011 + static int stbi__zhuffman_decode_slowpath(stbi__zbuf* a, stbi__zhuffman* z) 3585 4012 { 3586 3586 - int b,s,k; 3587 3587 - // not resolved by fast table, so compute it the slow way 3588 3588 - // use jpeg approach, which requires MSbits at top 3589 3589 - k = stbi__bit_reverse(a->code_buffer, 16); 3590 3590 - for (s=STBI__ZFAST_BITS+1; ; ++s) 3591 3591 - if (k < z->maxcode[s]) 3592 3592 - break; 3593 3593 - if (s == 16) return -1; // invalid code! 3594 3594 - // code size is s, so: 3595 3595 - b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; 3596 3596 - STBI_ASSERT(z->size[b] == s); 3597 3597 - a->code_buffer >>= s; 3598 3598 - a->num_bits -= s; 3599 3599 - return z->value[b]; 4013 4013 + int b, s, k; 4014 4014 + // not resolved by fast table, so compute it the slow way 4015 4015 + // use jpeg approach, which requires MSbits at top 4016 4016 + k = stbi__bit_reverse(a->code_buffer, 16); 4017 4017 + for (s = STBI__ZFAST_BITS + 1; ; ++s) 4018 4018 + if (k < z->maxcode[s]) 4019 4019 + break; 4020 4020 + if (s == 16) return -1; // invalid code! 4021 4021 + // code size is s, so: 4022 4022 + b = (k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s]; 4023 4023 + STBI_ASSERT(z->size[b] == s); 4024 4024 + a->code_buffer >>= s; 4025 4025 + a->num_bits -= s; 4026 4026 + return z->value[b]; 3600 4027 } 3601 4028 3602 3602 - stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) 4029 4029 + stbi_inline static int stbi__zhuffman_decode(stbi__zbuf* a, stbi__zhuffman* z) 3603 4030 { 3604 3604 - int b,s; 3605 3605 - if (a->num_bits < 16) stbi__fill_bits(a); 3606 3606 - b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; 3607 3607 - if (b) { 3608 3608 - s = b >> 9; 3609 3609 - a->code_buffer >>= s; 3610 3610 - a->num_bits -= s; 3611 3611 - return b & 511; 3612 3612 - } 3613 3613 - return stbi__zhuffman_decode_slowpath(a, z); 4031 4031 + int b, s; 4032 4032 + if (a->num_bits < 16) stbi__fill_bits(a); 4033 4033 + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; 4034 4034 + if (b) { 4035 4035 + s = b >> 9; 4036 4036 + a->code_buffer >>= s; 4037 4037 + a->num_bits -= s; 4038 4038 + return b & 511; 4039 4039 + } 4040 4040 + return stbi__zhuffman_decode_slowpath(a, z); 3614 4041 } 3615 4042 3616 3616 - static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes 4043 4043 + static int stbi__zexpand(stbi__zbuf* z, char* zout, int n) // need to make room for n bytes 3617 4044 { 3618 3618 - char *q; 3619 3619 - int cur, limit; 3620 3620 - z->zout = zout; 3621 3621 - if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); 3622 3622 - cur = (int) (z->zout - z->zout_start); 3623 3623 - limit = (int) (z->zout_end - z->zout_start); 3624 3624 - while (cur + n > limit) 3625 3625 - limit *= 2; 3626 3626 - q = (char *) STBI_REALLOC(z->zout_start, limit); 3627 3627 - if (q == NULL) return stbi__err("outofmem", "Out of memory"); 3628 3628 - z->zout_start = q; 3629 3629 - z->zout = q + cur; 3630 3630 - z->zout_end = q + limit; 3631 3631 - return 1; 4045 4045 + char* q; 4046 4046 + int cur, limit, old_limit; 4047 4047 + z->zout = zout; 4048 4048 + if (!z->z_expandable) return stbi__err("output buffer limit", "Corrupt PNG"); 4049 4049 + cur = (int)(z->zout - z->zout_start); 4050 4050 + limit = old_limit = (int)(z->zout_end - z->zout_start); 4051 4051 + while (cur + n > limit) 4052 4052 + limit *= 2; 4053 4053 + q = (char*)STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); 4054 4054 + STBI_NOTUSED(old_limit); 4055 4055 + if (q == NULL) return stbi__err("outofmem", "Out of memory"); 4056 4056 + z->zout_start = q; 4057 4057 + z->zout = q + cur; 4058 4058 + z->zout_end = q + limit; 4059 4059 + return 1; 3632 4060 } 3633 4061 3634 3634 - static int stbi__zlength_base[31] = { 4062 4062 + static const int stbi__zlength_base[31] = { 3635 4063 3,4,5,6,7,8,9,10,11,13, 3636 4064 15,17,19,23,27,31,35,43,51,59, 3637 4065 67,83,99,115,131,163,195,227,258,0,0 }; 3638 4066 3639 3639 - static int stbi__zlength_extra[31]= 4067 4067 + static const int stbi__zlength_extra[31] = 3640 4068 { 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 }; 3641 4069 3642 3642 - static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 3643 3643 - 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; 4070 4070 + static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 4071 4071 + 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0 }; 3644 4072 3645 3645 - static int stbi__zdist_extra[32] = 3646 3646 - { 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}; 4073 4073 + static const int stbi__zdist_extra[32] = 4074 4074 + { 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 }; 3647 4075 3648 3648 - static int stbi__parse_huffman_block(stbi__zbuf *a) 4076 4076 + static int stbi__parse_huffman_block(stbi__zbuf* a) 3649 4077 { 3650 3650 - char *zout = a->zout; 3651 3651 - for(;;) { 3652 3652 - int z = stbi__zhuffman_decode(a, &a->z_length); 3653 3653 - if (z < 256) { 3654 3654 - if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes 3655 3655 - if (zout >= a->zout_end) { 3656 3656 - if (!stbi__zexpand(a, zout, 1)) return 0; 3657 3657 - zout = a->zout; 3658 3658 - } 3659 3659 - *zout++ = (char) z; 3660 3660 - } else { 3661 3661 - stbi_uc *p; 3662 3662 - int len,dist; 3663 3663 - if (z == 256) { 3664 3664 - a->zout = zout; 3665 3665 - return 1; 3666 3666 - } 3667 3667 - z -= 257; 3668 3668 - len = stbi__zlength_base[z]; 3669 3669 - if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); 3670 3670 - z = stbi__zhuffman_decode(a, &a->z_distance); 3671 3671 - if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); 3672 3672 - dist = stbi__zdist_base[z]; 3673 3673 - if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); 3674 3674 - if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); 3675 3675 - if (zout + len > a->zout_end) { 3676 3676 - if (!stbi__zexpand(a, zout, len)) return 0; 3677 3677 - zout = a->zout; 3678 3678 - } 3679 3679 - p = (stbi_uc *) (zout - dist); 3680 3680 - if (dist == 1) { // run of one byte; common in images. 3681 3681 - stbi_uc v = *p; 3682 3682 - if (len) { do *zout++ = v; while (--len); } 3683 3683 - } else { 3684 3684 - if (len) { do *zout++ = *p++; while (--len); } 3685 3685 - } 3686 3686 - } 3687 3687 - } 4078 4078 + char* zout = a->zout; 4079 4079 + for (;;) { 4080 4080 + int z = stbi__zhuffman_decode(a, &a->z_length); 4081 4081 + if (z < 256) { 4082 4082 + if (z < 0) return stbi__err("bad huffman code", "Corrupt PNG"); // error in huffman codes 4083 4083 + if (zout >= a->zout_end) { 4084 4084 + if (!stbi__zexpand(a, zout, 1)) return 0; 4085 4085 + zout = a->zout; 4086 4086 + } 4087 4087 + *zout++ = (char)z; 4088 4088 + } 4089 4089 + else { 4090 4090 + stbi_uc* p; 4091 4091 + int len, dist; 4092 4092 + if (z == 256) { 4093 4093 + a->zout = zout; 4094 4094 + return 1; 4095 4095 + } 4096 4096 + z -= 257; 4097 4097 + len = stbi__zlength_base[z]; 4098 4098 + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); 4099 4099 + z = stbi__zhuffman_decode(a, &a->z_distance); 4100 4100 + if (z < 0) return stbi__err("bad huffman code", "Corrupt PNG"); 4101 4101 + dist = stbi__zdist_base[z]; 4102 4102 + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); 4103 4103 + if (zout - a->zout_start < dist) return stbi__err("bad dist", "Corrupt PNG"); 4104 4104 + if (zout + len > a->zout_end) { 4105 4105 + if (!stbi__zexpand(a, zout, len)) return 0; 4106 4106 + zout = a->zout; 4107 4107 + } 4108 4108 + p = (stbi_uc*)(zout - dist); 4109 4109 + if (dist == 1) { // run of one byte; common in images. 4110 4110 + stbi_uc v = *p; 4111 4111 + if (len) { do *zout++ = v; while (--len); } 4112 4112 + } 4113 4113 + else { 4114 4114 + if (len) { do *zout++ = *p++; while (--len); } 4115 4115 + } 4116 4116 + } 4117 4117 + } 3688 4118 } 3689 4119 3690 3690 - static int stbi__compute_huffman_codes(stbi__zbuf *a) 4120 4120 + static int stbi__compute_huffman_codes(stbi__zbuf* a) 3691 4121 { 3692 3692 - static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; 3693 3693 - stbi__zhuffman z_codelength; 3694 3694 - stbi_uc lencodes[286+32+137];//padding for maximum single op 3695 3695 - stbi_uc codelength_sizes[19]; 3696 3696 - int i,n; 4122 4122 + 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 }; 4123 4123 + stbi__zhuffman z_codelength; 4124 4124 + stbi_uc lencodes[286 + 32 + 137];//padding for maximum single op 4125 4125 + stbi_uc codelength_sizes[19]; 4126 4126 + int i, n; 3697 4127 3698 3698 - int hlit = stbi__zreceive(a,5) + 257; 3699 3699 - int hdist = stbi__zreceive(a,5) + 1; 3700 3700 - int hclen = stbi__zreceive(a,4) + 4; 4128 4128 + int hlit = stbi__zreceive(a, 5) + 257; 4129 4129 + int hdist = stbi__zreceive(a, 5) + 1; 4130 4130 + int hclen = stbi__zreceive(a, 4) + 4; 4131 4131 + int ntot = hlit + hdist; 3701 4132 3702 3702 - memset(codelength_sizes, 0, sizeof(codelength_sizes)); 3703 3703 - for (i=0; i < hclen; ++i) { 3704 3704 - int s = stbi__zreceive(a,3); 3705 3705 - codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; 3706 3706 - } 3707 3707 - if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; 4133 4133 + memset(codelength_sizes, 0, sizeof(codelength_sizes)); 4134 4134 + for (i = 0; i < hclen; ++i) { 4135 4135 + int s = stbi__zreceive(a, 3); 4136 4136 + codelength_sizes[length_dezigzag[i]] = (stbi_uc)s; 4137 4137 + } 4138 4138 + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; 3708 4139 3709 3709 - n = 0; 3710 3710 - while (n < hlit + hdist) { 3711 3711 - int c = stbi__zhuffman_decode(a, &z_codelength); 3712 3712 - if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); 3713 3713 - if (c < 16) 3714 3714 - lencodes[n++] = (stbi_uc) c; 3715 3715 - else if (c == 16) { 3716 3716 - c = stbi__zreceive(a,2)+3; 3717 3717 - memset(lencodes+n, lencodes[n-1], c); 3718 3718 - n += c; 3719 3719 - } else if (c == 17) { 3720 3720 - c = stbi__zreceive(a,3)+3; 3721 3721 - memset(lencodes+n, 0, c); 3722 3722 - n += c; 3723 3723 - } else { 3724 3724 - STBI_ASSERT(c == 18); 3725 3725 - c = stbi__zreceive(a,7)+11; 3726 3726 - memset(lencodes+n, 0, c); 3727 3727 - n += c; 3728 3728 - } 3729 3729 - } 3730 3730 - if (n != hlit+hdist) return stbi__err("bad codelengths","Corrupt PNG"); 3731 3731 - if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; 3732 3732 - if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; 3733 3733 - return 1; 4140 4140 + n = 0; 4141 4141 + while (n < ntot) { 4142 4142 + int c = stbi__zhuffman_decode(a, &z_codelength); 4143 4143 + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); 4144 4144 + if (c < 16) 4145 4145 + lencodes[n++] = (stbi_uc)c; 4146 4146 + else { 4147 4147 + stbi_uc fill = 0; 4148 4148 + if (c == 16) { 4149 4149 + c = stbi__zreceive(a, 2) + 3; 4150 4150 + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); 4151 4151 + fill = lencodes[n - 1]; 4152 4152 + } 4153 4153 + else if (c == 17) 4154 4154 + c = stbi__zreceive(a, 3) + 3; 4155 4155 + else { 4156 4156 + STBI_ASSERT(c == 18); 4157 4157 + c = stbi__zreceive(a, 7) + 11; 4158 4158 + } 4159 4159 + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); 4160 4160 + memset(lencodes + n, fill, c); 4161 4161 + n += c; 4162 4162 + } 4163 4163 + } 4164 4164 + if (n != ntot) return stbi__err("bad codelengths", "Corrupt PNG"); 4165 4165 + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; 4166 4166 + if (!stbi__zbuild_huffman(&a->z_distance, lencodes + hlit, hdist)) return 0; 4167 4167 + return 1; 3734 4168 } 3735 4169 3736 3736 - static int stbi__parse_uncomperssed_block(stbi__zbuf *a) 4170 4170 + static int stbi__parse_uncompressed_block(stbi__zbuf* a) 3737 4171 { 3738 3738 - stbi_uc header[4]; 3739 3739 - int len,nlen,k; 3740 3740 - if (a->num_bits & 7) 3741 3741 - stbi__zreceive(a, a->num_bits & 7); // discard 3742 3742 - // drain the bit-packed data into header 3743 3743 - k = 0; 3744 3744 - while (a->num_bits > 0) { 3745 3745 - header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check 3746 3746 - a->code_buffer >>= 8; 3747 3747 - a->num_bits -= 8; 3748 3748 - } 3749 3749 - STBI_ASSERT(a->num_bits == 0); 3750 3750 - // now fill header the normal way 3751 3751 - while (k < 4) 3752 3752 - header[k++] = stbi__zget8(a); 3753 3753 - len = header[1] * 256 + header[0]; 3754 3754 - nlen = header[3] * 256 + header[2]; 3755 3755 - if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); 3756 3756 - if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); 3757 3757 - if (a->zout + len > a->zout_end) 3758 3758 - if (!stbi__zexpand(a, a->zout, len)) return 0; 3759 3759 - memcpy(a->zout, a->zbuffer, len); 3760 3760 - a->zbuffer += len; 3761 3761 - a->zout += len; 3762 3762 - return 1; 4172 4172 + stbi_uc header[4]; 4173 4173 + int len, nlen, k; 4174 4174 + if (a->num_bits & 7) 4175 4175 + stbi__zreceive(a, a->num_bits & 7); // discard 4176 4176 + // drain the bit-packed data into header 4177 4177 + k = 0; 4178 4178 + while (a->num_bits > 0) { 4179 4179 + header[k++] = (stbi_uc)(a->code_buffer & 255); // suppress MSVC run-time check 4180 4180 + a->code_buffer >>= 8; 4181 4181 + a->num_bits -= 8; 4182 4182 + } 4183 4183 + STBI_ASSERT(a->num_bits == 0); 4184 4184 + // now fill header the normal way 4185 4185 + while (k < 4) 4186 4186 + header[k++] = stbi__zget8(a); 4187 4187 + len = header[1] * 256 + header[0]; 4188 4188 + nlen = header[3] * 256 + header[2]; 4189 4189 + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt", "Corrupt PNG"); 4190 4190 + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer", "Corrupt PNG"); 4191 4191 + if (a->zout + len > a->zout_end) 4192 4192 + if (!stbi__zexpand(a, a->zout, len)) return 0; 4193 4193 + memcpy(a->zout, a->zbuffer, len); 4194 4194 + a->zbuffer += len; 4195 4195 + a->zout += len; 4196 4196 + return 1; 3763 4197 } 3764 4198 3765 3765 - static int stbi__parse_zlib_header(stbi__zbuf *a) 4199 4199 + static int stbi__parse_zlib_header(stbi__zbuf* a) 3766 4200 { 3767 3767 - int cmf = stbi__zget8(a); 3768 3768 - int cm = cmf & 15; 3769 3769 - /* int cinfo = cmf >> 4; */ 3770 3770 - int flg = stbi__zget8(a); 3771 3771 - if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec 3772 3772 - if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png 3773 3773 - if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png 3774 3774 - // window = 1 << (8 + cinfo)... but who cares, we fully buffer output 3775 3775 - return 1; 4201 4201 + int cmf = stbi__zget8(a); 4202 4202 + int cm = cmf & 15; 4203 4203 + /* int cinfo = cmf >> 4; */ 4204 4204 + int flg = stbi__zget8(a); 4205 4205 + if ((cmf * 256 + flg) % 31 != 0) return stbi__err("bad zlib header", "Corrupt PNG"); // zlib spec 4206 4206 + if (flg & 32) return stbi__err("no preset dict", "Corrupt PNG"); // preset dictionary not allowed in png 4207 4207 + if (cm != 8) return stbi__err("bad compression", "Corrupt PNG"); // DEFLATE required for png 4208 4208 + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output 4209 4209 + return 1; 3776 4210 } 3777 4211 3778 3778 - // @TODO: should statically initialize these for optimal thread safety 3779 3779 - static stbi_uc stbi__zdefault_length[288], stbi__zdefault_distance[32]; 3780 3780 - static void stbi__init_zdefaults(void) 4212 4212 + static const stbi_uc stbi__zdefault_length[288] = 4213 4213 + { 4214 4214 + 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, 4215 4215 + 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, 4216 4216 + 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, 4217 4217 + 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, 4218 4218 + 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, 4219 4219 + 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, 4220 4220 + 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, 4221 4221 + 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, 4222 4222 + 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 4223 4223 + }; 4224 4224 + static const stbi_uc stbi__zdefault_distance[32] = 4225 4225 + { 4226 4226 + 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 4227 4227 + }; 4228 4228 + /* 4229 4229 + Init algorithm: 3781 4230 { 3782 4231 int i; // use <= to match clearly with spec 3783 4232 for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; ··· 3787 4236 3788 4237 for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; 3789 4238 } 4239 4239 + */ 3790 4240 3791 3791 - static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) 4241 4241 + static int stbi__parse_zlib(stbi__zbuf* a, int parse_header) 3792 4242 { 3793 3793 - int final, type; 3794 3794 - if (parse_header) 3795 3795 - if (!stbi__parse_zlib_header(a)) return 0; 3796 3796 - a->num_bits = 0; 3797 3797 - a->code_buffer = 0; 3798 3798 - do { 3799 3799 - final = stbi__zreceive(a,1); 3800 3800 - type = stbi__zreceive(a,2); 3801 3801 - if (type == 0) { 3802 3802 - if (!stbi__parse_uncomperssed_block(a)) return 0; 3803 3803 - } else if (type == 3) { 3804 3804 - return 0; 3805 3805 - } else { 3806 3806 - if (type == 1) { 3807 3807 - // use fixed code lengths 3808 3808 - if (!stbi__zdefault_distance[31]) stbi__init_zdefaults(); 3809 3809 - if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0; 3810 3810 - if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; 3811 3811 - } else { 3812 3812 - if (!stbi__compute_huffman_codes(a)) return 0; 3813 3813 - } 3814 3814 - if (!stbi__parse_huffman_block(a)) return 0; 3815 3815 - } 3816 3816 - } while (!final); 3817 3817 - return 1; 4243 4243 + int final, type; 4244 4244 + if (parse_header) 4245 4245 + if (!stbi__parse_zlib_header(a)) return 0; 4246 4246 + a->num_bits = 0; 4247 4247 + a->code_buffer = 0; 4248 4248 + do { 4249 4249 + final = stbi__zreceive(a, 1); 4250 4250 + type = stbi__zreceive(a, 2); 4251 4251 + if (type == 0) { 4252 4252 + if (!stbi__parse_uncompressed_block(a)) return 0; 4253 4253 + } 4254 4254 + else if (type == 3) { 4255 4255 + return 0; 4256 4256 + } 4257 4257 + else { 4258 4258 + if (type == 1) { 4259 4259 + // use fixed code lengths 4260 4260 + if (!stbi__zbuild_huffman(&a->z_length, stbi__zdefault_length, 288)) return 0; 4261 4261 + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; 4262 4262 + } 4263 4263 + else { 4264 4264 + if (!stbi__compute_huffman_codes(a)) return 0; 4265 4265 + } 4266 4266 + if (!stbi__parse_huffman_block(a)) return 0; 4267 4267 + } 4268 4268 + } while (!final); 4269 4269 + return 1; 3818 4270 } 3819 4271 3820 3820 - static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) 4272 4272 + static int stbi__do_zlib(stbi__zbuf* a, char* obuf, int olen, int exp, int parse_header) 3821 4273 { 3822 3822 - a->zout_start = obuf; 3823 3823 - a->zout = obuf; 3824 3824 - a->zout_end = obuf + olen; 3825 3825 - a->z_expandable = exp; 4274 4274 + a->zout_start = obuf; 4275 4275 + a->zout = obuf; 4276 4276 + a->zout_end = obuf + olen; 4277 4277 + a->z_expandable = exp; 3826 4278 3827 3827 - return stbi__parse_zlib(a, parse_header); 4279 4279 + return stbi__parse_zlib(a, parse_header); 3828 4280 } 3829 4281 3830 3830 - STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) 4282 4282 + STBIDEF char* stbi_zlib_decode_malloc_guesssize(const char* buffer, int len, int initial_size, int* outlen) 3831 4283 { 3832 3832 - stbi__zbuf a; 3833 3833 - char *p = (char *) stbi__malloc(initial_size); 3834 3834 - if (p == NULL) return NULL; 3835 3835 - a.zbuffer = (stbi_uc *) buffer; 3836 3836 - a.zbuffer_end = (stbi_uc *) buffer + len; 3837 3837 - if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { 3838 3838 - if (outlen) *outlen = (int) (a.zout - a.zout_start); 3839 3839 - return a.zout_start; 3840 3840 - } else { 3841 3841 - STBI_FREE(a.zout_start); 3842 3842 - return NULL; 3843 3843 - } 4284 4284 + stbi__zbuf a; 4285 4285 + char* p = (char*)stbi__malloc(initial_size); 4286 4286 + if (p == NULL) return NULL; 4287 4287 + a.zbuffer = (stbi_uc*)buffer; 4288 4288 + a.zbuffer_end = (stbi_uc*)buffer + len; 4289 4289 + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { 4290 4290 + if (outlen) *outlen = (int)(a.zout - a.zout_start); 4291 4291 + return a.zout_start; 4292 4292 + } 4293 4293 + else { 4294 4294 + STBI_FREE(a.zout_start); 4295 4295 + return NULL; 4296 4296 + } 3844 4297 } 3845 4298 3846 3846 - STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) 4299 4299 + STBIDEF char* stbi_zlib_decode_malloc(char const* buffer, int len, int* outlen) 3847 4300 { 3848 3848 - return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); 4301 4301 + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); 3849 4302 } 3850 4303 3851 3851 - STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) 4304 4304 + STBIDEF char* stbi_zlib_decode_malloc_guesssize_headerflag(const char* buffer, int len, int initial_size, int* outlen, int parse_header) 3852 4305 { 3853 3853 - stbi__zbuf a; 3854 3854 - char *p = (char *) stbi__malloc(initial_size); 3855 3855 - if (p == NULL) return NULL; 3856 3856 - a.zbuffer = (stbi_uc *) buffer; 3857 3857 - a.zbuffer_end = (stbi_uc *) buffer + len; 3858 3858 - if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { 3859 3859 - if (outlen) *outlen = (int) (a.zout - a.zout_start); 3860 3860 - return a.zout_start; 3861 3861 - } else { 3862 3862 - STBI_FREE(a.zout_start); 3863 3863 - return NULL; 3864 3864 - } 4306 4306 + stbi__zbuf a; 4307 4307 + char* p = (char*)stbi__malloc(initial_size); 4308 4308 + if (p == NULL) return NULL; 4309 4309 + a.zbuffer = (stbi_uc*)buffer; 4310 4310 + a.zbuffer_end = (stbi_uc*)buffer + len; 4311 4311 + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { 4312 4312 + if (outlen) *outlen = (int)(a.zout - a.zout_start); 4313 4313 + return a.zout_start; 4314 4314 + } 4315 4315 + else { 4316 4316 + STBI_FREE(a.zout_start); 4317 4317 + return NULL; 4318 4318 + } 3865 4319 } 3866 4320 3867 3867 - STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) 4321 4321 + STBIDEF int stbi_zlib_decode_buffer(char* obuffer, int olen, char const* ibuffer, int ilen) 3868 4322 { 3869 3869 - stbi__zbuf a; 3870 3870 - a.zbuffer = (stbi_uc *) ibuffer; 3871 3871 - a.zbuffer_end = (stbi_uc *) ibuffer + ilen; 3872 3872 - if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) 3873 3873 - return (int) (a.zout - a.zout_start); 3874 3874 - else 3875 3875 - return -1; 4323 4323 + stbi__zbuf a; 4324 4324 + a.zbuffer = (stbi_uc*)ibuffer; 4325 4325 + a.zbuffer_end = (stbi_uc*)ibuffer + ilen; 4326 4326 + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) 4327 4327 + return (int)(a.zout - a.zout_start); 4328 4328 + else 4329 4329 + return -1; 3876 4330 } 3877 4331 3878 3878 - STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) 4332 4332 + STBIDEF char* stbi_zlib_decode_noheader_malloc(char const* buffer, int len, int* outlen) 3879 4333 { 3880 3880 - stbi__zbuf a; 3881 3881 - char *p = (char *) stbi__malloc(16384); 3882 3882 - if (p == NULL) return NULL; 3883 3883 - a.zbuffer = (stbi_uc *) buffer; 3884 3884 - a.zbuffer_end = (stbi_uc *) buffer+len; 3885 3885 - if (stbi__do_zlib(&a, p, 16384, 1, 0)) { 3886 3886 - if (outlen) *outlen = (int) (a.zout - a.zout_start); 3887 3887 - return a.zout_start; 3888 3888 - } else { 3889 3889 - STBI_FREE(a.zout_start); 3890 3890 - return NULL; 3891 3891 - } 4334 4334 + stbi__zbuf a; 4335 4335 + char* p = (char*)stbi__malloc(16384); 4336 4336 + if (p == NULL) return NULL; 4337 4337 + a.zbuffer = (stbi_uc*)buffer; 4338 4338 + a.zbuffer_end = (stbi_uc*)buffer + len; 4339 4339 + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { 4340 4340 + if (outlen) *outlen = (int)(a.zout - a.zout_start); 4341 4341 + return a.zout_start; 4342 4342 + } 4343 4343 + else { 4344 4344 + STBI_FREE(a.zout_start); 4345 4345 + return NULL; 4346 4346 + } 3892 4347 } 3893 4348 3894 3894 - STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) 4349 4349 + STBIDEF int stbi_zlib_decode_noheader_buffer(char* obuffer, int olen, const char* ibuffer, int ilen) 3895 4350 { 3896 3896 - stbi__zbuf a; 3897 3897 - a.zbuffer = (stbi_uc *) ibuffer; 3898 3898 - a.zbuffer_end = (stbi_uc *) ibuffer + ilen; 3899 3899 - if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) 3900 3900 - return (int) (a.zout - a.zout_start); 3901 3901 - else 3902 3902 - return -1; 4351 4351 + stbi__zbuf a; 4352 4352 + a.zbuffer = (stbi_uc*)ibuffer; 4353 4353 + a.zbuffer_end = (stbi_uc*)ibuffer + ilen; 4354 4354 + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) 4355 4355 + return (int)(a.zout - a.zout_start); 4356 4356 + else 4357 4357 + return -1; 3903 4358 } 3904 4359 #endif 3905 4360 ··· 3916 4371 #ifndef STBI_NO_PNG 3917 4372 typedef struct 3918 4373 { 3919 3919 - stbi__uint32 length; 3920 3920 - stbi__uint32 type; 4374 4374 + stbi__uint32 length; 4375 4375 + stbi__uint32 type; 3921 4376 } stbi__pngchunk; 3922 4377 3923 3923 - static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) 4378 4378 + static stbi__pngchunk stbi__get_chunk_header(stbi__context* s) 3924 4379 { 3925 3925 - stbi__pngchunk c; 3926 3926 - c.length = stbi__get32be(s); 3927 3927 - c.type = stbi__get32be(s); 3928 3928 - return c; 4380 4380 + stbi__pngchunk c; 4381 4381 + c.length = stbi__get32be(s); 4382 4382 + c.type = stbi__get32be(s); 4383 4383 + return c; 3929 4384 } 3930 4385 3931 3931 - static int stbi__check_png_header(stbi__context *s) 4386 4386 + static int stbi__check_png_header(stbi__context* s) 3932 4387 { 3933 3933 - static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; 3934 3934 - int i; 3935 3935 - for (i=0; i < 8; ++i) 3936 3936 - if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); 3937 3937 - return 1; 4388 4388 + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; 4389 4389 + int i; 4390 4390 + for (i = 0; i < 8; ++i) 4391 4391 + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig", "Not a PNG"); 4392 4392 + return 1; 3938 4393 } 3939 4394 3940 4395 typedef struct 3941 4396 { 3942 3942 - stbi__context *s; 3943 3943 - stbi_uc *idata, *expanded, *out; 4397 4397 + stbi__context* s; 4398 4398 + stbi_uc* idata, * expanded, * out; 4399 4399 + int depth; 3944 4400 } stbi__png; 3945 4401 3946 4402 3947 4403 enum { 3948 3948 - STBI__F_none=0, 3949 3949 - STBI__F_sub=1, 3950 3950 - STBI__F_up=2, 3951 3951 - STBI__F_avg=3, 3952 3952 - STBI__F_paeth=4, 3953 3953 - // synthetic filters used for first scanline to avoid needing a dummy row of 0s 3954 3954 - STBI__F_avg_first, 3955 3955 - STBI__F_paeth_first 4404 4404 + STBI__F_none = 0, 4405 4405 + STBI__F_sub = 1, 4406 4406 + STBI__F_up = 2, 4407 4407 + STBI__F_avg = 3, 4408 4408 + STBI__F_paeth = 4, 4409 4409 + // synthetic filters used for first scanline to avoid needing a dummy row of 0s 4410 4410 + STBI__F_avg_first, 4411 4411 + STBI__F_paeth_first 3956 4412 }; 3957 4413 3958 4414 static stbi_uc first_row_filter[5] = ··· 3966 4422 3967 4423 static int stbi__paeth(int a, int b, int c) 3968 4424 { 3969 3969 - int p = a + b - c; 3970 3970 - int pa = abs(p-a); 3971 3971 - int pb = abs(p-b); 3972 3972 - int pc = abs(p-c); 3973 3973 - if (pa <= pb && pa <= pc) return a; 3974 3974 - if (pb <= pc) return b; 3975 3975 - return c; 4425 4425 + int p = a + b - c; 4426 4426 + int pa = abs(p - a); 4427 4427 + int pb = abs(p - b); 4428 4428 + int pc = abs(p - c); 4429 4429 + if (pa <= pb && pa <= pc) return a; 4430 4430 + if (pb <= pc) return b; 4431 4431 + return c; 3976 4432 } 3977 4433 3978 3978 - static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; 4434 4434 + static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; 3979 4435 3980 4436 // create the png data from post-deflated data 3981 3981 - 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) 4437 4437 + 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) 3982 4438 { 3983 3983 - stbi__context *s = a->s; 3984 3984 - stbi__uint32 i,j,stride = x*out_n; 3985 3985 - stbi__uint32 img_len, img_width_bytes; 3986 3986 - int k; 3987 3987 - int img_n = s->img_n; // copy it into a local for later 4439 4439 + int bytes = (depth == 16 ? 2 : 1); 4440 4440 + stbi__context* s = a->s; 4441 4441 + stbi__uint32 i, j, stride = x * out_n * bytes; 4442 4442 + stbi__uint32 img_len, img_width_bytes; 4443 4443 + int k; 4444 4444 + int img_n = s->img_n; // copy it into a local for later 3988 4445 3989 3989 - STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); 3990 3990 - a->out = (stbi_uc *) stbi__malloc(x * y * out_n); // extra bytes to write off the end into 3991 3991 - if (!a->out) return stbi__err("outofmem", "Out of memory"); 4446 4446 + int output_bytes = out_n * bytes; 4447 4447 + int filter_bytes = img_n * bytes; 4448 4448 + int width = x; 4449 4449 + 4450 4450 + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n + 1); 4451 4451 + a->out = (stbi_uc*)stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into 4452 4452 + if (!a->out) return stbi__err("outofmem", "Out of memory"); 3992 4453 3993 3993 - img_width_bytes = (((img_n * x * depth) + 7) >> 3); 3994 3994 - img_len = (img_width_bytes + 1) * y; 3995 3995 - if (s->img_x == x && s->img_y == y) { 3996 3996 - if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt PNG"); 3997 3997 - } else { // interlaced: 3998 3998 - if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); 3999 3999 - } 4454 4454 + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); 4455 4455 + img_width_bytes = (((img_n * x * depth) + 7) >> 3); 4456 4456 + img_len = (img_width_bytes + 1) * y; 4457 4457 + 4458 4458 + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, 4459 4459 + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), 4460 4460 + // so just check for raw_len < img_len always. 4461 4461 + if (raw_len < img_len) return stbi__err("not enough pixels", "Corrupt PNG"); 4462 4462 + 4463 4463 + for (j = 0; j < y; ++j) { 4464 4464 + stbi_uc* cur = a->out + stride * j; 4465 4465 + stbi_uc* prior; 4466 4466 + int filter = *raw++; 4000 4467 4001 4001 - for (j=0; j < y; ++j) { 4002 4002 - stbi_uc *cur = a->out + stride*j; 4003 4003 - stbi_uc *prior = cur - stride; 4004 4004 - int filter = *raw++; 4005 4005 - int filter_bytes = img_n; 4006 4006 - int width = x; 4007 4007 - if (filter > 4) 4008 4008 - return stbi__err("invalid filter","Corrupt PNG"); 4468 4468 + if (filter > 4) 4469 4469 + return stbi__err("invalid filter", "Corrupt PNG"); 4009 4470 4010 4010 - if (depth < 8) { 4011 4011 - STBI_ASSERT(img_width_bytes <= x); 4012 4012 - cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place 4013 4013 - filter_bytes = 1; 4014 4014 - width = img_width_bytes; 4015 4015 - } 4471 4471 + if (depth < 8) { 4472 4472 + STBI_ASSERT(img_width_bytes <= x); 4473 4473 + cur += x * out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place 4474 4474 + filter_bytes = 1; 4475 4475 + width = img_width_bytes; 4476 4476 + } 4477 4477 + prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above 4016 4478 4017 4017 - // if first row, use special filter that doesn't sample previous row 4018 4018 - if (j == 0) filter = first_row_filter[filter]; 4479 4479 + // if first row, use special filter that doesn't sample previous row 4480 4480 + if (j == 0) filter = first_row_filter[filter]; 4019 4481 4020 4020 - // handle first byte explicitly 4021 4021 - for (k=0; k < filter_bytes; ++k) { 4022 4022 - switch (filter) { 4023 4023 - case STBI__F_none : cur[k] = raw[k]; break; 4024 4024 - case STBI__F_sub : cur[k] = raw[k]; break; 4025 4025 - case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; 4026 4026 - case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; 4027 4027 - case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; 4028 4028 - case STBI__F_avg_first : cur[k] = raw[k]; break; 4482 4482 + // handle first byte explicitly 4483 4483 + for (k = 0; k < filter_bytes; ++k) { 4484 4484 + switch (filter) { 4485 4485 + case STBI__F_none: cur[k] = raw[k]; break; 4486 4486 + case STBI__F_sub: cur[k] = raw[k]; break; 4487 4487 + case STBI__F_up: cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; 4488 4488 + case STBI__F_avg: cur[k] = STBI__BYTECAST(raw[k] + (prior[k] >> 1)); break; 4489 4489 + case STBI__F_paeth: cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0, prior[k], 0)); break; 4490 4490 + case STBI__F_avg_first: cur[k] = raw[k]; break; 4029 4491 case STBI__F_paeth_first: cur[k] = raw[k]; break; 4030 4030 - } 4031 4031 - } 4492 4492 + } 4493 4493 + } 4032 4494 4033 4033 - if (depth == 8) { 4034 4034 - if (img_n != out_n) 4035 4035 - cur[img_n] = 255; // first pixel 4036 4036 - raw += img_n; 4037 4037 - cur += out_n; 4038 4038 - prior += out_n; 4039 4039 - } else { 4040 4040 - raw += 1; 4041 4041 - cur += 1; 4042 4042 - prior += 1; 4043 4043 - } 4495 4495 + if (depth == 8) { 4496 4496 + if (img_n != out_n) 4497 4497 + cur[img_n] = 255; // first pixel 4498 4498 + raw += img_n; 4499 4499 + cur += out_n; 4500 4500 + prior += out_n; 4501 4501 + } 4502 4502 + else if (depth == 16) { 4503 4503 + if (img_n != out_n) { 4504 4504 + cur[filter_bytes] = 255; // first pixel top byte 4505 4505 + cur[filter_bytes + 1] = 255; // first pixel bottom byte 4506 4506 + } 4507 4507 + raw += filter_bytes; 4508 4508 + cur += output_bytes; 4509 4509 + prior += output_bytes; 4510 4510 + } 4511 4511 + else { 4512 4512 + raw += 1; 4513 4513 + cur += 1; 4514 4514 + prior += 1; 4515 4515 + } 4044 4516 4045 4045 - // this is a little gross, so that we don't switch per-pixel or per-component 4046 4046 - if (depth < 8 || img_n == out_n) { 4047 4047 - int nk = (width - 1)*img_n; 4048 4048 - #define CASE(f) \ 4517 4517 + // this is a little gross, so that we don't switch per-pixel or per-component 4518 4518 + if (depth < 8 || img_n == out_n) { 4519 4519 + int nk = (width - 1) * filter_bytes; 4520 4520 + #define STBI__CASE(f) \ 4049 4521 case f: \ 4050 4522 for (k=0; k < nk; ++k) 4051 4051 - switch (filter) { 4052 4052 - // "none" filter turns into a memcpy here; make that explicit. 4523 4523 + switch (filter) { 4524 4524 + // "none" filter turns into a memcpy here; make that explicit. 4053 4525 case STBI__F_none: memcpy(cur, raw, nk); break; 4054 4054 - CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); break; 4055 4055 - CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; 4056 4056 - CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); break; 4057 4057 - CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); break; 4058 4058 - CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); break; 4059 4059 - CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); break; 4060 4060 - } 4061 4061 - #undef CASE 4062 4062 - raw += nk; 4063 4063 - } else { 4064 4064 - STBI_ASSERT(img_n+1 == out_n); 4065 4065 - #define CASE(f) \ 4526 4526 + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k - filter_bytes]); } break; 4527 4527 + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; 4528 4528 + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1)); } break; 4529 4529 + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - filter_bytes], prior[k], prior[k - filter_bytes])); } break; 4530 4530 + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k - filter_bytes] >> 1)); } break; 4531 4531 + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - filter_bytes], 0, 0)); } break; 4532 4532 + } 4533 4533 + #undef STBI__CASE 4534 4534 + raw += nk; 4535 4535 + } 4536 4536 + else { 4537 4537 + STBI_ASSERT(img_n + 1 == out_n); 4538 4538 + #define STBI__CASE(f) \ 4066 4539 case f: \ 4067 4067 - for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \ 4068 4068 - for (k=0; k < img_n; ++k) 4069 4069 - switch (filter) { 4070 4070 - CASE(STBI__F_none) cur[k] = raw[k]; break; 4071 4071 - CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-out_n]); break; 4072 4072 - CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; 4073 4073 - CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-out_n])>>1)); break; 4074 4074 - CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; 4075 4075 - CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-out_n] >> 1)); break; 4076 4076 - CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-out_n],0,0)); break; 4077 4077 - } 4078 4078 - #undef CASE 4079 4079 - } 4080 4080 - } 4540 4540 + for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ 4541 4541 + for (k=0; k < filter_bytes; ++k) 4542 4542 + switch (filter) { 4543 4543 + STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; 4544 4544 + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k - output_bytes]); } break; 4545 4545 + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; 4546 4546 + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - output_bytes]) >> 1)); } break; 4547 4547 + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - output_bytes], prior[k], prior[k - output_bytes])); } break; 4548 4548 + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k - output_bytes] >> 1)); } break; 4549 4549 + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - output_bytes], 0, 0)); } break; 4550 4550 + } 4551 4551 + #undef STBI__CASE 4552 4552 + 4553 4553 + // the loop above sets the high byte of the pixels' alpha, but for 4554 4554 + // 16 bit png files we also need the low byte set. we'll do that here. 4555 4555 + if (depth == 16) { 4556 4556 + cur = a->out + stride * j; // start at the beginning of the row again 4557 4557 + for (i = 0; i < x; ++i, cur += output_bytes) { 4558 4558 + cur[filter_bytes + 1] = 255; 4559 4559 + } 4560 4560 + } 4561 4561 + } 4562 4562 + } 4081 4563 4082 4082 - // we make a separate pass to expand bits to pixels; for performance, 4083 4083 - // this could run two scanlines behind the above code, so it won't 4084 4084 - // intefere with filtering but will still be in the cache. 4085 4085 - if (depth < 8) { 4086 4086 - for (j=0; j < y; ++j) { 4087 4087 - stbi_uc *cur = a->out + stride*j; 4088 4088 - stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; 4089 4089 - // 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 4090 4090 - // 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 4091 4091 - stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range 4564 4564 + // we make a separate pass to expand bits to pixels; for performance, 4565 4565 + // this could run two scanlines behind the above code, so it won't 4566 4566 + // intefere with filtering but will still be in the cache. 4567 4567 + if (depth < 8) { 4568 4568 + for (j = 0; j < y; ++j) { 4569 4569 + stbi_uc* cur = a->out + stride * j; 4570 4570 + stbi_uc* in = a->out + stride * j + x * out_n - img_width_bytes; 4571 4571 + // 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 4572 4572 + // 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 4573 4573 + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range 4092 4574 4093 4093 - // note that the final byte might overshoot and write more data than desired. 4094 4094 - // we can allocate enough data that this never writes out of memory, but it 4095 4095 - // could also overwrite the next scanline. can it overwrite non-empty data 4096 4096 - // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. 4097 4097 - // so we need to explicitly clamp the final ones 4575 4575 + // note that the final byte might overshoot and write more data than desired. 4576 4576 + // we can allocate enough data that this never writes out of memory, but it 4577 4577 + // could also overwrite the next scanline. can it overwrite non-empty data 4578 4578 + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. 4579 4579 + // so we need to explicitly clamp the final ones 4098 4580 4099 4099 - if (depth == 4) { 4100 4100 - for (k=x*img_n; k >= 2; k-=2, ++in) { 4101 4101 - *cur++ = scale * ((*in >> 4) ); 4102 4102 - *cur++ = scale * ((*in ) & 0x0f); 4581 4581 + if (depth == 4) { 4582 4582 + for (k = x * img_n; k >= 2; k -= 2, ++in) { 4583 4583 + *cur++ = scale * ((*in >> 4)); 4584 4584 + *cur++ = scale * ((*in) & 0x0f); 4585 4585 + } 4586 4586 + if (k > 0) *cur++ = scale * ((*in >> 4)); 4103 4587 } 4104 4104 - if (k > 0) *cur++ = scale * ((*in >> 4) ); 4105 4105 - } else if (depth == 2) { 4106 4106 - for (k=x*img_n; k >= 4; k-=4, ++in) { 4107 4107 - *cur++ = scale * ((*in >> 6) ); 4108 4108 - *cur++ = scale * ((*in >> 4) & 0x03); 4109 4109 - *cur++ = scale * ((*in >> 2) & 0x03); 4110 4110 - *cur++ = scale * ((*in ) & 0x03); 4588 4588 + else if (depth == 2) { 4589 4589 + for (k = x * img_n; k >= 4; k -= 4, ++in) { 4590 4590 + *cur++ = scale * ((*in >> 6)); 4591 4591 + *cur++ = scale * ((*in >> 4) & 0x03); 4592 4592 + *cur++ = scale * ((*in >> 2) & 0x03); 4593 4593 + *cur++ = scale * ((*in) & 0x03); 4594 4594 + } 4595 4595 + if (k > 0) *cur++ = scale * ((*in >> 6)); 4596 4596 + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); 4597 4597 + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); 4111 4598 } 4112 4112 - if (k > 0) *cur++ = scale * ((*in >> 6) ); 4113 4113 - if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); 4114 4114 - if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); 4115 4115 - } else if (depth == 1) { 4116 4116 - for (k=x*img_n; k >= 8; k-=8, ++in) { 4117 4117 - *cur++ = scale * ((*in >> 7) ); 4118 4118 - *cur++ = scale * ((*in >> 6) & 0x01); 4119 4119 - *cur++ = scale * ((*in >> 5) & 0x01); 4120 4120 - *cur++ = scale * ((*in >> 4) & 0x01); 4121 4121 - *cur++ = scale * ((*in >> 3) & 0x01); 4122 4122 - *cur++ = scale * ((*in >> 2) & 0x01); 4123 4123 - *cur++ = scale * ((*in >> 1) & 0x01); 4124 4124 - *cur++ = scale * ((*in ) & 0x01); 4599 4599 + else if (depth == 1) { 4600 4600 + for (k = x * img_n; k >= 8; k -= 8, ++in) { 4601 4601 + *cur++ = scale * ((*in >> 7)); 4602 4602 + *cur++ = scale * ((*in >> 6) & 0x01); 4603 4603 + *cur++ = scale * ((*in >> 5) & 0x01); 4604 4604 + *cur++ = scale * ((*in >> 4) & 0x01); 4605 4605 + *cur++ = scale * ((*in >> 3) & 0x01); 4606 4606 + *cur++ = scale * ((*in >> 2) & 0x01); 4607 4607 + *cur++ = scale * ((*in >> 1) & 0x01); 4608 4608 + *cur++ = scale * ((*in) & 0x01); 4609 4609 + } 4610 4610 + if (k > 0) *cur++ = scale * ((*in >> 7)); 4611 4611 + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); 4612 4612 + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); 4613 4613 + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); 4614 4614 + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); 4615 4615 + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); 4616 4616 + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); 4125 4617 } 4126 4126 - if (k > 0) *cur++ = scale * ((*in >> 7) ); 4127 4127 - if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); 4128 4128 - if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); 4129 4129 - if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); 4130 4130 - if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); 4131 4131 - if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); 4132 4132 - if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); 4133 4133 - } 4134 4134 - if (img_n != out_n) { 4135 4135 - int q; 4136 4136 - // insert alpha = 255 4137 4137 - cur = a->out + stride*j; 4138 4138 - if (img_n == 1) { 4139 4139 - for (q=x-1; q >= 0; --q) { 4140 4140 - cur[q*2+1] = 255; 4141 4141 - cur[q*2+0] = cur[q]; 4142 4142 - } 4143 4143 - } else { 4144 4144 - STBI_ASSERT(img_n == 3); 4145 4145 - for (q=x-1; q >= 0; --q) { 4146 4146 - cur[q*4+3] = 255; 4147 4147 - cur[q*4+2] = cur[q*3+2]; 4148 4148 - cur[q*4+1] = cur[q*3+1]; 4149 4149 - cur[q*4+0] = cur[q*3+0]; 4150 4150 - } 4618 4618 + if (img_n != out_n) { 4619 4619 + int q; 4620 4620 + // insert alpha = 255 4621 4621 + cur = a->out + stride * j; 4622 4622 + if (img_n == 1) { 4623 4623 + for (q = x - 1; q >= 0; --q) { 4624 4624 + cur[q * 2 + 1] = 255; 4625 4625 + cur[q * 2 + 0] = cur[q]; 4626 4626 + } 4627 4627 + } 4628 4628 + else { 4629 4629 + STBI_ASSERT(img_n == 3); 4630 4630 + for (q = x - 1; q >= 0; --q) { 4631 4631 + cur[q * 4 + 3] = 255; 4632 4632 + cur[q * 4 + 2] = cur[q * 3 + 2]; 4633 4633 + cur[q * 4 + 1] = cur[q * 3 + 1]; 4634 4634 + cur[q * 4 + 0] = cur[q * 3 + 0]; 4635 4635 + } 4636 4636 + } 4151 4637 } 4152 4152 - } 4153 4153 - } 4154 4154 - } 4638 4638 + } 4639 4639 + } 4640 4640 + else if (depth == 16) { 4641 4641 + // force the image data from big-endian to platform-native. 4642 4642 + // this is done in a separate pass due to the decoding relying 4643 4643 + // on the data being untouched, but could probably be done 4644 4644 + // per-line during decode if care is taken. 4645 4645 + stbi_uc* cur = a->out; 4646 4646 + stbi__uint16* cur16 = (stbi__uint16*)cur; 4647 4647 + 4648 4648 + for (i = 0; i < x * y * out_n; ++i, cur16++, cur += 2) { 4649 4649 + *cur16 = (cur[0] << 8) | cur[1]; 4650 4650 + } 4651 4651 + } 4155 4652 4156 4156 - return 1; 4653 4653 + return 1; 4157 4654 } 4158 4655 4159 4159 - 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) 4656 4656 + 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) 4160 4657 { 4161 4161 - stbi_uc *final; 4162 4162 - int p; 4163 4163 - if (!interlaced) 4164 4164 - return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); 4658 4658 + int bytes = (depth == 16 ? 2 : 1); 4659 4659 + int out_bytes = out_n * bytes; 4660 4660 + stbi_uc* final; 4661 4661 + int p; 4662 4662 + if (!interlaced) 4663 4663 + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); 4165 4664 4166 4166 - // de-interlacing 4167 4167 - final = (stbi_uc *) stbi__malloc(a->s->img_x * a->s->img_y * out_n); 4168 4168 - for (p=0; p < 7; ++p) { 4169 4169 - int xorig[] = { 0,4,0,2,0,1,0 }; 4170 4170 - int yorig[] = { 0,0,4,0,2,0,1 }; 4171 4171 - int xspc[] = { 8,8,4,4,2,2,1 }; 4172 4172 - int yspc[] = { 8,8,8,4,4,2,2 }; 4173 4173 - int i,j,x,y; 4174 4174 - // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 4175 4175 - x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; 4176 4176 - y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; 4177 4177 - if (x && y) { 4178 4178 - stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; 4179 4179 - if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { 4180 4180 - STBI_FREE(final); 4181 4181 - return 0; 4182 4182 - } 4183 4183 - for (j=0; j < y; ++j) { 4184 4184 - for (i=0; i < x; ++i) { 4185 4185 - int out_y = j*yspc[p]+yorig[p]; 4186 4186 - int out_x = i*xspc[p]+xorig[p]; 4187 4187 - memcpy(final + out_y*a->s->img_x*out_n + out_x*out_n, 4188 4188 - a->out + (j*x+i)*out_n, out_n); 4665 4665 + // de-interlacing 4666 4666 + final = (stbi_uc*)stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); 4667 4667 + for (p = 0; p < 7; ++p) { 4668 4668 + int xorig[] = { 0,4,0,2,0,1,0 }; 4669 4669 + int yorig[] = { 0,0,4,0,2,0,1 }; 4670 4670 + int xspc[] = { 8,8,4,4,2,2,1 }; 4671 4671 + int yspc[] = { 8,8,8,4,4,2,2 }; 4672 4672 + int i, j, x, y; 4673 4673 + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 4674 4674 + x = (a->s->img_x - xorig[p] + xspc[p] - 1) / xspc[p]; 4675 4675 + y = (a->s->img_y - yorig[p] + yspc[p] - 1) / yspc[p]; 4676 4676 + if (x && y) { 4677 4677 + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1)* y; 4678 4678 + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { 4679 4679 + STBI_FREE(final); 4680 4680 + return 0; 4681 4681 + } 4682 4682 + for (j = 0; j < y; ++j) { 4683 4683 + for (i = 0; i < x; ++i) { 4684 4684 + int out_y = j * yspc[p] + yorig[p]; 4685 4685 + int out_x = i * xspc[p] + xorig[p]; 4686 4686 + memcpy(final + out_y * a->s->img_x * out_bytes + out_x * out_bytes, 4687 4687 + a->out + (j * x + i) * out_bytes, out_bytes); 4688 4688 + } 4189 4689 } 4190 4190 - } 4191 4191 - STBI_FREE(a->out); 4192 4192 - image_data += img_len; 4193 4193 - image_data_len -= img_len; 4194 4194 - } 4195 4195 - } 4196 4196 - a->out = final; 4690 4690 + STBI_FREE(a->out); 4691 4691 + image_data += img_len; 4692 4692 + image_data_len -= img_len; 4693 4693 + } 4694 4694 + } 4695 4695 + a->out = final; 4197 4696 4198 4198 - return 1; 4697 4697 + return 1; 4199 4698 } 4200 4699 4201 4201 - static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) 4700 4700 + static int stbi__compute_transparency(stbi__png* z, stbi_uc tc[3], int out_n) 4202 4701 { 4203 4203 - stbi__context *s = z->s; 4204 4204 - stbi__uint32 i, pixel_count = s->img_x * s->img_y; 4205 4205 - stbi_uc *p = z->out; 4702 4702 + stbi__context* s = z->s; 4703 4703 + stbi__uint32 i, pixel_count = s->img_x * s->img_y; 4704 4704 + stbi_uc* p = z->out; 4206 4705 4207 4207 - // compute color-based transparency, assuming we've 4208 4208 - // already got 255 as the alpha value in the output 4209 4209 - STBI_ASSERT(out_n == 2 || out_n == 4); 4706 4706 + // compute color-based transparency, assuming we've 4707 4707 + // already got 255 as the alpha value in the output 4708 4708 + STBI_ASSERT(out_n == 2 || out_n == 4); 4210 4709 4211 4211 - if (out_n == 2) { 4212 4212 - for (i=0; i < pixel_count; ++i) { 4213 4213 - p[1] = (p[0] == tc[0] ? 0 : 255); 4214 4214 - p += 2; 4215 4215 - } 4216 4216 - } else { 4217 4217 - for (i=0; i < pixel_count; ++i) { 4218 4218 - if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) 4219 4219 - p[3] = 0; 4220 4220 - p += 4; 4221 4221 - } 4222 4222 - } 4223 4223 - return 1; 4710 4710 + if (out_n == 2) { 4711 4711 + for (i = 0; i < pixel_count; ++i) { 4712 4712 + p[1] = (p[0] == tc[0] ? 0 : 255); 4713 4713 + p += 2; 4714 4714 + } 4715 4715 + } 4716 4716 + else { 4717 4717 + for (i = 0; i < pixel_count; ++i) { 4718 4718 + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) 4719 4719 + p[3] = 0; 4720 4720 + p += 4; 4721 4721 + } 4722 4722 + } 4723 4723 + return 1; 4224 4724 } 4225 4725 4226 4226 - static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) 4726 4726 + static int stbi__compute_transparency16(stbi__png* z, stbi__uint16 tc[3], int out_n) 4227 4727 { 4228 4228 - stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; 4229 4229 - stbi_uc *p, *temp_out, *orig = a->out; 4728 4728 + stbi__context* s = z->s; 4729 4729 + stbi__uint32 i, pixel_count = s->img_x * s->img_y; 4730 4730 + stbi__uint16* p = (stbi__uint16*)z->out; 4230 4731 4231 4231 - p = (stbi_uc *) stbi__malloc(pixel_count * pal_img_n); 4232 4232 - if (p == NULL) return stbi__err("outofmem", "Out of memory"); 4732 4732 + // compute color-based transparency, assuming we've 4733 4733 + // already got 65535 as the alpha value in the output 4734 4734 + STBI_ASSERT(out_n == 2 || out_n == 4); 4233 4735 4234 4234 - // between here and free(out) below, exitting would leak 4235 4235 - temp_out = p; 4736 4736 + if (out_n == 2) { 4737 4737 + for (i = 0; i < pixel_count; ++i) { 4738 4738 + p[1] = (p[0] == tc[0] ? 0 : 65535); 4739 4739 + p += 2; 4740 4740 + } 4741 4741 + } 4742 4742 + else { 4743 4743 + for (i = 0; i < pixel_count; ++i) { 4744 4744 + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) 4745 4745 + p[3] = 0; 4746 4746 + p += 4; 4747 4747 + } 4748 4748 + } 4749 4749 + return 1; 4750 4750 + } 4751 4751 + 4752 4752 + static int stbi__expand_png_palette(stbi__png* a, stbi_uc* palette, int len, int pal_img_n) 4753 4753 + { 4754 4754 + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; 4755 4755 + stbi_uc* p, * temp_out, * orig = a->out; 4756 4756 + 4757 4757 + p = (stbi_uc*)stbi__malloc_mad2(pixel_count, pal_img_n, 0); 4758 4758 + if (p == NULL) return stbi__err("outofmem", "Out of memory"); 4759 4759 + 4760 4760 + // between here and free(out) below, exitting would leak 4761 4761 + temp_out = p; 4236 4762 4237 4237 - if (pal_img_n == 3) { 4238 4238 - for (i=0; i < pixel_count; ++i) { 4239 4239 - int n = orig[i]*4; 4240 4240 - p[0] = palette[n ]; 4241 4241 - p[1] = palette[n+1]; 4242 4242 - p[2] = palette[n+2]; 4243 4243 - p += 3; 4244 4244 - } 4245 4245 - } else { 4246 4246 - for (i=0; i < pixel_count; ++i) { 4247 4247 - int n = orig[i]*4; 4248 4248 - p[0] = palette[n ]; 4249 4249 - p[1] = palette[n+1]; 4250 4250 - p[2] = palette[n+2]; 4251 4251 - p[3] = palette[n+3]; 4252 4252 - p += 4; 4253 4253 - } 4254 4254 - } 4255 4255 - STBI_FREE(a->out); 4256 4256 - a->out = temp_out; 4763 4763 + if (pal_img_n == 3) { 4764 4764 + for (i = 0; i < pixel_count; ++i) { 4765 4765 + int n = orig[i] * 4; 4766 4766 + p[0] = palette[n]; 4767 4767 + p[1] = palette[n + 1]; 4768 4768 + p[2] = palette[n + 2]; 4769 4769 + p += 3; 4770 4770 + } 4771 4771 + } 4772 4772 + else { 4773 4773 + for (i = 0; i < pixel_count; ++i) { 4774 4774 + int n = orig[i] * 4; 4775 4775 + p[0] = palette[n]; 4776 4776 + p[1] = palette[n + 1]; 4777 4777 + p[2] = palette[n + 2]; 4778 4778 + p[3] = palette[n + 3]; 4779 4779 + p += 4; 4780 4780 + } 4781 4781 + } 4782 4782 + STBI_FREE(a->out); 4783 4783 + a->out = temp_out; 4257 4784 4258 4258 - STBI_NOTUSED(len); 4785 4785 + STBI_NOTUSED(len); 4259 4786 4260 4260 - return 1; 4787 4787 + return 1; 4261 4788 } 4262 4789 4263 4790 static int stbi__unpremultiply_on_load = 0; ··· 4265 4792 4266 4793 STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) 4267 4794 { 4268 4268 - stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; 4795 4795 + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; 4269 4796 } 4270 4797 4271 4798 STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) 4272 4799 { 4273 4273 - stbi__de_iphone_flag = flag_true_if_should_convert; 4800 4800 + stbi__de_iphone_flag = flag_true_if_should_convert; 4274 4801 } 4275 4802 4276 4276 - static void stbi__de_iphone(stbi__png *z) 4803 4803 + static void stbi__de_iphone(stbi__png* z) 4277 4804 { 4278 4278 - stbi__context *s = z->s; 4279 4279 - stbi__uint32 i, pixel_count = s->img_x * s->img_y; 4280 4280 - stbi_uc *p = z->out; 4805 4805 + stbi__context* s = z->s; 4806 4806 + stbi__uint32 i, pixel_count = s->img_x * s->img_y; 4807 4807 + stbi_uc* p = z->out; 4281 4808 4282 4282 - if (s->img_out_n == 3) { // convert bgr to rgb 4283 4283 - for (i=0; i < pixel_count; ++i) { 4284 4284 - stbi_uc t = p[0]; 4285 4285 - p[0] = p[2]; 4286 4286 - p[2] = t; 4287 4287 - p += 3; 4288 4288 - } 4289 4289 - } else { 4290 4290 - STBI_ASSERT(s->img_out_n == 4); 4291 4291 - if (stbi__unpremultiply_on_load) { 4292 4292 - // convert bgr to rgb and unpremultiply 4293 4293 - for (i=0; i < pixel_count; ++i) { 4294 4294 - stbi_uc a = p[3]; 4295 4295 - stbi_uc t = p[0]; 4296 4296 - if (a) { 4297 4297 - p[0] = p[2] * 255 / a; 4298 4298 - p[1] = p[1] * 255 / a; 4299 4299 - p[2] = t * 255 / a; 4300 4300 - } else { 4301 4301 - p[0] = p[2]; 4302 4302 - p[2] = t; 4303 4303 - } 4304 4304 - p += 4; 4305 4305 - } 4306 4306 - } else { 4307 4307 - // convert bgr to rgb 4308 4308 - for (i=0; i < pixel_count; ++i) { 4809 4809 + if (s->img_out_n == 3) { // convert bgr to rgb 4810 4810 + for (i = 0; i < pixel_count; ++i) { 4309 4811 stbi_uc t = p[0]; 4310 4812 p[0] = p[2]; 4311 4813 p[2] = t; 4312 4312 - p += 4; 4313 4313 - } 4314 4314 - } 4315 4315 - } 4814 4814 + p += 3; 4815 4815 + } 4816 4816 + } 4817 4817 + else { 4818 4818 + STBI_ASSERT(s->img_out_n == 4); 4819 4819 + if (stbi__unpremultiply_on_load) { 4820 4820 + // convert bgr to rgb and unpremultiply 4821 4821 + for (i = 0; i < pixel_count; ++i) { 4822 4822 + stbi_uc a = p[3]; 4823 4823 + stbi_uc t = p[0]; 4824 4824 + if (a) { 4825 4825 + stbi_uc half = a / 2; 4826 4826 + p[0] = (p[2] * 255 + half) / a; 4827 4827 + p[1] = (p[1] * 255 + half) / a; 4828 4828 + p[2] = (t * 255 + half) / a; 4829 4829 + } 4830 4830 + else { 4831 4831 + p[0] = p[2]; 4832 4832 + p[2] = t; 4833 4833 + } 4834 4834 + p += 4; 4835 4835 + } 4836 4836 + } 4837 4837 + else { 4838 4838 + // convert bgr to rgb 4839 4839 + for (i = 0; i < pixel_count; ++i) { 4840 4840 + stbi_uc t = p[0]; 4841 4841 + p[0] = p[2]; 4842 4842 + p[2] = t; 4843 4843 + p += 4; 4844 4844 + } 4845 4845 + } 4846 4846 + } 4316 4847 } 4317 4848 4318 4318 - #define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) 4849 4849 + #define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) 4319 4850 4320 4320 - static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) 4851 4851 + static int stbi__parse_png_file(stbi__png* z, int scan, int req_comp) 4321 4852 { 4322 4322 - stbi_uc palette[1024], pal_img_n=0; 4323 4323 - stbi_uc has_trans=0, tc[3]; 4324 4324 - stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; 4325 4325 - int first=1,k,interlace=0, color=0, depth=0, is_iphone=0; 4326 4326 - stbi__context *s = z->s; 4853 4853 + stbi_uc palette[1024], pal_img_n = 0; 4854 4854 + stbi_uc has_trans = 0, tc[3] = { 0 }; 4855 4855 + stbi__uint16 tc16[3]; 4856 4856 + stbi__uint32 ioff = 0, idata_limit = 0, i, pal_len = 0; 4857 4857 + int first = 1, k, interlace = 0, color = 0, is_iphone = 0; 4858 4858 + stbi__context* s = z->s; 4327 4859 4328 4328 - z->expanded = NULL; 4329 4329 - z->idata = NULL; 4330 4330 - z->out = NULL; 4860 4860 + z->expanded = NULL; 4861 4861 + z->idata = NULL; 4862 4862 + z->out = NULL; 4331 4863 4332 4332 - if (!stbi__check_png_header(s)) return 0; 4864 4864 + if (!stbi__check_png_header(s)) return 0; 4333 4865 4334 4334 - if (scan == STBI__SCAN_type) return 1; 4866 4866 + if (scan == STBI__SCAN_type) return 1; 4335 4867 4336 4336 - for (;;) { 4337 4337 - stbi__pngchunk c = stbi__get_chunk_header(s); 4338 4338 - switch (c.type) { 4339 4339 - case STBI__PNG_TYPE('C','g','B','I'): 4868 4868 + for (;;) { 4869 4869 + stbi__pngchunk c = stbi__get_chunk_header(s); 4870 4870 + switch (c.type) { 4871 4871 + case STBI__PNG_TYPE('C', 'g', 'B', 'I'): 4340 4872 is_iphone = 1; 4341 4873 stbi__skip(s, c.length); 4342 4874 break; 4343 4343 - case STBI__PNG_TYPE('I','H','D','R'): { 4344 4344 - int comp,filter; 4345 4345 - if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); 4875 4875 + case STBI__PNG_TYPE('I', 'H', 'D', 'R'): { 4876 4876 + int comp, filter; 4877 4877 + if (!first) return stbi__err("multiple IHDR", "Corrupt PNG"); 4346 4878 first = 0; 4347 4347 - if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); 4348 4348 - s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); 4349 4349 - s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); 4350 4350 - depth = stbi__get8(s); if (depth != 1 && depth != 2 && depth != 4 && depth != 8) return stbi__err("1/2/4/8-bit only","PNG not supported: 1/2/4/8-bit only"); 4351 4351 - color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); 4352 4352 - if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); 4353 4353 - comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); 4354 4354 - filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); 4355 4355 - interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); 4356 4356 - if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); 4879 4879 + if (c.length != 13) return stbi__err("bad IHDR len", "Corrupt PNG"); 4880 4880 + s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large", "Very large image (corrupt?)"); 4881 4881 + s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large", "Very large image (corrupt?)"); 4882 4882 + 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"); 4883 4883 + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype", "Corrupt PNG"); 4884 4884 + if (color == 3 && z->depth == 16) return stbi__err("bad ctype", "Corrupt PNG"); 4885 4885 + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype", "Corrupt PNG"); 4886 4886 + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method", "Corrupt PNG"); 4887 4887 + filter = stbi__get8(s); if (filter) return stbi__err("bad filter method", "Corrupt PNG"); 4888 4888 + interlace = stbi__get8(s); if (interlace > 1) return stbi__err("bad interlace method", "Corrupt PNG"); 4889 4889 + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image", "Corrupt PNG"); 4357 4890 if (!pal_img_n) { 4358 4358 - s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); 4359 4359 - if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); 4360 4360 - if (scan == STBI__SCAN_header) return 1; 4361 4361 - } else { 4362 4362 - // if paletted, then pal_n is our final components, and 4363 4363 - // img_n is # components to decompress/filter. 4364 4364 - s->img_n = 1; 4365 4365 - if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); 4366 4366 - // if SCAN_header, have to scan to see if we have a tRNS 4891 4891 + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); 4892 4892 + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); 4893 4893 + if (scan == STBI__SCAN_header) return 1; 4894 4894 + } 4895 4895 + else { 4896 4896 + // if paletted, then pal_n is our final components, and 4897 4897 + // img_n is # components to decompress/filter. 4898 4898 + s->img_n = 1; 4899 4899 + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large", "Corrupt PNG"); 4900 4900 + // if SCAN_header, have to scan to see if we have a tRNS 4367 4901 } 4368 4902 break; 4369 4369 - } 4903 4903 + } 4370 4904 4371 4371 - case STBI__PNG_TYPE('P','L','T','E'): { 4905 4905 + case STBI__PNG_TYPE('P', 'L', 'T', 'E'): { 4372 4906 if (first) return stbi__err("first not IHDR", "Corrupt PNG"); 4373 4373 - if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); 4907 4907 + if (c.length > 256 * 3) return stbi__err("invalid PLTE", "Corrupt PNG"); 4374 4908 pal_len = c.length / 3; 4375 4375 - if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); 4376 4376 - for (i=0; i < pal_len; ++i) { 4377 4377 - palette[i*4+0] = stbi__get8(s); 4378 4378 - palette[i*4+1] = stbi__get8(s); 4379 4379 - palette[i*4+2] = stbi__get8(s); 4380 4380 - palette[i*4+3] = 255; 4909 4909 + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE", "Corrupt PNG"); 4910 4910 + for (i = 0; i < pal_len; ++i) { 4911 4911 + palette[i * 4 + 0] = stbi__get8(s); 4912 4912 + palette[i * 4 + 1] = stbi__get8(s); 4913 4913 + palette[i * 4 + 2] = stbi__get8(s); 4914 4914 + palette[i * 4 + 3] = 255; 4381 4915 } 4382 4916 break; 4383 4383 - } 4917 4917 + } 4384 4918 4385 4385 - case STBI__PNG_TYPE('t','R','N','S'): { 4919 4919 + case STBI__PNG_TYPE('t', 'R', 'N', 'S'): { 4386 4920 if (first) return stbi__err("first not IHDR", "Corrupt PNG"); 4387 4387 - if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); 4921 4921 + if (z->idata) return stbi__err("tRNS after IDAT", "Corrupt PNG"); 4388 4922 if (pal_img_n) { 4389 4389 - if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } 4390 4390 - if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); 4391 4391 - if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); 4392 4392 - pal_img_n = 4; 4393 4393 - for (i=0; i < c.length; ++i) 4394 4394 - palette[i*4+3] = stbi__get8(s); 4395 4395 - } else { 4396 4396 - if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); 4397 4397 - if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); 4398 4398 - has_trans = 1; 4399 4399 - for (k=0; k < s->img_n; ++k) 4400 4400 - tc[k] = (stbi_uc) (stbi__get16be(s) & 255) * stbi__depth_scale_table[depth]; // non 8-bit images will be larger 4923 4923 + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } 4924 4924 + if (pal_len == 0) return stbi__err("tRNS before PLTE", "Corrupt PNG"); 4925 4925 + if (c.length > pal_len) return stbi__err("bad tRNS len", "Corrupt PNG"); 4926 4926 + pal_img_n = 4; 4927 4927 + for (i = 0; i < c.length; ++i) 4928 4928 + palette[i * 4 + 3] = stbi__get8(s); 4929 4929 + } 4930 4930 + else { 4931 4931 + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha", "Corrupt PNG"); 4932 4932 + if (c.length != (stbi__uint32)s->img_n * 2) return stbi__err("bad tRNS len", "Corrupt PNG"); 4933 4933 + has_trans = 1; 4934 4934 + if (z->depth == 16) { 4935 4935 + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is 4936 4936 + } 4937 4937 + else { 4938 4938 + 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 4939 4939 + } 4401 4940 } 4402 4941 break; 4403 4403 - } 4942 4942 + } 4404 4943 4405 4405 - case STBI__PNG_TYPE('I','D','A','T'): { 4944 4944 + case STBI__PNG_TYPE('I', 'D', 'A', 'T'): { 4406 4945 if (first) return stbi__err("first not IHDR", "Corrupt PNG"); 4407 4407 - if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); 4946 4946 + if (pal_img_n && !pal_len) return stbi__err("no PLTE", "Corrupt PNG"); 4408 4947 if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } 4409 4948 if ((int)(ioff + c.length) < (int)ioff) return 0; 4410 4949 if (ioff + c.length > idata_limit) { 4411 4411 - stbi_uc *p; 4412 4412 - if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; 4413 4413 - while (ioff + c.length > idata_limit) 4414 4414 - idata_limit *= 2; 4415 4415 - p = (stbi_uc *) STBI_REALLOC(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); 4416 4416 - z->idata = p; 4950 4950 + stbi__uint32 idata_limit_old = idata_limit; 4951 4951 + stbi_uc* p; 4952 4952 + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; 4953 4953 + while (ioff + c.length > idata_limit) 4954 4954 + idata_limit *= 2; 4955 4955 + STBI_NOTUSED(idata_limit_old); 4956 4956 + p = (stbi_uc*)STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); 4957 4957 + z->idata = p; 4417 4958 } 4418 4418 - if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); 4959 4959 + if (!stbi__getn(s, z->idata + ioff, c.length)) return stbi__err("outofdata", "Corrupt PNG"); 4419 4960 ioff += c.length; 4420 4961 break; 4421 4421 - } 4962 4962 + } 4422 4963 4423 4423 - case STBI__PNG_TYPE('I','E','N','D'): { 4964 4964 + case STBI__PNG_TYPE('I', 'E', 'N', 'D'): { 4424 4965 stbi__uint32 raw_len, bpl; 4425 4966 if (first) return stbi__err("first not IHDR", "Corrupt PNG"); 4426 4967 if (scan != STBI__SCAN_load) return 1; 4427 4427 - if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); 4968 4968 + if (z->idata == NULL) return stbi__err("no IDAT", "Corrupt PNG"); 4428 4969 // initial guess for decoded data size to avoid unnecessary reallocs 4429 4429 - bpl = (s->img_x * depth + 7) / 8; // bytes per line, per component 4970 4970 + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component 4430 4971 raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; 4431 4431 - z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); 4972 4972 + z->expanded = (stbi_uc*)stbi_zlib_decode_malloc_guesssize_headerflag((char*)z->idata, ioff, raw_len, (int*)&raw_len, !is_iphone); 4432 4973 if (z->expanded == NULL) return 0; // zlib should set error 4433 4974 STBI_FREE(z->idata); z->idata = NULL; 4434 4434 - if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) 4435 4435 - s->img_out_n = s->img_n+1; 4975 4975 + if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) || has_trans) 4976 4976 + s->img_out_n = s->img_n + 1; 4436 4977 else 4437 4437 - s->img_out_n = s->img_n; 4438 4438 - if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, depth, color, interlace)) return 0; 4439 4439 - if (has_trans) 4440 4440 - if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; 4978 4978 + s->img_out_n = s->img_n; 4979 4979 + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; 4980 4980 + if (has_trans) { 4981 4981 + if (z->depth == 16) { 4982 4982 + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; 4983 4983 + } 4984 4984 + else { 4985 4985 + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; 4986 4986 + } 4987 4987 + } 4441 4988 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) 4442 4442 - stbi__de_iphone(z); 4989 4989 + stbi__de_iphone(z); 4443 4990 if (pal_img_n) { 4444 4444 - // pal_img_n == 3 or 4 4445 4445 - s->img_n = pal_img_n; // record the actual colors we had 4446 4446 - s->img_out_n = pal_img_n; 4447 4447 - if (req_comp >= 3) s->img_out_n = req_comp; 4448 4448 - if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) 4449 4449 - return 0; 4991 4991 + // pal_img_n == 3 or 4 4992 4992 + s->img_n = pal_img_n; // record the actual colors we had 4993 4993 + s->img_out_n = pal_img_n; 4994 4994 + if (req_comp >= 3) s->img_out_n = req_comp; 4995 4995 + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) 4996 4996 + return 0; 4997 4997 + } 4998 4998 + else if (has_trans) { 4999 4999 + // non-paletted image with tRNS -> source image has (constant) alpha 5000 5000 + ++s->img_n; 4450 5001 } 4451 5002 STBI_FREE(z->expanded); z->expanded = NULL; 4452 5003 return 1; 4453 4453 - } 5004 5004 + } 4454 5005 4455 4455 - default: 5006 5006 + default: 4456 5007 // if critical, fail 4457 5008 if (first) return stbi__err("first not IHDR", "Corrupt PNG"); 4458 5009 if ((c.type & (1 << 29)) == 0) { 4459 4459 - #ifndef STBI_NO_FAILURE_STRINGS 4460 4460 - // not threadsafe 4461 4461 - static char invalid_chunk[] = "XXXX PNG chunk not known"; 4462 4462 - invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); 4463 4463 - invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); 4464 4464 - invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); 4465 4465 - invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); 4466 4466 - #endif 4467 4467 - return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); 5010 5010 + #ifndef STBI_NO_FAILURE_STRINGS 5011 5011 + // not threadsafe 5012 5012 + static char invalid_chunk[] = "XXXX PNG chunk not known"; 5013 5013 + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); 5014 5014 + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); 5015 5015 + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); 5016 5016 + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); 5017 5017 + #endif 5018 5018 + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); 4468 5019 } 4469 5020 stbi__skip(s, c.length); 4470 5021 break; 4471 4471 - } 4472 4472 - // end of PNG chunk, read and skip CRC 4473 4473 - stbi__get32be(s); 4474 4474 - } 5022 5022 + } 5023 5023 + // end of PNG chunk, read and skip CRC 5024 5024 + stbi__get32be(s); 5025 5025 + } 4475 5026 } 4476 5027 4477 4477 - static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp) 5028 5028 + static void* stbi__do_png(stbi__png* p, int* x, int* y, int* n, int req_comp, stbi__result_info* ri) 4478 5029 { 4479 4479 - unsigned char *result=NULL; 4480 4480 - if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); 4481 4481 - if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { 4482 4482 - result = p->out; 4483 4483 - p->out = NULL; 4484 4484 - if (req_comp && req_comp != p->s->img_out_n) { 4485 4485 - result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); 4486 4486 - p->s->img_out_n = req_comp; 4487 4487 - if (result == NULL) return result; 4488 4488 - } 4489 4489 - *x = p->s->img_x; 4490 4490 - *y = p->s->img_y; 4491 4491 - if (n) *n = p->s->img_out_n; 4492 4492 - } 4493 4493 - STBI_FREE(p->out); p->out = NULL; 4494 4494 - STBI_FREE(p->expanded); p->expanded = NULL; 4495 4495 - STBI_FREE(p->idata); p->idata = NULL; 5030 5030 + void* result = NULL; 5031 5031 + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); 5032 5032 + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { 5033 5033 + if (p->depth < 8) 5034 5034 + ri->bits_per_channel = 8; 5035 5035 + else 5036 5036 + ri->bits_per_channel = p->depth; 5037 5037 + result = p->out; 5038 5038 + p->out = NULL; 5039 5039 + if (req_comp && req_comp != p->s->img_out_n) { 5040 5040 + if (ri->bits_per_channel == 8) 5041 5041 + result = stbi__convert_format((unsigned char*)result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); 5042 5042 + else 5043 5043 + result = stbi__convert_format16((stbi__uint16*)result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); 5044 5044 + p->s->img_out_n = req_comp; 5045 5045 + if (result == NULL) return result; 5046 5046 + } 5047 5047 + *x = p->s->img_x; 5048 5048 + *y = p->s->img_y; 5049 5049 + if (n) *n = p->s->img_n; 5050 5050 + } 5051 5051 + STBI_FREE(p->out); p->out = NULL; 5052 5052 + STBI_FREE(p->expanded); p->expanded = NULL; 5053 5053 + STBI_FREE(p->idata); p->idata = NULL; 4496 5054 4497 4497 - return result; 5055 5055 + return result; 4498 5056 } 4499 5057 4500 4500 - static unsigned char *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 5058 5058 + static void* stbi__png_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 4501 5059 { 4502 4502 - stbi__png p; 4503 4503 - p.s = s; 4504 4504 - return stbi__do_png(&p, x,y,comp,req_comp); 5060 5060 + stbi__png p; 5061 5061 + p.s = s; 5062 5062 + return stbi__do_png(&p, x, y, comp, req_comp, ri); 4505 5063 } 4506 5064 4507 4507 - static int stbi__png_test(stbi__context *s) 5065 5065 + static int stbi__png_test(stbi__context* s) 4508 5066 { 4509 4509 - int r; 4510 4510 - r = stbi__check_png_header(s); 4511 4511 - stbi__rewind(s); 4512 4512 - return r; 5067 5067 + int r; 5068 5068 + r = stbi__check_png_header(s); 5069 5069 + stbi__rewind(s); 5070 5070 + return r; 5071 5071 + } 5072 5072 + 5073 5073 + static int stbi__png_info_raw(stbi__png* p, int* x, int* y, int* comp) 5074 5074 + { 5075 5075 + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { 5076 5076 + stbi__rewind(p->s); 5077 5077 + return 0; 5078 5078 + } 5079 5079 + if (x) *x = p->s->img_x; 5080 5080 + if (y) *y = p->s->img_y; 5081 5081 + if (comp) *comp = p->s->img_n; 5082 5082 + return 1; 4513 5083 } 4514 5084 4515 4515 - static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) 5085 5085 + static int stbi__png_info(stbi__context* s, int* x, int* y, int* comp) 4516 5086 { 4517 4517 - if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { 4518 4518 - stbi__rewind( p->s ); 4519 4519 - return 0; 4520 4520 - } 4521 4521 - if (x) *x = p->s->img_x; 4522 4522 - if (y) *y = p->s->img_y; 4523 4523 - if (comp) *comp = p->s->img_n; 4524 4524 - return 1; 5087 5087 + stbi__png p; 5088 5088 + p.s = s; 5089 5089 + return stbi__png_info_raw(&p, x, y, comp); 4525 5090 } 4526 5091 4527 4527 - static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) 5092 5092 + static int stbi__png_is16(stbi__context* s) 4528 5093 { 4529 4529 - stbi__png p; 4530 4530 - p.s = s; 4531 4531 - return stbi__png_info_raw(&p, x, y, comp); 5094 5094 + stbi__png p; 5095 5095 + p.s = s; 5096 5096 + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) 5097 5097 + return 0; 5098 5098 + if (p.depth != 16) { 5099 5099 + stbi__rewind(p.s); 5100 5100 + return 0; 5101 5101 + } 5102 5102 + return 1; 4532 5103 } 4533 5104 #endif 4534 5105 4535 5106 // Microsoft/Windows BMP image 4536 5107 4537 5108 #ifndef STBI_NO_BMP 4538 4538 - static int stbi__bmp_test_raw(stbi__context *s) 5109 5109 + static int stbi__bmp_test_raw(stbi__context* s) 4539 5110 { 4540 4540 - int r; 4541 4541 - int sz; 4542 4542 - if (stbi__get8(s) != 'B') return 0; 4543 4543 - if (stbi__get8(s) != 'M') return 0; 4544 4544 - stbi__get32le(s); // discard filesize 4545 4545 - stbi__get16le(s); // discard reserved 4546 4546 - stbi__get16le(s); // discard reserved 4547 4547 - stbi__get32le(s); // discard data offset 4548 4548 - sz = stbi__get32le(s); 4549 4549 - r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); 4550 4550 - return r; 5111 5111 + int r; 5112 5112 + int sz; 5113 5113 + if (stbi__get8(s) != 'B') return 0; 5114 5114 + if (stbi__get8(s) != 'M') return 0; 5115 5115 + stbi__get32le(s); // discard filesize 5116 5116 + stbi__get16le(s); // discard reserved 5117 5117 + stbi__get16le(s); // discard reserved 5118 5118 + stbi__get32le(s); // discard data offset 5119 5119 + sz = stbi__get32le(s); 5120 5120 + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); 5121 5121 + return r; 4551 5122 } 4552 5123 4553 4553 - static int stbi__bmp_test(stbi__context *s) 5124 5124 + static int stbi__bmp_test(stbi__context* s) 4554 5125 { 4555 4555 - int r = stbi__bmp_test_raw(s); 4556 4556 - stbi__rewind(s); 4557 4557 - return r; 5126 5126 + int r = stbi__bmp_test_raw(s); 5127 5127 + stbi__rewind(s); 5128 5128 + return r; 4558 5129 } 4559 5130 4560 5131 4561 5132 // returns 0..31 for the highest set bit 4562 5133 static int stbi__high_bit(unsigned int z) 4563 5134 { 4564 4564 - int n=0; 4565 4565 - if (z == 0) return -1; 4566 4566 - if (z >= 0x10000) n += 16, z >>= 16; 4567 4567 - if (z >= 0x00100) n += 8, z >>= 8; 4568 4568 - if (z >= 0x00010) n += 4, z >>= 4; 4569 4569 - if (z >= 0x00004) n += 2, z >>= 2; 4570 4570 - if (z >= 0x00002) n += 1, z >>= 1; 4571 4571 - return n; 5135 5135 + int n = 0; 5136 5136 + if (z == 0) return -1; 5137 5137 + if (z >= 0x10000) { n += 16; z >>= 16; } 5138 5138 + if (z >= 0x00100) { n += 8; z >>= 8; } 5139 5139 + if (z >= 0x00010) { n += 4; z >>= 4; } 5140 5140 + if (z >= 0x00004) { n += 2; z >>= 2; } 5141 5141 + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } 5142 5142 + return n; 4572 5143 } 4573 5144 4574 5145 static int stbi__bitcount(unsigned int a) 4575 5146 { 4576 4576 - a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 4577 4577 - a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 4578 4578 - a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits 4579 4579 - a = (a + (a >> 8)); // max 16 per 8 bits 4580 4580 - a = (a + (a >> 16)); // max 32 per 8 bits 4581 4581 - return a & 0xff; 5147 5147 + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 5148 5148 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 5149 5149 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits 5150 5150 + a = (a + (a >> 8)); // max 16 per 8 bits 5151 5151 + a = (a + (a >> 16)); // max 32 per 8 bits 5152 5152 + return a & 0xff; 4582 5153 } 4583 5154 4584 4584 - static int stbi__shiftsigned(int v, int shift, int bits) 5155 5155 + // extract an arbitrarily-aligned N-bit value (N=bits) 5156 5156 + // from v, and then make it 8-bits long and fractionally 5157 5157 + // extend it to full full range. 5158 5158 + static int stbi__shiftsigned(unsigned int v, int shift, int bits) 4585 5159 { 4586 4586 - int result; 4587 4587 - int z=0; 5160 5160 + static unsigned int mul_table[9] = { 5161 5161 + 0, 5162 5162 + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, 5163 5163 + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, 5164 5164 + }; 5165 5165 + static unsigned int shift_table[9] = { 5166 5166 + 0, 0,0,1,0,2,4,6,0, 5167 5167 + }; 5168 5168 + if (shift < 0) 5169 5169 + v <<= -shift; 5170 5170 + else 5171 5171 + v >>= shift; 5172 5172 + STBI_ASSERT(v >= 0 && v < 256); 5173 5173 + v >>= (8 - bits); 5174 5174 + STBI_ASSERT(bits >= 0 && bits <= 8); 5175 5175 + return (int)((unsigned)v * mul_table[bits]) >> shift_table[bits]; 5176 5176 + } 4588 5177 4589 4589 - if (shift < 0) v <<= -shift; 4590 4590 - else v >>= shift; 4591 4591 - result = v; 5178 5178 + typedef struct 5179 5179 + { 5180 5180 + int bpp, offset, hsz; 5181 5181 + unsigned int mr, mg, mb, ma, all_a; 5182 5182 + } stbi__bmp_data; 4592 5183 4593 4593 - z = bits; 4594 4594 - while (z < 8) { 4595 4595 - result += v >> z; 4596 4596 - z += bits; 4597 4597 - } 4598 4598 - return result; 5184 5184 + static void* stbi__bmp_parse_header(stbi__context* s, stbi__bmp_data* info) 5185 5185 + { 5186 5186 + int hsz; 5187 5187 + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); 5188 5188 + stbi__get32le(s); // discard filesize 5189 5189 + stbi__get16le(s); // discard reserved 5190 5190 + stbi__get16le(s); // discard reserved 5191 5191 + info->offset = stbi__get32le(s); 5192 5192 + info->hsz = hsz = stbi__get32le(s); 5193 5193 + info->mr = info->mg = info->mb = info->ma = 0; 5194 5194 + 5195 5195 + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); 5196 5196 + if (hsz == 12) { 5197 5197 + s->img_x = stbi__get16le(s); 5198 5198 + s->img_y = stbi__get16le(s); 5199 5199 + } 5200 5200 + else { 5201 5201 + s->img_x = stbi__get32le(s); 5202 5202 + s->img_y = stbi__get32le(s); 5203 5203 + } 5204 5204 + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); 5205 5205 + info->bpp = stbi__get16le(s); 5206 5206 + if (hsz != 12) { 5207 5207 + int compress = stbi__get32le(s); 5208 5208 + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); 5209 5209 + stbi__get32le(s); // discard sizeof 5210 5210 + stbi__get32le(s); // discard hres 5211 5211 + stbi__get32le(s); // discard vres 5212 5212 + stbi__get32le(s); // discard colorsused 5213 5213 + stbi__get32le(s); // discard max important 5214 5214 + if (hsz == 40 || hsz == 56) { 5215 5215 + if (hsz == 56) { 5216 5216 + stbi__get32le(s); 5217 5217 + stbi__get32le(s); 5218 5218 + stbi__get32le(s); 5219 5219 + stbi__get32le(s); 5220 5220 + } 5221 5221 + if (info->bpp == 16 || info->bpp == 32) { 5222 5222 + if (compress == 0) { 5223 5223 + if (info->bpp == 32) { 5224 5224 + info->mr = 0xffu << 16; 5225 5225 + info->mg = 0xffu << 8; 5226 5226 + info->mb = 0xffu << 0; 5227 5227 + info->ma = 0xffu << 24; 5228 5228 + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 5229 5229 + } 5230 5230 + else { 5231 5231 + info->mr = 31u << 10; 5232 5232 + info->mg = 31u << 5; 5233 5233 + info->mb = 31u << 0; 5234 5234 + } 5235 5235 + } 5236 5236 + else if (compress == 3) { 5237 5237 + info->mr = stbi__get32le(s); 5238 5238 + info->mg = stbi__get32le(s); 5239 5239 + info->mb = stbi__get32le(s); 5240 5240 + // not documented, but generated by photoshop and handled by mspaint 5241 5241 + if (info->mr == info->mg && info->mg == info->mb) { 5242 5242 + // ?!?!? 5243 5243 + return stbi__errpuc("bad BMP", "bad BMP"); 5244 5244 + } 5245 5245 + } 5246 5246 + else 5247 5247 + return stbi__errpuc("bad BMP", "bad BMP"); 5248 5248 + } 5249 5249 + } 5250 5250 + else { 5251 5251 + int i; 5252 5252 + if (hsz != 108 && hsz != 124) 5253 5253 + return stbi__errpuc("bad BMP", "bad BMP"); 5254 5254 + info->mr = stbi__get32le(s); 5255 5255 + info->mg = stbi__get32le(s); 5256 5256 + info->mb = stbi__get32le(s); 5257 5257 + info->ma = stbi__get32le(s); 5258 5258 + stbi__get32le(s); // discard color space 5259 5259 + for (i = 0; i < 12; ++i) 5260 5260 + stbi__get32le(s); // discard color space parameters 5261 5261 + if (hsz == 124) { 5262 5262 + stbi__get32le(s); // discard rendering intent 5263 5263 + stbi__get32le(s); // discard offset of profile data 5264 5264 + stbi__get32le(s); // discard size of profile data 5265 5265 + stbi__get32le(s); // discard reserved 5266 5266 + } 5267 5267 + } 5268 5268 + } 5269 5269 + return (void*)1; 4599 5270 } 4600 5271 4601 4601 - static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 5272 5272 + 5273 5273 + static void* stbi__bmp_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 4602 5274 { 4603 4603 - stbi_uc *out; 4604 4604 - unsigned int mr=0,mg=0,mb=0,ma=0, all_a=255; 4605 4605 - stbi_uc pal[256][4]; 4606 4606 - int psize=0,i,j,compress=0,width; 4607 4607 - int bpp, flip_vertically, pad, target, offset, hsz; 4608 4608 - if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); 4609 4609 - stbi__get32le(s); // discard filesize 4610 4610 - stbi__get16le(s); // discard reserved 4611 4611 - stbi__get16le(s); // discard reserved 4612 4612 - offset = stbi__get32le(s); 4613 4613 - hsz = stbi__get32le(s); 4614 4614 - if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); 4615 4615 - if (hsz == 12) { 4616 4616 - s->img_x = stbi__get16le(s); 4617 4617 - s->img_y = stbi__get16le(s); 4618 4618 - } else { 4619 4619 - s->img_x = stbi__get32le(s); 4620 4620 - s->img_y = stbi__get32le(s); 4621 4621 - } 4622 4622 - if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); 4623 4623 - bpp = stbi__get16le(s); 4624 4624 - if (bpp == 1) return stbi__errpuc("monochrome", "BMP type not supported: 1-bit"); 4625 4625 - flip_vertically = ((int) s->img_y) > 0; 4626 4626 - s->img_y = abs((int) s->img_y); 4627 4627 - if (hsz == 12) { 4628 4628 - if (bpp < 24) 4629 4629 - psize = (offset - 14 - 24) / 3; 4630 4630 - } else { 4631 4631 - compress = stbi__get32le(s); 4632 4632 - if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); 4633 4633 - stbi__get32le(s); // discard sizeof 4634 4634 - stbi__get32le(s); // discard hres 4635 4635 - stbi__get32le(s); // discard vres 4636 4636 - stbi__get32le(s); // discard colorsused 4637 4637 - stbi__get32le(s); // discard max important 4638 4638 - if (hsz == 40 || hsz == 56) { 4639 4639 - if (hsz == 56) { 4640 4640 - stbi__get32le(s); 4641 4641 - stbi__get32le(s); 4642 4642 - stbi__get32le(s); 4643 4643 - stbi__get32le(s); 4644 4644 - } 4645 4645 - if (bpp == 16 || bpp == 32) { 4646 4646 - mr = mg = mb = 0; 4647 4647 - if (compress == 0) { 4648 4648 - if (bpp == 32) { 4649 4649 - mr = 0xffu << 16; 4650 4650 - mg = 0xffu << 8; 4651 4651 - mb = 0xffu << 0; 4652 4652 - ma = 0xffu << 24; 4653 4653 - all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 4654 4654 - } else { 4655 4655 - mr = 31u << 10; 4656 4656 - mg = 31u << 5; 4657 4657 - mb = 31u << 0; 4658 4658 - } 4659 4659 - } else if (compress == 3) { 4660 4660 - mr = stbi__get32le(s); 4661 4661 - mg = stbi__get32le(s); 4662 4662 - mb = stbi__get32le(s); 4663 4663 - // not documented, but generated by photoshop and handled by mspaint 4664 4664 - if (mr == mg && mg == mb) { 4665 4665 - // ?!?!? 4666 4666 - return stbi__errpuc("bad BMP", "bad BMP"); 4667 4667 - } 4668 4668 - } else 4669 4669 - return stbi__errpuc("bad BMP", "bad BMP"); 4670 4670 - } 4671 4671 - } else { 4672 4672 - STBI_ASSERT(hsz == 108 || hsz == 124); 4673 4673 - mr = stbi__get32le(s); 4674 4674 - mg = stbi__get32le(s); 4675 4675 - mb = stbi__get32le(s); 4676 4676 - ma = stbi__get32le(s); 4677 4677 - stbi__get32le(s); // discard color space 4678 4678 - for (i=0; i < 12; ++i) 4679 4679 - stbi__get32le(s); // discard color space parameters 4680 4680 - if (hsz == 124) { 4681 4681 - stbi__get32le(s); // discard rendering intent 4682 4682 - stbi__get32le(s); // discard offset of profile data 4683 4683 - stbi__get32le(s); // discard size of profile data 4684 4684 - stbi__get32le(s); // discard reserved 4685 4685 - } 4686 4686 - } 4687 4687 - if (bpp < 16) 4688 4688 - psize = (offset - 14 - hsz) >> 2; 4689 4689 - } 4690 4690 - s->img_n = ma ? 4 : 3; 4691 4691 - if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 4692 4692 - target = req_comp; 4693 4693 - else 4694 4694 - target = s->img_n; // if they want monochrome, we'll post-convert 4695 4695 - out = (stbi_uc *) stbi__malloc(target * s->img_x * s->img_y); 4696 4696 - if (!out) return stbi__errpuc("outofmem", "Out of memory"); 4697 4697 - if (bpp < 16) { 4698 4698 - int z=0; 4699 4699 - if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } 4700 4700 - for (i=0; i < psize; ++i) { 4701 4701 - pal[i][2] = stbi__get8(s); 4702 4702 - pal[i][1] = stbi__get8(s); 4703 4703 - pal[i][0] = stbi__get8(s); 4704 4704 - if (hsz != 12) stbi__get8(s); 4705 4705 - pal[i][3] = 255; 4706 4706 - } 4707 4707 - stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); 4708 4708 - if (bpp == 4) width = (s->img_x + 1) >> 1; 4709 4709 - else if (bpp == 8) width = s->img_x; 4710 4710 - else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } 4711 4711 - pad = (-width)&3; 4712 4712 - for (j=0; j < (int) s->img_y; ++j) { 4713 4713 - for (i=0; i < (int) s->img_x; i += 2) { 4714 4714 - int v=stbi__get8(s),v2=0; 4715 4715 - if (bpp == 4) { 4716 4716 - v2 = v & 15; 4717 4717 - v >>= 4; 5275 5275 + stbi_uc* out; 5276 5276 + unsigned int mr = 0, mg = 0, mb = 0, ma = 0, all_a; 5277 5277 + stbi_uc pal[256][4]; 5278 5278 + int psize = 0, i, j, width; 5279 5279 + int flip_vertically, pad, target; 5280 5280 + stbi__bmp_data info; 5281 5281 + STBI_NOTUSED(ri); 5282 5282 + 5283 5283 + info.all_a = 255; 5284 5284 + if (stbi__bmp_parse_header(s, &info) == NULL) 5285 5285 + return NULL; // error code already set 5286 5286 + 5287 5287 + flip_vertically = ((int)s->img_y) > 0; 5288 5288 + s->img_y = abs((int)s->img_y); 5289 5289 + 5290 5290 + mr = info.mr; 5291 5291 + mg = info.mg; 5292 5292 + mb = info.mb; 5293 5293 + ma = info.ma; 5294 5294 + all_a = info.all_a; 5295 5295 + 5296 5296 + if (info.hsz == 12) { 5297 5297 + if (info.bpp < 24) 5298 5298 + psize = (info.offset - 14 - 24) / 3; 5299 5299 + } 5300 5300 + else { 5301 5301 + if (info.bpp < 16) 5302 5302 + psize = (info.offset - 14 - info.hsz) >> 2; 5303 5303 + } 5304 5304 + 5305 5305 + if (info.bpp == 24 && ma == 0xff000000) 5306 5306 + s->img_n = 3; 5307 5307 + else 5308 5308 + s->img_n = ma ? 4 : 3; 5309 5309 + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 5310 5310 + target = req_comp; 5311 5311 + else 5312 5312 + target = s->img_n; // if they want monochrome, we'll post-convert 5313 5313 + 5314 5314 + // sanity-check size 5315 5315 + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) 5316 5316 + return stbi__errpuc("too large", "Corrupt BMP"); 5317 5317 + 5318 5318 + out = (stbi_uc*)stbi__malloc_mad3(target, s->img_x, s->img_y, 0); 5319 5319 + if (!out) return stbi__errpuc("outofmem", "Out of memory"); 5320 5320 + if (info.bpp < 16) { 5321 5321 + int z = 0; 5322 5322 + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } 5323 5323 + for (i = 0; i < psize; ++i) { 5324 5324 + pal[i][2] = stbi__get8(s); 5325 5325 + pal[i][1] = stbi__get8(s); 5326 5326 + pal[i][0] = stbi__get8(s); 5327 5327 + if (info.hsz != 12) stbi__get8(s); 5328 5328 + pal[i][3] = 255; 5329 5329 + } 5330 5330 + stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); 5331 5331 + if (info.bpp == 1) width = (s->img_x + 7) >> 3; 5332 5332 + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; 5333 5333 + else if (info.bpp == 8) width = s->img_x; 5334 5334 + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } 5335 5335 + pad = (-width) & 3; 5336 5336 + if (info.bpp == 1) { 5337 5337 + for (j = 0; j < (int)s->img_y; ++j) { 5338 5338 + int bit_offset = 7, v = stbi__get8(s); 5339 5339 + for (i = 0; i < (int)s->img_x; ++i) { 5340 5340 + int color = (v >> bit_offset) & 0x1; 5341 5341 + out[z++] = pal[color][0]; 5342 5342 + out[z++] = pal[color][1]; 5343 5343 + out[z++] = pal[color][2]; 5344 5344 + if (target == 4) out[z++] = 255; 5345 5345 + if (i + 1 == (int)s->img_x) break; 5346 5346 + if ((--bit_offset) < 0) { 5347 5347 + bit_offset = 7; 5348 5348 + v = stbi__get8(s); 5349 5349 + } 5350 5350 + } 5351 5351 + stbi__skip(s, pad); 5352 5352 + } 5353 5353 + } 5354 5354 + else { 5355 5355 + for (j = 0; j < (int)s->img_y; ++j) { 5356 5356 + for (i = 0; i < (int)s->img_x; i += 2) { 5357 5357 + int v = stbi__get8(s), v2 = 0; 5358 5358 + if (info.bpp == 4) { 5359 5359 + v2 = v & 15; 5360 5360 + v >>= 4; 5361 5361 + } 5362 5362 + out[z++] = pal[v][0]; 5363 5363 + out[z++] = pal[v][1]; 5364 5364 + out[z++] = pal[v][2]; 5365 5365 + if (target == 4) out[z++] = 255; 5366 5366 + if (i + 1 == (int)s->img_x) break; 5367 5367 + v = (info.bpp == 8) ? stbi__get8(s) : v2; 5368 5368 + out[z++] = pal[v][0]; 5369 5369 + out[z++] = pal[v][1]; 5370 5370 + out[z++] = pal[v][2]; 5371 5371 + if (target == 4) out[z++] = 255; 5372 5372 + } 5373 5373 + stbi__skip(s, pad); 4718 5374 } 4719 4719 - out[z++] = pal[v][0]; 4720 4720 - out[z++] = pal[v][1]; 4721 4721 - out[z++] = pal[v][2]; 4722 4722 - if (target == 4) out[z++] = 255; 4723 4723 - if (i+1 == (int) s->img_x) break; 4724 4724 - v = (bpp == 8) ? stbi__get8(s) : v2; 4725 4725 - out[z++] = pal[v][0]; 4726 4726 - out[z++] = pal[v][1]; 4727 4727 - out[z++] = pal[v][2]; 4728 4728 - if (target == 4) out[z++] = 255; 4729 4729 - } 4730 4730 - stbi__skip(s, pad); 4731 4731 - } 4732 4732 - } else { 4733 4733 - int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; 4734 4734 - int z = 0; 4735 4735 - int easy=0; 4736 4736 - stbi__skip(s, offset - 14 - hsz); 4737 4737 - if (bpp == 24) width = 3 * s->img_x; 4738 4738 - else if (bpp == 16) width = 2*s->img_x; 4739 4739 - else /* bpp = 32 and pad = 0 */ width=0; 4740 4740 - pad = (-width) & 3; 4741 4741 - if (bpp == 24) { 4742 4742 - easy = 1; 4743 4743 - } else if (bpp == 32) { 4744 4744 - if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) 4745 4745 - easy = 2; 4746 4746 - } 4747 4747 - if (!easy) { 4748 4748 - if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } 4749 4749 - // right shift amt to put high bit in position #7 4750 4750 - rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); 4751 4751 - gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); 4752 4752 - bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); 4753 4753 - ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); 4754 4754 - } 4755 4755 - for (j=0; j < (int) s->img_y; ++j) { 4756 4756 - if (easy) { 4757 4757 - for (i=0; i < (int) s->img_x; ++i) { 4758 4758 - unsigned char a; 4759 4759 - out[z+2] = stbi__get8(s); 4760 4760 - out[z+1] = stbi__get8(s); 4761 4761 - out[z+0] = stbi__get8(s); 4762 4762 - z += 3; 4763 4763 - a = (easy == 2 ? stbi__get8(s) : 255); 4764 4764 - all_a |= a; 4765 4765 - if (target == 4) out[z++] = a; 5375 5375 + } 5376 5376 + } 5377 5377 + else { 5378 5378 + int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, gcount = 0, bcount = 0, acount = 0; 5379 5379 + int z = 0; 5380 5380 + int easy = 0; 5381 5381 + stbi__skip(s, info.offset - 14 - info.hsz); 5382 5382 + if (info.bpp == 24) width = 3 * s->img_x; 5383 5383 + else if (info.bpp == 16) width = 2 * s->img_x; 5384 5384 + else /* bpp = 32 and pad = 0 */ width = 0; 5385 5385 + pad = (-width) & 3; 5386 5386 + if (info.bpp == 24) { 5387 5387 + easy = 1; 5388 5388 + } 5389 5389 + else if (info.bpp == 32) { 5390 5390 + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) 5391 5391 + easy = 2; 5392 5392 + } 5393 5393 + if (!easy) { 5394 5394 + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } 5395 5395 + // right shift amt to put high bit in position #7 5396 5396 + rshift = stbi__high_bit(mr) - 7; rcount = stbi__bitcount(mr); 5397 5397 + gshift = stbi__high_bit(mg) - 7; gcount = stbi__bitcount(mg); 5398 5398 + bshift = stbi__high_bit(mb) - 7; bcount = stbi__bitcount(mb); 5399 5399 + ashift = stbi__high_bit(ma) - 7; acount = stbi__bitcount(ma); 5400 5400 + } 5401 5401 + for (j = 0; j < (int)s->img_y; ++j) { 5402 5402 + if (easy) { 5403 5403 + for (i = 0; i < (int)s->img_x; ++i) { 5404 5404 + unsigned char a; 5405 5405 + out[z + 2] = stbi__get8(s); 5406 5406 + out[z + 1] = stbi__get8(s); 5407 5407 + out[z + 0] = stbi__get8(s); 5408 5408 + z += 3; 5409 5409 + a = (easy == 2 ? stbi__get8(s) : 255); 5410 5410 + all_a |= a; 5411 5411 + if (target == 4) out[z++] = a; 5412 5412 + } 4766 5413 } 4767 4767 - } else { 4768 4768 - for (i=0; i < (int) s->img_x; ++i) { 4769 4769 - stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); 4770 4770 - int a; 4771 4771 - out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); 4772 4772 - out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); 4773 4773 - out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); 4774 4774 - a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); 4775 4775 - all_a |= a; 4776 4776 - if (target == 4) out[z++] = STBI__BYTECAST(a); 5414 5414 + else { 5415 5415 + int bpp = info.bpp; 5416 5416 + for (i = 0; i < (int)s->img_x; ++i) { 5417 5417 + stbi__uint32 v = (bpp == 16 ? (stbi__uint32)stbi__get16le(s) : stbi__get32le(s)); 5418 5418 + unsigned int a; 5419 5419 + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); 5420 5420 + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); 5421 5421 + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); 5422 5422 + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); 5423 5423 + all_a |= a; 5424 5424 + if (target == 4) out[z++] = STBI__BYTECAST(a); 5425 5425 + } 4777 5426 } 4778 4778 - } 4779 4779 - stbi__skip(s, pad); 4780 4780 - } 4781 4781 - } 4782 4782 - 4783 4783 - // if alpha channel is all 0s, replace with all 255s 4784 4784 - if (target == 4 && all_a == 0) 4785 4785 - for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) 4786 4786 - out[i] = 255; 5427 5427 + stbi__skip(s, pad); 5428 5428 + } 5429 5429 + } 4787 5430 4788 4788 - if (flip_vertically) { 4789 4789 - stbi_uc t; 4790 4790 - for (j=0; j < (int) s->img_y>>1; ++j) { 4791 4791 - stbi_uc *p1 = out + j *s->img_x*target; 4792 4792 - stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; 4793 4793 - for (i=0; i < (int) s->img_x*target; ++i) { 4794 4794 - t = p1[i], p1[i] = p2[i], p2[i] = t; 4795 4795 - } 4796 4796 - } 4797 4797 - } 5431 5431 + // if alpha channel is all 0s, replace with all 255s 5432 5432 + if (target == 4 && all_a == 0) 5433 5433 + for (i = 4 * s->img_x * s->img_y - 1; i >= 0; i -= 4) 5434 5434 + out[i] = 255; 4798 5435 4799 4799 - if (req_comp && req_comp != target) { 4800 4800 - out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); 4801 4801 - if (out == NULL) return out; // stbi__convert_format frees input on failure 4802 4802 - } 5436 5436 + if (flip_vertically) { 5437 5437 + stbi_uc t; 5438 5438 + for (j = 0; j < (int)s->img_y >> 1; ++j) { 5439 5439 + stbi_uc* p1 = out + j * s->img_x * target; 5440 5440 + stbi_uc* p2 = out + (s->img_y - 1 - j) * s->img_x * target; 5441 5441 + for (i = 0; i < (int)s->img_x * target; ++i) { 5442 5442 + t = p1[i]; p1[i] = p2[i]; p2[i] = t; 5443 5443 + } 5444 5444 + } 5445 5445 + } 4803 5446 4804 4804 - *x = s->img_x; 4805 4805 - *y = s->img_y; 4806 4806 - if (comp) *comp = s->img_n; 4807 4807 - return out; 5447 5447 + if (req_comp && req_comp != target) { 5448 5448 + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); 5449 5449 + if (out == NULL) return out; // stbi__convert_format frees input on failure 5450 5450 + } 5451 5451 + 5452 5452 + *x = s->img_x; 5453 5453 + *y = s->img_y; 5454 5454 + if (comp) *comp = s->img_n; 5455 5455 + return out; 4808 5456 } 4809 5457 #endif 4810 5458 4811 5459 // Targa Truevision - TGA 4812 5460 // by Jonathan Dummer 4813 5461 #ifndef STBI_NO_TGA 4814 4814 - static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) 5462 5462 + // returns STBI_rgb or whatever, 0 on error 5463 5463 + static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) 4815 5464 { 4816 4816 - int tga_w, tga_h, tga_comp; 4817 4817 - int sz; 5465 5465 + // only RGB or RGBA (incl. 16bit) or grey allowed 5466 5466 + if (is_rgb16) *is_rgb16 = 0; 5467 5467 + switch (bits_per_pixel) { 5468 5468 + case 8: return STBI_grey; 5469 5469 + case 16: if (is_grey) return STBI_grey_alpha; 5470 5470 + // fallthrough 5471 5471 + case 15: if (is_rgb16) *is_rgb16 = 1; 5472 5472 + return STBI_rgb; 5473 5473 + case 24: // fallthrough 5474 5474 + case 32: return bits_per_pixel / 8; 5475 5475 + default: return 0; 5476 5476 + } 5477 5477 + } 5478 5478 + 5479 5479 + static int stbi__tga_info(stbi__context* s, int* x, int* y, int* comp) 5480 5480 + { 5481 5481 + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; 5482 5482 + int sz, tga_colormap_type; 4818 5483 stbi__get8(s); // discard Offset 4819 4819 - sz = stbi__get8(s); // color type 4820 4820 - if( sz > 1 ) { 5484 5484 + tga_colormap_type = stbi__get8(s); // colormap type 5485 5485 + if (tga_colormap_type > 1) { 4821 5486 stbi__rewind(s); 4822 5487 return 0; // only RGB or indexed allowed 4823 5488 } 4824 4824 - sz = stbi__get8(s); // image type 4825 4825 - // only RGB or grey allowed, +/- RLE 4826 4826 - if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0; 4827 4827 - stbi__skip(s,9); 5489 5489 + tga_image_type = stbi__get8(s); // image type 5490 5490 + if (tga_colormap_type == 1) { // colormapped (paletted) image 5491 5491 + if (tga_image_type != 1 && tga_image_type != 9) { 5492 5492 + stbi__rewind(s); 5493 5493 + return 0; 5494 5494 + } 5495 5495 + stbi__skip(s, 4); // skip index of first colormap entry and number of entries 5496 5496 + sz = stbi__get8(s); // check bits per palette color entry 5497 5497 + if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) { 5498 5498 + stbi__rewind(s); 5499 5499 + return 0; 5500 5500 + } 5501 5501 + stbi__skip(s, 4); // skip image x and y origin 5502 5502 + tga_colormap_bpp = sz; 5503 5503 + } 5504 5504 + else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE 5505 5505 + if ((tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11)) { 5506 5506 + stbi__rewind(s); 5507 5507 + return 0; // only RGB or grey allowed, +/- RLE 5508 5508 + } 5509 5509 + stbi__skip(s, 9); // skip colormap specification and image x/y origin 5510 5510 + tga_colormap_bpp = 0; 5511 5511 + } 4828 5512 tga_w = stbi__get16le(s); 4829 4829 - if( tga_w < 1 ) { 5513 5513 + if (tga_w < 1) { 4830 5514 stbi__rewind(s); 4831 5515 return 0; // test width 4832 5516 } 4833 5517 tga_h = stbi__get16le(s); 4834 4834 - if( tga_h < 1 ) { 5518 5518 + if (tga_h < 1) { 4835 5519 stbi__rewind(s); 4836 5520 return 0; // test height 4837 5521 } 4838 4838 - sz = stbi__get8(s); // bits per pixel 4839 4839 - // only RGB or RGBA or grey allowed 4840 4840 - if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) { 5522 5522 + tga_bits_per_pixel = stbi__get8(s); // bits per pixel 5523 5523 + stbi__get8(s); // ignore alpha bits 5524 5524 + if (tga_colormap_bpp != 0) { 5525 5525 + if ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { 5526 5526 + // when using a colormap, tga_bits_per_pixel is the size of the indexes 5527 5527 + // I don't think anything but 8 or 16bit indexes makes sense 5528 5528 + stbi__rewind(s); 5529 5529 + return 0; 5530 5530 + } 5531 5531 + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); 5532 5532 + } 5533 5533 + else { 5534 5534 + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); 5535 5535 + } 5536 5536 + if (!tga_comp) { 4841 5537 stbi__rewind(s); 4842 5538 return 0; 4843 5539 } 4844 4844 - tga_comp = sz; 4845 5540 if (x) *x = tga_w; 4846 5541 if (y) *y = tga_h; 4847 4847 - if (comp) *comp = tga_comp / 8; 5542 5542 + if (comp) *comp = tga_comp; 4848 5543 return 1; // seems to have passed everything 4849 5544 } 4850 5545 4851 4851 - static int stbi__tga_test(stbi__context *s) 5546 5546 + static int stbi__tga_test(stbi__context* s) 4852 5547 { 4853 4853 - int res; 4854 4854 - int sz; 4855 4855 - stbi__get8(s); // discard Offset 4856 4856 - sz = stbi__get8(s); // color type 4857 4857 - if ( sz > 1 ) return 0; // only RGB or indexed allowed 4858 4858 - sz = stbi__get8(s); // image type 4859 4859 - if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE 4860 4860 - stbi__get16be(s); // discard palette start 4861 4861 - stbi__get16be(s); // discard palette length 4862 4862 - stbi__get8(s); // discard bits per palette color entry 4863 4863 - stbi__get16be(s); // discard x origin 4864 4864 - stbi__get16be(s); // discard y origin 4865 4865 - if ( stbi__get16be(s) < 1 ) return 0; // test width 4866 4866 - if ( stbi__get16be(s) < 1 ) return 0; // test height 4867 4867 - sz = stbi__get8(s); // bits per pixel 4868 4868 - if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) 4869 4869 - res = 0; 4870 4870 - else 4871 4871 - res = 1; 4872 4872 - stbi__rewind(s); 4873 4873 - return res; 5548 5548 + int res = 0; 5549 5549 + int sz, tga_color_type; 5550 5550 + stbi__get8(s); // discard Offset 5551 5551 + tga_color_type = stbi__get8(s); // color type 5552 5552 + if (tga_color_type > 1) goto errorEnd; // only RGB or indexed allowed 5553 5553 + sz = stbi__get8(s); // image type 5554 5554 + if (tga_color_type == 1) { // colormapped (paletted) image 5555 5555 + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 5556 5556 + stbi__skip(s, 4); // skip index of first colormap entry and number of entries 5557 5557 + sz = stbi__get8(s); // check bits per palette color entry 5558 5558 + if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) goto errorEnd; 5559 5559 + stbi__skip(s, 4); // skip image x and y origin 5560 5560 + } 5561 5561 + else { // "normal" image w/o colormap 5562 5562 + if ((sz != 2) && (sz != 3) && (sz != 10) && (sz != 11)) goto errorEnd; // only RGB or grey allowed, +/- RLE 5563 5563 + stbi__skip(s, 9); // skip colormap specification and image x/y origin 5564 5564 + } 5565 5565 + if (stbi__get16le(s) < 1) goto errorEnd; // test width 5566 5566 + if (stbi__get16le(s) < 1) goto errorEnd; // test height 5567 5567 + sz = stbi__get8(s); // bits per pixel 5568 5568 + if ((tga_color_type == 1) && (sz != 8) && (sz != 16)) goto errorEnd; // for colormapped images, bpp is size of an index 5569 5569 + if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) goto errorEnd; 5570 5570 + 5571 5571 + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 5572 5572 + 5573 5573 + errorEnd: 5574 5574 + stbi__rewind(s); 5575 5575 + return res; 4874 5576 } 4875 5577 4876 4876 - static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 5578 5578 + // read 16bit value and convert to 24bit RGB 5579 5579 + static void stbi__tga_read_rgb16(stbi__context* s, stbi_uc* out) 4877 5580 { 4878 4878 - // read in the TGA header stuff 4879 4879 - int tga_offset = stbi__get8(s); 4880 4880 - int tga_indexed = stbi__get8(s); 4881 4881 - int tga_image_type = stbi__get8(s); 4882 4882 - int tga_is_RLE = 0; 4883 4883 - int tga_palette_start = stbi__get16le(s); 4884 4884 - int tga_palette_len = stbi__get16le(s); 4885 4885 - int tga_palette_bits = stbi__get8(s); 4886 4886 - int tga_x_origin = stbi__get16le(s); 4887 4887 - int tga_y_origin = stbi__get16le(s); 4888 4888 - int tga_width = stbi__get16le(s); 4889 4889 - int tga_height = stbi__get16le(s); 4890 4890 - int tga_bits_per_pixel = stbi__get8(s); 4891 4891 - int tga_comp = tga_bits_per_pixel / 8; 4892 4892 - int tga_inverted = stbi__get8(s); 4893 4893 - // image data 4894 4894 - unsigned char *tga_data; 4895 4895 - unsigned char *tga_palette = NULL; 4896 4896 - int i, j; 4897 4897 - unsigned char raw_data[4]; 4898 4898 - int RLE_count = 0; 4899 4899 - int RLE_repeating = 0; 4900 4900 - int read_next_pixel = 1; 5581 5581 + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); 5582 5582 + stbi__uint16 fiveBitMask = 31; 5583 5583 + // we have 3 channels with 5bits each 5584 5584 + int r = (px >> 10)& fiveBitMask; 5585 5585 + int g = (px >> 5)& fiveBitMask; 5586 5586 + int b = px & fiveBitMask; 5587 5587 + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later 5588 5588 + out[0] = (stbi_uc)((r * 255) / 31); 5589 5589 + out[1] = (stbi_uc)((g * 255) / 31); 5590 5590 + out[2] = (stbi_uc)((b * 255) / 31); 4901 5591 4902 4902 - // do a tiny bit of precessing 4903 4903 - if ( tga_image_type >= 8 ) 4904 4904 - { 4905 4905 - tga_image_type -= 8; 4906 4906 - tga_is_RLE = 1; 4907 4907 - } 4908 4908 - /* int tga_alpha_bits = tga_inverted & 15; */ 4909 4909 - tga_inverted = 1 - ((tga_inverted >> 5) & 1); 5592 5592 + // some people claim that the most significant bit might be used for alpha 5593 5593 + // (possibly if an alpha-bit is set in the "image descriptor byte") 5594 5594 + // but that only made 16bit test images completely translucent.. 5595 5595 + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. 5596 5596 + } 5597 5597 + 5598 5598 + static void* stbi__tga_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 5599 5599 + { 5600 5600 + // read in the TGA header stuff 5601 5601 + int tga_offset = stbi__get8(s); 5602 5602 + int tga_indexed = stbi__get8(s); 5603 5603 + int tga_image_type = stbi__get8(s); 5604 5604 + int tga_is_RLE = 0; 5605 5605 + int tga_palette_start = stbi__get16le(s); 5606 5606 + int tga_palette_len = stbi__get16le(s); 5607 5607 + int tga_palette_bits = stbi__get8(s); 5608 5608 + int tga_x_origin = stbi__get16le(s); 5609 5609 + int tga_y_origin = stbi__get16le(s); 5610 5610 + int tga_width = stbi__get16le(s); 5611 5611 + int tga_height = stbi__get16le(s); 5612 5612 + int tga_bits_per_pixel = stbi__get8(s); 5613 5613 + int tga_comp, tga_rgb16 = 0; 5614 5614 + int tga_inverted = stbi__get8(s); 5615 5615 + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) 5616 5616 + // image data 5617 5617 + unsigned char* tga_data; 5618 5618 + unsigned char* tga_palette = NULL; 5619 5619 + int i, j; 5620 5620 + unsigned char raw_data[4] = { 0 }; 5621 5621 + int RLE_count = 0; 5622 5622 + int RLE_repeating = 0; 5623 5623 + int read_next_pixel = 1; 5624 5624 + STBI_NOTUSED(ri); 5625 5625 + STBI_NOTUSED(tga_x_origin); // @TODO 5626 5626 + STBI_NOTUSED(tga_y_origin); // @TODO 5627 5627 + 5628 5628 + // do a tiny bit of precessing 5629 5629 + if (tga_image_type >= 8) 5630 5630 + { 5631 5631 + tga_image_type -= 8; 5632 5632 + tga_is_RLE = 1; 5633 5633 + } 5634 5634 + tga_inverted = 1 - ((tga_inverted >> 5) & 1); 4910 5635 4911 4911 - // error check 4912 4912 - if ( //(tga_indexed) || 4913 4913 - (tga_width < 1) || (tga_height < 1) || 4914 4914 - (tga_image_type < 1) || (tga_image_type > 3) || 4915 4915 - ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) && 4916 4916 - (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32)) 4917 4917 - ) 4918 4918 - { 4919 4919 - return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA 4920 4920 - } 5636 5636 + // If I'm paletted, then I'll use the number of bits from the palette 5637 5637 + if (tga_indexed) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); 5638 5638 + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); 4921 5639 4922 4922 - // If I'm paletted, then I'll use the number of bits from the palette 4923 4923 - if ( tga_indexed ) 4924 4924 - { 4925 4925 - tga_comp = tga_palette_bits / 8; 4926 4926 - } 5640 5640 + if (!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency 5641 5641 + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); 4927 5642 4928 4928 - // tga info 4929 4929 - *x = tga_width; 4930 4930 - *y = tga_height; 4931 4931 - if (comp) *comp = tga_comp; 5643 5643 + // tga info 5644 5644 + *x = tga_width; 5645 5645 + *y = tga_height; 5646 5646 + if (comp) *comp = tga_comp; 5647 5647 + 5648 5648 + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) 5649 5649 + return stbi__errpuc("too large", "Corrupt TGA"); 4932 5650 4933 4933 - tga_data = (unsigned char*)stbi__malloc( (size_t)tga_width * tga_height * tga_comp ); 4934 4934 - if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); 5651 5651 + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); 5652 5652 + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); 4935 5653 4936 4936 - // skip to the data's starting position (offset usually = 0) 4937 4937 - stbi__skip(s, tga_offset ); 5654 5654 + // skip to the data's starting position (offset usually = 0) 5655 5655 + stbi__skip(s, tga_offset); 4938 5656 4939 4939 - if ( !tga_indexed && !tga_is_RLE) { 4940 4940 - for (i=0; i < tga_height; ++i) { 4941 4941 - int row = tga_inverted ? tga_height -i - 1 : i; 4942 4942 - stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; 4943 4943 - stbi__getn(s, tga_row, tga_width * tga_comp); 4944 4944 - } 4945 4945 - } else { 4946 4946 - // do I need to load a palette? 4947 4947 - if ( tga_indexed) 4948 4948 - { 4949 4949 - // any data to skip? (offset usually = 0) 4950 4950 - stbi__skip(s, tga_palette_start ); 4951 4951 - // load the palette 4952 4952 - tga_palette = (unsigned char*)stbi__malloc( tga_palette_len * tga_palette_bits / 8 ); 4953 4953 - if (!tga_palette) { 4954 4954 - STBI_FREE(tga_data); 4955 4955 - return stbi__errpuc("outofmem", "Out of memory"); 4956 4956 - } 4957 4957 - if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { 4958 4958 - STBI_FREE(tga_data); 4959 4959 - STBI_FREE(tga_palette); 4960 4960 - return stbi__errpuc("bad palette", "Corrupt TGA"); 4961 4961 - } 4962 4962 - } 4963 4963 - // load the data 4964 4964 - for (i=0; i < tga_width * tga_height; ++i) 4965 4965 - { 4966 4966 - // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? 4967 4967 - if ( tga_is_RLE ) 4968 4968 - { 4969 4969 - if ( RLE_count == 0 ) 5657 5657 + if (!tga_indexed && !tga_is_RLE && !tga_rgb16) { 5658 5658 + for (i = 0; i < tga_height; ++i) { 5659 5659 + int row = tga_inverted ? tga_height - i - 1 : i; 5660 5660 + stbi_uc* tga_row = tga_data + row * tga_width * tga_comp; 5661 5661 + stbi__getn(s, tga_row, tga_width * tga_comp); 5662 5662 + } 5663 5663 + } 5664 5664 + else { 5665 5665 + // do I need to load a palette? 5666 5666 + if (tga_indexed) 5667 5667 + { 5668 5668 + // any data to skip? (offset usually = 0) 5669 5669 + stbi__skip(s, tga_palette_start); 5670 5670 + // load the palette 5671 5671 + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); 5672 5672 + if (!tga_palette) { 5673 5673 + STBI_FREE(tga_data); 5674 5674 + return stbi__errpuc("outofmem", "Out of memory"); 5675 5675 + } 5676 5676 + if (tga_rgb16) { 5677 5677 + stbi_uc* pal_entry = tga_palette; 5678 5678 + STBI_ASSERT(tga_comp == STBI_rgb); 5679 5679 + for (i = 0; i < tga_palette_len; ++i) { 5680 5680 + stbi__tga_read_rgb16(s, pal_entry); 5681 5681 + pal_entry += tga_comp; 5682 5682 + } 5683 5683 + } 5684 5684 + else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { 5685 5685 + STBI_FREE(tga_data); 5686 5686 + STBI_FREE(tga_palette); 5687 5687 + return stbi__errpuc("bad palette", "Corrupt TGA"); 5688 5688 + } 5689 5689 + } 5690 5690 + // load the data 5691 5691 + for (i = 0; i < tga_width * tga_height; ++i) 5692 5692 + { 5693 5693 + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? 5694 5694 + if (tga_is_RLE) 4970 5695 { 4971 4971 - // yep, get the next byte as a RLE command 4972 4972 - int RLE_cmd = stbi__get8(s); 4973 4973 - RLE_count = 1 + (RLE_cmd & 127); 4974 4974 - RLE_repeating = RLE_cmd >> 7; 4975 4975 - read_next_pixel = 1; 4976 4976 - } else if ( !RLE_repeating ) 5696 5696 + if (RLE_count == 0) 5697 5697 + { 5698 5698 + // yep, get the next byte as a RLE command 5699 5699 + int RLE_cmd = stbi__get8(s); 5700 5700 + RLE_count = 1 + (RLE_cmd & 127); 5701 5701 + RLE_repeating = RLE_cmd >> 7; 5702 5702 + read_next_pixel = 1; 5703 5703 + } 5704 5704 + else if (!RLE_repeating) 5705 5705 + { 5706 5706 + read_next_pixel = 1; 5707 5707 + } 5708 5708 + } 5709 5709 + else 4977 5710 { 4978 4978 - read_next_pixel = 1; 5711 5711 + read_next_pixel = 1; 4979 5712 } 4980 4980 - } else 4981 4981 - { 4982 4982 - read_next_pixel = 1; 4983 4983 - } 4984 4984 - // OK, if I need to read a pixel, do it now 4985 4985 - if ( read_next_pixel ) 4986 4986 - { 4987 4987 - // load however much data we did have 4988 4988 - if ( tga_indexed ) 5713 5713 + // OK, if I need to read a pixel, do it now 5714 5714 + if (read_next_pixel) 4989 5715 { 4990 4990 - // read in 1 byte, then perform the lookup 4991 4991 - int pal_idx = stbi__get8(s); 4992 4992 - if ( pal_idx >= tga_palette_len ) 4993 4993 - { 4994 4994 - // invalid index 4995 4995 - pal_idx = 0; 4996 4996 - } 4997 4997 - pal_idx *= tga_bits_per_pixel / 8; 4998 4998 - for (j = 0; j*8 < tga_bits_per_pixel; ++j) 4999 4999 - { 5000 5000 - raw_data[j] = tga_palette[pal_idx+j]; 5001 5001 - } 5002 5002 - } else 5003 5003 - { 5004 5004 - // read in the data raw 5005 5005 - for (j = 0; j*8 < tga_bits_per_pixel; ++j) 5006 5006 - { 5007 5007 - raw_data[j] = stbi__get8(s); 5008 5008 - } 5009 5009 - } 5010 5010 - // clear the reading flag for the next pixel 5011 5011 - read_next_pixel = 0; 5012 5012 - } // end of reading a pixel 5716 5716 + // load however much data we did have 5717 5717 + if (tga_indexed) 5718 5718 + { 5719 5719 + // read in index, then perform the lookup 5720 5720 + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); 5721 5721 + if (pal_idx >= tga_palette_len) { 5722 5722 + // invalid index 5723 5723 + pal_idx = 0; 5724 5724 + } 5725 5725 + pal_idx *= tga_comp; 5726 5726 + for (j = 0; j < tga_comp; ++j) { 5727 5727 + raw_data[j] = tga_palette[pal_idx + j]; 5728 5728 + } 5729 5729 + } 5730 5730 + else if (tga_rgb16) { 5731 5731 + STBI_ASSERT(tga_comp == STBI_rgb); 5732 5732 + stbi__tga_read_rgb16(s, raw_data); 5733 5733 + } 5734 5734 + else { 5735 5735 + // read in the data raw 5736 5736 + for (j = 0; j < tga_comp; ++j) { 5737 5737 + raw_data[j] = stbi__get8(s); 5738 5738 + } 5739 5739 + } 5740 5740 + // clear the reading flag for the next pixel 5741 5741 + read_next_pixel = 0; 5742 5742 + } // end of reading a pixel 5013 5743 5014 5014 - // copy data 5015 5015 - for (j = 0; j < tga_comp; ++j) 5016 5016 - tga_data[i*tga_comp+j] = raw_data[j]; 5744 5744 + // copy data 5745 5745 + for (j = 0; j < tga_comp; ++j) 5746 5746 + tga_data[i * tga_comp + j] = raw_data[j]; 5017 5747 5018 5018 - // in case we're in RLE mode, keep counting down 5019 5019 - --RLE_count; 5020 5020 - } 5021 5021 - // do I need to invert the image? 5022 5022 - if ( tga_inverted ) 5023 5023 - { 5024 5024 - for (j = 0; j*2 < tga_height; ++j) 5025 5025 - { 5026 5026 - int index1 = j * tga_width * tga_comp; 5027 5027 - int index2 = (tga_height - 1 - j) * tga_width * tga_comp; 5028 5028 - for (i = tga_width * tga_comp; i > 0; --i) 5748 5748 + // in case we're in RLE mode, keep counting down 5749 5749 + --RLE_count; 5750 5750 + } 5751 5751 + // do I need to invert the image? 5752 5752 + if (tga_inverted) 5753 5753 + { 5754 5754 + for (j = 0; j * 2 < tga_height; ++j) 5029 5755 { 5030 5030 - unsigned char temp = tga_data[index1]; 5031 5031 - tga_data[index1] = tga_data[index2]; 5032 5032 - tga_data[index2] = temp; 5033 5033 - ++index1; 5034 5034 - ++index2; 5756 5756 + int index1 = j * tga_width * tga_comp; 5757 5757 + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; 5758 5758 + for (i = tga_width * tga_comp; i > 0; --i) 5759 5759 + { 5760 5760 + unsigned char temp = tga_data[index1]; 5761 5761 + tga_data[index1] = tga_data[index2]; 5762 5762 + tga_data[index2] = temp; 5763 5763 + ++index1; 5764 5764 + ++index2; 5765 5765 + } 5035 5766 } 5036 5036 - } 5037 5037 - } 5038 5038 - // clear my palette, if I had one 5039 5039 - if ( tga_palette != NULL ) 5040 5040 - { 5041 5041 - STBI_FREE( tga_palette ); 5042 5042 - } 5043 5043 - } 5767 5767 + } 5768 5768 + // clear my palette, if I had one 5769 5769 + if (tga_palette != NULL) 5770 5770 + { 5771 5771 + STBI_FREE(tga_palette); 5772 5772 + } 5773 5773 + } 5044 5774 5045 5045 - // swap RGB 5046 5046 - if (tga_comp >= 3) 5047 5047 - { 5048 5048 - unsigned char* tga_pixel = tga_data; 5049 5049 - for (i=0; i < tga_width * tga_height; ++i) 5050 5050 - { 5051 5051 - unsigned char temp = tga_pixel[0]; 5052 5052 - tga_pixel[0] = tga_pixel[2]; 5053 5053 - tga_pixel[2] = temp; 5054 5054 - tga_pixel += tga_comp; 5055 5055 - } 5056 5056 - } 5775 5775 + // swap RGB - if the source data was RGB16, it already is in the right order 5776 5776 + if (tga_comp >= 3 && !tga_rgb16) 5777 5777 + { 5778 5778 + unsigned char* tga_pixel = tga_data; 5779 5779 + for (i = 0; i < tga_width * tga_height; ++i) 5780 5780 + { 5781 5781 + unsigned char temp = tga_pixel[0]; 5782 5782 + tga_pixel[0] = tga_pixel[2]; 5783 5783 + tga_pixel[2] = temp; 5784 5784 + tga_pixel += tga_comp; 5785 5785 + } 5786 5786 + } 5057 5787 5058 5058 - // convert to target component count 5059 5059 - if (req_comp && req_comp != tga_comp) 5060 5060 - tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); 5788 5788 + // convert to target component count 5789 5789 + if (req_comp && req_comp != tga_comp) 5790 5790 + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); 5061 5791 5062 5062 - // the things I do to get rid of an error message, and yet keep 5063 5063 - // Microsoft's C compilers happy... [8^( 5064 5064 - tga_palette_start = tga_palette_len = tga_palette_bits = 5065 5065 - tga_x_origin = tga_y_origin = 0; 5066 5066 - // OK, done 5067 5067 - return tga_data; 5792 5792 + // the things I do to get rid of an error message, and yet keep 5793 5793 + // Microsoft's C compilers happy... [8^( 5794 5794 + tga_palette_start = tga_palette_len = tga_palette_bits = 5795 5795 + tga_x_origin = tga_y_origin = 0; 5796 5796 + STBI_NOTUSED(tga_palette_start); 5797 5797 + // OK, done 5798 5798 + return tga_data; 5068 5799 } 5069 5800 #endif 5070 5801 ··· 5072 5803 // Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB 5073 5804 5074 5805 #ifndef STBI_NO_PSD 5075 5075 - static int stbi__psd_test(stbi__context *s) 5806 5806 + static int stbi__psd_test(stbi__context* s) 5076 5807 { 5077 5077 - int r = (stbi__get32be(s) == 0x38425053); 5078 5078 - stbi__rewind(s); 5079 5079 - return r; 5808 5808 + int r = (stbi__get32be(s) == 0x38425053); 5809 5809 + stbi__rewind(s); 5810 5810 + return r; 5811 5811 + } 5812 5812 + 5813 5813 + static int stbi__psd_decode_rle(stbi__context* s, stbi_uc* p, int pixelCount) 5814 5814 + { 5815 5815 + int count, nleft, len; 5816 5816 + 5817 5817 + count = 0; 5818 5818 + while ((nleft = pixelCount - count) > 0) { 5819 5819 + len = stbi__get8(s); 5820 5820 + if (len == 128) { 5821 5821 + // No-op. 5822 5822 + } 5823 5823 + else if (len < 128) { 5824 5824 + // Copy next len+1 bytes literally. 5825 5825 + len++; 5826 5826 + if (len > nleft) return 0; // corrupt data 5827 5827 + count += len; 5828 5828 + while (len) { 5829 5829 + *p = stbi__get8(s); 5830 5830 + p += 4; 5831 5831 + len--; 5832 5832 + } 5833 5833 + } 5834 5834 + else if (len > 128) { 5835 5835 + stbi_uc val; 5836 5836 + // Next -len+1 bytes in the dest are replicated from next source byte. 5837 5837 + // (Interpret len as a negative 8-bit int.) 5838 5838 + len = 257 - len; 5839 5839 + if (len > nleft) return 0; // corrupt data 5840 5840 + val = stbi__get8(s); 5841 5841 + count += len; 5842 5842 + while (len) { 5843 5843 + *p = val; 5844 5844 + p += 4; 5845 5845 + len--; 5846 5846 + } 5847 5847 + } 5848 5848 + } 5849 5849 + 5850 5850 + return 1; 5080 5851 } 5081 5852 5082 5082 - static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 5853 5853 + static void* stbi__psd_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri, int bpc) 5083 5854 { 5084 5084 - int pixelCount; 5085 5085 - int channelCount, compression; 5086 5086 - int channel, i, count, len; 5087 5087 - int bitdepth; 5088 5088 - int w,h; 5089 5089 - stbi_uc *out; 5855 5855 + int pixelCount; 5856 5856 + int channelCount, compression; 5857 5857 + int channel, i; 5858 5858 + int bitdepth; 5859 5859 + int w, h; 5860 5860 + stbi_uc* out; 5861 5861 + STBI_NOTUSED(ri); 5090 5862 5091 5091 - // Check identifier 5092 5092 - if (stbi__get32be(s) != 0x38425053) // "8BPS" 5093 5093 - return stbi__errpuc("not PSD", "Corrupt PSD image"); 5863 5863 + // Check identifier 5864 5864 + if (stbi__get32be(s) != 0x38425053) // "8BPS" 5865 5865 + return stbi__errpuc("not PSD", "Corrupt PSD image"); 5094 5866 5095 5095 - // Check file type version. 5096 5096 - if (stbi__get16be(s) != 1) 5097 5097 - return stbi__errpuc("wrong version", "Unsupported version of PSD image"); 5867 5867 + // Check file type version. 5868 5868 + if (stbi__get16be(s) != 1) 5869 5869 + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); 5098 5870 5099 5099 - // Skip 6 reserved bytes. 5100 5100 - stbi__skip(s, 6 ); 5871 5871 + // Skip 6 reserved bytes. 5872 5872 + stbi__skip(s, 6); 5101 5873 5102 5102 - // Read the number of channels (R, G, B, A, etc). 5103 5103 - channelCount = stbi__get16be(s); 5104 5104 - if (channelCount < 0 || channelCount > 16) 5105 5105 - return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); 5874 5874 + // Read the number of channels (R, G, B, A, etc). 5875 5875 + channelCount = stbi__get16be(s); 5876 5876 + if (channelCount < 0 || channelCount > 16) 5877 5877 + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); 5106 5878 5107 5107 - // Read the rows and columns of the image. 5108 5108 - h = stbi__get32be(s); 5109 5109 - w = stbi__get32be(s); 5879 5879 + // Read the rows and columns of the image. 5880 5880 + h = stbi__get32be(s); 5881 5881 + w = stbi__get32be(s); 5110 5882 5111 5111 - // Make sure the depth is 8 bits. 5112 5112 - bitdepth = stbi__get16be(s); 5113 5113 - if (bitdepth != 8 && bitdepth != 16) 5114 5114 - return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); 5883 5883 + // Make sure the depth is 8 bits. 5884 5884 + bitdepth = stbi__get16be(s); 5885 5885 + if (bitdepth != 8 && bitdepth != 16) 5886 5886 + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); 5115 5887 5116 5116 - // Make sure the color mode is RGB. 5117 5117 - // Valid options are: 5118 5118 - // 0: Bitmap 5119 5119 - // 1: Grayscale 5120 5120 - // 2: Indexed color 5121 5121 - // 3: RGB color 5122 5122 - // 4: CMYK color 5123 5123 - // 7: Multichannel 5124 5124 - // 8: Duotone 5125 5125 - // 9: Lab color 5126 5126 - if (stbi__get16be(s) != 3) 5127 5127 - return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); 5888 5888 + // Make sure the color mode is RGB. 5889 5889 + // Valid options are: 5890 5890 + // 0: Bitmap 5891 5891 + // 1: Grayscale 5892 5892 + // 2: Indexed color 5893 5893 + // 3: RGB color 5894 5894 + // 4: CMYK color 5895 5895 + // 7: Multichannel 5896 5896 + // 8: Duotone 5897 5897 + // 9: Lab color 5898 5898 + if (stbi__get16be(s) != 3) 5899 5899 + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); 5900 5900 + 5901 5901 + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) 5902 5902 + stbi__skip(s, stbi__get32be(s)); 5903 5903 + 5904 5904 + // Skip the image resources. (resolution, pen tool paths, etc) 5905 5905 + stbi__skip(s, stbi__get32be(s)); 5906 5906 + 5907 5907 + // Skip the reserved data. 5908 5908 + stbi__skip(s, stbi__get32be(s)); 5128 5909 5129 5129 - // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) 5130 5130 - stbi__skip(s,stbi__get32be(s) ); 5910 5910 + // Find out if the data is compressed. 5911 5911 + // Known values: 5912 5912 + // 0: no compression 5913 5913 + // 1: RLE compressed 5914 5914 + compression = stbi__get16be(s); 5915 5915 + if (compression > 1) 5916 5916 + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); 5131 5917 5132 5132 - // Skip the image resources. (resolution, pen tool paths, etc) 5133 5133 - stbi__skip(s, stbi__get32be(s) ); 5918 5918 + // Check size 5919 5919 + if (!stbi__mad3sizes_valid(4, w, h, 0)) 5920 5920 + return stbi__errpuc("too large", "Corrupt PSD"); 5134 5921 5135 5135 - // Skip the reserved data. 5136 5136 - stbi__skip(s, stbi__get32be(s) ); 5922 5922 + // Create the destination image. 5137 5923 5138 5138 - // Find out if the data is compressed. 5139 5139 - // Known values: 5140 5140 - // 0: no compression 5141 5141 - // 1: RLE compressed 5142 5142 - compression = stbi__get16be(s); 5143 5143 - if (compression > 1) 5144 5144 - return stbi__errpuc("bad compression", "PSD has an unknown compression format"); 5924 5924 + if (!compression && bitdepth == 16 && bpc == 16) { 5925 5925 + out = (stbi_uc*)stbi__malloc_mad3(8, w, h, 0); 5926 5926 + ri->bits_per_channel = 16; 5927 5927 + } 5928 5928 + else 5929 5929 + out = (stbi_uc*)stbi__malloc(4 * w * h); 5145 5930 5146 5146 - // Create the destination image. 5147 5147 - out = (stbi_uc *) stbi__malloc(4 * w*h); 5148 5148 - if (!out) return stbi__errpuc("outofmem", "Out of memory"); 5149 5149 - pixelCount = w*h; 5931 5931 + if (!out) return stbi__errpuc("outofmem", "Out of memory"); 5932 5932 + pixelCount = w * h; 5150 5933 5151 5151 - // Initialize the data to zero. 5152 5152 - //memset( out, 0, pixelCount * 4 ); 5934 5934 + // Initialize the data to zero. 5935 5935 + //memset( out, 0, pixelCount * 4 ); 5153 5936 5154 5154 - // Finally, the image data. 5155 5155 - if (compression) { 5156 5156 - // RLE as used by .PSD and .TIFF 5157 5157 - // Loop until you get the number of unpacked bytes you are expecting: 5158 5158 - // Read the next source byte into n. 5159 5159 - // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. 5160 5160 - // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. 5161 5161 - // Else if n is 128, noop. 5162 5162 - // Endloop 5937 5937 + // Finally, the image data. 5938 5938 + if (compression) { 5939 5939 + // RLE as used by .PSD and .TIFF 5940 5940 + // Loop until you get the number of unpacked bytes you are expecting: 5941 5941 + // Read the next source byte into n. 5942 5942 + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. 5943 5943 + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. 5944 5944 + // Else if n is 128, noop. 5945 5945 + // Endloop 5163 5946 5164 5164 - // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, 5165 5165 - // which we're going to just skip. 5166 5166 - stbi__skip(s, h * channelCount * 2 ); 5947 5947 + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, 5948 5948 + // which we're going to just skip. 5949 5949 + stbi__skip(s, h * channelCount * 2); 5167 5950 5168 5168 - // Read the RLE data by channel. 5169 5169 - for (channel = 0; channel < 4; channel++) { 5170 5170 - stbi_uc *p; 5951 5951 + // Read the RLE data by channel. 5952 5952 + for (channel = 0; channel < 4; channel++) { 5953 5953 + stbi_uc* p; 5171 5954 5172 5172 - p = out+channel; 5173 5173 - if (channel >= channelCount) { 5174 5174 - // Fill this channel with default data. 5175 5175 - for (i = 0; i < pixelCount; i++, p += 4) 5176 5176 - *p = (channel == 3 ? 255 : 0); 5177 5177 - } else { 5178 5178 - // Read the RLE data. 5179 5179 - count = 0; 5180 5180 - while (count < pixelCount) { 5181 5181 - len = stbi__get8(s); 5182 5182 - if (len == 128) { 5183 5183 - // No-op. 5184 5184 - } else if (len < 128) { 5185 5185 - // Copy next len+1 bytes literally. 5186 5186 - len++; 5187 5187 - count += len; 5188 5188 - while (len) { 5189 5189 - *p = stbi__get8(s); 5190 5190 - p += 4; 5191 5191 - len--; 5192 5192 - } 5193 5193 - } else if (len > 128) { 5194 5194 - stbi_uc val; 5195 5195 - // Next -len+1 bytes in the dest are replicated from next source byte. 5196 5196 - // (Interpret len as a negative 8-bit int.) 5197 5197 - len ^= 0x0FF; 5198 5198 - len += 2; 5199 5199 - val = stbi__get8(s); 5200 5200 - count += len; 5201 5201 - while (len) { 5202 5202 - *p = val; 5203 5203 - p += 4; 5204 5204 - len--; 5205 5205 - } 5206 5206 - } 5955 5955 + p = out + channel; 5956 5956 + if (channel >= channelCount) { 5957 5957 + // Fill this channel with default data. 5958 5958 + for (i = 0; i < pixelCount; i++, p += 4) 5959 5959 + *p = (channel == 3 ? 255 : 0); 5960 5960 + } 5961 5961 + else { 5962 5962 + // Read the RLE data. 5963 5963 + if (!stbi__psd_decode_rle(s, p, pixelCount)) { 5964 5964 + STBI_FREE(out); 5965 5965 + return stbi__errpuc("corrupt", "bad RLE data"); 5966 5966 + } 5207 5967 } 5208 5208 - } 5209 5209 - } 5968 5968 + } 5210 5969 5211 5211 - } else { 5212 5212 - // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) 5213 5213 - // where each channel consists of an 8-bit value for each pixel in the image. 5970 5970 + } 5971 5971 + else { 5972 5972 + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) 5973 5973 + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. 5214 5974 5215 5215 - // Read the data by channel. 5216 5216 - for (channel = 0; channel < 4; channel++) { 5217 5217 - stbi_uc *p; 5975 5975 + // Read the data by channel. 5976 5976 + for (channel = 0; channel < 4; channel++) { 5977 5977 + if (channel >= channelCount) { 5978 5978 + // Fill this channel with default data. 5979 5979 + if (bitdepth == 16 && bpc == 16) { 5980 5980 + stbi__uint16* q = ((stbi__uint16*)out) + channel; 5981 5981 + stbi__uint16 val = channel == 3 ? 65535 : 0; 5982 5982 + for (i = 0; i < pixelCount; i++, q += 4) 5983 5983 + *q = val; 5984 5984 + } 5985 5985 + else { 5986 5986 + stbi_uc* p = out + channel; 5987 5987 + stbi_uc val = channel == 3 ? 255 : 0; 5988 5988 + for (i = 0; i < pixelCount; i++, p += 4) 5989 5989 + *p = val; 5990 5990 + } 5991 5991 + } 5992 5992 + else { 5993 5993 + if (ri->bits_per_channel == 16) { // output bpc 5994 5994 + stbi__uint16* q = ((stbi__uint16*)out) + channel; 5995 5995 + for (i = 0; i < pixelCount; i++, q += 4) 5996 5996 + *q = (stbi__uint16)stbi__get16be(s); 5997 5997 + } 5998 5998 + else { 5999 5999 + stbi_uc* p = out + channel; 6000 6000 + if (bitdepth == 16) { // input bpc 6001 6001 + for (i = 0; i < pixelCount; i++, p += 4) 6002 6002 + *p = (stbi_uc)(stbi__get16be(s) >> 8); 6003 6003 + } 6004 6004 + else { 6005 6005 + for (i = 0; i < pixelCount; i++, p += 4) 6006 6006 + *p = stbi__get8(s); 6007 6007 + } 6008 6008 + } 6009 6009 + } 6010 6010 + } 6011 6011 + } 5218 6012 5219 5219 - p = out + channel; 5220 5220 - if (channel >= channelCount) { 5221 5221 - // Fill this channel with default data. 5222 5222 - stbi_uc val = channel == 3 ? 255 : 0; 5223 5223 - for (i = 0; i < pixelCount; i++, p += 4) 5224 5224 - *p = val; 5225 5225 - } else { 5226 5226 - // Read the data. 5227 5227 - if (bitdepth == 16) { 5228 5228 - for (i = 0; i < pixelCount; i++, p += 4) 5229 5229 - *p = (stbi_uc) (stbi__get16be(s) >> 8); 5230 5230 - } else { 5231 5231 - for (i = 0; i < pixelCount; i++, p += 4) 5232 5232 - *p = stbi__get8(s); 6013 6013 + // remove weird white matte from PSD 6014 6014 + if (channelCount >= 4) { 6015 6015 + if (ri->bits_per_channel == 16) { 6016 6016 + for (i = 0; i < w * h; ++i) { 6017 6017 + stbi__uint16* pixel = (stbi__uint16*)out + 4 * i; 6018 6018 + if (pixel[3] != 0 && pixel[3] != 65535) { 6019 6019 + float a = pixel[3] / 65535.0f; 6020 6020 + float ra = 1.0f / a; 6021 6021 + float inv_a = 65535.0f * (1 - ra); 6022 6022 + pixel[0] = (stbi__uint16)(pixel[0] * ra + inv_a); 6023 6023 + pixel[1] = (stbi__uint16)(pixel[1] * ra + inv_a); 6024 6024 + pixel[2] = (stbi__uint16)(pixel[2] * ra + inv_a); 6025 6025 + } 6026 6026 + } 6027 6027 + } 6028 6028 + else { 6029 6029 + for (i = 0; i < w * h; ++i) { 6030 6030 + unsigned char* pixel = out + 4 * i; 6031 6031 + if (pixel[3] != 0 && pixel[3] != 255) { 6032 6032 + float a = pixel[3] / 255.0f; 6033 6033 + float ra = 1.0f / a; 6034 6034 + float inv_a = 255.0f * (1 - ra); 6035 6035 + pixel[0] = (unsigned char)(pixel[0] * ra + inv_a); 6036 6036 + pixel[1] = (unsigned char)(pixel[1] * ra + inv_a); 6037 6037 + pixel[2] = (unsigned char)(pixel[2] * ra + inv_a); 6038 6038 + } 5233 6039 } 5234 5234 - } 5235 5235 - } 5236 5236 - } 6040 6040 + } 6041 6041 + } 5237 6042 5238 5238 - if (req_comp && req_comp != 4) { 5239 5239 - out = stbi__convert_format(out, 4, req_comp, w, h); 5240 5240 - if (out == NULL) return out; // stbi__convert_format frees input on failure 5241 5241 - } 6043 6043 + // convert to desired output format 6044 6044 + if (req_comp && req_comp != 4) { 6045 6045 + if (ri->bits_per_channel == 16) 6046 6046 + out = (stbi_uc*)stbi__convert_format16((stbi__uint16*)out, 4, req_comp, w, h); 6047 6047 + else 6048 6048 + out = stbi__convert_format(out, 4, req_comp, w, h); 6049 6049 + if (out == NULL) return out; // stbi__convert_format frees input on failure 6050 6050 + } 5242 6051 5243 5243 - if (comp) *comp = 4; 5244 5244 - *y = h; 5245 5245 - *x = w; 6052 6052 + if (comp) *comp = 4; 6053 6053 + *y = h; 6054 6054 + *x = w; 5246 6055 5247 5247 - return out; 6056 6056 + return out; 5248 6057 } 5249 6058 #endif 5250 6059 ··· 5256 6065 // See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ 5257 6066 5258 6067 #ifndef STBI_NO_PIC 5259 5259 - static int stbi__pic_is4(stbi__context *s,const char *str) 6068 6068 + static int stbi__pic_is4(stbi__context* s, const char* str) 5260 6069 { 5261 5261 - int i; 5262 5262 - for (i=0; i<4; ++i) 5263 5263 - if (stbi__get8(s) != (stbi_uc)str[i]) 5264 5264 - return 0; 6070 6070 + int i; 6071 6071 + for (i = 0; i < 4; ++i) 6072 6072 + if (stbi__get8(s) != (stbi_uc)str[i]) 6073 6073 + return 0; 5265 6074 5266 5266 - return 1; 6075 6075 + return 1; 5267 6076 } 5268 6077 5269 5269 - static int stbi__pic_test_core(stbi__context *s) 6078 6078 + static int stbi__pic_test_core(stbi__context* s) 5270 6079 { 5271 5271 - int i; 6080 6080 + int i; 5272 6081 5273 5273 - if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) 5274 5274 - return 0; 6082 6082 + if (!stbi__pic_is4(s, "\x53\x80\xF6\x34")) 6083 6083 + return 0; 5275 6084 5276 5276 - for(i=0;i<84;++i) 5277 5277 - stbi__get8(s); 6085 6085 + for (i = 0; i < 84; ++i) 6086 6086 + stbi__get8(s); 5278 6087 5279 5279 - if (!stbi__pic_is4(s,"PICT")) 5280 5280 - return 0; 6088 6088 + if (!stbi__pic_is4(s, "PICT")) 6089 6089 + return 0; 5281 6090 5282 5282 - return 1; 6091 6091 + return 1; 5283 6092 } 5284 6093 5285 6094 typedef struct 5286 6095 { 5287 5287 - stbi_uc size,type,channel; 6096 6096 + stbi_uc size, type, channel; 5288 6097 } stbi__pic_packet; 5289 6098 5290 5290 - static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) 6099 6099 + static stbi_uc* stbi__readval(stbi__context* s, int channel, stbi_uc* dest) 5291 6100 { 5292 5292 - int mask=0x80, i; 6101 6101 + int mask = 0x80, i; 5293 6102 5294 5294 - for (i=0; i<4; ++i, mask>>=1) { 5295 5295 - if (channel & mask) { 5296 5296 - if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); 5297 5297 - dest[i]=stbi__get8(s); 5298 5298 - } 5299 5299 - } 6103 6103 + for (i = 0; i < 4; ++i, mask >>= 1) { 6104 6104 + if (channel & mask) { 6105 6105 + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "PIC file too short"); 6106 6106 + dest[i] = stbi__get8(s); 6107 6107 + } 6108 6108 + } 5300 6109 5301 5301 - return dest; 6110 6110 + return dest; 5302 6111 } 5303 6112 5304 5304 - static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) 6113 6113 + static void stbi__copyval(int channel, stbi_uc* dest, const stbi_uc* src) 5305 6114 { 5306 5306 - int mask=0x80,i; 6115 6115 + int mask = 0x80, i; 5307 6116 5308 5308 - for (i=0;i<4; ++i, mask>>=1) 5309 5309 - if (channel&mask) 5310 5310 - dest[i]=src[i]; 6117 6117 + for (i = 0; i < 4; ++i, mask >>= 1) 6118 6118 + if (channel & mask) 6119 6119 + dest[i] = src[i]; 5311 6120 } 5312 6121 5313 5313 - static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) 6122 6122 + static stbi_uc* stbi__pic_load_core(stbi__context* s, int width, int height, int* comp, stbi_uc* result) 5314 6123 { 5315 5315 - int act_comp=0,num_packets=0,y,chained; 5316 5316 - stbi__pic_packet packets[10]; 6124 6124 + int act_comp = 0, num_packets = 0, y, chained; 6125 6125 + stbi__pic_packet packets[10]; 5317 6126 5318 5318 - // this will (should...) cater for even some bizarre stuff like having data 5319 5319 - // for the same channel in multiple packets. 5320 5320 - do { 5321 5321 - stbi__pic_packet *packet; 6127 6127 + // this will (should...) cater for even some bizarre stuff like having data 6128 6128 + // for the same channel in multiple packets. 6129 6129 + do { 6130 6130 + stbi__pic_packet* packet; 5322 6131 5323 5323 - if (num_packets==sizeof(packets)/sizeof(packets[0])) 5324 5324 - return stbi__errpuc("bad format","too many packets"); 6132 6132 + if (num_packets == sizeof(packets) / sizeof(packets[0])) 6133 6133 + return stbi__errpuc("bad format", "too many packets"); 5325 6134 5326 5326 - packet = &packets[num_packets++]; 6135 6135 + packet = &packets[num_packets++]; 5327 6136 5328 5328 - chained = stbi__get8(s); 5329 5329 - packet->size = stbi__get8(s); 5330 5330 - packet->type = stbi__get8(s); 5331 5331 - packet->channel = stbi__get8(s); 6137 6137 + chained = stbi__get8(s); 6138 6138 + packet->size = stbi__get8(s); 6139 6139 + packet->type = stbi__get8(s); 6140 6140 + packet->channel = stbi__get8(s); 5332 6141 5333 5333 - act_comp |= packet->channel; 6142 6142 + act_comp |= packet->channel; 5334 6143 5335 5335 - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); 5336 5336 - if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); 5337 5337 - } while (chained); 6144 6144 + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (reading packets)"); 6145 6145 + if (packet->size != 8) return stbi__errpuc("bad format", "packet isn't 8bpp"); 6146 6146 + } while (chained); 5338 6147 5339 5339 - *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? 6148 6148 + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? 5340 6149 5341 5341 - for(y=0; y<height; ++y) { 5342 5342 - int packet_idx; 6150 6150 + for (y = 0; y < height; ++y) { 6151 6151 + int packet_idx; 5343 6152 5344 5344 - for(packet_idx=0; packet_idx < num_packets; ++packet_idx) { 5345 5345 - stbi__pic_packet *packet = &packets[packet_idx]; 5346 5346 - stbi_uc *dest = result+y*width*4; 6153 6153 + for (packet_idx = 0; packet_idx < num_packets; ++packet_idx) { 6154 6154 + stbi__pic_packet* packet = &packets[packet_idx]; 6155 6155 + stbi_uc* dest = result + y * width * 4; 5347 6156 5348 5348 - switch (packet->type) { 6157 6157 + switch (packet->type) { 5349 6158 default: 5350 5350 - return stbi__errpuc("bad format","packet has bad compression type"); 6159 6159 + return stbi__errpuc("bad format", "packet has bad compression type"); 5351 6160 5352 6161 case 0: {//uncompressed 5353 5353 - int x; 6162 6162 + int x; 5354 6163 5355 5355 - for(x=0;x<width;++x, dest+=4) 5356 5356 - if (!stbi__readval(s,packet->channel,dest)) 5357 5357 - return 0; 5358 5358 - break; 6164 6164 + for (x = 0; x < width; ++x, dest += 4) 6165 6165 + if (!stbi__readval(s, packet->channel, dest)) 6166 6166 + return 0; 6167 6167 + break; 5359 6168 } 5360 6169 5361 6170 case 1://Pure RLE 5362 5362 - { 5363 5363 - int left=width, i; 6171 6171 + { 6172 6172 + int left = width, i; 5364 6173 5365 5365 - while (left>0) { 5366 5366 - stbi_uc count,value[4]; 6174 6174 + while (left > 0) { 6175 6175 + stbi_uc count, value[4]; 5367 6176 5368 5368 - count=stbi__get8(s); 5369 5369 - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); 6177 6177 + count = stbi__get8(s); 6178 6178 + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (pure read count)"); 5370 6179 5371 5371 - if (count > left) 5372 5372 - count = (stbi_uc) left; 6180 6180 + if (count > left) 6181 6181 + count = (stbi_uc)left; 5373 6182 5374 5374 - if (!stbi__readval(s,packet->channel,value)) return 0; 6183 6183 + if (!stbi__readval(s, packet->channel, value)) return 0; 5375 6184 5376 5376 - for(i=0; i<count; ++i,dest+=4) 5377 5377 - stbi__copyval(packet->channel,dest,value); 5378 5378 - left -= count; 5379 5379 - } 5380 5380 - } 5381 5381 - break; 6185 6185 + for (i = 0; i < count; ++i, dest += 4) 6186 6186 + stbi__copyval(packet->channel, dest, value); 6187 6187 + left -= count; 6188 6188 + } 6189 6189 + } 6190 6190 + break; 5382 6191 5383 6192 case 2: {//Mixed RLE 5384 5384 - int left=width; 5385 5385 - while (left>0) { 5386 5386 - int count = stbi__get8(s), i; 5387 5387 - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); 6193 6193 + int left = width; 6194 6194 + while (left > 0) { 6195 6195 + int count = stbi__get8(s), i; 6196 6196 + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (mixed read count)"); 5388 6197 5389 5389 - if (count >= 128) { // Repeated 5390 5390 - stbi_uc value[4]; 6198 6198 + if (count >= 128) { // Repeated 6199 6199 + stbi_uc value[4]; 5391 6200 5392 5392 - if (count==128) 5393 5393 - count = stbi__get16be(s); 5394 5394 - else 5395 5395 - count -= 127; 5396 5396 - if (count > left) 5397 5397 - return stbi__errpuc("bad file","scanline overrun"); 6201 6201 + if (count == 128) 6202 6202 + count = stbi__get16be(s); 6203 6203 + else 6204 6204 + count -= 127; 6205 6205 + if (count > left) 6206 6206 + return stbi__errpuc("bad file", "scanline overrun"); 5398 6207 5399 5399 - if (!stbi__readval(s,packet->channel,value)) 5400 5400 - return 0; 6208 6208 + if (!stbi__readval(s, packet->channel, value)) 6209 6209 + return 0; 5401 6210 5402 5402 - for(i=0;i<count;++i, dest += 4) 5403 5403 - stbi__copyval(packet->channel,dest,value); 5404 5404 - } else { // Raw 5405 5405 - ++count; 5406 5406 - if (count>left) return stbi__errpuc("bad file","scanline overrun"); 6211 6211 + for (i = 0; i < count; ++i, dest += 4) 6212 6212 + stbi__copyval(packet->channel, dest, value); 6213 6213 + } 6214 6214 + else { // Raw 6215 6215 + ++count; 6216 6216 + if (count > left) return stbi__errpuc("bad file", "scanline overrun"); 5407 6217 5408 5408 - for(i=0;i<count;++i, dest+=4) 5409 5409 - if (!stbi__readval(s,packet->channel,dest)) 5410 5410 - return 0; 5411 5411 - } 5412 5412 - left-=count; 5413 5413 - } 5414 5414 - break; 6218 6218 + for (i = 0; i < count; ++i, dest += 4) 6219 6219 + if (!stbi__readval(s, packet->channel, dest)) 6220 6220 + return 0; 6221 6221 + } 6222 6222 + left -= count; 6223 6223 + } 6224 6224 + break; 5415 6225 } 5416 5416 - } 5417 5417 - } 5418 5418 - } 6226 6226 + } 6227 6227 + } 6228 6228 + } 5419 6229 5420 5420 - return result; 6230 6230 + return result; 5421 6231 } 5422 6232 5423 5423 - static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp) 6233 6233 + static void* stbi__pic_load(stbi__context* s, int* px, int* py, int* comp, int req_comp, stbi__result_info* ri) 5424 6234 { 5425 5425 - stbi_uc *result; 5426 5426 - int i, x,y; 6235 6235 + stbi_uc* result; 6236 6236 + int i, x, y, internal_comp; 6237 6237 + STBI_NOTUSED(ri); 5427 6238 5428 5428 - for (i=0; i<92; ++i) 5429 5429 - stbi__get8(s); 6239 6239 + if (!comp) comp = &internal_comp; 5430 6240 5431 5431 - x = stbi__get16be(s); 5432 5432 - y = stbi__get16be(s); 5433 5433 - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); 5434 5434 - if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to decode"); 6241 6241 + for (i = 0; i < 92; ++i) 6242 6242 + stbi__get8(s); 5435 6243 5436 5436 - stbi__get32be(s); //skip `ratio' 5437 5437 - stbi__get16be(s); //skip `fields' 5438 5438 - stbi__get16be(s); //skip `pad' 6244 6244 + x = stbi__get16be(s); 6245 6245 + y = stbi__get16be(s); 6246 6246 + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (pic header)"); 6247 6247 + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); 5439 6248 5440 5440 - // intermediate buffer is RGBA 5441 5441 - result = (stbi_uc *) stbi__malloc(x*y*4); 5442 5442 - memset(result, 0xff, x*y*4); 6249 6249 + stbi__get32be(s); //skip `ratio' 6250 6250 + stbi__get16be(s); //skip `fields' 6251 6251 + stbi__get16be(s); //skip `pad' 6252 6252 + 6253 6253 + // intermediate buffer is RGBA 6254 6254 + result = (stbi_uc*)stbi__malloc_mad3(x, y, 4, 0); 6255 6255 + memset(result, 0xff, x * y * 4); 5443 6256 5444 5444 - if (!stbi__pic_load_core(s,x,y,comp, result)) { 5445 5445 - STBI_FREE(result); 5446 5446 - result=0; 5447 5447 - } 5448 5448 - *px = x; 5449 5449 - *py = y; 5450 5450 - if (req_comp == 0) req_comp = *comp; 5451 5451 - result=stbi__convert_format(result,4,req_comp,x,y); 6257 6257 + if (!stbi__pic_load_core(s, x, y, comp, result)) { 6258 6258 + STBI_FREE(result); 6259 6259 + result = 0; 6260 6260 + } 6261 6261 + *px = x; 6262 6262 + *py = y; 6263 6263 + if (req_comp == 0) req_comp = *comp; 6264 6264 + result = stbi__convert_format(result, 4, req_comp, x, y); 5452 6265 5453 5453 - return result; 6266 6266 + return result; 5454 6267 } 5455 6268 5456 5456 - static int stbi__pic_test(stbi__context *s) 6269 6269 + static int stbi__pic_test(stbi__context* s) 5457 6270 { 5458 5458 - int r = stbi__pic_test_core(s); 5459 5459 - stbi__rewind(s); 5460 5460 - return r; 6271 6271 + int r = stbi__pic_test_core(s); 6272 6272 + stbi__rewind(s); 6273 6273 + return r; 5461 6274 } 5462 6275 #endif 5463 6276 ··· 5467 6280 #ifndef STBI_NO_GIF 5468 6281 typedef struct 5469 6282 { 5470 5470 - stbi__int16 prefix; 5471 5471 - stbi_uc first; 5472 5472 - stbi_uc suffix; 6283 6283 + stbi__int16 prefix; 6284 6284 + stbi_uc first; 6285 6285 + stbi_uc suffix; 5473 6286 } stbi__gif_lzw; 5474 6287 5475 6288 typedef struct 5476 6289 { 5477 5477 - int w,h; 5478 5478 - stbi_uc *out, *old_out; // output buffer (always 4 components) 5479 5479 - int flags, bgindex, ratio, transparent, eflags, delay; 5480 5480 - stbi_uc pal[256][4]; 5481 5481 - stbi_uc lpal[256][4]; 5482 5482 - stbi__gif_lzw codes[4096]; 5483 5483 - stbi_uc *color_table; 5484 5484 - int parse, step; 5485 5485 - int lflags; 5486 5486 - int start_x, start_y; 5487 5487 - int max_x, max_y; 5488 5488 - int cur_x, cur_y; 5489 5489 - int line_size; 6290 6290 + int w, h; 6291 6291 + stbi_uc* out; // output buffer (always 4 components) 6292 6292 + stbi_uc* background; // The current "background" as far as a gif is concerned 6293 6293 + stbi_uc* history; 6294 6294 + int flags, bgindex, ratio, transparent, eflags; 6295 6295 + stbi_uc pal[256][4]; 6296 6296 + stbi_uc lpal[256][4]; 6297 6297 + stbi__gif_lzw codes[8192]; 6298 6298 + stbi_uc* color_table; 6299 6299 + int parse, step; 6300 6300 + int lflags; 6301 6301 + int start_x, start_y; 6302 6302 + int max_x, max_y; 6303 6303 + int cur_x, cur_y; 6304 6304 + int line_size; 6305 6305 + int delay; 5490 6306 } stbi__gif; 5491 6307 5492 5492 - static int stbi__gif_test_raw(stbi__context *s) 6308 6308 + static int stbi__gif_test_raw(stbi__context* s) 5493 6309 { 5494 5494 - int sz; 5495 5495 - if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; 5496 5496 - sz = stbi__get8(s); 5497 5497 - if (sz != '9' && sz != '7') return 0; 5498 5498 - if (stbi__get8(s) != 'a') return 0; 5499 5499 - return 1; 6310 6310 + int sz; 6311 6311 + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; 6312 6312 + sz = stbi__get8(s); 6313 6313 + if (sz != '9' && sz != '7') return 0; 6314 6314 + if (stbi__get8(s) != 'a') return 0; 6315 6315 + return 1; 5500 6316 } 5501 6317 5502 5502 - static int stbi__gif_test(stbi__context *s) 6318 6318 + static int stbi__gif_test(stbi__context* s) 5503 6319 { 5504 5504 - int r = stbi__gif_test_raw(s); 5505 5505 - stbi__rewind(s); 5506 5506 - return r; 6320 6320 + int r = stbi__gif_test_raw(s); 6321 6321 + stbi__rewind(s); 6322 6322 + return r; 5507 6323 } 5508 6324 5509 5509 - static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) 6325 6325 + static void stbi__gif_parse_colortable(stbi__context* s, stbi_uc pal[256][4], int num_entries, int transp) 5510 6326 { 5511 5511 - int i; 5512 5512 - for (i=0; i < num_entries; ++i) { 5513 5513 - pal[i][2] = stbi__get8(s); 5514 5514 - pal[i][1] = stbi__get8(s); 5515 5515 - pal[i][0] = stbi__get8(s); 5516 5516 - pal[i][3] = transp == i ? 0 : 255; 5517 5517 - } 6327 6327 + int i; 6328 6328 + for (i = 0; i < num_entries; ++i) { 6329 6329 + pal[i][2] = stbi__get8(s); 6330 6330 + pal[i][1] = stbi__get8(s); 6331 6331 + pal[i][0] = stbi__get8(s); 6332 6332 + pal[i][3] = transp == i ? 0 : 255; 6333 6333 + } 5518 6334 } 5519 6335 5520 5520 - static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) 6336 6336 + static int stbi__gif_header(stbi__context* s, stbi__gif* g, int* comp, int is_info) 5521 6337 { 5522 5522 - stbi_uc version; 5523 5523 - if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') 5524 5524 - return stbi__err("not GIF", "Corrupt GIF"); 6338 6338 + stbi_uc version; 6339 6339 + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') 6340 6340 + return stbi__err("not GIF", "Corrupt GIF"); 5525 6341 5526 5526 - version = stbi__get8(s); 5527 5527 - if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); 5528 5528 - if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); 6342 6342 + version = stbi__get8(s); 6343 6343 + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); 6344 6344 + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); 5529 6345 5530 5530 - stbi__g_failure_reason = ""; 5531 5531 - g->w = stbi__get16le(s); 5532 5532 - g->h = stbi__get16le(s); 5533 5533 - g->flags = stbi__get8(s); 5534 5534 - g->bgindex = stbi__get8(s); 5535 5535 - g->ratio = stbi__get8(s); 5536 5536 - g->transparent = -1; 6346 6346 + stbi__g_failure_reason = ""; 6347 6347 + g->w = stbi__get16le(s); 6348 6348 + g->h = stbi__get16le(s); 6349 6349 + g->flags = stbi__get8(s); 6350 6350 + g->bgindex = stbi__get8(s); 6351 6351 + g->ratio = stbi__get8(s); 6352 6352 + g->transparent = -1; 5537 6353 5538 5538 - if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments 6354 6354 + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments 5539 6355 5540 5540 - if (is_info) return 1; 6356 6356 + if (is_info) return 1; 5541 6357 5542 5542 - if (g->flags & 0x80) 5543 5543 - stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); 6358 6358 + if (g->flags & 0x80) 6359 6359 + stbi__gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1); 5544 6360 5545 5545 - return 1; 6361 6361 + return 1; 5546 6362 } 5547 6363 5548 5548 - static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) 6364 6364 + static int stbi__gif_info_raw(stbi__context* s, int* x, int* y, int* comp) 5549 6365 { 5550 5550 - stbi__gif g; 5551 5551 - if (!stbi__gif_header(s, &g, comp, 1)) { 5552 5552 - stbi__rewind( s ); 5553 5553 - return 0; 5554 5554 - } 5555 5555 - if (x) *x = g.w; 5556 5556 - if (y) *y = g.h; 5557 5557 - return 1; 6366 6366 + stbi__gif* g = (stbi__gif*)stbi__malloc(sizeof(stbi__gif)); 6367 6367 + if (!stbi__gif_header(s, g, comp, 1)) { 6368 6368 + STBI_FREE(g); 6369 6369 + stbi__rewind(s); 6370 6370 + return 0; 6371 6371 + } 6372 6372 + if (x) *x = g->w; 6373 6373 + if (y) *y = g->h; 6374 6374 + STBI_FREE(g); 6375 6375 + return 1; 5558 6376 } 5559 6377 5560 5560 - static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) 6378 6378 + static void stbi__out_gif_code(stbi__gif* g, stbi__uint16 code) 5561 6379 { 5562 5562 - stbi_uc *p, *c; 6380 6380 + stbi_uc* p, * c; 6381 6381 + int idx; 5563 6382 5564 5564 - // recurse to decode the prefixes, since the linked-list is backwards, 5565 5565 - // and working backwards through an interleaved image would be nasty 5566 5566 - if (g->codes[code].prefix >= 0) 5567 5567 - stbi__out_gif_code(g, g->codes[code].prefix); 6383 6383 + // recurse to decode the prefixes, since the linked-list is backwards, 6384 6384 + // and working backwards through an interleaved image would be nasty 6385 6385 + if (g->codes[code].prefix >= 0) 6386 6386 + stbi__out_gif_code(g, g->codes[code].prefix); 5568 6387 5569 5569 - if (g->cur_y >= g->max_y) return; 6388 6388 + if (g->cur_y >= g->max_y) return; 5570 6389 5571 5571 - p = &g->out[g->cur_x + g->cur_y]; 5572 5572 - c = &g->color_table[g->codes[code].suffix * 4]; 6390 6390 + idx = g->cur_x + g->cur_y; 6391 6391 + p = &g->out[idx]; 6392 6392 + g->history[idx / 4] = 1; 5573 6393 5574 5574 - if (c[3] >= 128) { 5575 5575 - p[0] = c[2]; 5576 5576 - p[1] = c[1]; 5577 5577 - p[2] = c[0]; 5578 5578 - p[3] = c[3]; 5579 5579 - } 5580 5580 - g->cur_x += 4; 6394 6394 + c = &g->color_table[g->codes[code].suffix * 4]; 6395 6395 + if (c[3] > 128) { // don't render transparent pixels; 6396 6396 + p[0] = c[2]; 6397 6397 + p[1] = c[1]; 6398 6398 + p[2] = c[0]; 6399 6399 + p[3] = c[3]; 6400 6400 + } 6401 6401 + g->cur_x += 4; 5581 6402 5582 5582 - if (g->cur_x >= g->max_x) { 5583 5583 - g->cur_x = g->start_x; 5584 5584 - g->cur_y += g->step; 6403 6403 + if (g->cur_x >= g->max_x) { 6404 6404 + g->cur_x = g->start_x; 6405 6405 + g->cur_y += g->step; 5585 6406 5586 5586 - while (g->cur_y >= g->max_y && g->parse > 0) { 5587 5587 - g->step = (1 << g->parse) * g->line_size; 5588 5588 - g->cur_y = g->start_y + (g->step >> 1); 5589 5589 - --g->parse; 5590 5590 - } 5591 5591 - } 6407 6407 + while (g->cur_y >= g->max_y && g->parse > 0) { 6408 6408 + g->step = (1 << g->parse) * g->line_size; 6409 6409 + g->cur_y = g->start_y + (g->step >> 1); 6410 6410 + --g->parse; 6411 6411 + } 6412 6412 + } 5592 6413 } 5593 6414 5594 5594 - static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) 6415 6415 + static stbi_uc* stbi__process_gif_raster(stbi__context* s, stbi__gif* g) 5595 6416 { 5596 5596 - stbi_uc lzw_cs; 5597 5597 - stbi__int32 len, init_code; 5598 5598 - stbi__uint32 first; 5599 5599 - stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; 5600 5600 - stbi__gif_lzw *p; 6417 6417 + stbi_uc lzw_cs; 6418 6418 + stbi__int32 len, init_code; 6419 6419 + stbi__uint32 first; 6420 6420 + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; 6421 6421 + stbi__gif_lzw* p; 5601 6422 5602 5602 - lzw_cs = stbi__get8(s); 5603 5603 - if (lzw_cs > 12) return NULL; 5604 5604 - clear = 1 << lzw_cs; 5605 5605 - first = 1; 5606 5606 - codesize = lzw_cs + 1; 5607 5607 - codemask = (1 << codesize) - 1; 5608 5608 - bits = 0; 5609 5609 - valid_bits = 0; 5610 5610 - for (init_code = 0; init_code < clear; init_code++) { 5611 5611 - g->codes[init_code].prefix = -1; 5612 5612 - g->codes[init_code].first = (stbi_uc) init_code; 5613 5613 - g->codes[init_code].suffix = (stbi_uc) init_code; 5614 5614 - } 6423 6423 + lzw_cs = stbi__get8(s); 6424 6424 + if (lzw_cs > 12) return NULL; 6425 6425 + clear = 1 << lzw_cs; 6426 6426 + first = 1; 6427 6427 + codesize = lzw_cs + 1; 6428 6428 + codemask = (1 << codesize) - 1; 6429 6429 + bits = 0; 6430 6430 + valid_bits = 0; 6431 6431 + for (init_code = 0; init_code < clear; init_code++) { 6432 6432 + g->codes[init_code].prefix = -1; 6433 6433 + g->codes[init_code].first = (stbi_uc)init_code; 6434 6434 + g->codes[init_code].suffix = (stbi_uc)init_code; 6435 6435 + } 5615 6436 5616 5616 - // support no starting clear code 5617 5617 - avail = clear+2; 5618 5618 - oldcode = -1; 6437 6437 + // support no starting clear code 6438 6438 + avail = clear + 2; 6439 6439 + oldcode = -1; 5619 6440 5620 5620 - len = 0; 5621 5621 - for(;;) { 5622 5622 - if (valid_bits < codesize) { 5623 5623 - if (len == 0) { 5624 5624 - len = stbi__get8(s); // start new block 5625 5625 - if (len == 0) 5626 5626 - return g->out; 5627 5627 - } 5628 5628 - --len; 5629 5629 - bits |= (stbi__int32) stbi__get8(s) << valid_bits; 5630 5630 - valid_bits += 8; 5631 5631 - } else { 5632 5632 - stbi__int32 code = bits & codemask; 5633 5633 - bits >>= codesize; 5634 5634 - valid_bits -= codesize; 5635 5635 - // @OPTIMIZE: is there some way we can accelerate the non-clear path? 5636 5636 - if (code == clear) { // clear code 5637 5637 - codesize = lzw_cs + 1; 5638 5638 - codemask = (1 << codesize) - 1; 5639 5639 - avail = clear + 2; 5640 5640 - oldcode = -1; 5641 5641 - first = 0; 5642 5642 - } else if (code == clear + 1) { // end of stream code 5643 5643 - stbi__skip(s, len); 5644 5644 - while ((len = stbi__get8(s)) > 0) 5645 5645 - stbi__skip(s,len); 5646 5646 - return g->out; 5647 5647 - } else if (code <= avail) { 5648 5648 - if (first) return stbi__errpuc("no clear code", "Corrupt GIF"); 6441 6441 + len = 0; 6442 6442 + for (;;) { 6443 6443 + if (valid_bits < codesize) { 6444 6444 + if (len == 0) { 6445 6445 + len = stbi__get8(s); // start new block 6446 6446 + if (len == 0) 6447 6447 + return g->out; 6448 6448 + } 6449 6449 + --len; 6450 6450 + bits |= (stbi__int32)stbi__get8(s) << valid_bits; 6451 6451 + valid_bits += 8; 6452 6452 + } 6453 6453 + else { 6454 6454 + stbi__int32 code = bits & codemask; 6455 6455 + bits >>= codesize; 6456 6456 + valid_bits -= codesize; 6457 6457 + // @OPTIMIZE: is there some way we can accelerate the non-clear path? 6458 6458 + if (code == clear) { // clear code 6459 6459 + codesize = lzw_cs + 1; 6460 6460 + codemask = (1 << codesize) - 1; 6461 6461 + avail = clear + 2; 6462 6462 + oldcode = -1; 6463 6463 + first = 0; 6464 6464 + } 6465 6465 + else if (code == clear + 1) { // end of stream code 6466 6466 + stbi__skip(s, len); 6467 6467 + while ((len = stbi__get8(s)) > 0) 6468 6468 + stbi__skip(s, len); 6469 6469 + return g->out; 6470 6470 + } 6471 6471 + else if (code <= avail) { 6472 6472 + if (first) { 6473 6473 + return stbi__errpuc("no clear code", "Corrupt GIF"); 6474 6474 + } 5649 6475 5650 5650 - if (oldcode >= 0) { 5651 5651 - p = &g->codes[avail++]; 5652 5652 - if (avail > 4096) return stbi__errpuc("too many codes", "Corrupt GIF"); 5653 5653 - p->prefix = (stbi__int16) oldcode; 5654 5654 - p->first = g->codes[oldcode].first; 5655 5655 - p->suffix = (code == avail) ? p->first : g->codes[code].first; 5656 5656 - } else if (code == avail) 5657 5657 - return stbi__errpuc("illegal code in raster", "Corrupt GIF"); 6476 6476 + if (oldcode >= 0) { 6477 6477 + p = &g->codes[avail++]; 6478 6478 + if (avail > 8192) { 6479 6479 + return stbi__errpuc("too many codes", "Corrupt GIF"); 6480 6480 + } 5658 6481 5659 5659 - stbi__out_gif_code(g, (stbi__uint16) code); 6482 6482 + p->prefix = (stbi__int16)oldcode; 6483 6483 + p->first = g->codes[oldcode].first; 6484 6484 + p->suffix = (code == avail) ? p->first : g->codes[code].first; 6485 6485 + } 6486 6486 + else if (code == avail) 6487 6487 + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); 5660 6488 5661 5661 - if ((avail & codemask) == 0 && avail <= 0x0FFF) { 5662 5662 - codesize++; 5663 5663 - codemask = (1 << codesize) - 1; 5664 5664 - } 6489 6489 + stbi__out_gif_code(g, (stbi__uint16)code); 5665 6490 5666 5666 - oldcode = code; 5667 5667 - } else { 5668 5668 - return stbi__errpuc("illegal code in raster", "Corrupt GIF"); 5669 5669 - } 5670 5670 - } 5671 5671 - } 5672 5672 - } 6491 6491 + if ((avail & codemask) == 0 && avail <= 0x0FFF) { 6492 6492 + codesize++; 6493 6493 + codemask = (1 << codesize) - 1; 6494 6494 + } 5673 6495 5674 5674 - static void stbi__fill_gif_background(stbi__gif *g, int x0, int y0, int x1, int y1) 5675 5675 - { 5676 5676 - int x, y; 5677 5677 - stbi_uc *c = g->pal[g->bgindex]; 5678 5678 - for (y = y0; y < y1; y += 4 * g->w) { 5679 5679 - for (x = x0; x < x1; x += 4) { 5680 5680 - stbi_uc *p = &g->out[y + x]; 5681 5681 - p[0] = c[2]; 5682 5682 - p[1] = c[1]; 5683 5683 - p[2] = c[0]; 5684 5684 - p[3] = 0; 5685 5685 - } 5686 5686 - } 6496 6496 + oldcode = code; 6497 6497 + } 6498 6498 + else { 6499 6499 + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); 6500 6500 + } 6501 6501 + } 6502 6502 + } 5687 6503 } 5688 6504 5689 6505 // this function is designed to support animated gifs, although stb_image doesn't support it 5690 5690 - static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp) 6506 6506 + // two back is the image from two frames ago, used for a very specific disposal format 6507 6507 + static stbi_uc* stbi__gif_load_next(stbi__context* s, stbi__gif* g, int* comp, int req_comp, stbi_uc* two_back) 5691 6508 { 5692 5692 - int i; 5693 5693 - stbi_uc *prev_out = 0; 6509 6509 + int dispose; 6510 6510 + int first_frame; 6511 6511 + int pi; 6512 6512 + int pcount; 6513 6513 + STBI_NOTUSED(req_comp); 5694 6514 5695 5695 - if (g->out == 0 && !stbi__gif_header(s, g, comp,0)) 5696 5696 - return 0; // stbi__g_failure_reason set by stbi__gif_header 6515 6515 + // on first frame, any non-written pixels get the background colour (non-transparent) 6516 6516 + first_frame = 0; 6517 6517 + if (g->out == 0) { 6518 6518 + if (!stbi__gif_header(s, g, comp, 0)) return 0; // stbi__g_failure_reason set by stbi__gif_header 6519 6519 + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) 6520 6520 + return stbi__errpuc("too large", "GIF image is too large"); 6521 6521 + pcount = g->w * g->h; 6522 6522 + g->out = (stbi_uc*)stbi__malloc(4 * pcount); 6523 6523 + g->background = (stbi_uc*)stbi__malloc(4 * pcount); 6524 6524 + g->history = (stbi_uc*)stbi__malloc(pcount); 6525 6525 + if (!g->out || !g->background || !g->history) 6526 6526 + return stbi__errpuc("outofmem", "Out of memory"); 5697 6527 5698 5698 - prev_out = g->out; 5699 5699 - g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h); 5700 5700 - if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); 6528 6528 + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; 6529 6529 + // background colour is only used for pixels that are not rendered first frame, after that "background" 6530 6530 + // color refers to the color that was there the previous frame. 6531 6531 + memset(g->out, 0x00, 4 * pcount); 6532 6532 + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) 6533 6533 + memset(g->history, 0x00, pcount); // pixels that were affected previous frame 6534 6534 + first_frame = 1; 6535 6535 + } 6536 6536 + else { 6537 6537 + // second frame - how do we dispoase of the previous one? 6538 6538 + dispose = (g->eflags & 0x1C) >> 2; 6539 6539 + pcount = g->w * g->h; 5701 6540 5702 5702 - switch ((g->eflags & 0x1C) >> 2) { 5703 5703 - case 0: // unspecified (also always used on 1st frame) 5704 5704 - stbi__fill_gif_background(g, 0, 0, 4 * g->w, 4 * g->w * g->h); 5705 5705 - break; 5706 5706 - case 1: // do not dispose 5707 5707 - if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); 5708 5708 - g->old_out = prev_out; 5709 5709 - break; 5710 5710 - case 2: // dispose to background 5711 5711 - if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); 5712 5712 - stbi__fill_gif_background(g, g->start_x, g->start_y, g->max_x, g->max_y); 5713 5713 - break; 5714 5714 - case 3: // dispose to previous 5715 5715 - if (g->old_out) { 5716 5716 - for (i = g->start_y; i < g->max_y; i += 4 * g->w) 5717 5717 - memcpy(&g->out[i + g->start_x], &g->old_out[i + g->start_x], g->max_x - g->start_x); 5718 5718 - } 5719 5719 - break; 5720 5720 - } 6541 6541 + if ((dispose == 3) && (two_back == 0)) { 6542 6542 + dispose = 2; // if I don't have an image to revert back to, default to the old background 6543 6543 + } 5721 6544 5722 5722 - for (;;) { 5723 5723 - switch (stbi__get8(s)) { 5724 5724 - case 0x2C: /* Image Descriptor */ 5725 5725 - { 5726 5726 - int prev_trans = -1; 6545 6545 + if (dispose == 3) { // use previous graphic 6546 6546 + for (pi = 0; pi < pcount; ++pi) { 6547 6547 + if (g->history[pi]) { 6548 6548 + memcpy(&g->out[pi * 4], &two_back[pi * 4], 4); 6549 6549 + } 6550 6550 + } 6551 6551 + } 6552 6552 + else if (dispose == 2) { 6553 6553 + // restore what was changed last frame to background before that frame; 6554 6554 + for (pi = 0; pi < pcount; ++pi) { 6555 6555 + if (g->history[pi]) { 6556 6556 + memcpy(&g->out[pi * 4], &g->background[pi * 4], 4); 6557 6557 + } 6558 6558 + } 6559 6559 + } 6560 6560 + else { 6561 6561 + // This is a non-disposal case eithe way, so just 6562 6562 + // leave the pixels as is, and they will become the new background 6563 6563 + // 1: do not dispose 6564 6564 + // 0: not specified. 6565 6565 + } 6566 6566 + 6567 6567 + // background is what out is after the undoing of the previou frame; 6568 6568 + memcpy(g->background, g->out, 4 * g->w * g->h); 6569 6569 + } 6570 6570 + 6571 6571 + // clear my history; 6572 6572 + memset(g->history, 0x00, g->w * g->h); // pixels that were affected previous frame 6573 6573 + 6574 6574 + for (;;) { 6575 6575 + int tag = stbi__get8(s); 6576 6576 + switch (tag) { 6577 6577 + case 0x2C: /* Image Descriptor */ 6578 6578 + { 5727 6579 stbi__int32 x, y, w, h; 5728 5728 - stbi_uc *o; 6580 6580 + stbi_uc* o; 5729 6581 5730 6582 x = stbi__get16le(s); 5731 6583 y = stbi__get16le(s); 5732 6584 w = stbi__get16le(s); 5733 6585 h = stbi__get16le(s); 5734 6586 if (((x + w) > (g->w)) || ((y + h) > (g->h))) 5735 5735 - return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); 6587 6587 + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); 5736 6588 5737 6589 g->line_size = g->w * 4; 5738 6590 g->start_x = x * 4; 5739 6591 g->start_y = y * g->line_size; 5740 5740 - g->max_x = g->start_x + w * 4; 5741 5741 - g->max_y = g->start_y + h * g->line_size; 5742 5742 - g->cur_x = g->start_x; 5743 5743 - g->cur_y = g->start_y; 6592 6592 + g->max_x = g->start_x + w * 4; 6593 6593 + g->max_y = g->start_y + h * g->line_size; 6594 6594 + g->cur_x = g->start_x; 6595 6595 + g->cur_y = g->start_y; 6596 6596 + 6597 6597 + // if the width of the specified rectangle is 0, that means 6598 6598 + // we may not see *any* pixels or the image is malformed; 6599 6599 + // to make sure this is caught, move the current y down to 6600 6600 + // max_y (which is what out_gif_code checks). 6601 6601 + if (w == 0) 6602 6602 + g->cur_y = g->max_y; 5744 6603 5745 6604 g->lflags = stbi__get8(s); 5746 6605 5747 6606 if (g->lflags & 0x40) { 5748 5748 - g->step = 8 * g->line_size; // first interlaced spacing 5749 5749 - g->parse = 3; 5750 5750 - } else { 5751 5751 - g->step = g->line_size; 5752 5752 - g->parse = 0; 6607 6607 + g->step = 8 * g->line_size; // first interlaced spacing 6608 6608 + g->parse = 3; 6609 6609 + } 6610 6610 + else { 6611 6611 + g->step = g->line_size; 6612 6612 + g->parse = 0; 5753 6613 } 5754 6614 5755 6615 if (g->lflags & 0x80) { 5756 5756 - stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); 5757 5757 - g->color_table = (stbi_uc *) g->lpal; 5758 5758 - } else if (g->flags & 0x80) { 5759 5759 - if (g->transparent >= 0 && (g->eflags & 0x01)) { 5760 5760 - prev_trans = g->pal[g->transparent][3]; 5761 5761 - g->pal[g->transparent][3] = 0; 5762 5762 - } 5763 5763 - g->color_table = (stbi_uc *) g->pal; 5764 5764 - } else 5765 5765 - return stbi__errpuc("missing color table", "Corrupt GIF"); 6616 6616 + stbi__gif_parse_colortable(s, g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); 6617 6617 + g->color_table = (stbi_uc*)g->lpal; 6618 6618 + } 6619 6619 + else if (g->flags & 0x80) { 6620 6620 + g->color_table = (stbi_uc*)g->pal; 6621 6621 + } 6622 6622 + else 6623 6623 + return stbi__errpuc("missing color table", "Corrupt GIF"); 5766 6624 5767 6625 o = stbi__process_gif_raster(s, g); 5768 5768 - if (o == NULL) return NULL; 6626 6626 + if (!o) return NULL; 5769 6627 5770 5770 - if (prev_trans != -1) 5771 5771 - g->pal[g->transparent][3] = (stbi_uc) prev_trans; 6628 6628 + // if this was the first frame, 6629 6629 + pcount = g->w * g->h; 6630 6630 + if (first_frame && (g->bgindex > 0)) { 6631 6631 + // if first frame, any pixel not drawn to gets the background color 6632 6632 + for (pi = 0; pi < pcount; ++pi) { 6633 6633 + if (g->history[pi] == 0) { 6634 6634 + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; 6635 6635 + memcpy(&g->out[pi * 4], &g->pal[g->bgindex], 4); 6636 6636 + } 6637 6637 + } 6638 6638 + } 5772 6639 5773 6640 return o; 5774 5774 - } 6641 6641 + } 5775 6642 5776 5776 - case 0x21: // Comment Extension. 5777 5777 - { 6643 6643 + case 0x21: // Comment Extension. 6644 6644 + { 5778 6645 int len; 5779 5779 - if (stbi__get8(s) == 0xF9) { // Graphic Control Extension. 5780 5780 - len = stbi__get8(s); 5781 5781 - if (len == 4) { 5782 5782 - g->eflags = stbi__get8(s); 5783 5783 - g->delay = stbi__get16le(s); 5784 5784 - g->transparent = stbi__get8(s); 5785 5785 - } else { 5786 5786 - stbi__skip(s, len); 5787 5787 - break; 5788 5788 - } 6646 6646 + int ext = stbi__get8(s); 6647 6647 + if (ext == 0xF9) { // Graphic Control Extension. 6648 6648 + len = stbi__get8(s); 6649 6649 + if (len == 4) { 6650 6650 + g->eflags = stbi__get8(s); 6651 6651 + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. 6652 6652 + 6653 6653 + // unset old transparent 6654 6654 + if (g->transparent >= 0) { 6655 6655 + g->pal[g->transparent][3] = 255; 6656 6656 + } 6657 6657 + if (g->eflags & 0x01) { 6658 6658 + g->transparent = stbi__get8(s); 6659 6659 + if (g->transparent >= 0) { 6660 6660 + g->pal[g->transparent][3] = 0; 6661 6661 + } 6662 6662 + } 6663 6663 + else { 6664 6664 + // don't need transparent 6665 6665 + stbi__skip(s, 1); 6666 6666 + g->transparent = -1; 6667 6667 + } 6668 6668 + } 6669 6669 + else { 6670 6670 + stbi__skip(s, len); 6671 6671 + break; 6672 6672 + } 5789 6673 } 5790 5790 - while ((len = stbi__get8(s)) != 0) 5791 5791 - stbi__skip(s, len); 6674 6674 + while ((len = stbi__get8(s)) != 0) { 6675 6675 + stbi__skip(s, len); 6676 6676 + } 5792 6677 break; 5793 5793 - } 6678 6678 + } 5794 6679 5795 5795 - case 0x3B: // gif stream termination code 5796 5796 - return (stbi_uc *) s; // using '1' causes warning on some compilers 6680 6680 + case 0x3B: // gif stream termination code 6681 6681 + return (stbi_uc*)s; // using '1' causes warning on some compilers 5797 6682 5798 5798 - default: 6683 6683 + default: 5799 6684 return stbi__errpuc("unknown code", "Corrupt GIF"); 5800 5800 - } 5801 5801 - } 6685 6685 + } 6686 6686 + } 6687 6687 + } 6688 6688 + 6689 6689 + static void* stbi__load_gif_main(stbi__context* s, int** delays, int* x, int* y, int* z, int* comp, int req_comp) 6690 6690 + { 6691 6691 + if (stbi__gif_test(s)) { 6692 6692 + int layers = 0; 6693 6693 + stbi_uc* u = 0; 6694 6694 + stbi_uc* out = 0; 6695 6695 + stbi_uc* two_back = 0; 6696 6696 + stbi__gif g; 6697 6697 + int stride; 6698 6698 + memset(&g, 0, sizeof(g)); 6699 6699 + if (delays) { 6700 6700 + *delays = 0; 6701 6701 + } 6702 6702 + 6703 6703 + do { 6704 6704 + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); 6705 6705 + if (u == (stbi_uc*)s) u = 0; // end of animated gif marker 6706 6706 + 6707 6707 + if (u) { 6708 6708 + *x = g.w; 6709 6709 + *y = g.h; 6710 6710 + ++layers; 6711 6711 + stride = g.w * g.h * 4; 6712 6712 + 6713 6713 + if (out) { 6714 6714 + out = (stbi_uc*)STBI_REALLOC(out, layers * stride); 6715 6715 + if (delays) { 6716 6716 + *delays = (int*)STBI_REALLOC(*delays, sizeof(int) * layers); 6717 6717 + } 6718 6718 + } 6719 6719 + else { 6720 6720 + out = (stbi_uc*)stbi__malloc(layers * stride); 6721 6721 + if (delays) { 6722 6722 + *delays = (int*)stbi__malloc(layers * sizeof(int)); 6723 6723 + } 6724 6724 + } 6725 6725 + memcpy(out + ((layers - 1) * stride), u, stride); 6726 6726 + if (layers >= 2) { 6727 6727 + two_back = out - 2 * stride; 6728 6728 + } 6729 6729 + 6730 6730 + if (delays) { 6731 6731 + (*delays)[layers - 1U] = g.delay; 6732 6732 + } 6733 6733 + } 6734 6734 + } while (u != 0); 6735 6735 + 6736 6736 + // free temp buffer; 6737 6737 + STBI_FREE(g.out); 6738 6738 + STBI_FREE(g.history); 6739 6739 + STBI_FREE(g.background); 5802 6740 5803 5803 - STBI_NOTUSED(req_comp); 6741 6741 + // do the final conversion after loading everything; 6742 6742 + if (req_comp && req_comp != 4) 6743 6743 + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); 6744 6744 + 6745 6745 + *z = layers; 6746 6746 + return out; 6747 6747 + } 6748 6748 + else { 6749 6749 + return stbi__errpuc("not GIF", "Image was not as a gif type."); 6750 6750 + } 5804 6751 } 5805 6752 5806 5806 - static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 6753 6753 + static void* stbi__gif_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 5807 6754 { 5808 5808 - stbi_uc *u = 0; 5809 5809 - stbi__gif g; 5810 5810 - memset(&g, 0, sizeof(g)); 6755 6755 + stbi_uc* u = 0; 6756 6756 + stbi__gif g; 6757 6757 + memset(&g, 0, sizeof(g)); 6758 6758 + STBI_NOTUSED(ri); 6759 6759 + 6760 6760 + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); 6761 6761 + if (u == (stbi_uc*)s) u = 0; // end of animated gif marker 6762 6762 + if (u) { 6763 6763 + *x = g.w; 6764 6764 + *y = g.h; 5811 6765 5812 5812 - u = stbi__gif_load_next(s, &g, comp, req_comp); 5813 5813 - if (u == (stbi_uc *) s) u = 0; // end of animated gif marker 5814 5814 - if (u) { 5815 5815 - *x = g.w; 5816 5816 - *y = g.h; 5817 5817 - if (req_comp && req_comp != 4) 5818 5818 - u = stbi__convert_format(u, 4, req_comp, g.w, g.h); 5819 5819 - } 5820 5820 - else if (g.out) 5821 5821 - STBI_FREE(g.out); 6766 6766 + // moved conversion to after successful load so that the same 6767 6767 + // can be done for multiple frames. 6768 6768 + if (req_comp && req_comp != 4) 6769 6769 + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); 6770 6770 + } 6771 6771 + else if (g.out) { 6772 6772 + // if there was an error and we allocated an image buffer, free it! 6773 6773 + STBI_FREE(g.out); 6774 6774 + } 5822 6775 5823 5823 - return u; 6776 6776 + // free buffers needed for multiple frame loading; 6777 6777 + STBI_FREE(g.history); 6778 6778 + STBI_FREE(g.background); 6779 6779 + 6780 6780 + return u; 5824 6781 } 5825 6782 5826 5826 - static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) 6783 6783 + static int stbi__gif_info(stbi__context* s, int* x, int* y, int* comp) 5827 6784 { 5828 5828 - return stbi__gif_info_raw(s,x,y,comp); 6785 6785 + return stbi__gif_info_raw(s, x, y, comp); 5829 6786 } 5830 6787 #endif 5831 6788 ··· 5833 6790 // Radiance RGBE HDR loader 5834 6791 // originally by Nicolas Schulz 5835 6792 #ifndef STBI_NO_HDR 5836 5836 - static int stbi__hdr_test_core(stbi__context *s) 6793 6793 + static int stbi__hdr_test_core(stbi__context* s, const char* signature) 5837 6794 { 5838 5838 - const char *signature = "#?RADIANCE\n"; 5839 5839 - int i; 5840 5840 - for (i=0; signature[i]; ++i) 5841 5841 - if (stbi__get8(s) != signature[i]) 5842 5842 - return 0; 5843 5843 - return 1; 6795 6795 + int i; 6796 6796 + for (i = 0; signature[i]; ++i) 6797 6797 + if (stbi__get8(s) != signature[i]) 6798 6798 + return 0; 6799 6799 + stbi__rewind(s); 6800 6800 + return 1; 5844 6801 } 5845 6802 5846 6803 static int stbi__hdr_test(stbi__context* s) 5847 6804 { 5848 5848 - int r = stbi__hdr_test_core(s); 5849 5849 - stbi__rewind(s); 5850 5850 - return r; 6805 6805 + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); 6806 6806 + stbi__rewind(s); 6807 6807 + if (!r) { 6808 6808 + r = stbi__hdr_test_core(s, "#?RGBE\n"); 6809 6809 + stbi__rewind(s); 6810 6810 + } 6811 6811 + return r; 5851 6812 } 5852 6813 5853 6814 #define STBI__HDR_BUFLEN 1024 5854 5854 - static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) 6815 6815 + static char* stbi__hdr_gettoken(stbi__context* z, char* buffer) 5855 6816 { 5856 5856 - int len=0; 5857 5857 - char c = '\0'; 6817 6817 + int len = 0; 6818 6818 + char c = '\0'; 5858 6819 5859 5859 - c = (char) stbi__get8(z); 6820 6820 + c = (char)stbi__get8(z); 5860 6821 5861 5861 - while (!stbi__at_eof(z) && c != '\n') { 5862 5862 - buffer[len++] = c; 5863 5863 - if (len == STBI__HDR_BUFLEN-1) { 5864 5864 - // flush to end of line 5865 5865 - while (!stbi__at_eof(z) && stbi__get8(z) != '\n') 5866 5866 - ; 5867 5867 - break; 5868 5868 - } 5869 5869 - c = (char) stbi__get8(z); 5870 5870 - } 6822 6822 + while (!stbi__at_eof(z) && c != '\n') { 6823 6823 + buffer[len++] = c; 6824 6824 + if (len == STBI__HDR_BUFLEN - 1) { 6825 6825 + // flush to end of line 6826 6826 + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') 6827 6827 + ; 6828 6828 + break; 6829 6829 + } 6830 6830 + c = (char)stbi__get8(z); 6831 6831 + } 5871 6832 5872 5872 - buffer[len] = 0; 5873 5873 - return buffer; 6833 6833 + buffer[len] = 0; 6834 6834 + return buffer; 5874 6835 } 5875 6836 5876 5876 - static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) 6837 6837 + static void stbi__hdr_convert(float* output, stbi_uc* input, int req_comp) 5877 6838 { 5878 5878 - if ( input[3] != 0 ) { 5879 5879 - float f1; 5880 5880 - // Exponent 5881 5881 - f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); 5882 5882 - if (req_comp <= 2) 5883 5883 - output[0] = (input[0] + input[1] + input[2]) * f1 / 3; 5884 5884 - else { 5885 5885 - output[0] = input[0] * f1; 5886 5886 - output[1] = input[1] * f1; 5887 5887 - output[2] = input[2] * f1; 5888 5888 - } 5889 5889 - if (req_comp == 2) output[1] = 1; 5890 5890 - if (req_comp == 4) output[3] = 1; 5891 5891 - } else { 5892 5892 - switch (req_comp) { 5893 5893 - case 4: output[3] = 1; /* fallthrough */ 5894 5894 - case 3: output[0] = output[1] = output[2] = 0; 5895 5895 - break; 5896 5896 - case 2: output[1] = 1; /* fallthrough */ 5897 5897 - case 1: output[0] = 0; 5898 5898 - break; 5899 5899 - } 5900 5900 - } 6839 6839 + if (input[3] != 0) { 6840 6840 + float f1; 6841 6841 + // Exponent 6842 6842 + f1 = (float)ldexp(1.0f, input[3] - (int)(128 + 8)); 6843 6843 + if (req_comp <= 2) 6844 6844 + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; 6845 6845 + else { 6846 6846 + output[0] = input[0] * f1; 6847 6847 + output[1] = input[1] * f1; 6848 6848 + output[2] = input[2] * f1; 6849 6849 + } 6850 6850 + if (req_comp == 2) output[1] = 1; 6851 6851 + if (req_comp == 4) output[3] = 1; 6852 6852 + } 6853 6853 + else { 6854 6854 + switch (req_comp) { 6855 6855 + case 4: output[3] = 1; /* fallthrough */ 6856 6856 + case 3: output[0] = output[1] = output[2] = 0; 6857 6857 + break; 6858 6858 + case 2: output[1] = 1; /* fallthrough */ 6859 6859 + case 1: output[0] = 0; 6860 6860 + break; 6861 6861 + } 6862 6862 + } 5901 6863 } 5902 6864 5903 5903 - static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 6865 6865 + static float* stbi__hdr_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 5904 6866 { 5905 5905 - char buffer[STBI__HDR_BUFLEN]; 5906 5906 - char *token; 5907 5907 - int valid = 0; 5908 5908 - int width, height; 5909 5909 - stbi_uc *scanline; 5910 5910 - float *hdr_data; 5911 5911 - int len; 5912 5912 - unsigned char count, value; 5913 5913 - int i, j, k, c1,c2, z; 6867 6867 + char buffer[STBI__HDR_BUFLEN]; 6868 6868 + char* token; 6869 6869 + int valid = 0; 6870 6870 + int width, height; 6871 6871 + stbi_uc* scanline; 6872 6872 + float* hdr_data; 6873 6873 + int len; 6874 6874 + unsigned char count, value; 6875 6875 + int i, j, k, c1, c2, z; 6876 6876 + const char* headerToken; 6877 6877 + STBI_NOTUSED(ri); 5914 6878 6879 6879 + // Check identifier 6880 6880 + headerToken = stbi__hdr_gettoken(s, buffer); 6881 6881 + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) 6882 6882 + return stbi__errpf("not HDR", "Corrupt HDR image"); 5915 6883 5916 5916 - // Check identifier 5917 5917 - if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) 5918 5918 - return stbi__errpf("not HDR", "Corrupt HDR image"); 6884 6884 + // Parse header 6885 6885 + for (;;) { 6886 6886 + token = stbi__hdr_gettoken(s, buffer); 6887 6887 + if (token[0] == 0) break; 6888 6888 + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; 6889 6889 + } 5919 6890 5920 5920 - // Parse header 5921 5921 - for(;;) { 5922 5922 - token = stbi__hdr_gettoken(s,buffer); 5923 5923 - if (token[0] == 0) break; 5924 5924 - if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; 5925 5925 - } 6891 6891 + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); 5926 6892 5927 5927 - if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); 6893 6893 + // Parse width and height 6894 6894 + // can't use sscanf() if we're not using stdio! 6895 6895 + token = stbi__hdr_gettoken(s, buffer); 6896 6896 + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); 6897 6897 + token += 3; 6898 6898 + height = (int)strtol(token, &token, 10); 6899 6899 + while (*token == ' ') ++token; 6900 6900 + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); 6901 6901 + token += 3; 6902 6902 + width = (int)strtol(token, NULL, 10); 5928 6903 5929 5929 - // Parse width and height 5930 5930 - // can't use sscanf() if we're not using stdio! 5931 5931 - token = stbi__hdr_gettoken(s,buffer); 5932 5932 - if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); 5933 5933 - token += 3; 5934 5934 - height = (int) strtol(token, &token, 10); 5935 5935 - while (*token == ' ') ++token; 5936 5936 - if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); 5937 5937 - token += 3; 5938 5938 - width = (int) strtol(token, NULL, 10); 6904 6904 + *x = width; 6905 6905 + *y = height; 5939 6906 5940 5940 - *x = width; 5941 5941 - *y = height; 6907 6907 + if (comp) *comp = 3; 6908 6908 + if (req_comp == 0) req_comp = 3; 5942 6909 5943 5943 - if (comp) *comp = 3; 5944 5944 - if (req_comp == 0) req_comp = 3; 6910 6910 + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) 6911 6911 + return stbi__errpf("too large", "HDR image is too large"); 5945 6912 5946 5946 - // Read data 5947 5947 - hdr_data = (float *) stbi__malloc(height * width * req_comp * sizeof(float)); 6913 6913 + // Read data 6914 6914 + hdr_data = (float*)stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); 6915 6915 + if (!hdr_data) 6916 6916 + return stbi__errpf("outofmem", "Out of memory"); 5948 6917 5949 5949 - // Load image data 5950 5950 - // image data is stored as some number of sca 5951 5951 - if ( width < 8 || width >= 32768) { 5952 5952 - // Read flat data 5953 5953 - for (j=0; j < height; ++j) { 5954 5954 - for (i=0; i < width; ++i) { 5955 5955 - stbi_uc rgbe[4]; 5956 5956 - main_decode_loop: 5957 5957 - stbi__getn(s, rgbe, 4); 5958 5958 - stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); 5959 5959 - } 5960 5960 - } 5961 5961 - } else { 5962 5962 - // Read RLE-encoded data 5963 5963 - scanline = NULL; 6918 6918 + // Load image data 6919 6919 + // image data is stored as some number of sca 6920 6920 + if (width < 8 || width >= 32768) { 6921 6921 + // Read flat data 6922 6922 + for (j = 0; j < height; ++j) { 6923 6923 + for (i = 0; i < width; ++i) { 6924 6924 + stbi_uc rgbe[4]; 6925 6925 + main_decode_loop: 6926 6926 + stbi__getn(s, rgbe, 4); 6927 6927 + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); 6928 6928 + } 6929 6929 + } 6930 6930 + } 6931 6931 + else { 6932 6932 + // Read RLE-encoded data 6933 6933 + scanline = NULL; 5964 6934 5965 5965 - for (j = 0; j < height; ++j) { 5966 5966 - c1 = stbi__get8(s); 5967 5967 - c2 = stbi__get8(s); 5968 5968 - len = stbi__get8(s); 5969 5969 - if (c1 != 2 || c2 != 2 || (len & 0x80)) { 5970 5970 - // not run-length encoded, so we have to actually use THIS data as a decoded 5971 5971 - // pixel (note this can't be a valid pixel--one of RGB must be >= 128) 5972 5972 - stbi_uc rgbe[4]; 5973 5973 - rgbe[0] = (stbi_uc) c1; 5974 5974 - rgbe[1] = (stbi_uc) c2; 5975 5975 - rgbe[2] = (stbi_uc) len; 5976 5976 - rgbe[3] = (stbi_uc) stbi__get8(s); 5977 5977 - stbi__hdr_convert(hdr_data, rgbe, req_comp); 5978 5978 - i = 1; 5979 5979 - j = 0; 5980 5980 - STBI_FREE(scanline); 5981 5981 - goto main_decode_loop; // yes, this makes no sense 5982 5982 - } 5983 5983 - len <<= 8; 5984 5984 - len |= stbi__get8(s); 5985 5985 - if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } 5986 5986 - if (scanline == NULL) scanline = (stbi_uc *) stbi__malloc(width * 4); 6935 6935 + for (j = 0; j < height; ++j) { 6936 6936 + c1 = stbi__get8(s); 6937 6937 + c2 = stbi__get8(s); 6938 6938 + len = stbi__get8(s); 6939 6939 + if (c1 != 2 || c2 != 2 || (len & 0x80)) { 6940 6940 + // not run-length encoded, so we have to actually use THIS data as a decoded 6941 6941 + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) 6942 6942 + stbi_uc rgbe[4]; 6943 6943 + rgbe[0] = (stbi_uc)c1; 6944 6944 + rgbe[1] = (stbi_uc)c2; 6945 6945 + rgbe[2] = (stbi_uc)len; 6946 6946 + rgbe[3] = (stbi_uc)stbi__get8(s); 6947 6947 + stbi__hdr_convert(hdr_data, rgbe, req_comp); 6948 6948 + i = 1; 6949 6949 + j = 0; 6950 6950 + STBI_FREE(scanline); 6951 6951 + goto main_decode_loop; // yes, this makes no sense 6952 6952 + } 6953 6953 + len <<= 8; 6954 6954 + len |= stbi__get8(s); 6955 6955 + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } 6956 6956 + if (scanline == NULL) { 6957 6957 + scanline = (stbi_uc*)stbi__malloc_mad2(width, 4, 0); 6958 6958 + if (!scanline) { 6959 6959 + STBI_FREE(hdr_data); 6960 6960 + return stbi__errpf("outofmem", "Out of memory"); 6961 6961 + } 6962 6962 + } 5987 6963 5988 5988 - for (k = 0; k < 4; ++k) { 5989 5989 - i = 0; 5990 5990 - while (i < width) { 5991 5991 - count = stbi__get8(s); 5992 5992 - if (count > 128) { 5993 5993 - // Run 5994 5994 - value = stbi__get8(s); 5995 5995 - count -= 128; 5996 5996 - for (z = 0; z < count; ++z) 5997 5997 - scanline[i++ * 4 + k] = value; 5998 5998 - } else { 5999 5999 - // Dump 6000 6000 - for (z = 0; z < count; ++z) 6001 6001 - scanline[i++ * 4 + k] = stbi__get8(s); 6002 6002 - } 6964 6964 + for (k = 0; k < 4; ++k) { 6965 6965 + int nleft; 6966 6966 + i = 0; 6967 6967 + while ((nleft = width - i) > 0) { 6968 6968 + count = stbi__get8(s); 6969 6969 + if (count > 128) { 6970 6970 + // Run 6971 6971 + value = stbi__get8(s); 6972 6972 + count -= 128; 6973 6973 + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } 6974 6974 + for (z = 0; z < count; ++z) 6975 6975 + scanline[i++ * 4 + k] = value; 6976 6976 + } 6977 6977 + else { 6978 6978 + // Dump 6979 6979 + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } 6980 6980 + for (z = 0; z < count; ++z) 6981 6981 + scanline[i++ * 4 + k] = stbi__get8(s); 6982 6982 + } 6983 6983 + } 6003 6984 } 6004 6004 - } 6005 6005 - for (i=0; i < width; ++i) 6006 6006 - stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); 6007 6007 - } 6008 6008 - STBI_FREE(scanline); 6009 6009 - } 6985 6985 + for (i = 0; i < width; ++i) 6986 6986 + stbi__hdr_convert(hdr_data + (j * width + i) * req_comp, scanline + i * 4, req_comp); 6987 6987 + } 6988 6988 + if (scanline) 6989 6989 + STBI_FREE(scanline); 6990 6990 + } 6010 6991 6011 6011 - return hdr_data; 6992 6992 + return hdr_data; 6012 6993 } 6013 6994 6014 6014 - static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) 6995 6995 + static int stbi__hdr_info(stbi__context* s, int* x, int* y, int* comp) 6015 6996 { 6016 6016 - char buffer[STBI__HDR_BUFLEN]; 6017 6017 - char *token; 6018 6018 - int valid = 0; 6997 6997 + char buffer[STBI__HDR_BUFLEN]; 6998 6998 + char* token; 6999 6999 + int valid = 0; 7000 7000 + int dummy; 6019 7001 6020 6020 - if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) { 6021 6021 - stbi__rewind( s ); 6022 6022 - return 0; 6023 6023 - } 7002 7002 + if (!x) x = &dummy; 7003 7003 + if (!y) y = &dummy; 7004 7004 + if (!comp) comp = &dummy; 6024 7005 6025 6025 - for(;;) { 6026 6026 - token = stbi__hdr_gettoken(s,buffer); 6027 6027 - if (token[0] == 0) break; 6028 6028 - if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; 6029 6029 - } 7006 7006 + if (stbi__hdr_test(s) == 0) { 7007 7007 + stbi__rewind(s); 7008 7008 + return 0; 7009 7009 + } 7010 7010 + 7011 7011 + for (;;) { 7012 7012 + token = stbi__hdr_gettoken(s, buffer); 7013 7013 + if (token[0] == 0) break; 7014 7014 + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; 7015 7015 + } 6030 7016 6031 6031 - if (!valid) { 6032 6032 - stbi__rewind( s ); 6033 6033 - return 0; 6034 6034 - } 6035 6035 - token = stbi__hdr_gettoken(s,buffer); 6036 6036 - if (strncmp(token, "-Y ", 3)) { 6037 6037 - stbi__rewind( s ); 6038 6038 - return 0; 6039 6039 - } 6040 6040 - token += 3; 6041 6041 - *y = (int) strtol(token, &token, 10); 6042 6042 - while (*token == ' ') ++token; 6043 6043 - if (strncmp(token, "+X ", 3)) { 6044 6044 - stbi__rewind( s ); 6045 6045 - return 0; 6046 6046 - } 6047 6047 - token += 3; 6048 6048 - *x = (int) strtol(token, NULL, 10); 6049 6049 - *comp = 3; 6050 6050 - return 1; 7017 7017 + if (!valid) { 7018 7018 + stbi__rewind(s); 7019 7019 + return 0; 7020 7020 + } 7021 7021 + token = stbi__hdr_gettoken(s, buffer); 7022 7022 + if (strncmp(token, "-Y ", 3)) { 7023 7023 + stbi__rewind(s); 7024 7024 + return 0; 7025 7025 + } 7026 7026 + token += 3; 7027 7027 + *y = (int)strtol(token, &token, 10); 7028 7028 + while (*token == ' ') ++token; 7029 7029 + if (strncmp(token, "+X ", 3)) { 7030 7030 + stbi__rewind(s); 7031 7031 + return 0; 7032 7032 + } 7033 7033 + token += 3; 7034 7034 + *x = (int)strtol(token, NULL, 10); 7035 7035 + *comp = 3; 7036 7036 + return 1; 6051 7037 } 6052 7038 #endif // STBI_NO_HDR 6053 7039 6054 7040 #ifndef STBI_NO_BMP 6055 6055 - static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) 7041 7041 + static int stbi__bmp_info(stbi__context* s, int* x, int* y, int* comp) 6056 7042 { 6057 6057 - int hsz; 6058 6058 - if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') { 6059 6059 - stbi__rewind( s ); 6060 6060 - return 0; 6061 6061 - } 6062 6062 - stbi__skip(s,12); 6063 6063 - hsz = stbi__get32le(s); 6064 6064 - if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) { 6065 6065 - stbi__rewind( s ); 6066 6066 - return 0; 6067 6067 - } 6068 6068 - if (hsz == 12) { 6069 6069 - *x = stbi__get16le(s); 6070 6070 - *y = stbi__get16le(s); 6071 6071 - } else { 6072 6072 - *x = stbi__get32le(s); 6073 6073 - *y = stbi__get32le(s); 6074 6074 - } 6075 6075 - if (stbi__get16le(s) != 1) { 6076 6076 - stbi__rewind( s ); 6077 6077 - return 0; 6078 6078 - } 6079 6079 - *comp = stbi__get16le(s) / 8; 6080 6080 - return 1; 7043 7043 + void* p; 7044 7044 + stbi__bmp_data info; 7045 7045 + 7046 7046 + info.all_a = 255; 7047 7047 + p = stbi__bmp_parse_header(s, &info); 7048 7048 + stbi__rewind(s); 7049 7049 + if (p == NULL) 7050 7050 + return 0; 7051 7051 + if (x) *x = s->img_x; 7052 7052 + if (y) *y = s->img_y; 7053 7053 + if (comp) { 7054 7054 + if (info.bpp == 24 && info.ma == 0xff000000) 7055 7055 + *comp = 3; 7056 7056 + else 7057 7057 + *comp = info.ma ? 4 : 3; 7058 7058 + } 7059 7059 + return 1; 6081 7060 } 6082 7061 #endif 6083 7062 6084 7063 #ifndef STBI_NO_PSD 6085 6085 - static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) 7064 7064 + static int stbi__psd_info(stbi__context* s, int* x, int* y, int* comp) 6086 7065 { 6087 6087 - int channelCount; 6088 6088 - if (stbi__get32be(s) != 0x38425053) { 6089 6089 - stbi__rewind( s ); 6090 6090 - return 0; 6091 6091 - } 6092 6092 - if (stbi__get16be(s) != 1) { 6093 6093 - stbi__rewind( s ); 6094 6094 - return 0; 6095 6095 - } 6096 6096 - stbi__skip(s, 6); 6097 6097 - channelCount = stbi__get16be(s); 6098 6098 - if (channelCount < 0 || channelCount > 16) { 6099 6099 - stbi__rewind( s ); 6100 6100 - return 0; 6101 6101 - } 6102 6102 - *y = stbi__get32be(s); 6103 6103 - *x = stbi__get32be(s); 6104 6104 - if (stbi__get16be(s) != 8) { 6105 6105 - stbi__rewind( s ); 6106 6106 - return 0; 6107 6107 - } 6108 6108 - if (stbi__get16be(s) != 3) { 6109 6109 - stbi__rewind( s ); 6110 6110 - return 0; 6111 6111 - } 6112 6112 - *comp = 4; 6113 6113 - return 1; 7066 7066 + int channelCount, dummy, depth; 7067 7067 + if (!x) x = &dummy; 7068 7068 + if (!y) y = &dummy; 7069 7069 + if (!comp) comp = &dummy; 7070 7070 + if (stbi__get32be(s) != 0x38425053) { 7071 7071 + stbi__rewind(s); 7072 7072 + return 0; 7073 7073 + } 7074 7074 + if (stbi__get16be(s) != 1) { 7075 7075 + stbi__rewind(s); 7076 7076 + return 0; 7077 7077 + } 7078 7078 + stbi__skip(s, 6); 7079 7079 + channelCount = stbi__get16be(s); 7080 7080 + if (channelCount < 0 || channelCount > 16) { 7081 7081 + stbi__rewind(s); 7082 7082 + return 0; 7083 7083 + } 7084 7084 + *y = stbi__get32be(s); 7085 7085 + *x = stbi__get32be(s); 7086 7086 + depth = stbi__get16be(s); 7087 7087 + if (depth != 8 && depth != 16) { 7088 7088 + stbi__rewind(s); 7089 7089 + return 0; 7090 7090 + } 7091 7091 + if (stbi__get16be(s) != 3) { 7092 7092 + stbi__rewind(s); 7093 7093 + return 0; 7094 7094 + } 7095 7095 + *comp = 4; 7096 7096 + return 1; 7097 7097 + } 7098 7098 + 7099 7099 + static int stbi__psd_is16(stbi__context* s) 7100 7100 + { 7101 7101 + int channelCount, depth; 7102 7102 + if (stbi__get32be(s) != 0x38425053) { 7103 7103 + stbi__rewind(s); 7104 7104 + return 0; 7105 7105 + } 7106 7106 + if (stbi__get16be(s) != 1) { 7107 7107 + stbi__rewind(s); 7108 7108 + return 0; 7109 7109 + } 7110 7110 + stbi__skip(s, 6); 7111 7111 + channelCount = stbi__get16be(s); 7112 7112 + if (channelCount < 0 || channelCount > 16) { 7113 7113 + stbi__rewind(s); 7114 7114 + return 0; 7115 7115 + } 7116 7116 + (void)stbi__get32be(s); 7117 7117 + (void)stbi__get32be(s); 7118 7118 + depth = stbi__get16be(s); 7119 7119 + if (depth != 16) { 7120 7120 + stbi__rewind(s); 7121 7121 + return 0; 7122 7122 + } 7123 7123 + return 1; 6114 7124 } 6115 7125 #endif 6116 7126 6117 7127 #ifndef STBI_NO_PIC 6118 6118 - static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) 7128 7128 + static int stbi__pic_info(stbi__context* s, int* x, int* y, int* comp) 6119 7129 { 6120 6120 - int act_comp=0,num_packets=0,chained; 6121 6121 - stbi__pic_packet packets[10]; 7130 7130 + int act_comp = 0, num_packets = 0, chained, dummy; 7131 7131 + stbi__pic_packet packets[10]; 7132 7132 + 7133 7133 + if (!x) x = &dummy; 7134 7134 + if (!y) y = &dummy; 7135 7135 + if (!comp) comp = &dummy; 6122 7136 6123 6123 - if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { 6124 6124 - stbi__rewind(s); 6125 6125 - return 0; 6126 6126 - } 7137 7137 + if (!stbi__pic_is4(s, "\x53\x80\xF6\x34")) { 7138 7138 + stbi__rewind(s); 7139 7139 + return 0; 7140 7140 + } 6127 7141 6128 6128 - stbi__skip(s, 88); 7142 7142 + stbi__skip(s, 88); 6129 7143 6130 6130 - *x = stbi__get16be(s); 6131 6131 - *y = stbi__get16be(s); 6132 6132 - if (stbi__at_eof(s)) { 6133 6133 - stbi__rewind( s); 6134 6134 - return 0; 6135 6135 - } 6136 6136 - if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { 6137 6137 - stbi__rewind( s ); 6138 6138 - return 0; 6139 6139 - } 7144 7144 + *x = stbi__get16be(s); 7145 7145 + *y = stbi__get16be(s); 7146 7146 + if (stbi__at_eof(s)) { 7147 7147 + stbi__rewind(s); 7148 7148 + return 0; 7149 7149 + } 7150 7150 + if ((*x) != 0 && (1 << 28) / (*x) < (*y)) { 7151 7151 + stbi__rewind(s); 7152 7152 + return 0; 7153 7153 + } 6140 7154 6141 6141 - stbi__skip(s, 8); 7155 7155 + stbi__skip(s, 8); 6142 7156 6143 6143 - do { 6144 6144 - stbi__pic_packet *packet; 7157 7157 + do { 7158 7158 + stbi__pic_packet* packet; 6145 7159 6146 6146 - if (num_packets==sizeof(packets)/sizeof(packets[0])) 6147 6147 - return 0; 7160 7160 + if (num_packets == sizeof(packets) / sizeof(packets[0])) 7161 7161 + return 0; 6148 7162 6149 6149 - packet = &packets[num_packets++]; 6150 6150 - chained = stbi__get8(s); 6151 6151 - packet->size = stbi__get8(s); 6152 6152 - packet->type = stbi__get8(s); 6153 6153 - packet->channel = stbi__get8(s); 6154 6154 - act_comp |= packet->channel; 7163 7163 + packet = &packets[num_packets++]; 7164 7164 + chained = stbi__get8(s); 7165 7165 + packet->size = stbi__get8(s); 7166 7166 + packet->type = stbi__get8(s); 7167 7167 + packet->channel = stbi__get8(s); 7168 7168 + act_comp |= packet->channel; 6155 7169 6156 6156 - if (stbi__at_eof(s)) { 6157 6157 - stbi__rewind( s ); 6158 6158 - return 0; 6159 6159 - } 6160 6160 - if (packet->size != 8) { 6161 6161 - stbi__rewind( s ); 6162 6162 - return 0; 6163 6163 - } 6164 6164 - } while (chained); 7170 7170 + if (stbi__at_eof(s)) { 7171 7171 + stbi__rewind(s); 7172 7172 + return 0; 7173 7173 + } 7174 7174 + if (packet->size != 8) { 7175 7175 + stbi__rewind(s); 7176 7176 + return 0; 7177 7177 + } 7178 7178 + } while (chained); 6165 7179 6166 6166 - *comp = (act_comp & 0x10 ? 4 : 3); 7180 7180 + *comp = (act_comp & 0x10 ? 4 : 3); 6167 7181 6168 6168 - return 1; 7182 7182 + return 1; 6169 7183 } 6170 7184 #endif 6171 7185 ··· 6183 7197 6184 7198 #ifndef STBI_NO_PNM 6185 7199 6186 6186 - static int stbi__pnm_test(stbi__context *s) 7200 7200 + static int stbi__pnm_test(stbi__context* s) 6187 7201 { 6188 6188 - char p, t; 6189 6189 - p = (char) stbi__get8(s); 6190 6190 - t = (char) stbi__get8(s); 6191 6191 - if (p != 'P' || (t != '5' && t != '6')) { 6192 6192 - stbi__rewind( s ); 6193 6193 - return 0; 6194 6194 - } 6195 6195 - return 1; 7202 7202 + char p, t; 7203 7203 + p = (char)stbi__get8(s); 7204 7204 + t = (char)stbi__get8(s); 7205 7205 + if (p != 'P' || (t != '5' && t != '6')) { 7206 7206 + stbi__rewind(s); 7207 7207 + return 0; 7208 7208 + } 7209 7209 + return 1; 6196 7210 } 6197 7211 6198 6198 - static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) 7212 7212 + static void* stbi__pnm_load(stbi__context* s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri) 6199 7213 { 6200 6200 - stbi_uc *out; 6201 6201 - if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) 6202 6202 - return 0; 6203 6203 - *x = s->img_x; 6204 6204 - *y = s->img_y; 6205 6205 - *comp = s->img_n; 7214 7214 + stbi_uc* out; 7215 7215 + STBI_NOTUSED(ri); 6206 7216 6207 6207 - out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y); 6208 6208 - if (!out) return stbi__errpuc("outofmem", "Out of memory"); 6209 6209 - stbi__getn(s, out, s->img_n * s->img_x * s->img_y); 7217 7217 + if (!stbi__pnm_info(s, (int*)&s->img_x, (int*)&s->img_y, (int*)&s->img_n)) 7218 7218 + return 0; 6210 7219 6211 6211 - if (req_comp && req_comp != s->img_n) { 6212 6212 - out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); 6213 6213 - if (out == NULL) return out; // stbi__convert_format frees input on failure 6214 6214 - } 6215 6215 - return out; 7220 7220 + *x = s->img_x; 7221 7221 + *y = s->img_y; 7222 7222 + if (comp) *comp = s->img_n; 7223 7223 + 7224 7224 + if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) 7225 7225 + return stbi__errpuc("too large", "PNM too large"); 7226 7226 + 7227 7227 + out = (stbi_uc*)stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); 7228 7228 + if (!out) return stbi__errpuc("outofmem", "Out of memory"); 7229 7229 + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); 7230 7230 + 7231 7231 + if (req_comp && req_comp != s->img_n) { 7232 7232 + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); 7233 7233 + if (out == NULL) return out; // stbi__convert_format frees input on failure 7234 7234 + } 7235 7235 + return out; 6216 7236 } 6217 7237 6218 7238 static int stbi__pnm_isspace(char c) 6219 7239 { 6220 6220 - return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; 7240 7240 + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; 6221 7241 } 6222 7242 6223 6223 - static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) 7243 7243 + static void stbi__pnm_skip_whitespace(stbi__context* s, char* c) 6224 7244 { 6225 6225 - while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) 6226 6226 - *c = (char) stbi__get8(s); 7245 7245 + for (;;) { 7246 7246 + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) 7247 7247 + *c = (char)stbi__get8(s); 7248 7248 + 7249 7249 + if (stbi__at_eof(s) || *c != '#') 7250 7250 + break; 7251 7251 + 7252 7252 + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r') 7253 7253 + *c = (char)stbi__get8(s); 7254 7254 + } 6227 7255 } 6228 7256 6229 7257 static int stbi__pnm_isdigit(char c) 6230 7258 { 6231 6231 - return c >= '0' && c <= '9'; 7259 7259 + return c >= '0' && c <= '9'; 6232 7260 } 6233 7261 6234 6234 - static int stbi__pnm_getinteger(stbi__context *s, char *c) 7262 7262 + static int stbi__pnm_getinteger(stbi__context* s, char* c) 6235 7263 { 6236 6236 - int value = 0; 7264 7264 + int value = 0; 6237 7265 6238 6238 - while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { 6239 6239 - value = value*10 + (*c - '0'); 6240 6240 - *c = (char) stbi__get8(s); 6241 6241 - } 7266 7266 + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { 7267 7267 + value = value * 10 + (*c - '0'); 7268 7268 + *c = (char)stbi__get8(s); 7269 7269 + } 6242 7270 6243 6243 - return value; 7271 7271 + return value; 6244 7272 } 6245 7273 6246 6246 - static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) 7274 7274 + static int stbi__pnm_info(stbi__context* s, int* x, int* y, int* comp) 6247 7275 { 6248 6248 - int maxv; 6249 6249 - char c, p, t; 7276 7276 + int maxv, dummy; 7277 7277 + char c, p, t; 7278 7278 + 7279 7279 + if (!x) x = &dummy; 7280 7280 + if (!y) y = &dummy; 7281 7281 + if (!comp) comp = &dummy; 6250 7282 6251 6251 - stbi__rewind( s ); 7283 7283 + stbi__rewind(s); 6252 7284 6253 6253 - // Get identifier 6254 6254 - p = (char) stbi__get8(s); 6255 6255 - t = (char) stbi__get8(s); 6256 6256 - if (p != 'P' || (t != '5' && t != '6')) { 6257 6257 - stbi__rewind( s ); 6258 6258 - return 0; 6259 6259 - } 7285 7285 + // Get identifier 7286 7286 + p = (char)stbi__get8(s); 7287 7287 + t = (char)stbi__get8(s); 7288 7288 + if (p != 'P' || (t != '5' && t != '6')) { 7289 7289 + stbi__rewind(s); 7290 7290 + return 0; 7291 7291 + } 6260 7292 6261 6261 - *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm 7293 7293 + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm 6262 7294 6263 6263 - c = (char) stbi__get8(s); 6264 6264 - stbi__pnm_skip_whitespace(s, &c); 7295 7295 + c = (char)stbi__get8(s); 7296 7296 + stbi__pnm_skip_whitespace(s, &c); 6265 7297 6266 6266 - *x = stbi__pnm_getinteger(s, &c); // read width 6267 6267 - stbi__pnm_skip_whitespace(s, &c); 7298 7298 + *x = stbi__pnm_getinteger(s, &c); // read width 7299 7299 + stbi__pnm_skip_whitespace(s, &c); 6268 7300 6269 6269 - *y = stbi__pnm_getinteger(s, &c); // read height 6270 6270 - stbi__pnm_skip_whitespace(s, &c); 7301 7301 + *y = stbi__pnm_getinteger(s, &c); // read height 7302 7302 + stbi__pnm_skip_whitespace(s, &c); 6271 7303 6272 6272 - maxv = stbi__pnm_getinteger(s, &c); // read max value 7304 7304 + maxv = stbi__pnm_getinteger(s, &c); // read max value 6273 7305 6274 6274 - if (maxv > 255) 6275 6275 - return stbi__err("max value > 255", "PPM image not 8-bit"); 6276 6276 - else 6277 6277 - return 1; 7306 7306 + if (maxv > 255) 7307 7307 + return stbi__err("max value > 255", "PPM image not 8-bit"); 7308 7308 + else 7309 7309 + return 1; 6278 7310 } 6279 7311 #endif 6280 7312 6281 6281 - static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) 7313 7313 + static int stbi__info_main(stbi__context* s, int* x, int* y, int* comp) 6282 7314 { 6283 6283 - #ifndef STBI_NO_JPEG 6284 6284 - if (stbi__jpeg_info(s, x, y, comp)) return 1; 6285 6285 - #endif 7315 7315 + #ifndef STBI_NO_JPEG 7316 7316 + if (stbi__jpeg_info(s, x, y, comp)) return 1; 7317 7317 + #endif 6286 7318 6287 6287 - #ifndef STBI_NO_PNG 6288 6288 - if (stbi__png_info(s, x, y, comp)) return 1; 6289 6289 - #endif 7319 7319 + #ifndef STBI_NO_PNG 7320 7320 + if (stbi__png_info(s, x, y, comp)) return 1; 7321 7321 + #endif 6290 7322 6291 6291 - #ifndef STBI_NO_GIF 6292 6292 - if (stbi__gif_info(s, x, y, comp)) return 1; 6293 6293 - #endif 7323 7323 + #ifndef STBI_NO_GIF 7324 7324 + if (stbi__gif_info(s, x, y, comp)) return 1; 7325 7325 + #endif 6294 7326 6295 6295 - #ifndef STBI_NO_BMP 6296 6296 - if (stbi__bmp_info(s, x, y, comp)) return 1; 6297 6297 - #endif 7327 7327 + #ifndef STBI_NO_BMP 7328 7328 + if (stbi__bmp_info(s, x, y, comp)) return 1; 7329 7329 + #endif 6298 7330 6299 6299 - #ifndef STBI_NO_PSD 6300 6300 - if (stbi__psd_info(s, x, y, comp)) return 1; 6301 6301 - #endif 7331 7331 + #ifndef STBI_NO_PSD 7332 7332 + if (stbi__psd_info(s, x, y, comp)) return 1; 7333 7333 + #endif 6302 7334 6303 6303 - #ifndef STBI_NO_PIC 6304 6304 - if (stbi__pic_info(s, x, y, comp)) return 1; 6305 6305 - #endif 7335 7335 + #ifndef STBI_NO_PIC 7336 7336 + if (stbi__pic_info(s, x, y, comp)) return 1; 7337 7337 + #endif 6306 7338 6307 6307 - #ifndef STBI_NO_PNM 6308 6308 - if (stbi__pnm_info(s, x, y, comp)) return 1; 6309 6309 - #endif 7339 7339 + #ifndef STBI_NO_PNM 7340 7340 + if (stbi__pnm_info(s, x, y, comp)) return 1; 7341 7341 + #endif 6310 7342 6311 6311 - #ifndef STBI_NO_HDR 6312 6312 - if (stbi__hdr_info(s, x, y, comp)) return 1; 6313 6313 - #endif 7343 7343 + #ifndef STBI_NO_HDR 7344 7344 + if (stbi__hdr_info(s, x, y, comp)) return 1; 7345 7345 + #endif 6314 7346 6315 6315 - // test tga last because it's a crappy test! 6316 6316 - #ifndef STBI_NO_TGA 6317 6317 - if (stbi__tga_info(s, x, y, comp)) 6318 6318 - return 1; 6319 6319 - #endif 6320 6320 - return stbi__err("unknown image type", "Image not of any known type, or corrupt"); 7347 7347 + // test tga last because it's a crappy test! 7348 7348 + #ifndef STBI_NO_TGA 7349 7349 + if (stbi__tga_info(s, x, y, comp)) 7350 7350 + return 1; 7351 7351 + #endif 7352 7352 + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); 7353 7353 + } 7354 7354 + 7355 7355 + static int stbi__is_16_main(stbi__context* s) 7356 7356 + { 7357 7357 + #ifndef STBI_NO_PNG 7358 7358 + if (stbi__png_is16(s)) return 1; 7359 7359 + #endif 7360 7360 + 7361 7361 + #ifndef STBI_NO_PSD 7362 7362 + if (stbi__psd_is16(s)) return 1; 7363 7363 + #endif 7364 7364 + 7365 7365 + return 0; 6321 7366 } 6322 7367 6323 7368 #ifndef STBI_NO_STDIO 6324 6324 - STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) 7369 7369 + STBIDEF int stbi_info(char const* filename, int* x, int* y, int* comp) 6325 7370 { 6326 6326 - FILE *f = stbi__fopen(filename, "rb"); 7371 7371 + FILE* f = stbi__fopen(filename, "rb"); 6327 7372 int result; 6328 7373 if (!f) return stbi__err("can't fopen", "Unable to open file"); 6329 7374 result = stbi_info_from_file(f, x, y, comp); ··· 6331 7376 return result; 6332 7377 } 6333 7378 6334 6334 - STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) 7379 7379 + STBIDEF int stbi_info_from_file(FILE* f, int* x, int* y, int* comp) 7380 7380 + { 7381 7381 + int r; 7382 7382 + stbi__context s; 7383 7383 + long pos = ftell(f); 7384 7384 + stbi__start_file(&s, f); 7385 7385 + r = stbi__info_main(&s, x, y, comp); 7386 7386 + fseek(f, pos, SEEK_SET); 7387 7387 + return r; 7388 7388 + } 7389 7389 + 7390 7390 + STBIDEF int stbi_is_16_bit(char const* filename) 7391 7391 + { 7392 7392 + FILE* f = stbi__fopen(filename, "rb"); 7393 7393 + int result; 7394 7394 + if (!f) return stbi__err("can't fopen", "Unable to open file"); 7395 7395 + result = stbi_is_16_bit_from_file(f); 7396 7396 + fclose(f); 7397 7397 + return result; 7398 7398 + } 7399 7399 + 7400 7400 + STBIDEF int stbi_is_16_bit_from_file(FILE* f) 6335 7401 { 6336 6336 - int r; 6337 6337 - stbi__context s; 6338 6338 - long pos = ftell(f); 6339 6339 - stbi__start_file(&s, f); 6340 6340 - r = stbi__info_main(&s,x,y,comp); 6341 6341 - fseek(f,pos,SEEK_SET); 6342 6342 - return r; 7402 7402 + int r; 7403 7403 + stbi__context s; 7404 7404 + long pos = ftell(f); 7405 7405 + stbi__start_file(&s, f); 7406 7406 + r = stbi__is_16_main(&s); 7407 7407 + fseek(f, pos, SEEK_SET); 7408 7408 + return r; 6343 7409 } 6344 7410 #endif // !STBI_NO_STDIO 6345 7411 6346 6346 - STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) 7412 7412 + STBIDEF int stbi_info_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp) 6347 7413 { 6348 6348 - stbi__context s; 6349 6349 - stbi__start_mem(&s,buffer,len); 6350 6350 - return stbi__info_main(&s,x,y,comp); 7414 7414 + stbi__context s; 7415 7415 + stbi__start_mem(&s, buffer, len); 7416 7416 + return stbi__info_main(&s, x, y, comp); 6351 7417 } 6352 7418 6353 6353 - STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) 7419 7419 + STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const* c, void* user, int* x, int* y, int* comp) 6354 7420 { 6355 6355 - stbi__context s; 6356 6356 - stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); 6357 6357 - return stbi__info_main(&s,x,y,comp); 7421 7421 + stbi__context s; 7422 7422 + stbi__start_callbacks(&s, (stbi_io_callbacks*)c, user); 7423 7423 + return stbi__info_main(&s, x, y, comp); 7424 7424 + } 7425 7425 + 7426 7426 + STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const* buffer, int len) 7427 7427 + { 7428 7428 + stbi__context s; 7429 7429 + stbi__start_mem(&s, buffer, len); 7430 7430 + return stbi__is_16_main(&s); 7431 7431 + } 7432 7432 + 7433 7433 + STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const* c, void* user) 7434 7434 + { 7435 7435 + stbi__context s; 7436 7436 + stbi__start_callbacks(&s, (stbi_io_callbacks*)c, user); 7437 7437 + return stbi__is_16_main(&s); 6358 7438 } 6359 7439 6360 7440 #endif // STB_IMAGE_IMPLEMENTATION 6361 7441 6362 7442 /* 6363 7443 revision history: 7444 7444 + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 7445 7445 + 2.19 (2018-02-11) fix warning 7446 7446 + 2.18 (2018-01-30) fix warnings 7447 7447 + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug 7448 7448 + 1-bit BMP 7449 7449 + *_is_16_bit api 7450 7450 + avoid warnings 7451 7451 + 2.16 (2017-07-23) all functions have 16-bit variants; 7452 7452 + STBI_NO_STDIO works again; 7453 7453 + compilation fixes; 7454 7454 + fix rounding in unpremultiply; 7455 7455 + optimize vertical flip; 7456 7456 + disable raw_len validation; 7457 7457 + documentation fixes 7458 7458 + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; 7459 7459 + warning fixes; disable run-time SSE detection on gcc; 7460 7460 + uniform handling of optional "return" values; 7461 7461 + thread-safe initialization of zlib tables 7462 7462 + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs 7463 7463 + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now 7464 7464 + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes 7465 7465 + 2.11 (2016-04-02) allocate large structures on the stack 7466 7466 + remove white matting for transparent PSD 7467 7467 + fix reported channel count for PNG & BMP 7468 7468 + re-enable SSE2 in non-gcc 64-bit 7469 7469 + support RGB-formatted JPEG 7470 7470 + read 16-bit PNGs (only as 8-bit) 7471 7471 + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED 7472 7472 + 2.09 (2016-01-16) allow comments in PNM files 7473 7473 + 16-bit-per-pixel TGA (not bit-per-component) 7474 7474 + info() for TGA could break due to .hdr handling 7475 7475 + info() for BMP to shares code instead of sloppy parse 7476 7476 + can use STBI_REALLOC_SIZED if allocator doesn't support realloc 7477 7477 + code cleanup 6364 7478 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA 6365 7479 2.07 (2015-09-13) fix compiler warnings 6366 7480 partial animated GIF support 6367 6367 - limited 16-bit PSD support 7481 7481 + limited 16-bpc PSD support 6368 7482 #ifdef unused functions 6369 7483 bug with < 92 byte PIC,PNM,HDR,TGA 6370 7484 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value ··· 6507 7621 0.50 (2006-11-19) 6508 7622 first released version 6509 7623 */ 7624 7624 + 7625 7625 + 7626 7626 + /* 7627 7627 + ------------------------------------------------------------------------------ 7628 7628 + This software is available under 2 licenses -- choose whichever you prefer. 7629 7629 + ------------------------------------------------------------------------------ 7630 7630 + ALTERNATIVE A - MIT License 7631 7631 + Copyright (c) 2017 Sean Barrett 7632 7632 + Permission is hereby granted, free of charge, to any person obtaining a copy of 7633 7633 + this software and associated documentation files (the "Software"), to deal in 7634 7634 + the Software without restriction, including without limitation the rights to 7635 7635 + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 7636 7636 + of the Software, and to permit persons to whom the Software is furnished to do 7637 7637 + so, subject to the following conditions: 7638 7638 + The above copyright notice and this permission notice shall be included in all 7639 7639 + copies or substantial portions of the Software. 7640 7640 + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 7641 7641 + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 7642 7642 + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 7643 7643 + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 7644 7644 + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 7645 7645 + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 7646 7646 + SOFTWARE. 7647 7647 + ------------------------------------------------------------------------------ 7648 7648 + ALTERNATIVE B - Public Domain (www.unlicense.org) 7649 7649 + This is free and unencumbered software released into the public domain. 7650 7650 + Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 7651 7651 + software, either in source code form or as a compiled binary, for any purpose, 7652 7652 + commercial or non-commercial, and by any means. 7653 7653 + In jurisdictions that recognize copyright laws, the author or authors of this 7654 7654 + software dedicate any and all copyright interest in the software to the public 7655 7655 + domain. We make this dedication for the benefit of the public at large and to 7656 7656 + the detriment of our heirs and successors. We intend this dedication to be an 7657 7657 + overt act of relinquishment in perpetuity of all present and future rights to 7658 7658 + this software under copyright law. 7659 7659 + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 7660 7660 + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 7661 7661 + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 7662 7662 + AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 7663 7663 + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 7664 7664 + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 7665 7665 + ------------------------------------------------------------------------------ 7666 7666 + */

+4

tests/pixel-perfect/main.c

reviewed

··· 174 174 // Blitting 175 175 GPU_Blit(image, NULL, screen, x + image->w/2, y + image->h/2); 176 176 GPU_Blit(image2, NULL, screen, x + image2->w/2, y + image->h + image2->h/2); 177 177 + 178 178 + float scale = 2.0f; 179 179 + GPU_BlitScale(image, NULL, screen, x + image->w + scale * image->w / 2, y + scale * image->h / 2, 2, 2); 180 180 + GPU_BlitScale(image2, NULL, screen, x + image2->w + scale * image2->w / 2, y + scale * image->h + scale * image2->h / 2, 2, 2); 177 181 } 178 182 else if(mode == 1) 179 183 {