111 #ifndef STBI_INCLUDE_STB_IMAGE_H
112 #define STBI_INCLUDE_STB_IMAGE_H
320 #ifndef STBI_NO_STDIO
322 #endif // STBI_NO_STDIO
324 #define STBI_VERSION 1
345 #ifdef STB_IMAGE_STATIC
346 #define STBIDEF static
348 #define STBIDEF extern
376 #ifndef STBI_NO_STDIO
386 #ifdef STBI_WINDOWS_UTF8
387 STBIDEF int stbi_convert_wchar_to_utf8(
char *
buffer,
size_t bufferlen,
const wchar_t* input);
398 #ifndef STBI_NO_STDIO
407 #ifndef STBI_NO_LINEAR
411 #ifndef STBI_NO_STDIO
420 #endif // STBI_NO_HDR
422 #ifndef STBI_NO_LINEAR
425 #endif // STBI_NO_LINEAR
430 #ifndef STBI_NO_STDIO
433 #endif // STBI_NO_STDIO
449 #ifndef STBI_NO_STDIO
488 #endif // STBI_INCLUDE_STB_IMAGE_H
490 #ifdef STB_IMAGE_IMPLEMENTATION
492 #if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
493 || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
494 || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
495 || defined(STBI_ONLY_ZLIB)
496 #ifndef STBI_ONLY_JPEG
499 #ifndef STBI_ONLY_PNG
502 #ifndef STBI_ONLY_BMP
505 #ifndef STBI_ONLY_PSD
508 #ifndef STBI_ONLY_TGA
511 #ifndef STBI_ONLY_GIF
514 #ifndef STBI_ONLY_HDR
517 #ifndef STBI_ONLY_PIC
520 #ifndef STBI_ONLY_PNM
525 #if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
536 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
540 #ifndef STBI_NO_STDIO
546 #define STBI_ASSERT(x) assert(x)
550 #define STBI_EXTERN extern "C"
552 #define STBI_EXTERN extern
558 #define stbi_inline inline
563 #define stbi_inline __forceinline
568 typedef unsigned short stbi__uint16;
569 typedef signed short stbi__int16;
570 typedef unsigned int stbi__uint32;
571 typedef signed int stbi__int32;
574 typedef uint16_t stbi__uint16;
575 typedef int16_t stbi__int16;
576 typedef uint32_t stbi__uint32;
577 typedef int32_t stbi__int32;
581 typedef unsigned char validate_uint32[
sizeof(stbi__uint32)==4 ? 1 : -1];
584 #define STBI_NOTUSED(v) (void)(v)
586 #define STBI_NOTUSED(v) (void)sizeof(v)
590 #define STBI_HAS_LROTL
593 #ifdef STBI_HAS_LROTL
594 #define stbi_lrot(x,y) _lrotl(x,y)
596 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
599 #if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
601 #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
604 #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
608 #define STBI_MALLOC(sz) malloc(sz)
609 #define STBI_REALLOC(p,newsz) realloc(p,newsz)
610 #define STBI_FREE(p) free(p)
613 #ifndef STBI_REALLOC_SIZED
614 #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
618 #if defined(__x86_64__) || defined(_M_X64)
619 #define STBI__X64_TARGET
620 #elif defined(__i386) || defined(_M_IX86)
621 #define STBI__X86_TARGET
624 #if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
635 #if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
650 #if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
652 #include <emmintrin.h>
656 #if _MSC_VER >= 1400 // not VC6
658 static int stbi__cpuid3(
void)
665 static int stbi__cpuid3(
void)
677 #define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
679 #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
680 static int stbi__sse2_available(
void)
682 int info3 = stbi__cpuid3();
683 return ((info3 >> 26) & 1) != 0;
687 #else // assume GCC-style if not VC++
688 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
690 #if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
691 static int stbi__sse2_available(
void)
704 #if defined(STBI_NO_SIMD) && defined(STBI_NEON)
709 #include <arm_neon.h>
711 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
714 #ifndef STBI_SIMD_ALIGN
715 #define STBI_SIMD_ALIGN(type, name) type name
726 stbi__uint32 img_x, img_y;
727 int img_n, img_out_n;
732 int read_from_callbacks;
736 stbi_uc *img_buffer, *img_buffer_end;
737 stbi_uc *img_buffer_original, *img_buffer_original_end;
741 static void stbi__refill_buffer(stbi__context *
s);
744 static void stbi__start_mem(stbi__context *
s,
stbi_uc const *
buffer,
int len)
747 s->read_from_callbacks = 0;
748 s->img_buffer = s->img_buffer_original = (
stbi_uc *) buffer;
749 s->img_buffer_end = s->img_buffer_original_end = (
stbi_uc *) buffer+len;
756 s->io_user_data = user;
757 s->buflen =
sizeof(s->buffer_start);
758 s->read_from_callbacks = 1;
759 s->img_buffer_original = s->buffer_start;
760 stbi__refill_buffer(s);
761 s->img_buffer_original_end = s->img_buffer_end;
764 #ifndef STBI_NO_STDIO
766 static int stbi__stdio_read(
void *user,
char *
data,
int size)
768 return (
int) fread(data,1,size,(FILE*) user);
771 static void stbi__stdio_skip(
void *user,
int n)
776 static int stbi__stdio_eof(
void *user)
778 return feof((FILE*) user);
788 static void stbi__start_file(stbi__context *
s, FILE *
f)
790 stbi__start_callbacks(s, &stbi__stdio_callbacks, (
void *) f);
795 #endif // !STBI_NO_STDIO
797 static void stbi__rewind(stbi__context *s)
802 s->img_buffer = s->img_buffer_original;
803 s->img_buffer_end = s->img_buffer_original_end;
814 int bits_per_channel;
820 static int stbi__jpeg_test(stbi__context *s);
821 static void *stbi__jpeg_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
822 static int stbi__jpeg_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
826 static int stbi__png_test(stbi__context *s);
827 static void *stbi__png_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
828 static int stbi__png_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
829 static int stbi__png_is16(stbi__context *s);
833 static int stbi__bmp_test(stbi__context *s);
834 static void *stbi__bmp_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
835 static int stbi__bmp_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
839 static int stbi__tga_test(stbi__context *s);
840 static void *stbi__tga_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
841 static int stbi__tga_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
845 static int stbi__psd_test(stbi__context *s);
846 static void *stbi__psd_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc);
847 static int stbi__psd_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
848 static int stbi__psd_is16(stbi__context *s);
852 static int stbi__hdr_test(stbi__context *s);
853 static float *stbi__hdr_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
854 static int stbi__hdr_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
858 static int stbi__pic_test(stbi__context *s);
859 static void *stbi__pic_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
860 static int stbi__pic_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
864 static int stbi__gif_test(stbi__context *s);
865 static void *stbi__gif_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
866 static void *stbi__load_gif_main(stbi__context *s,
int **delays,
int *
x,
int *
y,
int *
z,
int *comp,
int req_comp);
867 static int stbi__gif_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
871 static int stbi__pnm_test(stbi__context *s);
872 static void *stbi__pnm_load(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri);
873 static int stbi__pnm_info(stbi__context *s,
int *
x,
int *
y,
int *comp);
877 static const char *stbi__g_failure_reason;
881 return stbi__g_failure_reason;
884 static int stbi__err(
const char *str)
886 stbi__g_failure_reason = str;
890 static void *stbi__malloc(
size_t size)
892 return STBI_MALLOC(size);
907 static int stbi__addsizes_valid(
int a,
int b)
914 return a <= INT_MAX -
b;
919 static int stbi__mul2sizes_valid(
int a,
int b)
921 if (a < 0 || b < 0)
return 0;
922 if (b == 0)
return 1;
924 return a <= INT_MAX/
b;
928 static int stbi__mad2sizes_valid(
int a,
int b,
int add)
930 return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
934 static int stbi__mad3sizes_valid(
int a,
int b,
int c,
int add)
936 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
937 stbi__addsizes_valid(a*b*c, add);
941 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
942 static int stbi__mad4sizes_valid(
int a,
int b,
int c,
int d,
int add)
944 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
945 stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
950 static void *stbi__malloc_mad2(
int a,
int b,
int add)
952 if (!stbi__mad2sizes_valid(a, b, add))
return NULL;
953 return stbi__malloc(a*b + add);
956 static void *stbi__malloc_mad3(
int a,
int b,
int c,
int add)
958 if (!stbi__mad3sizes_valid(a, b, c, add))
return NULL;
959 return stbi__malloc(a*b*c + add);
962 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
963 static void *stbi__malloc_mad4(
int a,
int b,
int c,
int d,
int add)
965 if (!stbi__mad4sizes_valid(a, b, c, d, add))
return NULL;
966 return stbi__malloc(a*b*c*d + add);
974 #ifdef STBI_NO_FAILURE_STRINGS
975 #define stbi__err(x,y) 0
976 #elif defined(STBI_FAILURE_USERMSG)
977 #define stbi__err(x,y) stbi__err(y)
979 #define stbi__err(x,y) stbi__err(x)
982 #define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
983 #define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
987 STBI_FREE(retval_from_stbi_load);
990 #ifndef STBI_NO_LINEAR
991 static float *stbi__ldr_to_hdr(
stbi_uc *data,
int x,
int y,
int comp);
995 static stbi_uc *stbi__hdr_to_ldr(
float *data,
int x,
int y,
int comp);
998 static int stbi__vertically_flip_on_load = 0;
1002 stbi__vertically_flip_on_load = flag_true_if_should_flip;
1005 static void *stbi__load_main(stbi__context *s,
int *
x,
int *
y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc)
1007 memset(ri, 0,
sizeof(*ri));
1008 ri->bits_per_channel = 8;
1009 ri->channel_order = STBI_ORDER_RGB;
1010 ri->num_channels = 0;
1012 #ifndef STBI_NO_JPEG
1013 if (stbi__jpeg_test(s))
return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
1016 if (stbi__png_test(s))
return stbi__png_load(s,x,y,comp,req_comp, ri);
1019 if (stbi__bmp_test(s))
return stbi__bmp_load(s,x,y,comp,req_comp, ri);
1022 if (stbi__gif_test(s))
return stbi__gif_load(s,x,y,comp,req_comp, ri);
1025 if (stbi__psd_test(s))
return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
1028 if (stbi__pic_test(s))
return stbi__pic_load(s,x,y,comp,req_comp, ri);
1031 if (stbi__pnm_test(s))
return stbi__pnm_load(s,x,y,comp,req_comp, ri);
1035 if (stbi__hdr_test(s)) {
1036 float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
1037 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
1043 if (stbi__tga_test(s))
1044 return stbi__tga_load(s,x,y,comp,req_comp, ri);
1047 return stbi__errpuc(
"unknown image type",
"Image not of any known type, or corrupt");
1050 static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig,
int w,
int h,
int channels)
1056 reduced = (
stbi_uc *) stbi__malloc(img_len);
1057 if (reduced == NULL)
return stbi__errpuc(
"outofmem",
"Out of memory");
1059 for (i = 0; i < img_len; ++i)
1060 reduced[i] = (
stbi_uc)((orig[i] >> 8) & 0xFF);
1066 static stbi__uint16 *stbi__convert_8_to_16(
stbi_uc *orig,
int w,
int h,
int channels)
1070 stbi__uint16 *enlarged;
1072 enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
1073 if (enlarged == NULL)
return (stbi__uint16 *) stbi__errpuc(
"outofmem",
"Out of memory");
1075 for (i = 0; i < img_len; ++i)
1076 enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]);
1082 static void stbi__vertical_flip(
void *
image,
int w,
int h,
int bytes_per_pixel)
1085 size_t bytes_per_row = (size_t)w * bytes_per_pixel;
1090 stbi_uc *row0 = bytes + row*bytes_per_row;
1091 stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
1093 size_t bytes_left = bytes_per_row;
1094 while (bytes_left) {
1095 size_t bytes_copy = (bytes_left <
sizeof(temp)) ? bytes_left :
sizeof(temp);
1096 memcpy(temp, row0, bytes_copy);
1097 memcpy(row0, row1, bytes_copy);
1098 memcpy(row1, temp, bytes_copy);
1101 bytes_left -= bytes_copy;
1107 static void stbi__vertical_flip_slices(
void *image,
int w,
int h,
int z,
int bytes_per_pixel)
1110 int slice_size = w * h * bytes_per_pixel;
1113 for (slice = 0; slice <
z; ++slice) {
1114 stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
1115 bytes += slice_size;
1120 static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
1122 stbi__result_info ri;
1123 void *
result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
1128 if (ri.bits_per_channel != 8) {
1129 STBI_ASSERT(ri.bits_per_channel == 16);
1130 result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1131 ri.bits_per_channel = 8;
1136 if (stbi__vertically_flip_on_load) {
1137 int channels = req_comp ? req_comp : *comp;
1138 stbi__vertical_flip(result, *x, *y, channels *
sizeof(
stbi_uc));
1141 return (
unsigned char *)
result;
1144 static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
1146 stbi__result_info ri;
1147 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
1152 if (ri.bits_per_channel != 16) {
1153 STBI_ASSERT(ri.bits_per_channel == 8);
1154 result = stbi__convert_8_to_16((
stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1155 ri.bits_per_channel = 16;
1161 if (stbi__vertically_flip_on_load) {
1162 int channels = req_comp ? req_comp : *comp;
1163 stbi__vertical_flip(result, *x, *y, channels *
sizeof(stbi__uint16));
1166 return (stbi__uint16 *)
result;
1169 #if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
1170 static void stbi__float_postprocess(
float *result,
int *x,
int *y,
int *comp,
int req_comp)
1172 if (stbi__vertically_flip_on_load && result != NULL) {
1173 int channels = req_comp ? req_comp : *comp;
1174 stbi__vertical_flip(result, *x, *y, channels *
sizeof(
float));
1179 #ifndef STBI_NO_STDIO
1181 #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
1182 STBI_EXTERN __declspec(dllimport)
int __stdcall MultiByteToWideChar(
unsigned int cp,
unsigned long flags, const
char *str,
int cbmb,
wchar_t *widestr,
int cchwide);
1183 STBI_EXTERN __declspec(dllimport)
int __stdcall WideCharToMultiByte(
unsigned int cp,
unsigned long flags, const
wchar_t *widestr,
int cchwide,
char *str,
int cbmb, const
char *defchar,
int *used_default);
1186 #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
1187 STBIDEF int stbi_convert_wchar_to_utf8(
char *
buffer,
size_t bufferlen,
const wchar_t* input)
1189 return WideCharToMultiByte(65001 , 0, input, -1, buffer, (
int) bufferlen, NULL, NULL);
1193 static FILE *stbi__fopen(
char const *
filename,
char const *
mode)
1196 #if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
1198 wchar_t wFilename[1024];
1199 if (0 == MultiByteToWideChar(65001 , 0, filename, -1, wFilename,
sizeof(wFilename)))
1202 if (0 == MultiByteToWideChar(65001 , 0, mode, -1, wMode,
sizeof(wMode)))
1205 #if _MSC_VER >= 1400
1206 if (0 != _wfopen_s(&f, wFilename, wMode))
1209 f = _wfopen(wFilename, wMode);
1212 #elif defined(_MSC_VER) && _MSC_VER >= 1400
1213 if (0 != fopen_s(&f, filename, mode))
1216 f =
fopen(filename, mode);
1224 FILE *f = stbi__fopen(filename,
"rb");
1226 if (!f)
return stbi__errpuc(
"can't fopen",
"Unable to open file");
1236 stbi__start_file(&s,f);
1237 result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1240 fseek(f, - (
int) (s.img_buffer_end - s.img_buffer),
SEEK_CUR);
1249 stbi__start_file(&s,f);
1250 result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
1253 fseek(f, - (
int) (s.img_buffer_end - s.img_buffer),
SEEK_CUR);
1260 FILE *f = stbi__fopen(filename,
"rb");
1262 if (!f)
return (
stbi_us *) stbi__errpuc(
"can't fopen",
"Unable to open file");
1274 stbi__start_mem(&s,buffer,len);
1275 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1282 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1288 stbi__start_mem(&s,buffer,len);
1289 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1296 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1304 stbi__start_mem(&s,buffer,len);
1306 result = (
unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
1307 if (stbi__vertically_flip_on_load) {
1308 stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
1315 #ifndef STBI_NO_LINEAR
1316 static float *stbi__loadf_main(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
1318 unsigned char *
data;
1320 if (stbi__hdr_test(s)) {
1321 stbi__result_info ri;
1322 float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
1324 stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
1328 data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
1330 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
1331 return stbi__errpf(
"unknown image type",
"Image not of any known type, or corrupt");
1337 stbi__start_mem(&s,buffer,len);
1338 return stbi__loadf_main(&s,x,y,comp,req_comp);
1345 return stbi__loadf_main(&s,x,y,comp,req_comp);
1348 #ifndef STBI_NO_STDIO
1349 STBIDEF float *
stbi_loadf(
char const *filename,
int *x,
int *y,
int *comp,
int req_comp)
1352 FILE *f = stbi__fopen(filename,
"rb");
1353 if (!f)
return stbi__errpf(
"can't fopen",
"Unable to open file");
1362 stbi__start_file(&s,f);
1363 return stbi__loadf_main(&s,x,y,comp,req_comp);
1365 #endif // !STBI_NO_STDIO
1367 #endif // !STBI_NO_LINEAR
1377 stbi__start_mem(&s,buffer,len);
1378 return stbi__hdr_test(&s);
1380 STBI_NOTUSED(buffer);
1386 #ifndef STBI_NO_STDIO
1389 FILE *f = stbi__fopen(filename,
"rb");
1401 long pos =
ftell(f);
1404 stbi__start_file(&s,f);
1405 res = stbi__hdr_test(&s);
1413 #endif // !STBI_NO_STDIO
1420 return stbi__hdr_test(&s);
1428 #ifndef STBI_NO_LINEAR
1429 static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
1435 static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
1453 static void stbi__refill_buffer(stbi__context *s)
1455 int n = (s->io.read)(s->io_user_data,(
char*)s->buffer_start,s->buflen);
1459 s->read_from_callbacks = 0;
1460 s->img_buffer = s->buffer_start;
1461 s->img_buffer_end = s->buffer_start+1;
1464 s->img_buffer = s->buffer_start;
1465 s->img_buffer_end = s->buffer_start +
n;
1469 stbi_inline
static stbi_uc stbi__get8(stbi__context *s)
1471 if (s->img_buffer < s->img_buffer_end)
1472 return *s->img_buffer++;
1473 if (s->read_from_callbacks) {
1474 stbi__refill_buffer(s);
1475 return *s->img_buffer++;
1480 stbi_inline
static int stbi__at_eof(stbi__context *s)
1483 if (!(s->io.eof)(s->io_user_data))
return 0;
1486 if (s->read_from_callbacks == 0)
return 1;
1489 return s->img_buffer >= s->img_buffer_end;
1492 static void stbi__skip(stbi__context *s,
int n)
1495 s->img_buffer = s->img_buffer_end;
1499 int blen = (
int) (s->img_buffer_end - s->img_buffer);
1501 s->img_buffer = s->img_buffer_end;
1502 (s->io.skip)(s->io_user_data, n - blen);
1509 static int stbi__getn(stbi__context *s,
stbi_uc *buffer,
int n)
1512 int blen = (
int) (s->img_buffer_end - s->img_buffer);
1516 memcpy(buffer, s->img_buffer, blen);
1518 count = (s->io.read)(s->io_user_data, (
char*) buffer + blen, n - blen);
1519 res = (count == (n-blen));
1520 s->img_buffer = s->img_buffer_end;
1525 if (s->img_buffer+
n <= s->img_buffer_end) {
1526 memcpy(buffer, s->img_buffer, n);
1533 static int stbi__get16be(stbi__context *s)
1535 int z = stbi__get8(s);
1536 return (z << 8) + stbi__get8(s);
1539 static stbi__uint32 stbi__get32be(stbi__context *s)
1541 stbi__uint32 z = stbi__get16be(s);
1542 return (z << 16) + stbi__get16be(s);
1545 #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
1548 static int stbi__get16le(stbi__context *s)
1550 int z = stbi__get8(s);
1551 return z + (stbi__get8(s) << 8);
1556 static stbi__uint32 stbi__get32le(stbi__context *s)
1558 stbi__uint32 z = stbi__get16le(s);
1559 return z + (stbi__get16le(s) << 16);
1563 #define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
1577 static stbi_uc stbi__compute_y(
int r,
int g,
int b)
1579 return (
stbi_uc) (((r*77) + (g*150) + (29*
b)) >> 8);
1582 static unsigned char *stbi__convert_format(
unsigned char *data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y)
1585 unsigned char *good;
1587 if (req_comp == img_n)
return data;
1588 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1590 good = (
unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
1593 return stbi__errpuc(
"outofmem",
"Out of memory");
1596 for (j=0; j < (
int) y; ++
j) {
1597 unsigned char *
src = data + j * x * img_n ;
1598 unsigned char *dest = good + j * x * req_comp;
1600 #define STBI__COMBO(a,b) ((a)*8+(b))
1601 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1604 switch (STBI__COMBO(img_n, req_comp)) {
1605 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; }
break;
1606 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
1607 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; }
break;
1608 STBI__CASE(2,1) { dest[0]=src[0]; }
break;
1609 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
1610 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; }
break;
1611 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; }
break;
1612 STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); }
break;
1613 STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; }
break;
1614 STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); }
break;
1615 STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; }
break;
1616 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; }
break;
1617 default: STBI_ASSERT(0);
1626 static stbi__uint16 stbi__compute_y_16(
int r,
int g,
int b)
1628 return (stbi__uint16) (((r*77) + (g*150) + (29*
b)) >> 8);
1631 static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y)
1636 if (req_comp == img_n)
return data;
1637 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1639 good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
1642 return (stbi__uint16 *) stbi__errpuc(
"outofmem",
"Out of memory");
1645 for (j=0; j < (
int) y; ++
j) {
1646 stbi__uint16 *src = data + j * x * img_n ;
1647 stbi__uint16 *dest = good + j * x * req_comp;
1649 #define STBI__COMBO(a,b) ((a)*8+(b))
1650 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1653 switch (STBI__COMBO(img_n, req_comp)) {
1654 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; }
break;
1655 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
1656 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; }
break;
1657 STBI__CASE(2,1) { dest[0]=src[0]; }
break;
1658 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
1659 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; }
break;
1660 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; }
break;
1661 STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); }
break;
1662 STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; }
break;
1663 STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); }
break;
1664 STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; }
break;
1665 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; }
break;
1666 default: STBI_ASSERT(0);
1675 #ifndef STBI_NO_LINEAR
1676 static float *stbi__ldr_to_hdr(
stbi_uc *data,
int x,
int y,
int comp)
1680 if (!data)
return NULL;
1681 output = (
float *) stbi__malloc_mad4(x, y, comp,
sizeof(
float), 0);
1682 if (output == NULL) { STBI_FREE(data);
return stbi__errpf(
"outofmem",
"Out of memory"); }
1684 if (comp & 1) n = comp;
else n = comp-1;
1685 for (i=0; i < x*
y; ++i) {
1686 for (k=0; k <
n; ++k) {
1687 output[i*comp + k] = (
float) (
pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
1691 for (i=0; i < x*
y; ++i) {
1692 output[i*comp +
n] = data[i*comp +
n]/255.0f;
1701 #define stbi__float2int(x) ((int) (x))
1702 static stbi_uc *stbi__hdr_to_ldr(
float *data,
int x,
int y,
int comp)
1706 if (!data)
return NULL;
1707 output = (
stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
1708 if (output == NULL) { STBI_FREE(data);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
1710 if (comp & 1) n = comp;
else n = comp-1;
1711 for (i=0; i < x*
y; ++i) {
1712 for (k=0; k <
n; ++k) {
1713 float z = (
float)
pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
1715 if (z > 255) z = 255;
1716 output[i*comp + k] = (
stbi_uc) stbi__float2int(z);
1719 float z = data[i*comp+k] * 255 + 0.5f;
1721 if (z > 255) z = 255;
1722 output[i*comp + k] = (
stbi_uc) stbi__float2int(z);
1751 #ifndef STBI_NO_JPEG
1754 #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
1760 stbi__uint16 code[256];
1763 unsigned int maxcode[18];
1770 stbi__huffman huff_dc[4];
1771 stbi__huffman huff_ac[4];
1772 stbi__uint16 dequant[4][64];
1773 stbi__int16 fast_ac[4][1 << FAST_BITS];
1776 int img_h_max, img_v_max;
1777 int img_mcu_x, img_mcu_y;
1778 int img_mcu_w, img_mcu_h;
1791 void *raw_data, *raw_coeff;
1794 int coeff_w, coeff_h;
1797 stbi__uint32 code_buffer;
1799 unsigned char marker;
1809 int app14_color_transform;
1812 int scan_n,
order[4];
1813 int restart_interval, todo;
1816 void (*idct_block_kernel)(
stbi_uc *out,
int out_stride,
short data[64]);
1821 static int stbi__build_huffman(stbi__huffman *h,
int *
count)
1826 for (i=0; i < 16; ++i)
1827 for (j=0; j < count[i]; ++
j)
1828 h->size[k++] = (
stbi_uc) (i+1);
1834 for(j=1; j <= 16; ++
j) {
1836 h->delta[
j] = k - code;
1837 if (h->size[k] == j) {
1838 while (h->size[k] == j)
1839 h->code[k++] = (stbi__uint16) (code++);
1840 if (code-1 >= (1u << j))
return stbi__err(
"bad code lengths",
"Corrupt JPEG");
1843 h->maxcode[
j] = code << (16-
j);
1846 h->maxcode[
j] = 0xffffffff;
1849 memset(h->fast, 255, 1 << FAST_BITS);
1850 for (i=0; i < k; ++i) {
1852 if (s <= FAST_BITS) {
1853 int c = h->code[i] << (FAST_BITS-
s);
1854 int m = 1 << (FAST_BITS-
s);
1855 for (j=0; j < m; ++
j) {
1865 static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
1868 for (i=0; i < (1 << FAST_BITS); ++i) {
1872 int rs = h->values[fast];
1873 int run = (rs >> 4) & 15;
1874 int magbits = rs & 15;
1875 int len = h->size[fast];
1877 if (magbits && len + magbits <= FAST_BITS) {
1879 int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
1880 int m = 1 << (magbits - 1);
1881 if (k < m) k += (~0U << magbits) + 1;
1883 if (k >= -128 && k <= 127)
1884 fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
1890 static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
1893 unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
1895 int c = stbi__get8(j->s);
1896 while (c == 0xff) c = stbi__get8(j->s);
1898 j->marker = (
unsigned char) c;
1903 j->code_buffer |= b << (24 - j->code_bits);
1905 }
while (j->code_bits <= 24);
1909 static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
1912 stbi_inline
static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
1917 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
1921 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
1925 if (s > j->code_bits)
1927 j->code_buffer <<=
s;
1929 return h->values[k];
1938 temp = j->code_buffer >> 16;
1939 for (k=FAST_BITS+1 ; ; ++k)
1940 if (temp < h->maxcode[k])
1948 if (k > j->code_bits)
1952 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
1953 STBI_ASSERT((((j->code_buffer) >> (32 - h->size[
c])) & stbi__bmask[h->size[
c]]) == h->code[c]);
1957 j->code_buffer <<= k;
1958 return h->values[
c];
1962 static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
1966 stbi_inline
static int stbi__extend_receive(stbi__jpeg *j,
int n)
1970 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
1972 sgn = (stbi__int32)j->code_buffer >> 31;
1973 k = stbi_lrot(j->code_buffer, n);
1974 STBI_ASSERT(n >= 0 && n < (
int) (
sizeof(stbi__bmask)/
sizeof(*stbi__bmask)));
1975 j->code_buffer = k & ~stbi__bmask[
n];
1976 k &= stbi__bmask[
n];
1978 return k + (stbi__jbias[
n] & ~sgn);
1982 stbi_inline
static int stbi__jpeg_get_bits(stbi__jpeg *j,
int n)
1985 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
1986 k = stbi_lrot(j->code_buffer, n);
1987 j->code_buffer = k & ~stbi__bmask[
n];
1988 k &= stbi__bmask[
n];
1993 stbi_inline
static int stbi__jpeg_get_bit(stbi__jpeg *j)
1996 if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
1998 j->code_buffer <<= 1;
2000 return k & 0x80000000;
2005 static const stbi_uc stbi__jpeg_dezigzag[64+15] =
2007 0, 1, 8, 16, 9, 2, 3, 10,
2008 17, 24, 32, 25, 18, 11, 4, 5,
2009 12, 19, 26, 33, 40, 48, 41, 34,
2010 27, 20, 13, 6, 7, 14, 21, 28,
2011 35, 42, 49, 56, 57, 50, 43, 36,
2012 29, 22, 15, 23, 30, 37, 44, 51,
2013 58, 59, 52, 45, 38, 31, 39, 46,
2014 53, 60, 61, 54, 47, 55, 62, 63,
2016 63, 63, 63, 63, 63, 63, 63, 63,
2017 63, 63, 63, 63, 63, 63, 63
2021 static int stbi__jpeg_decode_block(stbi__jpeg *j,
short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac,
int b, stbi__uint16 *dequant)
2026 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2027 t = stbi__jpeg_huff_decode(j, hdc);
2028 if (t < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2031 memset(data,0,64*
sizeof(data[0]));
2033 diff = t ? stbi__extend_receive(j, t) : 0;
2034 dc = j->img_comp[
b].dc_pred + diff;
2035 j->img_comp[
b].dc_pred = dc;
2036 data[0] = (short) (dc * dequant[0]);
2043 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2044 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2049 j->code_buffer <<=
s;
2052 zig = stbi__jpeg_dezigzag[k++];
2053 data[zig] = (short) ((r >> 8) * dequant[zig]);
2055 int rs = stbi__jpeg_huff_decode(j, hac);
2056 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2060 if (rs != 0xf0)
break;
2065 zig = stbi__jpeg_dezigzag[k++];
2066 data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
2073 static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j,
short data[64], stbi__huffman *hdc,
int b)
2077 if (j->spec_end != 0)
return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2079 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2081 if (j->succ_high == 0) {
2083 memset(data,0,64*
sizeof(data[0]));
2084 t = stbi__jpeg_huff_decode(j, hdc);
2085 diff = t ? stbi__extend_receive(j, t) : 0;
2087 dc = j->img_comp[
b].dc_pred + diff;
2088 j->img_comp[
b].dc_pred = dc;
2089 data[0] = (short) (dc << j->succ_low);
2092 if (stbi__jpeg_get_bit(j))
2093 data[0] += (
short) (1 << j->succ_low);
2100 static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j,
short data[64], stbi__huffman *hac, stbi__int16 *fac)
2103 if (j->spec_start == 0)
return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
2105 if (j->succ_high == 0) {
2106 int shift = j->succ_low;
2117 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2118 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2123 j->code_buffer <<=
s;
2125 zig = stbi__jpeg_dezigzag[k++];
2126 data[zig] = (short) ((r >> 8) << shift);
2128 int rs = stbi__jpeg_huff_decode(j, hac);
2129 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2134 j->eob_run = (1 <<
r);
2136 j->eob_run += stbi__jpeg_get_bits(j, r);
2143 zig = stbi__jpeg_dezigzag[k++];
2144 data[zig] = (short) (stbi__extend_receive(j,s) << shift);
2147 }
while (k <= j->spec_end);
2151 short bit = (short) (1 << j->succ_low);
2155 for (k = j->spec_start; k <= j->spec_end; ++k) {
2156 short *p = &data[stbi__jpeg_dezigzag[k]];
2158 if (stbi__jpeg_get_bit(j))
2159 if ((*p & bit)==0) {
2170 int rs = stbi__jpeg_huff_decode(j, hac);
2171 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2176 j->eob_run = (1 <<
r) - 1;
2178 j->eob_run += stbi__jpeg_get_bits(j, r);
2186 if (s != 1)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
2188 if (stbi__jpeg_get_bit(j))
2195 while (k <= j->spec_end) {
2196 short *p = &data[stbi__jpeg_dezigzag[k++]];
2198 if (stbi__jpeg_get_bit(j))
2199 if ((*p & bit)==0) {
2213 }
while (k <= j->spec_end);
2220 stbi_inline
static stbi_uc stbi__clamp(
int x)
2223 if ((
unsigned int) x > 255) {
2224 if (x < 0)
return 0;
2225 if (x > 255)
return 255;
2230 #define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
2231 #define stbi__fsh(x) ((x) * 4096)
2234 #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
2235 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
2238 p1 = (p2+p3) * stbi__f2f(0.5411961f); \
2239 t2 = p1 + p3*stbi__f2f(-1.847759065f); \
2240 t3 = p1 + p2*stbi__f2f( 0.765366865f); \
2243 t0 = stbi__fsh(p2+p3); \
2244 t1 = stbi__fsh(p2-p3); \
2257 p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
2258 t0 = t0*stbi__f2f( 0.298631336f); \
2259 t1 = t1*stbi__f2f( 2.053119869f); \
2260 t2 = t2*stbi__f2f( 3.072711026f); \
2261 t3 = t3*stbi__f2f( 1.501321110f); \
2262 p1 = p5 + p1*stbi__f2f(-0.899976223f); \
2263 p2 = p5 + p2*stbi__f2f(-2.562915447f); \
2264 p3 = p3*stbi__f2f(-1.961570560f); \
2265 p4 = p4*stbi__f2f(-0.390180644f); \
2271 static void stbi__idct_block(
stbi_uc *out,
int out_stride,
short data[64])
2278 for (i=0; i < 8; ++i,++d, ++
v) {
2280 if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
2281 && d[40]==0 && d[48]==0 && d[56]==0) {
2286 int dcterm = d[0]*4;
2287 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
2289 STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
2292 x0 += 512; x1 += 512;
x2 += 512; x3 += 512;
2293 v[ 0] = (x0+t3) >> 10;
2294 v[56] = (x0-t3) >> 10;
2295 v[ 8] = (x1+t2) >> 10;
2296 v[48] = (x1-t2) >> 10;
2297 v[16] = (
x2+t1) >> 10;
2298 v[40] = (
x2-t1) >> 10;
2299 v[24] = (x3+t0) >> 10;
2300 v[32] = (x3-t0) >> 10;
2304 for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
2306 STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
2313 x0 += 65536 + (128<<17);
2314 x1 += 65536 + (128<<17);
2315 x2 += 65536 + (128<<17);
2316 x3 += 65536 + (128<<17);
2319 o[0] = stbi__clamp((x0+t3) >> 17);
2320 o[7] = stbi__clamp((x0-t3) >> 17);
2321 o[1] = stbi__clamp((x1+t2) >> 17);
2322 o[6] = stbi__clamp((x1-t2) >> 17);
2323 o[2] = stbi__clamp((
x2+t1) >> 17);
2324 o[5] = stbi__clamp((
x2-t1) >> 17);
2325 o[3] = stbi__clamp((x3+t0) >> 17);
2326 o[4] = stbi__clamp((x3-t0) >> 17);
2334 static void stbi__idct_simd(
stbi_uc *out,
int out_stride,
short data[64])
2337 __m128i row0, row1, row2, row3, row4, row5, row6, row7;
2341 #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
2345 #define dct_rot(out0,out1, x,y,c0,c1) \
2346 __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
2347 __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
2348 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
2349 __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
2350 __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
2351 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
2354 #define dct_widen(out, in) \
2355 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
2356 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
2359 #define dct_wadd(out, a, b) \
2360 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
2361 __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
2364 #define dct_wsub(out, a, b) \
2365 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
2366 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
2369 #define dct_bfly32o(out0, out1, a,b,bias,s) \
2371 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
2372 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
2373 dct_wadd(sum, abiased, b); \
2374 dct_wsub(dif, abiased, b); \
2375 out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
2376 out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
2380 #define dct_interleave8(a, b) \
2382 a = _mm_unpacklo_epi8(a, b); \
2383 b = _mm_unpackhi_epi8(tmp, b)
2386 #define dct_interleave16(a, b) \
2388 a = _mm_unpacklo_epi16(a, b); \
2389 b = _mm_unpackhi_epi16(tmp, b)
2391 #define dct_pass(bias,shift) \
2394 dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
2395 __m128i sum04 = _mm_add_epi16(row0, row4); \
2396 __m128i dif04 = _mm_sub_epi16(row0, row4); \
2397 dct_widen(t0e, sum04); \
2398 dct_widen(t1e, dif04); \
2399 dct_wadd(x0, t0e, t3e); \
2400 dct_wsub(x3, t0e, t3e); \
2401 dct_wadd(x1, t1e, t2e); \
2402 dct_wsub(x2, t1e, t2e); \
2404 dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
2405 dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
2406 __m128i sum17 = _mm_add_epi16(row1, row7); \
2407 __m128i sum35 = _mm_add_epi16(row3, row5); \
2408 dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
2409 dct_wadd(x4, y0o, y4o); \
2410 dct_wadd(x5, y1o, y5o); \
2411 dct_wadd(x6, y2o, y5o); \
2412 dct_wadd(x7, y3o, y4o); \
2413 dct_bfly32o(row0,row7, x0,x7,bias,shift); \
2414 dct_bfly32o(row1,row6, x1,x6,bias,shift); \
2415 dct_bfly32o(row2,row5, x2,x5,bias,shift); \
2416 dct_bfly32o(row3,row4, x3,x4,bias,shift); \
2419 __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
2420 __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
2421 __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
2422 __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
2423 __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
2424 __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
2425 __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
2426 __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
2429 __m128i bias_0 = _mm_set1_epi32(512);
2430 __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
2433 row0 = _mm_load_si128((
const __m128i *) (data + 0*8));
2434 row1 = _mm_load_si128((
const __m128i *) (data + 1*8));
2435 row2 = _mm_load_si128((
const __m128i *) (data + 2*8));
2436 row3 = _mm_load_si128((
const __m128i *) (data + 3*8));
2437 row4 = _mm_load_si128((
const __m128i *) (data + 4*8));
2438 row5 = _mm_load_si128((
const __m128i *) (data + 5*8));
2439 row6 = _mm_load_si128((
const __m128i *) (data + 6*8));
2440 row7 = _mm_load_si128((
const __m128i *) (data + 7*8));
2443 dct_pass(bias_0, 10);
2447 dct_interleave16(row0, row4);
2448 dct_interleave16(row1, row5);
2449 dct_interleave16(row2, row6);
2450 dct_interleave16(row3, row7);
2453 dct_interleave16(row0, row2);
2454 dct_interleave16(row1, row3);
2455 dct_interleave16(row4, row6);
2456 dct_interleave16(row5, row7);
2459 dct_interleave16(row0, row1);
2460 dct_interleave16(row2, row3);
2461 dct_interleave16(row4, row5);
2462 dct_interleave16(row6, row7);
2466 dct_pass(bias_1, 17);
2470 __m128i p0 = _mm_packus_epi16(row0, row1);
2471 __m128i p1 = _mm_packus_epi16(row2, row3);
2472 __m128i p2 = _mm_packus_epi16(row4, row5);
2473 __m128i p3 = _mm_packus_epi16(row6, row7);
2476 dct_interleave8(p0, p2);
2477 dct_interleave8(p1, p3);
2480 dct_interleave8(p0, p1);
2481 dct_interleave8(p2, p3);
2484 dct_interleave8(p0, p2);
2485 dct_interleave8(p1, p3);
2488 _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
2489 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
2490 _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
2491 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
2492 _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
2493 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
2494 _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
2495 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
2504 #undef dct_interleave8
2505 #undef dct_interleave16
2515 static void stbi__idct_simd(
stbi_uc *out,
int out_stride,
short data[64])
2517 int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
2519 int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
2520 int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
2521 int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
2522 int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
2523 int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
2524 int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
2525 int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
2526 int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
2527 int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
2528 int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
2529 int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
2530 int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
2532 #define dct_long_mul(out, inq, coeff) \
2533 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
2534 int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
2536 #define dct_long_mac(out, acc, inq, coeff) \
2537 int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
2538 int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
2540 #define dct_widen(out, inq) \
2541 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
2542 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
2545 #define dct_wadd(out, a, b) \
2546 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
2547 int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
2550 #define dct_wsub(out, a, b) \
2551 int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
2552 int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
2555 #define dct_bfly32o(out0,out1, a,b,shiftop,s) \
2557 dct_wadd(sum, a, b); \
2558 dct_wsub(dif, a, b); \
2559 out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
2560 out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
2563 #define dct_pass(shiftop, shift) \
2566 int16x8_t sum26 = vaddq_s16(row2, row6); \
2567 dct_long_mul(p1e, sum26, rot0_0); \
2568 dct_long_mac(t2e, p1e, row6, rot0_1); \
2569 dct_long_mac(t3e, p1e, row2, rot0_2); \
2570 int16x8_t sum04 = vaddq_s16(row0, row4); \
2571 int16x8_t dif04 = vsubq_s16(row0, row4); \
2572 dct_widen(t0e, sum04); \
2573 dct_widen(t1e, dif04); \
2574 dct_wadd(x0, t0e, t3e); \
2575 dct_wsub(x3, t0e, t3e); \
2576 dct_wadd(x1, t1e, t2e); \
2577 dct_wsub(x2, t1e, t2e); \
2579 int16x8_t sum15 = vaddq_s16(row1, row5); \
2580 int16x8_t sum17 = vaddq_s16(row1, row7); \
2581 int16x8_t sum35 = vaddq_s16(row3, row5); \
2582 int16x8_t sum37 = vaddq_s16(row3, row7); \
2583 int16x8_t sumodd = vaddq_s16(sum17, sum35); \
2584 dct_long_mul(p5o, sumodd, rot1_0); \
2585 dct_long_mac(p1o, p5o, sum17, rot1_1); \
2586 dct_long_mac(p2o, p5o, sum35, rot1_2); \
2587 dct_long_mul(p3o, sum37, rot2_0); \
2588 dct_long_mul(p4o, sum15, rot2_1); \
2589 dct_wadd(sump13o, p1o, p3o); \
2590 dct_wadd(sump24o, p2o, p4o); \
2591 dct_wadd(sump23o, p2o, p3o); \
2592 dct_wadd(sump14o, p1o, p4o); \
2593 dct_long_mac(x4, sump13o, row7, rot3_0); \
2594 dct_long_mac(x5, sump24o, row5, rot3_1); \
2595 dct_long_mac(x6, sump23o, row3, rot3_2); \
2596 dct_long_mac(x7, sump14o, row1, rot3_3); \
2597 dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
2598 dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
2599 dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
2600 dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
2604 row0 = vld1q_s16(data + 0*8);
2605 row1 = vld1q_s16(data + 1*8);
2606 row2 = vld1q_s16(data + 2*8);
2607 row3 = vld1q_s16(data + 3*8);
2608 row4 = vld1q_s16(data + 4*8);
2609 row5 = vld1q_s16(data + 5*8);
2610 row6 = vld1q_s16(data + 6*8);
2611 row7 = vld1q_s16(data + 7*8);
2614 row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
2617 dct_pass(vrshrn_n_s32, 10);
2623 #define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
2624 #define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
2625 #define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
2628 dct_trn16(row0, row1);
2629 dct_trn16(row2, row3);
2630 dct_trn16(row4, row5);
2631 dct_trn16(row6, row7);
2634 dct_trn32(row0, row2);
2635 dct_trn32(row1, row3);
2636 dct_trn32(row4, row6);
2637 dct_trn32(row5, row7);
2640 dct_trn64(row0, row4);
2641 dct_trn64(row1, row5);
2642 dct_trn64(row2, row6);
2643 dct_trn64(row3, row7);
2654 dct_pass(vshrn_n_s32, 16);
2658 uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
2659 uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
2660 uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
2661 uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
2662 uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
2663 uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
2664 uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
2665 uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
2668 #define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
2669 #define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
2670 #define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
2682 dct_trn8_16(p0, p2);
2683 dct_trn8_16(p1, p3);
2684 dct_trn8_16(p4, p6);
2685 dct_trn8_16(p5, p7);
2688 dct_trn8_32(p0, p4);
2689 dct_trn8_32(p1, p5);
2690 dct_trn8_32(p2, p6);
2691 dct_trn8_32(p3, p7);
2694 vst1_u8(out, p0); out += out_stride;
2695 vst1_u8(out, p1); out += out_stride;
2696 vst1_u8(out, p2); out += out_stride;
2697 vst1_u8(out, p3); out += out_stride;
2698 vst1_u8(out, p4); out += out_stride;
2699 vst1_u8(out, p5); out += out_stride;
2700 vst1_u8(out, p6); out += out_stride;
2719 #define STBI__MARKER_none 0xff
2723 static stbi_uc stbi__get_marker(stbi__jpeg *j)
2726 if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none;
return x; }
2727 x = stbi__get8(j->s);
2728 if (x != 0xff)
return STBI__MARKER_none;
2730 x = stbi__get8(j->s);
2736 #define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
2740 static void stbi__jpeg_reset(stbi__jpeg *j)
2745 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;
2746 j->marker = STBI__MARKER_none;
2747 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
2753 static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
2755 stbi__jpeg_reset(z);
2756 if (!z->progressive) {
2757 if (z->scan_n == 1) {
2759 STBI_SIMD_ALIGN(
short, data[64]);
2760 int n = z->order[0];
2765 int w = (z->img_comp[
n].x+7) >> 3;
2766 int h = (z->img_comp[
n].y+7) >> 3;
2767 for (j=0; j <
h; ++
j) {
2768 for (i=0; i <
w; ++i) {
2769 int ha = z->img_comp[
n].ha;
2770 if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq]))
return 0;
2771 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
2773 if (--z->todo <= 0) {
2774 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2777 if (!STBI__RESTART(z->marker))
return 1;
2778 stbi__jpeg_reset(z);
2785 STBI_SIMD_ALIGN(
short, data[64]);
2786 for (j=0; j < z->img_mcu_y; ++
j) {
2787 for (i=0; i < z->img_mcu_x; ++i) {
2789 for (k=0; k < z->scan_n; ++k) {
2790 int n = z->order[k];
2793 for (y=0; y < z->img_comp[
n].v; ++
y) {
2794 for (x=0; x < z->img_comp[
n].h; ++
x) {
2795 int x2 = (i*z->img_comp[
n].h +
x)*8;
2796 int y2 = (j*z->img_comp[
n].v +
y)*8;
2797 int ha = z->img_comp[
n].ha;
2798 if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq]))
return 0;
2799 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
2805 if (--z->todo <= 0) {
2806 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2807 if (!STBI__RESTART(z->marker))
return 1;
2808 stbi__jpeg_reset(z);
2815 if (z->scan_n == 1) {
2817 int n = z->order[0];
2822 int w = (z->img_comp[
n].x+7) >> 3;
2823 int h = (z->img_comp[
n].y+7) >> 3;
2824 for (j=0; j <
h; ++
j) {
2825 for (i=0; i <
w; ++i) {
2826 short *data = z->img_comp[
n].coeff + 64 * (i + j * z->img_comp[
n].coeff_w);
2827 if (z->spec_start == 0) {
2828 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
2831 int ha = z->img_comp[
n].ha;
2832 if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
2836 if (--z->todo <= 0) {
2837 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2838 if (!STBI__RESTART(z->marker))
return 1;
2839 stbi__jpeg_reset(z);
2846 for (j=0; j < z->img_mcu_y; ++
j) {
2847 for (i=0; i < z->img_mcu_x; ++i) {
2849 for (k=0; k < z->scan_n; ++k) {
2850 int n = z->order[k];
2853 for (y=0; y < z->img_comp[
n].v; ++
y) {
2854 for (x=0; x < z->img_comp[
n].h; ++
x) {
2855 int x2 = (i*z->img_comp[
n].h +
x);
2856 int y2 = (j*z->img_comp[
n].v +
y);
2857 short *data = z->img_comp[
n].coeff + 64 * (x2 + y2 * z->img_comp[
n].coeff_w);
2858 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
2865 if (--z->todo <= 0) {
2866 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2867 if (!STBI__RESTART(z->marker))
return 1;
2868 stbi__jpeg_reset(z);
2877 static void stbi__jpeg_dequantize(
short *data, stbi__uint16 *dequant)
2880 for (i=0; i < 64; ++i)
2881 data[i] *= dequant[i];
2884 static void stbi__jpeg_finish(stbi__jpeg *z)
2886 if (z->progressive) {
2889 for (n=0; n < z->s->img_n; ++
n) {
2890 int w = (z->img_comp[
n].x+7) >> 3;
2891 int h = (z->img_comp[
n].y+7) >> 3;
2892 for (j=0; j <
h; ++
j) {
2893 for (i=0; i <
w; ++i) {
2894 short *data = z->img_comp[
n].coeff + 64 * (i + j * z->img_comp[
n].coeff_w);
2895 stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
2896 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
2903 static int stbi__process_marker(stbi__jpeg *z,
int m)
2907 case STBI__MARKER_none:
2908 return stbi__err(
"expected marker",
"Corrupt JPEG");
2911 if (stbi__get16be(z->s) != 4)
return stbi__err(
"bad DRI len",
"Corrupt JPEG");
2912 z->restart_interval = stbi__get16be(z->s);
2916 L = stbi__get16be(z->s)-2;
2918 int q = stbi__get8(z->s);
2919 int p = q >> 4, sixteen = (p != 0);
2921 if (p != 0 && p != 1)
return stbi__err(
"bad DQT type",
"Corrupt JPEG");
2922 if (t > 3)
return stbi__err(
"bad DQT table",
"Corrupt JPEG");
2924 for (i=0; i < 64; ++i)
2925 z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
2926 L -= (sixteen ? 129 : 65);
2931 L = stbi__get16be(z->s)-2;
2934 int sizes[16],i,n=0;
2935 int q = stbi__get8(z->s);
2938 if (tc > 1 || th > 3)
return stbi__err(
"bad DHT header",
"Corrupt JPEG");
2939 for (i=0; i < 16; ++i) {
2940 sizes[i] = stbi__get8(z->s);
2945 if (!stbi__build_huffman(z->huff_dc+th, sizes))
return 0;
2946 v = z->huff_dc[th].values;
2948 if (!stbi__build_huffman(z->huff_ac+th, sizes))
return 0;
2949 v = z->huff_ac[th].values;
2951 for (i=0; i <
n; ++i)
2952 v[i] = stbi__get8(z->s);
2954 stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
2961 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
2962 L = stbi__get16be(z->s);
2965 return stbi__err(
"bad COM len",
"Corrupt JPEG");
2967 return stbi__err(
"bad APP len",
"Corrupt JPEG");
2971 if (m == 0xE0 && L >= 5) {
2972 static const unsigned char tag[5] = {
'J',
'F',
'I',
'F',
'\0'};
2975 for (i=0; i < 5; ++i)
2976 if (stbi__get8(z->s) != tag[i])
2981 }
else if (m == 0xEE && L >= 12) {
2982 static const unsigned char tag[6] = {
'A',
'd',
'o',
'b',
'e',
'\0'};
2985 for (i=0; i < 6; ++i)
2986 if (stbi__get8(z->s) != tag[i])
2991 stbi__get16be(z->s);
2992 stbi__get16be(z->s);
2993 z->app14_color_transform = stbi__get8(z->s);
2998 stbi__skip(z->s, L);
3002 return stbi__err(
"unknown marker",
"Corrupt JPEG");
3006 static int stbi__process_scan_header(stbi__jpeg *z)
3009 int Ls = stbi__get16be(z->s);
3010 z->scan_n = stbi__get8(z->s);
3011 if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (
int) z->s->img_n)
return stbi__err(
"bad SOS component count",
"Corrupt JPEG");
3012 if (Ls != 6+2*z->scan_n)
return stbi__err(
"bad SOS len",
"Corrupt JPEG");
3013 for (i=0; i < z->scan_n; ++i) {
3014 int id = stbi__get8(z->s), which;
3015 int q = stbi__get8(z->s);
3016 for (which = 0; which < z->s->img_n; ++which)
3017 if (z->img_comp[which].id ==
id)
3019 if (which == z->s->img_n)
return 0;
3020 z->img_comp[which].hd = q >> 4;
if (z->img_comp[which].hd > 3)
return stbi__err(
"bad DC huff",
"Corrupt JPEG");
3021 z->img_comp[which].ha = q & 15;
if (z->img_comp[which].ha > 3)
return stbi__err(
"bad AC huff",
"Corrupt JPEG");
3022 z->order[i] = which;
3027 z->spec_start = stbi__get8(z->s);
3028 z->spec_end = stbi__get8(z->s);
3029 aa = stbi__get8(z->s);
3030 z->succ_high = (aa >> 4);
3031 z->succ_low = (aa & 15);
3032 if (z->progressive) {
3033 if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
3034 return stbi__err(
"bad SOS",
"Corrupt JPEG");
3036 if (z->spec_start != 0)
return stbi__err(
"bad SOS",
"Corrupt JPEG");
3037 if (z->succ_high != 0 || z->succ_low != 0)
return stbi__err(
"bad SOS",
"Corrupt JPEG");
3045 static int stbi__free_jpeg_components(stbi__jpeg *z,
int ncomp,
int why)
3048 for (i=0; i < ncomp; ++i) {
3049 if (z->img_comp[i].raw_data) {
3050 STBI_FREE(z->img_comp[i].raw_data);
3051 z->img_comp[i].raw_data = NULL;
3052 z->img_comp[i].data = NULL;
3054 if (z->img_comp[i].raw_coeff) {
3055 STBI_FREE(z->img_comp[i].raw_coeff);
3056 z->img_comp[i].raw_coeff = 0;
3057 z->img_comp[i].coeff = 0;
3059 if (z->img_comp[i].linebuf) {
3060 STBI_FREE(z->img_comp[i].linebuf);
3061 z->img_comp[i].linebuf = NULL;
3067 static int stbi__process_frame_header(stbi__jpeg *z,
int scan)
3069 stbi__context *s = z->s;
3070 int Lf,p,i,
q, h_max=1,v_max=1,
c;
3071 Lf = stbi__get16be(s);
if (Lf < 11)
return stbi__err(
"bad SOF len",
"Corrupt JPEG");
3072 p = stbi__get8(s);
if (p != 8)
return stbi__err(
"only 8-bit",
"JPEG format not supported: 8-bit only");
3073 s->img_y = stbi__get16be(s);
if (s->img_y == 0)
return stbi__err(
"no header height",
"JPEG format not supported: delayed height");
3074 s->img_x = stbi__get16be(s);
if (s->img_x == 0)
return stbi__err(
"0 width",
"Corrupt JPEG");
3076 if (c != 3 && c != 1 && c != 4)
return stbi__err(
"bad component count",
"Corrupt JPEG");
3078 for (i=0; i <
c; ++i) {
3079 z->img_comp[i].data = NULL;
3080 z->img_comp[i].linebuf = NULL;
3083 if (Lf != 8+3*s->img_n)
return stbi__err(
"bad SOF len",
"Corrupt JPEG");
3086 for (i=0; i < s->img_n; ++i) {
3087 static const unsigned char rgb[3] = {
'R',
'G',
'B' };
3088 z->img_comp[i].id = stbi__get8(s);
3089 if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
3092 z->img_comp[i].h = (q >> 4);
if (!z->img_comp[i].h || z->img_comp[i].h > 4)
return stbi__err(
"bad H",
"Corrupt JPEG");
3093 z->img_comp[i].v = q & 15;
if (!z->img_comp[i].v || z->img_comp[i].v > 4)
return stbi__err(
"bad V",
"Corrupt JPEG");
3094 z->img_comp[i].tq = stbi__get8(s);
if (z->img_comp[i].tq > 3)
return stbi__err(
"bad TQ",
"Corrupt JPEG");
3097 if (scan != STBI__SCAN_load)
return 1;
3099 if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0))
return stbi__err(
"too large",
"Image too large to decode");
3101 for (i=0; i < s->img_n; ++i) {
3102 if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
3103 if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
3107 z->img_h_max = h_max;
3108 z->img_v_max = v_max;
3109 z->img_mcu_w = h_max * 8;
3110 z->img_mcu_h = v_max * 8;
3112 z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
3113 z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
3115 for (i=0; i < s->img_n; ++i) {
3117 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
3118 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
3126 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
3127 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
3128 z->img_comp[i].coeff = 0;
3129 z->img_comp[i].raw_coeff = 0;
3130 z->img_comp[i].linebuf = NULL;
3131 z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
3132 if (z->img_comp[i].raw_data == NULL)
3133 return stbi__free_jpeg_components(z, i+1, stbi__err(
"outofmem",
"Out of memory"));
3135 z->img_comp[i].data = (
stbi_uc*) (((
size_t) z->img_comp[i].raw_data + 15) & ~15);
3136 if (z->progressive) {
3138 z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
3139 z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
3140 z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2,
sizeof(
short), 15);
3141 if (z->img_comp[i].raw_coeff == NULL)
3142 return stbi__free_jpeg_components(z, i+1, stbi__err(
"outofmem",
"Out of memory"));
3143 z->img_comp[i].coeff = (
short*) (((
size_t) z->img_comp[i].raw_coeff + 15) & ~15);
3151 #define stbi__DNL(x) ((x) == 0xdc)
3152 #define stbi__SOI(x) ((x) == 0xd8)
3153 #define stbi__EOI(x) ((x) == 0xd9)
3154 #define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
3155 #define stbi__SOS(x) ((x) == 0xda)
3157 #define stbi__SOF_progressive(x) ((x) == 0xc2)
3159 static int stbi__decode_jpeg_header(stbi__jpeg *z,
int scan)
3163 z->app14_color_transform = -1;
3164 z->marker = STBI__MARKER_none;
3165 m = stbi__get_marker(z);
3166 if (!stbi__SOI(m))
return stbi__err(
"no SOI",
"Corrupt JPEG");
3167 if (scan == STBI__SCAN_type)
return 1;
3168 m = stbi__get_marker(z);
3169 while (!stbi__SOF(m)) {
3170 if (!stbi__process_marker(z,m))
return 0;
3171 m = stbi__get_marker(z);
3172 while (m == STBI__MARKER_none) {
3174 if (stbi__at_eof(z->s))
return stbi__err(
"no SOF",
"Corrupt JPEG");
3175 m = stbi__get_marker(z);
3178 z->progressive = stbi__SOF_progressive(m);
3179 if (!stbi__process_frame_header(z, scan))
return 0;
3184 static int stbi__decode_jpeg_image(stbi__jpeg *j)
3187 for (m = 0; m < 4; m++) {
3188 j->img_comp[m].raw_data = NULL;
3189 j->img_comp[m].raw_coeff = NULL;
3191 j->restart_interval = 0;
3192 if (!stbi__decode_jpeg_header(j, STBI__SCAN_load))
return 0;
3193 m = stbi__get_marker(j);
3194 while (!stbi__EOI(m)) {
3196 if (!stbi__process_scan_header(j))
return 0;
3197 if (!stbi__parse_entropy_coded_data(j))
return 0;
3198 if (j->marker == STBI__MARKER_none ) {
3200 while (!stbi__at_eof(j->s)) {
3201 int x = stbi__get8(j->s);
3203 j->marker = stbi__get8(j->s);
3209 }
else if (stbi__DNL(m)) {
3210 int Ld = stbi__get16be(j->s);
3211 stbi__uint32 NL = stbi__get16be(j->s);
3212 if (Ld != 4)
return stbi__err(
"bad DNL len",
"Corrupt JPEG");
3213 if (NL != j->s->img_y)
return stbi__err(
"bad DNL height",
"Corrupt JPEG");
3215 if (!stbi__process_marker(j, m))
return 0;
3217 m = stbi__get_marker(j);
3220 stbi__jpeg_finish(j);
3229 #define stbi__div4(x) ((stbi_uc) ((x) >> 2))
3234 STBI_NOTUSED(in_far);
3245 for (i=0; i <
w; ++i)
3246 out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
3258 out[0] = out[1] = input[0];
3263 out[1] = stbi__div4(input[0]*3 + input[1] + 2);
3264 for (i=1; i < w-1; ++i) {
3265 int n = 3*input[i]+2;
3266 out[i*2+0] = stbi__div4(n+input[i-1]);
3267 out[i*2+1] = stbi__div4(n+input[i+1]);
3269 out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
3270 out[i*2+1] = input[w-1];
3272 STBI_NOTUSED(in_far);
3278 #define stbi__div16(x) ((stbi_uc) ((x) >> 4))
3285 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3289 t1 = 3*in_near[0] + in_far[0];
3290 out[0] = stbi__div4(t1+2);
3291 for (i=1; i <
w; ++i) {
3293 t1 = 3*in_near[i]+in_far[i];
3294 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3295 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3297 out[w*2-1] = stbi__div4(t1+2);
3304 #if defined(STBI_SSE2) || defined(STBI_NEON)
3311 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3315 t1 = 3*in_near[0] + in_far[0];
3319 for (; i < ((w-1) & ~7); i += 8) {
3320 #if defined(STBI_SSE2)
3323 __m128i
zero = _mm_setzero_si128();
3324 __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
3325 __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
3326 __m128i farw = _mm_unpacklo_epi8(farb, zero);
3327 __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
3328 __m128i diff = _mm_sub_epi16(farw, nearw);
3329 __m128i nears = _mm_slli_epi16(nearw, 2);
3330 __m128i curr = _mm_add_epi16(nears, diff);
3337 __m128i prv0 = _mm_slli_si128(curr, 2);
3338 __m128i nxt0 = _mm_srli_si128(curr, 2);
3339 __m128i prev = _mm_insert_epi16(prv0, t1, 0);
3340 __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
3346 __m128i bias = _mm_set1_epi16(8);
3347 __m128i curs = _mm_slli_epi16(curr, 2);
3348 __m128i prvd = _mm_sub_epi16(prev, curr);
3349 __m128i nxtd = _mm_sub_epi16(next, curr);
3350 __m128i curb = _mm_add_epi16(curs, bias);
3351 __m128i even = _mm_add_epi16(prvd, curb);
3352 __m128i odd = _mm_add_epi16(nxtd, curb);
3355 __m128i int0 = _mm_unpacklo_epi16(even, odd);
3356 __m128i int1 = _mm_unpackhi_epi16(even, odd);
3357 __m128i de0 = _mm_srli_epi16(int0, 4);
3358 __m128i de1 = _mm_srli_epi16(int1, 4);
3361 __m128i outv = _mm_packus_epi16(de0, de1);
3362 _mm_storeu_si128((__m128i *) (out + i*2), outv);
3363 #elif defined(STBI_NEON)
3366 uint8x8_t farb = vld1_u8(in_far + i);
3367 uint8x8_t nearb = vld1_u8(in_near + i);
3368 int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
3369 int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
3370 int16x8_t curr = vaddq_s16(nears, diff);
3377 int16x8_t prv0 = vextq_s16(curr, curr, 7);
3378 int16x8_t nxt0 = vextq_s16(curr, curr, 1);
3379 int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
3380 int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
3386 int16x8_t curs = vshlq_n_s16(curr, 2);
3387 int16x8_t prvd = vsubq_s16(prev, curr);
3388 int16x8_t nxtd = vsubq_s16(next, curr);
3389 int16x8_t even = vaddq_s16(curs, prvd);
3390 int16x8_t odd = vaddq_s16(curs, nxtd);
3394 o.val[0] = vqrshrun_n_s16(even, 4);
3395 o.val[1] = vqrshrun_n_s16(odd, 4);
3396 vst2_u8(out + i*2, o);
3400 t1 = 3*in_near[i+7] + in_far[i+7];
3404 t1 = 3*in_near[i] + in_far[i];
3405 out[i*2] = stbi__div16(3*t1 + t0 + 8);
3407 for (++i; i <
w; ++i) {
3409 t1 = 3*in_near[i]+in_far[i];
3410 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3411 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3413 out[w*2-1] = stbi__div4(t1+2);
3425 STBI_NOTUSED(in_far);
3426 for (i=0; i <
w; ++i)
3427 for (j=0; j < hs; ++
j)
3428 out[i*hs+j] = in_near[i];
3434 #define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
3438 for (i=0; i <
count; ++i) {
3439 int y_fixed = (y[i] << 20) + (1<<19);
3441 int cr = pcr[i] - 128;
3442 int cb = pcb[i] - 128;
3443 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3444 g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3445 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3449 if ((
unsigned) r > 255) {
if (r < 0) r = 0;
else r = 255; }
3450 if ((
unsigned) g > 255) {
if (g < 0) g = 0;
else g = 255; }
3451 if ((
unsigned) b > 255) {
if (b < 0) b = 0;
else b = 255; }
3460 #if defined(STBI_SSE2) || defined(STBI_NEON)
3471 __m128i signflip = _mm_set1_epi8(-0x80);
3472 __m128i cr_const0 = _mm_set1_epi16( (
short) ( 1.40200f*4096.0f+0.5f));
3473 __m128i cr_const1 = _mm_set1_epi16( - (
short) ( 0.71414f*4096.0f+0.5f));
3474 __m128i cb_const0 = _mm_set1_epi16( - (
short) ( 0.34414f*4096.0f+0.5f));
3475 __m128i cb_const1 = _mm_set1_epi16( (
short) ( 1.77200f*4096.0f+0.5f));
3476 __m128i y_bias = _mm_set1_epi8((
char) (
unsigned char) 128);
3477 __m128i xw = _mm_set1_epi16(255);
3479 for (; i+7 <
count; i += 8) {
3481 __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
3482 __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
3483 __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
3484 __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip);
3485 __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip);
3488 __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
3489 __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
3490 __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
3493 __m128i yws = _mm_srli_epi16(yw, 4);
3494 __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
3495 __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
3496 __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
3497 __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
3498 __m128i rws = _mm_add_epi16(cr0, yws);
3499 __m128i gwt = _mm_add_epi16(cb0, yws);
3500 __m128i bws = _mm_add_epi16(yws, cb1);
3501 __m128i gws = _mm_add_epi16(gwt, cr1);
3504 __m128i rw = _mm_srai_epi16(rws, 4);
3505 __m128i bw = _mm_srai_epi16(bws, 4);
3506 __m128i gw = _mm_srai_epi16(gws, 4);
3509 __m128i brb = _mm_packus_epi16(rw, bw);
3510 __m128i gxb = _mm_packus_epi16(gw, xw);
3513 __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
3514 __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
3515 __m128i o0 = _mm_unpacklo_epi16(t0, t1);
3516 __m128i o1 = _mm_unpackhi_epi16(t0, t1);
3519 _mm_storeu_si128((__m128i *) (out + 0), o0);
3520 _mm_storeu_si128((__m128i *) (out + 16), o1);
3530 uint8x8_t signflip = vdup_n_u8(0x80);
3531 int16x8_t cr_const0 = vdupq_n_s16( (
short) ( 1.40200f*4096.0f+0.5f));
3532 int16x8_t cr_const1 = vdupq_n_s16( - (
short) ( 0.71414f*4096.0f+0.5f));
3533 int16x8_t cb_const0 = vdupq_n_s16( - (
short) ( 0.34414f*4096.0f+0.5f));
3534 int16x8_t cb_const1 = vdupq_n_s16( (
short) ( 1.77200f*4096.0f+0.5f));
3536 for (; i+7 <
count; i += 8) {
3538 uint8x8_t y_bytes = vld1_u8(y + i);
3539 uint8x8_t cr_bytes = vld1_u8(pcr + i);
3540 uint8x8_t cb_bytes = vld1_u8(pcb + i);
3541 int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
3542 int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
3545 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
3546 int16x8_t crw = vshll_n_s8(cr_biased, 7);
3547 int16x8_t cbw = vshll_n_s8(cb_biased, 7);
3550 int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
3551 int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
3552 int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
3553 int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
3554 int16x8_t rws = vaddq_s16(yws, cr0);
3555 int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
3556 int16x8_t bws = vaddq_s16(yws, cb1);
3560 o.val[0] = vqrshrun_n_s16(rws, 4);
3561 o.val[1] = vqrshrun_n_s16(gws, 4);
3562 o.val[2] = vqrshrun_n_s16(bws, 4);
3563 o.val[3] = vdup_n_u8(255);
3572 for (; i <
count; ++i) {
3573 int y_fixed = (y[i] << 20) + (1<<19);
3575 int cr = pcr[i] - 128;
3576 int cb = pcb[i] - 128;
3577 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3578 g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3579 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3583 if ((
unsigned) r > 255) {
if (r < 0) r = 0;
else r = 255; }
3584 if ((
unsigned) g > 255) {
if (g < 0) g = 0;
else g = 255; }
3585 if ((
unsigned) b > 255) {
if (b < 0) b = 0;
else b = 255; }
3596 static void stbi__setup_jpeg(stbi__jpeg *j)
3598 j->idct_block_kernel = stbi__idct_block;
3599 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
3600 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
3603 if (stbi__sse2_available()) {
3604 j->idct_block_kernel = stbi__idct_simd;
3605 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3606 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3611 j->idct_block_kernel = stbi__idct_simd;
3612 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3613 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3618 static void stbi__cleanup_jpeg(stbi__jpeg *j)
3620 stbi__free_jpeg_components(j, j->s->img_n, 0);
3636 unsigned int t = x*y + 128;
3637 return (
stbi_uc) ((t + (t >>8)) >> 8);
3640 static stbi_uc *load_jpeg_image(stbi__jpeg *z,
int *out_x,
int *out_y,
int *comp,
int req_comp)
3642 int n, decode_n, is_rgb;
3646 if (req_comp < 0 || req_comp > 4)
return stbi__errpuc(
"bad req_comp",
"Internal error");
3649 if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z);
return NULL; }
3652 n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
3654 is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
3656 if (z->s->img_n == 3 && n < 3 && !is_rgb)
3659 decode_n = z->s->img_n;
3666 stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
3668 stbi__resample res_comp[4];
3670 for (k=0; k < decode_n; ++k) {
3671 stbi__resample *r = &res_comp[k];
3675 z->img_comp[k].linebuf = (
stbi_uc *) stbi__malloc(z->s->img_x + 3);
3676 if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
3678 r->hs = z->img_h_max / z->img_comp[k].h;
3679 r->vs = z->img_v_max / z->img_comp[k].v;
3680 r->ystep = r->vs >> 1;
3681 r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
3683 r->line0 = r->line1 = z->img_comp[k].data;
3685 if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
3686 else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
3687 else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
3688 else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
3689 else r->resample = stbi__resample_row_generic;
3693 output = (
stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
3694 if (!output) { stbi__cleanup_jpeg(z);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
3697 for (j=0; j < z->s->img_y; ++
j) {
3698 stbi_uc *out = output + n * z->s->img_x *
j;
3699 for (k=0; k < decode_n; ++k) {
3700 stbi__resample *r = &res_comp[k];
3701 int y_bot = r->ystep >= (r->vs >> 1);
3702 coutput[k] = r->resample(z->img_comp[k].linebuf,
3703 y_bot ? r->line1 : r->line0,
3704 y_bot ? r->line0 : r->line1,
3706 if (++r->ystep >= r->vs) {
3708 r->line0 = r->line1;
3709 if (++r->ypos < z->img_comp[k].y)
3710 r->line1 += z->img_comp[k].w2;
3715 if (z->s->img_n == 3) {
3717 for (i=0; i < z->s->img_x; ++i) {
3719 out[1] = coutput[1][i];
3720 out[2] = coutput[2][i];
3725 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3727 }
else if (z->s->img_n == 4) {
3728 if (z->app14_color_transform == 0) {
3729 for (i=0; i < z->s->img_x; ++i) {
3731 out[0] = stbi__blinn_8x8(coutput[0][i], m);
3732 out[1] = stbi__blinn_8x8(coutput[1][i], m);
3733 out[2] = stbi__blinn_8x8(coutput[2][i], m);
3737 }
else if (z->app14_color_transform == 2) {
3738 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3739 for (i=0; i < z->s->img_x; ++i) {
3741 out[0] = stbi__blinn_8x8(255 - out[0], m);
3742 out[1] = stbi__blinn_8x8(255 - out[1], m);
3743 out[2] = stbi__blinn_8x8(255 - out[2], m);
3747 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3750 for (i=0; i < z->s->img_x; ++i) {
3751 out[0] = out[1] = out[2] = y[i];
3758 for (i=0; i < z->s->img_x; ++i)
3759 *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3761 for (i=0; i < z->s->img_x; ++i, out += 2) {
3762 out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3766 }
else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
3767 for (i=0; i < z->s->img_x; ++i) {
3769 stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
3770 stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
3771 stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
3772 out[0] = stbi__compute_y(r, g, b);
3776 }
else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
3777 for (i=0; i < z->s->img_x; ++i) {
3778 out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
3785 for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
3787 for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
3791 stbi__cleanup_jpeg(z);
3792 *out_x = z->s->img_x;
3793 *out_y = z->s->img_y;
3794 if (comp) *comp = z->s->img_n >= 3 ? 3 : 1;
3799 static void *stbi__jpeg_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
3802 stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(
sizeof(stbi__jpeg));
3805 stbi__setup_jpeg(j);
3806 result = load_jpeg_image(j, x,y,comp,req_comp);
3811 static int stbi__jpeg_test(stbi__context *s)
3814 stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(
sizeof(stbi__jpeg));
3816 stbi__setup_jpeg(j);
3817 r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
3823 static int stbi__jpeg_info_raw(stbi__jpeg *j,
int *x,
int *y,
int *comp)
3825 if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
3826 stbi__rewind( j->s );
3829 if (x) *x = j->s->img_x;
3830 if (y) *y = j->s->img_y;
3831 if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
3835 static int stbi__jpeg_info(stbi__context *s,
int *x,
int *y,
int *comp)
3838 stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(
sizeof(stbi__jpeg)));
3840 result = stbi__jpeg_info_raw(j, x, y, comp);
3853 #ifndef STBI_NO_ZLIB
3856 #define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
3857 #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
3863 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
3864 stbi__uint16 firstcode[16];
3866 stbi__uint16 firstsymbol[16];
3868 stbi__uint16
value[288];
3871 stbi_inline
static int stbi__bitreverse16(
int n)
3873 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
3874 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
3875 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
3876 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
3880 stbi_inline
static int stbi__bit_reverse(
int v,
int bits)
3882 STBI_ASSERT(bits <= 16);
3885 return stbi__bitreverse16(v) >> (16-bits);
3888 static int stbi__zbuild_huffman(stbi__zhuffman *z,
const stbi_uc *sizelist,
int num)
3891 int code, next_code[16], sizes[17];
3894 memset(sizes, 0,
sizeof(sizes));
3895 memset(z->fast, 0,
sizeof(z->fast));
3896 for (i=0; i < num; ++i)
3897 ++sizes[sizelist[i]];
3899 for (i=1; i < 16; ++i)
3900 if (sizes[i] > (1 << i))
3901 return stbi__err(
"bad sizes",
"Corrupt PNG");
3903 for (i=1; i < 16; ++i) {
3904 next_code[i] = code;
3905 z->firstcode[i] = (stbi__uint16) code;
3906 z->firstsymbol[i] = (stbi__uint16) k;
3907 code = (code + sizes[i]);
3909 if (code-1 >= (1 << i))
return stbi__err(
"bad codelengths",
"Corrupt PNG");
3910 z->maxcode[i] = code << (16-i);
3914 z->maxcode[16] = 0x10000;
3915 for (i=0; i < num; ++i) {
3916 int s = sizelist[i];
3918 int c = next_code[
s] - z->firstcode[
s] + z->firstsymbol[
s];
3919 stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
3921 z->value[
c] = (stbi__uint16) i;
3922 if (s <= STBI__ZFAST_BITS) {
3923 int j = stbi__bit_reverse(next_code[s],s);
3924 while (j < (1 << STBI__ZFAST_BITS)) {
3943 stbi_uc *zbuffer, *zbuffer_end;
3945 stbi__uint32 code_buffer;
3952 stbi__zhuffman z_length, z_distance;
3955 stbi_inline
static stbi_uc stbi__zget8(stbi__zbuf *z)
3957 if (z->zbuffer >= z->zbuffer_end)
return 0;
3958 return *z->zbuffer++;
3961 static void stbi__fill_bits(stbi__zbuf *z)
3964 STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
3965 z->code_buffer |= (
unsigned int) stbi__zget8(z) << z->num_bits;
3967 }
while (z->num_bits <= 24);
3970 stbi_inline
static unsigned int stbi__zreceive(stbi__zbuf *z,
int n)
3973 if (z->num_bits < n) stbi__fill_bits(z);
3974 k = z->code_buffer & ((1 <<
n) - 1);
3975 z->code_buffer >>=
n;
3980 static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
3985 k = stbi__bit_reverse(a->code_buffer, 16);
3986 for (s=STBI__ZFAST_BITS+1; ; ++
s)
3987 if (k < z->maxcode[s])
3989 if (s == 16)
return -1;
3991 b = (k >> (16-
s)) - z->firstcode[
s] + z->firstsymbol[
s];
3992 STBI_ASSERT(z->size[b] == s);
3993 a->code_buffer >>=
s;
3998 stbi_inline
static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
4001 if (a->num_bits < 16) stbi__fill_bits(a);
4002 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
4005 a->code_buffer >>=
s;
4009 return stbi__zhuffman_decode_slowpath(a, z);
4012 static int stbi__zexpand(stbi__zbuf *z,
char *zout,
int n)
4015 int cur, limit, old_limit;
4017 if (!z->z_expandable)
return stbi__err(
"output buffer limit",
"Corrupt PNG");
4018 cur = (
int) (z->zout - z->zout_start);
4019 limit = old_limit = (
int) (z->zout_end - z->zout_start);
4020 while (cur + n > limit)
4022 q = (
char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
4023 STBI_NOTUSED(old_limit);
4024 if (q == NULL)
return stbi__err(
"outofmem",
"Out of memory");
4027 z->zout_end = q + limit;
4031 static const int stbi__zlength_base[31] = {
4032 3,4,5,6,7,8,9,10,11,13,
4033 15,17,19,23,27,31,35,43,51,59,
4034 67,83,99,115,131,163,195,227,258,0,0 };
4036 static const int stbi__zlength_extra[31]=
4037 { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
4039 static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
4040 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
4042 static const int stbi__zdist_extra[32] =
4043 { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
4045 static int stbi__parse_huffman_block(stbi__zbuf *a)
4047 char *zout = a->zout;
4049 int z = stbi__zhuffman_decode(a, &a->z_length);
4051 if (z < 0)
return stbi__err(
"bad huffman code",
"Corrupt PNG");
4052 if (zout >= a->zout_end) {
4053 if (!stbi__zexpand(a, zout, 1))
return 0;
4065 len = stbi__zlength_base[
z];
4066 if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
4067 z = stbi__zhuffman_decode(a, &a->z_distance);
4068 if (z < 0)
return stbi__err(
"bad huffman code",
"Corrupt PNG");
4069 dist = stbi__zdist_base[
z];
4070 if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
4071 if (zout - a->zout_start < dist)
return stbi__err(
"bad dist",
"Corrupt PNG");
4072 if (zout + len > a->zout_end) {
4073 if (!stbi__zexpand(a, zout, len))
return 0;
4076 p = (
stbi_uc *) (zout - dist);
4079 if (len) {
do *zout++ =
v;
while (--len); }
4081 if (len) {
do *zout++ = *p++;
while (--len); }
4087 static int stbi__compute_huffman_codes(stbi__zbuf *a)
4089 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 };
4090 stbi__zhuffman z_codelength;
4095 int hlit = stbi__zreceive(a,5) + 257;
4096 int hdist = stbi__zreceive(a,5) + 1;
4097 int hclen = stbi__zreceive(a,4) + 4;
4098 int ntot = hlit + hdist;
4100 memset(codelength_sizes, 0,
sizeof(codelength_sizes));
4101 for (i=0; i < hclen; ++i) {
4102 int s = stbi__zreceive(a,3);
4103 codelength_sizes[length_dezigzag[i]] = (
stbi_uc) s;
4105 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19))
return 0;
4109 int c = stbi__zhuffman_decode(a, &z_codelength);
4110 if (c < 0 || c >= 19)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
4116 c = stbi__zreceive(a,2)+3;
4117 if (n == 0)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
4118 fill = lencodes[n-1];
4120 c = stbi__zreceive(a,3)+3;
4122 STBI_ASSERT(c == 18);
4123 c = stbi__zreceive(a,7)+11;
4125 if (ntot - n < c)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
4126 memset(lencodes+n, fill, c);
4130 if (n != ntot)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
4131 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit))
return 0;
4132 if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist))
return 0;
4136 static int stbi__parse_uncompressed_block(stbi__zbuf *a)
4140 if (a->num_bits & 7)
4141 stbi__zreceive(a, a->num_bits & 7);
4144 while (a->num_bits > 0) {
4145 header[k++] = (
stbi_uc) (a->code_buffer & 255);
4146 a->code_buffer >>= 8;
4149 STBI_ASSERT(a->num_bits == 0);
4152 header[k++] = stbi__zget8(a);
4153 len = header[1] * 256 + header[0];
4154 nlen = header[3] * 256 + header[2];
4155 if (nlen != (len ^ 0xffff))
return stbi__err(
"zlib corrupt",
"Corrupt PNG");
4156 if (a->zbuffer + len > a->zbuffer_end)
return stbi__err(
"read past buffer",
"Corrupt PNG");
4157 if (a->zout + len > a->zout_end)
4158 if (!stbi__zexpand(a, a->zout, len))
return 0;
4159 memcpy(a->zout, a->zbuffer, len);
4165 static int stbi__parse_zlib_header(stbi__zbuf *a)
4167 int cmf = stbi__zget8(a);
4170 int flg = stbi__zget8(a);
4171 if ((cmf*256+flg) % 31 != 0)
return stbi__err(
"bad zlib header",
"Corrupt PNG");
4172 if (flg & 32)
return stbi__err(
"no preset dict",
"Corrupt PNG");
4173 if (cm != 8)
return stbi__err(
"bad compression",
"Corrupt PNG");
4178 static const stbi_uc stbi__zdefault_length[288] =
4180 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4181 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4182 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4183 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4184 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4185 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4186 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4187 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4188 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
4190 static const stbi_uc stbi__zdefault_distance[32] =
4192 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
4207 static int stbi__parse_zlib(stbi__zbuf *a,
int parse_header)
4211 if (!stbi__parse_zlib_header(a))
return 0;
4215 final = stbi__zreceive(a,1);
4216 type = stbi__zreceive(a,2);
4218 if (!stbi__parse_uncompressed_block(a))
return 0;
4219 }
else if (type == 3) {
4224 if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288))
return 0;
4225 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32))
return 0;
4227 if (!stbi__compute_huffman_codes(a))
return 0;
4229 if (!stbi__parse_huffman_block(a))
return 0;
4235 static int stbi__do_zlib(stbi__zbuf *a,
char *obuf,
int olen,
int exp,
int parse_header)
4237 a->zout_start = obuf;
4239 a->zout_end = obuf + olen;
4240 a->z_expandable =
exp;
4242 return stbi__parse_zlib(a, parse_header);
4248 char *p = (
char *) stbi__malloc(initial_size);
4249 if (p == NULL)
return NULL;
4250 a.zbuffer = (
stbi_uc *) buffer;
4251 a.zbuffer_end = (
stbi_uc *) buffer + len;
4252 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
4253 if (outlen) *outlen = (
int) (a.zout - a.zout_start);
4254 return a.zout_start;
4256 STBI_FREE(a.zout_start);
4269 char *p = (
char *) stbi__malloc(initial_size);
4270 if (p == NULL)
return NULL;
4271 a.zbuffer = (
stbi_uc *) buffer;
4272 a.zbuffer_end = (
stbi_uc *) buffer + len;
4273 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
4274 if (outlen) *outlen = (
int) (a.zout - a.zout_start);
4275 return a.zout_start;
4277 STBI_FREE(a.zout_start);
4285 a.zbuffer = (
stbi_uc *) ibuffer;
4286 a.zbuffer_end = (
stbi_uc *) ibuffer + ilen;
4287 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
4288 return (
int) (a.zout - a.zout_start);
4296 char *p = (
char *) stbi__malloc(16384);
4297 if (p == NULL)
return NULL;
4298 a.zbuffer = (
stbi_uc *) buffer;
4299 a.zbuffer_end = (
stbi_uc *) buffer+len;
4300 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
4301 if (outlen) *outlen = (
int) (a.zout - a.zout_start);
4302 return a.zout_start;
4304 STBI_FREE(a.zout_start);
4312 a.zbuffer = (
stbi_uc *) ibuffer;
4313 a.zbuffer_end = (
stbi_uc *) ibuffer + ilen;
4314 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
4315 return (
int) (a.zout - a.zout_start);
4338 static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
4341 c.length = stbi__get32be(s);
4342 c.type = stbi__get32be(s);
4346 static int stbi__check_png_header(stbi__context *s)
4348 static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
4350 for (i=0; i < 8; ++i)
4351 if (stbi__get8(s) != png_sig[i])
return stbi__err(
"bad png sig",
"Not a PNG");
4358 stbi_uc *idata, *expanded, *out;
4374 static stbi_uc first_row_filter[5] =
4383 static int stbi__paeth(
int a,
int b,
int c)
4389 if (pa <= pb && pa <= pc)
return a;
4390 if (pb <= pc)
return b;
4394 static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
4397 static int stbi__create_png_image_raw(stbi__png *a,
stbi_uc *raw, stbi__uint32 raw_len,
int out_n, stbi__uint32 x, stbi__uint32 y,
int depth,
int color)
4399 int bytes = (depth == 16? 2 : 1);
4400 stbi__context *s = a->s;
4401 stbi__uint32 i,
j,
stride = x*out_n*bytes;
4402 stbi__uint32 img_len, img_width_bytes;
4404 int img_n = s->img_n;
4406 int output_bytes = out_n*bytes;
4407 int filter_bytes = img_n*bytes;
4410 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
4411 a->out = (
stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0);
4412 if (!a->out)
return stbi__err(
"outofmem",
"Out of memory");
4414 if (!stbi__mad3sizes_valid(img_n, x, depth, 7))
return stbi__err(
"too large",
"Corrupt PNG");
4415 img_width_bytes = (((img_n * x *
depth) + 7) >> 3);
4416 img_len = (img_width_bytes + 1) * y;
4421 if (raw_len < img_len)
return stbi__err(
"not enough pixels",
"Corrupt PNG");
4423 for (j=0; j <
y; ++
j) {
4429 return stbi__err(
"invalid filter",
"Corrupt PNG");
4432 STBI_ASSERT(img_width_bytes <= x);
4433 cur += x*out_n - img_width_bytes;
4435 width = img_width_bytes;
4440 if (j == 0) filter = first_row_filter[
filter];
4443 for (k=0; k < filter_bytes; ++k) {
4445 case STBI__F_none : cur[k] = raw[k];
break;
4446 case STBI__F_sub : cur[k] = raw[k];
break;
4447 case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
break;
4448 case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
break;
4449 case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0));
break;
4450 case STBI__F_avg_first : cur[k] = raw[k];
break;
4451 case STBI__F_paeth_first: cur[k] = raw[k];
break;
4461 }
else if (depth == 16) {
4462 if (img_n != out_n) {
4463 cur[filter_bytes] = 255;
4464 cur[filter_bytes+1] = 255;
4466 raw += filter_bytes;
4467 cur += output_bytes;
4468 prior += output_bytes;
4476 if (depth < 8 || img_n == out_n) {
4477 int nk = (width - 1)*filter_bytes;
4478 #define STBI__CASE(f) \
4480 for (k=0; k < nk; ++k)
4483 case STBI__F_none: memcpy(cur, raw, nk);
break;
4484 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); }
break;
4485 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
break;
4486 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); }
break;
4487 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); }
break;
4488 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); }
break;
4489 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); }
break;
4494 STBI_ASSERT(img_n+1 == out_n);
4495 #define STBI__CASE(f) \
4497 for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
4498 for (k=0; k < filter_bytes; ++k)
4500 STBI__CASE(STBI__F_none) { cur[k] = raw[k]; }
break;
4501 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); }
break;
4502 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
break;
4503 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); }
break;
4504 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); }
break;
4505 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); }
break;
4506 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); }
break;
4513 cur = a->out + stride*
j;
4514 for (i=0; i <
x; ++i,cur+=output_bytes) {
4515 cur[filter_bytes+1] = 255;
4525 for (j=0; j <
y; ++
j) {
4527 stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes;
4530 stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1;
4539 for (k=x*img_n; k >= 2; k-=2, ++in) {
4540 *cur++ = scale * ((*in >> 4) );
4541 *cur++ = scale * ((*in ) & 0x0f);
4543 if (k > 0) *cur++ = scale * ((*in >> 4) );
4544 }
else if (depth == 2) {
4545 for (k=x*img_n; k >= 4; k-=4, ++in) {
4546 *cur++ = scale * ((*in >> 6) );
4547 *cur++ = scale * ((*in >> 4) & 0x03);
4548 *cur++ = scale * ((*in >> 2) & 0x03);
4549 *cur++ = scale * ((*in ) & 0x03);
4551 if (k > 0) *cur++ = scale * ((*in >> 6) );
4552 if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
4553 if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
4554 }
else if (depth == 1) {
4555 for (k=x*img_n; k >= 8; k-=8, ++in) {
4556 *cur++ = scale * ((*in >> 7) );
4557 *cur++ = scale * ((*in >> 6) & 0x01);
4558 *cur++ = scale * ((*in >> 5) & 0x01);
4559 *cur++ = scale * ((*in >> 4) & 0x01);
4560 *cur++ = scale * ((*in >> 3) & 0x01);
4561 *cur++ =
scale * ((*in >> 2) & 0x01);
4562 *cur++ =
scale * ((*in >> 1) & 0x01);
4563 *cur++ =
scale * ((*in ) & 0x01);
4565 if (k > 0) *cur++ =
scale * ((*in >> 7) );
4566 if (k > 1) *cur++ =
scale * ((*in >> 6) & 0x01);
4567 if (k > 2) *cur++ =
scale * ((*in >> 5) & 0x01);
4568 if (k > 3) *cur++ =
scale * ((*in >> 4) & 0x01);
4569 if (k > 4) *cur++ =
scale * ((*in >> 3) & 0x01);
4570 if (k > 5) *cur++ =
scale * ((*in >> 2) & 0x01);
4571 if (k > 6) *cur++ =
scale * ((*in >> 1) & 0x01);
4573 if (img_n != out_n) {
4576 cur = a->out + stride*
j;
4578 for (q=x-1; q >= 0; --
q) {
4580 cur[q*2+0] = cur[
q];
4583 STBI_ASSERT(img_n == 3);
4584 for (q=x-1; q >= 0; --
q) {
4586 cur[q*4+2] = cur[q*3+2];
4587 cur[q*4+1] = cur[q*3+1];
4588 cur[q*4+0] = cur[q*3+0];
4593 }
else if (depth == 16) {
4599 stbi__uint16 *cur16 = (stbi__uint16*)cur;
4601 for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
4602 *cur16 = (cur[0] << 8) | cur[1];
4609 static int stbi__create_png_image(stbi__png *a,
stbi_uc *image_data, stbi__uint32 image_data_len,
int out_n,
int depth,
int color,
int interlaced)
4611 int bytes = (depth == 16 ? 2 : 1);
4612 int out_bytes = out_n * bytes;
4616 return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
4619 final = (
stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
4620 for (p=0; p < 7; ++p) {
4621 int xorig[] = { 0,4,0,2,0,1,0 };
4622 int yorig[] = { 0,0,4,0,2,0,1 };
4623 int xspc[] = { 8,8,4,4,2,2,1 };
4624 int yspc[] = { 8,8,8,4,4,2,2 };
4627 x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
4628 y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
4630 stbi__uint32 img_len = ((((a->s->img_n * x *
depth) + 7) >> 3) + 1) *
y;
4631 if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
4635 for (j=0; j <
y; ++
j) {
4636 for (i=0; i <
x; ++i) {
4637 int out_y = j*yspc[p]+yorig[p];
4638 int out_x = i*xspc[p]+xorig[p];
4639 memcpy(
final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
4640 a->out + (j*x+i)*out_bytes, out_bytes);
4644 image_data += img_len;
4645 image_data_len -= img_len;
4653 static int stbi__compute_transparency(stbi__png *z,
stbi_uc tc[3],
int out_n)
4655 stbi__context *s = z->s;
4656 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4661 STBI_ASSERT(out_n == 2 || out_n == 4);
4664 for (i=0; i < pixel_count; ++i) {
4665 p[1] = (p[0] == tc[0] ? 0 : 255);
4669 for (i=0; i < pixel_count; ++i) {
4670 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4678 static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3],
int out_n)
4680 stbi__context *s = z->s;
4681 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4682 stbi__uint16 *p = (stbi__uint16*) z->out;
4686 STBI_ASSERT(out_n == 2 || out_n == 4);
4689 for (i = 0; i < pixel_count; ++i) {
4690 p[1] = (p[0] == tc[0] ? 0 : 65535);
4694 for (i = 0; i < pixel_count; ++i) {
4695 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4703 static int stbi__expand_png_palette(stbi__png *a,
stbi_uc *palette,
int len,
int pal_img_n)
4705 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
4706 stbi_uc *p, *temp_out, *orig = a->out;
4708 p = (
stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
4709 if (p == NULL)
return stbi__err(
"outofmem",
"Out of memory");
4714 if (pal_img_n == 3) {
4715 for (i=0; i < pixel_count; ++i) {
4718 p[1] = palette[n+1];
4719 p[2] = palette[n+2];
4723 for (i=0; i < pixel_count; ++i) {
4726 p[1] = palette[n+1];
4727 p[2] = palette[n+2];
4728 p[3] = palette[n+3];
4740 static int stbi__unpremultiply_on_load = 0;
4741 static int stbi__de_iphone_flag = 0;
4745 stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
4750 stbi__de_iphone_flag = flag_true_if_should_convert;
4753 static void stbi__de_iphone(stbi__png *z)
4755 stbi__context *s = z->s;
4756 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4759 if (s->img_out_n == 3) {
4760 for (i=0; i < pixel_count; ++i) {
4767 STBI_ASSERT(s->img_out_n == 4);
4768 if (stbi__unpremultiply_on_load) {
4770 for (i=0; i < pixel_count; ++i) {
4775 p[0] = (p[2] * 255 +
half) / a;
4776 p[1] = (p[1] * 255 +
half) / a;
4777 p[2] = ( t * 255 +
half) / a;
4786 for (i=0; i < pixel_count; ++i) {
4796 #define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
4798 static int stbi__parse_png_file(stbi__png *z,
int scan,
int req_comp)
4800 stbi_uc palette[1024], pal_img_n=0;
4801 stbi_uc has_trans=0, tc[3]={0};
4802 stbi__uint16 tc16[3];
4803 stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
4804 int first=1,k,interlace=0, color=0, is_iphone=0;
4805 stbi__context *s = z->s;
4811 if (!stbi__check_png_header(s))
return 0;
4813 if (scan == STBI__SCAN_type)
return 1;
4816 stbi__pngchunk c = stbi__get_chunk_header(s);
4818 case STBI__PNG_TYPE(
'C',
'g',
'B',
'I'):
4820 stbi__skip(s, c.length);
4822 case STBI__PNG_TYPE(
'I',
'H',
'D',
'R'): {
4824 if (!first)
return stbi__err(
"multiple IHDR",
"Corrupt PNG");
4826 if (c.length != 13)
return stbi__err(
"bad IHDR len",
"Corrupt PNG");
4827 s->img_x = stbi__get32be(s);
if (s->img_x > (1 << 24))
return stbi__err(
"too large",
"Very large image (corrupt?)");
4828 s->img_y = stbi__get32be(s);
if (s->img_y > (1 << 24))
return stbi__err(
"too large",
"Very large image (corrupt?)");
4829 z->depth = stbi__get8(s);
if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)
return stbi__err(
"1/2/4/8/16-bit only",
"PNG not supported: 1/2/4/8/16-bit only");
4830 color = stbi__get8(s);
if (color > 6)
return stbi__err(
"bad ctype",
"Corrupt PNG");
4831 if (color == 3 && z->depth == 16)
return stbi__err(
"bad ctype",
"Corrupt PNG");
4832 if (color == 3) pal_img_n = 3;
else if (color & 1)
return stbi__err(
"bad ctype",
"Corrupt PNG");
4833 comp = stbi__get8(s);
if (comp)
return stbi__err(
"bad comp method",
"Corrupt PNG");
4834 filter= stbi__get8(s);
if (filter)
return stbi__err(
"bad filter method",
"Corrupt PNG");
4835 interlace = stbi__get8(s);
if (interlace>1)
return stbi__err(
"bad interlace method",
"Corrupt PNG");
4836 if (!s->img_x || !s->img_y)
return stbi__err(
"0-pixel image",
"Corrupt PNG");
4838 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
4839 if ((1 << 30) / s->img_x / s->img_n < s->img_y)
return stbi__err(
"too large",
"Image too large to decode");
4840 if (scan == STBI__SCAN_header)
return 1;
4845 if ((1 << 30) / s->img_x / 4 < s->img_y)
return stbi__err(
"too large",
"Corrupt PNG");
4851 case STBI__PNG_TYPE(
'P',
'L',
'T',
'E'): {
4852 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
4853 if (c.length > 256*3)
return stbi__err(
"invalid PLTE",
"Corrupt PNG");
4854 pal_len = c.length / 3;
4855 if (pal_len * 3 != c.length)
return stbi__err(
"invalid PLTE",
"Corrupt PNG");
4856 for (i=0; i < pal_len; ++i) {
4857 palette[i*4+0] = stbi__get8(s);
4858 palette[i*4+1] = stbi__get8(s);
4859 palette[i*4+2] = stbi__get8(s);
4860 palette[i*4+3] = 255;
4865 case STBI__PNG_TYPE(
't',
'R',
'N',
'S'): {
4866 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
4867 if (z->idata)
return stbi__err(
"tRNS after IDAT",
"Corrupt PNG");
4869 if (scan == STBI__SCAN_header) { s->img_n = 4;
return 1; }
4870 if (pal_len == 0)
return stbi__err(
"tRNS before PLTE",
"Corrupt PNG");
4871 if (c.length > pal_len)
return stbi__err(
"bad tRNS len",
"Corrupt PNG");
4873 for (i=0; i < c.length; ++i)
4874 palette[i*4+3] = stbi__get8(s);
4876 if (!(s->img_n & 1))
return stbi__err(
"tRNS with alpha",
"Corrupt PNG");
4877 if (c.length != (stbi__uint32) s->img_n*2)
return stbi__err(
"bad tRNS len",
"Corrupt PNG");
4879 if (z->depth == 16) {
4880 for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s);
4882 for (k = 0; k < s->img_n; ++k) tc[k] = (
stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth];
4888 case STBI__PNG_TYPE(
'I',
'D',
'A',
'T'): {
4889 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
4890 if (pal_img_n && !pal_len)
return stbi__err(
"no PLTE",
"Corrupt PNG");
4891 if (scan == STBI__SCAN_header) { s->img_n = pal_img_n;
return 1; }
4892 if ((
int)(ioff + c.length) < (
int)ioff)
return 0;
4893 if (ioff + c.length > idata_limit) {
4894 stbi__uint32 idata_limit_old = idata_limit;
4896 if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
4897 while (ioff + c.length > idata_limit)
4899 STBI_NOTUSED(idata_limit_old);
4900 p = (
stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit);
if (p == NULL)
return stbi__err(
"outofmem",
"Out of memory");
4903 if (!stbi__getn(s, z->idata+ioff,c.length))
return stbi__err(
"outofdata",
"Corrupt PNG");
4908 case STBI__PNG_TYPE(
'I',
'E',
'N',
'D'): {
4909 stbi__uint32 raw_len, bpl;
4910 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
4911 if (scan != STBI__SCAN_load)
return 1;
4912 if (z->idata == NULL)
return stbi__err(
"no IDAT",
"Corrupt PNG");
4914 bpl = (s->img_x * z->depth + 7) / 8;
4915 raw_len = bpl * s->img_y * s->img_n + s->img_y ;
4917 if (z->expanded == NULL)
return 0;
4918 STBI_FREE(z->idata); z->idata = NULL;
4919 if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
4920 s->img_out_n = s->img_n+1;
4922 s->img_out_n = s->img_n;
4923 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace))
return 0;
4925 if (z->depth == 16) {
4926 if (!stbi__compute_transparency16(z, tc16, s->img_out_n))
return 0;
4928 if (!stbi__compute_transparency(z, tc, s->img_out_n))
return 0;
4931 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
4935 s->img_n = pal_img_n;
4936 s->img_out_n = pal_img_n;
4937 if (req_comp >= 3) s->img_out_n = req_comp;
4938 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
4940 }
else if (has_trans) {
4944 STBI_FREE(z->expanded); z->expanded = NULL;
4950 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
4951 if ((c.type & (1 << 29)) == 0) {
4952 #ifndef STBI_NO_FAILURE_STRINGS
4954 static char invalid_chunk[] =
"XXXX PNG chunk not known";
4955 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
4956 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
4957 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
4958 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
4960 return stbi__err(invalid_chunk,
"PNG not supported: unknown PNG chunk type");
4962 stbi__skip(s, c.length);
4970 static void *stbi__do_png(stbi__png *p,
int *x,
int *y,
int *n,
int req_comp, stbi__result_info *ri)
4973 if (req_comp < 0 || req_comp > 4)
return stbi__errpuc(
"bad req_comp",
"Internal error");
4974 if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
4976 ri->bits_per_channel = 8;
4978 ri->bits_per_channel = p->depth;
4981 if (req_comp && req_comp != p->s->img_out_n) {
4982 if (ri->bits_per_channel == 8)
4983 result = stbi__convert_format((
unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
4985 result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
4986 p->s->img_out_n = req_comp;
4987 if (result == NULL)
return result;
4991 if (n) *n = p->s->img_n;
4993 STBI_FREE(p->out); p->out = NULL;
4994 STBI_FREE(p->expanded); p->expanded = NULL;
4995 STBI_FREE(p->idata); p->idata = NULL;
5000 static void *stbi__png_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
5004 return stbi__do_png(&p, x,y,comp,req_comp, ri);
5007 static int stbi__png_test(stbi__context *s)
5010 r = stbi__check_png_header(s);
5015 static int stbi__png_info_raw(stbi__png *p,
int *x,
int *y,
int *comp)
5017 if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
5018 stbi__rewind( p->s );
5021 if (x) *x = p->s->img_x;
5022 if (y) *y = p->s->img_y;
5023 if (comp) *comp = p->s->img_n;
5027 static int stbi__png_info(stbi__context *s,
int *x,
int *y,
int *comp)
5031 return stbi__png_info_raw(&p, x, y, comp);
5034 static int stbi__png_is16(stbi__context *s)
5038 if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
5040 if (p.depth != 16) {
5051 static int stbi__bmp_test_raw(stbi__context *s)
5055 if (stbi__get8(s) !=
'B')
return 0;
5056 if (stbi__get8(s) !=
'M')
return 0;
5061 sz = stbi__get32le(s);
5062 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
5066 static int stbi__bmp_test(stbi__context *s)
5068 int r = stbi__bmp_test_raw(s);
5075 static int stbi__high_bit(
unsigned int z)
5078 if (z == 0)
return -1;
5079 if (z >= 0x10000) { n += 16; z >>= 16; }
5080 if (z >= 0x00100) { n += 8; z >>= 8; }
5081 if (z >= 0x00010) { n += 4; z >>= 4; }
5082 if (z >= 0x00004) { n += 2; z >>= 2; }
5083 if (z >= 0x00002) { n += 1; }
5087 static int stbi__bitcount(
unsigned int a)
5089 a = (a & 0x55555555) + ((a >> 1) & 0x55555555);
5090 a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
5091 a = (a + (a >> 4)) & 0x0f0f0f0f;
5093 a = (a + (a >> 16));
5100 static int stbi__shiftsigned(
unsigned int v,
int shift,
int bits)
5102 static unsigned int mul_table[9] = {
5104 0xff, 0x55, 0x49, 0x11,
5105 0x21, 0x41, 0x81, 0x01,
5107 static unsigned int shift_table[9] = {
5114 STBI_ASSERT(v >= 0 && v < 256);
5116 STBI_ASSERT(bits >= 0 && bits <= 8);
5117 return (
int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
5123 unsigned int mr,mg,mb,ma, all_a;
5126 static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
5129 if (stbi__get8(s) !=
'B' || stbi__get8(s) !=
'M')
return stbi__errpuc(
"not BMP",
"Corrupt BMP");
5133 info->offset = stbi__get32le(s);
5134 info->hsz = hsz = stbi__get32le(s);
5135 info->mr = info->mg = info->mb = info->ma = 0;
5137 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124)
return stbi__errpuc(
"unknown BMP",
"BMP type not supported: unknown");
5139 s->img_x = stbi__get16le(s);
5140 s->img_y = stbi__get16le(s);
5142 s->img_x = stbi__get32le(s);
5143 s->img_y = stbi__get32le(s);
5145 if (stbi__get16le(s) != 1)
return stbi__errpuc(
"bad BMP",
"bad BMP");
5146 info->bpp = stbi__get16le(s);
5148 int compress = stbi__get32le(s);
5149 if (compress == 1 || compress == 2)
return stbi__errpuc(
"BMP RLE",
"BMP type not supported: RLE");
5155 if (hsz == 40 || hsz == 56) {
5162 if (info->bpp == 16 || info->bpp == 32) {
5163 if (compress == 0) {
5164 if (info->bpp == 32) {
5165 info->mr = 0xffu << 16;
5166 info->mg = 0xffu << 8;
5167 info->mb = 0xffu << 0;
5168 info->ma = 0xffu << 24;
5171 info->mr = 31u << 10;
5172 info->mg = 31u << 5;
5173 info->mb = 31u << 0;
5175 }
else if (compress == 3) {
5176 info->mr = stbi__get32le(s);
5177 info->mg = stbi__get32le(s);
5178 info->mb = stbi__get32le(s);
5180 if (info->mr == info->mg && info->mg == info->mb) {
5182 return stbi__errpuc(
"bad BMP",
"bad BMP");
5185 return stbi__errpuc(
"bad BMP",
"bad BMP");
5189 if (hsz != 108 && hsz != 124)
5190 return stbi__errpuc(
"bad BMP",
"bad BMP");
5191 info->mr = stbi__get32le(s);
5192 info->mg = stbi__get32le(s);
5193 info->mb = stbi__get32le(s);
5194 info->ma = stbi__get32le(s);
5196 for (i=0; i < 12; ++i)
5210 static void *stbi__bmp_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
5213 unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
5217 stbi__bmp_data info;
5221 if (stbi__bmp_parse_header(s, &info) == NULL)
5224 flip_vertically = ((
int) s->img_y) > 0;
5225 s->img_y =
abs((
int) s->img_y);
5233 if (info.hsz == 12) {
5235 psize = (info.offset - 14 - 24) / 3;
5238 psize = (info.offset - 14 - info.hsz) >> 2;
5241 if (info.bpp == 24 && ma == 0xff000000)
5244 s->img_n = ma ? 4 : 3;
5245 if (req_comp && req_comp >= 3)
5251 if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
5252 return stbi__errpuc(
"too large",
"Corrupt BMP");
5254 out = (
stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
5255 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
5256 if (info.bpp < 16) {
5258 if (psize == 0 || psize > 256) { STBI_FREE(out);
return stbi__errpuc(
"invalid",
"Corrupt BMP"); }
5259 for (i=0; i < psize; ++i) {
5260 pal[i][2] = stbi__get8(s);
5261 pal[i][1] = stbi__get8(s);
5262 pal[i][0] = stbi__get8(s);
5263 if (info.hsz != 12) stbi__get8(s);
5266 stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
5267 if (info.bpp == 1) width = (s->img_x + 7) >> 3;
5268 else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
5269 else if (info.bpp == 8) width = s->img_x;
5270 else { STBI_FREE(out);
return stbi__errpuc(
"bad bpp",
"Corrupt BMP"); }
5272 if (info.bpp == 1) {
5273 for (j=0; j < (
int) s->img_y; ++j) {
5274 int bit_offset = 7, v = stbi__get8(s);
5275 for (i=0; i < (
int) s->img_x; ++i) {
5276 int color = (v>>bit_offset)&0x1;
5277 out[z++] = pal[
color][0];
5278 out[z++] = pal[
color][1];
5279 out[z++] = pal[
color][2];
5280 if (target == 4) out[z++] = 255;
5281 if (i+1 == (
int) s->img_x)
break;
5282 if((--bit_offset) < 0) {
5290 for (j=0; j < (
int) s->img_y; ++j) {
5291 for (i=0; i < (
int) s->img_x; i += 2) {
5292 int v=stbi__get8(s),
v2=0;
5293 if (info.bpp == 4) {
5297 out[z++] = pal[
v][0];
5298 out[z++] = pal[
v][1];
5299 out[z++] = pal[
v][2];
5300 if (target == 4) out[z++] = 255;
5301 if (i+1 == (
int) s->img_x)
break;
5302 v = (info.bpp == 8) ? stbi__get8(s) :
v2;
5303 out[z++] = pal[
v][0];
5304 out[z++] = pal[
v][1];
5305 out[z++] = pal[
v][2];
5306 if (target == 4) out[z++] = 255;
5312 int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
5315 stbi__skip(s, info.offset - 14 - info.hsz);
5316 if (info.bpp == 24) width = 3 * s->img_x;
5317 else if (info.bpp == 16) width = 2*s->img_x;
5320 if (info.bpp == 24) {
5322 }
else if (info.bpp == 32) {
5323 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
5327 if (!mr || !mg || !mb) { STBI_FREE(out);
return stbi__errpuc(
"bad masks",
"Corrupt BMP"); }
5329 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
5330 gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
5331 bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
5332 ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
5334 for (j=0; j < (
int) s->img_y; ++j) {
5336 for (i=0; i < (
int) s->img_x; ++i) {
5338 out[z+2] = stbi__get8(s);
5339 out[z+1] = stbi__get8(s);
5340 out[z+0] = stbi__get8(s);
5342 a = (easy == 2 ? stbi__get8(s) : 255);
5344 if (target == 4) out[z++] =
a;
5348 for (i=0; i < (
int) s->img_x; ++i) {
5349 stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
5351 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
5352 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
5353 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
5354 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
5356 if (target == 4) out[z++] = STBI__BYTECAST(a);
5364 if (target == 4 && all_a == 0)
5365 for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
5368 if (flip_vertically) {
5370 for (j=0; j < (
int) s->img_y>>1; ++j) {
5372 stbi_uc *p2 = out + (s->img_y-1-
j)*s->img_x*target;
5373 for (i=0; i < (
int) s->img_x*target; ++i) {
5374 t = p1[i]; p1[i] = p2[i]; p2[i] =
t;
5379 if (req_comp && req_comp != target) {
5380 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
5381 if (out == NULL)
return out;
5386 if (comp) *comp = s->img_n;
5395 static int stbi__tga_get_comp(
int bits_per_pixel,
int is_grey,
int* is_rgb16)
5398 if (is_rgb16) *is_rgb16 = 0;
5399 switch(bits_per_pixel) {
5403 case 15:
if(is_rgb16) *is_rgb16 = 1;
5406 case 32:
return bits_per_pixel/8;
5411 static int stbi__tga_info(stbi__context *s,
int *x,
int *y,
int *comp)
5413 int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
5414 int sz, tga_colormap_type;
5416 tga_colormap_type = stbi__get8(s);
5417 if( tga_colormap_type > 1 ) {
5421 tga_image_type = stbi__get8(s);
5422 if ( tga_colormap_type == 1 ) {
5423 if (tga_image_type != 1 && tga_image_type != 9) {
5429 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
5434 tga_colormap_bpp = sz;
5436 if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
5441 tga_colormap_bpp = 0;
5443 tga_w = stbi__get16le(s);
5448 tga_h = stbi__get16le(s);
5453 tga_bits_per_pixel = stbi__get8(s);
5455 if (tga_colormap_bpp != 0) {
5456 if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
5462 tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
5464 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
5472 if (comp) *comp = tga_comp;
5476 static int stbi__tga_test(stbi__context *s)
5479 int sz, tga_color_type;
5481 tga_color_type = stbi__get8(s);
5482 if ( tga_color_type > 1 )
goto errorEnd;
5484 if ( tga_color_type == 1 ) {
5485 if (sz != 1 && sz != 9)
goto errorEnd;
5488 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) )
goto errorEnd;
5491 if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) )
goto errorEnd;
5494 if ( stbi__get16le(s) < 1 )
goto errorEnd;
5495 if ( stbi__get16le(s) < 1 )
goto errorEnd;
5497 if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) )
goto errorEnd;
5498 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) )
goto errorEnd;
5508 static void stbi__tga_read_rgb16(stbi__context *s,
stbi_uc* out)
5510 stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
5511 stbi__uint16 fiveBitMask = 31;
5513 int r = (px >> 10) & fiveBitMask;
5514 int g = (px >> 5) & fiveBitMask;
5515 int b = px & fiveBitMask;
5517 out[0] = (
stbi_uc)((r * 255)/31);
5518 out[1] = (
stbi_uc)((g * 255)/31);
5519 out[2] = (
stbi_uc)((b * 255)/31);
5527 static void *stbi__tga_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
5530 int tga_offset = stbi__get8(s);
5531 int tga_indexed = stbi__get8(s);
5532 int tga_image_type = stbi__get8(s);
5534 int tga_palette_start = stbi__get16le(s);
5535 int tga_palette_len = stbi__get16le(s);
5536 int tga_palette_bits = stbi__get8(s);
5537 int tga_x_origin = stbi__get16le(s);
5538 int tga_y_origin = stbi__get16le(s);
5539 int tga_width = stbi__get16le(s);
5540 int tga_height = stbi__get16le(s);
5541 int tga_bits_per_pixel = stbi__get8(s);
5542 int tga_comp, tga_rgb16=0;
5543 int tga_inverted = stbi__get8(s);
5546 unsigned char *tga_data;
5547 unsigned char *tga_palette = NULL;
5549 unsigned char raw_data[4] = {0};
5551 int RLE_repeating = 0;
5552 int read_next_pixel = 1;
5554 STBI_NOTUSED(tga_x_origin);
5555 STBI_NOTUSED(tga_y_origin);
5558 if ( tga_image_type >= 8 )
5560 tga_image_type -= 8;
5563 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
5566 if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
5567 else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
5570 return stbi__errpuc(
"bad format",
"Can't find out TGA pixelformat");
5575 if (comp) *comp = tga_comp;
5577 if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
5578 return stbi__errpuc(
"too large",
"Corrupt TGA");
5580 tga_data = (
unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
5581 if (!tga_data)
return stbi__errpuc(
"outofmem",
"Out of memory");
5584 stbi__skip(s, tga_offset );
5586 if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
5587 for (i=0; i < tga_height; ++i) {
5588 int row = tga_inverted ? tga_height -i - 1 : i;
5589 stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
5590 stbi__getn(s, tga_row, tga_width * tga_comp);
5597 stbi__skip(s, tga_palette_start );
5599 tga_palette = (
unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
5601 STBI_FREE(tga_data);
5602 return stbi__errpuc(
"outofmem",
"Out of memory");
5605 stbi_uc *pal_entry = tga_palette;
5607 for (i=0; i < tga_palette_len; ++i) {
5608 stbi__tga_read_rgb16(s, pal_entry);
5609 pal_entry += tga_comp;
5611 }
else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
5612 STBI_FREE(tga_data);
5613 STBI_FREE(tga_palette);
5614 return stbi__errpuc(
"bad palette",
"Corrupt TGA");
5618 for (i=0; i < tga_width * tga_height; ++i)
5623 if ( RLE_count == 0 )
5626 int RLE_cmd = stbi__get8(s);
5627 RLE_count = 1 + (RLE_cmd & 127);
5628 RLE_repeating = RLE_cmd >> 7;
5629 read_next_pixel = 1;
5630 }
else if ( !RLE_repeating )
5632 read_next_pixel = 1;
5636 read_next_pixel = 1;
5639 if ( read_next_pixel )
5645 int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
5646 if ( pal_idx >= tga_palette_len ) {
5650 pal_idx *= tga_comp;
5651 for (j = 0; j < tga_comp; ++
j) {
5652 raw_data[
j] = tga_palette[pal_idx+
j];
5654 }
else if(tga_rgb16) {
5656 stbi__tga_read_rgb16(s, raw_data);
5659 for (j = 0; j < tga_comp; ++
j) {
5660 raw_data[
j] = stbi__get8(s);
5664 read_next_pixel = 0;
5668 for (j = 0; j < tga_comp; ++
j)
5669 tga_data[i*tga_comp+j] = raw_data[j];
5677 for (j = 0; j*2 < tga_height; ++
j)
5679 int index1 = j * tga_width * tga_comp;
5680 int index2 = (tga_height - 1 -
j) * tga_width * tga_comp;
5681 for (i = tga_width * tga_comp; i > 0; --i)
5683 unsigned char temp = tga_data[index1];
5684 tga_data[index1] = tga_data[index2];
5685 tga_data[index2] = temp;
5692 if ( tga_palette != NULL )
5694 STBI_FREE( tga_palette );
5699 if (tga_comp >= 3 && !tga_rgb16)
5701 unsigned char* tga_pixel = tga_data;
5702 for (i=0; i < tga_width * tga_height; ++i)
5704 unsigned char temp = tga_pixel[0];
5705 tga_pixel[0] = tga_pixel[2];
5706 tga_pixel[2] = temp;
5707 tga_pixel += tga_comp;
5712 if (req_comp && req_comp != tga_comp)
5713 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
5717 tga_palette_start = tga_palette_len = tga_palette_bits =
5718 tga_x_origin = tga_y_origin = 0;
5719 STBI_NOTUSED(tga_palette_start);
5729 static int stbi__psd_test(stbi__context *s)
5731 int r = (stbi__get32be(s) == 0x38425053);
5736 static int stbi__psd_decode_rle(stbi__context *s,
stbi_uc *p,
int pixelCount)
5738 int count, nleft, len;
5741 while ((nleft = pixelCount - count) > 0) {
5742 len = stbi__get8(s);
5745 }
else if (len < 128) {
5748 if (len > nleft)
return 0;
5755 }
else if (len > 128) {
5760 if (len > nleft)
return 0;
5761 val = stbi__get8(s);
5774 static void *stbi__psd_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc)
5777 int channelCount, compression;
5785 if (stbi__get32be(s) != 0x38425053)
5786 return stbi__errpuc(
"not PSD",
"Corrupt PSD image");
5789 if (stbi__get16be(s) != 1)
5790 return stbi__errpuc(
"wrong version",
"Unsupported version of PSD image");
5796 channelCount = stbi__get16be(s);
5797 if (channelCount < 0 || channelCount > 16)
5798 return stbi__errpuc(
"wrong channel count",
"Unsupported number of channels in PSD image");
5801 h = stbi__get32be(s);
5802 w = stbi__get32be(s);
5805 bitdepth = stbi__get16be(s);
5806 if (bitdepth != 8 && bitdepth != 16)
5807 return stbi__errpuc(
"unsupported bit depth",
"PSD bit depth is not 8 or 16 bit");
5819 if (stbi__get16be(s) != 3)
5820 return stbi__errpuc(
"wrong color format",
"PSD is not in RGB color format");
5823 stbi__skip(s,stbi__get32be(s) );
5826 stbi__skip(s, stbi__get32be(s) );
5829 stbi__skip(s, stbi__get32be(s) );
5835 compression = stbi__get16be(s);
5836 if (compression > 1)
5837 return stbi__errpuc(
"bad compression",
"PSD has an unknown compression format");
5840 if (!stbi__mad3sizes_valid(4, w, h, 0))
5841 return stbi__errpuc(
"too large",
"Corrupt PSD");
5845 if (!compression && bitdepth == 16 && bpc == 16) {
5846 out = (
stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
5847 ri->bits_per_channel = 16;
5849 out = (
stbi_uc *) stbi__malloc(4 * w*h);
5851 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
5869 stbi__skip(s, h * channelCount * 2 );
5872 for (channel = 0; channel < 4; channel++) {
5876 if (channel >= channelCount) {
5878 for (i = 0; i < pixelCount; i++, p += 4)
5879 *p = (channel == 3 ? 255 : 0);
5882 if (!stbi__psd_decode_rle(s, p, pixelCount)) {
5884 return stbi__errpuc(
"corrupt",
"bad RLE data");
5894 for (channel = 0; channel < 4; channel++) {
5895 if (channel >= channelCount) {
5897 if (bitdepth == 16 && bpc == 16) {
5898 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
5899 stbi__uint16 val = channel == 3 ? 65535 : 0;
5900 for (i = 0; i < pixelCount; i++, q += 4)
5904 stbi_uc val = channel == 3 ? 255 : 0;
5905 for (i = 0; i < pixelCount; i++, p += 4)
5909 if (ri->bits_per_channel == 16) {
5910 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
5911 for (i = 0; i < pixelCount; i++, q += 4)
5912 *q = (stbi__uint16) stbi__get16be(s);
5915 if (bitdepth == 16) {
5916 for (i = 0; i < pixelCount; i++, p += 4)
5917 *p = (
stbi_uc) (stbi__get16be(s) >> 8);
5919 for (i = 0; i < pixelCount; i++, p += 4)
5928 if (channelCount >= 4) {
5929 if (ri->bits_per_channel == 16) {
5930 for (i=0; i < w*
h; ++i) {
5931 stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
5932 if (pixel[3] != 0 && pixel[3] != 65535) {
5933 float a = pixel[3] / 65535.0f;
5934 float ra = 1.0f /
a;
5935 float inv_a = 65535.0f * (1 - ra);
5936 pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
5937 pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
5938 pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
5942 for (i=0; i < w*
h; ++i) {
5943 unsigned char *pixel = out + 4*i;
5944 if (pixel[3] != 0 && pixel[3] != 255) {
5945 float a = pixel[3] / 255.0f;
5946 float ra = 1.0f /
a;
5947 float inv_a = 255.0f * (1 - ra);
5948 pixel[0] = (
unsigned char) (pixel[0]*ra + inv_a);
5949 pixel[1] = (
unsigned char) (pixel[1]*ra + inv_a);
5950 pixel[2] = (
unsigned char) (pixel[2]*ra + inv_a);
5957 if (req_comp && req_comp != 4) {
5958 if (ri->bits_per_channel == 16)
5959 out = (
stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp,
w,
h);
5961 out = stbi__convert_format(out, 4, req_comp, w, h);
5962 if (out == NULL)
return out;
5965 if (comp) *comp = 4;
5981 static int stbi__pic_is4(stbi__context *s,
const char *str)
5985 if (stbi__get8(s) != (
stbi_uc)str[i])
5991 static int stbi__pic_test_core(stbi__context *s)
5995 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34"))
6001 if (!stbi__pic_is4(s,
"PICT"))
6012 static stbi_uc *stbi__readval(stbi__context *s,
int channel,
stbi_uc *dest)
6016 for (i=0; i<4; ++i, mask>>=1) {
6017 if (channel & mask) {
6018 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"PIC file too short");
6019 dest[i]=stbi__get8(s);
6026 static void stbi__copyval(
int channel,
stbi_uc *dest,
const stbi_uc *src)
6030 for (i=0;i<4; ++i, mask>>=1)
6035 static stbi_uc *stbi__pic_load_core(stbi__context *s,
int width,
int height,
int *comp,
stbi_uc *result)
6037 int act_comp=0,num_packets=0,
y,chained;
6038 stbi__pic_packet packets[10];
6043 stbi__pic_packet *packet;
6045 if (num_packets==
sizeof(packets)/
sizeof(packets[0]))
6046 return stbi__errpuc(
"bad format",
"too many packets");
6048 packet = &packets[num_packets++];
6050 chained = stbi__get8(s);
6051 packet->size = stbi__get8(s);
6052 packet->type = stbi__get8(s);
6053 packet->channel = stbi__get8(s);
6055 act_comp |= packet->channel;
6057 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (reading packets)");
6058 if (packet->size != 8)
return stbi__errpuc(
"bad format",
"packet isn't 8bpp");
6061 *comp = (act_comp & 0x10 ? 4 : 3);
6066 for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
6067 stbi__pic_packet *packet = &packets[packet_idx];
6068 stbi_uc *dest = result+y*width*4;
6070 switch (packet->type) {
6072 return stbi__errpuc(
"bad format",
"packet has bad compression type");
6077 for(x=0;x<
width;++
x, dest+=4)
6078 if (!stbi__readval(s,packet->channel,dest))
6090 count=stbi__get8(s);
6091 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (pure read count)");
6096 if (!stbi__readval(s,packet->channel,value))
return 0;
6098 for(i=0; i<
count; ++i,dest+=4)
6099 stbi__copyval(packet->channel,dest,value);
6108 int count = stbi__get8(s), i;
6109 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (mixed read count)");
6115 count = stbi__get16be(s);
6119 return stbi__errpuc(
"bad file",
"scanline overrun");
6121 if (!stbi__readval(s,packet->channel,value))
6124 for(i=0;i<
count;++i, dest += 4)
6125 stbi__copyval(packet->channel,dest,value);
6128 if (count>left)
return stbi__errpuc(
"bad file",
"scanline overrun");
6130 for(i=0;i<
count;++i, dest+=4)
6131 if (!stbi__readval(s,packet->channel,dest))
6145 static void *stbi__pic_load(stbi__context *s,
int *px,
int *
py,
int *comp,
int req_comp, stbi__result_info *ri)
6148 int i,
x,
y, internal_comp;
6151 if (!comp) comp = &internal_comp;
6153 for (i=0; i<92; ++i)
6156 x = stbi__get16be(s);
6157 y = stbi__get16be(s);
6158 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (pic header)");
6159 if (!stbi__mad3sizes_valid(x, y, 4, 0))
return stbi__errpuc(
"too large",
"PIC image too large to decode");
6166 result = (
stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
6167 memset(result, 0xff, x*y*4);
6169 if (!stbi__pic_load_core(s,x,y,comp, result)) {
6175 if (req_comp == 0) req_comp = *comp;
6176 result=stbi__convert_format(result,4,req_comp,x,y);
6181 static int stbi__pic_test(stbi__context *s)
6183 int r = stbi__pic_test_core(s);
6206 int flags, bgindex, ratio, transparent, eflags;
6209 stbi__gif_lzw codes[8192];
6213 int start_x, start_y;
6220 static int stbi__gif_test_raw(stbi__context *s)
6223 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
return 0;
6225 if (sz !=
'9' && sz !=
'7')
return 0;
6226 if (stbi__get8(s) !=
'a')
return 0;
6230 static int stbi__gif_test(stbi__context *s)
6232 int r = stbi__gif_test_raw(s);
6237 static void stbi__gif_parse_colortable(stbi__context *s,
stbi_uc pal[256][4],
int num_entries,
int transp)
6240 for (i=0; i < num_entries; ++i) {
6241 pal[i][2] = stbi__get8(s);
6242 pal[i][1] = stbi__get8(s);
6243 pal[i][0] = stbi__get8(s);
6244 pal[i][3] = transp == i ? 0 : 255;
6248 static int stbi__gif_header(stbi__context *s, stbi__gif *g,
int *comp,
int is_info)
6251 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
6252 return stbi__err(
"not GIF",
"Corrupt GIF");
6254 version = stbi__get8(s);
6255 if (version !=
'7' && version !=
'9')
return stbi__err(
"not GIF",
"Corrupt GIF");
6256 if (stbi__get8(s) !=
'a')
return stbi__err(
"not GIF",
"Corrupt GIF");
6258 stbi__g_failure_reason =
"";
6259 g->w = stbi__get16le(s);
6260 g->h = stbi__get16le(s);
6261 g->flags = stbi__get8(s);
6262 g->bgindex = stbi__get8(s);
6263 g->ratio = stbi__get8(s);
6264 g->transparent = -1;
6266 if (comp != 0) *comp = 4;
6268 if (is_info)
return 1;
6270 if (g->flags & 0x80)
6271 stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
6276 static int stbi__gif_info_raw(stbi__context *s,
int *x,
int *y,
int *comp)
6278 stbi__gif* g = (stbi__gif*) stbi__malloc(
sizeof(stbi__gif));
6279 if (!stbi__gif_header(s, g, comp, 1)) {
6290 static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
6297 if (g->codes[code].prefix >= 0)
6298 stbi__out_gif_code(g, g->codes[code].prefix);
6300 if (g->cur_y >= g->max_y)
return;
6302 idx = g->cur_x + g->cur_y;
6304 g->history[idx / 4] = 1;
6306 c = &g->color_table[g->codes[code].suffix * 4];
6315 if (g->cur_x >= g->max_x) {
6316 g->cur_x = g->start_x;
6317 g->cur_y += g->step;
6319 while (g->cur_y >= g->max_y && g->parse > 0) {
6320 g->step = (1 << g->parse) * g->line_size;
6321 g->cur_y = g->start_y + (g->step >> 1);
6327 static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
6330 stbi__int32 len, init_code;
6332 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
6335 lzw_cs = stbi__get8(s);
6336 if (lzw_cs > 12)
return NULL;
6337 clear = 1 << lzw_cs;
6339 codesize = lzw_cs + 1;
6340 codemask = (1 << codesize) - 1;
6343 for (init_code = 0; init_code < clear; init_code++) {
6344 g->codes[init_code].prefix = -1;
6345 g->codes[init_code].first = (
stbi_uc) init_code;
6346 g->codes[init_code].suffix = (
stbi_uc) init_code;
6355 if (valid_bits < codesize) {
6357 len = stbi__get8(s);
6362 bits |= (stbi__int32) stbi__get8(s) << valid_bits;
6365 stbi__int32 code = bits & codemask;
6367 valid_bits -= codesize;
6369 if (code == clear) {
6370 codesize = lzw_cs + 1;
6371 codemask = (1 << codesize) - 1;
6375 }
else if (code == clear + 1) {
6377 while ((len = stbi__get8(s)) > 0)
6380 }
else if (code <= avail) {
6382 return stbi__errpuc(
"no clear code",
"Corrupt GIF");
6386 p = &g->codes[avail++];
6388 return stbi__errpuc(
"too many codes",
"Corrupt GIF");
6391 p->prefix = (stbi__int16) oldcode;
6392 p->first = g->codes[oldcode].first;
6393 p->suffix = (code == avail) ? p->first : g->codes[code].first;
6394 }
else if (code == avail)
6395 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
6397 stbi__out_gif_code(g, (stbi__uint16) code);
6399 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
6401 codemask = (1 << codesize) - 1;
6406 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
6414 static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g,
int *comp,
int req_comp,
stbi_uc *two_back)
6420 STBI_NOTUSED(req_comp);
6425 if (!stbi__gif_header(s, g, comp,0))
return 0;
6426 if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
6427 return stbi__errpuc(
"too large",
"GIF image is too large");
6428 pcount = g->w * g->h;
6429 g->out = (
stbi_uc *) stbi__malloc(4 * pcount);
6430 g->background = (
stbi_uc *) stbi__malloc(4 * pcount);
6431 g->history = (
stbi_uc *) stbi__malloc(pcount);
6432 if (!g->out || !g->background || !g->history)
6433 return stbi__errpuc(
"outofmem",
"Out of memory");
6438 memset(g->out, 0x00, 4 * pcount);
6439 memset(g->background, 0x00, 4 * pcount);
6440 memset(g->history, 0x00, pcount);
6444 dispose = (g->eflags & 0x1C) >> 2;
6445 pcount = g->w * g->h;
6447 if ((dispose == 3) && (two_back == 0)) {
6452 for (pi = 0; pi < pcount; ++
pi) {
6453 if (g->history[pi]) {
6454 memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
6457 }
else if (dispose == 2) {
6459 for (pi = 0; pi < pcount; ++
pi) {
6460 if (g->history[pi]) {
6461 memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
6472 memcpy( g->background, g->out, 4 * g->w * g->h );
6476 memset( g->history, 0x00, g->w * g->h );
6479 int tag = stbi__get8(s);
6483 stbi__int32
x,
y,
w,
h;
6486 x = stbi__get16le(s);
6487 y = stbi__get16le(s);
6488 w = stbi__get16le(s);
6489 h = stbi__get16le(s);
6490 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
6491 return stbi__errpuc(
"bad Image Descriptor",
"Corrupt GIF");
6493 g->line_size = g->w * 4;
6495 g->start_y = y * g->line_size;
6496 g->max_x = g->start_x + w * 4;
6497 g->max_y = g->start_y + h * g->line_size;
6498 g->cur_x = g->start_x;
6499 g->cur_y = g->start_y;
6506 g->cur_y = g->max_y;
6508 g->lflags = stbi__get8(s);
6510 if (g->lflags & 0x40) {
6511 g->step = 8 * g->line_size;
6514 g->step = g->line_size;
6518 if (g->lflags & 0x80) {
6519 stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
6520 g->color_table = (
stbi_uc *) g->lpal;
6521 }
else if (g->flags & 0x80) {
6522 g->color_table = (
stbi_uc *) g->pal;
6524 return stbi__errpuc(
"missing color table",
"Corrupt GIF");
6526 o = stbi__process_gif_raster(s, g);
6527 if (!o)
return NULL;
6530 pcount = g->w * g->h;
6531 if (first_frame && (g->bgindex > 0)) {
6533 for (pi = 0; pi < pcount; ++
pi) {
6534 if (g->history[pi] == 0) {
6535 g->pal[g->bgindex][3] = 255;
6536 memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
6547 int ext = stbi__get8(s);
6549 len = stbi__get8(s);
6551 g->eflags = stbi__get8(s);
6552 g->delay = 10 * stbi__get16le(s);
6555 if (g->transparent >= 0) {
6556 g->pal[g->transparent][3] = 255;
6558 if (g->eflags & 0x01) {
6559 g->transparent = stbi__get8(s);
6560 if (g->transparent >= 0) {
6561 g->pal[g->transparent][3] = 0;
6566 g->transparent = -1;
6573 while ((len = stbi__get8(s)) != 0) {
6583 return stbi__errpuc(
"unknown code",
"Corrupt GIF");
6588 static void *stbi__load_gif_main(stbi__context *s,
int **delays,
int *x,
int *y,
int *z,
int *comp,
int req_comp)
6590 if (stbi__gif_test(s)) {
6597 memset(&g, 0,
sizeof(g));
6603 u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
6604 if (u == (
stbi_uc *) s) u = 0;
6610 stride = g.w * g.h * 4;
6613 out = (
stbi_uc*) STBI_REALLOC( out, layers * stride );
6615 *delays = (
int*) STBI_REALLOC( *delays,
sizeof(
int) * layers );
6618 out = (
stbi_uc*)stbi__malloc( layers * stride );
6620 *delays = (
int*) stbi__malloc( layers *
sizeof(
int) );
6623 memcpy( out + ((layers - 1) * stride), u, stride );
6625 two_back = out - 2 *
stride;
6629 (*delays)[layers - 1U] = g.delay;
6636 STBI_FREE(g.history);
6637 STBI_FREE(g.background);
6640 if (req_comp && req_comp != 4)
6641 out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
6646 return stbi__errpuc(
"not GIF",
"Image was not as a gif type.");
6650 static void *stbi__gif_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
6654 memset(&g, 0,
sizeof(g));
6657 u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
6658 if (u == (
stbi_uc *) s) u = 0;
6665 if (req_comp && req_comp != 4)
6666 u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
6673 STBI_FREE(g.history);
6674 STBI_FREE(g.background);
6679 static int stbi__gif_info(stbi__context *s,
int *x,
int *y,
int *comp)
6681 return stbi__gif_info_raw(s,x,y,comp);
6689 static int stbi__hdr_test_core(stbi__context *s,
const char *signature)
6692 for (i=0; signature[i]; ++i)
6693 if (stbi__get8(s) != signature[i])
6699 static int stbi__hdr_test(stbi__context* s)
6701 int r = stbi__hdr_test_core(s,
"#?RADIANCE\n");
6704 r = stbi__hdr_test_core(s,
"#?RGBE\n");
6710 #define STBI__HDR_BUFLEN 1024
6711 static char *stbi__hdr_gettoken(stbi__context *z,
char *buffer)
6716 c = (char) stbi__get8(z);
6718 while (!stbi__at_eof(z) && c !=
'\n') {
6720 if (len == STBI__HDR_BUFLEN-1) {
6722 while (!stbi__at_eof(z) && stbi__get8(z) !=
'\n')
6726 c = (char) stbi__get8(z);
6733 static void stbi__hdr_convert(
float *output,
stbi_uc *input,
int req_comp)
6735 if ( input[3] != 0 ) {
6738 f1 = (
float) ldexp(1.0f, input[3] - (
int)(128 + 8));
6740 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
6742 output[0] = input[0] * f1;
6743 output[1] = input[1] * f1;
6744 output[2] = input[2] * f1;
6746 if (req_comp == 2) output[1] = 1;
6747 if (req_comp == 4) output[3] = 1;
6750 case 4: output[3] = 1;
6751 case 3: output[0] = output[1] = output[2] = 0;
6753 case 2: output[1] = 1;
6754 case 1: output[0] = 0;
6760 static float *stbi__hdr_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
6762 char buffer[STBI__HDR_BUFLEN];
6770 int i,
j, k, c1,c2,
z;
6771 const char *headerToken;
6775 headerToken = stbi__hdr_gettoken(s,buffer);
6776 if (strcmp(headerToken,
"#?RADIANCE") != 0 && strcmp(headerToken,
"#?RGBE") != 0)
6777 return stbi__errpf(
"not HDR",
"Corrupt HDR image");
6781 token = stbi__hdr_gettoken(s,buffer);
6782 if (token[0] == 0)
break;
6783 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
6786 if (!valid)
return stbi__errpf(
"unsupported format",
"Unsupported HDR format");
6790 token = stbi__hdr_gettoken(s,buffer);
6791 if (strncmp(token,
"-Y ", 3))
return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
6793 height = (
int) strtol(token, &token, 10);
6794 while (*token ==
' ') ++token;
6795 if (strncmp(token,
"+X ", 3))
return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
6797 width = (
int) strtol(token, NULL, 10);
6802 if (comp) *comp = 3;
6803 if (req_comp == 0) req_comp = 3;
6805 if (!stbi__mad4sizes_valid(width, height, req_comp,
sizeof(
float), 0))
6806 return stbi__errpf(
"too large",
"HDR image is too large");
6809 hdr_data = (
float *) stbi__malloc_mad4(width, height, req_comp,
sizeof(
float), 0);
6811 return stbi__errpf(
"outofmem",
"Out of memory");
6818 for (i=0; i <
width; ++i) {
6821 stbi__getn(s, rgbe, 4);
6822 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
6829 for (j = 0; j <
height; ++
j) {
6832 len = stbi__get8(s);
6833 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
6840 rgbe[3] = (
stbi_uc) stbi__get8(s);
6841 stbi__hdr_convert(hdr_data, rgbe, req_comp);
6844 STBI_FREE(scanline);
6845 goto main_decode_loop;
6848 len |= stbi__get8(s);
6849 if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"invalid decoded scanline length",
"corrupt HDR"); }
6850 if (scanline == NULL) {
6851 scanline = (
stbi_uc *) stbi__malloc_mad2(width, 4, 0);
6853 STBI_FREE(hdr_data);
6854 return stbi__errpf(
"outofmem",
"Out of memory");
6858 for (k = 0; k < 4; ++k) {
6861 while ((nleft = width - i) > 0) {
6862 count = stbi__get8(s);
6865 value = stbi__get8(s);
6867 if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"corrupt",
"bad RLE data in HDR"); }
6868 for (z = 0; z <
count; ++
z)
6869 scanline[i++ * 4 + k] = value;
6872 if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"corrupt",
"bad RLE data in HDR"); }
6873 for (z = 0; z <
count; ++
z)
6874 scanline[i++ * 4 + k] = stbi__get8(s);
6878 for (i=0; i <
width; ++i)
6879 stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
6882 STBI_FREE(scanline);
6888 static int stbi__hdr_info(stbi__context *s,
int *x,
int *y,
int *comp)
6890 char buffer[STBI__HDR_BUFLEN];
6897 if (!comp) comp = &
dummy;
6899 if (stbi__hdr_test(s) == 0) {
6905 token = stbi__hdr_gettoken(s,buffer);
6906 if (token[0] == 0)
break;
6907 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
6914 token = stbi__hdr_gettoken(s,buffer);
6915 if (strncmp(token,
"-Y ", 3)) {
6920 *y = (
int) strtol(token, &token, 10);
6921 while (*token ==
' ') ++token;
6922 if (strncmp(token,
"+X ", 3)) {
6927 *x = (
int) strtol(token, NULL, 10);
6931 #endif // STBI_NO_HDR
6934 static int stbi__bmp_info(stbi__context *s,
int *x,
int *y,
int *comp)
6937 stbi__bmp_data info;
6940 p = stbi__bmp_parse_header(s, &info);
6944 if (x) *x = s->img_x;
6945 if (y) *y = s->img_y;
6947 if (info.bpp == 24 && info.ma == 0xff000000)
6950 *comp = info.ma ? 4 : 3;
6957 static int stbi__psd_info(stbi__context *s,
int *x,
int *y,
int *comp)
6962 if (!comp) comp = &
dummy;
6963 if (stbi__get32be(s) != 0x38425053) {
6967 if (stbi__get16be(s) != 1) {
6972 channelCount = stbi__get16be(s);
6973 if (channelCount < 0 || channelCount > 16) {
6977 *y = stbi__get32be(s);
6978 *x = stbi__get32be(s);
6979 depth = stbi__get16be(s);
6980 if (depth != 8 && depth != 16) {
6984 if (stbi__get16be(s) != 3) {
6992 static int stbi__psd_is16(stbi__context *s)
6994 int channelCount,
depth;
6995 if (stbi__get32be(s) != 0x38425053) {
6999 if (stbi__get16be(s) != 1) {
7004 channelCount = stbi__get16be(s);
7005 if (channelCount < 0 || channelCount > 16) {
7009 (
void) stbi__get32be(s);
7010 (
void) stbi__get32be(s);
7011 depth = stbi__get16be(s);
7021 static int stbi__pic_info(stbi__context *s,
int *x,
int *y,
int *comp)
7023 int act_comp=0,num_packets=0,chained,
dummy;
7024 stbi__pic_packet packets[10];
7028 if (!comp) comp = &
dummy;
7030 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34")) {
7037 *x = stbi__get16be(s);
7038 *y = stbi__get16be(s);
7039 if (stbi__at_eof(s)) {
7043 if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
7051 stbi__pic_packet *packet;
7053 if (num_packets==
sizeof(packets)/
sizeof(packets[0]))
7056 packet = &packets[num_packets++];
7057 chained = stbi__get8(s);
7058 packet->size = stbi__get8(s);
7059 packet->type = stbi__get8(s);
7060 packet->channel = stbi__get8(s);
7061 act_comp |= packet->channel;
7063 if (stbi__at_eof(s)) {
7067 if (packet->size != 8) {
7073 *comp = (act_comp & 0x10 ? 4 : 3);
7093 static int stbi__pnm_test(stbi__context *s)
7096 p = (char) stbi__get8(s);
7097 t = (char) stbi__get8(s);
7098 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
7105 static void *stbi__pnm_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
7110 if (!stbi__pnm_info(s, (
int *)&s->img_x, (
int *)&s->img_y, (
int *)&s->img_n))
7115 if (comp) *comp = s->img_n;
7117 if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
7118 return stbi__errpuc(
"too large",
"PNM too large");
7120 out = (
stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
7121 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
7122 stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
7124 if (req_comp && req_comp != s->img_n) {
7125 out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
7126 if (out == NULL)
return out;
7131 static int stbi__pnm_isspace(
char c)
7133 return c ==
' ' || c ==
'\t' || c ==
'\n' || c ==
'\v' || c ==
'\f' || c ==
'\r';
7136 static void stbi__pnm_skip_whitespace(stbi__context *s,
char *c)
7139 while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
7140 *c = (char) stbi__get8(s);
7142 if (stbi__at_eof(s) || *c !=
'#')
7145 while (!stbi__at_eof(s) && *c !=
'\n' && *c !=
'\r' )
7146 *c = (
char) stbi__get8(s);
7150 static int stbi__pnm_isdigit(
char c)
7152 return c >=
'0' && c <=
'9';
7155 static int stbi__pnm_getinteger(stbi__context *s,
char *c)
7159 while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
7160 value = value*10 + (*c -
'0');
7161 *c = (char) stbi__get8(s);
7167 static int stbi__pnm_info(stbi__context *s,
int *x,
int *y,
int *comp)
7174 if (!comp) comp = &
dummy;
7179 p = (char) stbi__get8(s);
7180 t = (char) stbi__get8(s);
7181 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
7186 *comp = (t ==
'6') ? 3 : 1;
7188 c = (char) stbi__get8(s);
7189 stbi__pnm_skip_whitespace(s, &c);
7191 *x = stbi__pnm_getinteger(s, &c);
7192 stbi__pnm_skip_whitespace(s, &c);
7194 *y = stbi__pnm_getinteger(s, &c);
7195 stbi__pnm_skip_whitespace(s, &c);
7197 maxv = stbi__pnm_getinteger(s, &c);
7200 return stbi__err(
"max value > 255",
"PPM image not 8-bit");
7206 static int stbi__info_main(stbi__context *s,
int *x,
int *y,
int *comp)
7208 #ifndef STBI_NO_JPEG
7209 if (stbi__jpeg_info(s, x, y, comp))
return 1;
7213 if (stbi__png_info(s, x, y, comp))
return 1;
7217 if (stbi__gif_info(s, x, y, comp))
return 1;
7221 if (stbi__bmp_info(s, x, y, comp))
return 1;
7225 if (stbi__psd_info(s, x, y, comp))
return 1;
7229 if (stbi__pic_info(s, x, y, comp))
return 1;
7233 if (stbi__pnm_info(s, x, y, comp))
return 1;
7237 if (stbi__hdr_info(s, x, y, comp))
return 1;
7242 if (stbi__tga_info(s, x, y, comp))
7245 return stbi__err(
"unknown image type",
"Image not of any known type, or corrupt");
7248 static int stbi__is_16_main(stbi__context *s)
7251 if (stbi__png_is16(s))
return 1;
7255 if (stbi__psd_is16(s))
return 1;
7261 #ifndef STBI_NO_STDIO
7264 FILE *f = stbi__fopen(filename,
"rb");
7266 if (!f)
return stbi__err(
"can't fopen",
"Unable to open file");
7276 long pos =
ftell(f);
7277 stbi__start_file(&s, f);
7278 r = stbi__info_main(&s,x,y,comp);
7285 FILE *f = stbi__fopen(filename,
"rb");
7287 if (!f)
return stbi__err(
"can't fopen",
"Unable to open file");
7297 long pos =
ftell(f);
7298 stbi__start_file(&s, f);
7299 r = stbi__is_16_main(&s);
7303 #endif // !STBI_NO_STDIO
7308 stbi__start_mem(&s,buffer,len);
7309 return stbi__info_main(&s,x,y,comp);
7316 return stbi__info_main(&s,x,y,comp);
7322 stbi__start_mem(&s,buffer,len);
7323 return stbi__is_16_main(&s);
7330 return stbi__is_16_main(&s);
7333 #endif // STB_IMAGE_IMPLEMENTATION
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
GLsizei GLfloat GLfloat yorig
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
GA_API const UT_StringHolder dist
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
GT_API const UT_StringHolder filename
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
STBIDEF const char * stbi_failure_reason(void)
imath_half_bits_t half
if we're in a C-only context, alias the half bits type to half
STBIDEF stbi_uc * stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
GLsizei const GLfloat * value
constexpr auto num_bits() -> int
GLdouble GLdouble GLdouble z
STBIDEF void stbi_hdr_to_ldr_scale(float scale)
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
GLboolean GLboolean GLboolean GLboolean a
STBIDEF float * stbi_loadf(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels)
GLuint GLsizei GLsizei * length
GLenum GLenum GLsizei void * image
**But if you need a result
STBIDEF int stbi_is_16_bit_from_file(FILE *f)
GLfloat GLfloat GLfloat v2
GLdouble GLdouble GLdouble q
STBIDEF stbi_us * stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma)
STBIDEF stbi_uc * stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
STBIDEF stbi_us * stbi_load_16(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels)
ImageBuf OIIO_API pow(const ImageBuf &A, cspan< float > B, ROI roi={}, int nthreads=0)
GA_API const UT_StringHolder scale
GLint GLsizei GLsizei height
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma)
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
STBIDEF void stbi_ldr_to_hdr_scale(float scale)
IMATH_NAMESPACE::V2f float
OIIO_UTIL_API FILE * fopen(string_view path, string_view mode)
Version of fopen that can handle UTF-8 paths even on Windows.
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
STBIDEF int stbi_is_hdr_from_file(FILE *f)
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
STBIDEF stbi_uc * stbi_load_from_file(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels)
GLint GLenum GLboolean GLsizei stride
STBIDEF int stbi_is_16_bit(char const *filename)
constexpr enabler dummy
An instance to use in EnableIf.
STBIDEF float * stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
GLdouble GLdouble GLint GLint order
cgltf_result(* read)(const struct cgltf_memory_options *memory_options, const struct cgltf_file_options *file_options, const char *path, cgltf_size *size, void **data)
GLboolean GLboolean GLboolean b
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp)
GLint GLint GLsizei GLsizei GLsizei depth
GT_API const UT_StringHolder version
int parse_header(const Char *&it, const Char *end, basic_format_specs< Char > &specs, GetArg get_arg)
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
STBIDEF stbi_us * stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
STBIDEF stbi_uc * stbi_load(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels)
GLfloat GLfloat GLfloat GLfloat h
OIIO_UTIL_API int fseek(FILE *file, int64_t offset, int whence)
Version of fseek that works with 64 bit offsets on all systems.
STBIDEF int stbi_is_hdr(char const *filename)
GLenum GLsizei GLsizei GLint * values
__hostdev__ constexpr T pi()
Pi constant taken from Boost to match old behaviour.
STBIDEF void stbi_image_free(void *retval_from_stbi_load)
OIIO_UTIL_API int64_t ftell(FILE *file)
Version of ftell that works with 64 bit offsets on all systems.
STBIDEF float * stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
STBIDEF stbi_uc * stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
STBIDEF char * stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen)
GLubyte GLubyte GLubyte GLubyte w
STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER IMATH_HOSTDEVICE constexpr T abs(T a) IMATH_NOEXCEPT
GLenum GLenum GLsizei void * row
ImageBuf OIIO_API add(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
STBIDEF char * stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen)
GLdouble GLdouble GLdouble y2
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the and then *wait for them to all complete We provide a helper *to make this easy
ImageBuf OIIO_API resample(const ImageBuf &src, bool interpolate=true, ROI roi={}, int nthreads=0)
ImageBuf OIIO_API zero(ROI roi, int nthreads=0)
STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user)
* for(int i=0;i< n_subtasks;++i)*tasks.push(pool-> push(myfunc))
STBIDEF float * stbi_loadf_from_file(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels)
STBIDEF stbi_us * stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels)
ImageBuf OIIO_API channels(const ImageBuf &src, int nchannels, cspan< int > channelorder, cspan< float > channelvalues={}, cspan< std::string > newchannelnames={}, bool shuffle_channel_names=false, int nthreads=0)
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
STBIDEF char * stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter