127#ifndef STBI_INCLUDE_STB_IMAGE_H
128#define STBI_INCLUDE_STB_IMAGE_H
372#define STBI_VERSION 1
384typedef unsigned char stbi_uc;
385typedef unsigned short stbi_us;
392#ifdef STB_IMAGE_STATIC
393#define STBIDEF static
395#define STBIDEF extern
409 int (*read)(
void * user,
char * data,
411 void (*skip)(
void * user,
int n);
412 int (*eof)(
void * user);
420STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * channels_in_file,
421 int desired_channels);
422STBIDEF stbi_uc * stbi_load_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
423 int * channels_in_file,
int desired_channels);
426STBIDEF stbi_uc * stbi_load(
char const * filename,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
427STBIDEF stbi_uc * stbi_load_from_file(FILE * f,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
432STBIDEF stbi_uc * stbi_load_gif_from_memory(stbi_uc
const * buffer,
int len,
int ** delays,
int * x,
int * y,
int * z,
433 int * comp,
int req_comp);
436#ifdef STBI_WINDOWS_UTF8
437STBIDEF
int stbi_convert_wchar_to_utf8(
char * buffer,
size_t bufferlen,
const wchar_t * input);
445STBIDEF stbi_us * stbi_load_16_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * channels_in_file,
446 int desired_channels);
447STBIDEF stbi_us * stbi_load_16_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
448 int * channels_in_file,
int desired_channels);
451STBIDEF stbi_us * stbi_load_16(
char const * filename,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
452STBIDEF stbi_us * stbi_load_from_file_16(FILE * f,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
459#ifndef STBI_NO_LINEAR
460STBIDEF
float * stbi_loadf_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * channels_in_file,
461 int desired_channels);
462STBIDEF
float * stbi_loadf_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
int * channels_in_file,
463 int desired_channels);
466STBIDEF
float * stbi_loadf(
char const * filename,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
467STBIDEF
float * stbi_loadf_from_file(FILE * f,
int * x,
int * y,
int * channels_in_file,
int desired_channels);
472STBIDEF
void stbi_hdr_to_ldr_gamma(
float gamma);
473STBIDEF
void stbi_hdr_to_ldr_scale(
float scale);
476#ifndef STBI_NO_LINEAR
477STBIDEF
void stbi_ldr_to_hdr_gamma(
float gamma);
478STBIDEF
void stbi_ldr_to_hdr_scale(
float scale);
482STBIDEF
int stbi_is_hdr_from_callbacks(
stbi_io_callbacks const * clbk,
void * user);
483STBIDEF
int stbi_is_hdr_from_memory(stbi_uc
const * buffer,
int len);
485STBIDEF
int stbi_is_hdr(
char const * filename);
486STBIDEF
int stbi_is_hdr_from_file(FILE * f);
491STBIDEF
const char * stbi_failure_reason(
void);
494STBIDEF
void stbi_image_free(
void * retval_from_stbi_load);
497STBIDEF
int stbi_info_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * comp);
498STBIDEF
int stbi_info_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
int * comp);
499STBIDEF
int stbi_is_16_bit_from_memory(stbi_uc
const * buffer,
int len);
500STBIDEF
int stbi_is_16_bit_from_callbacks(
stbi_io_callbacks const * clbk,
void * user);
503STBIDEF
int stbi_info(
char const * filename,
int * x,
int * y,
int * comp);
504STBIDEF
int stbi_info_from_file(FILE * f,
int * x,
int * y,
int * comp);
505STBIDEF
int stbi_is_16_bit(
char const * filename);
506STBIDEF
int stbi_is_16_bit_from_file(FILE * f);
512STBIDEF
void stbi_set_unpremultiply_on_load(
int flag_true_if_should_unpremultiply);
516STBIDEF
void stbi_convert_iphone_png_to_rgb(
int flag_true_if_should_convert);
519STBIDEF
void stbi_set_flip_vertically_on_load(
int flag_true_if_should_flip);
524STBIDEF
void stbi_set_unpremultiply_on_load_thread(
int flag_true_if_should_unpremultiply);
525STBIDEF
void stbi_convert_iphone_png_to_rgb_thread(
int flag_true_if_should_convert);
526STBIDEF
void stbi_set_flip_vertically_on_load_thread(
int flag_true_if_should_flip);
530STBIDEF
char * stbi_zlib_decode_malloc_guesssize(
const char * buffer,
int len,
int initial_size,
int * outlen);
531STBIDEF
char * stbi_zlib_decode_malloc_guesssize_headerflag(
const char * buffer,
int len,
int initial_size,
int * outlen,
533STBIDEF
char * stbi_zlib_decode_malloc(
const char * buffer,
int len,
int * outlen);
534STBIDEF
int stbi_zlib_decode_buffer(
char * obuffer,
int olen,
const char * ibuffer,
int ilen);
536STBIDEF
char * stbi_zlib_decode_noheader_malloc(
const char * buffer,
int len,
int * outlen);
537STBIDEF
int stbi_zlib_decode_noheader_buffer(
char * obuffer,
int olen,
const char * ibuffer,
int ilen);
548#ifdef STB_IMAGE_IMPLEMENTATION
550#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) || defined(STBI_ONLY_TGA) || \
551 defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || \
552 defined(STBI_ONLY_PNM) || defined(STBI_ONLY_ZLIB)
553#ifndef STBI_ONLY_JPEG
582#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
592#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
602#define STBI_ASSERT(x) assert(x)
606#define STBI_EXTERN extern "C"
608#define STBI_EXTERN extern
613#define stbi_inline inline
618#define stbi_inline __forceinline
621#ifndef STBI_NO_THREAD_LOCALS
622#if defined(__cplusplus) && __cplusplus >= 201103L
623#define STBI_THREAD_LOCAL thread_local
624#elif defined(__GNUC__) && __GNUC__ < 5
625#define STBI_THREAD_LOCAL __thread
626#elif defined(_MSC_VER)
627#define STBI_THREAD_LOCAL __declspec(thread)
628#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
629#define STBI_THREAD_LOCAL _Thread_local
632#ifndef STBI_THREAD_LOCAL
634#define STBI_THREAD_LOCAL __thread
639#if defined(_MSC_VER) || defined(__SYMBIAN32__)
640typedef unsigned short stbi__uint16;
641typedef signed short stbi__int16;
642typedef unsigned int stbi__uint32;
643typedef signed int stbi__int32;
646typedef uint16_t stbi__uint16;
647typedef int16_t stbi__int16;
648typedef uint32_t stbi__uint32;
649typedef int32_t stbi__int32;
653typedef unsigned char validate_uint32[
sizeof(stbi__uint32) == 4 ? 1 : -1];
656#define STBI_NOTUSED(v) (void)(v)
658#define STBI_NOTUSED(v) (void)sizeof(v)
662#define STBI_HAS_LROTL
666#define stbi_lrot(x, y) _lrotl(x, y)
668#define stbi_lrot(x, y) (((x) << (y)) | ((x) >> (-(y)&31)))
671#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
673#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
676#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
680#define STBI_MALLOC(sz) malloc(sz)
681#define STBI_REALLOC(p, newsz) realloc(p, newsz)
682#define STBI_FREE(p) free(p)
685#ifndef STBI_REALLOC_SIZED
686#define STBI_REALLOC_SIZED(p, oldsz, newsz) STBI_REALLOC(p, newsz)
690#if defined(__x86_64__) || defined(_M_X64)
691#define STBI__X64_TARGET
692#elif defined(__i386) || defined(_M_IX86)
693#define STBI__X86_TARGET
696#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
707#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
722#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
724#include <emmintrin.h>
730static int stbi__cpuid3(
void) {
736static int stbi__cpuid3(
void) {
747#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
749#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
750static int stbi__sse2_available(
void) {
751 int info3 = stbi__cpuid3();
752 return ((info3 >> 26) & 1) != 0;
757#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
759#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
760static int stbi__sse2_available(
void) {
772#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
779#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
781#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
785#ifndef STBI_SIMD_ALIGN
786#define STBI_SIMD_ALIGN(type, name) type name
789#ifndef STBI_MAX_DIMENSIONS
790#define STBI_MAX_DIMENSIONS (1 << 24)
800 stbi__uint32 img_x, img_y;
801 int img_n, img_out_n;
806 int read_from_callbacks;
808 stbi_uc buffer_start[128];
809 int callback_already_read;
811 stbi_uc *img_buffer, *img_buffer_end;
812 stbi_uc *img_buffer_original, *img_buffer_original_end;
815static void stbi__refill_buffer(stbi__context * s);
818static void stbi__start_mem(stbi__context * s, stbi_uc
const * buffer,
int len) {
820 s->read_from_callbacks = 0;
821 s->callback_already_read = 0;
822 s->img_buffer = s->img_buffer_original = (stbi_uc *)buffer;
823 s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *)buffer + len;
827static void stbi__start_callbacks(stbi__context * s,
stbi_io_callbacks * c,
void * user) {
829 s->io_user_data = user;
830 s->buflen =
sizeof(s->buffer_start);
831 s->read_from_callbacks = 1;
832 s->callback_already_read = 0;
833 s->img_buffer = s->img_buffer_original = s->buffer_start;
834 stbi__refill_buffer(s);
835 s->img_buffer_original_end = s->img_buffer_end;
840static int stbi__stdio_read(
void * user,
char * data,
int size) {
return (
int)fread(data, 1, size, (FILE *)user); }
842static void stbi__stdio_skip(
void * user,
int n) {
844 fseek((FILE *)user, n, SEEK_CUR);
845 ch = fgetc((FILE *)user);
847 ungetc(ch, (FILE *)user);
851static int stbi__stdio_eof(
void * user) {
return feof((FILE *)user) || ferror((FILE *)user); }
859static void stbi__start_file(stbi__context * s, FILE * f) { stbi__start_callbacks(s, &stbi__stdio_callbacks, (
void *)f); }
865static void stbi__rewind(stbi__context * s) {
869 s->img_buffer = s->img_buffer_original;
870 s->img_buffer_end = s->img_buffer_original_end;
873enum { STBI_ORDER_RGB, STBI_ORDER_BGR };
876 int bits_per_channel;
882static int stbi__jpeg_test(stbi__context * s);
883static void * stbi__jpeg_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
884static int stbi__jpeg_info(stbi__context * s,
int * x,
int * y,
int * comp);
888static int stbi__png_test(stbi__context * s);
889static void * stbi__png_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
890static int stbi__png_info(stbi__context * s,
int * x,
int * y,
int * comp);
891static int stbi__png_is16(stbi__context * s);
895static int stbi__bmp_test(stbi__context * s);
896static void * stbi__bmp_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
897static int stbi__bmp_info(stbi__context * s,
int * x,
int * y,
int * comp);
901static int stbi__tga_test(stbi__context * s);
902static void * stbi__tga_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
903static int stbi__tga_info(stbi__context * s,
int * x,
int * y,
int * comp);
907static int stbi__psd_test(stbi__context * s);
908static void * stbi__psd_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri,
int bpc);
909static int stbi__psd_info(stbi__context * s,
int * x,
int * y,
int * comp);
910static int stbi__psd_is16(stbi__context * s);
914static int stbi__hdr_test(stbi__context * s);
915static float * stbi__hdr_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
916static int stbi__hdr_info(stbi__context * s,
int * x,
int * y,
int * comp);
920static int stbi__pic_test(stbi__context * s);
921static void * stbi__pic_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
922static int stbi__pic_info(stbi__context * s,
int * x,
int * y,
int * comp);
926static int stbi__gif_test(stbi__context * s);
927static void * stbi__gif_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
928static void * stbi__load_gif_main(stbi__context * s,
int ** delays,
int * x,
int * y,
int * z,
int * comp,
int req_comp);
929static int stbi__gif_info(stbi__context * s,
int * x,
int * y,
int * comp);
933static int stbi__pnm_test(stbi__context * s);
934static void * stbi__pnm_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri);
935static int stbi__pnm_info(stbi__context * s,
int * x,
int * y,
int * comp);
936static int stbi__pnm_is16(stbi__context * s);
940#ifdef STBI_THREAD_LOCAL
943 const char * stbi__g_failure_reason;
945STBIDEF
const char * stbi_failure_reason(
void) {
return stbi__g_failure_reason; }
947#ifndef STBI_NO_FAILURE_STRINGS
948static int stbi__err(
const char * str) {
949 stbi__g_failure_reason = str;
954static void * stbi__malloc(
size_t size) {
return STBI_MALLOC(size); }
968static int stbi__addsizes_valid(
int a,
int b) {
975 return a <= INT_MAX - b;
980static int stbi__mul2sizes_valid(
int a,
int b) {
986 return a <= INT_MAX / b;
989#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
991static int stbi__mad2sizes_valid(
int a,
int b,
int add) {
992 return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a * b, add);
997static int stbi__mad3sizes_valid(
int a,
int b,
int c,
int add) {
998 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) && stbi__addsizes_valid(a * b * c, add);
1002#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1003static int stbi__mad4sizes_valid(
int a,
int b,
int c,
int d,
int add) {
1004 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a * b, c) && stbi__mul2sizes_valid(a * b * c, d) &&
1005 stbi__addsizes_valid(a * b * c * d, add);
1009#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
1011static void * stbi__malloc_mad2(
int a,
int b,
int add) {
1012 if (!stbi__mad2sizes_valid(a, b, add))
1014 return stbi__malloc(a * b + add);
1018static void * stbi__malloc_mad3(
int a,
int b,
int c,
int add) {
1019 if (!stbi__mad3sizes_valid(a, b, c, add))
1021 return stbi__malloc(a * b * c + add);
1024#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1025static void * stbi__malloc_mad4(
int a,
int b,
int c,
int d,
int add) {
1026 if (!stbi__mad4sizes_valid(a, b, c, d, add))
1028 return stbi__malloc(a * b * c * d + add);
1033static int stbi__addints_valid(
int a,
int b) {
1034 if ((a >= 0) != (b >= 0))
1037 return a >= INT_MIN - b;
1038 return a <= INT_MAX - b;
1042static int stbi__mul2shorts_valid(
short a,
short b) {
1043 if (b == 0 || b == -1)
1045 if ((a >= 0) == (b >= 0))
1046 return a <= SHRT_MAX / b;
1048 return a <= SHRT_MIN / b;
1049 return a >= SHRT_MIN / b;
1056#ifdef STBI_NO_FAILURE_STRINGS
1057#define stbi__err(x, y) 0
1058#elif defined(STBI_FAILURE_USERMSG)
1059#define stbi__err(x, y) stbi__err(y)
1061#define stbi__err(x, y) stbi__err(x)
1064#define stbi__errpf(x, y) ((float *)(size_t)(stbi__err(x, y) ? NULL : NULL))
1065#define stbi__errpuc(x, y) ((unsigned char *)(size_t)(stbi__err(x, y) ? NULL : NULL))
1067STBIDEF
void stbi_image_free(
void * retval_from_stbi_load) { STBI_FREE(retval_from_stbi_load); }
1069#ifndef STBI_NO_LINEAR
1070static float * stbi__ldr_to_hdr(stbi_uc * data,
int x,
int y,
int comp);
1074static stbi_uc * stbi__hdr_to_ldr(
float * data,
int x,
int y,
int comp);
1077static int stbi__vertically_flip_on_load_global = 0;
1079STBIDEF
void stbi_set_flip_vertically_on_load(
int flag_true_if_should_flip) {
1080 stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
1083#ifndef STBI_THREAD_LOCAL
1084#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
1086static STBI_THREAD_LOCAL
int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
1088STBIDEF
void stbi_set_flip_vertically_on_load_thread(
int flag_true_if_should_flip) {
1089 stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
1090 stbi__vertically_flip_on_load_set = 1;
1093#define stbi__vertically_flip_on_load \
1094 (stbi__vertically_flip_on_load_set ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global)
1097static void * stbi__load_main(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri,
int bpc) {
1098 memset(ri, 0,
sizeof(*ri));
1099 ri->bits_per_channel = 8;
1100 ri->channel_order = STBI_ORDER_RGB;
1101 ri->num_channels = 0;
1106 if (stbi__png_test(s))
1107 return stbi__png_load(s, x, y, comp, req_comp, ri);
1110 if (stbi__bmp_test(s))
1111 return stbi__bmp_load(s, x, y, comp, req_comp, ri);
1114 if (stbi__gif_test(s))
1115 return stbi__gif_load(s, x, y, comp, req_comp, ri);
1118 if (stbi__psd_test(s))
1119 return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc);
1124 if (stbi__pic_test(s))
1125 return stbi__pic_load(s, x, y, comp, req_comp, ri);
1132 if (stbi__jpeg_test(s))
1133 return stbi__jpeg_load(s, x, y, comp, req_comp, ri);
1136 if (stbi__pnm_test(s))
1137 return stbi__pnm_load(s, x, y, comp, req_comp, ri);
1141 if (stbi__hdr_test(s)) {
1142 float * hdr = stbi__hdr_load(s, x, y, comp, req_comp, ri);
1143 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
1149 if (stbi__tga_test(s))
1150 return stbi__tga_load(s, x, y, comp, req_comp, ri);
1153 return stbi__errpuc(
"unknown image type",
"Image not of any known type, or corrupt");
1156static stbi_uc * stbi__convert_16_to_8(stbi__uint16 * orig,
int w,
int h,
int channels) {
1158 int img_len = w * h * channels;
1161 reduced = (stbi_uc *)stbi__malloc(img_len);
1162 if (reduced == NULL)
1163 return stbi__errpuc(
"outofmem",
"Out of memory");
1165 for (i = 0; i < img_len; ++i)
1166 reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF);
1172static stbi__uint16 * stbi__convert_8_to_16(stbi_uc * orig,
int w,
int h,
int channels) {
1174 int img_len = w * h * channels;
1175 stbi__uint16 * enlarged;
1177 enlarged = (stbi__uint16 *)stbi__malloc(img_len * 2);
1178 if (enlarged == NULL)
1179 return (stbi__uint16 *)stbi__errpuc(
"outofmem",
"Out of memory");
1181 for (i = 0; i < img_len; ++i)
1182 enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]);
1188static void stbi__vertical_flip(
void * image,
int w,
int h,
int bytes_per_pixel) {
1190 size_t bytes_per_row = (size_t)w * bytes_per_pixel;
1192 stbi_uc * bytes = (stbi_uc *)image;
1194 for (row = 0; row < (h >> 1); row++) {
1195 stbi_uc * row0 = bytes + row * bytes_per_row;
1196 stbi_uc * row1 = bytes + (h - row - 1) * bytes_per_row;
1198 size_t bytes_left = bytes_per_row;
1199 while (bytes_left) {
1200 size_t bytes_copy = (bytes_left <
sizeof(temp)) ? bytes_left :
sizeof(temp);
1201 memcpy(temp, row0, bytes_copy);
1202 memcpy(row0, row1, bytes_copy);
1203 memcpy(row1, temp, bytes_copy);
1206 bytes_left -= bytes_copy;
1212static void stbi__vertical_flip_slices(
void * image,
int w,
int h,
int z,
int bytes_per_pixel) {
1214 int slice_size = w * h * bytes_per_pixel;
1216 stbi_uc * bytes = (stbi_uc *)image;
1217 for (slice = 0; slice < z; ++slice) {
1218 stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
1219 bytes += slice_size;
1224static unsigned char * stbi__load_and_postprocess_8bit(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp) {
1225 stbi__result_info ri;
1226 void * result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
1232 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1234 if (ri.bits_per_channel != 8) {
1235 result = stbi__convert_16_to_8((stbi__uint16 *)result, *x, *y, req_comp == 0 ? *comp : req_comp);
1236 ri.bits_per_channel = 8;
1241 if (stbi__vertically_flip_on_load) {
1242 int channels = req_comp ? req_comp : *comp;
1243 stbi__vertical_flip(result, *x, *y, channels *
sizeof(stbi_uc));
1246 return (
unsigned char *)result;
1249static stbi__uint16 * stbi__load_and_postprocess_16bit(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp) {
1250 stbi__result_info ri;
1251 void * result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
1257 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1259 if (ri.bits_per_channel != 16) {
1260 result = stbi__convert_8_to_16((stbi_uc *)result, *x, *y, req_comp == 0 ? *comp : req_comp);
1261 ri.bits_per_channel = 16;
1267 if (stbi__vertically_flip_on_load) {
1268 int channels = req_comp ? req_comp : *comp;
1269 stbi__vertical_flip(result, *x, *y, channels *
sizeof(stbi__uint16));
1272 return (stbi__uint16 *)result;
1275#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
1276static void stbi__float_postprocess(
float * result,
int * x,
int * y,
int * comp,
int req_comp) {
1277 if (stbi__vertically_flip_on_load && result != NULL) {
1278 int channels = req_comp ? req_comp : *comp;
1279 stbi__vertical_flip(result, *x, *y, channels *
sizeof(
float));
1284#ifndef STBI_NO_STDIO
1286#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1287STBI_EXTERN __declspec(dllimport)
int __stdcall MultiByteToWideChar(
unsigned int cp,
unsigned long flags,
const char * str,
1288 int cbmb,
wchar_t * widestr,
int cchwide);
1289STBI_EXTERN __declspec(dllimport)
int __stdcall WideCharToMultiByte(
unsigned int cp,
unsigned long flags,
1290 const wchar_t * widestr,
int cchwide,
char * str,
int cbmb,
1291 const char * defchar,
int * used_default);
1294#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1295STBIDEF
int stbi_convert_wchar_to_utf8(
char * buffer,
size_t bufferlen,
const wchar_t * input) {
1296 return WideCharToMultiByte(65001 , 0, input, -1, buffer, (
int)bufferlen, NULL, NULL);
1300static FILE * stbi__fopen(
char const * filename,
char const * mode) {
1302#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1304 wchar_t wFilename[1024];
1305 if (0 == MultiByteToWideChar(65001 , 0, filename, -1, wFilename,
sizeof(wFilename) /
sizeof(*wFilename)))
1308 if (0 == MultiByteToWideChar(65001 , 0, mode, -1, wMode,
sizeof(wMode) /
sizeof(*wMode)))
1311#if defined(_MSC_VER) && _MSC_VER >= 1400
1312 if (0 != _wfopen_s(&f, wFilename, wMode))
1315 f = _wfopen(wFilename, wMode);
1318#elif defined(_MSC_VER) && _MSC_VER >= 1400
1319 if (0 != fopen_s(&f, filename, mode))
1322 f = fopen(filename, mode);
1327STBIDEF stbi_uc * stbi_load(
char const * filename,
int * x,
int * y,
int * comp,
int req_comp) {
1328 FILE * f = stbi__fopen(filename,
"rb");
1329 unsigned char * result;
1331 return stbi__errpuc(
"can't fopen",
"Unable to open file");
1332 result = stbi_load_from_file(f, x, y, comp, req_comp);
1337STBIDEF stbi_uc * stbi_load_from_file(FILE * f,
int * x,
int * y,
int * comp,
int req_comp) {
1338 unsigned char * result;
1340 stbi__start_file(&s, f);
1341 result = stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
1344 fseek(f, -(
int)(s.img_buffer_end - s.img_buffer), SEEK_CUR);
1349STBIDEF stbi__uint16 * stbi_load_from_file_16(FILE * f,
int * x,
int * y,
int * comp,
int req_comp) {
1350 stbi__uint16 * result;
1352 stbi__start_file(&s, f);
1353 result = stbi__load_and_postprocess_16bit(&s, x, y, comp, req_comp);
1356 fseek(f, -(
int)(s.img_buffer_end - s.img_buffer), SEEK_CUR);
1361STBIDEF stbi_us * stbi_load_16(
char const * filename,
int * x,
int * y,
int * comp,
int req_comp) {
1362 FILE * f = stbi__fopen(filename,
"rb");
1363 stbi__uint16 * result;
1365 return (stbi_us *)stbi__errpuc(
"can't fopen",
"Unable to open file");
1366 result = stbi_load_from_file_16(f, x, y, comp, req_comp);
1373STBIDEF stbi_us * stbi_load_16_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * channels_in_file,
1374 int desired_channels) {
1376 stbi__start_mem(&s, buffer, len);
1377 return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels);
1380STBIDEF stbi_us * stbi_load_16_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
1381 int * channels_in_file,
int desired_channels) {
1384 return stbi__load_and_postprocess_16bit(&s, x, y, channels_in_file, desired_channels);
1387STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * comp,
int req_comp) {
1389 stbi__start_mem(&s, buffer, len);
1390 return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
1393STBIDEF stbi_uc * stbi_load_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
int * comp,
1397 return stbi__load_and_postprocess_8bit(&s, x, y, comp, req_comp);
1401STBIDEF stbi_uc * stbi_load_gif_from_memory(stbi_uc
const * buffer,
int len,
int ** delays,
int * x,
int * y,
int * z,
1402 int * comp,
int req_comp) {
1403 unsigned char * result;
1405 stbi__start_mem(&s, buffer, len);
1407 result = (
unsigned char *)stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
1408 if (stbi__vertically_flip_on_load) {
1409 stbi__vertical_flip_slices(result, *x, *y, *z, *comp);
1416#ifndef STBI_NO_LINEAR
1417static float * stbi__loadf_main(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp) {
1418 unsigned char * data;
1420 if (stbi__hdr_test(s)) {
1421 stbi__result_info ri;
1422 float * hdr_data = stbi__hdr_load(s, x, y, comp, req_comp, &ri);
1424 stbi__float_postprocess(hdr_data, x, y, comp, req_comp);
1428 data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
1430 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
1431 return stbi__errpf(
"unknown image type",
"Image not of any known type, or corrupt");
1434STBIDEF
float * stbi_loadf_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * comp,
int req_comp) {
1436 stbi__start_mem(&s, buffer, len);
1437 return stbi__loadf_main(&s, x, y, comp, req_comp);
1440STBIDEF
float * stbi_loadf_from_callbacks(
stbi_io_callbacks const * clbk,
void * user,
int * x,
int * y,
int * comp,
1444 return stbi__loadf_main(&s, x, y, comp, req_comp);
1447#ifndef STBI_NO_STDIO
1448STBIDEF
float * stbi_loadf(
char const * filename,
int * x,
int * y,
int * comp,
int req_comp) {
1450 FILE * f = stbi__fopen(filename,
"rb");
1452 return stbi__errpf(
"can't fopen",
"Unable to open file");
1453 result = stbi_loadf_from_file(f, x, y, comp, req_comp);
1458STBIDEF
float * stbi_loadf_from_file(FILE * f,
int * x,
int * y,
int * comp,
int req_comp) {
1460 stbi__start_file(&s, f);
1461 return stbi__loadf_main(&s, x, y, comp, req_comp);
1471STBIDEF
int stbi_is_hdr_from_memory(stbi_uc
const * buffer,
int len) {
1474 stbi__start_mem(&s, buffer, len);
1475 return stbi__hdr_test(&s);
1477 STBI_NOTUSED(buffer);
1483#ifndef STBI_NO_STDIO
1484STBIDEF
int stbi_is_hdr(
char const * filename) {
1485 FILE * f = stbi__fopen(filename,
"rb");
1488 result = stbi_is_hdr_from_file(f);
1494STBIDEF
int stbi_is_hdr_from_file(FILE * f) {
1496 long pos = ftell(f);
1499 stbi__start_file(&s, f);
1500 res = stbi__hdr_test(&s);
1501 fseek(f, pos, SEEK_SET);
1510STBIDEF
int stbi_is_hdr_from_callbacks(
stbi_io_callbacks const * clbk,
void * user) {
1514 return stbi__hdr_test(&s);
1522#ifndef STBI_NO_LINEAR
1523static float stbi__l2h_gamma = 2.2f, stbi__l2h_scale = 1.0f;
1525STBIDEF
void stbi_ldr_to_hdr_gamma(
float gamma) { stbi__l2h_gamma = gamma; }
1526STBIDEF
void stbi_ldr_to_hdr_scale(
float scale) { stbi__l2h_scale = scale; }
1529static float stbi__h2l_gamma_i = 1.0f / 2.2f, stbi__h2l_scale_i = 1.0f;
1531STBIDEF
void stbi_hdr_to_ldr_gamma(
float gamma) { stbi__h2l_gamma_i = 1 / gamma; }
1532STBIDEF
void stbi_hdr_to_ldr_scale(
float scale) { stbi__h2l_scale_i = 1 / scale; }
1539enum { STBI__SCAN_load = 0, STBI__SCAN_type, STBI__SCAN_header };
1541static void stbi__refill_buffer(stbi__context * s) {
1542 int n = (s->io.read)(s->io_user_data, (
char *)s->buffer_start, s->buflen);
1543 s->callback_already_read += (int)(s->img_buffer - s->img_buffer_original);
1547 s->read_from_callbacks = 0;
1548 s->img_buffer = s->buffer_start;
1549 s->img_buffer_end = s->buffer_start + 1;
1552 s->img_buffer = s->buffer_start;
1553 s->img_buffer_end = s->buffer_start + n;
1557stbi_inline
static stbi_uc stbi__get8(stbi__context * s) {
1558 if (s->img_buffer < s->img_buffer_end)
1559 return *s->img_buffer++;
1560 if (s->read_from_callbacks) {
1561 stbi__refill_buffer(s);
1562 return *s->img_buffer++;
1567#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1570stbi_inline
static int stbi__at_eof(stbi__context * s) {
1572 if (!(s->io.eof)(s->io_user_data))
1576 if (s->read_from_callbacks == 0)
1580 return s->img_buffer >= s->img_buffer_end;
1584#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && \
1585 defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
1588static void stbi__skip(stbi__context * s,
int n) {
1592 s->img_buffer = s->img_buffer_end;
1596 int blen = (int)(s->img_buffer_end - s->img_buffer);
1598 s->img_buffer = s->img_buffer_end;
1599 (s->io.skip)(s->io_user_data, n - blen);
1607#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
1610static int stbi__getn(stbi__context * s, stbi_uc * buffer,
int n) {
1612 int blen = (int)(s->img_buffer_end - s->img_buffer);
1616 memcpy(buffer, s->img_buffer, blen);
1618 count = (s->io.read)(s->io_user_data, (
char *)buffer + blen, n - blen);
1619 res = (count == (n - blen));
1620 s->img_buffer = s->img_buffer_end;
1625 if (s->img_buffer + n <= s->img_buffer_end) {
1626 memcpy(buffer, s->img_buffer, n);
1634#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1637static int stbi__get16be(stbi__context * s) {
1638 int z = stbi__get8(s);
1639 return (z << 8) + stbi__get8(s);
1643#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1646static stbi__uint32 stbi__get32be(stbi__context * s) {
1647 stbi__uint32 z = stbi__get16be(s);
1648 return (z << 16) + stbi__get16be(s);
1652#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
1655static int stbi__get16le(stbi__context * s) {
1656 int z = stbi__get8(s);
1657 return z + (stbi__get8(s) << 8);
1662static stbi__uint32 stbi__get32le(stbi__context * s) {
1663 stbi__uint32 z = stbi__get16le(s);
1664 z += (stbi__uint32)stbi__get16le(s) << 16;
1669#define STBI__BYTECAST(x) ((stbi_uc)((x)&255))
1671#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && \
1672 defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1686static stbi_uc stbi__compute_y(
int r,
int g,
int b) {
return (stbi_uc)(((r * 77) + (g * 150) + (29 * b)) >> 8); }
1689#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && \
1690 defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1693static unsigned char * stbi__convert_format(
unsigned char * data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y) {
1695 unsigned char * good;
1697 if (req_comp == img_n)
1699 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1701 good = (
unsigned char *)stbi__malloc_mad3(req_comp, x, y, 0);
1704 return stbi__errpuc(
"outofmem",
"Out of memory");
1707 for (j = 0; j < (int)y; ++j) {
1708 unsigned char * src = data + j * x * img_n;
1709 unsigned char * dest = good + j * x * req_comp;
1711#define STBI__COMBO(a, b) ((a)*8 + (b))
1712#define STBI__CASE(a, b) \
1713 case STBI__COMBO(a, b): \
1714 for (i = x - 1; i >= 0; --i, src += a, dest += b)
1717 switch (STBI__COMBO(img_n, req_comp)) {
1723 STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
1726 dest[0] = dest[1] = dest[2] = src[0];
1730 STBI__CASE(2, 1) { dest[0] = src[0]; }
1732 STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
1735 dest[0] = dest[1] = dest[2] = src[0];
1746 STBI__CASE(3, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); }
1749 dest[0] = stbi__compute_y(src[0], src[1], src[2]);
1753 STBI__CASE(4, 1) { dest[0] = stbi__compute_y(src[0], src[1], src[2]); }
1756 dest[0] = stbi__compute_y(src[0], src[1], src[2]);
1770 return stbi__errpuc(
"unsupported",
"Unsupported format conversion");
1780#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1783static stbi__uint16 stbi__compute_y_16(
int r,
int g,
int b) {
return (stbi__uint16)(((r * 77) + (g * 150) + (29 * b)) >> 8); }
1786#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1789static stbi__uint16 * stbi__convert_format16(stbi__uint16 * data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y) {
1791 stbi__uint16 * good;
1793 if (req_comp == img_n)
1795 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1797 good = (stbi__uint16 *)stbi__malloc(req_comp * x * y * 2);
1800 return (stbi__uint16 *)stbi__errpuc(
"outofmem",
"Out of memory");
1803 for (j = 0; j < (int)y; ++j) {
1804 stbi__uint16 * src = data + j * x * img_n;
1805 stbi__uint16 * dest = good + j * x * req_comp;
1807#define STBI__COMBO(a, b) ((a)*8 + (b))
1808#define STBI__CASE(a, b) \
1809 case STBI__COMBO(a, b): \
1810 for (i = x - 1; i >= 0; --i, src += a, dest += b)
1813 switch (STBI__COMBO(img_n, req_comp)) {
1819 STBI__CASE(1, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
1822 dest[0] = dest[1] = dest[2] = src[0];
1826 STBI__CASE(2, 1) { dest[0] = src[0]; }
1828 STBI__CASE(2, 3) { dest[0] = dest[1] = dest[2] = src[0]; }
1831 dest[0] = dest[1] = dest[2] = src[0];
1842 STBI__CASE(3, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); }
1845 dest[0] = stbi__compute_y_16(src[0], src[1], src[2]);
1849 STBI__CASE(4, 1) { dest[0] = stbi__compute_y_16(src[0], src[1], src[2]); }
1852 dest[0] = stbi__compute_y_16(src[0], src[1], src[2]);
1866 return (stbi__uint16 *)stbi__errpuc(
"unsupported",
"Unsupported format conversion");
1876#ifndef STBI_NO_LINEAR
1877static float * stbi__ldr_to_hdr(stbi_uc * data,
int x,
int y,
int comp) {
1882 output = (
float *)stbi__malloc_mad4(x, y, comp,
sizeof(
float), 0);
1883 if (output == NULL) {
1885 return stbi__errpf(
"outofmem",
"Out of memory");
1892 for (i = 0; i < x * y; ++i) {
1893 for (k = 0; k < n; ++k) {
1894 output[i * comp + k] = (float)(pow(data[i * comp + k] / 255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
1898 for (i = 0; i < x * y; ++i) {
1899 output[i * comp + n] = data[i * comp + n] / 255.0f;
1908#define stbi__float2int(x) ((int)(x))
1909static stbi_uc * stbi__hdr_to_ldr(
float * data,
int x,
int y,
int comp) {
1914 output = (stbi_uc *)stbi__malloc_mad3(x, y, comp, 0);
1915 if (output == NULL) {
1917 return stbi__errpuc(
"outofmem",
"Out of memory");
1924 for (i = 0; i < x * y; ++i) {
1925 for (k = 0; k < n; ++k) {
1926 float z = (float)pow(data[i * comp + k] * stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
1931 output[i * comp + k] = (stbi_uc)stbi__float2int(z);
1934 float z = data[i * comp + k] * 255 + 0.5f;
1939 output[i * comp + k] = (stbi_uc)stbi__float2int(z);
1974 stbi_uc fast[1 << FAST_BITS];
1976 stbi__uint16 code[256];
1977 stbi_uc values[256];
1979 unsigned int maxcode[18];
1985 stbi__huffman huff_dc[4];
1986 stbi__huffman huff_ac[4];
1987 stbi__uint16 dequant[4][64];
1988 stbi__int16 fast_ac[4][1 << FAST_BITS];
1991 int img_h_max, img_v_max;
1992 int img_mcu_x, img_mcu_y;
1993 int img_mcu_w, img_mcu_h;
2005 void *raw_data, *raw_coeff;
2008 int coeff_w, coeff_h;
2011 stbi__uint32 code_buffer;
2013 unsigned char marker;
2023 int app14_color_transform;
2026 int scan_n, order[4];
2027 int restart_interval, todo;
2030 void (*idct_block_kernel)(stbi_uc * out,
int out_stride,
short data[64]);
2031 void (*YCbCr_to_RGB_kernel)(stbi_uc * out,
const stbi_uc * y,
const stbi_uc * pcb,
const stbi_uc * pcr,
int count,
2033 stbi_uc * (*resample_row_hv_2_kernel)(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs);
2036static int stbi__build_huffman(stbi__huffman * h,
int * count) {
2040 for (i = 0; i < 16; ++i) {
2041 for (j = 0; j < count[i]; ++j) {
2042 h->size[k++] = (stbi_uc)(i + 1);
2044 return stbi__err(
"bad size list",
"Corrupt JPEG");
2052 for (j = 1; j <= 16; ++j) {
2054 h->delta[j] = k - code;
2055 if (h->size[k] == j) {
2056 while (h->size[k] == j)
2057 h->code[k++] = (stbi__uint16)(code++);
2058 if (code - 1 >= (1u << j))
2059 return stbi__err(
"bad code lengths",
"Corrupt JPEG");
2062 h->maxcode[j] = code << (16 - j);
2065 h->maxcode[j] = 0xffffffff;
2068 memset(h->fast, 255, 1 << FAST_BITS);
2069 for (i = 0; i < k; ++i) {
2071 if (s <= FAST_BITS) {
2072 int c = h->code[i] << (FAST_BITS - s);
2073 int m = 1 << (FAST_BITS - s);
2074 for (j = 0; j < m; ++j) {
2075 h->fast[c + j] = (stbi_uc)i;
2084static void stbi__build_fast_ac(stbi__int16 * fast_ac, stbi__huffman * h) {
2086 for (i = 0; i < (1 << FAST_BITS); ++i) {
2087 stbi_uc fast = h->fast[i];
2090 int rs = h->values[fast];
2091 int run = (rs >> 4) & 15;
2092 int magbits = rs & 15;
2093 int len = h->size[fast];
2095 if (magbits && len + magbits <= FAST_BITS) {
2097 int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
2098 int m = 1 << (magbits - 1);
2100 k += (~0U << magbits) + 1;
2102 if (k >= -128 && k <= 127)
2103 fast_ac[i] = (stbi__int16)((k * 256) + (run * 16) + (len + magbits));
2109static void stbi__grow_buffer_unsafe(stbi__jpeg * j) {
2111 unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
2113 int c = stbi__get8(j->s);
2115 c = stbi__get8(j->s);
2117 j->marker = (
unsigned char)c;
2122 j->code_buffer |= b << (24 - j->code_bits);
2124 }
while (j->code_bits <= 24);
2128static const stbi__uint32 stbi__bmask[17] = {0, 1, 3, 7, 15, 31, 63, 127, 255,
2129 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
2132stbi_inline
static int stbi__jpeg_huff_decode(stbi__jpeg * j, stbi__huffman * h) {
2136 if (j->code_bits < 16)
2137 stbi__grow_buffer_unsafe(j);
2141 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
2145 if (s > j->code_bits)
2147 j->code_buffer <<= s;
2149 return h->values[k];
2158 temp = j->code_buffer >> 16;
2159 for (k = FAST_BITS + 1;; ++k)
2160 if (temp < h->maxcode[k])
2168 if (k > j->code_bits)
2172 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
2173 if (c < 0 || c >= 256)
2175 STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
2179 j->code_buffer <<= k;
2180 return h->values[c];
2184static const int stbi__jbias[16] = {0, -1, -3, -7, -15, -31, -63, -127, -255, -511, -1023, -2047, -4095, -8191, -16383, -32767};
2188stbi_inline
static int stbi__extend_receive(stbi__jpeg * j,
int n) {
2191 if (j->code_bits < n)
2192 stbi__grow_buffer_unsafe(j);
2193 if (j->code_bits < n)
2196 sgn = j->code_buffer >> 31;
2197 k = stbi_lrot(j->code_buffer, n);
2198 j->code_buffer = k & ~stbi__bmask[n];
2199 k &= stbi__bmask[n];
2201 return k + (stbi__jbias[n] & (sgn - 1));
2205stbi_inline
static int stbi__jpeg_get_bits(stbi__jpeg * j,
int n) {
2207 if (j->code_bits < n)
2208 stbi__grow_buffer_unsafe(j);
2209 if (j->code_bits < n)
2211 k = stbi_lrot(j->code_buffer, n);
2212 j->code_buffer = k & ~stbi__bmask[n];
2213 k &= stbi__bmask[n];
2218stbi_inline
static int stbi__jpeg_get_bit(stbi__jpeg * j) {
2220 if (j->code_bits < 1)
2221 stbi__grow_buffer_unsafe(j);
2222 if (j->code_bits < 1)
2225 j->code_buffer <<= 1;
2227 return k & 0x80000000;
2232static const stbi_uc stbi__jpeg_dezigzag[64 + 15] = {
2233 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,
2234 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,
2236 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63};
2239static int stbi__jpeg_decode_block(stbi__jpeg * j,
short data[64], stbi__huffman * hdc, stbi__huffman * hac, stbi__int16 * fac,
2240 int b, stbi__uint16 * dequant) {
2244 if (j->code_bits < 16)
2245 stbi__grow_buffer_unsafe(j);
2246 t = stbi__jpeg_huff_decode(j, hdc);
2247 if (t < 0 || t > 15)
2248 return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2251 memset(data, 0, 64 *
sizeof(data[0]));
2253 diff = t ? stbi__extend_receive(j, t) : 0;
2254 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff))
2255 return stbi__err(
"bad delta",
"Corrupt JPEG");
2256 dc = j->img_comp[b].dc_pred + diff;
2257 j->img_comp[b].dc_pred = dc;
2258 if (!stbi__mul2shorts_valid(dc, dequant[0]))
2259 return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2260 data[0] = (short)(dc * dequant[0]);
2267 if (j->code_bits < 16)
2268 stbi__grow_buffer_unsafe(j);
2269 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
2274 if (s > j->code_bits)
2275 return stbi__err(
"bad huffman code",
"Combined length longer than code bits available");
2276 j->code_buffer <<= s;
2279 zig = stbi__jpeg_dezigzag[k++];
2280 data[zig] = (short)((r >> 8) * dequant[zig]);
2282 int rs = stbi__jpeg_huff_decode(j, hac);
2284 return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2294 zig = stbi__jpeg_dezigzag[k++];
2295 data[zig] = (short)(stbi__extend_receive(j, s) * dequant[zig]);
2302static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg * j,
short data[64], stbi__huffman * hdc,
int b) {
2305 if (j->spec_end != 0)
2306 return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2308 if (j->code_bits < 16)
2309 stbi__grow_buffer_unsafe(j);
2311 if (j->succ_high == 0) {
2313 memset(data, 0, 64 *
sizeof(data[0]));
2314 t = stbi__jpeg_huff_decode(j, hdc);
2315 if (t < 0 || t > 15)
2316 return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2317 diff = t ? stbi__extend_receive(j, t) : 0;
2319 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff))
2320 return stbi__err(
"bad delta",
"Corrupt JPEG");
2321 dc = j->img_comp[b].dc_pred + diff;
2322 j->img_comp[b].dc_pred = dc;
2323 if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low))
2324 return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2325 data[0] = (short)(dc * (1 << j->succ_low));
2328 if (stbi__jpeg_get_bit(j))
2329 data[0] += (
short)(1 << j->succ_low);
2336static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg * j,
short data[64], stbi__huffman * hac, stbi__int16 * fac) {
2338 if (j->spec_start == 0)
2339 return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2341 if (j->succ_high == 0) {
2342 int shift = j->succ_low;
2353 if (j->code_bits < 16)
2354 stbi__grow_buffer_unsafe(j);
2355 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1);
2360 if (s > j->code_bits)
2361 return stbi__err(
"bad huffman code",
"Combined length longer than code bits available");
2362 j->code_buffer <<= s;
2364 zig = stbi__jpeg_dezigzag[k++];
2365 data[zig] = (short)((r >> 8) * (1 << shift));
2367 int rs = stbi__jpeg_huff_decode(j, hac);
2369 return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2374 j->eob_run = (1 << r);
2376 j->eob_run += stbi__jpeg_get_bits(j, r);
2383 zig = stbi__jpeg_dezigzag[k++];
2384 data[zig] = (short)(stbi__extend_receive(j, s) * (1 << shift));
2387 }
while (k <= j->spec_end);
2391 short bit = (short)(1 << j->succ_low);
2395 for (k = j->spec_start; k <= j->spec_end; ++k) {
2396 short * p = &data[stbi__jpeg_dezigzag[k]];
2398 if (stbi__jpeg_get_bit(j))
2399 if ((*p & bit) == 0) {
2410 int rs = stbi__jpeg_huff_decode(
2413 return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2418 j->eob_run = (1 << r) - 1;
2420 j->eob_run += stbi__jpeg_get_bits(j, r);
2429 return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2431 if (stbi__jpeg_get_bit(j))
2438 while (k <= j->spec_end) {
2439 short * p = &data[stbi__jpeg_dezigzag[k++]];
2441 if (stbi__jpeg_get_bit(j))
2442 if ((*p & bit) == 0) {
2456 }
while (k <= j->spec_end);
2463stbi_inline
static stbi_uc stbi__clamp(
int x) {
2465 if ((
unsigned int)x > 255) {
2474#define stbi__f2f(x) ((int)(((x)*4096 + 0.5)))
2475#define stbi__fsh(x) ((x)*4096)
2478#define STBI__IDCT_1D(s0, s1, s2, s3, s4, s5, s6, s7) \
2479 int t0, t1, t2, t3, p1, p2, p3, p4, p5, x0, x1, x2, x3; \
2482 p1 = (p2 + p3) * stbi__f2f(0.5411961f); \
2483 t2 = p1 + p3 * stbi__f2f(-1.847759065f); \
2484 t3 = p1 + p2 * stbi__f2f(0.765366865f); \
2487 t0 = stbi__fsh(p2 + p3); \
2488 t1 = stbi__fsh(p2 - p3); \
2501 p5 = (p3 + p4) * stbi__f2f(1.175875602f); \
2502 t0 = t0 * stbi__f2f(0.298631336f); \
2503 t1 = t1 * stbi__f2f(2.053119869f); \
2504 t2 = t2 * stbi__f2f(3.072711026f); \
2505 t3 = t3 * stbi__f2f(1.501321110f); \
2506 p1 = p5 + p1 * stbi__f2f(-0.899976223f); \
2507 p2 = p5 + p2 * stbi__f2f(-2.562915447f); \
2508 p3 = p3 * stbi__f2f(-1.961570560f); \
2509 p4 = p4 * stbi__f2f(-0.390180644f); \
2515static void stbi__idct_block(stbi_uc * out,
int out_stride,
short data[64]) {
2516 int i, val[64], *v = val;
2521 for (i = 0; i < 8; ++i, ++d, ++v) {
2523 if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 && d[40] == 0 && d[48] == 0 && d[56] == 0) {
2528 int dcterm = d[0] * 4;
2529 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
2531 STBI__IDCT_1D(d[0], d[8], d[16], d[24], d[32], d[40], d[48], d[56])
2538 v[0] = (x0 + t3) >> 10;
2539 v[56] = (x0 - t3) >> 10;
2540 v[8] = (x1 + t2) >> 10;
2541 v[48] = (x1 - t2) >> 10;
2542 v[16] = (x2 + t1) >> 10;
2543 v[40] = (x2 - t1) >> 10;
2544 v[24] = (x3 + t0) >> 10;
2545 v[32] = (x3 - t0) >> 10;
2549 for (i = 0, v = val, o = out; i < 8; ++i, v += 8, o += out_stride) {
2551 STBI__IDCT_1D(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
2558 x0 += 65536 + (128 << 17);
2559 x1 += 65536 + (128 << 17);
2560 x2 += 65536 + (128 << 17);
2561 x3 += 65536 + (128 << 17);
2564 o[0] = stbi__clamp((x0 + t3) >> 17);
2565 o[7] = stbi__clamp((x0 - t3) >> 17);
2566 o[1] = stbi__clamp((x1 + t2) >> 17);
2567 o[6] = stbi__clamp((x1 - t2) >> 17);
2568 o[2] = stbi__clamp((x2 + t1) >> 17);
2569 o[5] = stbi__clamp((x2 - t1) >> 17);
2570 o[3] = stbi__clamp((x3 + t0) >> 17);
2571 o[4] = stbi__clamp((x3 - t0) >> 17);
2579static void stbi__idct_simd(stbi_uc * out,
int out_stride,
short data[64]) {
2581 __m128i row0, row1, row2, row3, row4, row5, row6, row7;
2585#define dct_const(x, y) _mm_setr_epi16((x), (y), (x), (y), (x), (y), (x), (y))
2589#define dct_rot(out0, out1, x, y, c0, c1) \
2590 __m128i c0##lo = _mm_unpacklo_epi16((x), (y)); \
2591 __m128i c0##hi = _mm_unpackhi_epi16((x), (y)); \
2592 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
2593 __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
2594 __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
2595 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
2598#define dct_widen(out, in) \
2599 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
2600 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
2603#define dct_wadd(out, a, b) \
2604 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
2605 __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
2608#define dct_wsub(out, a, b) \
2609 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
2610 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
2613#define dct_bfly32o(out0, out1, a, b, bias, s) \
2615 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
2616 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
2617 dct_wadd(sum, abiased, b); \
2618 dct_wsub(dif, abiased, b); \
2619 out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
2620 out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
2624#define dct_interleave8(a, b) \
2626 a = _mm_unpacklo_epi8(a, b); \
2627 b = _mm_unpackhi_epi8(tmp, b)
2630#define dct_interleave16(a, b) \
2632 a = _mm_unpacklo_epi16(a, b); \
2633 b = _mm_unpackhi_epi16(tmp, b)
2635#define dct_pass(bias, shift) \
2638 dct_rot(t2e, t3e, row2, row6, rot0_0, rot0_1); \
2639 __m128i sum04 = _mm_add_epi16(row0, row4); \
2640 __m128i dif04 = _mm_sub_epi16(row0, row4); \
2641 dct_widen(t0e, sum04); \
2642 dct_widen(t1e, dif04); \
2643 dct_wadd(x0, t0e, t3e); \
2644 dct_wsub(x3, t0e, t3e); \
2645 dct_wadd(x1, t1e, t2e); \
2646 dct_wsub(x2, t1e, t2e); \
2648 dct_rot(y0o, y2o, row7, row3, rot2_0, rot2_1); \
2649 dct_rot(y1o, y3o, row5, row1, rot3_0, rot3_1); \
2650 __m128i sum17 = _mm_add_epi16(row1, row7); \
2651 __m128i sum35 = _mm_add_epi16(row3, row5); \
2652 dct_rot(y4o, y5o, sum17, sum35, rot1_0, rot1_1); \
2653 dct_wadd(x4, y0o, y4o); \
2654 dct_wadd(x5, y1o, y5o); \
2655 dct_wadd(x6, y2o, y5o); \
2656 dct_wadd(x7, y3o, y4o); \
2657 dct_bfly32o(row0, row7, x0, x7, bias, shift); \
2658 dct_bfly32o(row1, row6, x1, x6, bias, shift); \
2659 dct_bfly32o(row2, row5, x2, x5, bias, shift); \
2660 dct_bfly32o(row3, row4, x3, x4, bias, shift); \
2663 __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
2664 __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f(0.765366865f), stbi__f2f(0.5411961f));
2665 __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
2666 __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
2667 __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f(0.298631336f), stbi__f2f(-1.961570560f));
2668 __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f(3.072711026f));
2669 __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f(2.053119869f), stbi__f2f(-0.390180644f));
2670 __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f(1.501321110f));
2673 __m128i bias_0 = _mm_set1_epi32(512);
2674 __m128i bias_1 = _mm_set1_epi32(65536 + (128 << 17));
2677 row0 = _mm_load_si128((
const __m128i *)(data + 0 * 8));
2678 row1 = _mm_load_si128((
const __m128i *)(data + 1 * 8));
2679 row2 = _mm_load_si128((
const __m128i *)(data + 2 * 8));
2680 row3 = _mm_load_si128((
const __m128i *)(data + 3 * 8));
2681 row4 = _mm_load_si128((
const __m128i *)(data + 4 * 8));
2682 row5 = _mm_load_si128((
const __m128i *)(data + 5 * 8));
2683 row6 = _mm_load_si128((
const __m128i *)(data + 6 * 8));
2684 row7 = _mm_load_si128((
const __m128i *)(data + 7 * 8));
2687 dct_pass(bias_0, 10);
2691 dct_interleave16(row0, row4);
2692 dct_interleave16(row1, row5);
2693 dct_interleave16(row2, row6);
2694 dct_interleave16(row3, row7);
2697 dct_interleave16(row0, row2);
2698 dct_interleave16(row1, row3);
2699 dct_interleave16(row4, row6);
2700 dct_interleave16(row5, row7);
2703 dct_interleave16(row0, row1);
2704 dct_interleave16(row2, row3);
2705 dct_interleave16(row4, row5);
2706 dct_interleave16(row6, row7);
2710 dct_pass(bias_1, 17);
2714 __m128i p0 = _mm_packus_epi16(row0, row1);
2715 __m128i p1 = _mm_packus_epi16(row2, row3);
2716 __m128i p2 = _mm_packus_epi16(row4, row5);
2717 __m128i p3 = _mm_packus_epi16(row6, row7);
2720 dct_interleave8(p0, p2);
2721 dct_interleave8(p1, p3);
2724 dct_interleave8(p0, p1);
2725 dct_interleave8(p2, p3);
2728 dct_interleave8(p0, p2);
2729 dct_interleave8(p1, p3);
2732 _mm_storel_epi64((__m128i *)out, p0);
2734 _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p0, 0x4e));
2736 _mm_storel_epi64((__m128i *)out, p2);
2738 _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p2, 0x4e));
2740 _mm_storel_epi64((__m128i *)out, p1);
2742 _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p1, 0x4e));
2744 _mm_storel_epi64((__m128i *)out, p3);
2746 _mm_storel_epi64((__m128i *)out, _mm_shuffle_epi32(p3, 0x4e));
2755#undef dct_interleave8
2756#undef dct_interleave16
2766static void stbi__idct_simd(stbi_uc * out,
int out_stride,
short data[64]) {
2767 int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
2769 int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
2770 int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
2771 int16x4_t rot0_2 = vdup_n_s16(stbi__f2f(0.765366865f));
2772 int16x4_t rot1_0 = vdup_n_s16(stbi__f2f(1.175875602f));
2773 int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
2774 int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
2775 int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
2776 int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
2777 int16x4_t rot3_0 = vdup_n_s16(stbi__f2f(0.298631336f));
2778 int16x4_t rot3_1 = vdup_n_s16(stbi__f2f(2.053119869f));
2779 int16x4_t rot3_2 = vdup_n_s16(stbi__f2f(3.072711026f));
2780 int16x4_t rot3_3 = vdup_n_s16(stbi__f2f(1.501321110f));
2782#define dct_long_mul(out, inq, coeff) \
2783 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
2784 int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
2786#define dct_long_mac(out, acc, inq, coeff) \
2787 int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
2788 int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
2790#define dct_widen(out, inq) \
2791 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
2792 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
2795#define dct_wadd(out, a, b) \
2796 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
2797 int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
2800#define dct_wsub(out, a, b) \
2801 int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
2802 int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
2805#define dct_bfly32o(out0, out1, a, b, shiftop, s) \
2807 dct_wadd(sum, a, b); \
2808 dct_wsub(dif, a, b); \
2809 out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
2810 out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
2813#define dct_pass(shiftop, shift) \
2816 int16x8_t sum26 = vaddq_s16(row2, row6); \
2817 dct_long_mul(p1e, sum26, rot0_0); \
2818 dct_long_mac(t2e, p1e, row6, rot0_1); \
2819 dct_long_mac(t3e, p1e, row2, rot0_2); \
2820 int16x8_t sum04 = vaddq_s16(row0, row4); \
2821 int16x8_t dif04 = vsubq_s16(row0, row4); \
2822 dct_widen(t0e, sum04); \
2823 dct_widen(t1e, dif04); \
2824 dct_wadd(x0, t0e, t3e); \
2825 dct_wsub(x3, t0e, t3e); \
2826 dct_wadd(x1, t1e, t2e); \
2827 dct_wsub(x2, t1e, t2e); \
2829 int16x8_t sum15 = vaddq_s16(row1, row5); \
2830 int16x8_t sum17 = vaddq_s16(row1, row7); \
2831 int16x8_t sum35 = vaddq_s16(row3, row5); \
2832 int16x8_t sum37 = vaddq_s16(row3, row7); \
2833 int16x8_t sumodd = vaddq_s16(sum17, sum35); \
2834 dct_long_mul(p5o, sumodd, rot1_0); \
2835 dct_long_mac(p1o, p5o, sum17, rot1_1); \
2836 dct_long_mac(p2o, p5o, sum35, rot1_2); \
2837 dct_long_mul(p3o, sum37, rot2_0); \
2838 dct_long_mul(p4o, sum15, rot2_1); \
2839 dct_wadd(sump13o, p1o, p3o); \
2840 dct_wadd(sump24o, p2o, p4o); \
2841 dct_wadd(sump23o, p2o, p3o); \
2842 dct_wadd(sump14o, p1o, p4o); \
2843 dct_long_mac(x4, sump13o, row7, rot3_0); \
2844 dct_long_mac(x5, sump24o, row5, rot3_1); \
2845 dct_long_mac(x6, sump23o, row3, rot3_2); \
2846 dct_long_mac(x7, sump14o, row1, rot3_3); \
2847 dct_bfly32o(row0, row7, x0, x7, shiftop, shift); \
2848 dct_bfly32o(row1, row6, x1, x6, shiftop, shift); \
2849 dct_bfly32o(row2, row5, x2, x5, shiftop, shift); \
2850 dct_bfly32o(row3, row4, x3, x4, shiftop, shift); \
2854 row0 = vld1q_s16(data + 0 * 8);
2855 row1 = vld1q_s16(data + 1 * 8);
2856 row2 = vld1q_s16(data + 2 * 8);
2857 row3 = vld1q_s16(data + 3 * 8);
2858 row4 = vld1q_s16(data + 4 * 8);
2859 row5 = vld1q_s16(data + 5 * 8);
2860 row6 = vld1q_s16(data + 6 * 8);
2861 row7 = vld1q_s16(data + 7 * 8);
2864 row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
2867 dct_pass(vrshrn_n_s32, 10);
2873#define dct_trn16(x, y) \
2875 int16x8x2_t t = vtrnq_s16(x, y); \
2879#define dct_trn32(x, y) \
2881 int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); \
2882 x = vreinterpretq_s16_s32(t.val[0]); \
2883 y = vreinterpretq_s16_s32(t.val[1]); \
2885#define dct_trn64(x, y) \
2889 x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); \
2890 y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); \
2894 dct_trn16(row0, row1);
2895 dct_trn16(row2, row3);
2896 dct_trn16(row4, row5);
2897 dct_trn16(row6, row7);
2900 dct_trn32(row0, row2);
2901 dct_trn32(row1, row3);
2902 dct_trn32(row4, row6);
2903 dct_trn32(row5, row7);
2906 dct_trn64(row0, row4);
2907 dct_trn64(row1, row5);
2908 dct_trn64(row2, row6);
2909 dct_trn64(row3, row7);
2920 dct_pass(vshrn_n_s32, 16);
2924 uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
2925 uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
2926 uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
2927 uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
2928 uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
2929 uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
2930 uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
2931 uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
2934#define dct_trn8_8(x, y) \
2936 uint8x8x2_t t = vtrn_u8(x, y); \
2940#define dct_trn8_16(x, y) \
2942 uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); \
2943 x = vreinterpret_u8_u16(t.val[0]); \
2944 y = vreinterpret_u8_u16(t.val[1]); \
2946#define dct_trn8_32(x, y) \
2948 uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); \
2949 x = vreinterpret_u8_u32(t.val[0]); \
2950 y = vreinterpret_u8_u32(t.val[1]); \
2963 dct_trn8_16(p0, p2);
2964 dct_trn8_16(p1, p3);
2965 dct_trn8_16(p4, p6);
2966 dct_trn8_16(p5, p7);
2969 dct_trn8_32(p0, p4);
2970 dct_trn8_32(p1, p5);
2971 dct_trn8_32(p2, p6);
2972 dct_trn8_32(p3, p7);
3007#define STBI__MARKER_none 0xff
3011static stbi_uc stbi__get_marker(stbi__jpeg * j) {
3013 if (j->marker != STBI__MARKER_none) {
3015 j->marker = STBI__MARKER_none;
3018 x = stbi__get8(j->s);
3020 return STBI__MARKER_none;
3022 x = stbi__get8(j->s);
3028#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
3032static void stbi__jpeg_reset(stbi__jpeg * j) {
3036 j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
3037 j->marker = STBI__MARKER_none;
3038 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
3044static int stbi__parse_entropy_coded_data(stbi__jpeg * z) {
3045 stbi__jpeg_reset(z);
3046 if (!z->progressive) {
3047 if (z->scan_n == 1) {
3049 STBI_SIMD_ALIGN(
short, data[64]);
3050 int n = z->order[0];
3055 int w = (z->img_comp[n].x + 7) >> 3;
3056 int h = (z->img_comp[n].y + 7) >> 3;
3057 for (j = 0; j < h; ++j) {
3058 for (i = 0; i < w; ++i) {
3059 int ha = z->img_comp[n].ha;
3060 if (!stbi__jpeg_decode_block(z, data, z->huff_dc + z->img_comp[n].hd, z->huff_ac + ha, z->fast_ac[ha], n,
3061 z->dequant[z->img_comp[n].tq]))
3063 z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, z->img_comp[n].w2, data);
3065 if (--z->todo <= 0) {
3066 if (z->code_bits < 24)
3067 stbi__grow_buffer_unsafe(z);
3070 if (!STBI__RESTART(z->marker))
3072 stbi__jpeg_reset(z);
3079 STBI_SIMD_ALIGN(
short, data[64]);
3080 for (j = 0; j < z->img_mcu_y; ++j) {
3081 for (i = 0; i < z->img_mcu_x; ++i) {
3083 for (k = 0; k < z->scan_n; ++k) {
3084 int n = z->order[k];
3087 for (y = 0; y < z->img_comp[n].v; ++y) {
3088 for (x = 0; x < z->img_comp[n].h; ++x) {
3089 int x2 = (i * z->img_comp[n].h + x) * 8;
3090 int y2 = (j * z->img_comp[n].v + y) * 8;
3091 int ha = z->img_comp[n].ha;
3092 if (!stbi__jpeg_decode_block(z, data, z->huff_dc + z->img_comp[n].hd, z->huff_ac + ha,
3093 z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq]))
3095 z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * y2 + x2, z->img_comp[n].w2,
3102 if (--z->todo <= 0) {
3103 if (z->code_bits < 24)
3104 stbi__grow_buffer_unsafe(z);
3105 if (!STBI__RESTART(z->marker))
3107 stbi__jpeg_reset(z);
3114 if (z->scan_n == 1) {
3116 int n = z->order[0];
3121 int w = (z->img_comp[n].x + 7) >> 3;
3122 int h = (z->img_comp[n].y + 7) >> 3;
3123 for (j = 0; j < h; ++j) {
3124 for (i = 0; i < w; ++i) {
3125 short * data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3126 if (z->spec_start == 0) {
3127 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3130 int ha = z->img_comp[n].ha;
3131 if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
3135 if (--z->todo <= 0) {
3136 if (z->code_bits < 24)
3137 stbi__grow_buffer_unsafe(z);
3138 if (!STBI__RESTART(z->marker))
3140 stbi__jpeg_reset(z);
3147 for (j = 0; j < z->img_mcu_y; ++j) {
3148 for (i = 0; i < z->img_mcu_x; ++i) {
3150 for (k = 0; k < z->scan_n; ++k) {
3151 int n = z->order[k];
3154 for (y = 0; y < z->img_comp[n].v; ++y) {
3155 for (x = 0; x < z->img_comp[n].h; ++x) {
3156 int x2 = (i * z->img_comp[n].h + x);
3157 int y2 = (j * z->img_comp[n].v + y);
3158 short * data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
3159 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3166 if (--z->todo <= 0) {
3167 if (z->code_bits < 24)
3168 stbi__grow_buffer_unsafe(z);
3169 if (!STBI__RESTART(z->marker))
3171 stbi__jpeg_reset(z);
3180static void stbi__jpeg_dequantize(
short * data, stbi__uint16 * dequant) {
3182 for (i = 0; i < 64; ++i)
3183 data[i] *= dequant[i];
3186static void stbi__jpeg_finish(stbi__jpeg * z) {
3187 if (z->progressive) {
3190 for (n = 0; n < z->s->img_n; ++n) {
3191 int w = (z->img_comp[n].x + 7) >> 3;
3192 int h = (z->img_comp[n].y + 7) >> 3;
3193 for (j = 0; j < h; ++j) {
3194 for (i = 0; i < w; ++i) {
3195 short * data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3196 stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
3197 z->idct_block_kernel(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, z->img_comp[n].w2, data);
3204static int stbi__process_marker(stbi__jpeg * z,
int m) {
3207 case STBI__MARKER_none:
3208 return stbi__err(
"expected marker",
"Corrupt JPEG");
3211 if (stbi__get16be(z->s) != 4)
3212 return stbi__err(
"bad DRI len",
"Corrupt JPEG");
3213 z->restart_interval = stbi__get16be(z->s);
3217 L = stbi__get16be(z->s) - 2;
3219 int q = stbi__get8(z->s);
3220 int p = q >> 4, sixteen = (p != 0);
3222 if (p != 0 && p != 1)
3223 return stbi__err(
"bad DQT type",
"Corrupt JPEG");
3225 return stbi__err(
"bad DQT table",
"Corrupt JPEG");
3227 for (i = 0; i < 64; ++i)
3228 z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
3229 L -= (sixteen ? 129 : 65);
3234 L = stbi__get16be(z->s) - 2;
3237 int sizes[16], i, n = 0;
3238 int q = stbi__get8(z->s);
3241 if (tc > 1 || th > 3)
3242 return stbi__err(
"bad DHT header",
"Corrupt JPEG");
3243 for (i = 0; i < 16; ++i) {
3244 sizes[i] = stbi__get8(z->s);
3248 return stbi__err(
"bad DHT header",
"Corrupt JPEG");
3251 if (!stbi__build_huffman(z->huff_dc + th, sizes))
3253 v = z->huff_dc[th].values;
3255 if (!stbi__build_huffman(z->huff_ac + th, sizes))
3257 v = z->huff_ac[th].values;
3259 for (i = 0; i < n; ++i)
3260 v[i] = stbi__get8(z->s);
3262 stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
3269 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
3270 L = stbi__get16be(z->s);
3273 return stbi__err(
"bad COM len",
"Corrupt JPEG");
3275 return stbi__err(
"bad APP len",
"Corrupt JPEG");
3279 if (m == 0xE0 && L >= 5) {
3280 static const unsigned char tag[5] = {
'J',
'F',
'I',
'F',
'\0'};
3283 for (i = 0; i < 5; ++i)
3284 if (stbi__get8(z->s) != tag[i])
3289 }
else if (m == 0xEE && L >= 12) {
3290 static const unsigned char tag[6] = {
'A',
'd',
'o',
'b',
'e',
'\0'};
3293 for (i = 0; i < 6; ++i)
3294 if (stbi__get8(z->s) != tag[i])
3299 stbi__get16be(z->s);
3300 stbi__get16be(z->s);
3301 z->app14_color_transform = stbi__get8(z->s);
3306 stbi__skip(z->s, L);
3310 return stbi__err(
"unknown marker",
"Corrupt JPEG");
3314static int stbi__process_scan_header(stbi__jpeg * z) {
3316 int Ls = stbi__get16be(z->s);
3317 z->scan_n = stbi__get8(z->s);
3318 if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (
int)z->s->img_n)
3319 return stbi__err(
"bad SOS component count",
"Corrupt JPEG");
3320 if (Ls != 6 + 2 * z->scan_n)
3321 return stbi__err(
"bad SOS len",
"Corrupt JPEG");
3322 for (i = 0; i < z->scan_n; ++i) {
3323 int id = stbi__get8(z->s), which;
3324 int q = stbi__get8(z->s);
3325 for (which = 0; which < z->s->img_n; ++which)
3326 if (z->img_comp[which].id ==
id)
3328 if (which == z->s->img_n)
3330 z->img_comp[which].hd = q >> 4;
3331 if (z->img_comp[which].hd > 3)
3332 return stbi__err(
"bad DC huff",
"Corrupt JPEG");
3333 z->img_comp[which].ha = q & 15;
3334 if (z->img_comp[which].ha > 3)
3335 return stbi__err(
"bad AC huff",
"Corrupt JPEG");
3336 z->order[i] = which;
3341 z->spec_start = stbi__get8(z->s);
3342 z->spec_end = stbi__get8(z->s);
3343 aa = stbi__get8(z->s);
3344 z->succ_high = (aa >> 4);
3345 z->succ_low = (aa & 15);
3346 if (z->progressive) {
3347 if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
3348 return stbi__err(
"bad SOS",
"Corrupt JPEG");
3350 if (z->spec_start != 0)
3351 return stbi__err(
"bad SOS",
"Corrupt JPEG");
3352 if (z->succ_high != 0 || z->succ_low != 0)
3353 return stbi__err(
"bad SOS",
"Corrupt JPEG");
3361static int stbi__free_jpeg_components(stbi__jpeg * z,
int ncomp,
int why) {
3363 for (i = 0; i < ncomp; ++i) {
3364 if (z->img_comp[i].raw_data) {
3365 STBI_FREE(z->img_comp[i].raw_data);
3366 z->img_comp[i].raw_data = NULL;
3367 z->img_comp[i].data = NULL;
3369 if (z->img_comp[i].raw_coeff) {
3370 STBI_FREE(z->img_comp[i].raw_coeff);
3371 z->img_comp[i].raw_coeff = 0;
3372 z->img_comp[i].coeff = 0;
3374 if (z->img_comp[i].linebuf) {
3375 STBI_FREE(z->img_comp[i].linebuf);
3376 z->img_comp[i].linebuf = NULL;
3382static int stbi__process_frame_header(stbi__jpeg * z,
int scan) {
3383 stbi__context * s = z->s;
3384 int Lf, p, i, q, h_max = 1, v_max = 1, c;
3385 Lf = stbi__get16be(s);
3387 return stbi__err(
"bad SOF len",
"Corrupt JPEG");
3390 return stbi__err(
"only 8-bit",
"JPEG format not supported: 8-bit only");
3391 s->img_y = stbi__get16be(s);
3393 return stbi__err(
"no header height",
3394 "JPEG format not supported: delayed height");
3395 s->img_x = stbi__get16be(s);
3397 return stbi__err(
"0 width",
"Corrupt JPEG");
3398 if (s->img_y > STBI_MAX_DIMENSIONS)
3399 return stbi__err(
"too large",
"Very large image (corrupt?)");
3400 if (s->img_x > STBI_MAX_DIMENSIONS)
3401 return stbi__err(
"too large",
"Very large image (corrupt?)");
3403 if (c != 3 && c != 1 && c != 4)
3404 return stbi__err(
"bad component count",
"Corrupt JPEG");
3406 for (i = 0; i < c; ++i) {
3407 z->img_comp[i].data = NULL;
3408 z->img_comp[i].linebuf = NULL;
3411 if (Lf != 8 + 3 * s->img_n)
3412 return stbi__err(
"bad SOF len",
"Corrupt JPEG");
3415 for (i = 0; i < s->img_n; ++i) {
3416 static const unsigned char rgb[3] = {
'R',
'G',
'B'};
3417 z->img_comp[i].id = stbi__get8(s);
3418 if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
3421 z->img_comp[i].h = (q >> 4);
3422 if (!z->img_comp[i].h || z->img_comp[i].h > 4)
3423 return stbi__err(
"bad H",
"Corrupt JPEG");
3424 z->img_comp[i].v = q & 15;
3425 if (!z->img_comp[i].v || z->img_comp[i].v > 4)
3426 return stbi__err(
"bad V",
"Corrupt JPEG");
3427 z->img_comp[i].tq = stbi__get8(s);
3428 if (z->img_comp[i].tq > 3)
3429 return stbi__err(
"bad TQ",
"Corrupt JPEG");
3432 if (scan != STBI__SCAN_load)
3435 if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0))
3436 return stbi__err(
"too large",
"Image too large to decode");
3438 for (i = 0; i < s->img_n; ++i) {
3439 if (z->img_comp[i].h > h_max)
3440 h_max = z->img_comp[i].h;
3441 if (z->img_comp[i].v > v_max)
3442 v_max = z->img_comp[i].v;
3447 for (i = 0; i < s->img_n; ++i) {
3448 if (h_max % z->img_comp[i].h != 0)
3449 return stbi__err(
"bad H",
"Corrupt JPEG");
3450 if (v_max % z->img_comp[i].v != 0)
3451 return stbi__err(
"bad V",
"Corrupt JPEG");
3455 z->img_h_max = h_max;
3456 z->img_v_max = v_max;
3457 z->img_mcu_w = h_max * 8;
3458 z->img_mcu_h = v_max * 8;
3460 z->img_mcu_x = (s->img_x + z->img_mcu_w - 1) / z->img_mcu_w;
3461 z->img_mcu_y = (s->img_y + z->img_mcu_h - 1) / z->img_mcu_h;
3463 for (i = 0; i < s->img_n; ++i) {
3465 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max - 1) / h_max;
3466 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max - 1) / v_max;
3474 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
3475 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
3476 z->img_comp[i].coeff = 0;
3477 z->img_comp[i].raw_coeff = 0;
3478 z->img_comp[i].linebuf = NULL;
3479 z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
3480 if (z->img_comp[i].raw_data == NULL)
3481 return stbi__free_jpeg_components(z, i + 1, stbi__err(
"outofmem",
"Out of memory"));
3483 z->img_comp[i].data = (stbi_uc *)(((
size_t)z->img_comp[i].raw_data + 15) & ~15);
3484 if (z->progressive) {
3486 z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
3487 z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
3488 z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2,
sizeof(
short), 15);
3489 if (z->img_comp[i].raw_coeff == NULL)
3490 return stbi__free_jpeg_components(z, i + 1, stbi__err(
"outofmem",
"Out of memory"));
3491 z->img_comp[i].coeff = (
short *)(((
size_t)z->img_comp[i].raw_coeff + 15) & ~15);
3499#define stbi__DNL(x) ((x) == 0xdc)
3500#define stbi__SOI(x) ((x) == 0xd8)
3501#define stbi__EOI(x) ((x) == 0xd9)
3502#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
3503#define stbi__SOS(x) ((x) == 0xda)
3505#define stbi__SOF_progressive(x) ((x) == 0xc2)
3507static int stbi__decode_jpeg_header(stbi__jpeg * z,
int scan) {
3510 z->app14_color_transform = -1;
3511 z->marker = STBI__MARKER_none;
3512 m = stbi__get_marker(z);
3514 return stbi__err(
"no SOI",
"Corrupt JPEG");
3515 if (scan == STBI__SCAN_type)
3517 m = stbi__get_marker(z);
3518 while (!stbi__SOF(m)) {
3519 if (!stbi__process_marker(z, m))
3521 m = stbi__get_marker(z);
3522 while (m == STBI__MARKER_none) {
3524 if (stbi__at_eof(z->s))
3525 return stbi__err(
"no SOF",
"Corrupt JPEG");
3526 m = stbi__get_marker(z);
3529 z->progressive = stbi__SOF_progressive(m);
3530 if (!stbi__process_frame_header(z, scan))
3535static int stbi__skip_jpeg_junk_at_end(stbi__jpeg * j) {
3538 while (!stbi__at_eof(j->s)) {
3539 int x = stbi__get8(j->s);
3541 if (stbi__at_eof(j->s))
3542 return STBI__MARKER_none;
3543 x = stbi__get8(j->s);
3544 if (x != 0x00 && x != 0xff) {
3554 return STBI__MARKER_none;
3558static int stbi__decode_jpeg_image(stbi__jpeg * j) {
3560 for (m = 0; m < 4; m++) {
3561 j->img_comp[m].raw_data = NULL;
3562 j->img_comp[m].raw_coeff = NULL;
3564 j->restart_interval = 0;
3565 if (!stbi__decode_jpeg_header(j, STBI__SCAN_load))
3567 m = stbi__get_marker(j);
3568 while (!stbi__EOI(m)) {
3570 if (!stbi__process_scan_header(j))
3572 if (!stbi__parse_entropy_coded_data(j))
3574 if (j->marker == STBI__MARKER_none) {
3575 j->marker = stbi__skip_jpeg_junk_at_end(j);
3578 m = stbi__get_marker(j);
3579 if (STBI__RESTART(m))
3580 m = stbi__get_marker(j);
3581 }
else if (stbi__DNL(m)) {
3582 int Ld = stbi__get16be(j->s);
3583 stbi__uint32 NL = stbi__get16be(j->s);
3585 return stbi__err(
"bad DNL len",
"Corrupt JPEG");
3586 if (NL != j->s->img_y)
3587 return stbi__err(
"bad DNL height",
"Corrupt JPEG");
3588 m = stbi__get_marker(j);
3590 if (!stbi__process_marker(j, m))
3592 m = stbi__get_marker(j);
3596 stbi__jpeg_finish(j);
3602typedef stbi_uc * (*resample_row_func)(stbi_uc * out, stbi_uc * in0, stbi_uc * in1,
int w,
int hs);
3604#define stbi__div4(x) ((stbi_uc)((x) >> 2))
3606static stbi_uc * resample_row_1(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3608 STBI_NOTUSED(in_far);
3614static stbi_uc * stbi__resample_row_v_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3618 for (i = 0; i < w; ++i)
3619 out[i] = stbi__div4(3 * in_near[i] + in_far[i] + 2);
3623static stbi_uc * stbi__resample_row_h_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3626 stbi_uc * input = in_near;
3630 out[0] = out[1] = input[0];
3635 out[1] = stbi__div4(input[0] * 3 + input[1] + 2);
3636 for (i = 1; i < w - 1; ++i) {
3637 int n = 3 * input[i] + 2;
3638 out[i * 2 + 0] = stbi__div4(n + input[i - 1]);
3639 out[i * 2 + 1] = stbi__div4(n + input[i + 1]);
3641 out[i * 2 + 0] = stbi__div4(input[w - 2] * 3 + input[w - 1] + 2);
3642 out[i * 2 + 1] = input[w - 1];
3644 STBI_NOTUSED(in_far);
3650#define stbi__div16(x) ((stbi_uc)((x) >> 4))
3652static stbi_uc * stbi__resample_row_hv_2(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3656 out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2);
3660 t1 = 3 * in_near[0] + in_far[0];
3661 out[0] = stbi__div4(t1 + 2);
3662 for (i = 1; i < w; ++i) {
3664 t1 = 3 * in_near[i] + in_far[i];
3665 out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8);
3666 out[i * 2] = stbi__div16(3 * t1 + t0 + 8);
3668 out[w * 2 - 1] = stbi__div4(t1 + 2);
3675#if defined(STBI_SSE2) || defined(STBI_NEON)
3676static stbi_uc * stbi__resample_row_hv_2_simd(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3681 out[0] = out[1] = stbi__div4(3 * in_near[0] + in_far[0] + 2);
3685 t1 = 3 * in_near[0] + in_far[0];
3689 for (; i < ((w - 1) & ~7); i += 8) {
3690#if defined(STBI_SSE2)
3693 __m128i zero = _mm_setzero_si128();
3694 __m128i farb = _mm_loadl_epi64((__m128i *)(in_far + i));
3695 __m128i nearb = _mm_loadl_epi64((__m128i *)(in_near + i));
3696 __m128i farw = _mm_unpacklo_epi8(farb, zero);
3697 __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
3698 __m128i diff = _mm_sub_epi16(farw, nearw);
3699 __m128i nears = _mm_slli_epi16(nearw, 2);
3700 __m128i curr = _mm_add_epi16(nears, diff);
3707 __m128i prv0 = _mm_slli_si128(curr, 2);
3708 __m128i nxt0 = _mm_srli_si128(curr, 2);
3709 __m128i prev = _mm_insert_epi16(prv0, t1, 0);
3710 __m128i next = _mm_insert_epi16(nxt0, 3 * in_near[i + 8] + in_far[i + 8], 7);
3716 __m128i bias = _mm_set1_epi16(8);
3717 __m128i curs = _mm_slli_epi16(curr, 2);
3718 __m128i prvd = _mm_sub_epi16(prev, curr);
3719 __m128i nxtd = _mm_sub_epi16(next, curr);
3720 __m128i curb = _mm_add_epi16(curs, bias);
3721 __m128i even = _mm_add_epi16(prvd, curb);
3722 __m128i odd = _mm_add_epi16(nxtd, curb);
3725 __m128i int0 = _mm_unpacklo_epi16(even, odd);
3726 __m128i int1 = _mm_unpackhi_epi16(even, odd);
3727 __m128i de0 = _mm_srli_epi16(int0, 4);
3728 __m128i de1 = _mm_srli_epi16(int1, 4);
3731 __m128i outv = _mm_packus_epi16(de0, de1);
3732 _mm_storeu_si128((__m128i *)(out + i * 2), outv);
3733#elif defined(STBI_NEON)
3736 uint8x8_t farb = vld1_u8(in_far + i);
3737 uint8x8_t nearb = vld1_u8(in_near + i);
3738 int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
3739 int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
3740 int16x8_t curr = vaddq_s16(nears, diff);
3747 int16x8_t prv0 = vextq_s16(curr, curr, 7);
3748 int16x8_t nxt0 = vextq_s16(curr, curr, 1);
3749 int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
3750 int16x8_t next = vsetq_lane_s16(3 * in_near[i + 8] + in_far[i + 8], nxt0, 7);
3756 int16x8_t curs = vshlq_n_s16(curr, 2);
3757 int16x8_t prvd = vsubq_s16(prev, curr);
3758 int16x8_t nxtd = vsubq_s16(next, curr);
3759 int16x8_t even = vaddq_s16(curs, prvd);
3760 int16x8_t odd = vaddq_s16(curs, nxtd);
3764 o.val[0] = vqrshrun_n_s16(even, 4);
3765 o.val[1] = vqrshrun_n_s16(odd, 4);
3766 vst2_u8(out + i * 2, o);
3770 t1 = 3 * in_near[i + 7] + in_far[i + 7];
3774 t1 = 3 * in_near[i] + in_far[i];
3775 out[i * 2] = stbi__div16(3 * t1 + t0 + 8);
3777 for (++i; i < w; ++i) {
3779 t1 = 3 * in_near[i] + in_far[i];
3780 out[i * 2 - 1] = stbi__div16(3 * t0 + t1 + 8);
3781 out[i * 2] = stbi__div16(3 * t1 + t0 + 8);
3783 out[w * 2 - 1] = stbi__div4(t1 + 2);
3791static stbi_uc * stbi__resample_row_generic(stbi_uc * out, stbi_uc * in_near, stbi_uc * in_far,
int w,
int hs) {
3794 STBI_NOTUSED(in_far);
3795 for (i = 0; i < w; ++i)
3796 for (j = 0; j < hs; ++j)
3797 out[i * hs + j] = in_near[i];
3803#define stbi__float2fixed(x) (((int)((x)*4096.0f + 0.5f)) << 8)
3804static void stbi__YCbCr_to_RGB_row(stbi_uc * out,
const stbi_uc * y,
const stbi_uc * pcb,
const stbi_uc * pcr,
int count,
3807 for (i = 0; i < count; ++i) {
3808 int y_fixed = (y[i] << 20) + (1 << 19);
3810 int cr = pcr[i] - 128;
3811 int cb = pcb[i] - 128;
3812 r = y_fixed + cr * stbi__float2fixed(1.40200f);
3813 g = y_fixed + (cr * -stbi__float2fixed(0.71414f)) + ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000);
3814 b = y_fixed + cb * stbi__float2fixed(1.77200f);
3818 if ((
unsigned)r > 255) {
3824 if ((
unsigned)g > 255) {
3830 if ((
unsigned)b > 255) {
3836 out[0] = (stbi_uc)r;
3837 out[1] = (stbi_uc)g;
3838 out[2] = (stbi_uc)b;
3844#if defined(STBI_SSE2) || defined(STBI_NEON)
3845static void stbi__YCbCr_to_RGB_simd(stbi_uc * out, stbi_uc
const * y, stbi_uc
const * pcb, stbi_uc
const * pcr,
int count,
3855 __m128i signflip = _mm_set1_epi8(-0x80);
3856 __m128i cr_const0 = _mm_set1_epi16((
short)(1.40200f * 4096.0f + 0.5f));
3857 __m128i cr_const1 = _mm_set1_epi16(-(
short)(0.71414f * 4096.0f + 0.5f));
3858 __m128i cb_const0 = _mm_set1_epi16(-(
short)(0.34414f * 4096.0f + 0.5f));
3859 __m128i cb_const1 = _mm_set1_epi16((
short)(1.77200f * 4096.0f + 0.5f));
3860 __m128i y_bias = _mm_set1_epi8((
char)(
unsigned char)128);
3861 __m128i xw = _mm_set1_epi16(255);
3863 for (; i + 7 < count; i += 8) {
3865 __m128i y_bytes = _mm_loadl_epi64((__m128i *)(y + i));
3866 __m128i cr_bytes = _mm_loadl_epi64((__m128i *)(pcr + i));
3867 __m128i cb_bytes = _mm_loadl_epi64((__m128i *)(pcb + i));
3868 __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip);
3869 __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip);
3872 __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
3873 __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
3874 __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
3877 __m128i yws = _mm_srli_epi16(yw, 4);
3878 __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
3879 __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
3880 __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
3881 __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
3882 __m128i rws = _mm_add_epi16(cr0, yws);
3883 __m128i gwt = _mm_add_epi16(cb0, yws);
3884 __m128i bws = _mm_add_epi16(yws, cb1);
3885 __m128i gws = _mm_add_epi16(gwt, cr1);
3888 __m128i rw = _mm_srai_epi16(rws, 4);
3889 __m128i bw = _mm_srai_epi16(bws, 4);
3890 __m128i gw = _mm_srai_epi16(gws, 4);
3893 __m128i brb = _mm_packus_epi16(rw, bw);
3894 __m128i gxb = _mm_packus_epi16(gw, xw);
3897 __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
3898 __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
3899 __m128i o0 = _mm_unpacklo_epi16(t0, t1);
3900 __m128i o1 = _mm_unpackhi_epi16(t0, t1);
3903 _mm_storeu_si128((__m128i *)(out + 0), o0);
3904 _mm_storeu_si128((__m128i *)(out + 16), o1);
3914 uint8x8_t signflip = vdup_n_u8(0x80);
3915 int16x8_t cr_const0 = vdupq_n_s16((
short)(1.40200f * 4096.0f + 0.5f));
3916 int16x8_t cr_const1 = vdupq_n_s16(-(
short)(0.71414f * 4096.0f + 0.5f));
3917 int16x8_t cb_const0 = vdupq_n_s16(-(
short)(0.34414f * 4096.0f + 0.5f));
3918 int16x8_t cb_const1 = vdupq_n_s16((
short)(1.77200f * 4096.0f + 0.5f));
3920 for (; i + 7 < count; i += 8) {
3922 uint8x8_t y_bytes = vld1_u8(y + i);
3923 uint8x8_t cr_bytes = vld1_u8(pcr + i);
3924 uint8x8_t cb_bytes = vld1_u8(pcb + i);
3925 int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
3926 int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
3929 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
3930 int16x8_t crw = vshll_n_s8(cr_biased, 7);
3931 int16x8_t cbw = vshll_n_s8(cb_biased, 7);
3934 int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
3935 int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
3936 int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
3937 int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
3938 int16x8_t rws = vaddq_s16(yws, cr0);
3939 int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
3940 int16x8_t bws = vaddq_s16(yws, cb1);
3944 o.val[0] = vqrshrun_n_s16(rws, 4);
3945 o.val[1] = vqrshrun_n_s16(gws, 4);
3946 o.val[2] = vqrshrun_n_s16(bws, 4);
3947 o.val[3] = vdup_n_u8(255);
3956 for (; i < count; ++i) {
3957 int y_fixed = (y[i] << 20) + (1 << 19);
3959 int cr = pcr[i] - 128;
3960 int cb = pcb[i] - 128;
3961 r = y_fixed + cr * stbi__float2fixed(1.40200f);
3962 g = y_fixed + cr * -stbi__float2fixed(0.71414f) + ((cb * -stbi__float2fixed(0.34414f)) & 0xffff0000);
3963 b = y_fixed + cb * stbi__float2fixed(1.77200f);
3967 if ((
unsigned)r > 255) {
3973 if ((
unsigned)g > 255) {
3979 if ((
unsigned)b > 255) {
3985 out[0] = (stbi_uc)r;
3986 out[1] = (stbi_uc)g;
3987 out[2] = (stbi_uc)b;
3995static void stbi__setup_jpeg(stbi__jpeg * j) {
3996 j->idct_block_kernel = stbi__idct_block;
3997 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
3998 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
4001 if (stbi__sse2_available()) {
4002 j->idct_block_kernel = stbi__idct_simd;
4003 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
4004 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
4009 j->idct_block_kernel = stbi__idct_simd;
4010 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
4011 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
4016static void stbi__cleanup_jpeg(stbi__jpeg * j) { stbi__free_jpeg_components(j, j->s->img_n, 0); }
4019 resample_row_func resample;
4020 stbi_uc *line0, *line1;
4028static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) {
4029 unsigned int t = x * y + 128;
4030 return (stbi_uc)((t + (t >> 8)) >> 8);
4033static stbi_uc * load_jpeg_image(stbi__jpeg * z,
int * out_x,
int * out_y,
int * comp,
int req_comp) {
4034 int n, decode_n, is_rgb;
4038 if (req_comp < 0 || req_comp > 4)
4039 return stbi__errpuc(
"bad req_comp",
"Internal error");
4042 if (!stbi__decode_jpeg_image(z)) {
4043 stbi__cleanup_jpeg(z);
4048 n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
4050 is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
4052 if (z->s->img_n == 3 && n < 3 && !is_rgb)
4055 decode_n = z->s->img_n;
4059 if (decode_n <= 0) {
4060 stbi__cleanup_jpeg(z);
4069 stbi_uc * coutput[4] = {NULL, NULL, NULL, NULL};
4071 stbi__resample res_comp[4];
4073 for (k = 0; k < decode_n; ++k) {
4074 stbi__resample * r = &res_comp[k];
4078 z->img_comp[k].linebuf = (stbi_uc *)stbi__malloc(z->s->img_x + 3);
4079 if (!z->img_comp[k].linebuf) {
4080 stbi__cleanup_jpeg(z);
4081 return stbi__errpuc(
"outofmem",
"Out of memory");
4084 r->hs = z->img_h_max / z->img_comp[k].h;
4085 r->vs = z->img_v_max / z->img_comp[k].v;
4086 r->ystep = r->vs >> 1;
4087 r->w_lores = (z->s->img_x + r->hs - 1) / r->hs;
4089 r->line0 = r->line1 = z->img_comp[k].data;
4091 if (r->hs == 1 && r->vs == 1)
4092 r->resample = resample_row_1;
4093 else if (r->hs == 1 && r->vs == 2)
4094 r->resample = stbi__resample_row_v_2;
4095 else if (r->hs == 2 && r->vs == 1)
4096 r->resample = stbi__resample_row_h_2;
4097 else if (r->hs == 2 && r->vs == 2)
4098 r->resample = z->resample_row_hv_2_kernel;
4100 r->resample = stbi__resample_row_generic;
4104 output = (stbi_uc *)stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
4106 stbi__cleanup_jpeg(z);
4107 return stbi__errpuc(
"outofmem",
"Out of memory");
4111 for (j = 0; j < z->s->img_y; ++j) {
4112 stbi_uc * out = output + n * z->s->img_x * j;
4113 for (k = 0; k < decode_n; ++k) {
4114 stbi__resample * r = &res_comp[k];
4115 int y_bot = r->ystep >= (r->vs >> 1);
4116 coutput[k] = r->resample(z->img_comp[k].linebuf, y_bot ? r->line1 : r->line0, y_bot ? r->line0 : r->line1,
4118 if (++r->ystep >= r->vs) {
4120 r->line0 = r->line1;
4121 if (++r->ypos < z->img_comp[k].y)
4122 r->line1 += z->img_comp[k].w2;
4126 stbi_uc * y = coutput[0];
4127 if (z->s->img_n == 3) {
4129 for (i = 0; i < z->s->img_x; ++i) {
4131 out[1] = coutput[1][i];
4132 out[2] = coutput[2][i];
4137 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
4139 }
else if (z->s->img_n == 4) {
4140 if (z->app14_color_transform == 0) {
4141 for (i = 0; i < z->s->img_x; ++i) {
4142 stbi_uc m = coutput[3][i];
4143 out[0] = stbi__blinn_8x8(coutput[0][i], m);
4144 out[1] = stbi__blinn_8x8(coutput[1][i], m);
4145 out[2] = stbi__blinn_8x8(coutput[2][i], m);
4149 }
else if (z->app14_color_transform == 2) {
4150 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
4151 for (i = 0; i < z->s->img_x; ++i) {
4152 stbi_uc m = coutput[3][i];
4153 out[0] = stbi__blinn_8x8(255 - out[0], m);
4154 out[1] = stbi__blinn_8x8(255 - out[1], m);
4155 out[2] = stbi__blinn_8x8(255 - out[2], m);
4159 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
4162 for (i = 0; i < z->s->img_x; ++i) {
4163 out[0] = out[1] = out[2] = y[i];
4170 for (i = 0; i < z->s->img_x; ++i)
4171 *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
4173 for (i = 0; i < z->s->img_x; ++i, out += 2) {
4174 out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
4178 }
else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
4179 for (i = 0; i < z->s->img_x; ++i) {
4180 stbi_uc m = coutput[3][i];
4181 stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
4182 stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
4183 stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
4184 out[0] = stbi__compute_y(r, g, b);
4188 }
else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
4189 for (i = 0; i < z->s->img_x; ++i) {
4190 out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
4195 stbi_uc * y = coutput[0];
4197 for (i = 0; i < z->s->img_x; ++i)
4200 for (i = 0; i < z->s->img_x; ++i) {
4207 stbi__cleanup_jpeg(z);
4208 *out_x = z->s->img_x;
4209 *out_y = z->s->img_y;
4211 *comp = z->s->img_n >= 3 ? 3 : 1;
4216static void * stbi__jpeg_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
4217 unsigned char * result;
4218 stbi__jpeg * j = (stbi__jpeg *)stbi__malloc(
sizeof(stbi__jpeg));
4220 return stbi__errpuc(
"outofmem",
"Out of memory");
4221 memset(j, 0,
sizeof(stbi__jpeg));
4224 stbi__setup_jpeg(j);
4225 result = load_jpeg_image(j, x, y, comp, req_comp);
4230static int stbi__jpeg_test(stbi__context * s) {
4232 stbi__jpeg * j = (stbi__jpeg *)stbi__malloc(
sizeof(stbi__jpeg));
4234 return stbi__err(
"outofmem",
"Out of memory");
4235 memset(j, 0,
sizeof(stbi__jpeg));
4237 stbi__setup_jpeg(j);
4238 r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
4244static int stbi__jpeg_info_raw(stbi__jpeg * j,
int * x,
int * y,
int * comp) {
4245 if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
4254 *comp = j->s->img_n >= 3 ? 3 : 1;
4258static int stbi__jpeg_info(stbi__context * s,
int * x,
int * y,
int * comp) {
4260 stbi__jpeg * j = (stbi__jpeg *)(stbi__malloc(
sizeof(stbi__jpeg)));
4262 return stbi__err(
"outofmem",
"Out of memory");
4263 memset(j, 0,
sizeof(stbi__jpeg));
4265 result = stbi__jpeg_info_raw(j, x, y, comp);
4281#define STBI__ZFAST_BITS 9
4282#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
4283#define STBI__ZNSYMS 288
4288 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
4289 stbi__uint16 firstcode[16];
4291 stbi__uint16 firstsymbol[16];
4292 stbi_uc size[STBI__ZNSYMS];
4293 stbi__uint16 value[STBI__ZNSYMS];
4296stbi_inline
static int stbi__bitreverse16(
int n) {
4297 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
4298 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
4299 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
4300 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
4304stbi_inline
static int stbi__bit_reverse(
int v,
int bits) {
4305 STBI_ASSERT(bits <= 16);
4308 return stbi__bitreverse16(v) >> (16 - bits);
4311static int stbi__zbuild_huffman(stbi__zhuffman * z,
const stbi_uc * sizelist,
int num) {
4313 int code, next_code[16], sizes[17];
4316 memset(sizes, 0,
sizeof(sizes));
4317 memset(z->fast, 0,
sizeof(z->fast));
4318 for (i = 0; i < num; ++i)
4319 ++sizes[sizelist[i]];
4321 for (i = 1; i < 16; ++i)
4322 if (sizes[i] > (1 << i))
4323 return stbi__err(
"bad sizes",
"Corrupt PNG");
4325 for (i = 1; i < 16; ++i) {
4326 next_code[i] = code;
4327 z->firstcode[i] = (stbi__uint16)code;
4328 z->firstsymbol[i] = (stbi__uint16)k;
4329 code = (code + sizes[i]);
4331 if (code - 1 >= (1 << i))
4332 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4333 z->maxcode[i] = code << (16 - i);
4337 z->maxcode[16] = 0x10000;
4338 for (i = 0; i < num; ++i) {
4339 int s = sizelist[i];
4341 int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
4342 stbi__uint16 fastv = (stbi__uint16)((s << 9) | i);
4343 z->size[c] = (stbi_uc)s;
4344 z->value[c] = (stbi__uint16)i;
4345 if (s <= STBI__ZFAST_BITS) {
4346 int j = stbi__bit_reverse(next_code[s], s);
4347 while (j < (1 << STBI__ZFAST_BITS)) {
4365 stbi_uc *zbuffer, *zbuffer_end;
4367 stbi__uint32 code_buffer;
4374 stbi__zhuffman z_length, z_distance;
4377stbi_inline
static int stbi__zeof(stbi__zbuf * z) {
return (z->zbuffer >= z->zbuffer_end); }
4379stbi_inline
static stbi_uc stbi__zget8(stbi__zbuf * z) {
return stbi__zeof(z) ? 0 : *z->zbuffer++; }
4381static void stbi__fill_bits(stbi__zbuf * z) {
4383 if (z->code_buffer >= (1U << z->num_bits)) {
4384 z->zbuffer = z->zbuffer_end;
4387 z->code_buffer |= (
unsigned int)stbi__zget8(z) << z->num_bits;
4389 }
while (z->num_bits <= 24);
4392stbi_inline
static unsigned int stbi__zreceive(stbi__zbuf * z,
int n) {
4394 if (z->num_bits < n)
4396 k = z->code_buffer & ((1 << n) - 1);
4397 z->code_buffer >>= n;
4402static int stbi__zhuffman_decode_slowpath(stbi__zbuf * a, stbi__zhuffman * z) {
4406 k = stbi__bit_reverse(a->code_buffer, 16);
4407 for (s = STBI__ZFAST_BITS + 1;; ++s)
4408 if (k < z->maxcode[s])
4413 b = (k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s];
4414 if (b >= STBI__ZNSYMS)
4416 if (z->size[b] != s)
4418 a->code_buffer >>= s;
4423stbi_inline
static int stbi__zhuffman_decode(stbi__zbuf * a, stbi__zhuffman * z) {
4425 if (a->num_bits < 16) {
4426 if (stbi__zeof(a)) {
4431 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
4434 a->code_buffer >>= s;
4438 return stbi__zhuffman_decode_slowpath(a, z);
4441static int stbi__zexpand(stbi__zbuf * z,
char * zout,
int n)
4444 unsigned int cur, limit, old_limit;
4446 if (!z->z_expandable)
4447 return stbi__err(
"output buffer limit",
"Corrupt PNG");
4448 cur = (
unsigned int)(z->zout - z->zout_start);
4449 limit = old_limit = (unsigned)(z->zout_end - z->zout_start);
4450 if (UINT_MAX - cur < (
unsigned)n)
4451 return stbi__err(
"outofmem",
"Out of memory");
4452 while (cur + n > limit) {
4453 if (limit > UINT_MAX / 2)
4454 return stbi__err(
"outofmem",
"Out of memory");
4457 q = (
char *)STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
4458 STBI_NOTUSED(old_limit);
4460 return stbi__err(
"outofmem",
"Out of memory");
4463 z->zout_end = q + limit;
4467static const int stbi__zlength_base[31] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
4468 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
4470static const int stbi__zlength_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
4471 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0};
4473static const int stbi__zdist_base[32] = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33,
4474 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537,
4475 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0};
4477static const int stbi__zdist_extra[32] = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6,
4478 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
4480static int stbi__parse_huffman_block(stbi__zbuf * a) {
4481 char * zout = a->zout;
4483 int z = stbi__zhuffman_decode(a, &a->z_length);
4486 return stbi__err(
"bad huffman code",
"Corrupt PNG");
4487 if (zout >= a->zout_end) {
4488 if (!stbi__zexpand(a, zout, 1))
4501 return stbi__err(
"bad huffman code",
4504 len = stbi__zlength_base[z];
4505 if (stbi__zlength_extra[z])
4506 len += stbi__zreceive(a, stbi__zlength_extra[z]);
4507 z = stbi__zhuffman_decode(a, &a->z_distance);
4508 if (z < 0 || z >= 30)
4509 return stbi__err(
"bad huffman code",
4511 dist = stbi__zdist_base[z];
4512 if (stbi__zdist_extra[z])
4513 dist += stbi__zreceive(a, stbi__zdist_extra[z]);
4514 if (zout - a->zout_start < dist)
4515 return stbi__err(
"bad dist",
"Corrupt PNG");
4516 if (zout + len > a->zout_end) {
4517 if (!stbi__zexpand(a, zout, len))
4521 p = (stbi_uc *)(zout - dist);
4540static int stbi__compute_huffman_codes(stbi__zbuf * a) {
4541 static const stbi_uc length_dezigzag[19] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
4542 stbi__zhuffman z_codelength;
4543 stbi_uc lencodes[286 + 32 + 137];
4544 stbi_uc codelength_sizes[19];
4547 int hlit = stbi__zreceive(a, 5) + 257;
4548 int hdist = stbi__zreceive(a, 5) + 1;
4549 int hclen = stbi__zreceive(a, 4) + 4;
4550 int ntot = hlit + hdist;
4552 memset(codelength_sizes, 0,
sizeof(codelength_sizes));
4553 for (i = 0; i < hclen; ++i) {
4554 int s = stbi__zreceive(a, 3);
4555 codelength_sizes[length_dezigzag[i]] = (stbi_uc)s;
4557 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19))
4562 int c = stbi__zhuffman_decode(a, &z_codelength);
4563 if (c < 0 || c >= 19)
4564 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4566 lencodes[n++] = (stbi_uc)c;
4570 c = stbi__zreceive(a, 2) + 3;
4572 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4573 fill = lencodes[n - 1];
4574 }
else if (c == 17) {
4575 c = stbi__zreceive(a, 3) + 3;
4576 }
else if (c == 18) {
4577 c = stbi__zreceive(a, 7) + 11;
4579 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4582 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4583 memset(lencodes + n, fill, c);
4588 return stbi__err(
"bad codelengths",
"Corrupt PNG");
4589 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit))
4591 if (!stbi__zbuild_huffman(&a->z_distance, lencodes + hlit, hdist))
4596static int stbi__parse_uncompressed_block(stbi__zbuf * a) {
4599 if (a->num_bits & 7)
4600 stbi__zreceive(a, a->num_bits & 7);
4603 while (a->num_bits > 0) {
4604 header[k++] = (stbi_uc)(a->code_buffer & 255);
4605 a->code_buffer >>= 8;
4608 if (a->num_bits < 0)
4609 return stbi__err(
"zlib corrupt",
"Corrupt PNG");
4612 header[k++] = stbi__zget8(a);
4613 len = header[1] * 256 + header[0];
4614 nlen = header[3] * 256 + header[2];
4615 if (nlen != (len ^ 0xffff))
4616 return stbi__err(
"zlib corrupt",
"Corrupt PNG");
4617 if (a->zbuffer + len > a->zbuffer_end)
4618 return stbi__err(
"read past buffer",
"Corrupt PNG");
4619 if (a->zout + len > a->zout_end)
4620 if (!stbi__zexpand(a, a->zout, len))
4622 memcpy(a->zout, a->zbuffer, len);
4628static int stbi__parse_zlib_header(stbi__zbuf * a) {
4629 int cmf = stbi__zget8(a);
4632 int flg = stbi__zget8(a);
4634 return stbi__err(
"bad zlib header",
"Corrupt PNG");
4635 if ((cmf * 256 + flg) % 31 != 0)
4636 return stbi__err(
"bad zlib header",
"Corrupt PNG");
4638 return stbi__err(
"no preset dict",
"Corrupt PNG");
4640 return stbi__err(
"bad compression",
"Corrupt PNG");
4645static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = {
4646 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
4647 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
4648 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
4649 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
4650 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,
4651 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,
4652 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,
4653 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};
4654static const stbi_uc stbi__zdefault_distance[32] = {5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
4655 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5};
4669static int stbi__parse_zlib(stbi__zbuf * a,
int parse_header) {
4672 if (!stbi__parse_zlib_header(a))
4677 final = stbi__zreceive(a, 1);
4678 type = stbi__zreceive(a, 2);
4680 if (!stbi__parse_uncompressed_block(a))
4682 }
else if (type == 3) {
4687 if (!stbi__zbuild_huffman(&a->z_length, stbi__zdefault_length, STBI__ZNSYMS))
4689 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32))
4692 if (!stbi__compute_huffman_codes(a))
4695 if (!stbi__parse_huffman_block(a))
4702static int stbi__do_zlib(stbi__zbuf * a,
char * obuf,
int olen,
int exp,
int parse_header) {
4703 a->zout_start = obuf;
4705 a->zout_end = obuf + olen;
4706 a->z_expandable = exp;
4708 return stbi__parse_zlib(a, parse_header);
4711STBIDEF
char * stbi_zlib_decode_malloc_guesssize(
const char * buffer,
int len,
int initial_size,
int * outlen) {
4713 char * p = (
char *)stbi__malloc(initial_size);
4716 a.zbuffer = (stbi_uc *)buffer;
4717 a.zbuffer_end = (stbi_uc *)buffer + len;
4718 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
4720 *outlen = (int)(a.zout - a.zout_start);
4721 return a.zout_start;
4723 STBI_FREE(a.zout_start);
4728STBIDEF
char * stbi_zlib_decode_malloc(
char const * buffer,
int len,
int * outlen) {
4729 return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
4732STBIDEF
char * stbi_zlib_decode_malloc_guesssize_headerflag(
const char * buffer,
int len,
int initial_size,
int * outlen,
4735 char * p = (
char *)stbi__malloc(initial_size);
4738 a.zbuffer = (stbi_uc *)buffer;
4739 a.zbuffer_end = (stbi_uc *)buffer + len;
4740 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
4742 *outlen = (int)(a.zout - a.zout_start);
4743 return a.zout_start;
4745 STBI_FREE(a.zout_start);
4750STBIDEF
int stbi_zlib_decode_buffer(
char * obuffer,
int olen,
char const * ibuffer,
int ilen) {
4752 a.zbuffer = (stbi_uc *)ibuffer;
4753 a.zbuffer_end = (stbi_uc *)ibuffer + ilen;
4754 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
4755 return (
int)(a.zout - a.zout_start);
4760STBIDEF
char * stbi_zlib_decode_noheader_malloc(
char const * buffer,
int len,
int * outlen) {
4762 char * p = (
char *)stbi__malloc(16384);
4765 a.zbuffer = (stbi_uc *)buffer;
4766 a.zbuffer_end = (stbi_uc *)buffer + len;
4767 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
4769 *outlen = (int)(a.zout - a.zout_start);
4770 return a.zout_start;
4772 STBI_FREE(a.zout_start);
4777STBIDEF
int stbi_zlib_decode_noheader_buffer(
char * obuffer,
int olen,
const char * ibuffer,
int ilen) {
4779 a.zbuffer = (stbi_uc *)ibuffer;
4780 a.zbuffer_end = (stbi_uc *)ibuffer + ilen;
4781 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
4782 return (
int)(a.zout - a.zout_start);
4800 stbi__uint32 length;
4804static stbi__pngchunk stbi__get_chunk_header(stbi__context * s) {
4806 c.length = stbi__get32be(s);
4807 c.type = stbi__get32be(s);
4811static int stbi__check_png_header(stbi__context * s) {
4812 static const stbi_uc png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
4814 for (i = 0; i < 8; ++i)
4815 if (stbi__get8(s) != png_sig[i])
4816 return stbi__err(
"bad png sig",
"Not a PNG");
4822 stbi_uc *idata, *expanded, *out;
4837static stbi_uc first_row_filter[5] = {STBI__F_none, STBI__F_sub, STBI__F_none, STBI__F_avg_first, STBI__F_paeth_first};
4839static int stbi__paeth(
int a,
int b,
int c) {
4841 int pa = abs(p - a);
4842 int pb = abs(p - b);
4843 int pc = abs(p - c);
4844 if (pa <= pb && pa <= pc)
4851static const stbi_uc stbi__depth_scale_table[9] = {0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01};
4854static int stbi__create_png_image_raw(stbi__png * a, stbi_uc * raw, stbi__uint32 raw_len,
int out_n, stbi__uint32 x,
4855 stbi__uint32 y,
int depth,
int color) {
4856 int bytes = (depth == 16 ? 2 : 1);
4857 stbi__context * s = a->s;
4858 stbi__uint32 i, j, stride = x * out_n * bytes;
4859 stbi__uint32 img_len, img_width_bytes;
4861 int img_n = s->img_n;
4863 int output_bytes = out_n * bytes;
4864 int filter_bytes = img_n * bytes;
4867 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n + 1);
4868 a->out = (stbi_uc *)stbi__malloc_mad3(x, y, output_bytes, 0);
4870 return stbi__err(
"outofmem",
"Out of memory");
4872 if (!stbi__mad3sizes_valid(img_n, x, depth, 7))
4873 return stbi__err(
"too large",
"Corrupt PNG");
4874 img_width_bytes = (((img_n * x * depth) + 7) >> 3);
4875 img_len = (img_width_bytes + 1) * y;
4880 if (raw_len < img_len)
4881 return stbi__err(
"not enough pixels",
"Corrupt PNG");
4883 for (j = 0; j < y; ++j) {
4884 stbi_uc * cur = a->out + stride * j;
4886 int filter = *raw++;
4889 return stbi__err(
"invalid filter",
"Corrupt PNG");
4892 if (img_width_bytes > x)
4893 return stbi__err(
"invalid width",
"Corrupt PNG");
4894 cur += x * out_n - img_width_bytes;
4896 width = img_width_bytes;
4898 prior = cur - stride;
4902 filter = first_row_filter[filter];
4905 for (k = 0; k < filter_bytes; ++k) {
4914 cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
4917 cur[k] = STBI__BYTECAST(raw[k] + (prior[k] >> 1));
4920 cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0, prior[k], 0));
4922 case STBI__F_avg_first:
4925 case STBI__F_paeth_first:
4937 }
else if (depth == 16) {
4938 if (img_n != out_n) {
4939 cur[filter_bytes] = 255;
4940 cur[filter_bytes + 1] = 255;
4942 raw += filter_bytes;
4943 cur += output_bytes;
4944 prior += output_bytes;
4952 if (depth < 8 || img_n == out_n) {
4953 int nk = (width - 1) * filter_bytes;
4954#define STBI__CASE(f) \
4956 for (k = 0; k < nk; ++k)
4960 memcpy(cur, raw, nk);
4962 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k - filter_bytes]); }
4964 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
4966 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1)); }
4968 STBI__CASE(STBI__F_paeth) {
4969 cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - filter_bytes], prior[k], prior[k - filter_bytes]));
4972 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k - filter_bytes] >> 1)); }
4974 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - filter_bytes], 0, 0)); }
4980 STBI_ASSERT(img_n + 1 == out_n);
4981#define STBI__CASE(f) \
4983 for (i = x - 1; i >= 1; --i, cur[filter_bytes] = 255, raw += filter_bytes, cur += output_bytes, prior += output_bytes) \
4984 for (k = 0; k < filter_bytes; ++k)
4986 STBI__CASE(STBI__F_none) { cur[k] = raw[k]; }
4988 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k - output_bytes]); }
4990 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
4992 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k - output_bytes]) >> 1)); }
4994 STBI__CASE(STBI__F_paeth) {
4995 cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - output_bytes], prior[k], prior[k - output_bytes]));
4998 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k - output_bytes] >> 1)); }
5000 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k - output_bytes], 0, 0)); }
5008 cur = a->out + stride * j;
5009 for (i = 0; i < x; ++i, cur += output_bytes) {
5010 cur[filter_bytes + 1] = 255;
5020 for (j = 0; j < y; ++j) {
5021 stbi_uc * cur = a->out + stride * j;
5022 stbi_uc * in = a->out + stride * j + x * out_n - img_width_bytes;
5026 stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1;
5035 for (k = x * img_n; k >= 2; k -= 2, ++in) {
5036 *cur++ = scale * ((*in >> 4));
5037 *cur++ = scale * ((*in) & 0x0f);
5040 *cur++ = scale * ((*in >> 4));
5041 }
else if (depth == 2) {
5042 for (k = x * img_n; k >= 4; k -= 4, ++in) {
5043 *cur++ = scale * ((*in >> 6));
5044 *cur++ = scale * ((*in >> 4) & 0x03);
5045 *cur++ = scale * ((*in >> 2) & 0x03);
5046 *cur++ = scale * ((*in) & 0x03);
5049 *cur++ = scale * ((*in >> 6));
5051 *cur++ = scale * ((*in >> 4) & 0x03);
5053 *cur++ = scale * ((*in >> 2) & 0x03);
5054 }
else if (depth == 1) {
5055 for (k = x * img_n; k >= 8; k -= 8, ++in) {
5056 *cur++ = scale * ((*in >> 7));
5057 *cur++ = scale * ((*in >> 6) & 0x01);
5058 *cur++ = scale * ((*in >> 5) & 0x01);
5059 *cur++ = scale * ((*in >> 4) & 0x01);
5060 *cur++ = scale * ((*in >> 3) & 0x01);
5061 *cur++ = scale * ((*in >> 2) & 0x01);
5062 *cur++ = scale * ((*in >> 1) & 0x01);
5063 *cur++ = scale * ((*in) & 0x01);
5066 *cur++ = scale * ((*in >> 7));
5068 *cur++ = scale * ((*in >> 6) & 0x01);
5070 *cur++ = scale * ((*in >> 5) & 0x01);
5072 *cur++ = scale * ((*in >> 4) & 0x01);
5074 *cur++ = scale * ((*in >> 3) & 0x01);
5076 *cur++ = scale * ((*in >> 2) & 0x01);
5078 *cur++ = scale * ((*in >> 1) & 0x01);
5080 if (img_n != out_n) {
5083 cur = a->out + stride * j;
5085 for (q = x - 1; q >= 0; --q) {
5086 cur[q * 2 + 1] = 255;
5087 cur[q * 2 + 0] = cur[q];
5090 STBI_ASSERT(img_n == 3);
5091 for (q = x - 1; q >= 0; --q) {
5092 cur[q * 4 + 3] = 255;
5093 cur[q * 4 + 2] = cur[q * 3 + 2];
5094 cur[q * 4 + 1] = cur[q * 3 + 1];
5095 cur[q * 4 + 0] = cur[q * 3 + 0];
5100 }
else if (depth == 16) {
5105 stbi_uc * cur = a->out;
5106 stbi__uint16 * cur16 = (stbi__uint16 *)cur;
5108 for (i = 0; i < x * y * out_n; ++i, cur16++, cur += 2) {
5109 *cur16 = (cur[0] << 8) | cur[1];
5116static int stbi__create_png_image(stbi__png * a, stbi_uc * image_data, stbi__uint32 image_data_len,
int out_n,
int depth,
5117 int color,
int interlaced) {
5118 int bytes = (depth == 16 ? 2 : 1);
5119 int out_bytes = out_n * bytes;
5123 return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
5126 final = (stbi_uc *)stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
5128 return stbi__err(
"outofmem",
"Out of memory");
5129 for (p = 0; p < 7; ++p) {
5130 int xorig[] = {0, 4, 0, 2, 0, 1, 0};
5131 int yorig[] = {0, 0, 4, 0, 2, 0, 1};
5132 int xspc[] = {8, 8, 4, 4, 2, 2, 1};
5133 int yspc[] = {8, 8, 8, 4, 4, 2, 2};
5136 x = (a->s->img_x - xorig[p] + xspc[p] - 1) / xspc[p];
5137 y = (a->s->img_y - yorig[p] + yspc[p] - 1) / yspc[p];
5139 stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
5140 if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
5144 for (j = 0; j < y; ++j) {
5145 for (i = 0; i < x; ++i) {
5146 int out_y = j * yspc[p] + yorig[p];
5147 int out_x = i * xspc[p] + xorig[p];
5148 memcpy(
final + out_y * a->s->img_x * out_bytes + out_x * out_bytes, a->out + (j * x + i) * out_bytes,
5153 image_data += img_len;
5154 image_data_len -= img_len;
5162static int stbi__compute_transparency(stbi__png * z, stbi_uc tc[3],
int out_n) {
5163 stbi__context * s = z->s;
5164 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
5165 stbi_uc * p = z->out;
5169 STBI_ASSERT(out_n == 2 || out_n == 4);
5172 for (i = 0; i < pixel_count; ++i) {
5173 p[1] = (p[0] == tc[0] ? 0 : 255);
5177 for (i = 0; i < pixel_count; ++i) {
5178 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
5186static int stbi__compute_transparency16(stbi__png * z, stbi__uint16 tc[3],
int out_n) {
5187 stbi__context * s = z->s;
5188 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
5189 stbi__uint16 * p = (stbi__uint16 *)z->out;
5193 STBI_ASSERT(out_n == 2 || out_n == 4);
5196 for (i = 0; i < pixel_count; ++i) {
5197 p[1] = (p[0] == tc[0] ? 0 : 65535);
5201 for (i = 0; i < pixel_count; ++i) {
5202 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
5210static int stbi__expand_png_palette(stbi__png * a, stbi_uc * palette,
int len,
int pal_img_n) {
5211 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
5212 stbi_uc *p, *temp_out, *orig = a->out;
5214 p = (stbi_uc *)stbi__malloc_mad2(pixel_count, pal_img_n, 0);
5216 return stbi__err(
"outofmem",
"Out of memory");
5221 if (pal_img_n == 3) {
5222 for (i = 0; i < pixel_count; ++i) {
5223 int n = orig[i] * 4;
5225 p[1] = palette[n + 1];
5226 p[2] = palette[n + 2];
5230 for (i = 0; i < pixel_count; ++i) {
5231 int n = orig[i] * 4;
5233 p[1] = palette[n + 1];
5234 p[2] = palette[n + 2];
5235 p[3] = palette[n + 3];
5247static int stbi__unpremultiply_on_load_global = 0;
5248static int stbi__de_iphone_flag_global = 0;
5250STBIDEF
void stbi_set_unpremultiply_on_load(
int flag_true_if_should_unpremultiply) {
5251 stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
5254STBIDEF
void stbi_convert_iphone_png_to_rgb(
int flag_true_if_should_convert) {
5255 stbi__de_iphone_flag_global = flag_true_if_should_convert;
5258#ifndef STBI_THREAD_LOCAL
5259#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global
5260#define stbi__de_iphone_flag stbi__de_iphone_flag_global
5262static STBI_THREAD_LOCAL
int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
5263static STBI_THREAD_LOCAL
int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
5265STBIDEF
void stbi_set_unpremultiply_on_load_thread(
int flag_true_if_should_unpremultiply) {
5266 stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
5267 stbi__unpremultiply_on_load_set = 1;
5270STBIDEF
void stbi_convert_iphone_png_to_rgb_thread(
int flag_true_if_should_convert) {
5271 stbi__de_iphone_flag_local = flag_true_if_should_convert;
5272 stbi__de_iphone_flag_set = 1;
5275#define stbi__unpremultiply_on_load \
5276 (stbi__unpremultiply_on_load_set ? stbi__unpremultiply_on_load_local : stbi__unpremultiply_on_load_global)
5277#define stbi__de_iphone_flag (stbi__de_iphone_flag_set ? stbi__de_iphone_flag_local : stbi__de_iphone_flag_global)
5280static void stbi__de_iphone(stbi__png * z) {
5281 stbi__context * s = z->s;
5282 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
5283 stbi_uc * p = z->out;
5285 if (s->img_out_n == 3) {
5286 for (i = 0; i < pixel_count; ++i) {
5293 STBI_ASSERT(s->img_out_n == 4);
5294 if (stbi__unpremultiply_on_load) {
5296 for (i = 0; i < pixel_count; ++i) {
5300 stbi_uc half = a / 2;
5301 p[0] = (p[2] * 255 + half) / a;
5302 p[1] = (p[1] * 255 + half) / a;
5303 p[2] = (t * 255 + half) / a;
5312 for (i = 0; i < pixel_count; ++i) {
5322#define STBI__PNG_TYPE(a, b, c, d) (((unsigned)(a) << 24) + ((unsigned)(b) << 16) + ((unsigned)(c) << 8) + (unsigned)(d))
5324static int stbi__parse_png_file(stbi__png * z,
int scan,
int req_comp) {
5325 stbi_uc palette[1024], pal_img_n = 0;
5326 stbi_uc has_trans = 0, tc[3] = {0};
5327 stbi__uint16 tc16[3];
5328 stbi__uint32 ioff = 0, idata_limit = 0, i, pal_len = 0;
5329 int first = 1, k, interlace = 0, color = 0, is_iphone = 0;
5330 stbi__context * s = z->s;
5336 if (!stbi__check_png_header(s))
5339 if (scan == STBI__SCAN_type)
5343 stbi__pngchunk c = stbi__get_chunk_header(s);
5345 case STBI__PNG_TYPE(
'C',
'g',
'B',
'I'):
5347 stbi__skip(s, c.length);
5349 case STBI__PNG_TYPE(
'I',
'H',
'D',
'R'): {
5352 return stbi__err(
"multiple IHDR",
"Corrupt PNG");
5355 return stbi__err(
"bad IHDR len",
"Corrupt PNG");
5356 s->img_x = stbi__get32be(s);
5357 s->img_y = stbi__get32be(s);
5358 if (s->img_y > STBI_MAX_DIMENSIONS)
5359 return stbi__err(
"too large",
"Very large image (corrupt?)");
5360 if (s->img_x > STBI_MAX_DIMENSIONS)
5361 return stbi__err(
"too large",
"Very large image (corrupt?)");
5362 z->depth = stbi__get8(s);
5363 if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)
5364 return stbi__err(
"1/2/4/8/16-bit only",
"PNG not supported: 1/2/4/8/16-bit only");
5365 color = stbi__get8(s);
5367 return stbi__err(
"bad ctype",
"Corrupt PNG");
5368 if (color == 3 && z->depth == 16)
5369 return stbi__err(
"bad ctype",
"Corrupt PNG");
5373 return stbi__err(
"bad ctype",
"Corrupt PNG");
5374 comp = stbi__get8(s);
5376 return stbi__err(
"bad comp method",
"Corrupt PNG");
5377 filter = stbi__get8(s);
5379 return stbi__err(
"bad filter method",
"Corrupt PNG");
5380 interlace = stbi__get8(s);
5382 return stbi__err(
"bad interlace method",
"Corrupt PNG");
5383 if (!s->img_x || !s->img_y)
5384 return stbi__err(
"0-pixel image",
"Corrupt PNG");
5386 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
5387 if ((1 << 30) / s->img_x / s->img_n < s->img_y)
5388 return stbi__err(
"too large",
"Image too large to decode");
5393 if ((1 << 30) / s->img_x / 4 < s->img_y)
5394 return stbi__err(
"too large",
"Corrupt PNG");
5400 case STBI__PNG_TYPE(
'P',
'L',
'T',
'E'): {
5402 return stbi__err(
"first not IHDR",
"Corrupt PNG");
5403 if (c.length > 256 * 3)
5404 return stbi__err(
"invalid PLTE",
"Corrupt PNG");
5405 pal_len = c.length / 3;
5406 if (pal_len * 3 != c.length)
5407 return stbi__err(
"invalid PLTE",
"Corrupt PNG");
5408 for (i = 0; i < pal_len; ++i) {
5409 palette[i * 4 + 0] = stbi__get8(s);
5410 palette[i * 4 + 1] = stbi__get8(s);
5411 palette[i * 4 + 2] = stbi__get8(s);
5412 palette[i * 4 + 3] = 255;
5417 case STBI__PNG_TYPE(
't',
'R',
'N',
'S'): {
5419 return stbi__err(
"first not IHDR",
"Corrupt PNG");
5421 return stbi__err(
"tRNS after IDAT",
"Corrupt PNG");
5423 if (scan == STBI__SCAN_header) {
5428 return stbi__err(
"tRNS before PLTE",
"Corrupt PNG");
5429 if (c.length > pal_len)
5430 return stbi__err(
"bad tRNS len",
"Corrupt PNG");
5432 for (i = 0; i < c.length; ++i)
5433 palette[i * 4 + 3] = stbi__get8(s);
5435 if (!(s->img_n & 1))
5436 return stbi__err(
"tRNS with alpha",
"Corrupt PNG");
5437 if (c.length != (stbi__uint32)s->img_n * 2)
5438 return stbi__err(
"bad tRNS len",
"Corrupt PNG");
5441 if (scan == STBI__SCAN_header) {
5445 if (z->depth == 16) {
5446 for (k = 0; k < s->img_n; ++k)
5447 tc16[k] = (stbi__uint16)stbi__get16be(s);
5449 for (k = 0; k < s->img_n; ++k)
5450 tc[k] = (stbi_uc)(stbi__get16be(s) & 255) *
5451 stbi__depth_scale_table[z->depth];
5457 case STBI__PNG_TYPE(
'I',
'D',
'A',
'T'): {
5459 return stbi__err(
"first not IHDR",
"Corrupt PNG");
5460 if (pal_img_n && !pal_len)
5461 return stbi__err(
"no PLTE",
"Corrupt PNG");
5462 if (scan == STBI__SCAN_header) {
5465 s->img_n = pal_img_n;
5468 if (c.length > (1u << 30))
5469 return stbi__err(
"IDAT size limit",
"IDAT section larger than 2^30 bytes");
5470 if ((
int)(ioff + c.length) < (
int)ioff)
5472 if (ioff + c.length > idata_limit) {
5473 stbi__uint32 idata_limit_old = idata_limit;
5475 if (idata_limit == 0)
5476 idata_limit = c.length > 4096 ? c.length : 4096;
5477 while (ioff + c.length > idata_limit)
5479 STBI_NOTUSED(idata_limit_old);
5480 p = (stbi_uc *)STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit);
5482 return stbi__err(
"outofmem",
"Out of memory");
5485 if (!stbi__getn(s, z->idata + ioff, c.length))
5486 return stbi__err(
"outofdata",
"Corrupt PNG");
5491 case STBI__PNG_TYPE(
'I',
'E',
'N',
'D'): {
5492 stbi__uint32 raw_len, bpl;
5494 return stbi__err(
"first not IHDR",
"Corrupt PNG");
5495 if (scan != STBI__SCAN_load)
5497 if (z->idata == NULL)
5498 return stbi__err(
"no IDAT",
"Corrupt PNG");
5500 bpl = (s->img_x * z->depth + 7) / 8;
5501 raw_len = bpl * s->img_y * s->img_n + s->img_y ;
5502 z->expanded = (stbi_uc *)stbi_zlib_decode_malloc_guesssize_headerflag((
char *)z->idata, ioff, raw_len,
5503 (
int *)&raw_len, !is_iphone);
5504 if (z->expanded == NULL)
5506 STBI_FREE(z->idata);
5508 if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) || has_trans)
5509 s->img_out_n = s->img_n + 1;
5511 s->img_out_n = s->img_n;
5512 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace))
5515 if (z->depth == 16) {
5516 if (!stbi__compute_transparency16(z, tc16, s->img_out_n))
5519 if (!stbi__compute_transparency(z, tc, s->img_out_n))
5523 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
5527 s->img_n = pal_img_n;
5528 s->img_out_n = pal_img_n;
5530 s->img_out_n = req_comp;
5531 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
5533 }
else if (has_trans) {
5537 STBI_FREE(z->expanded);
5547 return stbi__err(
"first not IHDR",
"Corrupt PNG");
5548 if ((c.type & (1 << 29)) == 0) {
5549#ifndef STBI_NO_FAILURE_STRINGS
5551 static char invalid_chunk[] =
"XXXX PNG chunk not known";
5552 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
5553 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
5554 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
5555 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
5557 return stbi__err(invalid_chunk,
"PNG not supported: unknown PNG chunk type");
5559 stbi__skip(s, c.length);
5567static void * stbi__do_png(stbi__png * p,
int * x,
int * y,
int * n,
int req_comp, stbi__result_info * ri) {
5568 void * result = NULL;
5569 if (req_comp < 0 || req_comp > 4)
5570 return stbi__errpuc(
"bad req_comp",
"Internal error");
5571 if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
5573 ri->bits_per_channel = 8;
5574 else if (p->depth == 16)
5575 ri->bits_per_channel = 16;
5577 return stbi__errpuc(
"bad bits_per_channel",
"PNG not supported: unsupported color depth");
5580 if (req_comp && req_comp != p->s->img_out_n) {
5581 if (ri->bits_per_channel == 8)
5582 result = stbi__convert_format((
unsigned char *)result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5584 result = stbi__convert_format16((stbi__uint16 *)result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5585 p->s->img_out_n = req_comp;
5596 STBI_FREE(p->expanded);
5598 STBI_FREE(p->idata);
5604static void * stbi__png_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
5607 return stbi__do_png(&p, x, y, comp, req_comp, ri);
5610static int stbi__png_test(stbi__context * s) {
5612 r = stbi__check_png_header(s);
5617static int stbi__png_info_raw(stbi__png * p,
int * x,
int * y,
int * comp) {
5618 if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
5627 *comp = p->s->img_n;
5631static int stbi__png_info(stbi__context * s,
int * x,
int * y,
int * comp) {
5634 return stbi__png_info_raw(&p, x, y, comp);
5637static int stbi__png_is16(stbi__context * s) {
5640 if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
5642 if (p.depth != 16) {
5653static int stbi__bmp_test_raw(stbi__context * s) {
5656 if (stbi__get8(s) !=
'B')
5658 if (stbi__get8(s) !=
'M')
5664 sz = stbi__get32le(s);
5665 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
5669static int stbi__bmp_test(stbi__context * s) {
5670 int r = stbi__bmp_test_raw(s);
5676static int stbi__high_bit(
unsigned int z) {
5702static int stbi__bitcount(
unsigned int a) {
5703 a = (a & 0x55555555) + ((a >> 1) & 0x55555555);
5704 a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
5705 a = (a + (a >> 4)) & 0x0f0f0f0f;
5707 a = (a + (a >> 16));
5714static int stbi__shiftsigned(
unsigned int v,
int shift,
int bits) {
5715 static unsigned int mul_table[9] = {
5726 static unsigned int shift_table[9] = {
5727 0, 0, 0, 1, 0, 2, 4, 6, 0,
5733 STBI_ASSERT(v < 256);
5735 STBI_ASSERT(bits >= 0 && bits <= 8);
5736 return (
int)((unsigned)v * mul_table[bits]) >> shift_table[bits];
5740 int bpp, offset, hsz;
5741 unsigned int mr, mg, mb, ma, all_a;
5745static int stbi__bmp_set_mask_defaults(stbi__bmp_data * info,
int compress) {
5750 if (compress == 0) {
5751 if (info->bpp == 16) {
5752 info->mr = 31u << 10;
5753 info->mg = 31u << 5;
5754 info->mb = 31u << 0;
5755 }
else if (info->bpp == 32) {
5756 info->mr = 0xffu << 16;
5757 info->mg = 0xffu << 8;
5758 info->mb = 0xffu << 0;
5759 info->ma = 0xffu << 24;
5763 info->mr = info->mg = info->mb = info->ma = 0;
5770static void * stbi__bmp_parse_header(stbi__context * s, stbi__bmp_data * info) {
5772 if (stbi__get8(s) !=
'B' || stbi__get8(s) !=
'M')
5773 return stbi__errpuc(
"not BMP",
"Corrupt BMP");
5777 info->offset = stbi__get32le(s);
5778 info->hsz = hsz = stbi__get32le(s);
5779 info->mr = info->mg = info->mb = info->ma = 0;
5780 info->extra_read = 14;
5782 if (info->offset < 0)
5783 return stbi__errpuc(
"bad BMP",
"bad BMP");
5785 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124)
5786 return stbi__errpuc(
"unknown BMP",
"BMP type not supported: unknown");
5788 s->img_x = stbi__get16le(s);
5789 s->img_y = stbi__get16le(s);
5791 s->img_x = stbi__get32le(s);
5792 s->img_y = stbi__get32le(s);
5794 if (stbi__get16le(s) != 1)
5795 return stbi__errpuc(
"bad BMP",
"bad BMP");
5796 info->bpp = stbi__get16le(s);
5798 int compress = stbi__get32le(s);
5799 if (compress == 1 || compress == 2)
5800 return stbi__errpuc(
"BMP RLE",
"BMP type not supported: RLE");
5802 return stbi__errpuc(
"BMP JPEG/PNG",
5803 "BMP type not supported: unsupported compression");
5804 if (compress == 3 && info->bpp != 16 && info->bpp != 32)
5805 return stbi__errpuc(
"bad BMP",
"bad BMP");
5811 if (hsz == 40 || hsz == 56) {
5818 if (info->bpp == 16 || info->bpp == 32) {
5819 if (compress == 0) {
5820 stbi__bmp_set_mask_defaults(info, compress);
5821 }
else if (compress == 3) {
5822 info->mr = stbi__get32le(s);
5823 info->mg = stbi__get32le(s);
5824 info->mb = stbi__get32le(s);
5825 info->extra_read += 12;
5827 if (info->mr == info->mg && info->mg == info->mb) {
5829 return stbi__errpuc(
"bad BMP",
"bad BMP");
5832 return stbi__errpuc(
"bad BMP",
"bad BMP");
5837 if (hsz != 108 && hsz != 124)
5838 return stbi__errpuc(
"bad BMP",
"bad BMP");
5839 info->mr = stbi__get32le(s);
5840 info->mg = stbi__get32le(s);
5841 info->mb = stbi__get32le(s);
5842 info->ma = stbi__get32le(s);
5844 stbi__bmp_set_mask_defaults(info, compress);
5846 for (i = 0; i < 12; ++i)
5859static void * stbi__bmp_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
5861 unsigned int mr = 0, mg = 0, mb = 0, ma = 0, all_a;
5862 stbi_uc pal[256][4];
5863 int psize = 0, i, j, width;
5864 int flip_vertically, pad, target;
5865 stbi__bmp_data info;
5869 if (stbi__bmp_parse_header(s, &info) == NULL)
5872 flip_vertically = ((int)s->img_y) > 0;
5873 s->img_y = abs((
int)s->img_y);
5875 if (s->img_y > STBI_MAX_DIMENSIONS)
5876 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
5877 if (s->img_x > STBI_MAX_DIMENSIONS)
5878 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
5886 if (info.hsz == 12) {
5888 psize = (info.offset - info.extra_read - 24) / 3;
5891 psize = (info.offset - info.extra_read - info.hsz) >> 2;
5896 int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
5897 int header_limit = 1024;
5898 int extra_data_limit = 256 * 4;
5899 if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
5900 return stbi__errpuc(
"bad header",
"Corrupt BMP");
5906 if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
5907 return stbi__errpuc(
"bad offset",
"Corrupt BMP");
5909 stbi__skip(s, info.offset - bytes_read_so_far);
5913 if (info.bpp == 24 && ma == 0xff000000)
5916 s->img_n = ma ? 4 : 3;
5917 if (req_comp && req_comp >= 3)
5923 if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
5924 return stbi__errpuc(
"too large",
"Corrupt BMP");
5926 out = (stbi_uc *)stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
5928 return stbi__errpuc(
"outofmem",
"Out of memory");
5929 if (info.bpp < 16) {
5931 if (psize == 0 || psize > 256) {
5933 return stbi__errpuc(
"invalid",
"Corrupt BMP");
5935 for (i = 0; i < psize; ++i) {
5936 pal[i][2] = stbi__get8(s);
5937 pal[i][1] = stbi__get8(s);
5938 pal[i][0] = stbi__get8(s);
5943 stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
5945 width = (s->img_x + 7) >> 3;
5946 else if (info.bpp == 4)
5947 width = (s->img_x + 1) >> 1;
5948 else if (info.bpp == 8)
5952 return stbi__errpuc(
"bad bpp",
"Corrupt BMP");
5955 if (info.bpp == 1) {
5956 for (j = 0; j < (int)s->img_y; ++j) {
5957 int bit_offset = 7, v = stbi__get8(s);
5958 for (i = 0; i < (int)s->img_x; ++i) {
5959 int color = (v >> bit_offset) & 0x1;
5960 out[z++] = pal[color][0];
5961 out[z++] = pal[color][1];
5962 out[z++] = pal[color][2];
5965 if (i + 1 == (
int)s->img_x)
5967 if ((--bit_offset) < 0) {
5975 for (j = 0; j < (int)s->img_y; ++j) {
5976 for (i = 0; i < (int)s->img_x; i += 2) {
5977 int v = stbi__get8(s), v2 = 0;
5978 if (info.bpp == 4) {
5982 out[z++] = pal[v][0];
5983 out[z++] = pal[v][1];
5984 out[z++] = pal[v][2];
5987 if (i + 1 == (
int)s->img_x)
5989 v = (info.bpp == 8) ? stbi__get8(s) : v2;
5990 out[z++] = pal[v][0];
5991 out[z++] = pal[v][1];
5992 out[z++] = pal[v][2];
6000 int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, gcount = 0, bcount = 0, acount = 0;
6003 stbi__skip(s, info.offset - info.extra_read - info.hsz);
6005 width = 3 * s->img_x;
6006 else if (info.bpp == 16)
6007 width = 2 * s->img_x;
6011 if (info.bpp == 24) {
6013 }
else if (info.bpp == 32) {
6014 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
6018 if (!mr || !mg || !mb) {
6020 return stbi__errpuc(
"bad masks",
"Corrupt BMP");
6023 rshift = stbi__high_bit(mr) - 7;
6024 rcount = stbi__bitcount(mr);
6025 gshift = stbi__high_bit(mg) - 7;
6026 gcount = stbi__bitcount(mg);
6027 bshift = stbi__high_bit(mb) - 7;
6028 bcount = stbi__bitcount(mb);
6029 ashift = stbi__high_bit(ma) - 7;
6030 acount = stbi__bitcount(ma);
6031 if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) {
6033 return stbi__errpuc(
"bad masks",
"Corrupt BMP");
6036 for (j = 0; j < (int)s->img_y; ++j) {
6038 for (i = 0; i < (int)s->img_x; ++i) {
6040 out[z + 2] = stbi__get8(s);
6041 out[z + 1] = stbi__get8(s);
6042 out[z + 0] = stbi__get8(s);
6044 a = (easy == 2 ? stbi__get8(s) : 255);
6051 for (i = 0; i < (int)s->img_x; ++i) {
6052 stbi__uint32 v = (bpp == 16 ? (stbi__uint32)stbi__get16le(s) : stbi__get32le(s));
6054 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
6055 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
6056 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
6057 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
6060 out[z++] = STBI__BYTECAST(a);
6068 if (target == 4 && all_a == 0)
6069 for (i = 4 * s->img_x * s->img_y - 1; i >= 0; i -= 4)
6072 if (flip_vertically) {
6074 for (j = 0; j < (int)s->img_y >> 1; ++j) {
6075 stbi_uc * p1 = out + j * s->img_x * target;
6076 stbi_uc * p2 = out + (s->img_y - 1 - j) * s->img_x * target;
6077 for (i = 0; i < (int)s->img_x * target; ++i) {
6085 if (req_comp && req_comp != target) {
6086 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
6103static int stbi__tga_get_comp(
int bits_per_pixel,
int is_grey,
int * is_rgb16) {
6107 switch (bits_per_pixel) {
6112 return STBI_grey_alpha;
6120 return bits_per_pixel / 8;
6126static int stbi__tga_info(stbi__context * s,
int * x,
int * y,
int * comp) {
6127 int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
6128 int sz, tga_colormap_type;
6130 tga_colormap_type = stbi__get8(s);
6131 if (tga_colormap_type > 1) {
6135 tga_image_type = stbi__get8(s);
6136 if (tga_colormap_type == 1) {
6137 if (tga_image_type != 1 && tga_image_type != 9) {
6143 if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32)) {
6148 tga_colormap_bpp = sz;
6150 if ((tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11)) {
6155 tga_colormap_bpp = 0;
6157 tga_w = stbi__get16le(s);
6162 tga_h = stbi__get16le(s);
6167 tga_bits_per_pixel = stbi__get8(s);
6169 if (tga_colormap_bpp != 0) {
6170 if ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
6176 tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
6178 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
6193static int stbi__tga_test(stbi__context * s) {
6195 int sz, tga_color_type;
6197 tga_color_type = stbi__get8(s);
6198 if (tga_color_type > 1)
6201 if (tga_color_type == 1) {
6202 if (sz != 1 && sz != 9)
6206 if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32))
6210 if ((sz != 2) && (sz != 3) && (sz != 10) && (sz != 11))
6214 if (stbi__get16le(s) < 1)
6216 if (stbi__get16le(s) < 1)
6219 if ((tga_color_type == 1) && (sz != 8) && (sz != 16))
6221 if ((sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32))
6232static void stbi__tga_read_rgb16(stbi__context * s, stbi_uc * out) {
6233 stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
6234 stbi__uint16 fiveBitMask = 31;
6236 int r = (px >> 10) & fiveBitMask;
6237 int g = (px >> 5) & fiveBitMask;
6238 int b = px & fiveBitMask;
6240 out[0] = (stbi_uc)((r * 255) / 31);
6241 out[1] = (stbi_uc)((g * 255) / 31);
6242 out[2] = (stbi_uc)((b * 255) / 31);
6250static void * stbi__tga_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
6252 int tga_offset = stbi__get8(s);
6253 int tga_indexed = stbi__get8(s);
6254 int tga_image_type = stbi__get8(s);
6256 int tga_palette_start = stbi__get16le(s);
6257 int tga_palette_len = stbi__get16le(s);
6258 int tga_palette_bits = stbi__get8(s);
6259 int tga_x_origin = stbi__get16le(s);
6260 int tga_y_origin = stbi__get16le(s);
6261 int tga_width = stbi__get16le(s);
6262 int tga_height = stbi__get16le(s);
6263 int tga_bits_per_pixel = stbi__get8(s);
6264 int tga_comp, tga_rgb16 = 0;
6265 int tga_inverted = stbi__get8(s);
6268 unsigned char * tga_data;
6269 unsigned char * tga_palette = NULL;
6271 unsigned char raw_data[4] = {0};
6273 int RLE_repeating = 0;
6274 int read_next_pixel = 1;
6276 STBI_NOTUSED(tga_x_origin);
6277 STBI_NOTUSED(tga_y_origin);
6279 if (tga_height > STBI_MAX_DIMENSIONS)
6280 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6281 if (tga_width > STBI_MAX_DIMENSIONS)
6282 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6285 if (tga_image_type >= 8) {
6286 tga_image_type -= 8;
6289 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
6293 tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
6295 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
6298 return stbi__errpuc(
"bad format",
"Can't find out TGA pixelformat");
6306 if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
6307 return stbi__errpuc(
"too large",
"Corrupt TGA");
6309 tga_data = (
unsigned char *)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
6311 return stbi__errpuc(
"outofmem",
"Out of memory");
6314 stbi__skip(s, tga_offset);
6316 if (!tga_indexed && !tga_is_RLE && !tga_rgb16) {
6317 for (i = 0; i < tga_height; ++i) {
6318 int row = tga_inverted ? tga_height - i - 1 : i;
6319 stbi_uc * tga_row = tga_data + row * tga_width * tga_comp;
6320 stbi__getn(s, tga_row, tga_width * tga_comp);
6325 if (tga_palette_len == 0) {
6326 STBI_FREE(tga_data);
6327 return stbi__errpuc(
"bad palette",
"Corrupt TGA");
6331 stbi__skip(s, tga_palette_start);
6333 tga_palette = (
unsigned char *)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
6335 STBI_FREE(tga_data);
6336 return stbi__errpuc(
"outofmem",
"Out of memory");
6339 stbi_uc * pal_entry = tga_palette;
6340 STBI_ASSERT(tga_comp == STBI_rgb);
6341 for (i = 0; i < tga_palette_len; ++i) {
6342 stbi__tga_read_rgb16(s, pal_entry);
6343 pal_entry += tga_comp;
6345 }
else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
6346 STBI_FREE(tga_data);
6347 STBI_FREE(tga_palette);
6348 return stbi__errpuc(
"bad palette",
"Corrupt TGA");
6352 for (i = 0; i < tga_width * tga_height; ++i) {
6355 if (RLE_count == 0) {
6357 int RLE_cmd = stbi__get8(s);
6358 RLE_count = 1 + (RLE_cmd & 127);
6359 RLE_repeating = RLE_cmd >> 7;
6360 read_next_pixel = 1;
6361 }
else if (!RLE_repeating) {
6362 read_next_pixel = 1;
6365 read_next_pixel = 1;
6368 if (read_next_pixel) {
6372 int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
6373 if (pal_idx >= tga_palette_len) {
6377 pal_idx *= tga_comp;
6378 for (j = 0; j < tga_comp; ++j) {
6379 raw_data[j] = tga_palette[pal_idx + j];
6381 }
else if (tga_rgb16) {
6382 STBI_ASSERT(tga_comp == STBI_rgb);
6383 stbi__tga_read_rgb16(s, raw_data);
6386 for (j = 0; j < tga_comp; ++j) {
6387 raw_data[j] = stbi__get8(s);
6391 read_next_pixel = 0;
6395 for (j = 0; j < tga_comp; ++j)
6396 tga_data[i * tga_comp + j] = raw_data[j];
6403 for (j = 0; j * 2 < tga_height; ++j) {
6404 int index1 = j * tga_width * tga_comp;
6405 int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
6406 for (i = tga_width * tga_comp; i > 0; --i) {
6407 unsigned char temp = tga_data[index1];
6408 tga_data[index1] = tga_data[index2];
6409 tga_data[index2] = temp;
6416 if (tga_palette != NULL) {
6417 STBI_FREE(tga_palette);
6422 if (tga_comp >= 3 && !tga_rgb16) {
6423 unsigned char * tga_pixel = tga_data;
6424 for (i = 0; i < tga_width * tga_height; ++i) {
6425 unsigned char temp = tga_pixel[0];
6426 tga_pixel[0] = tga_pixel[2];
6427 tga_pixel[2] = temp;
6428 tga_pixel += tga_comp;
6433 if (req_comp && req_comp != tga_comp)
6434 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
6438 tga_palette_start = tga_palette_len = tga_palette_bits = tga_x_origin = tga_y_origin = 0;
6439 STBI_NOTUSED(tga_palette_start);
6449static int stbi__psd_test(stbi__context * s) {
6450 int r = (stbi__get32be(s) == 0x38425053);
6455static int stbi__psd_decode_rle(stbi__context * s, stbi_uc * p,
int pixelCount) {
6456 int count, nleft, len;
6459 while ((nleft = pixelCount - count) > 0) {
6460 len = stbi__get8(s);
6463 }
else if (len < 128) {
6474 }
else if (len > 128) {
6481 val = stbi__get8(s);
6494static void * stbi__psd_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri,
int bpc) {
6496 int channelCount, compression;
6504 if (stbi__get32be(s) != 0x38425053)
6505 return stbi__errpuc(
"not PSD",
"Corrupt PSD image");
6508 if (stbi__get16be(s) != 1)
6509 return stbi__errpuc(
"wrong version",
"Unsupported version of PSD image");
6515 channelCount = stbi__get16be(s);
6516 if (channelCount < 0 || channelCount > 16)
6517 return stbi__errpuc(
"wrong channel count",
"Unsupported number of channels in PSD image");
6520 h = stbi__get32be(s);
6521 w = stbi__get32be(s);
6523 if (h > STBI_MAX_DIMENSIONS)
6524 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6525 if (w > STBI_MAX_DIMENSIONS)
6526 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6529 bitdepth = stbi__get16be(s);
6530 if (bitdepth != 8 && bitdepth != 16)
6531 return stbi__errpuc(
"unsupported bit depth",
"PSD bit depth is not 8 or 16 bit");
6543 if (stbi__get16be(s) != 3)
6544 return stbi__errpuc(
"wrong color format",
"PSD is not in RGB color format");
6547 stbi__skip(s, stbi__get32be(s));
6550 stbi__skip(s, stbi__get32be(s));
6553 stbi__skip(s, stbi__get32be(s));
6559 compression = stbi__get16be(s);
6560 if (compression > 1)
6561 return stbi__errpuc(
"bad compression",
"PSD has an unknown compression format");
6564 if (!stbi__mad3sizes_valid(4, w, h, 0))
6565 return stbi__errpuc(
"too large",
"Corrupt PSD");
6569 if (!compression && bitdepth == 16 && bpc == 16) {
6570 out = (stbi_uc *)stbi__malloc_mad3(8, w, h, 0);
6571 ri->bits_per_channel = 16;
6573 out = (stbi_uc *)stbi__malloc(4 * w * h);
6576 return stbi__errpuc(
"outofmem",
"Out of memory");
6594 stbi__skip(s, h * channelCount * 2);
6597 for (channel = 0; channel < 4; channel++) {
6601 if (channel >= channelCount) {
6603 for (i = 0; i < pixelCount; i++, p += 4)
6604 *p = (channel == 3 ? 255 : 0);
6607 if (!stbi__psd_decode_rle(s, p, pixelCount)) {
6609 return stbi__errpuc(
"corrupt",
"bad RLE data");
6618 for (channel = 0; channel < 4; channel++) {
6619 if (channel >= channelCount) {
6621 if (bitdepth == 16 && bpc == 16) {
6622 stbi__uint16 * q = ((stbi__uint16 *)out) + channel;
6623 stbi__uint16 val = channel == 3 ? 65535 : 0;
6624 for (i = 0; i < pixelCount; i++, q += 4)
6627 stbi_uc * p = out + channel;
6628 stbi_uc val = channel == 3 ? 255 : 0;
6629 for (i = 0; i < pixelCount; i++, p += 4)
6633 if (ri->bits_per_channel == 16) {
6634 stbi__uint16 * q = ((stbi__uint16 *)out) + channel;
6635 for (i = 0; i < pixelCount; i++, q += 4)
6636 *q = (stbi__uint16)stbi__get16be(s);
6638 stbi_uc * p = out + channel;
6639 if (bitdepth == 16) {
6640 for (i = 0; i < pixelCount; i++, p += 4)
6641 *p = (stbi_uc)(stbi__get16be(s) >> 8);
6643 for (i = 0; i < pixelCount; i++, p += 4)
6652 if (channelCount >= 4) {
6653 if (ri->bits_per_channel == 16) {
6654 for (i = 0; i < w * h; ++i) {
6655 stbi__uint16 * pixel = (stbi__uint16 *)out + 4 * i;
6656 if (pixel[3] != 0 && pixel[3] != 65535) {
6657 float a = pixel[3] / 65535.0f;
6658 float ra = 1.0f / a;
6659 float inv_a = 65535.0f * (1 - ra);
6660 pixel[0] = (stbi__uint16)(pixel[0] * ra + inv_a);
6661 pixel[1] = (stbi__uint16)(pixel[1] * ra + inv_a);
6662 pixel[2] = (stbi__uint16)(pixel[2] * ra + inv_a);
6666 for (i = 0; i < w * h; ++i) {
6667 unsigned char * pixel = out + 4 * i;
6668 if (pixel[3] != 0 && pixel[3] != 255) {
6669 float a = pixel[3] / 255.0f;
6670 float ra = 1.0f / a;
6671 float inv_a = 255.0f * (1 - ra);
6672 pixel[0] = (
unsigned char)(pixel[0] * ra + inv_a);
6673 pixel[1] = (
unsigned char)(pixel[1] * ra + inv_a);
6674 pixel[2] = (
unsigned char)(pixel[2] * ra + inv_a);
6681 if (req_comp && req_comp != 4) {
6682 if (ri->bits_per_channel == 16)
6683 out = (stbi_uc *)stbi__convert_format16((stbi__uint16 *)out, 4, req_comp, w, h);
6685 out = stbi__convert_format(out, 4, req_comp, w, h);
6707static int stbi__pic_is4(stbi__context * s,
const char * str) {
6709 for (i = 0; i < 4; ++i)
6710 if (stbi__get8(s) != (stbi_uc)str[i])
6716static int stbi__pic_test_core(stbi__context * s) {
6719 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34"))
6722 for (i = 0; i < 84; ++i)
6725 if (!stbi__pic_is4(s,
"PICT"))
6732 stbi_uc size, type, channel;
6735static stbi_uc * stbi__readval(stbi__context * s,
int channel, stbi_uc * dest) {
6738 for (i = 0; i < 4; ++i, mask >>= 1) {
6739 if (channel & mask) {
6740 if (stbi__at_eof(s))
6741 return stbi__errpuc(
"bad file",
"PIC file too short");
6742 dest[i] = stbi__get8(s);
6749static void stbi__copyval(
int channel, stbi_uc * dest,
const stbi_uc * src) {
6752 for (i = 0; i < 4; ++i, mask >>= 1)
6757static stbi_uc * stbi__pic_load_core(stbi__context * s,
int width,
int height,
int * comp, stbi_uc * result) {
6758 int act_comp = 0, num_packets = 0, y, chained;
6759 stbi__pic_packet packets[10];
6764 stbi__pic_packet * packet;
6766 if (num_packets ==
sizeof(packets) /
sizeof(packets[0]))
6767 return stbi__errpuc(
"bad format",
"too many packets");
6769 packet = &packets[num_packets++];
6771 chained = stbi__get8(s);
6772 packet->size = stbi__get8(s);
6773 packet->type = stbi__get8(s);
6774 packet->channel = stbi__get8(s);
6776 act_comp |= packet->channel;
6778 if (stbi__at_eof(s))
6779 return stbi__errpuc(
"bad file",
"file too short (reading packets)");
6780 if (packet->size != 8)
6781 return stbi__errpuc(
"bad format",
"packet isn't 8bpp");
6784 *comp = (act_comp & 0x10 ? 4 : 3);
6786 for (y = 0; y < height; ++y) {
6789 for (packet_idx = 0; packet_idx < num_packets; ++packet_idx) {
6790 stbi__pic_packet * packet = &packets[packet_idx];
6791 stbi_uc * dest = result + y * width * 4;
6793 switch (packet->type) {
6795 return stbi__errpuc(
"bad format",
"packet has bad compression type");
6800 for (x = 0; x < width; ++x, dest += 4)
6801 if (!stbi__readval(s, packet->channel, dest))
6808 int left = width, i;
6811 stbi_uc count, value[4];
6813 count = stbi__get8(s);
6814 if (stbi__at_eof(s))
6815 return stbi__errpuc(
"bad file",
"file too short (pure read count)");
6818 count = (stbi_uc)left;
6820 if (!stbi__readval(s, packet->channel, value))
6823 for (i = 0; i < count; ++i, dest += 4)
6824 stbi__copyval(packet->channel, dest, value);
6832 int count = stbi__get8(s), i;
6833 if (stbi__at_eof(s))
6834 return stbi__errpuc(
"bad file",
"file too short (mixed read count)");
6840 count = stbi__get16be(s);
6844 return stbi__errpuc(
"bad file",
"scanline overrun");
6846 if (!stbi__readval(s, packet->channel, value))
6849 for (i = 0; i < count; ++i, dest += 4)
6850 stbi__copyval(packet->channel, dest, value);
6854 return stbi__errpuc(
"bad file",
"scanline overrun");
6856 for (i = 0; i < count; ++i, dest += 4)
6857 if (!stbi__readval(s, packet->channel, dest))
6871static void * stbi__pic_load(stbi__context * s,
int * px,
int * py,
int * comp,
int req_comp, stbi__result_info * ri) {
6873 int i, x, y, internal_comp;
6877 comp = &internal_comp;
6879 for (i = 0; i < 92; ++i)
6882 x = stbi__get16be(s);
6883 y = stbi__get16be(s);
6885 if (y > STBI_MAX_DIMENSIONS)
6886 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6887 if (x > STBI_MAX_DIMENSIONS)
6888 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
6890 if (stbi__at_eof(s))
6891 return stbi__errpuc(
"bad file",
"file too short (pic header)");
6892 if (!stbi__mad3sizes_valid(x, y, 4, 0))
6893 return stbi__errpuc(
"too large",
"PIC image too large to decode");
6900 result = (stbi_uc *)stbi__malloc_mad3(x, y, 4, 0);
6902 return stbi__errpuc(
"outofmem",
"Out of memory");
6903 memset(result, 0xff, x * y * 4);
6905 if (!stbi__pic_load_core(s, x, y, comp, result)) {
6913 result = stbi__convert_format(result, 4, req_comp, x, y);
6918static int stbi__pic_test(stbi__context * s) {
6919 int r = stbi__pic_test_core(s);
6938 stbi_uc * background;
6940 int flags, bgindex, ratio, transparent, eflags;
6941 stbi_uc pal[256][4];
6942 stbi_uc lpal[256][4];
6943 stbi__gif_lzw codes[8192];
6944 stbi_uc * color_table;
6947 int start_x, start_y;
6954static int stbi__gif_test_raw(stbi__context * s) {
6956 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
6959 if (sz !=
'9' && sz !=
'7')
6961 if (stbi__get8(s) !=
'a')
6966static int stbi__gif_test(stbi__context * s) {
6967 int r = stbi__gif_test_raw(s);
6972static void stbi__gif_parse_colortable(stbi__context * s, stbi_uc pal[256][4],
int num_entries,
int transp) {
6974 for (i = 0; i < num_entries; ++i) {
6975 pal[i][2] = stbi__get8(s);
6976 pal[i][1] = stbi__get8(s);
6977 pal[i][0] = stbi__get8(s);
6978 pal[i][3] = transp == i ? 0 : 255;
6982static int stbi__gif_header(stbi__context * s, stbi__gif * g,
int * comp,
int is_info) {
6984 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
6985 return stbi__err(
"not GIF",
"Corrupt GIF");
6987 version = stbi__get8(s);
6988 if (version !=
'7' && version !=
'9')
6989 return stbi__err(
"not GIF",
"Corrupt GIF");
6990 if (stbi__get8(s) !=
'a')
6991 return stbi__err(
"not GIF",
"Corrupt GIF");
6993 stbi__g_failure_reason =
"";
6994 g->w = stbi__get16le(s);
6995 g->h = stbi__get16le(s);
6996 g->flags = stbi__get8(s);
6997 g->bgindex = stbi__get8(s);
6998 g->ratio = stbi__get8(s);
6999 g->transparent = -1;
7001 if (g->w > STBI_MAX_DIMENSIONS)
7002 return stbi__err(
"too large",
"Very large image (corrupt?)");
7003 if (g->h > STBI_MAX_DIMENSIONS)
7004 return stbi__err(
"too large",
"Very large image (corrupt?)");
7012 if (g->flags & 0x80)
7013 stbi__gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1);
7018static int stbi__gif_info_raw(stbi__context * s,
int * x,
int * y,
int * comp) {
7019 stbi__gif * g = (stbi__gif *)stbi__malloc(
sizeof(stbi__gif));
7021 return stbi__err(
"outofmem",
"Out of memory");
7022 if (!stbi__gif_header(s, g, comp, 1)) {
7035static void stbi__out_gif_code(stbi__gif * g, stbi__uint16 code) {
7041 if (g->codes[code].prefix >= 0)
7042 stbi__out_gif_code(g, g->codes[code].prefix);
7044 if (g->cur_y >= g->max_y)
7047 idx = g->cur_x + g->cur_y;
7049 g->history[idx / 4] = 1;
7051 c = &g->color_table[g->codes[code].suffix * 4];
7060 if (g->cur_x >= g->max_x) {
7061 g->cur_x = g->start_x;
7062 g->cur_y += g->step;
7064 while (g->cur_y >= g->max_y && g->parse > 0) {
7065 g->step = (1 << g->parse) * g->line_size;
7066 g->cur_y = g->start_y + (g->step >> 1);
7072static stbi_uc * stbi__process_gif_raster(stbi__context * s, stbi__gif * g) {
7074 stbi__int32 len, init_code;
7076 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
7079 lzw_cs = stbi__get8(s);
7082 clear = 1 << lzw_cs;
7084 codesize = lzw_cs + 1;
7085 codemask = (1 << codesize) - 1;
7088 for (init_code = 0; init_code < clear; init_code++) {
7089 g->codes[init_code].prefix = -1;
7090 g->codes[init_code].first = (stbi_uc)init_code;
7091 g->codes[init_code].suffix = (stbi_uc)init_code;
7100 if (valid_bits < codesize) {
7102 len = stbi__get8(s);
7107 bits |= (stbi__int32)stbi__get8(s) << valid_bits;
7110 stbi__int32 code = bits & codemask;
7112 valid_bits -= codesize;
7114 if (code == clear) {
7115 codesize = lzw_cs + 1;
7116 codemask = (1 << codesize) - 1;
7120 }
else if (code == clear + 1) {
7122 while ((len = stbi__get8(s)) > 0)
7125 }
else if (code <= avail) {
7127 return stbi__errpuc(
"no clear code",
"Corrupt GIF");
7131 p = &g->codes[avail++];
7133 return stbi__errpuc(
"too many codes",
"Corrupt GIF");
7136 p->prefix = (stbi__int16)oldcode;
7137 p->first = g->codes[oldcode].first;
7138 p->suffix = (code == avail) ? p->first : g->codes[code].first;
7139 }
else if (code == avail)
7140 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
7142 stbi__out_gif_code(g, (stbi__uint16)code);
7144 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
7146 codemask = (1 << codesize) - 1;
7151 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
7159static stbi_uc * stbi__gif_load_next(stbi__context * s, stbi__gif * g,
int * comp,
int req_comp, stbi_uc * two_back) {
7164 STBI_NOTUSED(req_comp);
7169 if (!stbi__gif_header(s, g, comp, 0))
7171 if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
7172 return stbi__errpuc(
"too large",
"GIF image is too large");
7173 pcount = g->w * g->h;
7174 g->out = (stbi_uc *)stbi__malloc(4 * pcount);
7175 g->background = (stbi_uc *)stbi__malloc(4 * pcount);
7176 g->history = (stbi_uc *)stbi__malloc(pcount);
7177 if (!g->out || !g->background || !g->history)
7178 return stbi__errpuc(
"outofmem",
"Out of memory");
7183 memset(g->out, 0x00, 4 * pcount);
7184 memset(g->background, 0x00, 4 * pcount);
7185 memset(g->history, 0x00, pcount);
7189 dispose = (g->eflags & 0x1C) >> 2;
7190 pcount = g->w * g->h;
7192 if ((dispose == 3) && (two_back == 0)) {
7197 for (pi = 0; pi < pcount; ++pi) {
7198 if (g->history[pi]) {
7199 memcpy(&g->out[pi * 4], &two_back[pi * 4], 4);
7202 }
else if (dispose == 2) {
7204 for (pi = 0; pi < pcount; ++pi) {
7205 if (g->history[pi]) {
7206 memcpy(&g->out[pi * 4], &g->background[pi * 4], 4);
7217 memcpy(g->background, g->out, 4 * g->w * g->h);
7221 memset(g->history, 0x00, g->w * g->h);
7224 int tag = stbi__get8(s);
7228 stbi__int32 x, y, w, h;
7231 x = stbi__get16le(s);
7232 y = stbi__get16le(s);
7233 w = stbi__get16le(s);
7234 h = stbi__get16le(s);
7235 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
7236 return stbi__errpuc(
"bad Image Descriptor",
"Corrupt GIF");
7238 g->line_size = g->w * 4;
7240 g->start_y = y * g->line_size;
7241 g->max_x = g->start_x + w * 4;
7242 g->max_y = g->start_y + h * g->line_size;
7243 g->cur_x = g->start_x;
7244 g->cur_y = g->start_y;
7251 g->cur_y = g->max_y;
7253 g->lflags = stbi__get8(s);
7255 if (g->lflags & 0x40) {
7256 g->step = 8 * g->line_size;
7259 g->step = g->line_size;
7263 if (g->lflags & 0x80) {
7264 stbi__gif_parse_colortable(s, g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
7265 g->color_table = (stbi_uc *)g->lpal;
7266 }
else if (g->flags & 0x80) {
7267 g->color_table = (stbi_uc *)g->pal;
7269 return stbi__errpuc(
"missing color table",
"Corrupt GIF");
7271 o = stbi__process_gif_raster(s, g);
7276 pcount = g->w * g->h;
7277 if (first_frame && (g->bgindex > 0)) {
7279 for (pi = 0; pi < pcount; ++pi) {
7280 if (g->history[pi] == 0) {
7281 g->pal[g->bgindex][3] =
7283 memcpy(&g->out[pi * 4], &g->pal[g->bgindex], 4);
7294 int ext = stbi__get8(s);
7296 len = stbi__get8(s);
7298 g->eflags = stbi__get8(s);
7299 g->delay = 10 * stbi__get16le(s);
7302 if (g->transparent >= 0) {
7303 g->pal[g->transparent][3] = 255;
7305 if (g->eflags & 0x01) {
7306 g->transparent = stbi__get8(s);
7307 if (g->transparent >= 0) {
7308 g->pal[g->transparent][3] = 0;
7313 g->transparent = -1;
7320 while ((len = stbi__get8(s)) != 0) {
7327 return (stbi_uc *)s;
7330 return stbi__errpuc(
"unknown code",
"Corrupt GIF");
7335static void * stbi__load_gif_main_outofmem(stbi__gif * g, stbi_uc * out,
int ** delays) {
7337 STBI_FREE(g->history);
7338 STBI_FREE(g->background);
7342 if (delays && *delays)
7344 return stbi__errpuc(
"outofmem",
"Out of memory");
7347static void * stbi__load_gif_main(stbi__context * s,
int ** delays,
int * x,
int * y,
int * z,
int * comp,
int req_comp) {
7348 if (stbi__gif_test(s)) {
7352 stbi_uc * two_back = 0;
7356 int delays_size = 0;
7358 STBI_NOTUSED(out_size);
7359 STBI_NOTUSED(delays_size);
7361 memset(&g, 0,
sizeof(g));
7367 u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
7368 if (u == (stbi_uc *)s)
7375 stride = g.w * g.h * 4;
7378 void * tmp = (stbi_uc *)STBI_REALLOC_SIZED(out, out_size, layers * stride);
7380 return stbi__load_gif_main_outofmem(&g, out, delays);
7382 out = (stbi_uc *)tmp;
7383 out_size = layers * stride;
7387 int * new_delays = (
int *)STBI_REALLOC_SIZED(*delays, delays_size,
sizeof(
int) * layers);
7389 return stbi__load_gif_main_outofmem(&g, out, delays);
7390 *delays = new_delays;
7391 delays_size = layers *
sizeof(int);
7394 out = (stbi_uc *)stbi__malloc(layers * stride);
7396 return stbi__load_gif_main_outofmem(&g, out, delays);
7397 out_size = layers * stride;
7399 *delays = (
int *)stbi__malloc(layers *
sizeof(
int));
7401 return stbi__load_gif_main_outofmem(&g, out, delays);
7402 delays_size = layers *
sizeof(int);
7405 memcpy(out + ((layers - 1) * stride), u, stride);
7407 two_back = out - 2 * stride;
7411 (*delays)[layers - 1U] = g.delay;
7418 STBI_FREE(g.history);
7419 STBI_FREE(g.background);
7422 if (req_comp && req_comp != 4)
7423 out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
7428 return stbi__errpuc(
"not GIF",
"Image was not as a gif type.");
7432static void * stbi__gif_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
7435 memset(&g, 0,
sizeof(g));
7438 u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
7439 if (u == (stbi_uc *)s)
7447 if (req_comp && req_comp != 4)
7448 u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
7455 STBI_FREE(g.history);
7456 STBI_FREE(g.background);
7461static int stbi__gif_info(stbi__context * s,
int * x,
int * y,
int * comp) {
return stbi__gif_info_raw(s, x, y, comp); }
7468static int stbi__hdr_test_core(stbi__context * s,
const char * signature) {
7470 for (i = 0; signature[i]; ++i)
7471 if (stbi__get8(s) != signature[i])
7477static int stbi__hdr_test(stbi__context * s) {
7478 int r = stbi__hdr_test_core(s,
"#?RADIANCE\n");
7481 r = stbi__hdr_test_core(s,
"#?RGBE\n");
7487#define STBI__HDR_BUFLEN 1024
7488static char * stbi__hdr_gettoken(stbi__context * z,
char * buffer) {
7492 c = (char)stbi__get8(z);
7494 while (!stbi__at_eof(z) && c !=
'\n') {
7496 if (len == STBI__HDR_BUFLEN - 1) {
7498 while (!stbi__at_eof(z) && stbi__get8(z) !=
'\n')
7502 c = (char)stbi__get8(z);
7509static void stbi__hdr_convert(
float * output, stbi_uc * input,
int req_comp) {
7510 if (input[3] != 0) {
7513 f1 = (float)ldexp(1.0f, input[3] - (
int)(128 + 8));
7515 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
7517 output[0] = input[0] * f1;
7518 output[1] = input[1] * f1;
7519 output[2] = input[2] * f1;
7530 output[0] = output[1] = output[2] = 0;
7541static float * stbi__hdr_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
7542 char buffer[STBI__HDR_BUFLEN];
7549 unsigned char count, value;
7550 int i, j, k, c1, c2, z;
7551 const char * headerToken;
7555 headerToken = stbi__hdr_gettoken(s, buffer);
7556 if (strcmp(headerToken,
"#?RADIANCE") != 0 && strcmp(headerToken,
"#?RGBE") != 0)
7557 return stbi__errpf(
"not HDR",
"Corrupt HDR image");
7561 token = stbi__hdr_gettoken(s, buffer);
7564 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0)
7569 return stbi__errpf(
"unsupported format",
"Unsupported HDR format");
7573 token = stbi__hdr_gettoken(s, buffer);
7574 if (strncmp(token,
"-Y ", 3))
7575 return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
7577 height = (int)strtol(token, &token, 10);
7578 while (*token ==
' ')
7580 if (strncmp(token,
"+X ", 3))
7581 return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
7583 width = (int)strtol(token, NULL, 10);
7585 if (height > STBI_MAX_DIMENSIONS)
7586 return stbi__errpf(
"too large",
"Very large image (corrupt?)");
7587 if (width > STBI_MAX_DIMENSIONS)
7588 return stbi__errpf(
"too large",
"Very large image (corrupt?)");
7598 if (!stbi__mad4sizes_valid(width, height, req_comp,
sizeof(
float), 0))
7599 return stbi__errpf(
"too large",
"HDR image is too large");
7602 hdr_data = (
float *)stbi__malloc_mad4(width, height, req_comp,
sizeof(
float), 0);
7604 return stbi__errpf(
"outofmem",
"Out of memory");
7608 if (width < 8 || width >= 32768) {
7610 for (j = 0; j < height; ++j) {
7611 for (i = 0; i < width; ++i) {
7614 stbi__getn(s, rgbe, 4);
7615 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
7622 for (j = 0; j < height; ++j) {
7625 len = stbi__get8(s);
7626 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
7630 rgbe[0] = (stbi_uc)c1;
7631 rgbe[1] = (stbi_uc)c2;
7632 rgbe[2] = (stbi_uc)len;
7633 rgbe[3] = (stbi_uc)stbi__get8(s);
7634 stbi__hdr_convert(hdr_data, rgbe, req_comp);
7637 STBI_FREE(scanline);
7638 goto main_decode_loop;
7641 len |= stbi__get8(s);
7643 STBI_FREE(hdr_data);
7644 STBI_FREE(scanline);
7645 return stbi__errpf(
"invalid decoded scanline length",
"corrupt HDR");
7647 if (scanline == NULL) {
7648 scanline = (stbi_uc *)stbi__malloc_mad2(width, 4, 0);
7650 STBI_FREE(hdr_data);
7651 return stbi__errpf(
"outofmem",
"Out of memory");
7655 for (k = 0; k < 4; ++k) {
7658 while ((nleft = width - i) > 0) {
7659 count = stbi__get8(s);
7662 value = stbi__get8(s);
7664 if ((count == 0) || (count > nleft)) {
7665 STBI_FREE(hdr_data);
7666 STBI_FREE(scanline);
7667 return stbi__errpf(
"corrupt",
"bad RLE data in HDR");
7669 for (z = 0; z < count; ++z)
7670 scanline[i++ * 4 + k] = value;
7673 if ((count == 0) || (count > nleft)) {
7674 STBI_FREE(hdr_data);
7675 STBI_FREE(scanline);
7676 return stbi__errpf(
"corrupt",
"bad RLE data in HDR");
7678 for (z = 0; z < count; ++z)
7679 scanline[i++ * 4 + k] = stbi__get8(s);
7683 for (i = 0; i < width; ++i)
7684 stbi__hdr_convert(hdr_data + (j * width + i) * req_comp, scanline + i * 4, req_comp);
7687 STBI_FREE(scanline);
7693static int stbi__hdr_info(stbi__context * s,
int * x,
int * y,
int * comp) {
7694 char buffer[STBI__HDR_BUFLEN];
7706 if (stbi__hdr_test(s) == 0) {
7712 token = stbi__hdr_gettoken(s, buffer);
7715 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0)
7723 token = stbi__hdr_gettoken(s, buffer);
7724 if (strncmp(token,
"-Y ", 3)) {
7729 *y = (int)strtol(token, &token, 10);
7730 while (*token ==
' ')
7732 if (strncmp(token,
"+X ", 3)) {
7737 *x = (int)strtol(token, NULL, 10);
7744static int stbi__bmp_info(stbi__context * s,
int * x,
int * y,
int * comp) {
7746 stbi__bmp_data info;
7749 p = stbi__bmp_parse_header(s, &info);
7759 if (info.bpp == 24 && info.ma == 0xff000000)
7762 *comp = info.ma ? 4 : 3;
7769static int stbi__psd_info(stbi__context * s,
int * x,
int * y,
int * comp) {
7770 int channelCount, dummy, depth;
7777 if (stbi__get32be(s) != 0x38425053) {
7781 if (stbi__get16be(s) != 1) {
7786 channelCount = stbi__get16be(s);
7787 if (channelCount < 0 || channelCount > 16) {
7791 *y = stbi__get32be(s);
7792 *x = stbi__get32be(s);
7793 depth = stbi__get16be(s);
7794 if (depth != 8 && depth != 16) {
7798 if (stbi__get16be(s) != 3) {
7806static int stbi__psd_is16(stbi__context * s) {
7807 int channelCount, depth;
7808 if (stbi__get32be(s) != 0x38425053) {
7812 if (stbi__get16be(s) != 1) {
7817 channelCount = stbi__get16be(s);
7818 if (channelCount < 0 || channelCount > 16) {
7822 STBI_NOTUSED(stbi__get32be(s));
7823 STBI_NOTUSED(stbi__get32be(s));
7824 depth = stbi__get16be(s);
7834static int stbi__pic_info(stbi__context * s,
int * x,
int * y,
int * comp) {
7835 int act_comp = 0, num_packets = 0, chained, dummy;
7836 stbi__pic_packet packets[10];
7845 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34")) {
7852 *x = stbi__get16be(s);
7853 *y = stbi__get16be(s);
7854 if (stbi__at_eof(s)) {
7858 if ((*x) != 0 && (1 << 28) / (*x) < (*y)) {
7866 stbi__pic_packet * packet;
7868 if (num_packets ==
sizeof(packets) /
sizeof(packets[0]))
7871 packet = &packets[num_packets++];
7872 chained = stbi__get8(s);
7873 packet->size = stbi__get8(s);
7874 packet->type = stbi__get8(s);
7875 packet->channel = stbi__get8(s);
7876 act_comp |= packet->channel;
7878 if (stbi__at_eof(s)) {
7882 if (packet->size != 8) {
7888 *comp = (act_comp & 0x10 ? 4 : 3);
7907static int stbi__pnm_test(stbi__context * s) {
7909 p = (char)stbi__get8(s);
7910 t = (char)stbi__get8(s);
7911 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
7918static void * stbi__pnm_load(stbi__context * s,
int * x,
int * y,
int * comp,
int req_comp, stbi__result_info * ri) {
7922 ri->bits_per_channel = stbi__pnm_info(s, (
int *)&s->img_x, (
int *)&s->img_y, (
int *)&s->img_n);
7923 if (ri->bits_per_channel == 0)
7926 if (s->img_y > STBI_MAX_DIMENSIONS)
7927 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
7928 if (s->img_x > STBI_MAX_DIMENSIONS)
7929 return stbi__errpuc(
"too large",
"Very large image (corrupt?)");
7936 if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
7937 return stbi__errpuc(
"too large",
"PNM too large");
7939 out = (stbi_uc *)stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
7941 return stbi__errpuc(
"outofmem",
"Out of memory");
7942 if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
7944 return stbi__errpuc(
"bad PNM",
"PNM file truncated");
7947 if (req_comp && req_comp != s->img_n) {
7948 if (ri->bits_per_channel == 16) {
7949 out = (stbi_uc *)stbi__convert_format16((stbi__uint16 *)out, s->img_n, req_comp, s->img_x, s->img_y);
7951 out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
7959static int stbi__pnm_isspace(
char c) {
return c ==
' ' || c ==
'\t' || c ==
'\n' || c ==
'\v' || c ==
'\f' || c ==
'\r'; }
7961static void stbi__pnm_skip_whitespace(stbi__context * s,
char * c) {
7963 while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
7964 *c = (char)stbi__get8(s);
7966 if (stbi__at_eof(s) || *c !=
'#')
7969 while (!stbi__at_eof(s) && *c !=
'\n' && *c !=
'\r')
7970 *c = (
char)stbi__get8(s);
7974static int stbi__pnm_isdigit(
char c) {
return c >=
'0' && c <=
'9'; }
7976static int stbi__pnm_getinteger(stbi__context * s,
char * c) {
7979 while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
7980 value = value * 10 + (*c -
'0');
7981 *c = (char)stbi__get8(s);
7982 if ((value > 214748364) || (value == 214748364 && *c >
'7'))
7983 return stbi__err(
"integer parse overflow",
"Parsing an integer in the PPM header overflowed a 32-bit int");
7989static int stbi__pnm_info(stbi__context * s,
int * x,
int * y,
int * comp) {
8003 p = (char)stbi__get8(s);
8004 t = (char)stbi__get8(s);
8005 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
8010 *comp = (t ==
'6') ? 3 : 1;
8012 c = (char)stbi__get8(s);
8013 stbi__pnm_skip_whitespace(s, &c);
8015 *x = stbi__pnm_getinteger(s, &c);
8017 return stbi__err(
"invalid width",
"PPM image header had zero or overflowing width");
8018 stbi__pnm_skip_whitespace(s, &c);
8020 *y = stbi__pnm_getinteger(s, &c);
8022 return stbi__err(
"invalid width",
"PPM image header had zero or overflowing width");
8023 stbi__pnm_skip_whitespace(s, &c);
8025 maxv = stbi__pnm_getinteger(s, &c);
8027 return stbi__err(
"max value > 65535",
"PPM image supports only 8-bit and 16-bit images");
8028 else if (maxv > 255)
8034static int stbi__pnm_is16(stbi__context * s) {
8035 if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
8041static int stbi__info_main(stbi__context * s,
int * x,
int * y,
int * comp) {
8043 if (stbi__jpeg_info(s, x, y, comp))
8048 if (stbi__png_info(s, x, y, comp))
8053 if (stbi__gif_info(s, x, y, comp))
8058 if (stbi__bmp_info(s, x, y, comp))
8063 if (stbi__psd_info(s, x, y, comp))
8068 if (stbi__pic_info(s, x, y, comp))
8073 if (stbi__pnm_info(s, x, y, comp))
8078 if (stbi__hdr_info(s, x, y, comp))
8084 if (stbi__tga_info(s, x, y, comp))
8087 return stbi__err(
"unknown image type",
"Image not of any known type, or corrupt");
8090static int stbi__is_16_main(stbi__context * s) {
8092 if (stbi__png_is16(s))
8097 if (stbi__psd_is16(s))
8102 if (stbi__pnm_is16(s))
8108#ifndef STBI_NO_STDIO
8109STBIDEF
int stbi_info(
char const * filename,
int * x,
int * y,
int * comp) {
8110 FILE * f = stbi__fopen(filename,
"rb");
8113 return stbi__err(
"can't fopen",
"Unable to open file");
8114 result = stbi_info_from_file(f, x, y, comp);
8119STBIDEF
int stbi_info_from_file(FILE * f,
int * x,
int * y,
int * comp) {
8122 long pos = ftell(f);
8123 stbi__start_file(&s, f);
8124 r = stbi__info_main(&s, x, y, comp);
8125 fseek(f, pos, SEEK_SET);
8129STBIDEF
int stbi_is_16_bit(
char const * filename) {
8130 FILE * f = stbi__fopen(filename,
"rb");
8133 return stbi__err(
"can't fopen",
"Unable to open file");
8134 result = stbi_is_16_bit_from_file(f);
8139STBIDEF
int stbi_is_16_bit_from_file(FILE * f) {
8142 long pos = ftell(f);
8143 stbi__start_file(&s, f);
8144 r = stbi__is_16_main(&s);
8145 fseek(f, pos, SEEK_SET);
8150STBIDEF
int stbi_info_from_memory(stbi_uc
const * buffer,
int len,
int * x,
int * y,
int * comp) {
8152 stbi__start_mem(&s, buffer, len);
8153 return stbi__info_main(&s, x, y, comp);
8156STBIDEF
int stbi_info_from_callbacks(
stbi_io_callbacks const * c,
void * user,
int * x,
int * y,
int * comp) {
8159 return stbi__info_main(&s, x, y, comp);
8162STBIDEF
int stbi_is_16_bit_from_memory(stbi_uc
const * buffer,
int len) {
8164 stbi__start_mem(&s, buffer, len);
8165 return stbi__is_16_main(&s);
8168STBIDEF
int stbi_is_16_bit_from_callbacks(
stbi_io_callbacks const * c,
void * user) {
8171 return stbi__is_16_main(&s);
Definition stb_image.h:408