+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
102 #ifndef STBI_INCLUDE_STB_IMAGE_H
+
103 #define STBI_INCLUDE_STB_IMAGE_H
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
304 #ifndef STBI_NO_STDIO
+
+
306 #endif // STBI_NO_STDIO
+
+
308 #define STBI_VERSION 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
327 #ifdef STB_IMAGE_STATIC
+
328 #define STBIDEF static
+
+
330 #define STBIDEF extern
+
+
+
+
+
+
+
+
+
+
+
+
+
344 int (*read) (
void *user,
char *data,
int size);
+
345 void (*skip) (
void *user,
int n);
+
346 int (*eof) (
void *user);
+
+
+
+
+
+
+
+
+
+
357 #ifndef STBI_NO_STDIO
+
358 STBIDEF stbi_uc *
stbi_load (
char const *filename,
int *x,
int *y,
int *channels_in_file,
int desired_channels);
+
+
+
+
+
+
+
+
+
+
+
+
371 #ifndef STBI_NO_STDIO
+
+
+
+
+
+
+
+
380 #ifndef STBI_NO_LINEAR
+
+
+
+
384 #ifndef STBI_NO_STDIO
+
385 STBIDEF float *
stbi_loadf (
char const *filename,
int *x,
int *y,
int *channels_in_file,
int desired_channels);
+
+
+
+
+
+
+
+
393 #endif // STBI_NO_HDR
+
+
395 #ifndef STBI_NO_LINEAR
+
+
+
398 #endif // STBI_NO_LINEAR
+
+
+
+
+
403 #ifndef STBI_NO_STDIO
+
+
+
406 #endif // STBI_NO_STDIO
+
+
+
+
+
+
+
+
+
+
+
+
+
+
420 #ifndef STBI_NO_STDIO
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
458 #endif // STBI_INCLUDE_STB_IMAGE_H
+
+
460 #ifdef STB_IMAGE_IMPLEMENTATION
+
+
462 #if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+
463 || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+
464 || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+
465 || defined(STBI_ONLY_ZLIB)
+
466 #ifndef STBI_ONLY_JPEG
+
+
+
469 #ifndef STBI_ONLY_PNG
+
+
+
472 #ifndef STBI_ONLY_BMP
+
+
+
475 #ifndef STBI_ONLY_PSD
+
+
+
478 #ifndef STBI_ONLY_TGA
+
+
+
481 #ifndef STBI_ONLY_GIF
+
+
+
484 #ifndef STBI_ONLY_HDR
+
+
+
487 #ifndef STBI_ONLY_PIC
+
+
+
490 #ifndef STBI_ONLY_PNM
+
+
+
+
+
495 #if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+
+
+
+
+
+
+
+
+
+
+
506 #if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+
+
+
+
510 #ifndef STBI_NO_STDIO
+
+
+
+
+
+
516 #define STBI_ASSERT(x) assert(x)
+
+
+
+
+
+
522 #define stbi_inline inline
+
+
+
+
+
527 #define stbi_inline __forceinline
+
+
+
+
+
532 typedef unsigned short stbi__uint16;
+
533 typedef signed short stbi__int16;
+
534 typedef unsigned int stbi__uint32;
+
535 typedef signed int stbi__int32;
+
+
+
538 typedef uint16_t stbi__uint16;
+
539 typedef int16_t stbi__int16;
+
540 typedef uint32_t stbi__uint32;
+
541 typedef int32_t stbi__int32;
+
+
+
+
545 typedef unsigned char validate_uint32[
sizeof(stbi__uint32)==4 ? 1 : -1];
+
+
+
548 #define STBI_NOTUSED(v) (void)(v)
+
+
550 #define STBI_NOTUSED(v) (void)sizeof(v)
+
+
+
+
554 #define STBI_HAS_LROTL
+
+
+
557 #ifdef STBI_HAS_LROTL
+
558 #define stbi_lrot(x,y) _lrotl(x,y)
+
+
560 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
+
+
+
563 #if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+
+
565 #elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+
+
+
568 #error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+
+
+
+
572 #define STBI_MALLOC(sz) malloc(sz)
+
573 #define STBI_REALLOC(p,newsz) realloc(p,newsz)
+
574 #define STBI_FREE(p) free(p)
+
+
+
577 #ifndef STBI_REALLOC_SIZED
+
578 #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+
+
+
+
582 #if defined(__x86_64__) || defined(_M_X64)
+
583 #define STBI__X64_TARGET
+
584 #elif defined(__i386) || defined(_M_IX86)
+
585 #define STBI__X86_TARGET
+
+
+
588 #if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+
+
+
+
+
+
+
+
+
+
+
599 #if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
614 #if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+
+
616 #include <emmintrin.h>
+
+
+
+
620 #if _MSC_VER >= 1400 // not VC6
+
+
622 static int stbi__cpuid3(
void)
+
+
+
+
+
+
+
629 static int stbi__cpuid3(
void)
+
+
+
+
+
+
+
+
+
+
+
+
641 #define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+
643 static int stbi__sse2_available(
void)
+
+
645 int info3 = stbi__cpuid3();
+
646 return ((info3 >> 26) & 1) != 0;
+
+
648 #else // assume GCC-style if not VC++
+
649 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+
651 static int stbi__sse2_available(
void)
+
+
+
+
+
+
+
+
+
+
+
662 #if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+
+
+
+
+
667 #include <arm_neon.h>
+
+
669 #define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+
+
672 #ifndef STBI_SIMD_ALIGN
+
673 #define STBI_SIMD_ALIGN(type, name) type name
+
+
+
+
+
+
+
+
+
+
684 stbi__uint32 img_x, img_y;
+
685 int img_n, img_out_n;
+
+
+
+
+
690 int read_from_callbacks;
+
+
+
+
694 stbi_uc *img_buffer, *img_buffer_end;
+
695 stbi_uc *img_buffer_original, *img_buffer_original_end;
+
+
+
+
699 static void stbi__refill_buffer(stbi__context *s);
+
+
+
702 static void stbi__start_mem(stbi__context *s,
stbi_uc const *buffer,
int len)
+
+
+
705 s->read_from_callbacks = 0;
+
706 s->img_buffer = s->img_buffer_original = (
stbi_uc *) buffer;
+
707 s->img_buffer_end = s->img_buffer_original_end = (
stbi_uc *) buffer+len;
+
+
+
+
711 static void stbi__start_callbacks(stbi__context *s,
stbi_io_callbacks *c,
void *user)
+
+
+
714 s->io_user_data = user;
+
715 s->buflen =
sizeof(s->buffer_start);
+
716 s->read_from_callbacks = 1;
+
717 s->img_buffer_original = s->buffer_start;
+
718 stbi__refill_buffer(s);
+
719 s->img_buffer_original_end = s->img_buffer_end;
+
+
+
722 #ifndef STBI_NO_STDIO
+
+
724 static int stbi__stdio_read(
void *user,
char *data,
int size)
+
+
726 return (
int) fread(data,1,size,(FILE*) user);
+
+
+
729 static void stbi__stdio_skip(
void *user,
int n)
+
+
731 fseek((FILE*) user, n, SEEK_CUR);
+
+
+
734 static int stbi__stdio_eof(
void *user)
+
+
736 return feof((FILE*) user);
+
+
+
+
+
+
+
+
+
+
746 static void stbi__start_file(stbi__context *s, FILE *f)
+
+
748 stbi__start_callbacks(s, &stbi__stdio_callbacks, (
void *) f);
+
+
+
+
+
753 #endif // !STBI_NO_STDIO
+
+
755 static void stbi__rewind(stbi__context *s)
+
+
+
+
+
760 s->img_buffer = s->img_buffer_original;
+
761 s->img_buffer_end = s->img_buffer_original_end;
+
+
+
+
+
+
+
+
+
+
+
772 int bits_per_channel;
+
+
+
+
+
+
778 static int stbi__jpeg_test(stbi__context *s);
+
779 static void *stbi__jpeg_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
780 static int stbi__jpeg_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
784 static int stbi__png_test(stbi__context *s);
+
785 static void *stbi__png_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
786 static int stbi__png_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
790 static int stbi__bmp_test(stbi__context *s);
+
791 static void *stbi__bmp_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
792 static int stbi__bmp_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
796 static int stbi__tga_test(stbi__context *s);
+
797 static void *stbi__tga_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
798 static int stbi__tga_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
802 static int stbi__psd_test(stbi__context *s);
+
803 static void *stbi__psd_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc);
+
804 static int stbi__psd_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
808 static int stbi__hdr_test(stbi__context *s);
+
809 static float *stbi__hdr_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
810 static int stbi__hdr_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
814 static int stbi__pic_test(stbi__context *s);
+
815 static void *stbi__pic_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
816 static int stbi__pic_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
820 static int stbi__gif_test(stbi__context *s);
+
821 static void *stbi__gif_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
822 static int stbi__gif_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
826 static int stbi__pnm_test(stbi__context *s);
+
827 static void *stbi__pnm_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri);
+
828 static int stbi__pnm_info(stbi__context *s,
int *x,
int *y,
int *comp);
+
+
+
+
832 static const char *stbi__g_failure_reason;
+
+
+
+
836 return stbi__g_failure_reason;
+
+
+
839 static int stbi__err(
const char *str)
+
+
841 stbi__g_failure_reason = str;
+
+
+
+
845 static void *stbi__malloc(
size_t size)
+
+
847 return STBI_MALLOC(size);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
862 static int stbi__addsizes_valid(
int a,
int b)
+
+
+
+
+
+
+
869 return a <= INT_MAX - b;
+
+
+
+
+
874 static int stbi__mul2sizes_valid(
int a,
int b)
+
+
876 if (a < 0 || b < 0)
return 0;
+
877 if (b == 0)
return 1;
+
+
879 return a <= INT_MAX/b;
+
+
+
+
883 static int stbi__mad2sizes_valid(
int a,
int b,
int add)
+
+
885 return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+
+
+
+
889 static int stbi__mad3sizes_valid(
int a,
int b,
int c,
int add)
+
+
891 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+
892 stbi__addsizes_valid(a*b*c, add);
+
+
+
+
896 static int stbi__mad4sizes_valid(
int a,
int b,
int c,
int d,
int add)
+
+
898 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+
899 stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+
+
+
+
903 static void *stbi__malloc_mad2(
int a,
int b,
int add)
+
+
905 if (!stbi__mad2sizes_valid(a, b, add))
return NULL;
+
906 return stbi__malloc(a*b + add);
+
+
+
909 static void *stbi__malloc_mad3(
int a,
int b,
int c,
int add)
+
+
911 if (!stbi__mad3sizes_valid(a, b, c, add))
return NULL;
+
912 return stbi__malloc(a*b*c + add);
+
+
+
915 static void *stbi__malloc_mad4(
int a,
int b,
int c,
int d,
int add)
+
+
917 if (!stbi__mad4sizes_valid(a, b, c, d, add))
return NULL;
+
918 return stbi__malloc(a*b*c*d + add);
+
+
+
+
+
+
+
925 #ifdef STBI_NO_FAILURE_STRINGS
+
926 #define stbi__err(x,y) 0
+
927 #elif defined(STBI_FAILURE_USERMSG)
+
928 #define stbi__err(x,y) stbi__err(y)
+
+
930 #define stbi__err(x,y) stbi__err(x)
+
+
+
933 #define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
934 #define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+
+
+
938 STBI_FREE(retval_from_stbi_load);
+
+
+
941 #ifndef STBI_NO_LINEAR
+
942 static float *stbi__ldr_to_hdr(
stbi_uc *data,
int x,
int y,
int comp);
+
+
+
+
946 static stbi_uc *stbi__hdr_to_ldr(
float *data,
int x,
int y,
int comp);
+
+
+
949 static int stbi__vertically_flip_on_load = 0;
+
+
+
+
953 stbi__vertically_flip_on_load = flag_true_if_should_flip;
+
+
+
956 static void *stbi__load_main(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc)
+
+
958 memset(ri, 0,
sizeof(*ri));
+
959 ri->bits_per_channel = 8;
+
960 ri->channel_order = STBI_ORDER_RGB;
+
961 ri->num_channels = 0;
+
+
+
964 if (stbi__jpeg_test(s))
return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+
+
+
967 if (stbi__png_test(s))
return stbi__png_load(s,x,y,comp,req_comp, ri);
+
+
+
970 if (stbi__bmp_test(s))
return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+
+
+
973 if (stbi__gif_test(s))
return stbi__gif_load(s,x,y,comp,req_comp, ri);
+
+
+
976 if (stbi__psd_test(s))
return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+
+
+
979 if (stbi__pic_test(s))
return stbi__pic_load(s,x,y,comp,req_comp, ri);
+
+
+
982 if (stbi__pnm_test(s))
return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+
+
+
+
986 if (stbi__hdr_test(s)) {
+
987 float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+
988 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+
+
+
+
+
+
994 if (stbi__tga_test(s))
+
995 return stbi__tga_load(s,x,y,comp,req_comp, ri);
+
+
+
998 return stbi__errpuc(
"unknown image type",
"Image not of any known type, or corrupt");
+
+
+
1001 static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig,
int w,
int h,
int channels)
+
+
+
1004 int img_len = w * h * channels;
+
+
+
1007 reduced = (
stbi_uc *) stbi__malloc(img_len);
+
1008 if (reduced == NULL)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
1010 for (i = 0; i < img_len; ++i)
+
1011 reduced[i] = (
stbi_uc)((orig[i] >> 8) & 0xFF);
+
+
+
+
+
+
1017 static stbi__uint16 *stbi__convert_8_to_16(
stbi_uc *orig,
int w,
int h,
int channels)
+
+
+
1020 int img_len = w * h * channels;
+
1021 stbi__uint16 *enlarged;
+
+
1023 enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+
1024 if (enlarged == NULL)
return (stbi__uint16 *) stbi__errpuc(
"outofmem",
"Out of memory");
+
+
1026 for (i = 0; i < img_len; ++i)
+
1027 enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]);
+
+
+
+
+
+
1033 static void stbi__vertical_flip(
void *image,
int w,
int h,
int bytes_per_pixel)
+
+
+
1036 size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+
+
+
+
1040 for (row = 0; row < (h>>1); row++) {
+
1041 stbi_uc *row0 = bytes + row*bytes_per_row;
+
1042 stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+
+
1044 size_t bytes_left = bytes_per_row;
+
1045 while (bytes_left) {
+
1046 size_t bytes_copy = (bytes_left <
sizeof(temp)) ? bytes_left :
sizeof(temp);
+
1047 memcpy(temp, row0, bytes_copy);
+
1048 memcpy(row0, row1, bytes_copy);
+
1049 memcpy(row1, temp, bytes_copy);
+
+
+
1052 bytes_left -= bytes_copy;
+
+
+
+
+
1057 static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
+
+
1059 stbi__result_info ri;
+
1060 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+
+
+
+
1065 if (ri.bits_per_channel != 8) {
+
1066 STBI_ASSERT(ri.bits_per_channel == 16);
+
1067 result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+
1068 ri.bits_per_channel = 8;
+
+
+
+
+
1073 if (stbi__vertically_flip_on_load) {
+
1074 int channels = req_comp ? req_comp : *comp;
+
1075 stbi__vertical_flip(result, *x, *y, channels *
sizeof(
stbi_uc));
+
+
+
1078 return (
unsigned char *) result;
+
+
+
1081 static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
+
+
1083 stbi__result_info ri;
+
1084 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+
+
+
+
1089 if (ri.bits_per_channel != 16) {
+
1090 STBI_ASSERT(ri.bits_per_channel == 8);
+
1091 result = stbi__convert_8_to_16((
stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+
1092 ri.bits_per_channel = 16;
+
+
+
+
+
+
1098 if (stbi__vertically_flip_on_load) {
+
1099 int channels = req_comp ? req_comp : *comp;
+
1100 stbi__vertical_flip(result, *x, *y, channels *
sizeof(stbi__uint16));
+
+
+
1103 return (stbi__uint16 *) result;
+
+
+
+
1107 static void stbi__float_postprocess(
float *result,
int *x,
int *y,
int *comp,
int req_comp)
+
+
1109 if (stbi__vertically_flip_on_load && result != NULL) {
+
1110 int channels = req_comp ? req_comp : *comp;
+
1111 stbi__vertical_flip(result, *x, *y, channels *
sizeof(
float));
+
+
+
+
+
1116 #ifndef STBI_NO_STDIO
+
+
1118 static FILE *stbi__fopen(
char const *filename,
char const *mode)
+
+
+
1121 #if defined(_MSC_VER) && _MSC_VER >= 1400
+
1122 if (0 != fopen_s(&f, filename, mode))
+
+
+
1125 f = fopen(filename, mode);
+
+
+
+
+
+
+
+
1133 FILE *f = stbi__fopen(filename,
"rb");
+
1134 unsigned char *result;
+
1135 if (!f)
return stbi__errpuc(
"can't fopen",
"Unable to open file");
+
+
+
+
+
+
+
+
1143 unsigned char *result;
+
+
1145 stbi__start_file(&s,f);
+
1146 result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+
+
+
1149 fseek(f, - (
int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+
+
+
+
+
+
+
1156 stbi__uint16 *result;
+
+
1158 stbi__start_file(&s,f);
+
1159 result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+
+
+
1162 fseek(f, - (
int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+
+
+
+
+
+
+
1169 FILE *f = stbi__fopen(filename,
"rb");
+
1170 stbi__uint16 *result;
+
1171 if (!f)
return (
stbi_us *) stbi__errpuc(
"can't fopen",
"Unable to open file");
+
+
+
+
+
+
+
+
+
+
+
+
1183 stbi__start_mem(&s,buffer,len);
+
1184 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+
+
+
+
+
+
+
1191 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+
+
+
+
+
+
1197 stbi__start_mem(&s,buffer,len);
+
1198 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+
+
+
+
+
+
+
1205 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+
+
+
1208 #ifndef STBI_NO_LINEAR
+
1209 static float *stbi__loadf_main(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp)
+
+
1211 unsigned char *data;
+
+
1213 if (stbi__hdr_test(s)) {
+
1214 stbi__result_info ri;
+
1215 float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+
+
1217 stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+
+
+
+
1221 data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+
+
1223 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+
1224 return stbi__errpf(
"unknown image type",
"Image not of any known type, or corrupt");
+
+
+
+
+
+
1230 stbi__start_mem(&s,buffer,len);
+
1231 return stbi__loadf_main(&s,x,y,comp,req_comp);
+
+
+
+
+
+
+
1238 return stbi__loadf_main(&s,x,y,comp,req_comp);
+
+
+
1241 #ifndef STBI_NO_STDIO
+
1242 STBIDEF float *
stbi_loadf(
char const *filename,
int *x,
int *y,
int *comp,
int req_comp)
+
+
+
1245 FILE *f = stbi__fopen(filename,
"rb");
+
1246 if (!f)
return stbi__errpf(
"can't fopen",
"Unable to open file");
+
+
+
+
+
+
+
+
+
1255 stbi__start_file(&s,f);
+
1256 return stbi__loadf_main(&s,x,y,comp,req_comp);
+
+
1258 #endif // !STBI_NO_STDIO
+
+
1260 #endif // !STBI_NO_LINEAR
+
+
+
+
+
+
+
+
+
+
1270 stbi__start_mem(&s,buffer,len);
+
1271 return stbi__hdr_test(&s);
+
+
1273 STBI_NOTUSED(buffer);
+
+
+
+
+
+
1279 #ifndef STBI_NO_STDIO
+
+
+
1282 FILE *f = stbi__fopen(filename,
"rb");
+
+
+
+
+
+
+
+
+
+
+
+
+
1295 stbi__start_file(&s,f);
+
1296 return stbi__hdr_test(&s);
+
+
+
+
+
+
1302 #endif // !STBI_NO_STDIO
+
+
+
+
+
+
+
1309 return stbi__hdr_test(&s);
+
+
+
+
+
+
+
+
1317 #ifndef STBI_NO_LINEAR
+
1318 static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+
+
+
+
+
1324 static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1342 static void stbi__refill_buffer(stbi__context *s)
+
+
1344 int n = (s->io.read)(s->io_user_data,(
char*)s->buffer_start,s->buflen);
+
+
+
+
1348 s->read_from_callbacks = 0;
+
1349 s->img_buffer = s->buffer_start;
+
1350 s->img_buffer_end = s->buffer_start+1;
+
+
+
1353 s->img_buffer = s->buffer_start;
+
1354 s->img_buffer_end = s->buffer_start + n;
+
+
+
+
1358 stbi_inline
static stbi_uc stbi__get8(stbi__context *s)
+
+
1360 if (s->img_buffer < s->img_buffer_end)
+
1361 return *s->img_buffer++;
+
1362 if (s->read_from_callbacks) {
+
1363 stbi__refill_buffer(s);
+
1364 return *s->img_buffer++;
+
+
+
+
+
1369 stbi_inline
static int stbi__at_eof(stbi__context *s)
+
+
+
1372 if (!(s->io.eof)(s->io_user_data))
return 0;
+
+
+
1375 if (s->read_from_callbacks == 0)
return 1;
+
+
+
1378 return s->img_buffer >= s->img_buffer_end;
+
+
+
1381 static void stbi__skip(stbi__context *s,
int n)
+
+
+
1384 s->img_buffer = s->img_buffer_end;
+
+
+
+
1388 int blen = (int) (s->img_buffer_end - s->img_buffer);
+
+
1390 s->img_buffer = s->img_buffer_end;
+
1391 (s->io.skip)(s->io_user_data, n - blen);
+
+
+
+
+
+
+
1398 static int stbi__getn(stbi__context *s,
stbi_uc *buffer,
int n)
+
+
+
1401 int blen = (int) (s->img_buffer_end - s->img_buffer);
+
+
+
+
1405 memcpy(buffer, s->img_buffer, blen);
+
+
1407 count = (s->io.read)(s->io_user_data, (
char*) buffer + blen, n - blen);
+
1408 res = (count == (n-blen));
+
1409 s->img_buffer = s->img_buffer_end;
+
+
+
+
+
1414 if (s->img_buffer+n <= s->img_buffer_end) {
+
1415 memcpy(buffer, s->img_buffer, n);
+
+
+
+
+
+
+
1422 static int stbi__get16be(stbi__context *s)
+
+
1424 int z = stbi__get8(s);
+
1425 return (z << 8) + stbi__get8(s);
+
+
+
1428 static stbi__uint32 stbi__get32be(stbi__context *s)
+
+
1430 stbi__uint32 z = stbi__get16be(s);
+
1431 return (z << 16) + stbi__get16be(s);
+
+
+
1434 #if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+
+
+
1437 static int stbi__get16le(stbi__context *s)
+
+
1439 int z = stbi__get8(s);
+
1440 return z + (stbi__get8(s) << 8);
+
+
+
+
+
1445 static stbi__uint32 stbi__get32le(stbi__context *s)
+
+
1447 stbi__uint32 z = stbi__get16le(s);
+
1448 return z + (stbi__get16le(s) << 16);
+
+
+
+
1452 #define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
+
+
+
+
+
+
+
+
+
+
+
+
+
1466 static stbi_uc stbi__compute_y(
int r,
int g,
int b)
+
+
1468 return (
stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
+
+
+
1471 static unsigned char *stbi__convert_format(
unsigned char *data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y)
+
+
+
1474 unsigned char *good;
+
+
1476 if (req_comp == img_n)
return data;
+
1477 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+
1479 good = (
unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+
+
+
1482 return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
+
1485 for (j=0; j < (int) y; ++j) {
+
1486 unsigned char *src = data + j * x * img_n ;
+
1487 unsigned char *dest = good + j * x * req_comp;
+
+
1489 #define STBI__COMBO(a,b) ((a)*8+(b))
+
1490 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+
+
+
1493 switch (STBI__COMBO(img_n, req_comp)) {
+
1494 STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255; }
break;
+
1495 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
+
1496 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; }
break;
+
1497 STBI__CASE(2,1) { dest[0]=src[0]; }
break;
+
1498 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
+
1499 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; }
break;
+
1500 STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; }
break;
+
1501 STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); }
break;
+
1502 STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; }
break;
+
1503 STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); }
break;
+
1504 STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; }
break;
+
1505 STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; }
break;
+
1506 default: STBI_ASSERT(0);
+
+
+
+
+
+
+
+
+
1515 static stbi__uint16 stbi__compute_y_16(
int r,
int g,
int b)
+
+
1517 return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
+
+
+
1520 static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y)
+
+
+
+
+
1525 if (req_comp == img_n)
return data;
+
1526 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+
1528 good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+
+
+
1531 return (stbi__uint16 *) stbi__errpuc(
"outofmem",
"Out of memory");
+
+
+
1534 for (j=0; j < (int) y; ++j) {
+
1535 stbi__uint16 *src = data + j * x * img_n ;
+
1536 stbi__uint16 *dest = good + j * x * req_comp;
+
+
1538 #define STBI__COMBO(a,b) ((a)*8+(b))
+
1539 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+
+
+
1542 switch (STBI__COMBO(img_n, req_comp)) {
+
1543 STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff; }
break;
+
1544 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
+
1545 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff; }
break;
+
1546 STBI__CASE(2,1) { dest[0]=src[0]; }
break;
+
1547 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; }
break;
+
1548 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; }
break;
+
1549 STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; }
break;
+
1550 STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); }
break;
+
1551 STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; }
break;
+
1552 STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); }
break;
+
1553 STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; }
break;
+
1554 STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; }
break;
+
1555 default: STBI_ASSERT(0);
+
+
+
+
+
+
+
+
+
1564 #ifndef STBI_NO_LINEAR
+
1565 static float *stbi__ldr_to_hdr(
stbi_uc *data,
int x,
int y,
int comp)
+
+
+
+
1569 if (!data)
return NULL;
+
1570 output = (
float *) stbi__malloc_mad4(x, y, comp,
sizeof(
float), 0);
+
1571 if (output == NULL) { STBI_FREE(data);
return stbi__errpf(
"outofmem",
"Out of memory"); }
+
+
1573 if (comp & 1) n = comp;
else n = comp-1;
+
1574 for (i=0; i < x*y; ++i) {
+
1575 for (k=0; k < n; ++k) {
+
1576 output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+
+
1578 if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+
+
+
+
+
+
+
+
1586 #define stbi__float2int(x) ((int) (x))
+
1587 static stbi_uc *stbi__hdr_to_ldr(
float *data,
int x,
int y,
int comp)
+
+
+
+
1591 if (!data)
return NULL;
+
1592 output = (
stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+
1593 if (output == NULL) { STBI_FREE(data);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
+
+
1595 if (comp & 1) n = comp;
else n = comp-1;
+
1596 for (i=0; i < x*y; ++i) {
+
1597 for (k=0; k < n; ++k) {
+
1598 float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+
+
1600 if (z > 255) z = 255;
+
1601 output[i*comp + k] = (
stbi_uc) stbi__float2int(z);
+
+
+
1604 float z = data[i*comp+k] * 255 + 0.5f;
+
+
1606 if (z > 255) z = 255;
+
1607 output[i*comp + k] = (
stbi_uc) stbi__float2int(z);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1636 #ifndef STBI_NO_JPEG
+
+
+
1639 #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
+
+
+
+
+
+
1645 stbi__uint16 code[256];
+
+
+
1648 unsigned int maxcode[18];
+
+
+
+
+
+
+
1655 stbi__huffman huff_dc[4];
+
1656 stbi__huffman huff_ac[4];
+
1657 stbi__uint16 dequant[4][64];
+
1658 stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+
+
1661 int img_h_max, img_v_max;
+
1662 int img_mcu_x, img_mcu_y;
+
1663 int img_mcu_w, img_mcu_h;
+
+
+
+
+
+
+
+
+
+
+
+
+
1676 void *raw_data, *raw_coeff;
+
+
+
1679 int coeff_w, coeff_h;
+
+
+
1682 stbi__uint32 code_buffer;
+
+
1684 unsigned char marker;
+
+
+
+
+
+
+
+
+
+
1694 int app14_color_transform;
+
+
+
1697 int scan_n, order[4];
+
1698 int restart_interval, todo;
+
+
+
1701 void (*idct_block_kernel)(
stbi_uc *out,
int out_stride,
short data[64]);
+
+
+
+
+
1706 static int stbi__build_huffman(stbi__huffman *h,
int *count)
+
+
+
+
1710 for (i=0; i < 16; ++i)
+
1711 for (j=0; j < count[i]; ++j)
+
1712 h->size[k++] = (
stbi_uc) (i+1);
+
+
+
+
+
+
1718 for(j=1; j <= 16; ++j) {
+
+
1720 h->delta[j] = k - code;
+
1721 if (h->size[k] == j) {
+
1722 while (h->size[k] == j)
+
1723 h->code[k++] = (stbi__uint16) (code++);
+
1724 if (code-1 >= (1 << j))
return stbi__err(
"bad code lengths",
"Corrupt JPEG");
+
+
+
1727 h->maxcode[j] = code << (16-j);
+
+
+
1730 h->maxcode[j] = 0xffffffff;
+
+
+
1733 memset(h->fast, 255, 1 << FAST_BITS);
+
1734 for (i=0; i < k; ++i) {
+
+
1736 if (s <= FAST_BITS) {
+
1737 int c = h->code[i] << (FAST_BITS-s);
+
1738 int m = 1 << (FAST_BITS-s);
+
1739 for (j=0; j < m; ++j) {
+
+
+
+
+
+
+
+
+
+
1749 static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+
+
+
1752 for (i=0; i < (1 << FAST_BITS); ++i) {
+
+
+
+
1756 int rs = h->values[fast];
+
1757 int run = (rs >> 4) & 15;
+
1758 int magbits = rs & 15;
+
1759 int len = h->size[fast];
+
+
1761 if (magbits && len + magbits <= FAST_BITS) {
+
+
1763 int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+
1764 int m = 1 << (magbits - 1);
+
1765 if (k < m) k += (~0
U << magbits) + 1;
+
+
1767 if (k >= -128 && k <= 127)
+
1768 fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits));
+
+
+
+
+
+
1774 static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+
+
+
1777 int b = j->nomore ? 0 : stbi__get8(j->s);
+
+
1779 int c = stbi__get8(j->s);
+
1780 while (c == 0xff) c = stbi__get8(j->s);
+
+
1782 j->marker = (
unsigned char) c;
+
+
+
+
+
1787 j->code_buffer |= b << (24 - j->code_bits);
+
+
1789 }
while (j->code_bits <= 24);
+
+
+
+
1793 static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+
+
1796 stbi_inline
static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+
+
+
+
+
1801 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+
+
+
1805 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+
+
+
+
1809 if (s > j->code_bits)
+
+
1811 j->code_buffer <<= s;
+
+
1813 return h->values[k];
+
+
+
+
+
+
+
+
+
1822 temp = j->code_buffer >> 16;
+
1823 for (k=FAST_BITS+1 ; ; ++k)
+
1824 if (temp < h->maxcode[k])
+
+
+
+
+
+
+
+
1832 if (k > j->code_bits)
+
+
+
+
1836 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+
1837 STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+
+
+
1841 j->code_buffer <<= k;
+
1842 return h->values[c];
+
+
+
+
1846 static int const stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+
+
+
1850 stbi_inline
static int stbi__extend_receive(stbi__jpeg *j,
int n)
+
+
+
+
1854 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+
+
1856 sgn = (stbi__int32)j->code_buffer >> 31;
+
1857 k = stbi_lrot(j->code_buffer, n);
+
1858 STBI_ASSERT(n >= 0 && n < (
int) (
sizeof(stbi__bmask)/
sizeof(*stbi__bmask)));
+
1859 j->code_buffer = k & ~stbi__bmask[n];
+
1860 k &= stbi__bmask[n];
+
+
1862 return k + (stbi__jbias[n] & ~sgn);
+
+
+
+
1866 stbi_inline
static int stbi__jpeg_get_bits(stbi__jpeg *j,
int n)
+
+
+
1869 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+
1870 k = stbi_lrot(j->code_buffer, n);
+
1871 j->code_buffer = k & ~stbi__bmask[n];
+
1872 k &= stbi__bmask[n];
+
+
+
+
+
1877 stbi_inline
static int stbi__jpeg_get_bit(stbi__jpeg *j)
+
+
+
1880 if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+
+
1882 j->code_buffer <<= 1;
+
+
1884 return k & 0x80000000;
+
+
+
+
+
1889 static stbi_uc stbi__jpeg_dezigzag[64+15] =
+
+
1891 0, 1, 8, 16, 9, 2, 3, 10,
+
1892 17, 24, 32, 25, 18, 11, 4, 5,
+
1893 12, 19, 26, 33, 40, 48, 41, 34,
+
1894 27, 20, 13, 6, 7, 14, 21, 28,
+
1895 35, 42, 49, 56, 57, 50, 43, 36,
+
1896 29, 22, 15, 23, 30, 37, 44, 51,
+
1897 58, 59, 52, 45, 38, 31, 39, 46,
+
1898 53, 60, 61, 54, 47, 55, 62, 63,
+
+
1900 63, 63, 63, 63, 63, 63, 63, 63,
+
1901 63, 63, 63, 63, 63, 63, 63
+
+
+
+
1905 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)
+
+
+
+
+
1910 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
1911 t = stbi__jpeg_huff_decode(j, hdc);
+
1912 if (t < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
+
+
+
1915 memset(data,0,64*
sizeof(data[0]));
+
+
1917 diff = t ? stbi__extend_receive(j, t) : 0;
+
1918 dc = j->img_comp[b].dc_pred + diff;
+
1919 j->img_comp[b].dc_pred = dc;
+
1920 data[0] = (short) (dc * dequant[0]);
+
+
+
+
+
+
+
1927 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
1928 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+
+
+
+
+
1933 j->code_buffer <<= s;
+
+
+
1936 zig = stbi__jpeg_dezigzag[k++];
+
1937 data[zig] = (short) ((r >> 8) * dequant[zig]);
+
+
1939 int rs = stbi__jpeg_huff_decode(j, hac);
+
1940 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
+
+
+
+
1944 if (rs != 0xf0)
break;
+
+
+
+
+
1949 zig = stbi__jpeg_dezigzag[k++];
+
1950 data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+
+
+
+
+
+
+
1957 static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j,
short data[64], stbi__huffman *hdc,
int b)
+
+
+
+
1961 if (j->spec_end != 0)
return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
+
+
1963 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+
1965 if (j->succ_high == 0) {
+
+
1967 memset(data,0,64*
sizeof(data[0]));
+
1968 t = stbi__jpeg_huff_decode(j, hdc);
+
1969 diff = t ? stbi__extend_receive(j, t) : 0;
+
+
1971 dc = j->img_comp[b].dc_pred + diff;
+
1972 j->img_comp[b].dc_pred = dc;
+
1973 data[0] = (short) (dc << j->succ_low);
+
+
+
1976 if (stbi__jpeg_get_bit(j))
+
1977 data[0] += (
short) (1 << j->succ_low);
+
+
+
+
+
+
+
1984 static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j,
short data[64], stbi__huffman *hac, stbi__int16 *fac)
+
+
+
1987 if (j->spec_start == 0)
return stbi__err(
"can't merge dc and ac",
"Corrupt JPEG");
+
+
1989 if (j->succ_high == 0) {
+
1990 int shift = j->succ_low;
+
+
+
+
+
+
+
+
+
+
+
2001 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
2002 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+
+
+
+
+
2007 j->code_buffer <<= s;
+
+
2009 zig = stbi__jpeg_dezigzag[k++];
+
2010 data[zig] = (short) ((r >> 8) << shift);
+
+
2012 int rs = stbi__jpeg_huff_decode(j, hac);
+
2013 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
+
+
+
+
+
2018 j->eob_run = (1 << r);
+
+
2020 j->eob_run += stbi__jpeg_get_bits(j, r);
+
+
+
+
+
+
+
2027 zig = stbi__jpeg_dezigzag[k++];
+
2028 data[zig] = (short) (stbi__extend_receive(j,s) << shift);
+
+
+
2031 }
while (k <= j->spec_end);
+
+
+
+
2035 short bit = (short) (1 << j->succ_low);
+
+
+
+
2039 for (k = j->spec_start; k <= j->spec_end; ++k) {
+
2040 short *p = &data[stbi__jpeg_dezigzag[k]];
+
+
2042 if (stbi__jpeg_get_bit(j))
+
2043 if ((*p & bit)==0) {
+
+
+
+
+
+
+
+
+
+
+
2054 int rs = stbi__jpeg_huff_decode(j, hac);
+
2055 if (rs < 0)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
+
+
+
+
+
2060 j->eob_run = (1 << r) - 1;
+
+
2062 j->eob_run += stbi__jpeg_get_bits(j, r);
+
+
+
+
+
+
+
+
2070 if (s != 1)
return stbi__err(
"bad huffman code",
"Corrupt JPEG");
+
+
2072 if (stbi__jpeg_get_bit(j))
+
+
+
+
+
+
+
2079 while (k <= j->spec_end) {
+
2080 short *p = &data[stbi__jpeg_dezigzag[k++]];
+
+
2082 if (stbi__jpeg_get_bit(j))
+
2083 if ((*p & bit)==0) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2097 }
while (k <= j->spec_end);
+
+
+
+
+
+
+
2104 stbi_inline
static stbi_uc stbi__clamp(
int x)
+
+
+
2107 if ((
unsigned int) x > 255) {
+
2108 if (x < 0)
return 0;
+
2109 if (x > 255)
return 255;
+
+
+
+
+
2114 #define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
+
2115 #define stbi__fsh(x) ((x) << 12)
+
+
+
2118 #define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+
2119 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+
+
+
2122 p1 = (p2+p3) * stbi__f2f(0.5411961f); \
+
2123 t2 = p1 + p3*stbi__f2f(-1.847759065f); \
+
2124 t3 = p1 + p2*stbi__f2f( 0.765366865f); \
+
+
+
2127 t0 = stbi__fsh(p2+p3); \
+
2128 t1 = stbi__fsh(p2-p3); \
+
+
+
+
+
+
+
+
+
+
+
+
+
2141 p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
+
2142 t0 = t0*stbi__f2f( 0.298631336f); \
+
2143 t1 = t1*stbi__f2f( 2.053119869f); \
+
2144 t2 = t2*stbi__f2f( 3.072711026f); \
+
2145 t3 = t3*stbi__f2f( 1.501321110f); \
+
2146 p1 = p5 + p1*stbi__f2f(-0.899976223f); \
+
2147 p2 = p5 + p2*stbi__f2f(-2.562915447f); \
+
2148 p3 = p3*stbi__f2f(-1.961570560f); \
+
2149 p4 = p4*stbi__f2f(-0.390180644f); \
+
+
+
+
+
+
2155 static void stbi__idct_block(
stbi_uc *out,
int out_stride,
short data[64])
+
+
2157 int i,val[64],*v=val;
+
+
+
+
+
2162 for (i=0; i < 8; ++i,++d, ++v) {
+
+
2164 if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+
2165 && d[40]==0 && d[48]==0 && d[56]==0) {
+
+
+
+
+
2170 int dcterm = d[0] << 2;
+
2171 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+
+
2173 STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+
+
+
2176 x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+
2177 v[ 0] = (x0+t3) >> 10;
+
2178 v[56] = (x0-t3) >> 10;
+
2179 v[ 8] = (x1+t2) >> 10;
+
2180 v[48] = (x1-t2) >> 10;
+
2181 v[16] = (x2+t1) >> 10;
+
2182 v[40] = (x2-t1) >> 10;
+
2183 v[24] = (x3+t0) >> 10;
+
2184 v[32] = (x3-t0) >> 10;
+
+
+
+
2188 for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+
+
2190 STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+
+
+
+
+
+
+
2197 x0 += 65536 + (128<<17);
+
2198 x1 += 65536 + (128<<17);
+
2199 x2 += 65536 + (128<<17);
+
2200 x3 += 65536 + (128<<17);
+
+
+
2203 o[0] = stbi__clamp((x0+t3) >> 17);
+
2204 o[7] = stbi__clamp((x0-t3) >> 17);
+
2205 o[1] = stbi__clamp((x1+t2) >> 17);
+
2206 o[6] = stbi__clamp((x1-t2) >> 17);
+
2207 o[2] = stbi__clamp((x2+t1) >> 17);
+
2208 o[5] = stbi__clamp((x2-t1) >> 17);
+
2209 o[3] = stbi__clamp((x3+t0) >> 17);
+
2210 o[4] = stbi__clamp((x3-t0) >> 17);
+
+
+
+
+
+
+
+
2218 static void stbi__idct_simd(
stbi_uc *out,
int out_stride,
short data[64])
+
+
+
2221 __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+
+
+
+
2225 #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+
+
+
2229 #define dct_rot(out0,out1, x,y,c0,c1) \
+
2230 __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+
2231 __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+
2232 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+
2233 __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+
2234 __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+
2235 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+
+
2238 #define dct_widen(out, in) \
+
2239 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+
2240 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+
+
2243 #define dct_wadd(out, a, b) \
+
2244 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+
2245 __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+
+
2248 #define dct_wsub(out, a, b) \
+
2249 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+
2250 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+
+
2253 #define dct_bfly32o(out0, out1, a,b,bias,s) \
+
+
2255 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+
2256 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+
2257 dct_wadd(sum, abiased, b); \
+
2258 dct_wsub(dif, abiased, b); \
+
2259 out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+
2260 out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+
+
+
+
2264 #define dct_interleave8(a, b) \
+
+
2266 a = _mm_unpacklo_epi8(a, b); \
+
2267 b = _mm_unpackhi_epi8(tmp, b)
+
+
+
2270 #define dct_interleave16(a, b) \
+
+
2272 a = _mm_unpacklo_epi16(a, b); \
+
2273 b = _mm_unpackhi_epi16(tmp, b)
+
+
2275 #define dct_pass(bias,shift) \
+
+
+
2278 dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+
2279 __m128i sum04 = _mm_add_epi16(row0, row4); \
+
2280 __m128i dif04 = _mm_sub_epi16(row0, row4); \
+
2281 dct_widen(t0e, sum04); \
+
2282 dct_widen(t1e, dif04); \
+
2283 dct_wadd(x0, t0e, t3e); \
+
2284 dct_wsub(x3, t0e, t3e); \
+
2285 dct_wadd(x1, t1e, t2e); \
+
2286 dct_wsub(x2, t1e, t2e); \
+
+
2288 dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+
2289 dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+
2290 __m128i sum17 = _mm_add_epi16(row1, row7); \
+
2291 __m128i sum35 = _mm_add_epi16(row3, row5); \
+
2292 dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+
2293 dct_wadd(x4, y0o, y4o); \
+
2294 dct_wadd(x5, y1o, y5o); \
+
2295 dct_wadd(x6, y2o, y5o); \
+
2296 dct_wadd(x7, y3o, y4o); \
+
2297 dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+
2298 dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+
2299 dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+
2300 dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+
+
+
2303 __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+
2304 __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+
2305 __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+
2306 __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+
2307 __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+
2308 __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+
2309 __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+
2310 __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+
+
2313 __m128i bias_0 = _mm_set1_epi32(512);
+
2314 __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+
+
2317 row0 = _mm_load_si128((
const __m128i *) (data + 0*8));
+
2318 row1 = _mm_load_si128((
const __m128i *) (data + 1*8));
+
2319 row2 = _mm_load_si128((
const __m128i *) (data + 2*8));
+
2320 row3 = _mm_load_si128((
const __m128i *) (data + 3*8));
+
2321 row4 = _mm_load_si128((
const __m128i *) (data + 4*8));
+
2322 row5 = _mm_load_si128((
const __m128i *) (data + 5*8));
+
2323 row6 = _mm_load_si128((
const __m128i *) (data + 6*8));
+
2324 row7 = _mm_load_si128((
const __m128i *) (data + 7*8));
+
+
+
2327 dct_pass(bias_0, 10);
+
+
+
+
2331 dct_interleave16(row0, row4);
+
2332 dct_interleave16(row1, row5);
+
2333 dct_interleave16(row2, row6);
+
2334 dct_interleave16(row3, row7);
+
+
+
2337 dct_interleave16(row0, row2);
+
2338 dct_interleave16(row1, row3);
+
2339 dct_interleave16(row4, row6);
+
2340 dct_interleave16(row5, row7);
+
+
+
2343 dct_interleave16(row0, row1);
+
2344 dct_interleave16(row2, row3);
+
2345 dct_interleave16(row4, row5);
+
2346 dct_interleave16(row6, row7);
+
+
+
+
2350 dct_pass(bias_1, 17);
+
+
+
+
2354 __m128i p0 = _mm_packus_epi16(row0, row1);
+
2355 __m128i p1 = _mm_packus_epi16(row2, row3);
+
2356 __m128i p2 = _mm_packus_epi16(row4, row5);
+
2357 __m128i p3 = _mm_packus_epi16(row6, row7);
+
+
+
2360 dct_interleave8(p0, p2);
+
2361 dct_interleave8(p1, p3);
+
+
+
2364 dct_interleave8(p0, p1);
+
2365 dct_interleave8(p2, p3);
+
+
+
2368 dct_interleave8(p0, p2);
+
2369 dct_interleave8(p1, p3);
+
+
+
2372 _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+
2373 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+
2374 _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+
2375 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+
2376 _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+
2377 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+
2378 _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+
2379 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+
+
+
+
+
+
+
+
+
2388 #undef dct_interleave8
+
2389 #undef dct_interleave16
+
+
+
+
+
+
+
+
+
+
2399 static void stbi__idct_simd(
stbi_uc *out,
int out_stride,
short data[64])
+
+
2401 int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+
2403 int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+
2404 int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+
2405 int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+
2406 int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+
2407 int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+
2408 int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+
2409 int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+
2410 int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+
2411 int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+
2412 int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+
2413 int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+
2414 int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+
2416 #define dct_long_mul(out, inq, coeff) \
+
2417 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+
2418 int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+
2420 #define dct_long_mac(out, acc, inq, coeff) \
+
2421 int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+
2422 int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+
2424 #define dct_widen(out, inq) \
+
2425 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+
2426 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+
+
2429 #define dct_wadd(out, a, b) \
+
2430 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+
2431 int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+
+
2434 #define dct_wsub(out, a, b) \
+
2435 int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+
2436 int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+
+
2439 #define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+
+
2441 dct_wadd(sum, a, b); \
+
2442 dct_wsub(dif, a, b); \
+
2443 out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+
2444 out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+
+
+
2447 #define dct_pass(shiftop, shift) \
+
+
+
2450 int16x8_t sum26 = vaddq_s16(row2, row6); \
+
2451 dct_long_mul(p1e, sum26, rot0_0); \
+
2452 dct_long_mac(t2e, p1e, row6, rot0_1); \
+
2453 dct_long_mac(t3e, p1e, row2, rot0_2); \
+
2454 int16x8_t sum04 = vaddq_s16(row0, row4); \
+
2455 int16x8_t dif04 = vsubq_s16(row0, row4); \
+
2456 dct_widen(t0e, sum04); \
+
2457 dct_widen(t1e, dif04); \
+
2458 dct_wadd(x0, t0e, t3e); \
+
2459 dct_wsub(x3, t0e, t3e); \
+
2460 dct_wadd(x1, t1e, t2e); \
+
2461 dct_wsub(x2, t1e, t2e); \
+
+
2463 int16x8_t sum15 = vaddq_s16(row1, row5); \
+
2464 int16x8_t sum17 = vaddq_s16(row1, row7); \
+
2465 int16x8_t sum35 = vaddq_s16(row3, row5); \
+
2466 int16x8_t sum37 = vaddq_s16(row3, row7); \
+
2467 int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+
2468 dct_long_mul(p5o, sumodd, rot1_0); \
+
2469 dct_long_mac(p1o, p5o, sum17, rot1_1); \
+
2470 dct_long_mac(p2o, p5o, sum35, rot1_2); \
+
2471 dct_long_mul(p3o, sum37, rot2_0); \
+
2472 dct_long_mul(p4o, sum15, rot2_1); \
+
2473 dct_wadd(sump13o, p1o, p3o); \
+
2474 dct_wadd(sump24o, p2o, p4o); \
+
2475 dct_wadd(sump23o, p2o, p3o); \
+
2476 dct_wadd(sump14o, p1o, p4o); \
+
2477 dct_long_mac(x4, sump13o, row7, rot3_0); \
+
2478 dct_long_mac(x5, sump24o, row5, rot3_1); \
+
2479 dct_long_mac(x6, sump23o, row3, rot3_2); \
+
2480 dct_long_mac(x7, sump14o, row1, rot3_3); \
+
2481 dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+
2482 dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+
2483 dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+
2484 dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+
+
+
+
2488 row0 = vld1q_s16(data + 0*8);
+
2489 row1 = vld1q_s16(data + 1*8);
+
2490 row2 = vld1q_s16(data + 2*8);
+
2491 row3 = vld1q_s16(data + 3*8);
+
2492 row4 = vld1q_s16(data + 4*8);
+
2493 row5 = vld1q_s16(data + 5*8);
+
2494 row6 = vld1q_s16(data + 6*8);
+
2495 row7 = vld1q_s16(data + 7*8);
+
+
+
2498 row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+
+
2501 dct_pass(vrshrn_n_s32, 10);
+
+
+
+
+
+
2507 #define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+
2508 #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]); }
+
2509 #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)); }
+
+
+
2512 dct_trn16(row0, row1);
+
2513 dct_trn16(row2, row3);
+
2514 dct_trn16(row4, row5);
+
2515 dct_trn16(row6, row7);
+
+
+
2518 dct_trn32(row0, row2);
+
2519 dct_trn32(row1, row3);
+
2520 dct_trn32(row4, row6);
+
2521 dct_trn32(row5, row7);
+
+
+
2524 dct_trn64(row0, row4);
+
2525 dct_trn64(row1, row5);
+
2526 dct_trn64(row2, row6);
+
2527 dct_trn64(row3, row7);
+
+
+
+
+
+
+
+
+
+
+
2538 dct_pass(vshrn_n_s32, 16);
+
+
+
+
2542 uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+
2543 uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+
2544 uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+
2545 uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+
2546 uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+
2547 uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+
2548 uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+
2549 uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+
+
2552 #define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+
2553 #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]); }
+
2554 #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]); }
+
+
+
+
+
+
+
+
+
+
+
+
2566 dct_trn8_16(p0, p2);
+
2567 dct_trn8_16(p1, p3);
+
2568 dct_trn8_16(p4, p6);
+
2569 dct_trn8_16(p5, p7);
+
+
+
2572 dct_trn8_32(p0, p4);
+
2573 dct_trn8_32(p1, p5);
+
2574 dct_trn8_32(p2, p6);
+
2575 dct_trn8_32(p3, p7);
+
+
+
2578 vst1_u8(out, p0); out += out_stride;
+
2579 vst1_u8(out, p1); out += out_stride;
+
2580 vst1_u8(out, p2); out += out_stride;
+
2581 vst1_u8(out, p3); out += out_stride;
+
2582 vst1_u8(out, p4); out += out_stride;
+
2583 vst1_u8(out, p5); out += out_stride;
+
2584 vst1_u8(out, p6); out += out_stride;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
2603 #define STBI__MARKER_none 0xff
+
+
+
+
2607 static stbi_uc stbi__get_marker(stbi__jpeg *j)
+
+
+
2610 if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none;
return x; }
+
2611 x = stbi__get8(j->s);
+
2612 if (x != 0xff)
return STBI__MARKER_none;
+
+
2614 x = stbi__get8(j->s);
+
+
+
+
+
+
2620 #define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
+
+
+
+
2624 static void stbi__jpeg_reset(stbi__jpeg *j)
+
+
+
+
+
2629 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;
+
2630 j->marker = STBI__MARKER_none;
+
2631 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+
+
+
+
+
+
2637 static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+
+
2639 stbi__jpeg_reset(z);
+
2640 if (!z->progressive) {
+
2641 if (z->scan_n == 1) {
+
+
2643 STBI_SIMD_ALIGN(
short, data[64]);
+
2644 int n = z->order[0];
+
+
+
+
+
2649 int w = (z->img_comp[n].x+7) >> 3;
+
2650 int h = (z->img_comp[n].y+7) >> 3;
+
2651 for (j=0; j < h; ++j) {
+
2652 for (i=0; i < w; ++i) {
+
2653 int ha = z->img_comp[n].ha;
+
2654 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;
+
2655 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+
+
2657 if (--z->todo <= 0) {
+
2658 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+
+
+
2661 if (!STBI__RESTART(z->marker))
return 1;
+
2662 stbi__jpeg_reset(z);
+
+
+
+
+
+
+
2669 STBI_SIMD_ALIGN(
short, data[64]);
+
2670 for (j=0; j < z->img_mcu_y; ++j) {
+
2671 for (i=0; i < z->img_mcu_x; ++i) {
+
+
2673 for (k=0; k < z->scan_n; ++k) {
+
2674 int n = z->order[k];
+
+
+
2677 for (y=0; y < z->img_comp[n].v; ++y) {
+
2678 for (x=0; x < z->img_comp[n].h; ++x) {
+
2679 int x2 = (i*z->img_comp[n].h + x)*8;
+
2680 int y2 = (j*z->img_comp[n].v + y)*8;
+
2681 int ha = z->img_comp[n].ha;
+
2682 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;
+
2683 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+
+
+
+
+
+
2689 if (--z->todo <= 0) {
+
2690 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+
2691 if (!STBI__RESTART(z->marker))
return 1;
+
2692 stbi__jpeg_reset(z);
+
+
+
+
+
+
+
2699 if (z->scan_n == 1) {
+
+
2701 int n = z->order[0];
+
+
+
+
+
2706 int w = (z->img_comp[n].x+7) >> 3;
+
2707 int h = (z->img_comp[n].y+7) >> 3;
+
2708 for (j=0; j < h; ++j) {
+
2709 for (i=0; i < w; ++i) {
+
2710 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+
2711 if (z->spec_start == 0) {
+
2712 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+
+
+
2715 int ha = z->img_comp[n].ha;
+
2716 if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+
+
+
+
2720 if (--z->todo <= 0) {
+
2721 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+
2722 if (!STBI__RESTART(z->marker))
return 1;
+
2723 stbi__jpeg_reset(z);
+
+
+
+
+
+
+
2730 for (j=0; j < z->img_mcu_y; ++j) {
+
2731 for (i=0; i < z->img_mcu_x; ++i) {
+
+
2733 for (k=0; k < z->scan_n; ++k) {
+
2734 int n = z->order[k];
+
+
+
2737 for (y=0; y < z->img_comp[n].v; ++y) {
+
2738 for (x=0; x < z->img_comp[n].h; ++x) {
+
2739 int x2 = (i*z->img_comp[n].h + x);
+
2740 int y2 = (j*z->img_comp[n].v + y);
+
2741 short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+
2742 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+
+
+
+
+
+
+
2749 if (--z->todo <= 0) {
+
2750 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+
2751 if (!STBI__RESTART(z->marker))
return 1;
+
2752 stbi__jpeg_reset(z);
+
+
+
+
+
+
+
+
+
2761 static void stbi__jpeg_dequantize(
short *data, stbi__uint16 *dequant)
+
+
+
2764 for (i=0; i < 64; ++i)
+
2765 data[i] *= dequant[i];
+
+
+
2768 static void stbi__jpeg_finish(stbi__jpeg *z)
+
+
2770 if (z->progressive) {
+
+
+
2773 for (n=0; n < z->s->img_n; ++n) {
+
2774 int w = (z->img_comp[n].x+7) >> 3;
+
2775 int h = (z->img_comp[n].y+7) >> 3;
+
2776 for (j=0; j < h; ++j) {
+
2777 for (i=0; i < w; ++i) {
+
2778 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+
2779 stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+
2780 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+
+
+
+
+
+
+
2787 static int stbi__process_marker(stbi__jpeg *z,
int m)
+
+
+
+
2791 case STBI__MARKER_none:
+
2792 return stbi__err(
"expected marker",
"Corrupt JPEG");
+
+
+
2795 if (stbi__get16be(z->s) != 4)
return stbi__err(
"bad DRI len",
"Corrupt JPEG");
+
2796 z->restart_interval = stbi__get16be(z->s);
+
+
+
+
2800 L = stbi__get16be(z->s)-2;
+
+
2802 int q = stbi__get8(z->s);
+
2803 int p = q >> 4, sixteen = (p != 0);
+
+
2805 if (p != 0 && p != 1)
return stbi__err(
"bad DQT type",
"Corrupt JPEG");
+
2806 if (t > 3)
return stbi__err(
"bad DQT table",
"Corrupt JPEG");
+
+
2808 for (i=0; i < 64; ++i)
+
2809 z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+
2810 L -= (sixteen ? 129 : 65);
+
+
+
+
+
2815 L = stbi__get16be(z->s)-2;
+
+
+
2818 int sizes[16],i,n=0;
+
2819 int q = stbi__get8(z->s);
+
+
+
2822 if (tc > 1 || th > 3)
return stbi__err(
"bad DHT header",
"Corrupt JPEG");
+
2823 for (i=0; i < 16; ++i) {
+
2824 sizes[i] = stbi__get8(z->s);
+
+
+
+
+
2829 if (!stbi__build_huffman(z->huff_dc+th, sizes))
return 0;
+
2830 v = z->huff_dc[th].values;
+
+
2832 if (!stbi__build_huffman(z->huff_ac+th, sizes))
return 0;
+
2833 v = z->huff_ac[th].values;
+
+
2835 for (i=0; i < n; ++i)
+
2836 v[i] = stbi__get8(z->s);
+
+
2838 stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+
+
+
+
+
+
+
2845 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+
2846 L = stbi__get16be(z->s);
+
+
+
2849 return stbi__err(
"bad COM len",
"Corrupt JPEG");
+
+
2851 return stbi__err(
"bad APP len",
"Corrupt JPEG");
+
+
+
+
2855 if (m == 0xE0 && L >= 5) {
+
2856 static const unsigned char tag[5] = {
'J',
'F',
'I',
'F',
'\0'};
+
+
+
2859 for (i=0; i < 5; ++i)
+
2860 if (stbi__get8(z->s) != tag[i])
+
+
+
+
+
2865 }
else if (m == 0xEE && L >= 12) {
+
2866 static const unsigned char tag[6] = {
'A',
'd',
'o',
'b',
'e',
'\0'};
+
+
+
2869 for (i=0; i < 6; ++i)
+
2870 if (stbi__get8(z->s) != tag[i])
+
+
+
+
+
2875 stbi__get16be(z->s);
+
2876 stbi__get16be(z->s);
+
2877 z->app14_color_transform = stbi__get8(z->s);
+
+
+
+
+
2882 stbi__skip(z->s, L);
+
+
+
+
2886 return stbi__err(
"unknown marker",
"Corrupt JPEG");
+
+
+
+
2890 static int stbi__process_scan_header(stbi__jpeg *z)
+
+
+
2893 int Ls = stbi__get16be(z->s);
+
2894 z->scan_n = stbi__get8(z->s);
+
2895 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");
+
2896 if (Ls != 6+2*z->scan_n)
return stbi__err(
"bad SOS len",
"Corrupt JPEG");
+
2897 for (i=0; i < z->scan_n; ++i) {
+
2898 int id = stbi__get8(z->s), which;
+
2899 int q = stbi__get8(z->s);
+
2900 for (which = 0; which < z->s->img_n; ++which)
+
2901 if (z->img_comp[which].id ==
id)
+
+
2903 if (which == z->s->img_n)
return 0;
+
2904 z->img_comp[which].hd = q >> 4;
if (z->img_comp[which].hd > 3)
return stbi__err(
"bad DC huff",
"Corrupt JPEG");
+
2905 z->img_comp[which].ha = q & 15;
if (z->img_comp[which].ha > 3)
return stbi__err(
"bad AC huff",
"Corrupt JPEG");
+
2906 z->order[i] = which;
+
+
+
+
+
2911 z->spec_start = stbi__get8(z->s);
+
2912 z->spec_end = stbi__get8(z->s);
+
2913 aa = stbi__get8(z->s);
+
2914 z->succ_high = (aa >> 4);
+
2915 z->succ_low = (aa & 15);
+
2916 if (z->progressive) {
+
2917 if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+
2918 return stbi__err(
"bad SOS",
"Corrupt JPEG");
+
+
2920 if (z->spec_start != 0)
return stbi__err(
"bad SOS",
"Corrupt JPEG");
+
2921 if (z->succ_high != 0 || z->succ_low != 0)
return stbi__err(
"bad SOS",
"Corrupt JPEG");
+
+
+
+
+
+
+
+
2929 static int stbi__free_jpeg_components(stbi__jpeg *z,
int ncomp,
int why)
+
+
+
2932 for (i=0; i < ncomp; ++i) {
+
2933 if (z->img_comp[i].raw_data) {
+
2934 STBI_FREE(z->img_comp[i].raw_data);
+
2935 z->img_comp[i].raw_data = NULL;
+
2936 z->img_comp[i].data = NULL;
+
+
2938 if (z->img_comp[i].raw_coeff) {
+
2939 STBI_FREE(z->img_comp[i].raw_coeff);
+
2940 z->img_comp[i].raw_coeff = 0;
+
2941 z->img_comp[i].coeff = 0;
+
+
2943 if (z->img_comp[i].linebuf) {
+
2944 STBI_FREE(z->img_comp[i].linebuf);
+
2945 z->img_comp[i].linebuf = NULL;
+
+
+
+
+
+
2951 static int stbi__process_frame_header(stbi__jpeg *z,
int scan)
+
+
2953 stbi__context *s = z->s;
+
2954 int Lf,p,i,q, h_max=1,v_max=1,c;
+
2955 Lf = stbi__get16be(s);
if (Lf < 11)
return stbi__err(
"bad SOF len",
"Corrupt JPEG");
+
2956 p = stbi__get8(s);
if (p != 8)
return stbi__err(
"only 8-bit",
"JPEG format not supported: 8-bit only");
+
2957 s->img_y = stbi__get16be(s);
if (s->img_y == 0)
return stbi__err(
"no header height",
"JPEG format not supported: delayed height");
+
2958 s->img_x = stbi__get16be(s);
if (s->img_x == 0)
return stbi__err(
"0 width",
"Corrupt JPEG");
+
+
2960 if (c != 3 && c != 1 && c != 4)
return stbi__err(
"bad component count",
"Corrupt JPEG");
+
+
2962 for (i=0; i < c; ++i) {
+
2963 z->img_comp[i].data = NULL;
+
2964 z->img_comp[i].linebuf = NULL;
+
+
+
2967 if (Lf != 8+3*s->img_n)
return stbi__err(
"bad SOF len",
"Corrupt JPEG");
+
+
+
2970 for (i=0; i < s->img_n; ++i) {
+
2971 static unsigned char rgb[3] = {
'R',
'G',
'B' };
+
2972 z->img_comp[i].id = stbi__get8(s);
+
2973 if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+
+
+
2976 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");
+
2977 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");
+
2978 z->img_comp[i].tq = stbi__get8(s);
if (z->img_comp[i].tq > 3)
return stbi__err(
"bad TQ",
"Corrupt JPEG");
+
+
+
2981 if (scan != STBI__SCAN_load)
return 1;
+
+
2983 if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0))
return stbi__err(
"too large",
"Image too large to decode");
+
+
2985 for (i=0; i < s->img_n; ++i) {
+
2986 if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+
2987 if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+
+
+
+
2991 z->img_h_max = h_max;
+
2992 z->img_v_max = v_max;
+
2993 z->img_mcu_w = h_max * 8;
+
2994 z->img_mcu_h = v_max * 8;
+
+
2996 z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+
2997 z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+
2999 for (i=0; i < s->img_n; ++i) {
+
+
3001 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+
3002 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+
+
+
+
+
+
+
+
3010 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+
3011 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+
3012 z->img_comp[i].coeff = 0;
+
3013 z->img_comp[i].raw_coeff = 0;
+
3014 z->img_comp[i].linebuf = NULL;
+
3015 z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+
3016 if (z->img_comp[i].raw_data == NULL)
+
3017 return stbi__free_jpeg_components(z, i+1, stbi__err(
"outofmem",
"Out of memory"));
+
+
3019 z->img_comp[i].data = (
stbi_uc*) (((
size_t) z->img_comp[i].raw_data + 15) & ~15);
+
3020 if (z->progressive) {
+
+
3022 z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+
3023 z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+
3024 z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2,
sizeof(
short), 15);
+
3025 if (z->img_comp[i].raw_coeff == NULL)
+
3026 return stbi__free_jpeg_components(z, i+1, stbi__err(
"outofmem",
"Out of memory"));
+
3027 z->img_comp[i].coeff = (
short*) (((
size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+
+
+
+
+
+
+
+
3035 #define stbi__DNL(x) ((x) == 0xdc)
+
3036 #define stbi__SOI(x) ((x) == 0xd8)
+
3037 #define stbi__EOI(x) ((x) == 0xd9)
+
3038 #define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+
3039 #define stbi__SOS(x) ((x) == 0xda)
+
+
3041 #define stbi__SOF_progressive(x) ((x) == 0xc2)
+
+
3043 static int stbi__decode_jpeg_header(stbi__jpeg *z,
int scan)
+
+
+
+
3047 z->app14_color_transform = -1;
+
3048 z->marker = STBI__MARKER_none;
+
3049 m = stbi__get_marker(z);
+
3050 if (!stbi__SOI(m))
return stbi__err(
"no SOI",
"Corrupt JPEG");
+
3051 if (scan == STBI__SCAN_type)
return 1;
+
3052 m = stbi__get_marker(z);
+
3053 while (!stbi__SOF(m)) {
+
3054 if (!stbi__process_marker(z,m))
return 0;
+
3055 m = stbi__get_marker(z);
+
3056 while (m == STBI__MARKER_none) {
+
+
3058 if (stbi__at_eof(z->s))
return stbi__err(
"no SOF",
"Corrupt JPEG");
+
3059 m = stbi__get_marker(z);
+
+
+
3062 z->progressive = stbi__SOF_progressive(m);
+
3063 if (!stbi__process_frame_header(z, scan))
return 0;
+
+
+
+
+
3068 static int stbi__decode_jpeg_image(stbi__jpeg *j)
+
+
+
3071 for (m = 0; m < 4; m++) {
+
3072 j->img_comp[m].raw_data = NULL;
+
3073 j->img_comp[m].raw_coeff = NULL;
+
+
3075 j->restart_interval = 0;
+
3076 if (!stbi__decode_jpeg_header(j, STBI__SCAN_load))
return 0;
+
3077 m = stbi__get_marker(j);
+
3078 while (!stbi__EOI(m)) {
+
+
3080 if (!stbi__process_scan_header(j))
return 0;
+
3081 if (!stbi__parse_entropy_coded_data(j))
return 0;
+
3082 if (j->marker == STBI__MARKER_none ) {
+
+
3084 while (!stbi__at_eof(j->s)) {
+
3085 int x = stbi__get8(j->s);
+
+
3087 j->marker = stbi__get8(j->s);
+
+
+
+
+
+
3093 }
else if (stbi__DNL(m)) {
+
3094 int Ld = stbi__get16be(j->s);
+
3095 stbi__uint32 NL = stbi__get16be(j->s);
+
3096 if (Ld != 4) stbi__err(
"bad DNL len",
"Corrupt JPEG");
+
3097 if (NL != j->s->img_y) stbi__err(
"bad DNL height",
"Corrupt JPEG");
+
+
3099 if (!stbi__process_marker(j, m))
return 0;
+
+
3101 m = stbi__get_marker(j);
+
+
+
3104 stbi__jpeg_finish(j);
+
+
+
+
+
+
+
+
+
3113 #define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+
+
+
+
3118 STBI_NOTUSED(in_far);
+
+
+
+
+
+
+
+
+
+
+
3129 for (i=0; i < w; ++i)
+
3130 out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+
+
+
+
+
+
+
+
+
+
+
+
3142 out[0] = out[1] = input[0];
+
+
+
+
+
3147 out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+
3148 for (i=1; i < w-1; ++i) {
+
3149 int n = 3*input[i]+2;
+
3150 out[i*2+0] = stbi__div4(n+input[i-1]);
+
3151 out[i*2+1] = stbi__div4(n+input[i+1]);
+
+
3153 out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+
3154 out[i*2+1] = input[w-1];
+
+
3156 STBI_NOTUSED(in_far);
+
+
+
+
+
+
3162 #define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+
+
+
+
+
+
3169 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+
+
+
+
3173 t1 = 3*in_near[0] + in_far[0];
+
3174 out[0] = stbi__div4(t1+2);
+
3175 for (i=1; i < w; ++i) {
+
+
3177 t1 = 3*in_near[i]+in_far[i];
+
3178 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+
3179 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
+
+
3181 out[w*2-1] = stbi__div4(t1+2);
+
+
+
+
+
+
+
3188 #if defined(STBI_SSE2) || defined(STBI_NEON)
+
+
+
+
+
+
+
3195 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+
+
+
+
3199 t1 = 3*in_near[0] + in_far[0];
+
+
+
+
3203 for (; i < ((w-1) & ~7); i += 8) {
+
3204 #if defined(STBI_SSE2)
+
+
+
3207 __m128i zero = _mm_setzero_si128();
+
3208 __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
+
3209 __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+
3210 __m128i farw = _mm_unpacklo_epi8(farb, zero);
+
3211 __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+
3212 __m128i diff = _mm_sub_epi16(farw, nearw);
+
3213 __m128i nears = _mm_slli_epi16(nearw, 2);
+
3214 __m128i curr = _mm_add_epi16(nears, diff);
+
+
+
+
+
+
+
3221 __m128i prv0 = _mm_slli_si128(curr, 2);
+
3222 __m128i nxt0 = _mm_srli_si128(curr, 2);
+
3223 __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+
3224 __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+
+
+
+
+
3230 __m128i bias = _mm_set1_epi16(8);
+
3231 __m128i curs = _mm_slli_epi16(curr, 2);
+
3232 __m128i prvd = _mm_sub_epi16(prev, curr);
+
3233 __m128i nxtd = _mm_sub_epi16(next, curr);
+
3234 __m128i curb = _mm_add_epi16(curs, bias);
+
3235 __m128i even = _mm_add_epi16(prvd, curb);
+
3236 __m128i odd = _mm_add_epi16(nxtd, curb);
+
+
+
3239 __m128i int0 = _mm_unpacklo_epi16(even, odd);
+
3240 __m128i int1 = _mm_unpackhi_epi16(even, odd);
+
3241 __m128i de0 = _mm_srli_epi16(int0, 4);
+
3242 __m128i de1 = _mm_srli_epi16(int1, 4);
+
+
+
3245 __m128i outv = _mm_packus_epi16(de0, de1);
+
3246 _mm_storeu_si128((__m128i *) (out + i*2), outv);
+
3247 #elif defined(STBI_NEON)
+
+
+
3250 uint8x8_t farb = vld1_u8(in_far + i);
+
3251 uint8x8_t nearb = vld1_u8(in_near + i);
+
3252 int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+
3253 int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+
3254 int16x8_t curr = vaddq_s16(nears, diff);
+
+
+
+
+
+
+
3261 int16x8_t prv0 = vextq_s16(curr, curr, 7);
+
3262 int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+
3263 int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+
3264 int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+
+
+
+
+
3270 int16x8_t curs = vshlq_n_s16(curr, 2);
+
3271 int16x8_t prvd = vsubq_s16(prev, curr);
+
3272 int16x8_t nxtd = vsubq_s16(next, curr);
+
3273 int16x8_t even = vaddq_s16(curs, prvd);
+
3274 int16x8_t odd = vaddq_s16(curs, nxtd);
+
+
+
+
3278 o.val[0] = vqrshrun_n_s16(even, 4);
+
3279 o.val[1] = vqrshrun_n_s16(odd, 4);
+
3280 vst2_u8(out + i*2, o);
+
+
+
+
3284 t1 = 3*in_near[i+7] + in_far[i+7];
+
+
+
+
3288 t1 = 3*in_near[i] + in_far[i];
+
3289 out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+
3291 for (++i; 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);
+
+
+
+
+
+
+
+
+
+
+
+
3309 STBI_NOTUSED(in_far);
+
3310 for (i=0; i < w; ++i)
+
3311 for (j=0; j < hs; ++j)
+
3312 out[i*hs+j] = in_near[i];
+
+
+
+
+
+
3318 #define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
+
+
+
+
3322 for (i=0; i < count; ++i) {
+
3323 int y_fixed = (y[i] << 20) + (1<<19);
+
+
3325 int cr = pcr[i] - 128;
+
3326 int cb = pcb[i] - 128;
+
3327 r = y_fixed + cr* stbi__float2fixed(1.40200f);
+
3328 g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+
3329 b = y_fixed + cb* stbi__float2fixed(1.77200f);
+
+
+
+
3333 if ((
unsigned) r > 255) {
if (r < 0) r = 0;
else r = 255; }
+
3334 if ((
unsigned) g > 255) {
if (g < 0) g = 0;
else g = 255; }
+
3335 if ((
unsigned) b > 255) {
if (b < 0) b = 0;
else b = 255; }
+
+
+
+
+
+
+
+
+
3344 #if defined(STBI_SSE2) || defined(STBI_NEON)
+
+
+
+
+
+
+
+
+
+
+
3355 __m128i signflip = _mm_set1_epi8(-0x80);
+
3356 __m128i cr_const0 = _mm_set1_epi16( (
short) ( 1.40200f*4096.0f+0.5f));
+
3357 __m128i cr_const1 = _mm_set1_epi16( - (
short) ( 0.71414f*4096.0f+0.5f));
+
3358 __m128i cb_const0 = _mm_set1_epi16( - (
short) ( 0.34414f*4096.0f+0.5f));
+
3359 __m128i cb_const1 = _mm_set1_epi16( (
short) ( 1.77200f*4096.0f+0.5f));
+
3360 __m128i y_bias = _mm_set1_epi8((
char) (
unsigned char) 128);
+
3361 __m128i xw = _mm_set1_epi16(255);
+
+
3363 for (; i+7 < count; i += 8) {
+
+
3365 __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+
3366 __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+
3367 __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+
3368 __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip);
+
3369 __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip);
+
+
+
3372 __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
+
3373 __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+
3374 __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+
+
3377 __m128i yws = _mm_srli_epi16(yw, 4);
+
3378 __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+
3379 __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+
3380 __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+
3381 __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+
3382 __m128i rws = _mm_add_epi16(cr0, yws);
+
3383 __m128i gwt = _mm_add_epi16(cb0, yws);
+
3384 __m128i bws = _mm_add_epi16(yws, cb1);
+
3385 __m128i gws = _mm_add_epi16(gwt, cr1);
+
+
+
3388 __m128i rw = _mm_srai_epi16(rws, 4);
+
3389 __m128i bw = _mm_srai_epi16(bws, 4);
+
3390 __m128i gw = _mm_srai_epi16(gws, 4);
+
+
+
3393 __m128i brb = _mm_packus_epi16(rw, bw);
+
3394 __m128i gxb = _mm_packus_epi16(gw, xw);
+
+
+
3397 __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+
3398 __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+
3399 __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+
3400 __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+
+
3403 _mm_storeu_si128((__m128i *) (out + 0), o0);
+
3404 _mm_storeu_si128((__m128i *) (out + 16), o1);
+
+
+
+
+
+
+
+
+
+
3414 uint8x8_t signflip = vdup_n_u8(0x80);
+
3415 int16x8_t cr_const0 = vdupq_n_s16( (
short) ( 1.40200f*4096.0f+0.5f));
+
3416 int16x8_t cr_const1 = vdupq_n_s16( - (
short) ( 0.71414f*4096.0f+0.5f));
+
3417 int16x8_t cb_const0 = vdupq_n_s16( - (
short) ( 0.34414f*4096.0f+0.5f));
+
3418 int16x8_t cb_const1 = vdupq_n_s16( (
short) ( 1.77200f*4096.0f+0.5f));
+
+
3420 for (; i+7 < count; i += 8) {
+
+
3422 uint8x8_t y_bytes = vld1_u8(y + i);
+
3423 uint8x8_t cr_bytes = vld1_u8(pcr + i);
+
3424 uint8x8_t cb_bytes = vld1_u8(pcb + i);
+
3425 int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+
3426 int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+
+
3429 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+
3430 int16x8_t crw = vshll_n_s8(cr_biased, 7);
+
3431 int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+
+
3434 int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+
3435 int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+
3436 int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+
3437 int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+
3438 int16x8_t rws = vaddq_s16(yws, cr0);
+
3439 int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+
3440 int16x8_t bws = vaddq_s16(yws, cb1);
+
+
+
+
3444 o.val[0] = vqrshrun_n_s16(rws, 4);
+
3445 o.val[1] = vqrshrun_n_s16(gws, 4);
+
3446 o.val[2] = vqrshrun_n_s16(bws, 4);
+
3447 o.val[3] = vdup_n_u8(255);
+
+
+
+
+
+
+
+
+
3456 for (; i < count; ++i) {
+
3457 int y_fixed = (y[i] << 20) + (1<<19);
+
+
3459 int cr = pcr[i] - 128;
+
3460 int cb = pcb[i] - 128;
+
3461 r = y_fixed + cr* stbi__float2fixed(1.40200f);
+
3462 g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+
3463 b = y_fixed + cb* stbi__float2fixed(1.77200f);
+
+
+
+
3467 if ((
unsigned) r > 255) {
if (r < 0) r = 0;
else r = 255; }
+
3468 if ((
unsigned) g > 255) {
if (g < 0) g = 0;
else g = 255; }
+
3469 if ((
unsigned) b > 255) {
if (b < 0) b = 0;
else b = 255; }
+
+
+
+
+
+
+
+
+
+
+
3480 static void stbi__setup_jpeg(stbi__jpeg *j)
+
+
3482 j->idct_block_kernel = stbi__idct_block;
+
3483 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+
3484 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+
+
3487 if (stbi__sse2_available()) {
+
3488 j->idct_block_kernel = stbi__idct_simd;
+
3489 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+
3490 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+
+
+
+
+
3495 j->idct_block_kernel = stbi__idct_simd;
+
3496 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+
3497 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+
+
+
+
+
3502 static void stbi__cleanup_jpeg(stbi__jpeg *j)
+
+
3504 stbi__free_jpeg_components(j, j->s->img_n, 0);
+
+
+
+
+
3509 resample_row_func resample;
+
+
+
+
+
+
+
+
+
+
+
3520 unsigned int t = x*y + 128;
+
3521 return (
stbi_uc) ((t + (t >>8)) >> 8);
+
+
+
3524 static stbi_uc *load_jpeg_image(stbi__jpeg *z,
int *out_x,
int *out_y,
int *comp,
int req_comp)
+
+
3526 int n, decode_n, is_rgb;
+
+
+
+
3530 if (req_comp < 0 || req_comp > 4)
return stbi__errpuc(
"bad req_comp",
"Internal error");
+
+
+
3533 if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z);
return NULL; }
+
+
+
3536 n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+
3538 is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+
3540 if (z->s->img_n == 3 && n < 3 && !is_rgb)
+
+
+
3543 decode_n = z->s->img_n;
+
+
+
+
+
+
+
+
+
3552 stbi__resample res_comp[4];
+
+
3554 for (k=0; k < decode_n; ++k) {
+
3555 stbi__resample *r = &res_comp[k];
+
+
+
+
3559 z->img_comp[k].linebuf = (
stbi_uc *) stbi__malloc(z->s->img_x + 3);
+
3560 if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
+
+
3562 r->hs = z->img_h_max / z->img_comp[k].h;
+
3563 r->vs = z->img_v_max / z->img_comp[k].v;
+
3564 r->ystep = r->vs >> 1;
+
3565 r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+
+
3567 r->line0 = r->line1 = z->img_comp[k].data;
+
+
3569 if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+
3570 else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+
3571 else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+
3572 else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+
3573 else r->resample = stbi__resample_row_generic;
+
+
+
+
3577 output = (
stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+
3578 if (!output) { stbi__cleanup_jpeg(z);
return stbi__errpuc(
"outofmem",
"Out of memory"); }
+
+
+
3581 for (j=0; j < z->s->img_y; ++j) {
+
3582 stbi_uc *out = output + n * z->s->img_x * j;
+
3583 for (k=0; k < decode_n; ++k) {
+
3584 stbi__resample *r = &res_comp[k];
+
3585 int y_bot = r->ystep >= (r->vs >> 1);
+
3586 coutput[k] = r->resample(z->img_comp[k].linebuf,
+
3587 y_bot ? r->line1 : r->line0,
+
3588 y_bot ? r->line0 : r->line1,
+
+
3590 if (++r->ystep >= r->vs) {
+
+
3592 r->line0 = r->line1;
+
3593 if (++r->ypos < z->img_comp[k].y)
+
3594 r->line1 += z->img_comp[k].w2;
+
+
+
+
+
3599 if (z->s->img_n == 3) {
+
+
3601 for (i=0; i < z->s->img_x; ++i) {
+
+
3603 out[1] = coutput[1][i];
+
3604 out[2] = coutput[2][i];
+
+
+
+
+
3609 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+
+
3611 }
else if (z->s->img_n == 4) {
+
3612 if (z->app14_color_transform == 0) {
+
3613 for (i=0; i < z->s->img_x; ++i) {
+
+
3615 out[0] = stbi__blinn_8x8(coutput[0][i], m);
+
3616 out[1] = stbi__blinn_8x8(coutput[1][i], m);
+
3617 out[2] = stbi__blinn_8x8(coutput[2][i], m);
+
+
+
+
3621 }
else if (z->app14_color_transform == 2) {
+
3622 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+
3623 for (i=0; i < z->s->img_x; ++i) {
+
+
3625 out[0] = stbi__blinn_8x8(255 - out[0], m);
+
3626 out[1] = stbi__blinn_8x8(255 - out[1], m);
+
3627 out[2] = stbi__blinn_8x8(255 - out[2], m);
+
+
+
+
3631 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+
+
+
3634 for (i=0; i < z->s->img_x; ++i) {
+
3635 out[0] = out[1] = out[2] = y[i];
+
+
+
+
+
+
+
3642 for (i=0; i < z->s->img_x; ++i)
+
3643 *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+
+
3645 for (i=0; i < z->s->img_x; ++i, out += 2) {
+
3646 out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+
+
+
+
3650 }
else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+
3651 for (i=0; i < z->s->img_x; ++i) {
+
+
3653 stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+
3654 stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+
3655 stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+
3656 out[0] = stbi__compute_y(r, g, b);
+
+
+
+
3660 }
else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+
3661 for (i=0; i < z->s->img_x; ++i) {
+
3662 out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+
+
+
+
+
+
+
3669 for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+
+
3671 for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+
+
+
+
3675 stbi__cleanup_jpeg(z);
+
3676 *out_x = z->s->img_x;
+
3677 *out_y = z->s->img_y;
+
3678 if (comp) *comp = z->s->img_n >= 3 ? 3 : 1;
+
+
+
+
+
3683 static void *stbi__jpeg_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
3685 unsigned char* result;
+
3686 stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(
sizeof(stbi__jpeg));
+
+
+
3689 stbi__setup_jpeg(j);
+
3690 result = load_jpeg_image(j, x,y,comp,req_comp);
+
+
+
+
+
3695 static int stbi__jpeg_test(stbi__context *s)
+
+
+
3698 stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(
sizeof(stbi__jpeg));
+
+
3700 stbi__setup_jpeg(j);
+
3701 r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+
+
+
+
+
+
3707 static int stbi__jpeg_info_raw(stbi__jpeg *j,
int *x,
int *y,
int *comp)
+
+
3709 if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+
3710 stbi__rewind( j->s );
+
+
+
3713 if (x) *x = j->s->img_x;
+
3714 if (y) *y = j->s->img_y;
+
3715 if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+
+
+
+
3719 static int stbi__jpeg_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
+
3722 stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(
sizeof(stbi__jpeg)));
+
+
3724 result = stbi__jpeg_info_raw(j, x, y, comp);
+
+
+
+
+
+
+
+
+
+
+
+
+
3737 #ifndef STBI_NO_ZLIB
+
+
+
3740 #define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
+
3741 #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
+
+
+
+
+
+
3747 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+
3748 stbi__uint16 firstcode[16];
+
+
3750 stbi__uint16 firstsymbol[16];
+
+
3752 stbi__uint16 value[288];
+
+
+
3755 stbi_inline
static int stbi__bitreverse16(
int n)
+
+
3757 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
+
3758 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
+
3759 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
+
3760 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
+
+
+
+
3764 stbi_inline
static int stbi__bit_reverse(
int v,
int bits)
+
+
3766 STBI_ASSERT(bits <= 16);
+
+
+
3769 return stbi__bitreverse16(v) >> (16-bits);
+
+
+
3772 static int stbi__zbuild_huffman(stbi__zhuffman *z,
const stbi_uc *sizelist,
int num)
+
+
+
3775 int code, next_code[16], sizes[17];
+
+
+
3778 memset(sizes, 0,
sizeof(sizes));
+
3779 memset(z->fast, 0,
sizeof(z->fast));
+
3780 for (i=0; i < num; ++i)
+
3781 ++sizes[sizelist[i]];
+
+
3783 for (i=1; i < 16; ++i)
+
3784 if (sizes[i] > (1 << i))
+
3785 return stbi__err(
"bad sizes",
"Corrupt PNG");
+
+
3787 for (i=1; i < 16; ++i) {
+
3788 next_code[i] = code;
+
3789 z->firstcode[i] = (stbi__uint16) code;
+
3790 z->firstsymbol[i] = (stbi__uint16) k;
+
3791 code = (code + sizes[i]);
+
+
3793 if (code-1 >= (1 << i))
return stbi__err(
"bad codelengths",
"Corrupt PNG");
+
3794 z->maxcode[i] = code << (16-i);
+
+
+
+
3798 z->maxcode[16] = 0x10000;
+
3799 for (i=0; i < num; ++i) {
+
3800 int s = sizelist[i];
+
+
3802 int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+
3803 stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+
+
3805 z->value[c] = (stbi__uint16) i;
+
3806 if (s <= STBI__ZFAST_BITS) {
+
3807 int j = stbi__bit_reverse(next_code[s],s);
+
3808 while (j < (1 << STBI__ZFAST_BITS)) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
3827 stbi_uc *zbuffer, *zbuffer_end;
+
+
3829 stbi__uint32 code_buffer;
+
+
+
+
+
+
+
3836 stbi__zhuffman z_length, z_distance;
+
+
+
3839 stbi_inline
static stbi_uc stbi__zget8(stbi__zbuf *z)
+
+
3841 if (z->zbuffer >= z->zbuffer_end)
return 0;
+
3842 return *z->zbuffer++;
+
+
+
3845 static void stbi__fill_bits(stbi__zbuf *z)
+
+
+
3848 STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
+
3849 z->code_buffer |= (
unsigned int) stbi__zget8(z) << z->num_bits;
+
+
3851 }
while (z->num_bits <= 24);
+
+
+
3854 stbi_inline
static unsigned int stbi__zreceive(stbi__zbuf *z,
int n)
+
+
+
3857 if (z->num_bits < n) stbi__fill_bits(z);
+
3858 k = z->code_buffer & ((1 << n) - 1);
+
3859 z->code_buffer >>= n;
+
+
+
+
+
3864 static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+
+
+
+
+
3869 k = stbi__bit_reverse(a->code_buffer, 16);
+
3870 for (s=STBI__ZFAST_BITS+1; ; ++s)
+
3871 if (k < z->maxcode[s])
+
+
3873 if (s == 16)
return -1;
+
+
3875 b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+
3876 STBI_ASSERT(z->size[b] == s);
+
3877 a->code_buffer >>= s;
+
+
+
+
+
3882 stbi_inline
static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+
+
+
3885 if (a->num_bits < 16) stbi__fill_bits(a);
+
3886 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+
+
+
3889 a->code_buffer >>= s;
+
+
+
+
3893 return stbi__zhuffman_decode_slowpath(a, z);
+
+
+
3896 static int stbi__zexpand(stbi__zbuf *z,
char *zout,
int n)
+
+
+
3899 int cur, limit, old_limit;
+
+
3901 if (!z->z_expandable)
return stbi__err(
"output buffer limit",
"Corrupt PNG");
+
3902 cur = (int) (z->zout - z->zout_start);
+
3903 limit = old_limit = (int) (z->zout_end - z->zout_start);
+
3904 while (cur + n > limit)
+
+
3906 q = (
char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+
3907 STBI_NOTUSED(old_limit);
+
3908 if (q == NULL)
return stbi__err(
"outofmem",
"Out of memory");
+
+
+
3911 z->zout_end = q + limit;
+
+
+
+
3915 static int stbi__zlength_base[31] = {
+
3916 3,4,5,6,7,8,9,10,11,13,
+
3917 15,17,19,23,27,31,35,43,51,59,
+
3918 67,83,99,115,131,163,195,227,258,0,0 };
+
+
3920 static int stbi__zlength_extra[31]=
+
3921 { 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 };
+
+
3923 static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+
3924 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+
3926 static int stbi__zdist_extra[32] =
+
3927 { 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};
+
+
3929 static int stbi__parse_huffman_block(stbi__zbuf *a)
+
+
3931 char *zout = a->zout;
+
+
3933 int z = stbi__zhuffman_decode(a, &a->z_length);
+
+
3935 if (z < 0)
return stbi__err(
"bad huffman code",
"Corrupt PNG");
+
3936 if (zout >= a->zout_end) {
+
3937 if (!stbi__zexpand(a, zout, 1))
return 0;
+
+
+
+
+
+
+
+
+
+
+
+
3949 len = stbi__zlength_base[z];
+
3950 if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+
3951 z = stbi__zhuffman_decode(a, &a->z_distance);
+
3952 if (z < 0)
return stbi__err(
"bad huffman code",
"Corrupt PNG");
+
3953 dist = stbi__zdist_base[z];
+
3954 if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+
3955 if (zout - a->zout_start < dist)
return stbi__err(
"bad dist",
"Corrupt PNG");
+
3956 if (zout + len > a->zout_end) {
+
3957 if (!stbi__zexpand(a, zout, len))
return 0;
+
+
+
3960 p = (
stbi_uc *) (zout - dist);
+
+
+
3963 if (len) {
do *zout++ = v;
while (--len); }
+
+
3965 if (len) {
do *zout++ = *p++;
while (--len); }
+
+
+
+
+
+
3971 static int stbi__compute_huffman_codes(stbi__zbuf *a)
+
+
3973 static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+
3974 stbi__zhuffman z_codelength;
+
+
+
+
+
3979 int hlit = stbi__zreceive(a,5) + 257;
+
3980 int hdist = stbi__zreceive(a,5) + 1;
+
3981 int hclen = stbi__zreceive(a,4) + 4;
+
3982 int ntot = hlit + hdist;
+
+
3984 memset(codelength_sizes, 0,
sizeof(codelength_sizes));
+
3985 for (i=0; i < hclen; ++i) {
+
3986 int s = stbi__zreceive(a,3);
+
3987 codelength_sizes[length_dezigzag[i]] = (
stbi_uc) s;
+
+
3989 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19))
return 0;
+
+
+
+
3993 int c = stbi__zhuffman_decode(a, &z_codelength);
+
3994 if (c < 0 || c >= 19)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
+
+
+
+
+
+
4000 c = stbi__zreceive(a,2)+3;
+
4001 if (n == 0)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
+
4002 fill = lencodes[n-1];
+
+
4004 c = stbi__zreceive(a,3)+3;
+
+
4006 STBI_ASSERT(c == 18);
+
4007 c = stbi__zreceive(a,7)+11;
+
+
4009 if (ntot - n < c)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
+
4010 memset(lencodes+n, fill, c);
+
+
+
+
4014 if (n != ntot)
return stbi__err(
"bad codelengths",
"Corrupt PNG");
+
4015 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit))
return 0;
+
4016 if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist))
return 0;
+
+
+
+
4020 static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+
+
+
+
4024 if (a->num_bits & 7)
+
4025 stbi__zreceive(a, a->num_bits & 7);
+
+
+
4028 while (a->num_bits > 0) {
+
4029 header[k++] = (
stbi_uc) (a->code_buffer & 255);
+
4030 a->code_buffer >>= 8;
+
+
+
4033 STBI_ASSERT(a->num_bits == 0);
+
+
+
4036 header[k++] = stbi__zget8(a);
+
4037 len = header[1] * 256 + header[0];
+
4038 nlen = header[3] * 256 + header[2];
+
4039 if (nlen != (len ^ 0xffff))
return stbi__err(
"zlib corrupt",
"Corrupt PNG");
+
4040 if (a->zbuffer + len > a->zbuffer_end)
return stbi__err(
"read past buffer",
"Corrupt PNG");
+
4041 if (a->zout + len > a->zout_end)
+
4042 if (!stbi__zexpand(a, a->zout, len))
return 0;
+
4043 memcpy(a->zout, a->zbuffer, len);
+
+
+
+
+
+
4049 static int stbi__parse_zlib_header(stbi__zbuf *a)
+
+
4051 int cmf = stbi__zget8(a);
+
+
+
4054 int flg = stbi__zget8(a);
+
4055 if ((cmf*256+flg) % 31 != 0)
return stbi__err(
"bad zlib header",
"Corrupt PNG");
+
4056 if (flg & 32)
return stbi__err(
"no preset dict",
"Corrupt PNG");
+
4057 if (cm != 8)
return stbi__err(
"bad compression",
"Corrupt PNG");
+
+
+
+
+
4062 static const stbi_uc stbi__zdefault_length[288] =
+
+
4064 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+
4065 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+
4066 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+
4067 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+
4068 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,
+
4069 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+
4070 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+
4071 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+
4072 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
+
+
4074 static const stbi_uc stbi__zdefault_distance[32] =
+
+
4076 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
4091 static int stbi__parse_zlib(stbi__zbuf *a,
int parse_header)
+
+
+
+
4095 if (!stbi__parse_zlib_header(a))
return 0;
+
+
+
+
4099 final = stbi__zreceive(a,1);
+
4100 type = stbi__zreceive(a,2);
+
+
4102 if (!stbi__parse_uncompressed_block(a))
return 0;
+
4103 }
else if (type == 3) {
+
+
+
+
+
4108 if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288))
return 0;
+
4109 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32))
return 0;
+
+
4111 if (!stbi__compute_huffman_codes(a))
return 0;
+
+
4113 if (!stbi__parse_huffman_block(a))
return 0;
+
+
+
+
+
+
4119 static int stbi__do_zlib(stbi__zbuf *a,
char *obuf,
int olen,
int exp,
int parse_header)
+
+
4121 a->zout_start = obuf;
+
+
4123 a->zout_end = obuf + olen;
+
4124 a->z_expandable = exp;
+
+
4126 return stbi__parse_zlib(a, parse_header);
+
+
+
+
+
+
4132 char *p = (
char *) stbi__malloc(initial_size);
+
4133 if (p == NULL)
return NULL;
+
4134 a.zbuffer = (
stbi_uc *) buffer;
+
4135 a.zbuffer_end = (
stbi_uc *) buffer + len;
+
4136 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+
4137 if (outlen) *outlen = (int) (a.zout - a.zout_start);
+
4138 return a.zout_start;
+
+
4140 STBI_FREE(a.zout_start);
+
+
+
+
+
+
+
+
+
+
+
+
+
4153 char *p = (
char *) stbi__malloc(initial_size);
+
4154 if (p == NULL)
return NULL;
+
4155 a.zbuffer = (
stbi_uc *) buffer;
+
4156 a.zbuffer_end = (
stbi_uc *) buffer + len;
+
4157 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+
4158 if (outlen) *outlen = (int) (a.zout - a.zout_start);
+
4159 return a.zout_start;
+
+
4161 STBI_FREE(a.zout_start);
+
+
+
+
+
+
+
+
4169 a.zbuffer = (
stbi_uc *) ibuffer;
+
4170 a.zbuffer_end = (
stbi_uc *) ibuffer + ilen;
+
4171 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+
4172 return (
int) (a.zout - a.zout_start);
+
+
+
+
+
+
+
+
4180 char *p = (
char *) stbi__malloc(16384);
+
4181 if (p == NULL)
return NULL;
+
4182 a.zbuffer = (
stbi_uc *) buffer;
+
4183 a.zbuffer_end = (
stbi_uc *) buffer+len;
+
4184 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+
4185 if (outlen) *outlen = (int) (a.zout - a.zout_start);
+
4186 return a.zout_start;
+
+
4188 STBI_FREE(a.zout_start);
+
+
+
+
+
+
+
+
4196 a.zbuffer = (
stbi_uc *) ibuffer;
+
4197 a.zbuffer_end = (
stbi_uc *) ibuffer + ilen;
+
4198 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+
4199 return (
int) (a.zout - a.zout_start);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
4218 stbi__uint32 length;
+
+
+
+
4222 static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+
+
+
4225 c.length = stbi__get32be(s);
+
4226 c.type = stbi__get32be(s);
+
+
+
+
4230 static int stbi__check_png_header(stbi__context *s)
+
+
4232 static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+
+
4234 for (i=0; i < 8; ++i)
+
4235 if (stbi__get8(s) != png_sig[i])
return stbi__err(
"bad png sig",
"Not a PNG");
+
+
+
+
+
+
+
4242 stbi_uc *idata, *expanded, *out;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
4258 static stbi_uc first_row_filter[5] =
+
+
+
+
+
+
+
+
+
4267 static int stbi__paeth(
int a,
int b,
int c)
+
+
+
+
+
+
4273 if (pa <= pb && pa <= pc)
return a;
+
4274 if (pb <= pc)
return b;
+
+
+
+
4278 static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+
+
4281 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)
+
+
4283 int bytes = (depth == 16? 2 : 1);
+
4284 stbi__context *s = a->s;
+
4285 stbi__uint32 i,j,stride = x*out_n*bytes;
+
4286 stbi__uint32 img_len, img_width_bytes;
+
+
4288 int img_n = s->img_n;
+
+
4290 int output_bytes = out_n*bytes;
+
4291 int filter_bytes = img_n*bytes;
+
+
+
4294 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+
4295 a->out = (
stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0);
+
4296 if (!a->out)
return stbi__err(
"outofmem",
"Out of memory");
+
+
4298 img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+
4299 img_len = (img_width_bytes + 1) * y;
+
+
+
+
4303 if (raw_len < img_len)
return stbi__err(
"not enough pixels",
"Corrupt PNG");
+
+
4305 for (j=0; j < y; ++j) {
+
4306 stbi_uc *cur = a->out + stride*j;
+
+
4308 int filter = *raw++;
+
+
+
4311 return stbi__err(
"invalid filter",
"Corrupt PNG");
+
+
+
4314 STBI_ASSERT(img_width_bytes <= x);
+
4315 cur += x*out_n - img_width_bytes;
+
+
4317 width = img_width_bytes;
+
+
4319 prior = cur - stride;
+
+
+
4322 if (j == 0) filter = first_row_filter[filter];
+
+
+
4325 for (k=0; k < filter_bytes; ++k) {
+
+
4327 case STBI__F_none : cur[k] = raw[k];
break;
+
4328 case STBI__F_sub : cur[k] = raw[k];
break;
+
4329 case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
break;
+
4330 case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
break;
+
4331 case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0));
break;
+
4332 case STBI__F_avg_first : cur[k] = raw[k];
break;
+
4333 case STBI__F_paeth_first: cur[k] = raw[k];
break;
+
+
+
+
+
+
+
+
+
+
4343 }
else if (depth == 16) {
+
4344 if (img_n != out_n) {
+
4345 cur[filter_bytes] = 255;
+
4346 cur[filter_bytes+1] = 255;
+
+
4348 raw += filter_bytes;
+
4349 cur += output_bytes;
+
4350 prior += output_bytes;
+
+
+
+
+
+
+
+
4358 if (depth < 8 || img_n == out_n) {
+
4359 int nk = (width - 1)*filter_bytes;
+
4360 #define STBI__CASE(f) \
+
+
4362 for (k=0; k < nk; ++k)
+
+
+
4365 case STBI__F_none: memcpy(cur, raw, nk);
break;
+
4366 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); }
break;
+
4367 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
break;
+
4368 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); }
break;
+
4369 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); }
break;
+
4370 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); }
break;
+
4371 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); }
break;
+
+
+
+
+
4376 STBI_ASSERT(img_n+1 == out_n);
+
4377 #define STBI__CASE(f) \
+
+
4379 for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
+
4380 for (k=0; k < filter_bytes; ++k)
+
+
4382 STBI__CASE(STBI__F_none) { cur[k] = raw[k]; }
break;
+
4383 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); }
break;
+
4384 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); }
break;
+
4385 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); }
break;
+
4386 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); }
break;
+
4387 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); }
break;
+
4388 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); }
break;
+
+
+
+
+
+
+
4395 cur = a->out + stride*j;
+
4396 for (i=0; i < x; ++i,cur+=output_bytes) {
+
4397 cur[filter_bytes+1] = 255;
+
+
+
+
+
+
+
+
+
+
4407 for (j=0; j < y; ++j) {
+
4408 stbi_uc *cur = a->out + stride*j;
+
4409 stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes;
+
+
+
4412 stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1;
+
+
+
+
+
+
+
+
+
4421 for (k=x*img_n; k >= 2; k-=2, ++in) {
+
4422 *cur++ = scale * ((*in >> 4) );
+
4423 *cur++ = scale * ((*in ) & 0x0f);
+
+
4425 if (k > 0) *cur++ = scale * ((*in >> 4) );
+
4426 }
else if (depth == 2) {
+
4427 for (k=x*img_n; k >= 4; k-=4, ++in) {
+
4428 *cur++ = scale * ((*in >> 6) );
+
4429 *cur++ = scale * ((*in >> 4) & 0x03);
+
4430 *cur++ = scale * ((*in >> 2) & 0x03);
+
4431 *cur++ = scale * ((*in ) & 0x03);
+
+
4433 if (k > 0) *cur++ = scale * ((*in >> 6) );
+
4434 if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
+
4435 if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
+
4436 }
else if (depth == 1) {
+
4437 for (k=x*img_n; k >= 8; k-=8, ++in) {
+
4438 *cur++ = scale * ((*in >> 7) );
+
4439 *cur++ = scale * ((*in >> 6) & 0x01);
+
4440 *cur++ = scale * ((*in >> 5) & 0x01);
+
4441 *cur++ = scale * ((*in >> 4) & 0x01);
+
4442 *cur++ = scale * ((*in >> 3) & 0x01);
+
4443 *cur++ = scale * ((*in >> 2) & 0x01);
+
4444 *cur++ = scale * ((*in >> 1) & 0x01);
+
4445 *cur++ = scale * ((*in ) & 0x01);
+
+
4447 if (k > 0) *cur++ = scale * ((*in >> 7) );
+
4448 if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
+
4449 if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
+
4450 if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
+
4451 if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
+
4452 if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
+
4453 if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
+
+
4455 if (img_n != out_n) {
+
+
+
4458 cur = a->out + stride*j;
+
+
4460 for (q=x-1; q >= 0; --q) {
+
+
4462 cur[q*2+0] = cur[q];
+
+
+
4465 STBI_ASSERT(img_n == 3);
+
4466 for (q=x-1; q >= 0; --q) {
+
+
4468 cur[q*4+2] = cur[q*3+2];
+
4469 cur[q*4+1] = cur[q*3+1];
+
4470 cur[q*4+0] = cur[q*3+0];
+
+
+
+
+
4475 }
else if (depth == 16) {
+
+
+
+
+
+
4481 stbi__uint16 *cur16 = (stbi__uint16*)cur;
+
+
4483 for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
+
4484 *cur16 = (cur[0] << 8) | cur[1];
+
+
+
+
+
+
+
4491 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)
+
+
4493 int bytes = (depth == 16 ? 2 : 1);
+
4494 int out_bytes = out_n * bytes;
+
+
+
+
4498 return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+
+
4501 final = (
stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+
4502 for (p=0; p < 7; ++p) {
+
4503 int xorig[] = { 0,4,0,2,0,1,0 };
+
4504 int yorig[] = { 0,0,4,0,2,0,1 };
+
4505 int xspc[] = { 8,8,4,4,2,2,1 };
+
4506 int yspc[] = { 8,8,8,4,4,2,2 };
+
+
+
4509 x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+
4510 y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+
+
4512 stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+
4513 if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+
+
+
+
4517 for (j=0; j < y; ++j) {
+
4518 for (i=0; i < x; ++i) {
+
4519 int out_y = j*yspc[p]+yorig[p];
+
4520 int out_x = i*xspc[p]+xorig[p];
+
4521 memcpy(
final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+
4522 a->out + (j*x+i)*out_bytes, out_bytes);
+
+
+
+
4526 image_data += img_len;
+
4527 image_data_len -= img_len;
+
+
+
+
+
+
+
+
4535 static int stbi__compute_transparency(stbi__png *z,
stbi_uc tc[3],
int out_n)
+
+
4537 stbi__context *s = z->s;
+
4538 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+
+
+
+
+
4543 STBI_ASSERT(out_n == 2 || out_n == 4);
+
+
+
4546 for (i=0; i < pixel_count; ++i) {
+
4547 p[1] = (p[0] == tc[0] ? 0 : 255);
+
+
+
+
4551 for (i=0; i < pixel_count; ++i) {
+
4552 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+
+
+
+
+
+
+
+
4560 static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3],
int out_n)
+
+
4562 stbi__context *s = z->s;
+
4563 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+
4564 stbi__uint16 *p = (stbi__uint16*) z->out;
+
+
+
+
4568 STBI_ASSERT(out_n == 2 || out_n == 4);
+
+
+
4571 for (i = 0; i < pixel_count; ++i) {
+
4572 p[1] = (p[0] == tc[0] ? 0 : 65535);
+
+
+
+
4576 for (i = 0; i < pixel_count; ++i) {
+
4577 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+
+
+
+
+
+
+
+
4585 static int stbi__expand_png_palette(stbi__png *a,
stbi_uc *palette,
int len,
int pal_img_n)
+
+
4587 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+
4588 stbi_uc *p, *temp_out, *orig = a->out;
+
+
4590 p = (
stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+
4591 if (p == NULL)
return stbi__err(
"outofmem",
"Out of memory");
+
+
+
+
+
4596 if (pal_img_n == 3) {
+
4597 for (i=0; i < pixel_count; ++i) {
+
+
+
4600 p[1] = palette[n+1];
+
4601 p[2] = palette[n+2];
+
+
+
+
4605 for (i=0; i < pixel_count; ++i) {
+
+
+
4608 p[1] = palette[n+1];
+
4609 p[2] = palette[n+2];
+
4610 p[3] = palette[n+3];
+
+
+
+
+
+
+
+
+
+
+
+
4622 static int stbi__unpremultiply_on_load = 0;
+
4623 static int stbi__de_iphone_flag = 0;
+
+
+
+
4627 stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply;
+
+
+
+
+
4632 stbi__de_iphone_flag = flag_true_if_should_convert;
+
+
+
4635 static void stbi__de_iphone(stbi__png *z)
+
+
4637 stbi__context *s = z->s;
+
4638 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+
+
+
4641 if (s->img_out_n == 3) {
+
4642 for (i=0; i < pixel_count; ++i) {
+
+
+
+
+
+
+
4649 STBI_ASSERT(s->img_out_n == 4);
+
4650 if (stbi__unpremultiply_on_load) {
+
+
4652 for (i=0; i < pixel_count; ++i) {
+
+
+
+
+
4657 p[0] = (p[2] * 255 + half) / a;
+
4658 p[1] = (p[1] * 255 + half) / a;
+
4659 p[2] = ( t * 255 + half) / a;
+
+
+
+
+
+
+
+
+
4668 for (i=0; i < pixel_count; ++i) {
+
+
+
+
+
+
+
+
+
+
4678 #define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+
+
4680 static int stbi__parse_png_file(stbi__png *z,
int scan,
int req_comp)
+
+
4682 stbi_uc palette[1024], pal_img_n=0;
+
+
4684 stbi__uint16 tc16[3];
+
4685 stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+
4686 int first=1,k,interlace=0, color=0, is_iphone=0;
+
4687 stbi__context *s = z->s;
+
+
+
+
+
+
4693 if (!stbi__check_png_header(s))
return 0;
+
+
4695 if (scan == STBI__SCAN_type)
return 1;
+
+
+
4698 stbi__pngchunk c = stbi__get_chunk_header(s);
+
+
4700 case STBI__PNG_TYPE(
'C',
'g',
'B',
'I'):
+
+
4702 stbi__skip(s, c.length);
+
+
4704 case STBI__PNG_TYPE(
'I',
'H',
'D',
'R'): {
+
+
4706 if (!first)
return stbi__err(
"multiple IHDR",
"Corrupt PNG");
+
+
4708 if (c.length != 13)
return stbi__err(
"bad IHDR len",
"Corrupt PNG");
+
4709 s->img_x = stbi__get32be(s);
if (s->img_x > (1 << 24))
return stbi__err(
"too large",
"Very large image (corrupt?)");
+
4710 s->img_y = stbi__get32be(s);
if (s->img_y > (1 << 24))
return stbi__err(
"too large",
"Very large image (corrupt?)");
+
4711 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");
+
4712 color = stbi__get8(s);
if (color > 6)
return stbi__err(
"bad ctype",
"Corrupt PNG");
+
4713 if (color == 3 && z->depth == 16)
return stbi__err(
"bad ctype",
"Corrupt PNG");
+
4714 if (color == 3) pal_img_n = 3;
else if (color & 1)
return stbi__err(
"bad ctype",
"Corrupt PNG");
+
4715 comp = stbi__get8(s);
if (comp)
return stbi__err(
"bad comp method",
"Corrupt PNG");
+
4716 filter= stbi__get8(s);
if (filter)
return stbi__err(
"bad filter method",
"Corrupt PNG");
+
4717 interlace = stbi__get8(s);
if (interlace>1)
return stbi__err(
"bad interlace method",
"Corrupt PNG");
+
4718 if (!s->img_x || !s->img_y)
return stbi__err(
"0-pixel image",
"Corrupt PNG");
+
+
4720 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+
4721 if ((1 << 30) / s->img_x / s->img_n < s->img_y)
return stbi__err(
"too large",
"Image too large to decode");
+
4722 if (scan == STBI__SCAN_header)
return 1;
+
+
+
+
+
4727 if ((1 << 30) / s->img_x / 4 < s->img_y)
return stbi__err(
"too large",
"Corrupt PNG");
+
+
+
+
+
+
4733 case STBI__PNG_TYPE(
'P',
'L',
'T',
'E'): {
+
4734 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
+
4735 if (c.length > 256*3)
return stbi__err(
"invalid PLTE",
"Corrupt PNG");
+
4736 pal_len = c.length / 3;
+
4737 if (pal_len * 3 != c.length)
return stbi__err(
"invalid PLTE",
"Corrupt PNG");
+
4738 for (i=0; i < pal_len; ++i) {
+
4739 palette[i*4+0] = stbi__get8(s);
+
4740 palette[i*4+1] = stbi__get8(s);
+
4741 palette[i*4+2] = stbi__get8(s);
+
4742 palette[i*4+3] = 255;
+
+
+
+
+
4747 case STBI__PNG_TYPE(
't',
'R',
'N',
'S'): {
+
4748 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
+
4749 if (z->idata)
return stbi__err(
"tRNS after IDAT",
"Corrupt PNG");
+
+
4751 if (scan == STBI__SCAN_header) { s->img_n = 4;
return 1; }
+
4752 if (pal_len == 0)
return stbi__err(
"tRNS before PLTE",
"Corrupt PNG");
+
4753 if (c.length > pal_len)
return stbi__err(
"bad tRNS len",
"Corrupt PNG");
+
+
4755 for (i=0; i < c.length; ++i)
+
4756 palette[i*4+3] = stbi__get8(s);
+
+
4758 if (!(s->img_n & 1))
return stbi__err(
"tRNS with alpha",
"Corrupt PNG");
+
4759 if (c.length != (stbi__uint32) s->img_n*2)
return stbi__err(
"bad tRNS len",
"Corrupt PNG");
+
+
4761 if (z->depth == 16) {
+
4762 for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s);
+
+
4764 for (k = 0; k < s->img_n; ++k) tc[k] = (
stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth];
+
+
+
+
+
+
4770 case STBI__PNG_TYPE(
'I',
'D',
'A',
'T'): {
+
4771 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
+
4772 if (pal_img_n && !pal_len)
return stbi__err(
"no PLTE",
"Corrupt PNG");
+
4773 if (scan == STBI__SCAN_header) { s->img_n = pal_img_n;
return 1; }
+
4774 if ((
int)(ioff + c.length) < (
int)ioff)
return 0;
+
4775 if (ioff + c.length > idata_limit) {
+
4776 stbi__uint32 idata_limit_old = idata_limit;
+
+
4778 if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+
4779 while (ioff + c.length > idata_limit)
+
+
4781 STBI_NOTUSED(idata_limit_old);
+
4782 p = (
stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit);
if (p == NULL)
return stbi__err(
"outofmem",
"Out of memory");
+
+
+
4785 if (!stbi__getn(s, z->idata+ioff,c.length))
return stbi__err(
"outofdata",
"Corrupt PNG");
+
+
+
+
+
4790 case STBI__PNG_TYPE(
'I',
'E',
'N',
'D'): {
+
4791 stbi__uint32 raw_len, bpl;
+
4792 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
+
4793 if (scan != STBI__SCAN_load)
return 1;
+
4794 if (z->idata == NULL)
return stbi__err(
"no IDAT",
"Corrupt PNG");
+
+
4796 bpl = (s->img_x * z->depth + 7) / 8;
+
4797 raw_len = bpl * s->img_y * s->img_n + s->img_y ;
+
+
4799 if (z->expanded == NULL)
return 0;
+
4800 STBI_FREE(z->idata); z->idata = NULL;
+
4801 if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+
4802 s->img_out_n = s->img_n+1;
+
+
4804 s->img_out_n = s->img_n;
+
4805 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace))
return 0;
+
+
4807 if (z->depth == 16) {
+
4808 if (!stbi__compute_transparency16(z, tc16, s->img_out_n))
return 0;
+
+
4810 if (!stbi__compute_transparency(z, tc, s->img_out_n))
return 0;
+
+
+
4813 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+
+
+
+
4817 s->img_n = pal_img_n;
+
4818 s->img_out_n = pal_img_n;
+
4819 if (req_comp >= 3) s->img_out_n = req_comp;
+
4820 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+
+
4822 }
else if (has_trans) {
+
+
+
+
4826 STBI_FREE(z->expanded); z->expanded = NULL;
+
+
+
+
+
+
4832 if (first)
return stbi__err(
"first not IHDR",
"Corrupt PNG");
+
4833 if ((c.type & (1 << 29)) == 0) {
+
4834 #ifndef STBI_NO_FAILURE_STRINGS
+
+
4836 static char invalid_chunk[] =
"XXXX PNG chunk not known";
+
4837 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+
4838 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+
4839 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
+
4840 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
+
+
4842 return stbi__err(invalid_chunk,
"PNG not supported: unknown PNG chunk type");
+
+
4844 stbi__skip(s, c.length);
+
+
+
+
+
+
+
+
4852 static void *stbi__do_png(stbi__png *p,
int *x,
int *y,
int *n,
int req_comp, stbi__result_info *ri)
+
+
+
4855 if (req_comp < 0 || req_comp > 4)
return stbi__errpuc(
"bad req_comp",
"Internal error");
+
4856 if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+
+
4858 ri->bits_per_channel = 8;
+
+
4860 ri->bits_per_channel = p->depth;
+
+
+
4863 if (req_comp && req_comp != p->s->img_out_n) {
+
4864 if (ri->bits_per_channel == 8)
+
4865 result = stbi__convert_format((
unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+
+
4867 result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+
4868 p->s->img_out_n = req_comp;
+
4869 if (result == NULL)
return result;
+
+
+
+
4873 if (n) *n = p->s->img_n;
+
+
4875 STBI_FREE(p->out); p->out = NULL;
+
4876 STBI_FREE(p->expanded); p->expanded = NULL;
+
4877 STBI_FREE(p->idata); p->idata = NULL;
+
+
+
+
+
4882 static void *stbi__png_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
+
4886 return stbi__do_png(&p, x,y,comp,req_comp, ri);
+
+
+
4889 static int stbi__png_test(stbi__context *s)
+
+
+
4892 r = stbi__check_png_header(s);
+
+
+
+
+
4897 static int stbi__png_info_raw(stbi__png *p,
int *x,
int *y,
int *comp)
+
+
4899 if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+
4900 stbi__rewind( p->s );
+
+
+
4903 if (x) *x = p->s->img_x;
+
4904 if (y) *y = p->s->img_y;
+
4905 if (comp) *comp = p->s->img_n;
+
+
+
+
4909 static int stbi__png_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
+
+
4913 return stbi__png_info_raw(&p, x, y, comp);
+
+
+
+
+
+
+
4920 static int stbi__bmp_test_raw(stbi__context *s)
+
+
+
+
4924 if (stbi__get8(s) !=
'B')
return 0;
+
4925 if (stbi__get8(s) !=
'M')
return 0;
+
+
+
+
+
4930 sz = stbi__get32le(s);
+
4931 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+
+
+
+
4935 static int stbi__bmp_test(stbi__context *s)
+
+
4937 int r = stbi__bmp_test_raw(s);
+
+
+
+
+
+
+
4944 static int stbi__high_bit(
unsigned int z)
+
+
+
4947 if (z == 0)
return -1;
+
4948 if (z >= 0x10000) n += 16, z >>= 16;
+
4949 if (z >= 0x00100) n += 8, z >>= 8;
+
4950 if (z >= 0x00010) n += 4, z >>= 4;
+
4951 if (z >= 0x00004) n += 2, z >>= 2;
+
4952 if (z >= 0x00002) n += 1, z >>= 1;
+
+
+
+
4956 static int stbi__bitcount(
unsigned int a)
+
+
4958 a = (a & 0x55555555) + ((a >> 1) & 0x55555555);
+
4959 a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
+
4960 a = (a + (a >> 4)) & 0x0f0f0f0f;
+
+
4962 a = (a + (a >> 16));
+
+
+
+
4966 static int stbi__shiftsigned(
int v,
int shift,
int bits)
+
+
+
+
+
4971 if (shift < 0) v <<= -shift;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
4985 int bpp, offset, hsz;
+
4986 unsigned int mr,mg,mb,ma, all_a;
+
+
+
4989 static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+
+
+
4992 if (stbi__get8(s) !=
'B' || stbi__get8(s) !=
'M')
return stbi__errpuc(
"not BMP",
"Corrupt BMP");
+
+
+
+
4996 info->offset = stbi__get32le(s);
+
4997 info->hsz = hsz = stbi__get32le(s);
+
4998 info->mr = info->mg = info->mb = info->ma = 0;
+
+
5000 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124)
return stbi__errpuc(
"unknown BMP",
"BMP type not supported: unknown");
+
+
5002 s->img_x = stbi__get16le(s);
+
5003 s->img_y = stbi__get16le(s);
+
+
5005 s->img_x = stbi__get32le(s);
+
5006 s->img_y = stbi__get32le(s);
+
+
5008 if (stbi__get16le(s) != 1)
return stbi__errpuc(
"bad BMP",
"bad BMP");
+
5009 info->bpp = stbi__get16le(s);
+
5010 if (info->bpp == 1)
return stbi__errpuc(
"monochrome",
"BMP type not supported: 1-bit");
+
+
5012 int compress = stbi__get32le(s);
+
5013 if (compress == 1 || compress == 2)
return stbi__errpuc(
"BMP RLE",
"BMP type not supported: RLE");
+
+
+
+
+
+
5019 if (hsz == 40 || hsz == 56) {
+
+
+
+
+
+
+
5026 if (info->bpp == 16 || info->bpp == 32) {
+
5027 if (compress == 0) {
+
5028 if (info->bpp == 32) {
+
5029 info->mr = 0xffu << 16;
+
5030 info->mg = 0xffu << 8;
+
5031 info->mb = 0xffu << 0;
+
5032 info->ma = 0xffu << 24;
+
+
+
5035 info->mr = 31u << 10;
+
5036 info->mg = 31u << 5;
+
5037 info->mb = 31u << 0;
+
+
5039 }
else if (compress == 3) {
+
5040 info->mr = stbi__get32le(s);
+
5041 info->mg = stbi__get32le(s);
+
5042 info->mb = stbi__get32le(s);
+
+
5044 if (info->mr == info->mg && info->mg == info->mb) {
+
+
5046 return stbi__errpuc(
"bad BMP",
"bad BMP");
+
+
+
5049 return stbi__errpuc(
"bad BMP",
"bad BMP");
+
+
+
+
5053 if (hsz != 108 && hsz != 124)
+
5054 return stbi__errpuc(
"bad BMP",
"bad BMP");
+
5055 info->mr = stbi__get32le(s);
+
5056 info->mg = stbi__get32le(s);
+
5057 info->mb = stbi__get32le(s);
+
5058 info->ma = stbi__get32le(s);
+
+
5060 for (i=0; i < 12; ++i)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
5074 static void *stbi__bmp_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
5077 unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+
+
5079 int psize=0,i,j,width;
+
5080 int flip_vertically, pad, target;
+
5081 stbi__bmp_data info;
+
+
+
+
5085 if (stbi__bmp_parse_header(s, &info) == NULL)
+
+
+
5088 flip_vertically = ((int) s->img_y) > 0;
+
5089 s->img_y = abs((
int) s->img_y);
+
+
+
+
+
+
+
+
5097 if (info.hsz == 12) {
+
+
5099 psize = (info.offset - 14 - 24) / 3;
+
+
+
5102 psize = (info.offset - 14 - info.hsz) >> 2;
+
+
+
5105 s->img_n = ma ? 4 : 3;
+
5106 if (req_comp && req_comp >= 3)
+
+
+
+
+
+
5112 if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+
5113 return stbi__errpuc(
"too large",
"Corrupt BMP");
+
+
5115 out = (
stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+
5116 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
5117 if (info.bpp < 16) {
+
+
5119 if (psize == 0 || psize > 256) { STBI_FREE(out);
return stbi__errpuc(
"invalid",
"Corrupt BMP"); }
+
5120 for (i=0; i < psize; ++i) {
+
5121 pal[i][2] = stbi__get8(s);
+
5122 pal[i][1] = stbi__get8(s);
+
5123 pal[i][0] = stbi__get8(s);
+
5124 if (info.hsz != 12) stbi__get8(s);
+
+
+
5127 stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+
5128 if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+
5129 else if (info.bpp == 8) width = s->img_x;
+
5130 else { STBI_FREE(out);
return stbi__errpuc(
"bad bpp",
"Corrupt BMP"); }
+
+
5132 for (j=0; j < (int) s->img_y; ++j) {
+
5133 for (i=0; i < (int) s->img_x; i += 2) {
+
5134 int v=stbi__get8(s),v2=0;
+
5135 if (info.bpp == 4) {
+
+
+
+
5139 out[z++] = pal[v][0];
+
5140 out[z++] = pal[v][1];
+
5141 out[z++] = pal[v][2];
+
5142 if (target == 4) out[z++] = 255;
+
5143 if (i+1 == (
int) s->img_x)
break;
+
5144 v = (info.bpp == 8) ? stbi__get8(s) : v2;
+
5145 out[z++] = pal[v][0];
+
5146 out[z++] = pal[v][1];
+
5147 out[z++] = pal[v][2];
+
5148 if (target == 4) out[z++] = 255;
+
+
+
+
+
5153 int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+
+
+
5156 stbi__skip(s, info.offset - 14 - info.hsz);
+
5157 if (info.bpp == 24) width = 3 * s->img_x;
+
5158 else if (info.bpp == 16) width = 2*s->img_x;
+
+
+
5161 if (info.bpp == 24) {
+
+
5163 }
else if (info.bpp == 32) {
+
5164 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+
+
+
+
5168 if (!mr || !mg || !mb) { STBI_FREE(out);
return stbi__errpuc(
"bad masks",
"Corrupt BMP"); }
+
+
5170 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+
5171 gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+
5172 bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+
5173 ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+
+
5175 for (j=0; j < (int) s->img_y; ++j) {
+
+
5177 for (i=0; i < (int) s->img_x; ++i) {
+
+
5179 out[z+2] = stbi__get8(s);
+
5180 out[z+1] = stbi__get8(s);
+
5181 out[z+0] = stbi__get8(s);
+
+
5183 a = (easy == 2 ? stbi__get8(s) : 255);
+
+
5185 if (target == 4) out[z++] = a;
+
+
+
+
5189 for (i=0; i < (int) s->img_x; ++i) {
+
5190 stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+
+
5192 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+
5193 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+
5194 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+
5195 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+
+
5197 if (target == 4) out[z++] = STBI__BYTECAST(a);
+
+
+
+
+
+
+
+
5205 if (target == 4 && all_a == 0)
+
5206 for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+
+
+
5209 if (flip_vertically) {
+
+
5211 for (j=0; j < (int) s->img_y>>1; ++j) {
+
5212 stbi_uc *p1 = out + j *s->img_x*target;
+
5213 stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+
5214 for (i=0; i < (int) s->img_x*target; ++i) {
+
5215 t = p1[i], p1[i] = p2[i], p2[i] = t;
+
+
+
+
+
5220 if (req_comp && req_comp != target) {
+
5221 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+
5222 if (out == NULL)
return out;
+
+
+
+
+
5227 if (comp) *comp = s->img_n;
+
+
+
+
+
+
+
+
+
5236 static int stbi__tga_get_comp(
int bits_per_pixel,
int is_grey,
int* is_rgb16)
+
+
+
5239 if(is_rgb16) *is_rgb16 = 0;
+
5240 switch(bits_per_pixel) {
+
+
+
+
5244 case 15:
if(is_rgb16) *is_rgb16 = 1;
+
+
+
5247 case 32:
return bits_per_pixel/8;
+
+
+
+
+
5252 static int stbi__tga_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
5254 int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+
5255 int sz, tga_colormap_type;
+
+
5257 tga_colormap_type = stbi__get8(s);
+
5258 if( tga_colormap_type > 1 ) {
+
+
+
+
5262 tga_image_type = stbi__get8(s);
+
5263 if ( tga_colormap_type == 1 ) {
+
5264 if (tga_image_type != 1 && tga_image_type != 9) {
+
+
+
+
+
+
5270 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+
+
+
+
+
5275 tga_colormap_bpp = sz;
+
+
5277 if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+
+
+
+
+
5282 tga_colormap_bpp = 0;
+
+
5284 tga_w = stbi__get16le(s);
+
+
+
+
+
5289 tga_h = stbi__get16le(s);
+
+
+
+
+
5294 tga_bits_per_pixel = stbi__get8(s);
+
+
5296 if (tga_colormap_bpp != 0) {
+
5297 if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+
+
+
+
+
+
5303 tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+
+
5305 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+
+
+
+
+
+
+
+
5313 if (comp) *comp = tga_comp;
+
+
+
+
5317 static int stbi__tga_test(stbi__context *s)
+
+
+
5320 int sz, tga_color_type;
+
+
5322 tga_color_type = stbi__get8(s);
+
5323 if ( tga_color_type > 1 )
goto errorEnd;
+
+
5325 if ( tga_color_type == 1 ) {
+
5326 if (sz != 1 && sz != 9)
goto errorEnd;
+
+
+
5329 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) )
goto errorEnd;
+
+
+
5332 if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) )
goto errorEnd;
+
+
+
5335 if ( stbi__get16le(s) < 1 )
goto errorEnd;
+
5336 if ( stbi__get16le(s) < 1 )
goto errorEnd;
+
+
5338 if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) )
goto errorEnd;
+
5339 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) )
goto errorEnd;
+
+
+
+
+
+
+
+
+
+
5349 static void stbi__tga_read_rgb16(stbi__context *s,
stbi_uc* out)
+
+
5351 stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+
5352 stbi__uint16 fiveBitMask = 31;
+
+
5354 int r = (px >> 10) & fiveBitMask;
+
5355 int g = (px >> 5) & fiveBitMask;
+
5356 int b = px & fiveBitMask;
+
+
5358 out[0] = (
stbi_uc)((r * 255)/31);
+
5359 out[1] = (
stbi_uc)((g * 255)/31);
+
5360 out[2] = (
stbi_uc)((b * 255)/31);
+
+
+
+
+
+
+
+
5368 static void *stbi__tga_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
5371 int tga_offset = stbi__get8(s);
+
5372 int tga_indexed = stbi__get8(s);
+
5373 int tga_image_type = stbi__get8(s);
+
+
5375 int tga_palette_start = stbi__get16le(s);
+
5376 int tga_palette_len = stbi__get16le(s);
+
5377 int tga_palette_bits = stbi__get8(s);
+
5378 int tga_x_origin = stbi__get16le(s);
+
5379 int tga_y_origin = stbi__get16le(s);
+
5380 int tga_width = stbi__get16le(s);
+
5381 int tga_height = stbi__get16le(s);
+
5382 int tga_bits_per_pixel = stbi__get8(s);
+
5383 int tga_comp, tga_rgb16=0;
+
5384 int tga_inverted = stbi__get8(s);
+
+
+
5387 unsigned char *tga_data;
+
5388 unsigned char *tga_palette = NULL;
+
+
5390 unsigned char raw_data[4] = {0};
+
+
5392 int RLE_repeating = 0;
+
5393 int read_next_pixel = 1;
+
+
+
+
5397 if ( tga_image_type >= 8 )
+
+
5399 tga_image_type -= 8;
+
+
+
5402 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+
+
5405 if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+
5406 else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+
+
5409 return stbi__errpuc(
"bad format",
"Can't find out TGA pixelformat");
+
+
+
+
+
5414 if (comp) *comp = tga_comp;
+
+
5416 if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+
5417 return stbi__errpuc(
"too large",
"Corrupt TGA");
+
+
5419 tga_data = (
unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+
5420 if (!tga_data)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
+
5423 stbi__skip(s, tga_offset );
+
+
5425 if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+
5426 for (i=0; i < tga_height; ++i) {
+
5427 int row = tga_inverted ? tga_height -i - 1 : i;
+
5428 stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+
5429 stbi__getn(s, tga_row, tga_width * tga_comp);
+
+
+
+
+
+
+
5436 stbi__skip(s, tga_palette_start );
+
+
5438 tga_palette = (
unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+
+
5440 STBI_FREE(tga_data);
+
5441 return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
+
5444 stbi_uc *pal_entry = tga_palette;
+
+
5446 for (i=0; i < tga_palette_len; ++i) {
+
5447 stbi__tga_read_rgb16(s, pal_entry);
+
5448 pal_entry += tga_comp;
+
+
5450 }
else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+
5451 STBI_FREE(tga_data);
+
5452 STBI_FREE(tga_palette);
+
5453 return stbi__errpuc(
"bad palette",
"Corrupt TGA");
+
+
+
+
5457 for (i=0; i < tga_width * tga_height; ++i)
+
+
+
+
+
5462 if ( RLE_count == 0 )
+
+
+
5465 int RLE_cmd = stbi__get8(s);
+
5466 RLE_count = 1 + (RLE_cmd & 127);
+
5467 RLE_repeating = RLE_cmd >> 7;
+
5468 read_next_pixel = 1;
+
5469 }
else if ( !RLE_repeating )
+
+
5471 read_next_pixel = 1;
+
+
+
+
5475 read_next_pixel = 1;
+
+
+
5478 if ( read_next_pixel )
+
+
+
+
+
+
5484 int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+
5485 if ( pal_idx >= tga_palette_len ) {
+
+
+
+
5489 pal_idx *= tga_comp;
+
5490 for (j = 0; j < tga_comp; ++j) {
+
5491 raw_data[j] = tga_palette[pal_idx+j];
+
+
5493 }
else if(tga_rgb16) {
+
+
5495 stbi__tga_read_rgb16(s, raw_data);
+
+
+
5498 for (j = 0; j < tga_comp; ++j) {
+
5499 raw_data[j] = stbi__get8(s);
+
+
+
+
5503 read_next_pixel = 0;
+
+
+
+
5507 for (j = 0; j < tga_comp; ++j)
+
5508 tga_data[i*tga_comp+j] = raw_data[j];
+
+
+
+
+
+
+
+
5516 for (j = 0; j*2 < tga_height; ++j)
+
+
5518 int index1 = j * tga_width * tga_comp;
+
5519 int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+
5520 for (i = tga_width * tga_comp; i > 0; --i)
+
+
5522 unsigned char temp = tga_data[index1];
+
5523 tga_data[index1] = tga_data[index2];
+
5524 tga_data[index2] = temp;
+
+
+
+
+
+
+
5531 if ( tga_palette != NULL )
+
+
5533 STBI_FREE( tga_palette );
+
+
+
+
+
5538 if (tga_comp >= 3 && !tga_rgb16)
+
+
5540 unsigned char* tga_pixel = tga_data;
+
5541 for (i=0; i < tga_width * tga_height; ++i)
+
+
5543 unsigned char temp = tga_pixel[0];
+
5544 tga_pixel[0] = tga_pixel[2];
+
5545 tga_pixel[2] = temp;
+
5546 tga_pixel += tga_comp;
+
+
+
+
+
5551 if (req_comp && req_comp != tga_comp)
+
5552 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+
+
+
5556 tga_palette_start = tga_palette_len = tga_palette_bits =
+
5557 tga_x_origin = tga_y_origin = 0;
+
+
+
+
+
+
+
+
+
+
5567 static int stbi__psd_test(stbi__context *s)
+
+
5569 int r = (stbi__get32be(s) == 0x38425053);
+
+
+
+
+
5574 static int stbi__psd_decode_rle(stbi__context *s,
stbi_uc *p,
int pixelCount)
+
+
5576 int count, nleft, len;
+
+
+
5579 while ((nleft = pixelCount - count) > 0) {
+
5580 len = stbi__get8(s);
+
+
+
5583 }
else if (len < 128) {
+
+
+
5586 if (len > nleft)
return 0;
+
+
+
+
+
+
+
5593 }
else if (len > 128) {
+
+
+
+
+
5598 if (len > nleft)
return 0;
+
5599 val = stbi__get8(s);
+
+
+
+
+
+
+
+
+
+
+
+
+
5612 static void *stbi__psd_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri,
int bpc)
+
+
+
5615 int channelCount, compression;
+
+
+
+
+
+
+
+
5623 if (stbi__get32be(s) != 0x38425053)
+
5624 return stbi__errpuc(
"not PSD",
"Corrupt PSD image");
+
+
+
5627 if (stbi__get16be(s) != 1)
+
5628 return stbi__errpuc(
"wrong version",
"Unsupported version of PSD image");
+
+
+
+
+
+
5634 channelCount = stbi__get16be(s);
+
5635 if (channelCount < 0 || channelCount > 16)
+
5636 return stbi__errpuc(
"wrong channel count",
"Unsupported number of channels in PSD image");
+
+
+
5639 h = stbi__get32be(s);
+
5640 w = stbi__get32be(s);
+
+
+
5643 bitdepth = stbi__get16be(s);
+
5644 if (bitdepth != 8 && bitdepth != 16)
+
5645 return stbi__errpuc(
"unsupported bit depth",
"PSD bit depth is not 8 or 16 bit");
+
+
+
+
+
+
+
+
+
+
+
+
5657 if (stbi__get16be(s) != 3)
+
5658 return stbi__errpuc(
"wrong color format",
"PSD is not in RGB color format");
+
+
+
5661 stbi__skip(s,stbi__get32be(s) );
+
+
+
5664 stbi__skip(s, stbi__get32be(s) );
+
+
+
5667 stbi__skip(s, stbi__get32be(s) );
+
+
+
+
+
+
5673 compression = stbi__get16be(s);
+
5674 if (compression > 1)
+
5675 return stbi__errpuc(
"bad compression",
"PSD has an unknown compression format");
+
+
+
5678 if (!stbi__mad3sizes_valid(4, w, h, 0))
+
5679 return stbi__errpuc(
"too large",
"Corrupt PSD");
+
+
+
+
5683 if (!compression && bitdepth == 16 && bpc == 16) {
+
5684 out = (
stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+
5685 ri->bits_per_channel = 16;
+
+
5687 out = (
stbi_uc *) stbi__malloc(4 * w*h);
+
+
5689 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
5707 stbi__skip(s, h * channelCount * 2 );
+
+
+
5710 for (channel = 0; channel < 4; channel++) {
+
+
+
+
5714 if (channel >= channelCount) {
+
+
5716 for (i = 0; i < pixelCount; i++, p += 4)
+
5717 *p = (channel == 3 ? 255 : 0);
+
+
+
5720 if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+
+
5722 return stbi__errpuc(
"corrupt",
"bad RLE data");
+
+
+
+
+
+
+
+
+
+
5732 for (channel = 0; channel < 4; channel++) {
+
5733 if (channel >= channelCount) {
+
+
5735 if (bitdepth == 16 && bpc == 16) {
+
5736 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+
5737 stbi__uint16 val = channel == 3 ? 65535 : 0;
+
5738 for (i = 0; i < pixelCount; i++, q += 4)
+
+
+
+
5742 stbi_uc val = channel == 3 ? 255 : 0;
+
5743 for (i = 0; i < pixelCount; i++, p += 4)
+
+
+
+
5747 if (ri->bits_per_channel == 16) {
+
5748 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+
5749 for (i = 0; i < pixelCount; i++, q += 4)
+
5750 *q = (stbi__uint16) stbi__get16be(s);
+
+
+
5753 if (bitdepth == 16) {
+
5754 for (i = 0; i < pixelCount; i++, p += 4)
+
5755 *p = (
stbi_uc) (stbi__get16be(s) >> 8);
+
+
5757 for (i = 0; i < pixelCount; i++, p += 4)
+
+
+
+
+
+
+
+
+
5766 if (channelCount >= 4) {
+
5767 if (ri->bits_per_channel == 16) {
+
5768 for (i=0; i < w*h; ++i) {
+
5769 stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+
5770 if (pixel[3] != 0 && pixel[3] != 65535) {
+
5771 float a = pixel[3] / 65535.0f;
+
5772 float ra = 1.0f / a;
+
5773 float inv_a = 65535.0f * (1 - ra);
+
5774 pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+
5775 pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+
5776 pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+
+
+
+
5780 for (i=0; i < w*h; ++i) {
+
5781 unsigned char *pixel = out + 4*i;
+
5782 if (pixel[3] != 0 && pixel[3] != 255) {
+
5783 float a = pixel[3] / 255.0f;
+
5784 float ra = 1.0f / a;
+
5785 float inv_a = 255.0f * (1 - ra);
+
5786 pixel[0] = (
unsigned char) (pixel[0]*ra + inv_a);
+
5787 pixel[1] = (
unsigned char) (pixel[1]*ra + inv_a);
+
5788 pixel[2] = (
unsigned char) (pixel[2]*ra + inv_a);
+
+
+
+
+
+
+
5795 if (req_comp && req_comp != 4) {
+
5796 if (ri->bits_per_channel == 16)
+
5797 out = (
stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+
+
5799 out = stbi__convert_format(out, 4, req_comp, w, h);
+
5800 if (out == NULL)
return out;
+
+
+
5803 if (comp) *comp = 4;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
5819 static int stbi__pic_is4(stbi__context *s,
const char *str)
+
+
+
+
5823 if (stbi__get8(s) != (
stbi_uc)str[i])
+
+
+
+
+
+
5829 static int stbi__pic_test_core(stbi__context *s)
+
+
+
+
5833 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34"))
+
+
+
+
+
+
5839 if (!stbi__pic_is4(s,
"PICT"))
+
+
+
+
+
+
+
+
+
+
+
5850 static stbi_uc *stbi__readval(stbi__context *s,
int channel,
stbi_uc *dest)
+
+
+
+
5854 for (i=0; i<4; ++i, mask>>=1) {
+
5855 if (channel & mask) {
+
5856 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"PIC file too short");
+
5857 dest[i]=stbi__get8(s);
+
+
+
+
+
+
+
5864 static void stbi__copyval(
int channel,
stbi_uc *dest,
const stbi_uc *src)
+
+
+
+
5868 for (i=0;i<4; ++i, mask>>=1)
+
+
+
+
+
5873 static stbi_uc *stbi__pic_load_core(stbi__context *s,
int width,
int height,
int *comp,
stbi_uc *result)
+
+
5875 int act_comp=0,num_packets=0,y,chained;
+
5876 stbi__pic_packet packets[10];
+
+
+
+
+
5881 stbi__pic_packet *packet;
+
+
5883 if (num_packets==
sizeof(packets)/
sizeof(packets[0]))
+
5884 return stbi__errpuc(
"bad format",
"too many packets");
+
+
5886 packet = &packets[num_packets++];
+
+
5888 chained = stbi__get8(s);
+
5889 packet->size = stbi__get8(s);
+
5890 packet->type = stbi__get8(s);
+
5891 packet->channel = stbi__get8(s);
+
+
5893 act_comp |= packet->channel;
+
+
5895 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (reading packets)");
+
5896 if (packet->size != 8)
return stbi__errpuc(
"bad format",
"packet isn't 8bpp");
+
+
+
5899 *comp = (act_comp & 0x10 ? 4 : 3);
+
+
5901 for(y=0; y<height; ++y) {
+
+
+
5904 for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+
5905 stbi__pic_packet *packet = &packets[packet_idx];
+
5906 stbi_uc *dest = result+y*width*4;
+
+
5908 switch (packet->type) {
+
+
5910 return stbi__errpuc(
"bad format",
"packet has bad compression type");
+
+
+
+
+
5915 for(x=0;x<width;++x, dest+=4)
+
5916 if (!stbi__readval(s,packet->channel,dest))
+
+
+
+
+
+
+
+
+
+
+
+
5928 count=stbi__get8(s);
+
5929 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (pure read count)");
+
+
+
+
+
5934 if (!stbi__readval(s,packet->channel,value))
return 0;
+
+
5936 for(i=0; i<count; ++i,dest+=4)
+
5937 stbi__copyval(packet->channel,dest,value);
+
+
+
+
+
+
+
+
+
5946 int count = stbi__get8(s), i;
+
5947 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (mixed read count)");
+
+
+
+
+
+
5953 count = stbi__get16be(s);
+
+
+
+
5957 return stbi__errpuc(
"bad file",
"scanline overrun");
+
+
5959 if (!stbi__readval(s,packet->channel,value))
+
+
+
5962 for(i=0;i<count;++i, dest += 4)
+
5963 stbi__copyval(packet->channel,dest,value);
+
+
+
5966 if (count>left)
return stbi__errpuc(
"bad file",
"scanline overrun");
+
+
5968 for(i=0;i<count;++i, dest+=4)
+
5969 if (!stbi__readval(s,packet->channel,dest))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
5983 static void *stbi__pic_load(stbi__context *s,
int *px,
int *py,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
5986 int i, x,y, internal_comp;
+
+
+
5989 if (!comp) comp = &internal_comp;
+
+
5991 for (i=0; i<92; ++i)
+
+
+
5994 x = stbi__get16be(s);
+
5995 y = stbi__get16be(s);
+
5996 if (stbi__at_eof(s))
return stbi__errpuc(
"bad file",
"file too short (pic header)");
+
5997 if (!stbi__mad3sizes_valid(x, y, 4, 0))
return stbi__errpuc(
"too large",
"PIC image too large to decode");
+
+
+
+
+
+
+
6004 result = (
stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+
6005 memset(result, 0xff, x*y*4);
+
+
6007 if (!stbi__pic_load_core(s,x,y,comp, result)) {
+
+
+
+
+
+
6013 if (req_comp == 0) req_comp = *comp;
+
6014 result=stbi__convert_format(result,4,req_comp,x,y);
+
+
+
+
+
6019 static int stbi__pic_test(stbi__context *s)
+
+
6021 int r = stbi__pic_test_core(s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
6042 int flags, bgindex, ratio, transparent, eflags, delay;
+
+
+
6045 stbi__gif_lzw codes[4096];
+
+
+
+
6049 int start_x, start_y;
+
+
+
+
+
+
6055 static int stbi__gif_test_raw(stbi__context *s)
+
+
+
6058 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
return 0;
+
+
6060 if (sz !=
'9' && sz !=
'7')
return 0;
+
6061 if (stbi__get8(s) !=
'a')
return 0;
+
+
+
+
6065 static int stbi__gif_test(stbi__context *s)
+
+
6067 int r = stbi__gif_test_raw(s);
+
+
+
+
+
6072 static void stbi__gif_parse_colortable(stbi__context *s,
stbi_uc pal[256][4],
int num_entries,
int transp)
+
+
+
6075 for (i=0; i < num_entries; ++i) {
+
6076 pal[i][2] = stbi__get8(s);
+
6077 pal[i][1] = stbi__get8(s);
+
6078 pal[i][0] = stbi__get8(s);
+
6079 pal[i][3] = transp == i ? 0 : 255;
+
+
+
+
6083 static int stbi__gif_header(stbi__context *s, stbi__gif *g,
int *comp,
int is_info)
+
+
+
6086 if (stbi__get8(s) !=
'G' || stbi__get8(s) !=
'I' || stbi__get8(s) !=
'F' || stbi__get8(s) !=
'8')
+
6087 return stbi__err(
"not GIF",
"Corrupt GIF");
+
+
6089 version = stbi__get8(s);
+
6090 if (version !=
'7' && version !=
'9')
return stbi__err(
"not GIF",
"Corrupt GIF");
+
6091 if (stbi__get8(s) !=
'a')
return stbi__err(
"not GIF",
"Corrupt GIF");
+
+
6093 stbi__g_failure_reason =
"";
+
6094 g->w = stbi__get16le(s);
+
6095 g->h = stbi__get16le(s);
+
6096 g->flags = stbi__get8(s);
+
6097 g->bgindex = stbi__get8(s);
+
6098 g->ratio = stbi__get8(s);
+
6099 g->transparent = -1;
+
+
6101 if (comp != 0) *comp = 4;
+
+
6103 if (is_info)
return 1;
+
+
6105 if (g->flags & 0x80)
+
6106 stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+
+
+
+
6111 static int stbi__gif_info_raw(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6113 stbi__gif* g = (stbi__gif*) stbi__malloc(
sizeof(stbi__gif));
+
6114 if (!stbi__gif_header(s, g, comp, 1)) {
+
+
+
+
+
+
+
+
+
+
+
6125 static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+
+
+
+
+
+
6131 if (g->codes[code].prefix >= 0)
+
6132 stbi__out_gif_code(g, g->codes[code].prefix);
+
+
6134 if (g->cur_y >= g->max_y)
return;
+
+
6136 p = &g->out[g->cur_x + g->cur_y];
+
6137 c = &g->color_table[g->codes[code].suffix * 4];
+
+
+
+
+
+
+
+
+
+
6147 if (g->cur_x >= g->max_x) {
+
6148 g->cur_x = g->start_x;
+
6149 g->cur_y += g->step;
+
+
6151 while (g->cur_y >= g->max_y && g->parse > 0) {
+
6152 g->step = (1 << g->parse) * g->line_size;
+
6153 g->cur_y = g->start_y + (g->step >> 1);
+
+
+
+
+
+
6159 static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+
+
+
6162 stbi__int32 len, init_code;
+
+
6164 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+
+
+
6167 lzw_cs = stbi__get8(s);
+
6168 if (lzw_cs > 12)
return NULL;
+
6169 clear = 1 << lzw_cs;
+
+
6171 codesize = lzw_cs + 1;
+
6172 codemask = (1 << codesize) - 1;
+
+
+
6175 for (init_code = 0; init_code < clear; init_code++) {
+
6176 g->codes[init_code].prefix = -1;
+
6177 g->codes[init_code].first = (
stbi_uc) init_code;
+
6178 g->codes[init_code].suffix = (
stbi_uc) init_code;
+
+
+
+
+
+
+
+
+
6187 if (valid_bits < codesize) {
+
+
6189 len = stbi__get8(s);
+
+
+
+
+
6194 bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+
+
+
6197 stbi__int32 code = bits & codemask;
+
+
6199 valid_bits -= codesize;
+
+
6201 if (code == clear) {
+
6202 codesize = lzw_cs + 1;
+
6203 codemask = (1 << codesize) - 1;
+
+
+
+
6207 }
else if (code == clear + 1) {
+
+
6209 while ((len = stbi__get8(s)) > 0)
+
+
+
6212 }
else if (code <= avail) {
+
6213 if (first)
return stbi__errpuc(
"no clear code",
"Corrupt GIF");
+
+
+
6216 p = &g->codes[avail++];
+
6217 if (avail > 4096)
return stbi__errpuc(
"too many codes",
"Corrupt GIF");
+
6218 p->prefix = (stbi__int16) oldcode;
+
6219 p->first = g->codes[oldcode].first;
+
6220 p->suffix = (code == avail) ? p->first : g->codes[code].first;
+
6221 }
else if (code == avail)
+
6222 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
+
+
6224 stbi__out_gif_code(g, (stbi__uint16) code);
+
+
6226 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+
+
6228 codemask = (1 << codesize) - 1;
+
+
+
+
+
6233 return stbi__errpuc(
"illegal code in raster",
"Corrupt GIF");
+
+
+
+
+
+
6239 static void stbi__fill_gif_background(stbi__gif *g,
int x0,
int y0,
int x1,
int y1)
+
+
+
6242 stbi_uc *c = g->pal[g->bgindex];
+
6243 for (y = y0; y < y1; y += 4 * g->w) {
+
6244 for (x = x0; x < x1; x += 4) {
+
+
+
+
+
+
+
+
+
+
+
6255 static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g,
int *comp,
int req_comp)
+
+
+
+
+
6260 if (g->out == 0 && !stbi__gif_header(s, g, comp,0))
+
+
+
6263 if (!stbi__mad3sizes_valid(g->w, g->h, 4, 0))
+
6264 return stbi__errpuc(
"too large",
"GIF too large");
+
+
+
6267 g->out = (
stbi_uc *) stbi__malloc_mad3(4, g->w, g->h, 0);
+
6268 if (g->out == 0)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
+
6270 switch ((g->eflags & 0x1C) >> 2) {
+
+
6272 stbi__fill_gif_background(g, 0, 0, 4 * g->w, 4 * g->w * g->h);
+
+
+
6275 if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h);
+
6276 g->old_out = prev_out;
+
+
+
6279 if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h);
+
6280 stbi__fill_gif_background(g, g->start_x, g->start_y, g->max_x, g->max_y);
+
+
+
+
6284 for (i = g->start_y; i < g->max_y; i += 4 * g->w)
+
6285 memcpy(&g->out[i + g->start_x], &g->old_out[i + g->start_x], g->max_x - g->start_x);
+
+
+
+
+
+
6291 switch (stbi__get8(s)) {
+
+
+
6294 int prev_trans = -1;
+
6295 stbi__int32 x, y, w, h;
+
+
+
6298 x = stbi__get16le(s);
+
6299 y = stbi__get16le(s);
+
6300 w = stbi__get16le(s);
+
6301 h = stbi__get16le(s);
+
6302 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+
6303 return stbi__errpuc(
"bad Image Descriptor",
"Corrupt GIF");
+
+
6305 g->line_size = g->w * 4;
+
+
6307 g->start_y = y * g->line_size;
+
6308 g->max_x = g->start_x + w * 4;
+
6309 g->max_y = g->start_y + h * g->line_size;
+
6310 g->cur_x = g->start_x;
+
6311 g->cur_y = g->start_y;
+
+
6313 g->lflags = stbi__get8(s);
+
+
6315 if (g->lflags & 0x40) {
+
6316 g->step = 8 * g->line_size;
+
+
+
6319 g->step = g->line_size;
+
+
+
+
6323 if (g->lflags & 0x80) {
+
6324 stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+
6325 g->color_table = (
stbi_uc *) g->lpal;
+
6326 }
else if (g->flags & 0x80) {
+
6327 if (g->transparent >= 0 && (g->eflags & 0x01)) {
+
6328 prev_trans = g->pal[g->transparent][3];
+
6329 g->pal[g->transparent][3] = 0;
+
+
6331 g->color_table = (
stbi_uc *) g->pal;
+
+
6333 return stbi__errpuc(
"missing color table",
"Corrupt GIF");
+
+
6335 o = stbi__process_gif_raster(s, g);
+
6336 if (o == NULL)
return NULL;
+
+
6338 if (prev_trans != -1)
+
6339 g->pal[g->transparent][3] = (
stbi_uc) prev_trans;
+
+
+
+
+
+
+
+
6347 if (stbi__get8(s) == 0xF9) {
+
6348 len = stbi__get8(s);
+
+
6350 g->eflags = stbi__get8(s);
+
6351 g->delay = stbi__get16le(s);
+
6352 g->transparent = stbi__get8(s);
+
+
+
+
+
+
6358 while ((len = stbi__get8(s)) != 0)
+
+
+
+
+
+
+
+
+
6367 return stbi__errpuc(
"unknown code",
"Corrupt GIF");
+
+
+
+
6371 STBI_NOTUSED(req_comp);
+
+
+
6374 static void *stbi__gif_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
6377 stbi__gif* g = (stbi__gif*) stbi__malloc(
sizeof(stbi__gif));
+
6378 memset(g, 0,
sizeof(*g));
+
+
+
6381 u = stbi__gif_load_next(s, g, comp, req_comp);
+
6382 if (u == (
stbi_uc *) s) u = 0;
+
+
+
+
6386 if (req_comp && req_comp != 4)
+
6387 u = stbi__convert_format(u, 4, req_comp, g->w, g->h);
+
+
+
+
+
+
+
+
6395 static int stbi__gif_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6397 return stbi__gif_info_raw(s,x,y,comp);
+
+
+
+
+
+
+
+
6405 static int stbi__hdr_test_core(stbi__context *s,
const char *signature)
+
+
+
6408 for (i=0; signature[i]; ++i)
+
6409 if (stbi__get8(s) != signature[i])
+
+
+
+
+
+
6415 static int stbi__hdr_test(stbi__context* s)
+
+
6417 int r = stbi__hdr_test_core(s,
"#?RADIANCE\n");
+
+
+
6420 r = stbi__hdr_test_core(s,
"#?RGBE\n");
+
+
+
+
+
+
6426 #define STBI__HDR_BUFLEN 1024
+
6427 static char *stbi__hdr_gettoken(stbi__context *z,
char *buffer)
+
+
+
+
+
6432 c = (char) stbi__get8(z);
+
+
6434 while (!stbi__at_eof(z) && c !=
'\n') {
+
+
6436 if (len == STBI__HDR_BUFLEN-1) {
+
+
6438 while (!stbi__at_eof(z) && stbi__get8(z) !=
'\n')
+
+
+
+
6442 c = (char) stbi__get8(z);
+
+
+
+
+
+
+
6449 static void stbi__hdr_convert(
float *output,
stbi_uc *input,
int req_comp)
+
+
6451 if ( input[3] != 0 ) {
+
+
+
6454 f1 = (float) ldexp(1.0f, input[3] - (
int)(128 + 8));
+
+
6456 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+
+
6458 output[0] = input[0] * f1;
+
6459 output[1] = input[1] * f1;
+
6460 output[2] = input[2] * f1;
+
+
6462 if (req_comp == 2) output[1] = 1;
+
6463 if (req_comp == 4) output[3] = 1;
+
+
+
6466 case 4: output[3] = 1;
+
6467 case 3: output[0] = output[1] = output[2] = 0;
+
+
6469 case 2: output[1] = 1;
+
6470 case 1: output[0] = 0;
+
+
+
+
+
+
6476 static float *stbi__hdr_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
6478 char buffer[STBI__HDR_BUFLEN];
+
+
+
+
+
+
+
6485 unsigned char count, value;
+
6486 int i, j, k, c1,c2, z;
+
6487 const char *headerToken;
+
+
+
+
6491 headerToken = stbi__hdr_gettoken(s,buffer);
+
6492 if (strcmp(headerToken,
"#?RADIANCE") != 0 && strcmp(headerToken,
"#?RGBE") != 0)
+
6493 return stbi__errpf(
"not HDR",
"Corrupt HDR image");
+
+
+
+
6497 token = stbi__hdr_gettoken(s,buffer);
+
6498 if (token[0] == 0)
break;
+
6499 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+
+
+
6502 if (!valid)
return stbi__errpf(
"unsupported format",
"Unsupported HDR format");
+
+
+
+
6506 token = stbi__hdr_gettoken(s,buffer);
+
6507 if (strncmp(token,
"-Y ", 3))
return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
+
+
6509 height = (int) strtol(token, &token, 10);
+
6510 while (*token ==
' ') ++token;
+
6511 if (strncmp(token,
"+X ", 3))
return stbi__errpf(
"unsupported data layout",
"Unsupported HDR format");
+
+
6513 width = (int) strtol(token, NULL, 10);
+
+
+
+
+
6518 if (comp) *comp = 3;
+
6519 if (req_comp == 0) req_comp = 3;
+
+
6521 if (!stbi__mad4sizes_valid(width, height, req_comp,
sizeof(
float), 0))
+
6522 return stbi__errpf(
"too large",
"HDR image is too large");
+
+
+
6525 hdr_data = (
float *) stbi__malloc_mad4(width, height, req_comp,
sizeof(
float), 0);
+
+
6527 return stbi__errpf(
"outofmem",
"Out of memory");
+
+
+
+
6531 if ( width < 8 || width >= 32768) {
+
+
6533 for (j=0; j < height; ++j) {
+
6534 for (i=0; i < width; ++i) {
+
+
+
6537 stbi__getn(s, rgbe, 4);
+
6538 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+
+
+
+
+
+
+
6545 for (j = 0; j < height; ++j) {
+
+
+
6548 len = stbi__get8(s);
+
6549 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+
+
+
+
+
+
+
6556 rgbe[3] = (
stbi_uc) stbi__get8(s);
+
6557 stbi__hdr_convert(hdr_data, rgbe, req_comp);
+
+
+
6560 STBI_FREE(scanline);
+
6561 goto main_decode_loop;
+
+
+
6564 len |= stbi__get8(s);
+
6565 if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"invalid decoded scanline length",
"corrupt HDR"); }
+
6566 if (scanline == NULL) {
+
6567 scanline = (
stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+
+
6569 STBI_FREE(hdr_data);
+
6570 return stbi__errpf(
"outofmem",
"Out of memory");
+
+
+
+
6574 for (k = 0; k < 4; ++k) {
+
+
+
6577 while ((nleft = width - i) > 0) {
+
6578 count = stbi__get8(s);
+
+
+
6581 value = stbi__get8(s);
+
+
6583 if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"corrupt",
"bad RLE data in HDR"); }
+
6584 for (z = 0; z < count; ++z)
+
6585 scanline[i++ * 4 + k] = value;
+
+
+
6588 if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline);
return stbi__errpf(
"corrupt",
"bad RLE data in HDR"); }
+
6589 for (z = 0; z < count; ++z)
+
6590 scanline[i++ * 4 + k] = stbi__get8(s);
+
+
+
+
6594 for (i=0; i < width; ++i)
+
6595 stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+
+
+
6598 STBI_FREE(scanline);
+
+
+
+
+
+
6604 static int stbi__hdr_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6606 char buffer[STBI__HDR_BUFLEN];
+
+
+
+
+
+
+
6613 if (!comp) comp = &dummy;
+
+
6615 if (stbi__hdr_test(s) == 0) {
+
+
+
+
+
+
6621 token = stbi__hdr_gettoken(s,buffer);
+
6622 if (token[0] == 0)
break;
+
6623 if (strcmp(token,
"FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+
+
+
+
+
+
+
6630 token = stbi__hdr_gettoken(s,buffer);
+
6631 if (strncmp(token,
"-Y ", 3)) {
+
+
+
+
+
6636 *y = (int) strtol(token, &token, 10);
+
6637 while (*token ==
' ') ++token;
+
6638 if (strncmp(token,
"+X ", 3)) {
+
+
+
+
+
6643 *x = (int) strtol(token, NULL, 10);
+
+
+
+
6647 #endif // STBI_NO_HDR
+
+
+
6650 static int stbi__bmp_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
+
6653 stbi__bmp_data info;
+
+
+
6656 p = stbi__bmp_parse_header(s, &info);
+
+
+
+
6660 if (x) *x = s->img_x;
+
6661 if (y) *y = s->img_y;
+
6662 if (comp) *comp = info.ma ? 4 : 3;
+
+
+
+
+
+
6668 static int stbi__psd_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6670 int channelCount, dummy;
+
+
+
6673 if (!comp) comp = &dummy;
+
6674 if (stbi__get32be(s) != 0x38425053) {
+
+
+
+
6678 if (stbi__get16be(s) != 1) {
+
+
+
+
+
6683 channelCount = stbi__get16be(s);
+
6684 if (channelCount < 0 || channelCount > 16) {
+
+
+
+
6688 *y = stbi__get32be(s);
+
6689 *x = stbi__get32be(s);
+
6690 if (stbi__get16be(s) != 8) {
+
+
+
+
6694 if (stbi__get16be(s) != 3) {
+
+
+
+
+
+
+
+
+
+
6704 static int stbi__pic_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6706 int act_comp=0,num_packets=0,chained,dummy;
+
6707 stbi__pic_packet packets[10];
+
+
+
+
6711 if (!comp) comp = &dummy;
+
+
6713 if (!stbi__pic_is4(s,
"\x53\x80\xF6\x34")) {
+
+
+
+
+
+
+
6720 *x = stbi__get16be(s);
+
6721 *y = stbi__get16be(s);
+
6722 if (stbi__at_eof(s)) {
+
+
+
+
6726 if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+
+
+
+
+
+
+
+
6734 stbi__pic_packet *packet;
+
+
6736 if (num_packets==
sizeof(packets)/
sizeof(packets[0]))
+
+
+
6739 packet = &packets[num_packets++];
+
6740 chained = stbi__get8(s);
+
6741 packet->size = stbi__get8(s);
+
6742 packet->type = stbi__get8(s);
+
6743 packet->channel = stbi__get8(s);
+
6744 act_comp |= packet->channel;
+
+
6746 if (stbi__at_eof(s)) {
+
+
+
+
6750 if (packet->size != 8) {
+
+
+
+
+
+
6756 *comp = (act_comp & 0x10 ? 4 : 3);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
6776 static int stbi__pnm_test(stbi__context *s)
+
+
+
6779 p = (char) stbi__get8(s);
+
6780 t = (char) stbi__get8(s);
+
6781 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
+
+
+
+
+
+
+
6788 static void *stbi__pnm_load(stbi__context *s,
int *x,
int *y,
int *comp,
int req_comp, stbi__result_info *ri)
+
+
+
+
+
6793 if (!stbi__pnm_info(s, (
int *)&s->img_x, (
int *)&s->img_y, (
int *)&s->img_n))
+
+
+
+
+
6798 if (comp) *comp = s->img_n;
+
+
6800 if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
+
6801 return stbi__errpuc(
"too large",
"PNM too large");
+
+
6803 out = (
stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
+
6804 if (!out)
return stbi__errpuc(
"outofmem",
"Out of memory");
+
6805 stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
+
+
6807 if (req_comp && req_comp != s->img_n) {
+
6808 out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+
6809 if (out == NULL)
return out;
+
+
+
+
+
6814 static int stbi__pnm_isspace(
char c)
+
+
6816 return c ==
' ' || c ==
'\t' || c ==
'\n' || c ==
'\v' || c ==
'\f' || c ==
'\r';
+
+
+
6819 static void stbi__pnm_skip_whitespace(stbi__context *s,
char *c)
+
+
+
6822 while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+
6823 *c = (char) stbi__get8(s);
+
+
6825 if (stbi__at_eof(s) || *c !=
'#')
+
+
+
6828 while (!stbi__at_eof(s) && *c !=
'\n' && *c !=
'\r' )
+
6829 *c = (
char) stbi__get8(s);
+
+
+
+
6833 static int stbi__pnm_isdigit(
char c)
+
+
6835 return c >=
'0' && c <=
'9';
+
+
+
6838 static int stbi__pnm_getinteger(stbi__context *s,
char *c)
+
+
+
+
6842 while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+
6843 value = value*10 + (*c -
'0');
+
6844 *c = (char) stbi__get8(s);
+
+
+
+
+
+
6850 static int stbi__pnm_info(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
+
+
+
+
+
6857 if (!comp) comp = &dummy;
+
+
+
+
+
6862 p = (char) stbi__get8(s);
+
6863 t = (char) stbi__get8(s);
+
6864 if (p !=
'P' || (t !=
'5' && t !=
'6')) {
+
+
+
+
+
6869 *comp = (t ==
'6') ? 3 : 1;
+
+
6871 c = (char) stbi__get8(s);
+
6872 stbi__pnm_skip_whitespace(s, &c);
+
+
6874 *x = stbi__pnm_getinteger(s, &c);
+
6875 stbi__pnm_skip_whitespace(s, &c);
+
+
6877 *y = stbi__pnm_getinteger(s, &c);
+
6878 stbi__pnm_skip_whitespace(s, &c);
+
+
6880 maxv = stbi__pnm_getinteger(s, &c);
+
+
+
6883 return stbi__err(
"max value > 255",
"PPM image not 8-bit");
+
+
+
+
+
+
6889 static int stbi__info_main(stbi__context *s,
int *x,
int *y,
int *comp)
+
+
6891 #ifndef STBI_NO_JPEG
+
6892 if (stbi__jpeg_info(s, x, y, comp))
return 1;
+
+
+
+
6896 if (stbi__png_info(s, x, y, comp))
return 1;
+
+
+
+
6900 if (stbi__gif_info(s, x, y, comp))
return 1;
+
+
+
+
6904 if (stbi__bmp_info(s, x, y, comp))
return 1;
+
+
+
+
6908 if (stbi__psd_info(s, x, y, comp))
return 1;
+
+
+
+
6912 if (stbi__pic_info(s, x, y, comp))
return 1;
+
+
+
+
6916 if (stbi__pnm_info(s, x, y, comp))
return 1;
+
+
+
+
6920 if (stbi__hdr_info(s, x, y, comp))
return 1;
+
+
+
+
+
6925 if (stbi__tga_info(s, x, y, comp))
+
+
+
6928 return stbi__err(
"unknown image type",
"Image not of any known type, or corrupt");
+
+
+
6931 #ifndef STBI_NO_STDIO
+
+
+
6934 FILE *f = stbi__fopen(filename,
"rb");
+
+
6936 if (!f)
return stbi__err(
"can't fopen",
"Unable to open file");
+
+
+
+
+
+
+
+
+
+
6946 long pos = ftell(f);
+
6947 stbi__start_file(&s, f);
+
6948 r = stbi__info_main(&s,x,y,comp);
+
6949 fseek(f,pos,SEEK_SET);
+
+
+
6952 #endif // !STBI_NO_STDIO
+
+
+
+
+
6957 stbi__start_mem(&s,buffer,len);
+
6958 return stbi__info_main(&s,x,y,comp);
+
+
+
+
+
+
+
6965 return stbi__info_main(&s,x,y,comp);
+
+
+
6968 #endif // STB_IMAGE_IMPLEMENTATION
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#define STBIDEF
Definition: stb_image.h:330
+
+
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+
Definition: stb_image.h:315
+
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+
STBIDEF const char * stbi_failure_reason(void)
+
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)
+
STBIDEF void stbi_hdr_to_ldr_scale(float scale)
+
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+
unsigned short stbi_us
Definition: stb_image.h:321
+
STBIDEF float * stbi_loadf(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels)
+
STBIDEF stbi_us * stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma)
+
Definition: stb_image.h:316
+
STBIDEF stbi_us * stbi_load_16(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels)
+
Definition: stb_image.h:342
+
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)
+
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)
+
Definition: stb_image.h:317
+
STBIDEF float * stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp)
+
Definition: stb_image.h:314
+
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)
+
STBIDEF int stbi_is_hdr(char const *filename)
+
unsigned char stbi_uc
Definition: stb_image.h:320
+
STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+
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)
+
STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+
STBIDEF char * stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen)
+
Definition: stb_image.h:312
+
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)
+
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)
+
+
+
+ 
+
+
+ 