diff options
Diffstat (limited to 'mwe/resource-manager/stb_image.h')
| -rw-r--r-- | mwe/resource-manager/stb_image.h | 1502 |
1 files changed, 576 insertions, 926 deletions
diff --git a/mwe/resource-manager/stb_image.h b/mwe/resource-manager/stb_image.h index ce0cc10..ceff2b6 100644 --- a/mwe/resource-manager/stb_image.h +++ b/mwe/resource-manager/stb_image.h @@ -410,9 +410,8 @@ typedef struct { int (*read)( void * user, char * data, int size); // fill 'data' with 'size' bytes. return number of bytes actually read - void (*skip)( - void * user, - int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + void (*skip)(void * user, + int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative int (*eof)(void * user); // returns nonzero if we are at end of file/data } stbi_io_callbacks; @@ -421,33 +420,28 @@ typedef struct { // 8-bits-per-channel interface // -STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc const * buffer, int len, - int * x, int * y, - int * channels_in_file, - int desired_channels); -STBIDEF stbi_uc * stbi_load_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * channels_in_file, +STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * channels_in_file, int desired_channels); +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); #ifndef STBI_NO_STDIO -STBIDEF stbi_uc * stbi_load(char const * filename, int * x, int * y, - int * channels_in_file, int desired_channels); -STBIDEF stbi_uc * stbi_load_from_file(FILE * f, int * x, int * y, - int * channels_in_file, +STBIDEF stbi_uc * stbi_load(char const * filename, int * x, int * y, int * channels_in_file, + int desired_channels); +STBIDEF stbi_uc * stbi_load_from_file(FILE * f, int * x, int * y, int * channels_in_file, int desired_channels); // for stbi_load_from_file, file pointer is left pointing immediately after image #endif #ifndef STBI_NO_GIF -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); +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); #endif #ifdef STBI_WINDOWS_UTF8 -STBIDEF int stbi_convert_wchar_to_utf8(char * buffer, size_t bufferlen, - const wchar_t * input); +STBIDEF int stbi_convert_wchar_to_utf8(char * buffer, size_t bufferlen, const wchar_t * input); #endif //////////////////////////////////// @@ -455,20 +449,16 @@ STBIDEF int stbi_convert_wchar_to_utf8(char * buffer, size_t bufferlen, // 16-bits-per-channel interface // -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); -STBIDEF stbi_us * stbi_load_16_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * channels_in_file, +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); +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); #ifndef STBI_NO_STDIO -STBIDEF stbi_us * stbi_load_16(char const * filename, int * x, int * y, - int * channels_in_file, int desired_channels); -STBIDEF stbi_us * stbi_load_from_file_16(FILE * f, int * x, int * y, - int * channels_in_file, +STBIDEF stbi_us * stbi_load_16(char const * filename, int * x, int * y, int * channels_in_file, + int desired_channels); +STBIDEF stbi_us * stbi_load_from_file_16(FILE * f, int * x, int * y, int * channels_in_file, int desired_channels); #endif @@ -477,19 +467,16 @@ STBIDEF stbi_us * stbi_load_from_file_16(FILE * f, int * x, int * y, // float-per-channel interface // #ifndef STBI_NO_LINEAR -STBIDEF float * stbi_loadf_from_memory(stbi_uc const * buffer, int len, int * x, - int * y, int * channels_in_file, - int desired_channels); -STBIDEF float * stbi_loadf_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * channels_in_file, +STBIDEF float * stbi_loadf_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * channels_in_file, int desired_channels); +STBIDEF float * stbi_loadf_from_callbacks(stbi_io_callbacks const * clbk, void * user, int * x, + int * y, int * channels_in_file, int desired_channels); #ifndef STBI_NO_STDIO -STBIDEF float * stbi_loadf(char const * filename, int * x, int * y, - int * channels_in_file, int desired_channels); -STBIDEF float * stbi_loadf_from_file(FILE * f, int * x, int * y, - int * channels_in_file, +STBIDEF float * stbi_loadf(char const * filename, int * x, int * y, int * channels_in_file, + int desired_channels); +STBIDEF float * stbi_loadf_from_file(FILE * f, int * x, int * y, int * channels_in_file, int desired_channels); #endif #endif @@ -505,8 +492,7 @@ STBIDEF void stbi_ldr_to_hdr_scale(float scale); #endif // STBI_NO_LINEAR // stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR -STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const * clbk, - void * user); +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const * clbk, void * user); STBIDEF int stbi_is_hdr_from_memory(stbi_uc const * buffer, int len); #ifndef STBI_NO_STDIO STBIDEF int stbi_is_hdr(char const * filename); @@ -521,13 +507,12 @@ STBIDEF const char * stbi_failure_reason(void); STBIDEF void stbi_image_free(void * retval_from_stbi_load); // get image dimensions & components without fully decoding -STBIDEF int stbi_info_from_memory(stbi_uc const * buffer, int len, int * x, - int * y, int * comp); -STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, int * comp); +STBIDEF int stbi_info_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const * clbk, void * user, int * x, + int * y, int * comp); STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const * buffer, int len); -STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const * clbk, - void * user); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const * clbk, void * user); #ifndef STBI_NO_STDIO STBIDEF int stbi_info(char const * filename, int * x, int * y, int * comp); @@ -539,8 +524,7 @@ STBIDEF int stbi_is_16_bit_from_file(FILE * f); // for image formats that explicitly notate that they have premultiplied alpha, // we just return the colors as stored in the file. set this flag to force // unpremultiplication. results are undefined if the unpremultiply overflow. -STBIDEF void -stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); // indicate whether we should process iphone images back to canonical format, // or just pass them through "as-is" @@ -552,32 +536,23 @@ STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); // as above, but only applies to images loaded on the thread that calls the function // this function is only available if your compiler supports thread-local variables; // calling it will fail to link if your compiler doesn't -STBIDEF void -stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); -STBIDEF void -stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); -STBIDEF void -stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); // ZLIB client - used by PNG, available for other purposes STBIDEF char * stbi_zlib_decode_malloc_guesssize(const char * buffer, int len, - int initial_size, - int * outlen); -STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer, - int len, - int initial_size, - int * outlen, + int initial_size, int * outlen); +STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer, int len, + int initial_size, int * outlen, int parse_header); -STBIDEF char * stbi_zlib_decode_malloc(const char * buffer, int len, - int * outlen); -STBIDEF int stbi_zlib_decode_buffer(char * obuffer, int olen, - const char * ibuffer, int ilen); +STBIDEF char * stbi_zlib_decode_malloc(const char * buffer, int len, int * outlen); +STBIDEF int stbi_zlib_decode_buffer(char * obuffer, int olen, const char * ibuffer, int ilen); -STBIDEF char * stbi_zlib_decode_noheader_malloc(const char * buffer, int len, - int * outlen); -STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, - const char * ibuffer, int ilen); +STBIDEF char * stbi_zlib_decode_noheader_malloc(const char * buffer, int len, int * outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, const char * ibuffer, + int ilen); #ifdef __cplusplus } @@ -590,11 +565,10 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, #ifdef STB_IMAGE_IMPLEMENTATION -#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) \ - || defined(STBI_ONLY_BMP) || defined(STBI_ONLY_TGA) \ - || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ - || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) \ - || defined(STBI_ONLY_PNM) || defined(STBI_ONLY_ZLIB) +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) #ifndef STBI_ONLY_JPEG #define STBI_NO_JPEG #endif @@ -624,8 +598,7 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, #endif #endif -#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) \ - && !defined(STBI_NO_ZLIB) +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) #define STBI_NO_ZLIB #endif @@ -671,8 +644,7 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, #define STBI_THREAD_LOCAL __thread #elif defined(_MSC_VER) #define STBI_THREAD_LOCAL __declspec(thread) -#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \ - && !defined(__STDC_NO_THREADS__) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) #define STBI_THREAD_LOCAL _Thread_local #endif @@ -755,8 +727,8 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32) == 4 ? 1 : -1]; #define STBI_NO_SIMD #endif -#if defined(__MINGW32__) && defined(STBI__X86_TARGET) \ - && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) \ + && !defined(STBI_NO_SIMD) // Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET // // 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the @@ -771,8 +743,7 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32) == 4 ? 1 : -1]; #define STBI_NO_SIMD #endif -#if !defined(STBI_NO_SIMD) \ - && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) #define STBI_SSE2 #include <emmintrin.h> @@ -868,8 +839,7 @@ typedef struct { static void stbi__refill_buffer(stbi__context * s); // initialize a memory-decode context -static void stbi__start_mem(stbi__context * s, stbi_uc const * buffer, - int len) { +static void stbi__start_mem(stbi__context * s, stbi_uc const * buffer, int len) { s->io.read = NULL; s->read_from_callbacks = 0; s->callback_already_read = 0; @@ -878,8 +848,7 @@ static void stbi__start_mem(stbi__context * s, stbi_uc const * buffer, } // initialize a callback-based context -static void stbi__start_callbacks(stbi__context * s, stbi_io_callbacks * c, - void * user) { +static void stbi__start_callbacks(stbi__context * s, stbi_io_callbacks * c, void * user) { s->io = *c; s->io_user_data = user; s->buflen = sizeof(s->buffer_start); @@ -941,68 +910,68 @@ typedef struct { #ifndef STBI_NO_JPEG static int stbi__jpeg_test(stbi__context * s); -static void * stbi__jpeg_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__jpeg_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__jpeg_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_PNG static int stbi__png_test(stbi__context * s); -static void * stbi__png_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__png_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__png_info(stbi__context * s, int * x, int * y, int * comp); static int stbi__png_is16(stbi__context * s); #endif #ifndef STBI_NO_BMP static int stbi__bmp_test(stbi__context * s); -static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__bmp_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_TGA static int stbi__tga_test(stbi__context * s); -static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__tga_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_PSD static int stbi__psd_test(stbi__context * s); -static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri, int bpc); +static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri, int bpc); static int stbi__psd_info(stbi__context * s, int * x, int * y, int * comp); static int stbi__psd_is16(stbi__context * s); #endif #ifndef STBI_NO_HDR static int stbi__hdr_test(stbi__context * s); -static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__hdr_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_PIC static int stbi__pic_test(stbi__context * s); -static void * stbi__pic_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__pic_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__pic_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_GIF static int stbi__gif_test(stbi__context * s); -static void * stbi__gif_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); -static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, - int * y, int * z, int * comp, int req_comp); +static void * stbi__gif_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); +static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, int * y, int * z, + int * comp, int req_comp); static int stbi__gif_info(stbi__context * s, int * x, int * y, int * comp); #endif #ifndef STBI_NO_PNM static int stbi__pnm_test(stbi__context * s); -static void * stbi__pnm_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri); +static void * stbi__pnm_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri); static int stbi__pnm_info(stbi__context * s, int * x, int * y, int * comp); static int stbi__pnm_is16(stbi__context * s); #endif @@ -1013,9 +982,7 @@ static #endif const char * stbi__g_failure_reason; -STBIDEF const char * stbi_failure_reason(void) { - return stbi__g_failure_reason; -} +STBIDEF const char * stbi_failure_reason(void) { return stbi__g_failure_reason; } #ifndef STBI_NO_FAILURE_STRINGS static int stbi__err(const char * str) { @@ -1074,8 +1041,7 @@ static int stbi__mad3sizes_valid(int a, int b, int c, int add) { #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) { return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) - && stbi__mul2sizes_valid(a * b * c, d) - && stbi__addsizes_valid(a * b * c * d, add); + && stbi__mul2sizes_valid(a * b * c, d) && stbi__addsizes_valid(a * b * c * d, add); } #endif @@ -1102,8 +1068,7 @@ static void * stbi__malloc_mad4(int a, int b, int c, int d, int add) { // returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. static int stbi__addints_valid(int a, int b) { - if ((a >= 0) != (b >= 0)) - return 1; // a and b have different signs, so no overflow + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow if (a < 0 && b < 0) return a >= INT_MIN @@ -1116,9 +1081,7 @@ static int stbi__mul2shorts_valid(int a, int b) { if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow if ((a >= 0) == (b >= 0)) - return a - <= SHRT_MAX - / b; // product is positive, so similar to mul2sizes_valid + return a <= SHRT_MAX / b; // product is positive, so similar to mul2sizes_valid if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN return a >= SHRT_MIN / b; } @@ -1136,8 +1099,7 @@ static int stbi__mul2shorts_valid(int a, int b) { #endif #define stbi__errpf(x, y) ((float *) (size_t) (stbi__err(x, y) ? NULL : NULL)) -#define stbi__errpuc(x, y) \ - ((unsigned char *) (size_t) (stbi__err(x, y) ? NULL : NULL)) +#define stbi__errpuc(x, y) ((unsigned char *) (size_t) (stbi__err(x, y) ? NULL : NULL)) STBIDEF void stbi_image_free(void * retval_from_stbi_load) { STBI_FREE(retval_from_stbi_load); @@ -1163,8 +1125,7 @@ STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) { static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; -STBIDEF void -stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) { +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) { stbi__vertically_flip_on_load_local = flag_true_if_should_flip; stbi__vertically_flip_on_load_set = 1; } @@ -1174,12 +1135,11 @@ stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) { : stbi__vertically_flip_on_load_global) #endif // STBI_THREAD_LOCAL -static void * stbi__load_main(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri, int bpc) { +static void * stbi__load_main(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri, int bpc) { memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields - ri->bits_per_channel - = 8; // default is 8 so most paths don't have to be changed + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order ri->num_channels = 0; @@ -1196,8 +1156,7 @@ static void * stbi__load_main(stbi__context * s, int * x, int * y, int * comp, if (stbi__gif_test(s)) return stbi__gif_load(s, x, y, comp, req_comp, ri); #endif #ifndef STBI_NO_PSD - if (stbi__psd_test(s)) - return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc); + if (stbi__psd_test(s)) return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc); #else STBI_NOTUSED(bpc); #endif @@ -1227,12 +1186,10 @@ static void * stbi__load_main(stbi__context * s, int * x, int * y, int * comp, if (stbi__tga_test(s)) return stbi__tga_load(s, x, y, comp, req_comp, ri); #endif - return stbi__errpuc("unknown image type", - "Image not of any known type, or corrupt"); + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); } -static stbi_uc * stbi__convert_16_to_8(stbi__uint16 * orig, int w, int h, - int channels) { +static stbi_uc * stbi__convert_16_to_8(stbi__uint16 * orig, int w, int h, int channels) { int i; int img_len = w * h * channels; stbi_uc * reduced; @@ -1249,15 +1206,13 @@ static stbi_uc * stbi__convert_16_to_8(stbi__uint16 * orig, int w, int h, return reduced; } -static stbi__uint16 * stbi__convert_8_to_16(stbi_uc * orig, int w, int h, - int channels) { +static stbi__uint16 * stbi__convert_8_to_16(stbi_uc * orig, int w, int h, int channels) { int i; int img_len = w * h * channels; stbi__uint16 * enlarged; enlarged = (stbi__uint16 *) stbi__malloc(img_len * 2); - if (enlarged == NULL) - return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); for (i = 0; i < img_len; ++i) enlarged[i] @@ -1269,8 +1224,7 @@ static stbi__uint16 * stbi__convert_8_to_16(stbi_uc * orig, int w, int h, return enlarged; } -static void stbi__vertical_flip(void * image, int w, int h, - int bytes_per_pixel) { +static void stbi__vertical_flip(void * image, int w, int h, int bytes_per_pixel) { int row; size_t bytes_per_row = (size_t) w * bytes_per_pixel; stbi_uc temp[2048]; @@ -1282,8 +1236,7 @@ static void stbi__vertical_flip(void * image, int w, int h, // swap row0 with row1 size_t bytes_left = bytes_per_row; while (bytes_left) { - size_t bytes_copy - = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); memcpy(temp, row0, bytes_copy); memcpy(row0, row1, bytes_copy); memcpy(row1, temp, bytes_copy); @@ -1308,10 +1261,8 @@ static void stbi__vertical_flip_slices(void * image, int w, int h, int z, } #endif -static unsigned char * stbi__load_and_postprocess_8bit(stbi__context * s, - int * x, int * y, - int * comp, - int req_comp) { +static unsigned char * stbi__load_and_postprocess_8bit(stbi__context * s, int * x, int * y, + int * comp, int req_comp) { stbi__result_info ri; void * result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); @@ -1336,10 +1287,8 @@ static unsigned char * stbi__load_and_postprocess_8bit(stbi__context * s, return (unsigned char *) result; } -static stbi__uint16 * stbi__load_and_postprocess_16bit(stbi__context * s, - int * x, int * y, - int * comp, - int req_comp) { +static stbi__uint16 * stbi__load_and_postprocess_16bit(stbi__context * s, int * x, int * y, + int * comp, int req_comp) { stbi__result_info ri; void * result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); @@ -1366,8 +1315,8 @@ static stbi__uint16 * stbi__load_and_postprocess_16bit(stbi__context * s, } #if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) -static void stbi__float_postprocess(float * result, int * x, int * y, - int * comp, int req_comp) { +static void stbi__float_postprocess(float * result, int * x, int * y, int * comp, + int req_comp) { if (stbi__vertically_flip_on_load && result != NULL) { int channels = req_comp ? req_comp : *comp; stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); @@ -1378,19 +1327,21 @@ static void stbi__float_postprocess(float * result, int * x, int * y, #ifndef STBI_NO_STDIO #if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) -STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar( - unsigned int cp, unsigned long flags, const char * str, int cbmb, - wchar_t * widestr, int cchwide); +STBI_EXTERN + __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, + unsigned long flags, + const char * str, int cbmb, + wchar_t * widestr, int cchwide); 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); + unsigned int cp, unsigned long flags, const wchar_t * widestr, int cchwide, char * str, + int cbmb, const char * defchar, int * used_default); #endif #if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) STBIDEF int stbi_convert_wchar_to_utf8(char * buffer, size_t bufferlen, const wchar_t * input) { - return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, - (int) bufferlen, NULL, NULL); + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, + NULL); } #endif @@ -1433,8 +1384,7 @@ STBIDEF stbi_uc * stbi_load(char const * filename, int * x, int * y, int * comp, return result; } -STBIDEF stbi_uc * stbi_load_from_file(FILE * f, int * x, int * y, int * comp, - int req_comp) { +STBIDEF stbi_uc * stbi_load_from_file(FILE * f, int * x, int * y, int * comp, int req_comp) { unsigned char * result; stbi__context s; stbi__start_file(&s, f); @@ -1446,8 +1396,8 @@ STBIDEF stbi_uc * stbi_load_from_file(FILE * f, int * x, int * y, int * comp, return result; } -STBIDEF stbi__uint16 * stbi_load_from_file_16(FILE * f, int * x, int * y, - int * comp, int req_comp) { +STBIDEF stbi__uint16 * stbi_load_from_file_16(FILE * f, int * x, int * y, int * comp, + int req_comp) { stbi__uint16 * result; stbi__context s; stbi__start_file(&s, f); @@ -1459,12 +1409,11 @@ STBIDEF stbi__uint16 * stbi_load_from_file_16(FILE * f, int * x, int * y, return result; } -STBIDEF stbi_us * stbi_load_16(char const * filename, int * x, int * y, - int * comp, int req_comp) { +STBIDEF stbi_us * stbi_load_16(char const * filename, int * x, int * y, int * comp, + int req_comp) { FILE * f = stbi__fopen(filename, "rb"); stbi__uint16 * result; - if (!f) - return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); result = stbi_load_from_file_16(f, x, y, comp, req_comp); fclose(f); return result; @@ -1472,52 +1421,44 @@ STBIDEF stbi_us * stbi_load_16(char const * filename, int * x, int * y, #endif //!STBI_NO_STDIO -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) { +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) { stbi__context s; stbi__start_mem(&s, buffer, len); - return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, - desired_channels); + return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels); } -STBIDEF stbi_us * stbi_load_16_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * channels_in_file, +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) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); - return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, - desired_channels); + return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels); } -STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc const * buffer, int len, - int * x, int * y, int * comp, - int req_comp) { +STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * comp, int req_comp) { stbi__context s; stbi__start_mem(&s, buffer, len); return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp); } -STBIDEF stbi_uc * stbi_load_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * comp, int req_comp) { +STBIDEF stbi_uc * stbi_load_from_callbacks(stbi_io_callbacks const * clbk, void * user, + int * x, int * y, int * comp, int req_comp) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp); } #ifndef STBI_NO_GIF -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) { +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) { unsigned char * result; stbi__context s; stbi__start_mem(&s, buffer, len); - result = (unsigned char *) stbi__load_gif_main(&s, delays, x, y, z, comp, - req_comp); + result = (unsigned char *) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); if (stbi__vertically_flip_on_load) { stbi__vertical_flip_slices(result, *x, *y, *z, *comp); } @@ -1539,30 +1480,26 @@ static float * stbi__loadf_main(stbi__context * s, int * x, int * y, int * comp, } #endif data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); - if (data) - return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); - return stbi__errpf("unknown image type", - "Image not of any known type, or corrupt"); + if (data) return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); } -STBIDEF float * stbi_loadf_from_memory(stbi_uc const * buffer, int len, int * x, - int * y, int * comp, int req_comp) { +STBIDEF float * stbi_loadf_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * comp, int req_comp) { stbi__context s; stbi__start_mem(&s, buffer, len); return stbi__loadf_main(&s, x, y, comp, req_comp); } -STBIDEF float * stbi_loadf_from_callbacks(stbi_io_callbacks const * clbk, - void * user, int * x, int * y, - int * comp, int req_comp) { +STBIDEF float * stbi_loadf_from_callbacks(stbi_io_callbacks const * clbk, void * user, int * x, + int * y, int * comp, int req_comp) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); return stbi__loadf_main(&s, x, y, comp, req_comp); } #ifndef STBI_NO_STDIO -STBIDEF float * stbi_loadf(char const * filename, int * x, int * y, int * comp, - int req_comp) { +STBIDEF float * stbi_loadf(char const * filename, int * x, int * y, int * comp, int req_comp) { float * result; FILE * f = stbi__fopen(filename, "rb"); if (!f) return stbi__errpf("can't fopen", "Unable to open file"); @@ -1571,8 +1508,7 @@ STBIDEF float * stbi_loadf(char const * filename, int * x, int * y, int * comp, return result; } -STBIDEF float * stbi_loadf_from_file(FILE * f, int * x, int * y, int * comp, - int req_comp) { +STBIDEF float * stbi_loadf_from_file(FILE * f, int * x, int * y, int * comp, int req_comp) { stbi__context s; stbi__start_file(&s, f); return stbi__loadf_main(&s, x, y, comp, req_comp); @@ -1624,8 +1560,7 @@ STBIDEF int stbi_is_hdr_from_file(FILE * f) { } #endif // !STBI_NO_STDIO -STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const * clbk, - void * user) { +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const * clbk, void * user) { #ifndef STBI_NO_HDR stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); @@ -1646,12 +1581,8 @@ STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } static float stbi__h2l_gamma_i = 1.0f / 2.2f, stbi__h2l_scale_i = 1.0f; -STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { - stbi__h2l_gamma_i = 1 / gamma; -} -STBIDEF void stbi_hdr_to_ldr_scale(float scale) { - stbi__h2l_scale_i = 1 / scale; -} +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1 / gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1 / scale; } ////////////////////////////////////////////////////////////////////////////// // @@ -1736,8 +1667,7 @@ static int stbi__getn(stbi__context * s, stbi_uc * buffer, int n) { memcpy(buffer, s->img_buffer, blen); - count = (s->io.read)(s->io_user_data, (char *) buffer + blen, - n - blen); + count = (s->io.read)(s->io_user_data, (char *) buffer + blen, n - blen); res = (count == (n - blen)); s->img_buffer = s->img_buffer_end; return res; @@ -1788,8 +1718,7 @@ static stbi__uint32 stbi__get32le(stbi__context * s) { } #endif -#define STBI__BYTECAST(x) \ - ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) \ && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) \ @@ -1817,9 +1746,8 @@ static stbi_uc stbi__compute_y(int r, int g, int b) { && defined(STBI_NO_PNM) // nothing #else -static unsigned char * stbi__convert_format(unsigned char * data, int img_n, - int req_comp, unsigned int x, - unsigned int y) { +static unsigned char * stbi__convert_format(unsigned char * data, int img_n, int req_comp, + unsigned int x, unsigned int y) { int i, j; unsigned char * good; @@ -1871,18 +1799,14 @@ static unsigned char * stbi__convert_format(unsigned char * data, int img_n, dest[3] = 255; } break; - STBI__CASE(3, 1) { - dest[0] = stbi__compute_y(src[0], src[1], src[2]); - } + STBI__CASE(3, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); } break; STBI__CASE(3, 2) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); dest[1] = 255; } break; - STBI__CASE(4, 1) { - dest[0] = stbi__compute_y(src[0], src[1], src[2]); - } + STBI__CASE(4, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); } break; STBI__CASE(4, 2) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); @@ -1899,8 +1823,7 @@ static unsigned char * stbi__convert_format(unsigned char * data, int img_n, STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); - return stbi__errpuc("unsupported", - "Unsupported format conversion"); + return stbi__errpuc("unsupported", "Unsupported format conversion"); } #undef STBI__CASE } @@ -1921,9 +1844,8 @@ static stbi__uint16 stbi__compute_y_16(int r, int g, int b) { #if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) // nothing #else -static stbi__uint16 * stbi__convert_format16(stbi__uint16 * data, int img_n, - int req_comp, unsigned int x, - unsigned int y) { +static stbi__uint16 * stbi__convert_format16(stbi__uint16 * data, int img_n, int req_comp, + unsigned int x, unsigned int y) { int i, j; stbi__uint16 * good; @@ -1975,18 +1897,14 @@ static stbi__uint16 * stbi__convert_format16(stbi__uint16 * data, int img_n, dest[3] = 0xffff; } break; - STBI__CASE(3, 1) { - dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); - } + STBI__CASE(3, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); } break; STBI__CASE(3, 2) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); dest[1] = 0xffff; } break; - STBI__CASE(4, 1) { - dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); - } + STBI__CASE(4, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); } break; STBI__CASE(4, 2) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); @@ -2003,8 +1921,8 @@ static stbi__uint16 * stbi__convert_format16(stbi__uint16 * data, int img_n, STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); - return (stbi__uint16 *) stbi__errpuc( - "unsupported", "Unsupported format conversion"); + return (stbi__uint16 *) stbi__errpuc("unsupported", + "Unsupported format conversion"); } #undef STBI__CASE } @@ -2029,9 +1947,8 @@ static float * stbi__ldr_to_hdr(stbi_uc * data, int x, int y, int comp) { else n = comp - 1; for (i = 0; i < x * y; ++i) { for (k = 0; k < n; ++k) { - output[i * comp + k] - = (float) (pow(data[i * comp + k] / 255.0f, stbi__l2h_gamma) - * stbi__l2h_scale); + output[i * comp + k] = (float) (pow(data[i * comp + k] / 255.0f, stbi__l2h_gamma) + * stbi__l2h_scale); } } if (n < comp) { @@ -2060,10 +1977,9 @@ static stbi_uc * stbi__hdr_to_ldr(float * data, int x, int y, int comp) { else n = comp - 1; for (i = 0; i < x * y; ++i) { for (k = 0; k < n; ++k) { - float z = (float) pow(data[i * comp + k] * stbi__h2l_scale_i, - stbi__h2l_gamma_i) - * 255 - + 0.5f; + float z + = (float) pow(data[i * comp + k] * stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + + 0.5f; if (z < 0) z = 0; if (z > 255) z = 255; output[i * comp + k] = (stbi_uc) stbi__float2int(z); @@ -2164,11 +2080,10 @@ typedef struct { // kernels void (*idct_block_kernel)(stbi_uc * out, int out_stride, short data[64]); - void (*YCbCr_to_RGB_kernel)(stbi_uc * out, const stbi_uc * y, - const stbi_uc * pcb, const stbi_uc * pcr, - int count, int step); - stbi_uc * (*resample_row_hv_2_kernel)(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs); + void (*YCbCr_to_RGB_kernel)(stbi_uc * out, const stbi_uc * y, const stbi_uc * pcb, + const stbi_uc * pcr, int count, int step); + stbi_uc * (*resample_row_hv_2_kernel)(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, + int w, int hs); } stbi__jpeg; static int stbi__build_huffman(stbi__huffman * h, int * count) { @@ -2191,8 +2106,7 @@ static int stbi__build_huffman(stbi__huffman * h, int * count) { h->delta[j] = k - code; if (h->size[k] == j) { while (h->size[k] == j) h->code[k++] = (stbi__uint16) (code++); - if (code - 1 >= (1u << j)) - return stbi__err("bad code lengths", "Corrupt JPEG"); + if (code - 1 >= (1u << j)) return stbi__err("bad code lengths", "Corrupt JPEG"); } // compute largest code + 1 for this size, preshifted as needed later h->maxcode[j] = code << (16 - j); @@ -2230,14 +2144,12 @@ static void stbi__build_fast_ac(stbi__int16 * fast_ac, stbi__huffman * h) { if (magbits && len + magbits <= FAST_BITS) { // magnitude code followed by receive_extend code - int k = ((i << len) & ((1 << FAST_BITS) - 1)) - >> (FAST_BITS - magbits); + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); int m = 1 << (magbits - 1); if (k < m) k += (~0U << magbits) + 1; // if the result is small enough, we can fit it in fast_ac table if (k >= -128 && k <= 127) - fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) - + (len + magbits)); + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); } } } @@ -2262,12 +2174,10 @@ static void stbi__grow_buffer_unsafe(stbi__jpeg * j) { // (1 << n) - 1 static const stbi__uint32 stbi__bmask[17] - = {0, 1, 3, 7, 15, 31, 63, 127, 255, - 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535}; + = {0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535}; // decode a jpeg huffman value from the bitstream -stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg * j, - stbi__huffman * h) { +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg * j, stbi__huffman * h) { unsigned int temp; int c, k; @@ -2306,9 +2216,8 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg * j, c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; if (c < 0 || c >= 256) // symbol id out of bounds! return -1; - STBI_ASSERT( - (((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) - == h->code[c]); + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) + == h->code[c]); // convert the id to a symbol j->code_bits -= k; @@ -2317,9 +2226,8 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg * j, } // bias[n] = (-1<<n) + 1 -static const int stbi__jbias[16] - = {0, -1, -3, -7, -15, -31, -63, -127, - -255, -511, -1023, -2047, -4095, -8191, -16383, -32767}; +static const int stbi__jbias[16] = {0, -1, -3, -7, -15, -31, -63, -127, + -255, -511, -1023, -2047, -4095, -8191, -16383, -32767}; // combined JPEG 'receive' and JPEG 'extend', since baseline // always extends everything it receives. @@ -2366,17 +2274,15 @@ stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg * j) { // given a value that's at position X in the zigzag stream, // where does it appear in the 8x8 matrix coded as row-major? static const stbi_uc stbi__jpeg_dezigzag[64 + 15] - = {0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, - 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, - 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, - 60, 61, 54, 47, 55, 62, 63, + = {0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, + 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, // let corrupt input sample past end 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63}; // decode one 64-entry block-- -static int stbi__jpeg_decode_block(stbi__jpeg * j, short data[64], - stbi__huffman * hdc, stbi__huffman * hac, - stbi__int16 * fac, int b, +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) { int diff, dc, k; int t; @@ -2409,9 +2315,8 @@ static int stbi__jpeg_decode_block(stbi__jpeg * j, short data[64], k += (r >> 4) & 15; // run s = r & 15; // combined length if (s > j->code_bits) - return stbi__err( - "bad huffman code", - "Combined length longer than code bits available"); + return stbi__err("bad huffman code", + "Combined length longer than code bits available"); j->code_buffer <<= s; j->code_bits -= s; // decode into unzigzag'd location @@ -2436,12 +2341,11 @@ static int stbi__jpeg_decode_block(stbi__jpeg * j, short data[64], return 1; } -static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg * j, short data[64], - stbi__huffman * hdc, int b) { +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg * j, short data[64], stbi__huffman * hdc, + int b) { int diff, dc; int t; - if (j->spec_end != 0) - return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); @@ -2449,8 +2353,7 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg * j, short data[64], // first scan for DC coefficient, must be first memset(data, 0, 64 * sizeof(data[0])); // 0 all the ac values now t = stbi__jpeg_huff_decode(j, hdc); - if (t < 0 || t > 15) - return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); diff = t ? stbi__extend_receive(j, t) : 0; if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) @@ -2469,12 +2372,10 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg * j, short data[64], // @OPTIMIZE: store non-zigzagged during the decode passes, // and only de-zigzag when dequantizing -static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], - stbi__huffman * hac, +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], stbi__huffman * hac, stbi__int16 * fac) { int k; - if (j->spec_start == 0) - return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); if (j->succ_high == 0) { int shift = j->succ_low; @@ -2495,17 +2396,15 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], k += (r >> 4) & 15; // run s = r & 15; // combined length if (s > j->code_bits) - return stbi__err( - "bad huffman code", - "Combined length longer than code bits available"); + return stbi__err("bad huffman code", + "Combined length longer than code bits available"); j->code_buffer <<= s; j->code_bits -= s; zig = stbi__jpeg_dezigzag[k++]; data[zig] = (short) ((r >> 8) * (1 << shift)); } else { int rs = stbi__jpeg_huff_decode(j, hac); - if (rs < 0) - return stbi__err("bad huffman code", "Corrupt JPEG"); + if (rs < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); s = rs & 15; r = rs >> 4; if (s == 0) { @@ -2519,8 +2418,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], } else { k += r; zig = stbi__jpeg_dezigzag[k++]; - data[zig] - = (short) (stbi__extend_receive(j, s) * (1 << shift)); + data[zig] = (short) (stbi__extend_receive(j, s) * (1 << shift)); } } } while (k <= j->spec_end); @@ -2547,8 +2445,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], 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 - if (rs < 0) - return stbi__err("bad huffman code", "Corrupt JPEG"); + if (rs < 0) return stbi__err("bad huffman code", "Corrupt JPEG"); s = rs & 15; r = rs >> 4; if (s == 0) { @@ -2562,8 +2459,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j, short data[64], // so we don't have to do anything special here } } else { - if (s != 1) - return stbi__err("bad huffman code", "Corrupt JPEG"); + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); // sign bit if (stbi__jpeg_get_bit(j)) s = bit; else s = -bit; @@ -2651,15 +2547,14 @@ static void stbi__idct_block(stbi_uc * out, int out_stride, short data[64]) { // columns for (i = 0; i < 8; ++i, ++d, ++v) { // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing - if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 && d[40] == 0 - && d[48] == 0 && d[56] == 0) { + if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 && d[40] == 0 && d[48] == 0 + && d[56] == 0) { // no shortcut 0 seconds // (1|2|3|4|5|6|7)==0 0 seconds // all separate -0.047 seconds // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds int dcterm = d[0] * 4; - v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] - = dcterm; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; } else { STBI__IDCT_1D(d[0], d[8], d[16], d[24], d[32], d[40], d[48], d[56]) // constants scaled things up by 1<<12; let's bring them back @@ -2729,10 +2624,8 @@ static void stbi__idct_simd(stbi_uc * out, int out_stride, short data[64]) { // out = in << 12 (in 16-bit, out 32-bit) #define dct_widen(out, in) \ - __m128i out##_l \ - = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ - __m128i out##_h \ - = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) // wide add #define dct_wadd(out, a, b) \ @@ -2751,10 +2644,8 @@ static void stbi__idct_simd(stbi_uc * out, int out_stride, short data[64]) { __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ dct_wadd(sum, abiased, b); \ dct_wsub(dif, abiased, b); \ - out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), \ - _mm_srai_epi32(sum_h, s)); \ - out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), \ - _mm_srai_epi32(dif_h, s)); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ } // 8-bit interleave step (for transposes) @@ -2798,28 +2689,21 @@ static void stbi__idct_simd(stbi_uc * out, int out_stride, short data[64]) { } __m128i rot0_0 - = dct_const(stbi__f2f(0.5411961f), - stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); - __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f(0.765366865f), - stbi__f2f(0.5411961f)); - __m128i rot1_0 - = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), - stbi__f2f(1.175875602f)); - __m128i rot1_1 - = dct_const(stbi__f2f(1.175875602f), - stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); - __m128i rot2_0 - = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f(0.298631336f), - stbi__f2f(-1.961570560f)); - __m128i rot2_1 - = dct_const(stbi__f2f(-1.961570560f), - stbi__f2f(-1.961570560f) + stbi__f2f(3.072711026f)); - __m128i rot3_0 - = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f(2.053119869f), - stbi__f2f(-0.390180644f)); - __m128i rot3_1 - = dct_const(stbi__f2f(-0.390180644f), - stbi__f2f(-0.390180644f) + stbi__f2f(1.501321110f)); + = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 + = dct_const(stbi__f2f(0.5411961f) + stbi__f2f(0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), + stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), + stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f(0.298631336f), + stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), + stbi__f2f(-1.961570560f) + stbi__f2f(3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f(2.053119869f), + stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), + stbi__f2f(-0.390180644f) + stbi__f2f(1.501321110f)); // rounding biases in column/row passes, see stbi__idct_block for explanation. __m128i bias_0 = _mm_set1_epi32(512); @@ -3030,8 +2914,7 @@ static void stbi__idct_simd(stbi_uc * out, int out_stride, short data[64]) { } #define dct_trn32(x, y) \ { \ - int32x4x2_t t \ - = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(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]); \ } @@ -3092,15 +2975,13 @@ static void stbi__idct_simd(stbi_uc * out, int out_stride, short data[64]) { } #define dct_trn8_16(x, y) \ { \ - uint16x4x2_t t \ - = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(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]); \ } #define dct_trn8_32(x, y) \ { \ - uint32x2x2_t t \ - = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(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]); \ } @@ -3211,14 +3092,13 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg * z) { for (j = 0; j < h; ++j) { for (i = 0; i < w; ++i) { int ha = z->img_comp[n].ha; - 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])) + 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; - z->idct_block_kernel( - z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, - z->img_comp[n].w2, data); + z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + + i * 8, + z->img_comp[n].w2, data); // every data block is an MCU, so countdown the restart interval if (--z->todo <= 0) { if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); @@ -3245,15 +3125,14 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg * z) { int x2 = (i * z->img_comp[n].h + x) * 8; int y2 = (j * z->img_comp[n].v + y) * 8; int ha = z->img_comp[n].ha; - 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])) + 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; - z->idct_block_kernel( - z->img_comp[n].data + z->img_comp[n].w2 * y2 - + x2, - z->img_comp[n].w2, data); + z->idct_block_kernel(z->img_comp[n].data + + z->img_comp[n].w2 * y2 + x2, + z->img_comp[n].w2, data); } } } @@ -3280,16 +3159,16 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg * z) { int h = (z->img_comp[n].y + 7) >> 3; for (j = 0; j < h; ++j) { for (i = 0; i < w; ++i) { - short * data = z->img_comp[n].coeff - + 64 * (i + j * z->img_comp[n].coeff_w); + short * data + = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); if (z->spec_start == 0) { if (!stbi__jpeg_decode_block_prog_dc( z, data, &z->huff_dc[z->img_comp[n].hd], n)) return 0; } else { int ha = z->img_comp[n].ha; - if (!stbi__jpeg_decode_block_prog_ac( - z, data, &z->huff_ac[ha], z->fast_ac[ha])) + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], + z->fast_ac[ha])) return 0; } // every data block is an MCU, so countdown the restart interval @@ -3314,12 +3193,10 @@ static int stbi__parse_entropy_coded_data(stbi__jpeg * z) { for (x = 0; x < z->img_comp[n].h; ++x) { int x2 = (i * z->img_comp[n].h + x); int y2 = (j * z->img_comp[n].v + y); - short * data - = z->img_comp[n].coeff - + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + short * data = z->img_comp[n].coeff + + 64 * (x2 + y2 * z->img_comp[n].coeff_w); if (!stbi__jpeg_decode_block_prog_dc( - z, data, &z->huff_dc[z->img_comp[n].hd], - n)) + z, data, &z->huff_dc[z->img_comp[n].hd], n)) return 0; } } @@ -3352,12 +3229,12 @@ static void stbi__jpeg_finish(stbi__jpeg * z) { int h = (z->img_comp[n].y + 7) >> 3; for (j = 0; j < h; ++j) { for (i = 0; i < w; ++i) { - short * data = z->img_comp[n].coeff - + 64 * (i + j * z->img_comp[n].coeff_w); + short * data + = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); - z->idct_block_kernel( - z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, - z->img_comp[n].w2, data); + z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + + i * 8, + z->img_comp[n].w2, data); } } } @@ -3371,8 +3248,7 @@ static int stbi__process_marker(stbi__jpeg * z, int m) { return stbi__err("expected marker", "Corrupt JPEG"); case 0xDD: // DRI - specify restart interval - if (stbi__get16be(z->s) != 4) - return stbi__err("bad DRI len", "Corrupt JPEG"); + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len", "Corrupt JPEG"); z->restart_interval = stbi__get16be(z->s); return 1; @@ -3382,14 +3258,12 @@ static int stbi__process_marker(stbi__jpeg * z, int m) { int q = stbi__get8(z->s); int p = q >> 4, sixteen = (p != 0); int t = q & 15, i; - if (p != 0 && p != 1) - return stbi__err("bad DQT type", "Corrupt JPEG"); + if (p != 0 && p != 1) return stbi__err("bad DQT type", "Corrupt JPEG"); if (t > 3) return stbi__err("bad DQT table", "Corrupt JPEG"); for (i = 0; i < 64; ++i) z->dequant[t][stbi__jpeg_dezigzag[i]] - = (stbi__uint16) (sixteen ? stbi__get16be(z->s) - : stbi__get8(z->s)); + = (stbi__uint16) (sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); L -= (sixteen ? 129 : 65); } return L == 0; @@ -3402,8 +3276,7 @@ static int stbi__process_marker(stbi__jpeg * z, int m) { int q = stbi__get8(z->s); int tc = q >> 4; int th = q & 15; - if (tc > 1 || th > 3) - return stbi__err("bad DHT header", "Corrupt JPEG"); + if (tc > 1 || th > 3) return stbi__err("bad DHT header", "Corrupt JPEG"); for (i = 0; i < 16; ++i) { sizes[i] = stbi__get8(z->s); n += sizes[i]; @@ -3421,8 +3294,7 @@ static int stbi__process_marker(stbi__jpeg * z, int m) { v = z->huff_ac[th].values; } for (i = 0; i < n; ++i) v[i] = stbi__get8(z->s); - if (tc != 0) - stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + if (tc != 0) stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); L -= n; } return L == 0; @@ -3475,8 +3347,7 @@ static int stbi__process_scan_header(stbi__jpeg * z) { z->scan_n = stbi__get8(z->s); 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"); - if (Ls != 6 + 2 * z->scan_n) - return stbi__err("bad SOS len", "Corrupt JPEG"); + if (Ls != 6 + 2 * z->scan_n) return stbi__err("bad SOS len", "Corrupt JPEG"); for (i = 0; i < z->scan_n; ++i) { int id = stbi__get8(z->s), which; int q = stbi__get8(z->s); @@ -3484,11 +3355,9 @@ static int stbi__process_scan_header(stbi__jpeg * z) { if (z->img_comp[which].id == id) break; if (which == z->s->img_n) return 0; // no match z->img_comp[which].hd = q >> 4; - if (z->img_comp[which].hd > 3) - return stbi__err("bad DC huff", "Corrupt JPEG"); + if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff", "Corrupt JPEG"); z->img_comp[which].ha = q & 15; - if (z->img_comp[which].ha > 3) - return stbi__err("bad AC huff", "Corrupt JPEG"); + if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff", "Corrupt JPEG"); z->order[i] = which; } @@ -3500,9 +3369,8 @@ static int stbi__process_scan_header(stbi__jpeg * z) { z->succ_high = (aa >> 4); z->succ_low = (aa & 15); if (z->progressive) { - if (z->spec_start > 63 || z->spec_end > 63 - || z->spec_start > z->spec_end || z->succ_high > 13 - || z->succ_low > 13) + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end + || z->succ_high > 13 || z->succ_low > 13) return stbi__err("bad SOS", "Corrupt JPEG"); } else { if (z->spec_start != 0) return stbi__err("bad SOS", "Corrupt JPEG"); @@ -3543,24 +3411,21 @@ static int stbi__process_frame_header(stbi__jpeg * z, int scan) { if (Lf < 11) return stbi__err("bad SOF len", "Corrupt JPEG"); // JPEG p = stbi__get8(s); if (p != 8) - return stbi__err( - "only 8-bit", - "JPEG format not supported: 8-bit only"); // JPEG baseline + return stbi__err("only 8-bit", + "JPEG format not supported: 8-bit only"); // JPEG baseline 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 s->img_x = stbi__get16be(s); - if (s->img_x == 0) - return stbi__err("0 width", "Corrupt JPEG"); // JPEG requires + if (s->img_x == 0) return stbi__err("0 width", "Corrupt JPEG"); // JPEG requires if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large", "Very large image (corrupt?)"); if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large", "Very large image (corrupt?)"); c = stbi__get8(s); - if (c != 3 && c != 1 && c != 4) - return stbi__err("bad component count", "Corrupt JPEG"); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count", "Corrupt JPEG"); s->img_n = c; for (i = 0; i < c; ++i) { z->img_comp[i].data = NULL; @@ -3598,10 +3463,8 @@ static int stbi__process_frame_header(stbi__jpeg * z, int scan) { // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios // and I've never seen a non-corrupted JPEG file actually use them for (i = 0; i < s->img_n; ++i) { - if (h_max % z->img_comp[i].h != 0) - return stbi__err("bad H", "Corrupt JPEG"); - if (v_max % z->img_comp[i].v != 0) - return stbi__err("bad V", "Corrupt JPEG"); + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H", "Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V", "Corrupt JPEG"); } // compute interleaved mcu info @@ -3629,25 +3492,22 @@ static int stbi__process_frame_header(stbi__jpeg * z, int scan) { z->img_comp[i].coeff = 0; z->img_comp[i].raw_coeff = 0; z->img_comp[i].linebuf = NULL; - z->img_comp[i].raw_data - = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); if (z->img_comp[i].raw_data == NULL) - return stbi__free_jpeg_components( - z, i + 1, stbi__err("outofmem", "Out of memory")); + return stbi__free_jpeg_components(z, i + 1, + stbi__err("outofmem", "Out of memory")); // align blocks for idct using mmx/sse - z->img_comp[i].data - = (stbi_uc *) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].data = (stbi_uc *) (((size_t) z->img_comp[i].raw_data + 15) & ~15); if (z->progressive) { // w2, h2 are multiples of 8 (see above) z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; - z->img_comp[i].raw_coeff = stbi__malloc_mad3( - z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + z->img_comp[i].raw_coeff + = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); if (z->img_comp[i].raw_coeff == NULL) - return stbi__free_jpeg_components( - z, i + 1, stbi__err("outofmem", "Out of memory")); - z->img_comp[i].coeff - = (short *) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + return stbi__free_jpeg_components(z, i + 1, + stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short *) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); } } @@ -3731,8 +3591,7 @@ static int stbi__decode_jpeg_image(stbi__jpeg * j) { int Ld = stbi__get16be(j->s); stbi__uint32 NL = stbi__get16be(j->s); if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); - if (NL != j->s->img_y) - return stbi__err("bad DNL height", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); m = stbi__get_marker(j); } else { if (!stbi__process_marker(j, m)) return 1; @@ -3745,13 +3604,13 @@ static int stbi__decode_jpeg_image(stbi__jpeg * j) { // static jfif-centered resampling (across block boundaries) -typedef stbi_uc * (*resample_row_func)(stbi_uc * out, stbi_uc * in0, - stbi_uc * in1, int w, int hs); +typedef stbi_uc * (*resample_row_func)(stbi_uc * out, stbi_uc * in0, stbi_uc * in1, int w, + int hs); #define stbi__div4(x) ((stbi_uc) ((x) >> 2)) -static stbi_uc * resample_row_1(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs) { +static stbi_uc * resample_row_1(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, int w, + int hs) { STBI_NOTUSED(out); STBI_NOTUSED(in_far); STBI_NOTUSED(w); @@ -3759,8 +3618,8 @@ static stbi_uc * resample_row_1(stbi_uc * out, stbi_uc * in_near, return in_near; } -static stbi_uc * stbi__resample_row_v_2(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs) { +static stbi_uc * stbi__resample_row_v_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, + int w, int hs) { // need to generate two samples vertically for every one in input int i; STBI_NOTUSED(hs); @@ -3768,8 +3627,8 @@ static stbi_uc * stbi__resample_row_v_2(stbi_uc * out, stbi_uc * in_near, return out; } -static stbi_uc * stbi__resample_row_h_2(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs) { +static stbi_uc * stbi__resample_row_h_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, + int w, int hs) { // need to generate two samples horizontally for every one in input int i; stbi_uc * input = in_near; @@ -3798,8 +3657,8 @@ static stbi_uc * stbi__resample_row_h_2(stbi_uc * out, stbi_uc * in_near, #define stbi__div16(x) ((stbi_uc) ((x) >> 4)) -static stbi_uc * stbi__resample_row_hv_2(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs) { +static stbi_uc * stbi__resample_row_hv_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, + int w, int hs) { // need to generate 2x2 samples for every one in input int i, t0, t1; if (w == 1) { @@ -3858,8 +3717,7 @@ static stbi_uc * stbi__resample_row_hv_2_simd(stbi_uc * out, stbi_uc * in_near, __m128i prv0 = _mm_slli_si128(curr, 2); __m128i nxt0 = _mm_srli_si128(curr, 2); __m128i prev = _mm_insert_epi16(prv0, t1, 0); - __m128i next - = _mm_insert_epi16(nxt0, 3 * in_near[i + 8] + in_far[i + 8], 7); + __m128i next = _mm_insert_epi16(nxt0, 3 * in_near[i + 8] + in_far[i + 8], 7); // horizontal filter, polyphase implementation since it's convenient: // even pixels = 3*cur + prev = cur*4 + (prev - cur) @@ -3899,8 +3757,7 @@ static stbi_uc * stbi__resample_row_hv_2_simd(stbi_uc * out, stbi_uc * in_near, int16x8_t prv0 = vextq_s16(curr, curr, 7); int16x8_t nxt0 = vextq_s16(curr, curr, 1); int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); - int16x8_t next - = vsetq_lane_s16(3 * in_near[i + 8] + in_far[i + 8], nxt0, 7); + int16x8_t next = vsetq_lane_s16(3 * in_near[i + 8] + in_far[i + 8], nxt0, 7); // horizontal filter, polyphase implementation since it's convenient: // even pixels = 3*cur + prev = cur*4 + (prev - cur) @@ -3941,8 +3798,8 @@ static stbi_uc * stbi__resample_row_hv_2_simd(stbi_uc * out, stbi_uc * in_near, } #endif -static stbi_uc * stbi__resample_row_generic(stbi_uc * out, stbi_uc * in_near, - stbi_uc * in_far, int w, int hs) { +static stbi_uc * stbi__resample_row_generic(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far, + int w, int hs) { // resample with nearest-neighbor int i, j; STBI_NOTUSED(in_far); @@ -3954,9 +3811,8 @@ static stbi_uc * stbi__resample_row_generic(stbi_uc * out, stbi_uc * in_near, // this is a reduced-precision calculation of YCbCr-to-RGB introduced // to make sure the code produces the same results in both SIMD and scalar #define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) -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) { +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) { int i; for (i = 0; i < count; ++i) { int y_fixed = (y[i] << 20) + (1 << 19); // rounding @@ -3991,9 +3847,8 @@ static void stbi__YCbCr_to_RGB_row(stbi_uc * out, const stbi_uc * y, } #if defined(STBI_SSE2) || defined(STBI_NEON) -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) { +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) { int i = 0; #ifdef STBI_SSE2 @@ -4004,10 +3859,8 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc * out, stbi_uc const * y, // this is a fairly straightforward implementation and not super-optimized. __m128i signflip = _mm_set1_epi8(-0x80); __m128i cr_const0 = _mm_set1_epi16((short) (1.40200f * 4096.0f + 0.5f)); - __m128i cr_const1 - = _mm_set1_epi16(-(short) (0.71414f * 4096.0f + 0.5f)); - __m128i cb_const0 - = _mm_set1_epi16(-(short) (0.34414f * 4096.0f + 0.5f)); + __m128i cr_const1 = _mm_set1_epi16(-(short) (0.71414f * 4096.0f + 0.5f)); + __m128i cb_const0 = _mm_set1_epi16(-(short) (0.34414f * 4096.0f + 0.5f)); __m128i cb_const1 = _mm_set1_epi16((short) (1.77200f * 4096.0f + 0.5f)); __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); __m128i xw = _mm_set1_epi16(255); // alpha channel @@ -4074,10 +3927,8 @@ static void stbi__YCbCr_to_RGB_simd(stbi_uc * out, stbi_uc const * y, uint8x8_t y_bytes = vld1_u8(y + i); uint8x8_t cr_bytes = vld1_u8(pcr + i); uint8x8_t cb_bytes = vld1_u8(pcb + i); - int8x8_t cr_biased - = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); - int8x8_t cb_biased - = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); // expand to s16 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); @@ -4181,14 +4032,13 @@ static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) { return (stbi_uc) ((t + (t >> 8)) >> 8); } -static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, - int * comp, int req_comp) { +static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, int * comp, + int req_comp) { int n, decode_n, is_rgb; z->s->img_n = 0; // make stbi__cleanup_jpeg safe // validate req_comp - if (req_comp < 0 || req_comp > 4) - return stbi__errpuc("bad req_comp", "Internal error"); + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); // load a jpeg image from whichever source, but leave in YCbCr format if (!stbi__decode_jpeg_image(z)) { @@ -4199,8 +4049,7 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, // determine actual number of components to generate n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; - is_rgb = z->s->img_n == 3 - && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); if (z->s->img_n == 3 && n < 3 && !is_rgb) decode_n = 1; else decode_n = z->s->img_n; @@ -4240,12 +4089,9 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, r->line0 = r->line1 = z->img_comp[k].data; if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; - else if (r->hs == 1 && r->vs == 2) - r->resample = stbi__resample_row_v_2; - else if (r->hs == 2 && r->vs == 1) - r->resample = stbi__resample_row_h_2; - else if (r->hs == 2 && r->vs == 2) - r->resample = z->resample_row_hv_2_kernel; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; else r->resample = stbi__resample_row_generic; } @@ -4262,14 +4108,12 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, for (k = 0; k < decode_n; ++k) { stbi__resample * r = &res_comp[k]; int y_bot = r->ystep >= (r->vs >> 1); - coutput[k] = r->resample( - z->img_comp[k].linebuf, y_bot ? r->line1 : r->line0, - y_bot ? r->line0 : r->line1, r->w_lores, r->hs); + coutput[k] = r->resample(z->img_comp[k].linebuf, y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, r->w_lores, r->hs); if (++r->ystep >= r->vs) { r->ystep = 0; r->line0 = r->line1; - if (++r->ypos < z->img_comp[k].y) - r->line1 += z->img_comp[k].w2; + if (++r->ypos < z->img_comp[k].y) r->line1 += z->img_comp[k].w2; } } if (n >= 3) { @@ -4284,8 +4128,7 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, out += n; } } else { - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], - z->s->img_x, n); + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); } } else if (z->s->img_n == 4) { if (z->app14_color_transform == 0) { // CMYK @@ -4298,8 +4141,7 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, out += n; } } else if (z->app14_color_transform == 2) { // YCCK - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], - z->s->img_x, n); + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); for (i = 0; i < z->s->img_x; ++i) { stbi_uc m = coutput[3][i]; out[0] = stbi__blinn_8x8(255 - out[0], m); @@ -4308,8 +4150,7 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, out += n; } } else { // YCbCr + alpha? Ignore the fourth channel for now - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], - z->s->img_x, n); + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); } } else for (i = 0; i < z->s->img_x; ++i) { @@ -4321,12 +4162,12 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, if (is_rgb) { if (n == 1) for (i = 0; i < z->s->img_x; ++i) - *out++ = stbi__compute_y( - coutput[0][i], coutput[1][i], coutput[2][i]); + *out++ + = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); else { for (i = 0; i < z->s->img_x; ++i, out += 2) { - out[0] = stbi__compute_y( - coutput[0][i], coutput[1][i], coutput[2][i]); + out[0] + = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); out[1] = 255; } } @@ -4342,8 +4183,7 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, } } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { for (i = 0; i < z->s->img_x; ++i) { - out[0] = stbi__blinn_8x8(255 - coutput[0][i], - coutput[3][i]); + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); out[1] = 255; out += n; } @@ -4362,16 +4202,13 @@ static stbi_uc * load_jpeg_image(stbi__jpeg * z, int * out_x, int * out_y, stbi__cleanup_jpeg(z); *out_x = z->s->img_x; *out_y = z->s->img_y; - if (comp) - *comp = z->s->img_n >= 3 - ? 3 - : 1; // report original components, not output + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output return output; } } -static void * stbi__jpeg_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__jpeg_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { unsigned char * result; stbi__jpeg * j = (stbi__jpeg *) stbi__malloc(sizeof(stbi__jpeg)); if (!j) return stbi__errpuc("outofmem", "Out of memory"); @@ -4460,8 +4297,7 @@ stbi_inline static int stbi__bit_reverse(int v, int bits) { return stbi__bitreverse16(v) >> (16 - bits); } -static int stbi__zbuild_huffman(stbi__zhuffman * z, const stbi_uc * sizelist, - int num) { +static int stbi__zbuild_huffman(stbi__zhuffman * z, const stbi_uc * sizelist, int num) { int i, k = 0; int code, next_code[16], sizes[17]; @@ -4479,8 +4315,7 @@ static int stbi__zbuild_huffman(stbi__zhuffman * z, const stbi_uc * sizelist, z->firstsymbol[i] = (stbi__uint16) k; code = (code + sizes[i]); if (sizes[i]) - if (code - 1 >= (1 << i)) - return stbi__err("bad codelengths", "Corrupt PNG"); + if (code - 1 >= (1 << i)) return stbi__err("bad codelengths", "Corrupt PNG"); z->maxcode[i] = code << (16 - i); // preshift for inner loop code <<= 1; k += sizes[i]; @@ -4526,9 +4361,7 @@ typedef struct { stbi__zhuffman z_length, z_distance; } stbi__zbuf; -stbi_inline static int stbi__zeof(stbi__zbuf * z) { - return (z->zbuffer >= z->zbuffer_end); -} +stbi_inline static int stbi__zeof(stbi__zbuf * z) { return (z->zbuffer >= z->zbuffer_end); } stbi_inline static stbi_uc stbi__zget8(stbi__zbuf * z) { return stbi__zeof(z) ? 0 : *z->zbuffer++; @@ -4565,15 +4398,13 @@ static int stbi__zhuffman_decode_slowpath(stbi__zbuf * a, stbi__zhuffman * z) { // code size is s, so: b = (k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s]; if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! - if (z->size[b] != s) - return -1; // was originally an assert, but report failure instead. + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. a->code_buffer >>= s; a->num_bits -= s; return z->value[b]; } -stbi_inline static int stbi__zhuffman_decode(stbi__zbuf * a, - stbi__zhuffman * z) { +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf * a, stbi__zhuffman * z) { int b, s; if (a->num_bits < 16) { if (stbi__zeof(a)) { @@ -4608,12 +4439,10 @@ static int stbi__zexpand(stbi__zbuf * z, char * zout, char * q; unsigned int cur, limit, old_limit; z->zout = zout; - if (!z->z_expandable) - return stbi__err("output buffer limit", "Corrupt PNG"); + if (!z->z_expandable) return stbi__err("output buffer limit", "Corrupt PNG"); cur = (unsigned int) (z->zout - z->zout_start); limit = old_limit = (unsigned) (z->zout_end - z->zout_start); - if (UINT_MAX - cur < (unsigned) n) - return stbi__err("outofmem", "Out of memory"); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); while (cur + n > limit) { if (limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); limit *= 2; @@ -4631,18 +4460,16 @@ static const int stbi__zlength_base[31] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; -static const int stbi__zlength_extra[31] - = {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}; +static const int stbi__zlength_extra[31] = {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}; static const int stbi__zdist_base[32] = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; -static const int stbi__zdist_extra[32] - = {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}; +static const int stbi__zdist_extra[32] = {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}; static int stbi__parse_huffman_block(stbi__zbuf * a) { char * zout = a->zout; @@ -4677,18 +4504,15 @@ static int stbi__parse_huffman_block(stbi__zbuf * a) { "Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data z -= 257; len = stbi__zlength_base[z]; - if (stbi__zlength_extra[z]) - len += stbi__zreceive(a, stbi__zlength_extra[z]); + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); z = stbi__zhuffman_decode(a, &a->z_distance); if (z < 0 || z >= 30) return stbi__err( "bad huffman code", "Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data dist = stbi__zdist_base[z]; - if (stbi__zdist_extra[z]) - dist += stbi__zreceive(a, stbi__zdist_extra[z]); - if (zout - a->zout_start < dist) - return stbi__err("bad dist", "Corrupt PNG"); + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist", "Corrupt PNG"); if (len > a->zout_end - zout) { if (!stbi__zexpand(a, zout, len)) return 0; zout = a->zout; @@ -4733,8 +4557,7 @@ static int stbi__compute_huffman_codes(stbi__zbuf * a) { n = 0; while (n < ntot) { int c = stbi__zhuffman_decode(a, &z_codelength); - if (c < 0 || c >= 19) - return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); if (c < 16) lencodes[n++] = (stbi_uc) c; else { stbi_uc fill = 0; @@ -4749,8 +4572,7 @@ static int stbi__compute_huffman_codes(stbi__zbuf * a) { } else { return stbi__err("bad codelengths", "Corrupt PNG"); } - if (ntot - n < c) - return stbi__err("bad codelengths", "Corrupt PNG"); + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); memset(lencodes + n, fill, c); n += c; } @@ -4768,8 +4590,7 @@ static int stbi__parse_uncompressed_block(stbi__zbuf * a) { // drain the bit-packed data into header k = 0; while (a->num_bits > 0) { - header[k++] - = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check a->code_buffer >>= 8; a->num_bits -= 8; } @@ -4779,8 +4600,7 @@ static int stbi__parse_uncompressed_block(stbi__zbuf * a) { len = header[1] * 256 + header[0]; nlen = header[3] * 256 + header[2]; if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt", "Corrupt PNG"); - if (a->zbuffer + len > a->zbuffer_end) - return stbi__err("read past buffer", "Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer", "Corrupt PNG"); if (a->zout + len > a->zout_end) if (!stbi__zexpand(a, a->zout, len)) return 0; memcpy(a->zout, a->zbuffer, len); @@ -4794,8 +4614,7 @@ static int stbi__parse_zlib_header(stbi__zbuf * a) { int cm = cmf & 15; /* int cinfo = cmf >> 4; */ int flg = stbi__zget8(a); - if (stbi__zeof(a)) - return stbi__err("bad zlib header", "Corrupt PNG"); // zlib spec + if (stbi__zeof(a)) return stbi__err("bad zlib header", "Corrupt PNG"); // zlib spec if ((cmf * 256 + flg) % 31 != 0) return stbi__err("bad zlib header", "Corrupt PNG"); // zlib spec if (flg & 32) @@ -4809,18 +4628,16 @@ static int stbi__parse_zlib_header(stbi__zbuf * a) { } static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] - = {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, 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, 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, - 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, 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, 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, - 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, 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, 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}; + = {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, 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, 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, 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, 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, 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, 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, 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, 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}; static const stbi_uc stbi__zdefault_distance[32] = {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}; @@ -4854,11 +4671,9 @@ static int stbi__parse_zlib(stbi__zbuf * a, int parse_header) { } else { if (type == 1) { // use fixed code lengths - if (!stbi__zbuild_huffman(&a->z_length, stbi__zdefault_length, - STBI__ZNSYMS)) + if (!stbi__zbuild_huffman(&a->z_length, stbi__zdefault_length, STBI__ZNSYMS)) return 0; - if (!stbi__zbuild_huffman(&a->z_distance, - stbi__zdefault_distance, 32)) + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; } else { if (!stbi__compute_huffman_codes(a)) return 0; @@ -4869,8 +4684,7 @@ static int stbi__parse_zlib(stbi__zbuf * a, int parse_header) { return 1; } -static int stbi__do_zlib(stbi__zbuf * a, char * obuf, int olen, int exp, - int parse_header) { +static int stbi__do_zlib(stbi__zbuf * a, char * obuf, int olen, int exp, int parse_header) { a->zout_start = obuf; a->zout = obuf; a->zout_end = obuf + olen; @@ -4880,8 +4694,7 @@ static int stbi__do_zlib(stbi__zbuf * a, char * obuf, int olen, int exp, } STBIDEF char * stbi_zlib_decode_malloc_guesssize(const char * buffer, int len, - int initial_size, - int * outlen) { + int initial_size, int * outlen) { stbi__zbuf a; char * p = (char *) stbi__malloc(initial_size); if (p == NULL) return NULL; @@ -4896,15 +4709,12 @@ STBIDEF char * stbi_zlib_decode_malloc_guesssize(const char * buffer, int len, } } -STBIDEF char * stbi_zlib_decode_malloc(char const * buffer, int len, - int * outlen) { +STBIDEF char * stbi_zlib_decode_malloc(char const * buffer, int len, int * outlen) { return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); } -STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer, - int len, - int initial_size, - int * outlen, +STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer, int len, + int initial_size, int * outlen, int parse_header) { stbi__zbuf a; char * p = (char *) stbi__malloc(initial_size); @@ -4920,18 +4730,15 @@ STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char * buffer, } } -STBIDEF int stbi_zlib_decode_buffer(char * obuffer, int olen, - char const * ibuffer, int ilen) { +STBIDEF int stbi_zlib_decode_buffer(char * obuffer, int olen, char const * ibuffer, int ilen) { stbi__zbuf a; a.zbuffer = (stbi_uc *) ibuffer; a.zbuffer_end = (stbi_uc *) ibuffer + ilen; - if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) - return (int) (a.zout - a.zout_start); + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) return (int) (a.zout - a.zout_start); else return -1; } -STBIDEF char * stbi_zlib_decode_noheader_malloc(char const * buffer, int len, - int * outlen) { +STBIDEF char * stbi_zlib_decode_noheader_malloc(char const * buffer, int len, int * outlen) { stbi__zbuf a; char * p = (char *) stbi__malloc(16384); if (p == NULL) return NULL; @@ -4946,13 +4753,12 @@ STBIDEF char * stbi_zlib_decode_noheader_malloc(char const * buffer, int len, } } -STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, - const char * ibuffer, int ilen) { +STBIDEF int stbi_zlib_decode_noheader_buffer(char * obuffer, int olen, const char * ibuffer, + int ilen) { stbi__zbuf a; a.zbuffer = (stbi_uc *) ibuffer; a.zbuffer_end = (stbi_uc *) ibuffer + ilen; - if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) - return (int) (a.zout - a.zout_start); + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) return (int) (a.zout - a.zout_start); else return -1; } #endif @@ -4984,8 +4790,7 @@ static int stbi__check_png_header(stbi__context * s) { static const stbi_uc png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; int i; for (i = 0; i < 8; ++i) - if (stbi__get8(s) != png_sig[i]) - return stbi__err("bad png sig", "Not a PNG"); + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig", "Not a PNG"); return 1; } @@ -5022,14 +4827,13 @@ static int stbi__paeth(int a, int b, int c) { return t1; } -static const stbi_uc stbi__depth_scale_table[9] - = {0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01}; +static const stbi_uc stbi__depth_scale_table[9] = {0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01}; // adds an extra all-255 alpha channel // dest == src is legal // img_n must be 1 or 3 -static void stbi__create_png_alpha_expand8(stbi_uc * dest, stbi_uc * src, - stbi__uint32 x, int img_n) { +static void stbi__create_png_alpha_expand8(stbi_uc * dest, stbi_uc * src, stbi__uint32 x, + int img_n) { int i; // must process data backwards since we allow dest==src if (img_n == 1) { @@ -5049,9 +4853,8 @@ static void stbi__create_png_alpha_expand8(stbi_uc * dest, stbi_uc * src, } // create the png data from post-deflated data -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, +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) { int bytes = (depth == 16 ? 2 : 1); stbi__context * s = a->s; @@ -5067,8 +4870,8 @@ static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, int width = x; STBI_ASSERT(out_n == s->img_n || out_n == s->img_n + 1); - a->out = (stbi_uc *) stbi__malloc_mad3( - x, y, output_bytes, 0); // extra bytes to write off the end into + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, + 0); // extra bytes to write off the end into if (!a->out) return stbi__err("outofmem", "Out of memory"); // note: error exits here don't need to clean up a->out individually, @@ -5123,32 +4926,28 @@ static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, cur[k] = STBI__BYTECAST(raw[k] + cur[k - filter_bytes]); break; case STBI__F_up: - for (k = 0; k < nk; ++k) - cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + for (k = 0; k < nk; ++k) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; case STBI__F_avg: for (k = 0; k < filter_bytes; ++k) cur[k] = STBI__BYTECAST(raw[k] + (prior[k] >> 1)); for (k = filter_bytes; k < nk; ++k) - cur[k] = STBI__BYTECAST( - raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1)); + cur[k] + = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1)); break; case STBI__F_paeth: for (k = 0; k < filter_bytes; ++k) cur[k] = STBI__BYTECAST( - raw[k] - + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) for (k = filter_bytes; k < nk; ++k) - cur[k] = STBI__BYTECAST( - raw[k] - + stbi__paeth(cur[k - filter_bytes], prior[k], - prior[k - filter_bytes])); + cur[k] = STBI__BYTECAST(raw[k] + + stbi__paeth(cur[k - filter_bytes], prior[k], + prior[k - filter_bytes])); break; case STBI__F_avg_first: memcpy(cur, raw, filter_bytes); for (k = filter_bytes; k < nk; ++k) - cur[k] - = STBI__BYTECAST(raw[k] + (cur[k - filter_bytes] >> 1)); + cur[k] = STBI__BYTECAST(raw[k] + (cur[k - filter_bytes] >> 1)); break; } @@ -5156,9 +4955,8 @@ static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, // expand decoded bits in cur to dest, also adding an extra alpha channel if desired if (depth < 8) { - stbi_uc scale = (color == 0) - ? stbi__depth_scale_table[depth] - : 1; // scale grayscale values to 0..255 range + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] + : 1; // scale grayscale values to 0..255 range stbi_uc * in = cur; stbi_uc * out = dest; stbi_uc inb = 0; @@ -5187,8 +4985,7 @@ static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, } // insert alpha=255 values if desired - if (img_n != out_n) - stbi__create_png_alpha_expand8(dest, dest, x, img_n); + if (img_n != out_n) stbi__create_png_alpha_expand8(dest, dest, x, img_n); } else if (depth == 8) { if (img_n == out_n) memcpy(dest, cur, x * img_n); else stbi__create_png_alpha_expand8(dest, cur, x, img_n); @@ -5227,20 +5024,18 @@ static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, } 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) { + stbi__uint32 image_data_len, int out_n, int depth, int color, + int interlaced) { int bytes = (depth == 16 ? 2 : 1); int out_bytes = out_n * bytes; stbi_uc * final; int p; if (!interlaced) - return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, - a->s->img_x, a->s->img_y, depth, - color); + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, + a->s->img_y, depth, color); // de-interlacing - final - = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); if (!final) return stbi__err("outofmem", "Out of memory"); for (p = 0; p < 7; ++p) { int xorig[] = {0, 4, 0, 2, 0, 1, 0}; @@ -5252,10 +5047,9 @@ static int stbi__create_png_image(stbi__png * a, stbi_uc * image_data, x = (a->s->img_x - xorig[p] + xspc[p] - 1) / xspc[p]; y = (a->s->img_y - yorig[p] + yspc[p] - 1) / yspc[p]; if (x && y) { - stbi__uint32 img_len - = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; - if (!stbi__create_png_image_raw(a, image_data, image_data_len, - out_n, x, y, depth, color)) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, + color)) { STBI_FREE(final); return 0; } @@ -5263,8 +5057,7 @@ static int stbi__create_png_image(stbi__png * a, stbi_uc * image_data, for (i = 0; i < x; ++i) { int out_y = j * yspc[p] + yorig[p]; int out_x = i * xspc[p] + xorig[p]; - memcpy(final + out_y * a->s->img_x * out_bytes - + out_x * out_bytes, + memcpy(final + out_y * a->s->img_x * out_bytes + out_x * out_bytes, a->out + (j * x + i) * out_bytes, out_bytes); } } @@ -5301,8 +5094,7 @@ static int stbi__compute_transparency(stbi__png * z, stbi_uc tc[3], int out_n) { return 1; } -static int stbi__compute_transparency16(stbi__png * z, stbi__uint16 tc[3], - int out_n) { +static int stbi__compute_transparency16(stbi__png * z, stbi__uint16 tc[3], int out_n) { stbi__context * s = z->s; stbi__uint32 i, pixel_count = s->img_x * s->img_y; stbi__uint16 * p = (stbi__uint16 *) z->out; @@ -5325,8 +5117,7 @@ static int stbi__compute_transparency16(stbi__png * z, stbi__uint16 tc[3], return 1; } -static int stbi__expand_png_palette(stbi__png * a, stbi_uc * palette, int len, - int pal_img_n) { +static int stbi__expand_png_palette(stbi__png * a, stbi_uc * palette, int len, int pal_img_n) { stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; stbi_uc *p, *temp_out, *orig = a->out; @@ -5365,8 +5156,7 @@ static int stbi__expand_png_palette(stbi__png * a, stbi_uc * palette, int len, static int stbi__unpremultiply_on_load_global = 0; static int stbi__de_iphone_flag_global = 0; -STBIDEF void -stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) { +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) { stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; } @@ -5380,17 +5170,14 @@ STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) { #else static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; -static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, - stbi__de_iphone_flag_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; -STBIDEF void -stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) { +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) { stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; stbi__unpremultiply_on_load_set = 1; } -STBIDEF void -stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) { +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) { stbi__de_iphone_flag_local = flag_true_if_should_convert; stbi__de_iphone_flag_set = 1; } @@ -5399,8 +5186,7 @@ stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) { (stbi__unpremultiply_on_load_set ? stbi__unpremultiply_on_load_local \ : stbi__unpremultiply_on_load_global) #define stbi__de_iphone_flag \ - (stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local \ - : stbi__de_iphone_flag_global) + (stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local : stbi__de_iphone_flag_global) #endif // STBI_THREAD_LOCAL static void stbi__de_iphone(stbi__png * z) { @@ -5446,8 +5232,7 @@ static void stbi__de_iphone(stbi__png * z) { } #define STBI__PNG_TYPE(a, b, c, d) \ - (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) \ - + (unsigned) (d)) + (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { stbi_uc palette[1024], pal_img_n = 0; @@ -5476,43 +5261,34 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { int comp, filter; if (!first) return stbi__err("multiple IHDR", "Corrupt PNG"); first = 0; - if (c.length != 13) - return stbi__err("bad IHDR len", "Corrupt PNG"); + if (c.length != 13) return stbi__err("bad IHDR len", "Corrupt PNG"); s->img_x = stbi__get32be(s); s->img_y = stbi__get32be(s); if (s->img_y > STBI_MAX_DIMENSIONS) - return stbi__err("too large", - "Very large image (corrupt?)"); + return stbi__err("too large", "Very large image (corrupt?)"); if (s->img_x > STBI_MAX_DIMENSIONS) - return stbi__err("too large", - "Very large image (corrupt?)"); + return stbi__err("too large", "Very large image (corrupt?)"); z->depth = stbi__get8(s); - if (z->depth != 1 && z->depth != 2 && z->depth != 4 - && z->depth != 8 && z->depth != 16) + 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"); color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype", "Corrupt PNG"); - if (color == 3 && z->depth == 16) - return stbi__err("bad ctype", "Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype", "Corrupt PNG"); if (color == 3) pal_img_n = 3; - else if (color & 1) - return stbi__err("bad ctype", "Corrupt PNG"); + else if (color & 1) return stbi__err("bad ctype", "Corrupt PNG"); comp = stbi__get8(s); if (comp) return stbi__err("bad comp method", "Corrupt PNG"); filter = stbi__get8(s); - if (filter) - return stbi__err("bad filter method", "Corrupt PNG"); + if (filter) return stbi__err("bad filter method", "Corrupt PNG"); interlace = stbi__get8(s); - if (interlace > 1) - return stbi__err("bad interlace method", "Corrupt PNG"); - if (!s->img_x || !s->img_y) - return stbi__err("0-pixel image", "Corrupt PNG"); + if (interlace > 1) return stbi__err("bad interlace method", "Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image", "Corrupt PNG"); if (!pal_img_n) { s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); if ((1 << 30) / s->img_x / s->img_n < s->img_y) - return stbi__err("too large", - "Image too large to decode"); + return stbi__err("too large", "Image too large to decode"); } else { // if paletted, then pal_n is our final components, and // img_n is # components to decompress/filter. @@ -5526,11 +5302,9 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { case STBI__PNG_TYPE('P', 'L', 'T', 'E'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (c.length > 256 * 3) - return stbi__err("invalid PLTE", "Corrupt PNG"); + if (c.length > 256 * 3) return stbi__err("invalid PLTE", "Corrupt PNG"); pal_len = c.length / 3; - if (pal_len * 3 != c.length) - return stbi__err("invalid PLTE", "Corrupt PNG"); + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE", "Corrupt PNG"); for (i = 0; i < pal_len; ++i) { palette[i * 4 + 0] = stbi__get8(s); palette[i * 4 + 1] = stbi__get8(s); @@ -5542,23 +5316,18 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { case STBI__PNG_TYPE('t', 'R', 'N', 'S'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (z->idata) - return stbi__err("tRNS after IDAT", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT", "Corrupt PNG"); if (pal_img_n) { if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } - if (pal_len == 0) - return stbi__err("tRNS before PLTE", "Corrupt PNG"); - if (c.length > pal_len) - return stbi__err("bad tRNS len", "Corrupt PNG"); + if (pal_len == 0) return stbi__err("tRNS before PLTE", "Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len", "Corrupt PNG"); pal_img_n = 4; - for (i = 0; i < c.length; ++i) - palette[i * 4 + 3] = stbi__get8(s); + for (i = 0; i < c.length; ++i) palette[i * 4 + 3] = stbi__get8(s); } else { - if (!(s->img_n & 1)) - return stbi__err("tRNS with alpha", "Corrupt PNG"); + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha", "Corrupt PNG"); if (c.length != (stbi__uint32) s->img_n * 2) return stbi__err("bad tRNS len", "Corrupt PNG"); has_trans = 1; @@ -5569,14 +5338,12 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { } if (z->depth == 16) { for (k = 0; k < s->img_n; ++k) - tc16[k] = (stbi__uint16) stbi__get16be( - s); // copy the values as-is + tc16[k] = (stbi__uint16) stbi__get16be(s); // copy the values as-is } else { 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 + tc[k] = (stbi_uc) (stbi__get16be(s) & 255) + * stbi__depth_scale_table + [z->depth]; // non 8-bit images will be larger } } break; @@ -5584,28 +5351,23 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { case STBI__PNG_TYPE('I', 'D', 'A', 'T'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (pal_img_n && !pal_len) - return stbi__err("no PLTE", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE", "Corrupt PNG"); if (scan == STBI__SCAN_header) { // header scan definitely stops at first IDAT if (pal_img_n) s->img_n = pal_img_n; return 1; } if (c.length > (1u << 30)) - return stbi__err("IDAT size limit", - "IDAT section larger than 2^30 bytes"); + return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); if ((int) (ioff + c.length) < (int) ioff) return 0; if (ioff + c.length > idata_limit) { stbi__uint32 idata_limit_old = idata_limit; stbi_uc * p; - if (idata_limit == 0) - idata_limit = c.length > 4096 ? c.length : 4096; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; while (ioff + c.length > idata_limit) idata_limit *= 2; STBI_NOTUSED(idata_limit_old); - p = (stbi_uc *) STBI_REALLOC_SIZED( - z->idata, idata_limit_old, idata_limit); - if (p == NULL) - return stbi__err("outofmem", "Out of memory"); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); z->idata = p; } if (!stbi__getn(s, z->idata + ioff, c.length)) @@ -5618,48 +5380,36 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { stbi__uint32 raw_len, bpl; if (first) return stbi__err("first not IHDR", "Corrupt PNG"); if (scan != STBI__SCAN_load) return 1; - if (z->idata == NULL) - return stbi__err("no IDAT", "Corrupt PNG"); + if (z->idata == NULL) return stbi__err("no IDAT", "Corrupt PNG"); // initial guess for decoded data size to avoid unnecessary reallocs - bpl = (s->img_x * z->depth + 7) - / 8; // bytes per line, per component + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; - z->expanded - = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag( - (char *) z->idata, ioff, raw_len, (int *) &raw_len, - !is_iphone); + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag( + (char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); if (z->expanded == NULL) return 0; // zlib should set error STBI_FREE(z->idata); z->idata = NULL; - if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) - || has_trans) + if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) || has_trans) s->img_out_n = s->img_n + 1; else s->img_out_n = s->img_n; - if (!stbi__create_png_image(z, z->expanded, raw_len, - s->img_out_n, z->depth, color, - interlace)) + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, + color, interlace)) return 0; if (has_trans) { if (z->depth == 16) { - if (!stbi__compute_transparency16(z, tc16, - s->img_out_n)) - return 0; + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; } else { - if (!stbi__compute_transparency(z, tc, s->img_out_n)) - return 0; + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; } } - if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) - stbi__de_iphone(z); + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) stbi__de_iphone(z); if (pal_img_n) { // pal_img_n == 3 or 4 s->img_n = pal_img_n; // record the actual colors we had s->img_out_n = pal_img_n; if (req_comp >= 3) s->img_out_n = req_comp; - if (!stbi__expand_png_palette(z, palette, pal_len, - s->img_out_n)) - return 0; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) return 0; } else if (has_trans) { // non-paletted image with tRNS -> source image has (constant) alpha ++s->img_n; @@ -5683,9 +5433,8 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); #endif - return stbi__err( - invalid_chunk, - "PNG not supported: unknown PNG chunk type"); + return stbi__err(invalid_chunk, + "PNG not supported: unknown PNG chunk type"); } stbi__skip(s, c.length); break; @@ -5695,11 +5444,10 @@ static int stbi__parse_png_file(stbi__png * z, int scan, int req_comp) { } } -static void * stbi__do_png(stbi__png * p, int * x, int * y, int * n, - int req_comp, stbi__result_info * ri) { +static void * stbi__do_png(stbi__png * p, int * x, int * y, int * n, int req_comp, + stbi__result_info * ri) { void * result = NULL; - if (req_comp < 0 || req_comp > 4) - return stbi__errpuc("bad req_comp", "Internal error"); + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { if (p->depth <= 8) ri->bits_per_channel = 8; else if (p->depth == 16) ri->bits_per_channel = 16; @@ -5710,13 +5458,11 @@ static void * stbi__do_png(stbi__png * p, int * x, int * y, int * n, p->out = NULL; if (req_comp && req_comp != p->s->img_out_n) { if (ri->bits_per_channel == 8) - result = stbi__convert_format((unsigned char *) result, - p->s->img_out_n, req_comp, - p->s->img_x, p->s->img_y); + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, + req_comp, p->s->img_x, p->s->img_y); else - result = stbi__convert_format16((stbi__uint16 *) result, - p->s->img_out_n, req_comp, - p->s->img_x, p->s->img_y); + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, + req_comp, p->s->img_x, p->s->img_y); p->s->img_out_n = req_comp; if (result == NULL) return result; } @@ -5734,8 +5480,8 @@ static void * stbi__do_png(stbi__png * p, int * x, int * y, int * n, return result; } -static void * stbi__png_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__png_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { stbi__png p; p.s = s; return stbi__do_png(&p, x, y, comp, req_comp, ri); @@ -5926,8 +5672,8 @@ static void * stbi__bmp_parse_header(stbi__context * s, stbi__bmp_data * info) { "BMP type not supported: unsupported " "compression"); // this includes PNG/JPEG modes if (compress == 3 && info->bpp != 16 && info->bpp != 32) - return stbi__errpuc( - "bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + return stbi__errpuc("bad BMP", + "bad BMP"); // bitfields requires 16 or 32 bits/pixel stbi__get32le(s); // discard sizeof stbi__get32le(s); // discard hres stbi__get32le(s); // discard vres @@ -5958,18 +5704,15 @@ static void * stbi__bmp_parse_header(stbi__context * s, stbi__bmp_data * info) { } else { // V4/V5 header int i; - if (hsz != 108 && hsz != 124) - return stbi__errpuc("bad BMP", "bad BMP"); + if (hsz != 108 && hsz != 124) return stbi__errpuc("bad BMP", "bad BMP"); info->mr = stbi__get32le(s); info->mg = stbi__get32le(s); info->mb = stbi__get32le(s); info->ma = stbi__get32le(s); - if (compress - != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs stbi__bmp_set_mask_defaults(info, compress); stbi__get32le(s); // discard color space - for (i = 0; i < 12; ++i) - stbi__get32le(s); // discard color space parameters + for (i = 0; i < 12; ++i) stbi__get32le(s); // discard color space parameters if (hsz == 124) { stbi__get32le(s); // discard rendering intent stbi__get32le(s); // discard offset of profile data @@ -5981,8 +5724,8 @@ static void * stbi__bmp_parse_header(stbi__context * s, stbi__bmp_data * info) { return (void *) 1; } -static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { stbi_uc * out; unsigned int mr = 0, mg = 0, mb = 0, ma = 0, all_a; stbi_uc pal[256][4]; @@ -5992,8 +5735,7 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, STBI_NOTUSED(ri); info.all_a = 255; - if (stbi__bmp_parse_header(s, &info) == NULL) - return NULL; // error code already set + if (stbi__bmp_parse_header(s, &info) == NULL) return NULL; // error code already set flip_vertically = ((int) s->img_y) > 0; s->img_y = abs((int) s->img_y); @@ -6012,17 +5754,14 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, if (info.hsz == 12) { if (info.bpp < 24) psize = (info.offset - info.extra_read - 24) / 3; } else { - if (info.bpp < 16) - psize = (info.offset - info.extra_read - info.hsz) >> 2; + if (info.bpp < 16) psize = (info.offset - info.extra_read - info.hsz) >> 2; } if (psize == 0) { // accept some number of extra bytes after the header, but if the offset points either to before // the header ends or implies a large amount of extra data, reject the file as malformed int bytes_read_so_far - = s->callback_already_read - + (int) (s->img_buffer - s->img_buffer_original); - int header_limit - = 1024; // max we actually read is below 256 bytes currently. + = s->callback_already_read + (int) (s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. int extra_data_limit = 256 * 4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. @@ -6116,8 +5855,8 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, } } } else { - int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, - gcount = 0, bcount = 0, acount = 0; + int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, gcount = 0, bcount = 0, + acount = 0; int z = 0; int easy = 0; stbi__skip(s, info.offset - info.extra_read - info.hsz); @@ -6128,9 +5867,7 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, if (info.bpp == 24) { easy = 1; } else if (info.bpp == 32) { - if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 - && ma == 0xff000000) - easy = 2; + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) easy = 2; } if (!easy) { if (!mr || !mg || !mb) { @@ -6167,15 +5904,11 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, int bpp = info.bpp; for (i = 0; i < (int) s->img_x; ++i) { stbi__uint32 v - = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) - : stbi__get32le(s)); + = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); unsigned int a; - out[z++] = STBI__BYTECAST( - stbi__shiftsigned(v & mr, rshift, rcount)); - out[z++] = STBI__BYTECAST( - stbi__shiftsigned(v & mg, gshift, gcount)); - out[z++] = STBI__BYTECAST( - stbi__shiftsigned(v & mb, bshift, bcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); all_a |= a; if (target == 4) out[z++] = STBI__BYTECAST(a); @@ -6204,8 +5937,7 @@ static void * stbi__bmp_load(stbi__context * s, int * x, int * y, int * comp, if (req_comp && req_comp != target) { out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); - if (out == NULL) - return out; // stbi__convert_format frees input on failure + if (out == NULL) return out; // stbi__convert_format frees input on failure } *x = s->img_x; @@ -6240,8 +5972,7 @@ static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int * is_rgb16) { } static int stbi__tga_info(stbi__context * s, int * x, int * y, int * comp) { - int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, - tga_colormap_bpp; + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; int sz, tga_colormap_type; stbi__get8(s); // discard Offset tga_colormap_type = stbi__get8(s); // colormap type @@ -6255,8 +5986,7 @@ static int stbi__tga_info(stbi__context * s, int * x, int * y, int * comp) { stbi__rewind(s); return 0; } - stbi__skip( - s, 4); // skip index of first colormap entry and number of entries + stbi__skip(s, 4); // skip index of first colormap entry and number of entries sz = stbi__get8(s); // check bits per palette color entry if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) { stbi__rewind(s); @@ -6265,8 +5995,8 @@ static int stbi__tga_info(stbi__context * s, int * x, int * y, int * comp) { stbi__skip(s, 4); // skip image x and y origin tga_colormap_bpp = sz; } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE - if ((tga_image_type != 2) && (tga_image_type != 3) - && (tga_image_type != 10) && (tga_image_type != 11)) { + if ((tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) + && (tga_image_type != 11)) { stbi__rewind(s); return 0; // only RGB or grey allowed, +/- RLE } @@ -6294,9 +6024,8 @@ static int stbi__tga_info(stbi__context * s, int * x, int * y, int * comp) { } tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); } else { - tga_comp = stbi__tga_get_comp( - tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), - NULL); + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, + (tga_image_type == 3) || (tga_image_type == 11), NULL); } if (!tga_comp) { stbi__rewind(s); @@ -6316,13 +6045,10 @@ static int stbi__tga_test(stbi__context * s) { if (tga_color_type > 1) goto errorEnd; // only RGB or indexed allowed sz = stbi__get8(s); // image type if (tga_color_type == 1) { // colormapped (paletted) image - if (sz != 1 && sz != 9) - goto errorEnd; // colortype 1 demands image type 1 or 9 - stbi__skip( - s, 4); // skip index of first colormap entry and number of entries + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s, 4); // skip index of first colormap entry and number of entries sz = stbi__get8(s); // check bits per palette color entry - if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) - goto errorEnd; + if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) goto errorEnd; stbi__skip(s, 4); // skip image x and y origin } else { // "normal" image w/o colormap if ((sz != 2) && (sz != 3) && (sz != 10) && (sz != 11)) @@ -6334,8 +6060,7 @@ static int stbi__tga_test(stbi__context * s) { sz = stbi__get8(s); // bits per pixel if ((tga_color_type == 1) && (sz != 8) && (sz != 16)) goto errorEnd; // for colormapped images, bpp is size of an index - if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) - goto errorEnd; + if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) goto errorEnd; res = 1; // if we got this far, everything's good and we can return 1 instead of 0 @@ -6363,8 +6088,8 @@ static void stbi__tga_read_rgb16(stbi__context * s, stbi_uc * out) { // so let's treat all 15 and 16bit TGAs as RGB with no alpha. } -static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { // read in the TGA header stuff int tga_offset = stbi__get8(s); int tga_indexed = stbi__get8(s); @@ -6406,11 +6131,8 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, tga_inverted = 1 - ((tga_inverted >> 5) & 1); // If I'm paletted, then I'll use the number of bits from the palette - if (tga_indexed) - tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); - else - tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), - &tga_rgb16); + if (tga_indexed) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); if (!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); @@ -6423,8 +6145,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) return stbi__errpuc("too large", "Corrupt TGA"); - tga_data = (unsigned char *) stbi__malloc_mad3(tga_width, tga_height, - tga_comp, 0); + tga_data = (unsigned char *) stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); // skip to the data's starting position (offset usually = 0) @@ -6439,8 +6160,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, } else { // do I need to load a palette? if (tga_indexed) { - if (tga_palette_len - == 0) { /* you have to have at least one entry! */ + if (tga_palette_len == 0) { /* you have to have at least one entry! */ STBI_FREE(tga_data); return stbi__errpuc("bad palette", "Corrupt TGA"); } @@ -6448,8 +6168,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, // any data to skip? (offset usually = 0) stbi__skip(s, tga_palette_start); // load the palette - tga_palette = (unsigned char *) stbi__malloc_mad2(tga_palette_len, - tga_comp, 0); + tga_palette = (unsigned char *) stbi__malloc_mad2(tga_palette_len, tga_comp, 0); if (!tga_palette) { STBI_FREE(tga_data); return stbi__errpuc("outofmem", "Out of memory"); @@ -6461,8 +6180,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, stbi__tga_read_rgb16(s, pal_entry); pal_entry += tga_comp; } - } else if (!stbi__getn(s, tga_palette, - tga_palette_len * tga_comp)) { + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { STBI_FREE(tga_data); STBI_FREE(tga_palette); return stbi__errpuc("bad palette", "Corrupt TGA"); @@ -6489,8 +6207,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, // load however much data we did have if (tga_indexed) { // read in index, then perform the lookup - int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) - : stbi__get16le(s); + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); if (pal_idx >= tga_palette_len) { // invalid index pal_idx = 0; @@ -6513,8 +6230,7 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, } // end of reading a pixel // copy data - for (j = 0; j < tga_comp; ++j) - tga_data[i * tga_comp + j] = raw_data[j]; + for (j = 0; j < tga_comp; ++j) tga_data[i * tga_comp + j] = raw_data[j]; // in case we're in RLE mode, keep counting down --RLE_count; @@ -6552,13 +6268,11 @@ static void * stbi__tga_load(stbi__context * s, int * x, int * y, int * comp, // convert to target component count if (req_comp && req_comp != tga_comp) - tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, - tga_height); + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); // the things I do to get rid of an error message, and yet keep // Microsoft's C compilers happy... [8^( - tga_palette_start = tga_palette_len = tga_palette_bits = tga_x_origin - = tga_y_origin = 0; + tga_palette_start = tga_palette_len = tga_palette_bits = tga_x_origin = tga_y_origin = 0; STBI_NOTUSED(tga_palette_start); // OK, done return tga_data; @@ -6575,8 +6289,7 @@ static int stbi__psd_test(stbi__context * s) { return r; } -static int stbi__psd_decode_rle(stbi__context * s, stbi_uc * p, - int pixelCount) { +static int stbi__psd_decode_rle(stbi__context * s, stbi_uc * p, int pixelCount) { int count, nleft, len; count = 0; @@ -6613,8 +6326,8 @@ static int stbi__psd_decode_rle(stbi__context * s, stbi_uc * p, return 1; } -static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri, int bpc) { +static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri, int bpc) { int pixelCount; int channelCount, compression; int channel, i; @@ -6629,8 +6342,7 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, // Check file type version. if (stbi__get16be(s) != 1) - return stbi__errpuc("wrong version", - "Unsupported version of PSD image"); + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); // Skip 6 reserved bytes. stbi__skip(s, 6); @@ -6653,8 +6365,7 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, // Make sure the depth is 8 bits. bitdepth = stbi__get16be(s); if (bitdepth != 8 && bitdepth != 16) - return stbi__errpuc("unsupported bit depth", - "PSD bit depth is not 8 or 16 bit"); + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); // Make sure the color mode is RGB. // Valid options are: @@ -6667,8 +6378,7 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, // 8: Duotone // 9: Lab color if (stbi__get16be(s) != 3) - return stbi__errpuc("wrong color format", - "PSD is not in RGB color format"); + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) stbi__skip(s, stbi__get32be(s)); @@ -6685,12 +6395,10 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, // 1: RLE compressed compression = stbi__get16be(s); if (compression > 1) - return stbi__errpuc("bad compression", - "PSD has an unknown compression format"); + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); // Check size - if (!stbi__mad3sizes_valid(4, w, h, 0)) - return stbi__errpuc("too large", "Corrupt PSD"); + if (!stbi__mad3sizes_valid(4, w, h, 0)) return stbi__errpuc("too large", "Corrupt PSD"); // Create the destination image. @@ -6726,8 +6434,7 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, p = out + channel; if (channel >= channelCount) { // Fill this channel with default data. - for (i = 0; i < pixelCount; i++, p += 4) - *p = (channel == 3 ? 255 : 0); + for (i = 0; i < pixelCount; i++, p += 4) *p = (channel == 3 ? 255 : 0); } else { // Read the RLE data. if (!stbi__psd_decode_rle(s, p, pixelCount)) { @@ -6765,8 +6472,7 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, for (i = 0; i < pixelCount; i++, p += 4) *p = (stbi_uc) (stbi__get16be(s) >> 8); } else { - for (i = 0; i < pixelCount; i++, p += 4) - *p = stbi__get8(s); + for (i = 0; i < pixelCount; i++, p += 4) *p = stbi__get8(s); } } } @@ -6805,11 +6511,9 @@ static void * stbi__psd_load(stbi__context * s, int * x, int * y, int * comp, // convert to desired output format if (req_comp && req_comp != 4) { if (ri->bits_per_channel == 16) - out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, - req_comp, w, h); + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); else out = stbi__convert_format(out, 4, req_comp, w, h); - if (out == NULL) - return out; // stbi__convert_format frees input on failure + if (out == NULL) return out; // stbi__convert_format frees input on failure } if (comp) *comp = 4; @@ -6857,8 +6561,7 @@ static stbi_uc * stbi__readval(stbi__context * s, int channel, stbi_uc * dest) { for (i = 0; i < 4; ++i, mask >>= 1) { if (channel & mask) { - if (stbi__at_eof(s)) - return stbi__errpuc("bad file", "PIC file too short"); + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "PIC file too short"); dest[i] = stbi__get8(s); } } @@ -6873,8 +6576,8 @@ static void stbi__copyval(int channel, stbi_uc * dest, const stbi_uc * src) { if (channel & mask) dest[i] = src[i]; } -static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, - int * comp, stbi_uc * result) { +static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, int * comp, + stbi_uc * result) { int act_comp = 0, num_packets = 0, y, chained; stbi__pic_packet packets[10]; @@ -6897,8 +6600,7 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (reading packets)"); - if (packet->size != 8) - return stbi__errpuc("bad format", "packet isn't 8bpp"); + if (packet->size != 8) return stbi__errpuc("bad format", "packet isn't 8bpp"); } while (chained); *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? @@ -6912,8 +6614,7 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, switch (packet->type) { default: - return stbi__errpuc("bad format", - "packet has bad compression type"); + return stbi__errpuc("bad format", "packet has bad compression type"); case 0: { //uncompressed int x; @@ -6932,8 +6633,8 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, count = stbi__get8(s); if (stbi__at_eof(s)) - return stbi__errpuc( - "bad file", "file too short (pure read count)"); + return stbi__errpuc("bad file", + "file too short (pure read count)"); if (count > left) count = (stbi_uc) left; @@ -6950,9 +6651,8 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, while (left > 0) { int count = stbi__get8(s), i; if (stbi__at_eof(s)) - return stbi__errpuc( - "bad file", - "file too short (mixed read count)"); + return stbi__errpuc("bad file", + "file too short (mixed read count)"); if (count >= 128) { // Repeated stbi_uc value[4]; @@ -6960,23 +6660,19 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, if (count == 128) count = stbi__get16be(s); else count -= 127; if (count > left) - return stbi__errpuc("bad file", - "scanline overrun"); + return stbi__errpuc("bad file", "scanline overrun"); - if (!stbi__readval(s, packet->channel, value)) - return 0; + if (!stbi__readval(s, packet->channel, value)) return 0; for (i = 0; i < count; ++i, dest += 4) stbi__copyval(packet->channel, dest, value); } else { // Raw ++count; if (count > left) - return stbi__errpuc("bad file", - "scanline overrun"); + return stbi__errpuc("bad file", "scanline overrun"); for (i = 0; i < count; ++i, dest += 4) - if (!stbi__readval(s, packet->channel, dest)) - return 0; + if (!stbi__readval(s, packet->channel, dest)) return 0; } left -= count; } @@ -6989,8 +6685,8 @@ static stbi_uc * stbi__pic_load_core(stbi__context * s, int width, int height, return result; } -static void * stbi__pic_load(stbi__context * s, int * px, int * py, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__pic_load(stbi__context * s, int * px, int * py, int * comp, int req_comp, + stbi__result_info * ri) { stbi_uc * result; int i, x, y, internal_comp; STBI_NOTUSED(ri); @@ -7007,8 +6703,7 @@ static void * stbi__pic_load(stbi__context * s, int * px, int * py, int * comp, if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large", "Very large image (corrupt?)"); - if (stbi__at_eof(s)) - return stbi__errpuc("bad file", "file too short (pic header)"); + if (stbi__at_eof(s)) return stbi__errpuc("bad file", "file too short (pic header)"); if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); @@ -7053,8 +6748,7 @@ typedef struct { typedef struct { int w, h; stbi_uc * out; // output buffer (always 4 components) - stbi_uc * - background; // The current "background" as far as a gif is concerned + stbi_uc * background; // The current "background" as far as a gif is concerned stbi_uc * history; int flags, bgindex, ratio, transparent, eflags; stbi_uc pal[256][4]; @@ -7087,8 +6781,8 @@ static int stbi__gif_test(stbi__context * s) { return r; } -static void stbi__gif_parse_colortable(stbi__context * s, stbi_uc pal[256][4], - int num_entries, int transp) { +static void stbi__gif_parse_colortable(stbi__context * s, stbi_uc pal[256][4], int num_entries, + int transp) { int i; for (i = 0; i < num_entries; ++i) { pal[i][2] = stbi__get8(s); @@ -7098,16 +6792,14 @@ static void stbi__gif_parse_colortable(stbi__context * s, stbi_uc pal[256][4], } } -static int stbi__gif_header(stbi__context * s, stbi__gif * g, int * comp, - int is_info) { +static int stbi__gif_header(stbi__context * s, stbi__gif * g, int * comp, int is_info) { stbi_uc version; if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return stbi__err("not GIF", "Corrupt GIF"); version = stbi__get8(s); - if (version != '7' && version != '9') - return stbi__err("not GIF", "Corrupt GIF"); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); stbi__g_failure_reason = ""; @@ -7124,13 +6816,11 @@ static int stbi__gif_header(stbi__context * s, stbi__gif * g, int * comp, return stbi__err("too large", "Very large image (corrupt?)"); if (comp != 0) - *comp - = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments if (is_info) return 1; - if (g->flags & 0x80) - stbi__gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1); + if (g->flags & 0x80) stbi__gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1); return 1; } @@ -7155,8 +6845,7 @@ static void stbi__out_gif_code(stbi__gif * g, stbi__uint16 code) { // recurse to decode the prefixes, since the linked-list is backwards, // and working backwards through an interleaved image would be nasty - if (g->codes[code].prefix >= 0) - stbi__out_gif_code(g, g->codes[code].prefix); + if (g->codes[code].prefix >= 0) stbi__out_gif_code(g, g->codes[code].prefix); if (g->cur_y >= g->max_y) return; @@ -7248,11 +6937,9 @@ static stbi_uc * stbi__process_gif_raster(stbi__context * s, stbi__gif * g) { p->prefix = (stbi__int16) oldcode; p->first = g->codes[oldcode].first; - p->suffix - = (code == avail) ? p->first : g->codes[code].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; } else if (code == avail) - return stbi__errpuc("illegal code in raster", - "Corrupt GIF"); + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); stbi__out_gif_code(g, (stbi__uint16) code); @@ -7271,9 +6958,8 @@ static stbi_uc * stbi__process_gif_raster(stbi__context * s, stbi__gif * g) { // this function is designed to support animated gifs, although stb_image doesn't support it // two back is the image from two frames ago, used for a very specific disposal format -static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, - int * comp, int req_comp, - stbi_uc * two_back) { +static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, int * comp, + int req_comp, stbi_uc * two_back) { int dispose; int first_frame; int pi; @@ -7382,13 +7068,11 @@ static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, if (g->lflags & 0x80) { stbi__gif_parse_colortable(s, g->lpal, 2 << (g->lflags & 7), - g->eflags & 0x01 ? g->transparent - : -1); + g->eflags & 0x01 ? g->transparent : -1); g->color_table = (stbi_uc *) g->lpal; } else if (g->flags & 0x80) { g->color_table = (stbi_uc *) g->pal; - } else - return stbi__errpuc("missing color table", "Corrupt GIF"); + } else return stbi__errpuc("missing color table", "Corrupt GIF"); o = stbi__process_gif_raster(s, g); if (!o) return NULL; @@ -7417,10 +7101,9 @@ static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, len = stbi__get8(s); if (len == 4) { g->eflags = stbi__get8(s); - g->delay - = 10 - * stbi__get16le( - s); // delay - 1/100th of a second, saving as 1/1000ths. + g->delay = 10 + * stbi__get16le( + s); // delay - 1/100th of a second, saving as 1/1000ths. // unset old transparent if (g->transparent >= 0) { @@ -7448,8 +7131,7 @@ static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, } case 0x3B: // gif stream termination code - return ( - stbi_uc *) s; // using '1' causes warning on some compilers + return (stbi_uc *) s; // using '1' causes warning on some compilers default: return stbi__errpuc("unknown code", "Corrupt GIF"); @@ -7457,8 +7139,7 @@ static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g, } } -static void * stbi__load_gif_main_outofmem(stbi__gif * g, stbi_uc * out, - int ** delays) { +static void * stbi__load_gif_main_outofmem(stbi__gif * g, stbi_uc * out, int ** delays) { STBI_FREE(g->out); STBI_FREE(g->history); STBI_FREE(g->background); @@ -7468,8 +7149,8 @@ static void * stbi__load_gif_main_outofmem(stbi__gif * g, stbi_uc * out, return stbi__errpuc("outofmem", "Out of memory"); } -static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, - int * y, int * z, int * comp, int req_comp) { +static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, int * y, int * z, + int * comp, int req_comp) { if (stbi__gif_test(s)) { int layers = 0; stbi_uc * u = 0; @@ -7499,34 +7180,28 @@ static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, stride = g.w * g.h * 4; if (out) { - void * tmp = (stbi_uc *) STBI_REALLOC_SIZED( - out, out_size, layers * stride); - if (!tmp) - return stbi__load_gif_main_outofmem(&g, out, delays); + void * tmp + = (stbi_uc *) STBI_REALLOC_SIZED(out, out_size, layers * stride); + if (!tmp) return stbi__load_gif_main_outofmem(&g, out, delays); else { out = (stbi_uc *) tmp; out_size = layers * stride; } if (delays) { - int * new_delays = (int *) STBI_REALLOC_SIZED( - *delays, delays_size, sizeof(int) * layers); - if (!new_delays) - return stbi__load_gif_main_outofmem(&g, out, - delays); + int * new_delays = (int *) STBI_REALLOC_SIZED(*delays, delays_size, + sizeof(int) * layers); + if (!new_delays) return stbi__load_gif_main_outofmem(&g, out, delays); *delays = new_delays; delays_size = layers * sizeof(int); } } else { out = (stbi_uc *) stbi__malloc(layers * stride); - if (!out) - return stbi__load_gif_main_outofmem(&g, out, delays); + if (!out) return stbi__load_gif_main_outofmem(&g, out, delays); out_size = layers * stride; if (delays) { *delays = (int *) stbi__malloc(layers * sizeof(int)); - if (!*delays) - return stbi__load_gif_main_outofmem(&g, out, - delays); + if (!*delays) return stbi__load_gif_main_outofmem(&g, out, delays); delays_size = layers * sizeof(int); } } @@ -7557,8 +7232,8 @@ static void * stbi__load_gif_main(stbi__context * s, int ** delays, int * x, } } -static void * stbi__gif_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__gif_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { stbi_uc * u = 0; stbi__gif g; memset(&g, 0, sizeof(g)); @@ -7572,8 +7247,7 @@ static void * stbi__gif_load(stbi__context * s, int * x, int * y, int * comp, // moved conversion to after successful load so that the same // can be done for multiple frames. - if (req_comp && req_comp != 4) - u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + if (req_comp && req_comp != 4) u = stbi__convert_format(u, 4, req_comp, g.w, g.h); } else if (g.out) { // if there was an error and we allocated an image buffer, free it! STBI_FREE(g.out); @@ -7639,8 +7313,7 @@ static void stbi__hdr_convert(float * output, stbi_uc * input, int req_comp) { float f1; // Exponent f1 = (float) ldexp(1.0f, input[3] - (int) (128 + 8)); - if (req_comp <= 2) - output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + if (req_comp <= 2) output[0] = (input[0] + input[1] + input[2]) * f1 / 3; else { output[0] = input[0] * f1; output[1] = input[1] * f1; @@ -7664,8 +7337,8 @@ static void stbi__hdr_convert(float * output, stbi_uc * input, int req_comp) { } } -static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { char buffer[STBI__HDR_BUFLEN]; char * token; int valid = 0; @@ -7680,8 +7353,7 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, // Check identifier headerToken = stbi__hdr_gettoken(s, buffer); - if (strcmp(headerToken, "#?RADIANCE") != 0 - && strcmp(headerToken, "#?RGBE") != 0) + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) return stbi__errpf("not HDR", "Corrupt HDR image"); // Parse header @@ -7691,8 +7363,7 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; } - if (!valid) - return stbi__errpf("unsupported format", "Unsupported HDR format"); + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); // Parse width and height // can't use sscanf() if we're not using stdio! @@ -7722,8 +7393,7 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, return stbi__errpf("too large", "HDR image is too large"); // Read data - hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, - sizeof(float), 0); + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); if (!hdr_data) return stbi__errpf("outofmem", "Out of memory"); // Load image data @@ -7735,9 +7405,8 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, stbi_uc rgbe[4]; main_decode_loop: stbi__getn(s, rgbe, 4); - stbi__hdr_convert(hdr_data + j * width * req_comp - + i * req_comp, - rgbe, req_comp); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, + req_comp); } } } else { @@ -7767,8 +7436,7 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); - return stbi__errpf("invalid decoded scanline length", - "corrupt HDR"); + return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } if (scanline == NULL) { scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); @@ -7790,27 +7458,23 @@ static float * stbi__hdr_load(stbi__context * s, int * x, int * y, int * comp, if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); - return stbi__errpf("corrupt", - "bad RLE data in HDR"); + return stbi__errpf("corrupt", "bad RLE data in HDR"); } - for (z = 0; z < count; ++z) - scanline[i++ * 4 + k] = value; + for (z = 0; z < count; ++z) scanline[i++ * 4 + k] = value; } else { // Dump if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); - return stbi__errpf("corrupt", - "bad RLE data in HDR"); + return stbi__errpf("corrupt", "bad RLE data in HDR"); } - for (z = 0; z < count; ++z) - scanline[i++ * 4 + k] = stbi__get8(s); + for (z = 0; z < count; ++z) scanline[i++ * 4 + k] = stbi__get8(s); } } } for (i = 0; i < width; ++i) - stbi__hdr_convert(hdr_data + (j * width + i) * req_comp, - scanline + i * 4, req_comp); + stbi__hdr_convert(hdr_data + (j * width + i) * req_comp, scanline + i * 4, + req_comp); } if (scanline) STBI_FREE(scanline); } @@ -8026,13 +7690,13 @@ static int stbi__pnm_test(stbi__context * s) { return 1; } -static void * stbi__pnm_load(stbi__context * s, int * x, int * y, int * comp, - int req_comp, stbi__result_info * ri) { +static void * stbi__pnm_load(stbi__context * s, int * x, int * y, int * comp, int req_comp, + stbi__result_info * ri) { stbi_uc * out; STBI_NOTUSED(ri); - ri->bits_per_channel = stbi__pnm_info(s, (int *) &s->img_x, - (int *) &s->img_y, (int *) &s->img_n); + ri->bits_per_channel + = stbi__pnm_info(s, (int *) &s->img_x, (int *) &s->img_y, (int *) &s->img_n); if (ri->bits_per_channel == 0) return 0; if (s->img_y > STBI_MAX_DIMENSIONS) @@ -8044,48 +7708,40 @@ static void * stbi__pnm_load(stbi__context * s, int * x, int * y, int * comp, *y = s->img_y; if (comp) *comp = s->img_n; - if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, - ri->bits_per_channel / 8, 0)) + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) return stbi__errpuc("too large", "PNM too large"); - out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, - ri->bits_per_channel / 8, 0); + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, + 0); if (!out) return stbi__errpuc("outofmem", "Out of memory"); - if (!stbi__getn(s, out, - s->img_n * s->img_x * s->img_y - * (ri->bits_per_channel / 8))) { + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { STBI_FREE(out); return stbi__errpuc("bad PNM", "PNM file truncated"); } if (req_comp && req_comp != s->img_n) { if (ri->bits_per_channel == 16) { - out = (stbi_uc *) stbi__convert_format16( - (stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, + s->img_x, s->img_y); } else { - out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, - s->img_y); + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); } - if (out == NULL) - return out; // stbi__convert_format frees input on failure + if (out == NULL) return out; // stbi__convert_format frees input on failure } return out; } static int stbi__pnm_isspace(char c) { - return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' - || c == '\r'; + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; } static void stbi__pnm_skip_whitespace(stbi__context * s, char * c) { for (;;) { - while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) - *c = (char) stbi__get8(s); + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) *c = (char) stbi__get8(s); if (stbi__at_eof(s) || *c != '#') break; - while (!stbi__at_eof(s) && *c != '\n' && *c != '\r') - *c = (char) stbi__get8(s); + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r') *c = (char) stbi__get8(s); } } @@ -8098,9 +7754,8 @@ static int stbi__pnm_getinteger(stbi__context * s, char * c) { value = value * 10 + (*c - '0'); *c = (char) stbi__get8(s); if ((value > 214748364) || (value == 214748364 && *c > '7')) - return stbi__err( - "integer parse overflow", - "Parsing an integer in the PPM header overflowed a 32-bit int"); + return stbi__err("integer parse overflow", + "Parsing an integer in the PPM header overflowed a 32-bit int"); } return value; @@ -8124,22 +7779,19 @@ static int stbi__pnm_info(stbi__context * s, int * x, int * y, int * comp) { return 0; } - *comp = (t == '6') ? 3 - : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm c = (char) stbi__get8(s); stbi__pnm_skip_whitespace(s, &c); *x = stbi__pnm_getinteger(s, &c); // read width if (*x == 0) - return stbi__err("invalid width", - "PPM image header had zero or overflowing width"); + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); stbi__pnm_skip_whitespace(s, &c); *y = stbi__pnm_getinteger(s, &c); // read height if (*y == 0) - return stbi__err("invalid width", - "PPM image header had zero or overflowing width"); + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); stbi__pnm_skip_whitespace(s, &c); maxv = stbi__pnm_getinteger(s, &c); // read max value @@ -8193,8 +7845,7 @@ static int stbi__info_main(stbi__context * s, int * x, int * y, int * comp) { #ifndef STBI_NO_TGA if (stbi__tga_info(s, x, y, comp)) return 1; #endif - return stbi__err("unknown image type", - "Image not of any known type, or corrupt"); + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); } static int stbi__is_16_main(stbi__context * s) { @@ -8252,15 +7903,15 @@ STBIDEF int stbi_is_16_bit_from_file(FILE * f) { } #endif // !STBI_NO_STDIO -STBIDEF int stbi_info_from_memory(stbi_uc const * buffer, int len, int * x, - int * y, int * comp) { +STBIDEF int stbi_info_from_memory(stbi_uc const * buffer, int len, int * x, int * y, + int * comp) { stbi__context s; stbi__start_mem(&s, buffer, len); return stbi__info_main(&s, x, y, comp); } -STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const * c, void * user, - int * x, int * y, int * comp) { +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const * c, void * user, int * x, + int * y, int * comp) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); return stbi__info_main(&s, x, y, comp); @@ -8272,8 +7923,7 @@ STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const * buffer, int len) { return stbi__is_16_main(&s); } -STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const * c, - void * user) { +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const * c, void * user) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); return stbi__is_16_main(&s); |