summaryrefslogtreecommitdiff
path: root/externals/stb/stb_image.h
diff options
context:
space:
mode:
Diffstat (limited to 'externals/stb/stb_image.h')
-rw-r--r--externals/stb/stb_image.h7218
1 files changed, 0 insertions, 7218 deletions
diff --git a/externals/stb/stb_image.h b/externals/stb/stb_image.h
index 7e8d1c124..f0dfad1c6 100644
--- a/externals/stb/stb_image.h
+++ b/externals/stb/stb_image.h
@@ -545,7224 +545,6 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const ch
545//// end header file ///////////////////////////////////////////////////// 545//// end header file /////////////////////////////////////////////////////
546#endif // STBI_INCLUDE_STB_IMAGE_H 546#endif // STBI_INCLUDE_STB_IMAGE_H
547 547
548#ifdef STB_IMAGE_IMPLEMENTATION
549
550#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
551 || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
552 || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
553 || defined(STBI_ONLY_ZLIB)
554 #ifndef STBI_ONLY_JPEG
555 #define STBI_NO_JPEG
556 #endif
557 #ifndef STBI_ONLY_PNG
558 #define STBI_NO_PNG
559 #endif
560 #ifndef STBI_ONLY_BMP
561 #define STBI_NO_BMP
562 #endif
563 #ifndef STBI_ONLY_PSD
564 #define STBI_NO_PSD
565 #endif
566 #ifndef STBI_ONLY_TGA
567 #define STBI_NO_TGA
568 #endif
569 #ifndef STBI_ONLY_GIF
570 #define STBI_NO_GIF
571 #endif
572 #ifndef STBI_ONLY_HDR
573 #define STBI_NO_HDR
574 #endif
575 #ifndef STBI_ONLY_PIC
576 #define STBI_NO_PIC
577 #endif
578 #ifndef STBI_ONLY_PNM
579 #define STBI_NO_PNM
580 #endif
581#endif
582
583#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
584#define STBI_NO_ZLIB
585#endif
586
587
588#include <stdarg.h>
589#include <stddef.h> // ptrdiff_t on osx
590#include <stdlib.h>
591#include <string.h>
592#include <limits.h>
593
594#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
595#include <math.h> // ldexp, pow
596#endif
597
598#ifndef STBI_NO_STDIO
599#include <stdio.h>
600#endif
601
602#ifndef STBI_ASSERT
603#include <assert.h>
604#define STBI_ASSERT(x) assert(x)
605#endif
606
607#ifdef __cplusplus
608#define STBI_EXTERN extern "C"
609#else
610#define STBI_EXTERN extern
611#endif
612
613
614#ifndef _MSC_VER
615 #ifdef __cplusplus
616 #define stbi_inline inline
617 #else
618 #define stbi_inline
619 #endif
620#else
621 #define stbi_inline __forceinline
622#endif
623
624#ifndef STBI_NO_THREAD_LOCALS
625 #if defined(__cplusplus) && __cplusplus >= 201103L
626 #define STBI_THREAD_LOCAL thread_local
627 #elif defined(__GNUC__) && __GNUC__ < 5
628 #define STBI_THREAD_LOCAL __thread
629 #elif defined(_MSC_VER)
630 #define STBI_THREAD_LOCAL __declspec(thread)
631 #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
632 #define STBI_THREAD_LOCAL _Thread_local
633 #endif
634
635 #ifndef STBI_THREAD_LOCAL
636 #if defined(__GNUC__)
637 #define STBI_THREAD_LOCAL __thread
638 #endif
639 #endif
640#endif
641
642#if defined(_MSC_VER) || defined(__SYMBIAN32__)
643typedef unsigned short stbi__uint16;
644typedef signed short stbi__int16;
645typedef unsigned int stbi__uint32;
646typedef signed int stbi__int32;
647#else
648#include <stdint.h>
649typedef uint16_t stbi__uint16;
650typedef int16_t stbi__int16;
651typedef uint32_t stbi__uint32;
652typedef int32_t stbi__int32;
653#endif
654
655// should produce compiler error if size is wrong
656typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
657
658#ifdef _MSC_VER
659#define STBI_NOTUSED(v) (void)(v)
660#else
661#define STBI_NOTUSED(v) (void)sizeof(v)
662#endif
663
664#ifdef _MSC_VER
665#define STBI_HAS_LROTL
666#endif
667
668#ifdef STBI_HAS_LROTL
669 #define stbi_lrot(x,y) _lrotl(x,y)
670#else
671 #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))
672#endif
673
674#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
675// ok
676#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
677// ok
678#else
679#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
680#endif
681
682#ifndef STBI_MALLOC
683#define STBI_MALLOC(sz) malloc(sz)
684#define STBI_REALLOC(p,newsz) realloc(p,newsz)
685#define STBI_FREE(p) free(p)
686#endif
687
688#ifndef STBI_REALLOC_SIZED
689#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
690#endif
691
692// x86/x64 detection
693#if defined(__x86_64__) || defined(_M_X64)
694#define STBI__X64_TARGET
695#elif defined(__i386) || defined(_M_IX86)
696#define STBI__X86_TARGET
697#endif
698
699#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
700// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
701// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
702// but previous attempts to provide the SSE2 functions with runtime
703// detection caused numerous issues. The way architecture extensions are
704// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
705// New behavior: if compiled with -msse2, we use SSE2 without any
706// detection; if not, we don't use it at all.
707#define STBI_NO_SIMD
708#endif
709
710#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
711// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
712//
713// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
714// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
715// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
716// simultaneously enabling "-mstackrealign".
717//
718// See https://github.com/nothings/stb/issues/81 for more information.
719//
720// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
721// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
722#define STBI_NO_SIMD
723#endif
724
725#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
726#define STBI_SSE2
727#include <emmintrin.h>
728
729#ifdef _MSC_VER
730
731#if _MSC_VER >= 1400 // not VC6
732#include <intrin.h> // __cpuid
733static int stbi__cpuid3(void)
734{
735 int info[4];
736 __cpuid(info,1);
737 return info[3];
738}
739#else
740static int stbi__cpuid3(void)
741{
742 int res;
743 __asm {
744 mov eax,1
745 cpuid
746 mov res,edx
747 }
748 return res;
749}
750#endif
751
752#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
753
754#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
755static int stbi__sse2_available(void)
756{
757 int info3 = stbi__cpuid3();
758 return ((info3 >> 26) & 1) != 0;
759}
760#endif
761
762#else // assume GCC-style if not VC++
763#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
764
765#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
766static int stbi__sse2_available(void)
767{
768 // If we're even attempting to compile this on GCC/Clang, that means
769 // -msse2 is on, which means the compiler is allowed to use SSE2
770 // instructions at will, and so are we.
771 return 1;
772}
773#endif
774
775#endif
776#endif
777
778// ARM NEON
779#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
780#undef STBI_NEON
781#endif
782
783#ifdef STBI_NEON
784#include <arm_neon.h>
785#ifdef _MSC_VER
786#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
787#else
788#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
789#endif
790#endif
791
792#ifndef STBI_SIMD_ALIGN
793#define STBI_SIMD_ALIGN(type, name) type name
794#endif
795
796#ifndef STBI_MAX_DIMENSIONS
797#define STBI_MAX_DIMENSIONS (1 << 24)
798#endif
799
800///////////////////////////////////////////////
801//
802// stbi__context struct and start_xxx functions
803
804// stbi__context structure is our basic context used by all images, so it
805// contains all the IO context, plus some basic image information
806typedef struct
807{
808 stbi__uint32 img_x, img_y;
809 int img_n, img_out_n;
810
811 stbi_io_callbacks io;
812 void *io_user_data;
813
814 int read_from_callbacks;
815 int buflen;
816 stbi_uc buffer_start[128];
817 int callback_already_read;
818
819 stbi_uc *img_buffer, *img_buffer_end;
820 stbi_uc *img_buffer_original, *img_buffer_original_end;
821} stbi__context;
822
823
824static void stbi__refill_buffer(stbi__context *s);
825
826// initialize a memory-decode context
827static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
828{
829 s->io.read = NULL;
830 s->read_from_callbacks = 0;
831 s->callback_already_read = 0;
832 s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
833 s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
834}
835
836// initialize a callback-based context
837static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
838{
839 s->io = *c;
840 s->io_user_data = user;
841 s->buflen = sizeof(s->buffer_start);
842 s->read_from_callbacks = 1;
843 s->callback_already_read = 0;
844 s->img_buffer = s->img_buffer_original = s->buffer_start;
845 stbi__refill_buffer(s);
846 s->img_buffer_original_end = s->img_buffer_end;
847}
848
849#ifndef STBI_NO_STDIO
850
851static int stbi__stdio_read(void *user, char *data, int size)
852{
853 return (int) fread(data,1,size,(FILE*) user);
854}
855
856static void stbi__stdio_skip(void *user, int n)
857{
858 int ch;
859 fseek((FILE*) user, n, SEEK_CUR);
860 ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */
861 if (ch != EOF) {
862 ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */
863 }
864}
865
866static int stbi__stdio_eof(void *user)
867{
868 return feof((FILE*) user) || ferror((FILE *) user);
869}
870
871static stbi_io_callbacks stbi__stdio_callbacks =
872{
873 stbi__stdio_read,
874 stbi__stdio_skip,
875 stbi__stdio_eof,
876};
877
878static void stbi__start_file(stbi__context *s, FILE *f)
879{
880 stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
881}
882
883//static void stop_file(stbi__context *s) { }
884
885#endif // !STBI_NO_STDIO
886
887static void stbi__rewind(stbi__context *s)
888{
889 // conceptually rewind SHOULD rewind to the beginning of the stream,
890 // but we just rewind to the beginning of the initial buffer, because
891 // we only use it after doing 'test', which only ever looks at at most 92 bytes
892 s->img_buffer = s->img_buffer_original;
893 s->img_buffer_end = s->img_buffer_original_end;
894}
895
896enum
897{
898 STBI_ORDER_RGB,
899 STBI_ORDER_BGR
900};
901
902typedef struct
903{
904 int bits_per_channel;
905 int num_channels;
906 int channel_order;
907} stbi__result_info;
908
909#ifndef STBI_NO_JPEG
910static int stbi__jpeg_test(stbi__context *s);
911static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
912static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
913#endif
914
915#ifndef STBI_NO_PNG
916static int stbi__png_test(stbi__context *s);
917static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
918static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
919static int stbi__png_is16(stbi__context *s);
920#endif
921
922#ifndef STBI_NO_BMP
923static int stbi__bmp_test(stbi__context *s);
924static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
925static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
926#endif
927
928#ifndef STBI_NO_TGA
929static int stbi__tga_test(stbi__context *s);
930static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
931static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
932#endif
933
934#ifndef STBI_NO_PSD
935static int stbi__psd_test(stbi__context *s);
936static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
937static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
938static int stbi__psd_is16(stbi__context *s);
939#endif
940
941#ifndef STBI_NO_HDR
942static int stbi__hdr_test(stbi__context *s);
943static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
944static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
945#endif
946
947#ifndef STBI_NO_PIC
948static int stbi__pic_test(stbi__context *s);
949static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
950static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
951#endif
952
953#ifndef STBI_NO_GIF
954static int stbi__gif_test(stbi__context *s);
955static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
956static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
957static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
958#endif
959
960#ifndef STBI_NO_PNM
961static int stbi__pnm_test(stbi__context *s);
962static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
963static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
964static int stbi__pnm_is16(stbi__context *s);
965#endif
966
967static
968#ifdef STBI_THREAD_LOCAL
969STBI_THREAD_LOCAL
970#endif
971const char *stbi__g_failure_reason;
972
973STBIDEF const char *stbi_failure_reason(void)
974{
975 return stbi__g_failure_reason;
976}
977
978#ifndef STBI_NO_FAILURE_STRINGS
979static int stbi__err(const char *str)
980{
981 stbi__g_failure_reason = str;
982 return 0;
983}
984#endif
985
986static void *stbi__malloc(size_t size)
987{
988 return STBI_MALLOC(size);
989}
990
991// stb_image uses ints pervasively, including for offset calculations.
992// therefore the largest decoded image size we can support with the
993// current code, even on 64-bit targets, is INT_MAX. this is not a
994// significant limitation for the intended use case.
995//
996// we do, however, need to make sure our size calculations don't
997// overflow. hence a few helper functions for size calculations that
998// multiply integers together, making sure that they're non-negative
999// and no overflow occurs.
1000
1001// return 1 if the sum is valid, 0 on overflow.
1002// negative terms are considered invalid.
1003static int stbi__addsizes_valid(int a, int b)
1004{
1005 if (b < 0) return 0;
1006 // now 0 <= b <= INT_MAX, hence also
1007 // 0 <= INT_MAX - b <= INTMAX.
1008 // And "a + b <= INT_MAX" (which might overflow) is the
1009 // same as a <= INT_MAX - b (no overflow)
1010 return a <= INT_MAX - b;
1011}
1012
1013// returns 1 if the product is valid, 0 on overflow.
1014// negative factors are considered invalid.
1015static int stbi__mul2sizes_valid(int a, int b)
1016{
1017 if (a < 0 || b < 0) return 0;
1018 if (b == 0) return 1; // mul-by-0 is always safe
1019 // portable way to check for no overflows in a*b
1020 return a <= INT_MAX/b;
1021}
1022
1023#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
1024// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
1025static int stbi__mad2sizes_valid(int a, int b, int add)
1026{
1027 return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
1028}
1029#endif
1030
1031// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
1032static int stbi__mad3sizes_valid(int a, int b, int c, int add)
1033{
1034 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
1035 stbi__addsizes_valid(a*b*c, add);
1036}
1037
1038// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
1039#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1040static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
1041{
1042 return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
1043 stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
1044}
1045#endif
1046
1047#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
1048// mallocs with size overflow checking
1049static void *stbi__malloc_mad2(int a, int b, int add)
1050{
1051 if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
1052 return stbi__malloc(a*b + add);
1053}
1054#endif
1055
1056static void *stbi__malloc_mad3(int a, int b, int c, int add)
1057{
1058 if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
1059 return stbi__malloc(a*b*c + add);
1060}
1061
1062#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
1063static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
1064{
1065 if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
1066 return stbi__malloc(a*b*c*d + add);
1067}
1068#endif
1069
1070// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
1071static int stbi__addints_valid(int a, int b)
1072{
1073 if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
1074 if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
1075 return a <= INT_MAX - b;
1076}
1077
1078// returns 1 if the product of two signed shorts is valid, 0 on overflow.
1079static int stbi__mul2shorts_valid(short a, short b)
1080{
1081 if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
1082 if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
1083 if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
1084 return a >= SHRT_MIN / b;
1085}
1086
1087// stbi__err - error
1088// stbi__errpf - error returning pointer to float
1089// stbi__errpuc - error returning pointer to unsigned char
1090
1091#ifdef STBI_NO_FAILURE_STRINGS
1092 #define stbi__err(x,y) 0
1093#elif defined(STBI_FAILURE_USERMSG)
1094 #define stbi__err(x,y) stbi__err(y)
1095#else
1096 #define stbi__err(x,y) stbi__err(x)
1097#endif
1098
1099#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
1100#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
1101
1102STBIDEF void stbi_image_free(void *retval_from_stbi_load)
1103{
1104 STBI_FREE(retval_from_stbi_load);
1105}
1106
1107#ifndef STBI_NO_LINEAR
1108static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
1109#endif
1110
1111#ifndef STBI_NO_HDR
1112static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
1113#endif
1114
1115static int stbi__vertically_flip_on_load_global = 0;
1116
1117STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
1118{
1119 stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
1120}
1121
1122#ifndef STBI_THREAD_LOCAL
1123#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global
1124#else
1125static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
1126
1127STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
1128{
1129 stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
1130 stbi__vertically_flip_on_load_set = 1;
1131}
1132
1133#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \
1134 ? stbi__vertically_flip_on_load_local \
1135 : stbi__vertically_flip_on_load_global)
1136#endif // STBI_THREAD_LOCAL
1137
1138static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
1139{
1140 memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
1141 ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
1142 ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
1143 ri->num_channels = 0;
1144
1145 // test the formats with a very explicit header first (at least a FOURCC
1146 // or distinctive magic number first)
1147 #ifndef STBI_NO_PNG
1148 if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);
1149 #endif
1150 #ifndef STBI_NO_BMP
1151 if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);
1152 #endif
1153 #ifndef STBI_NO_GIF
1154 if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);
1155 #endif
1156 #ifndef STBI_NO_PSD
1157 if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
1158 #else
1159 STBI_NOTUSED(bpc);
1160 #endif
1161 #ifndef STBI_NO_PIC
1162 if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);
1163 #endif
1164
1165 // then the formats that can end up attempting to load with just 1 or 2
1166 // bytes matching expectations; these are prone to false positives, so
1167 // try them later
1168 #ifndef STBI_NO_JPEG
1169 if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
1170 #endif
1171 #ifndef STBI_NO_PNM
1172 if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);
1173 #endif
1174
1175 #ifndef STBI_NO_HDR
1176 if (stbi__hdr_test(s)) {
1177 float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
1178 return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
1179 }
1180 #endif
1181
1182 #ifndef STBI_NO_TGA
1183 // test tga last because it's a crappy test!
1184 if (stbi__tga_test(s))
1185 return stbi__tga_load(s,x,y,comp,req_comp, ri);
1186 #endif
1187
1188 return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
1189}
1190
1191static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
1192{
1193 int i;
1194 int img_len = w * h * channels;
1195 stbi_uc *reduced;
1196
1197 reduced = (stbi_uc *) stbi__malloc(img_len);
1198 if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
1199
1200 for (i = 0; i < img_len; ++i)
1201 reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
1202
1203 STBI_FREE(orig);
1204 return reduced;
1205}
1206
1207static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
1208{
1209 int i;
1210 int img_len = w * h * channels;
1211 stbi__uint16 *enlarged;
1212
1213 enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
1214 if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
1215
1216 for (i = 0; i < img_len; ++i)
1217 enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
1218
1219 STBI_FREE(orig);
1220 return enlarged;
1221}
1222
1223static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
1224{
1225 int row;
1226 size_t bytes_per_row = (size_t)w * bytes_per_pixel;
1227 stbi_uc temp[2048];
1228 stbi_uc *bytes = (stbi_uc *)image;
1229
1230 for (row = 0; row < (h>>1); row++) {
1231 stbi_uc *row0 = bytes + row*bytes_per_row;
1232 stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
1233 // swap row0 with row1
1234 size_t bytes_left = bytes_per_row;
1235 while (bytes_left) {
1236 size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
1237 memcpy(temp, row0, bytes_copy);
1238 memcpy(row0, row1, bytes_copy);
1239 memcpy(row1, temp, bytes_copy);
1240 row0 += bytes_copy;
1241 row1 += bytes_copy;
1242 bytes_left -= bytes_copy;
1243 }
1244 }
1245}
1246
1247#ifndef STBI_NO_GIF
1248static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
1249{
1250 int slice;
1251 int slice_size = w * h * bytes_per_pixel;
1252
1253 stbi_uc *bytes = (stbi_uc *)image;
1254 for (slice = 0; slice < z; ++slice) {
1255 stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
1256 bytes += slice_size;
1257 }
1258}
1259#endif
1260
1261static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1262{
1263 stbi__result_info ri;
1264 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
1265
1266 if (result == NULL)
1267 return NULL;
1268
1269 // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
1270 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1271
1272 if (ri.bits_per_channel != 8) {
1273 result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1274 ri.bits_per_channel = 8;
1275 }
1276
1277 // @TODO: move stbi__convert_format to here
1278
1279 if (stbi__vertically_flip_on_load) {
1280 int channels = req_comp ? req_comp : *comp;
1281 stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
1282 }
1283
1284 return (unsigned char *) result;
1285}
1286
1287static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1288{
1289 stbi__result_info ri;
1290 void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
1291
1292 if (result == NULL)
1293 return NULL;
1294
1295 // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
1296 STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
1297
1298 if (ri.bits_per_channel != 16) {
1299 result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
1300 ri.bits_per_channel = 16;
1301 }
1302
1303 // @TODO: move stbi__convert_format16 to here
1304 // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
1305
1306 if (stbi__vertically_flip_on_load) {
1307 int channels = req_comp ? req_comp : *comp;
1308 stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
1309 }
1310
1311 return (stbi__uint16 *) result;
1312}
1313
1314#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
1315static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
1316{
1317 if (stbi__vertically_flip_on_load && result != NULL) {
1318 int channels = req_comp ? req_comp : *comp;
1319 stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
1320 }
1321}
1322#endif
1323
1324#ifndef STBI_NO_STDIO
1325
1326#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1327STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
1328STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
1329#endif
1330
1331#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1332STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
1333{
1334 return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
1335}
1336#endif
1337
1338static FILE *stbi__fopen(char const *filename, char const *mode)
1339{
1340 FILE *f;
1341#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
1342 wchar_t wMode[64];
1343 wchar_t wFilename[1024];
1344 if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
1345 return 0;
1346
1347 if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
1348 return 0;
1349
1350#if defined(_MSC_VER) && _MSC_VER >= 1400
1351 if (0 != _wfopen_s(&f, wFilename, wMode))
1352 f = 0;
1353#else
1354 f = _wfopen(wFilename, wMode);
1355#endif
1356
1357#elif defined(_MSC_VER) && _MSC_VER >= 1400
1358 if (0 != fopen_s(&f, filename, mode))
1359 f=0;
1360#else
1361 f = fopen(filename, mode);
1362#endif
1363 return f;
1364}
1365
1366
1367STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
1368{
1369 FILE *f = stbi__fopen(filename, "rb");
1370 unsigned char *result;
1371 if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
1372 result = stbi_load_from_file(f,x,y,comp,req_comp);
1373 fclose(f);
1374 return result;
1375}
1376
1377STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
1378{
1379 unsigned char *result;
1380 stbi__context s;
1381 stbi__start_file(&s,f);
1382 result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1383 if (result) {
1384 // need to 'unget' all the characters in the IO buffer
1385 fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
1386 }
1387 return result;
1388}
1389
1390STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
1391{
1392 stbi__uint16 *result;
1393 stbi__context s;
1394 stbi__start_file(&s,f);
1395 result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
1396 if (result) {
1397 // need to 'unget' all the characters in the IO buffer
1398 fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
1399 }
1400 return result;
1401}
1402
1403STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
1404{
1405 FILE *f = stbi__fopen(filename, "rb");
1406 stbi__uint16 *result;
1407 if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
1408 result = stbi_load_from_file_16(f,x,y,comp,req_comp);
1409 fclose(f);
1410 return result;
1411}
1412
1413
1414#endif //!STBI_NO_STDIO
1415
1416STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
1417{
1418 stbi__context s;
1419 stbi__start_mem(&s,buffer,len);
1420 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1421}
1422
1423STBIDEF 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)
1424{
1425 stbi__context s;
1426 stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
1427 return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
1428}
1429
1430STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
1431{
1432 stbi__context s;
1433 stbi__start_mem(&s,buffer,len);
1434 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1435}
1436
1437STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
1438{
1439 stbi__context s;
1440 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1441 return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
1442}
1443
1444#ifndef STBI_NO_GIF
1445STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
1446{
1447 unsigned char *result;
1448 stbi__context s;
1449 stbi__start_mem(&s,buffer,len);
1450
1451 result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
1452 if (stbi__vertically_flip_on_load) {
1453 stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
1454 }
1455
1456 return result;
1457}
1458#endif
1459
1460#ifndef STBI_NO_LINEAR
1461static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
1462{
1463 unsigned char *data;
1464 #ifndef STBI_NO_HDR
1465 if (stbi__hdr_test(s)) {
1466 stbi__result_info ri;
1467 float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
1468 if (hdr_data)
1469 stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
1470 return hdr_data;
1471 }
1472 #endif
1473 data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
1474 if (data)
1475 return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
1476 return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
1477}
1478
1479STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
1480{
1481 stbi__context s;
1482 stbi__start_mem(&s,buffer,len);
1483 return stbi__loadf_main(&s,x,y,comp,req_comp);
1484}
1485
1486STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
1487{
1488 stbi__context s;
1489 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1490 return stbi__loadf_main(&s,x,y,comp,req_comp);
1491}
1492
1493#ifndef STBI_NO_STDIO
1494STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
1495{
1496 float *result;
1497 FILE *f = stbi__fopen(filename, "rb");
1498 if (!f) return stbi__errpf("can't fopen", "Unable to open file");
1499 result = stbi_loadf_from_file(f,x,y,comp,req_comp);
1500 fclose(f);
1501 return result;
1502}
1503
1504STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
1505{
1506 stbi__context s;
1507 stbi__start_file(&s,f);
1508 return stbi__loadf_main(&s,x,y,comp,req_comp);
1509}
1510#endif // !STBI_NO_STDIO
1511
1512#endif // !STBI_NO_LINEAR
1513
1514// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
1515// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
1516// reports false!
1517
1518STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
1519{
1520 #ifndef STBI_NO_HDR
1521 stbi__context s;
1522 stbi__start_mem(&s,buffer,len);
1523 return stbi__hdr_test(&s);
1524 #else
1525 STBI_NOTUSED(buffer);
1526 STBI_NOTUSED(len);
1527 return 0;
1528 #endif
1529}
1530
1531#ifndef STBI_NO_STDIO
1532STBIDEF int stbi_is_hdr (char const *filename)
1533{
1534 FILE *f = stbi__fopen(filename, "rb");
1535 int result=0;
1536 if (f) {
1537 result = stbi_is_hdr_from_file(f);
1538 fclose(f);
1539 }
1540 return result;
1541}
1542
1543STBIDEF int stbi_is_hdr_from_file(FILE *f)
1544{
1545 #ifndef STBI_NO_HDR
1546 long pos = ftell(f);
1547 int res;
1548 stbi__context s;
1549 stbi__start_file(&s,f);
1550 res = stbi__hdr_test(&s);
1551 fseek(f, pos, SEEK_SET);
1552 return res;
1553 #else
1554 STBI_NOTUSED(f);
1555 return 0;
1556 #endif
1557}
1558#endif // !STBI_NO_STDIO
1559
1560STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
1561{
1562 #ifndef STBI_NO_HDR
1563 stbi__context s;
1564 stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
1565 return stbi__hdr_test(&s);
1566 #else
1567 STBI_NOTUSED(clbk);
1568 STBI_NOTUSED(user);
1569 return 0;
1570 #endif
1571}
1572
1573#ifndef STBI_NO_LINEAR
1574static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
1575
1576STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
1577STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
1578#endif
1579
1580static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
1581
1582STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
1583STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
1584
1585
1586//////////////////////////////////////////////////////////////////////////////
1587//
1588// Common code used by all image loaders
1589//
1590
1591enum
1592{
1593 STBI__SCAN_load=0,
1594 STBI__SCAN_type,
1595 STBI__SCAN_header
1596};
1597
1598static void stbi__refill_buffer(stbi__context *s)
1599{
1600 int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
1601 s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
1602 if (n == 0) {
1603 // at end of file, treat same as if from memory, but need to handle case
1604 // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
1605 s->read_from_callbacks = 0;
1606 s->img_buffer = s->buffer_start;
1607 s->img_buffer_end = s->buffer_start+1;
1608 *s->img_buffer = 0;
1609 } else {
1610 s->img_buffer = s->buffer_start;
1611 s->img_buffer_end = s->buffer_start + n;
1612 }
1613}
1614
1615stbi_inline static stbi_uc stbi__get8(stbi__context *s)
1616{
1617 if (s->img_buffer < s->img_buffer_end)
1618 return *s->img_buffer++;
1619 if (s->read_from_callbacks) {
1620 stbi__refill_buffer(s);
1621 return *s->img_buffer++;
1622 }
1623 return 0;
1624}
1625
1626#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1627// nothing
1628#else
1629stbi_inline static int stbi__at_eof(stbi__context *s)
1630{
1631 if (s->io.read) {
1632 if (!(s->io.eof)(s->io_user_data)) return 0;
1633 // if feof() is true, check if buffer = end
1634 // special case: we've only got the special 0 character at the end
1635 if (s->read_from_callbacks == 0) return 1;
1636 }
1637
1638 return s->img_buffer >= s->img_buffer_end;
1639}
1640#endif
1641
1642#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
1643// nothing
1644#else
1645static void stbi__skip(stbi__context *s, int n)
1646{
1647 if (n == 0) return; // already there!
1648 if (n < 0) {
1649 s->img_buffer = s->img_buffer_end;
1650 return;
1651 }
1652 if (s->io.read) {
1653 int blen = (int) (s->img_buffer_end - s->img_buffer);
1654 if (blen < n) {
1655 s->img_buffer = s->img_buffer_end;
1656 (s->io.skip)(s->io_user_data, n - blen);
1657 return;
1658 }
1659 }
1660 s->img_buffer += n;
1661}
1662#endif
1663
1664#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
1665// nothing
1666#else
1667static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
1668{
1669 if (s->io.read) {
1670 int blen = (int) (s->img_buffer_end - s->img_buffer);
1671 if (blen < n) {
1672 int res, count;
1673
1674 memcpy(buffer, s->img_buffer, blen);
1675
1676 count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
1677 res = (count == (n-blen));
1678 s->img_buffer = s->img_buffer_end;
1679 return res;
1680 }
1681 }
1682
1683 if (s->img_buffer+n <= s->img_buffer_end) {
1684 memcpy(buffer, s->img_buffer, n);
1685 s->img_buffer += n;
1686 return 1;
1687 } else
1688 return 0;
1689}
1690#endif
1691
1692#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1693// nothing
1694#else
1695static int stbi__get16be(stbi__context *s)
1696{
1697 int z = stbi__get8(s);
1698 return (z << 8) + stbi__get8(s);
1699}
1700#endif
1701
1702#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
1703// nothing
1704#else
1705static stbi__uint32 stbi__get32be(stbi__context *s)
1706{
1707 stbi__uint32 z = stbi__get16be(s);
1708 return (z << 16) + stbi__get16be(s);
1709}
1710#endif
1711
1712#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
1713// nothing
1714#else
1715static int stbi__get16le(stbi__context *s)
1716{
1717 int z = stbi__get8(s);
1718 return z + (stbi__get8(s) << 8);
1719}
1720#endif
1721
1722#ifndef STBI_NO_BMP
1723static stbi__uint32 stbi__get32le(stbi__context *s)
1724{
1725 stbi__uint32 z = stbi__get16le(s);
1726 z += (stbi__uint32)stbi__get16le(s) << 16;
1727 return z;
1728}
1729#endif
1730
1731#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
1732
1733#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1734// nothing
1735#else
1736//////////////////////////////////////////////////////////////////////////////
1737//
1738// generic converter from built-in img_n to req_comp
1739// individual types do this automatically as much as possible (e.g. jpeg
1740// does all cases internally since it needs to colorspace convert anyway,
1741// and it never has alpha, so very few cases ). png can automatically
1742// interleave an alpha=255 channel, but falls back to this for other cases
1743//
1744// assume data buffer is malloced, so malloc a new one and free that one
1745// only failure mode is malloc failing
1746
1747static stbi_uc stbi__compute_y(int r, int g, int b)
1748{
1749 return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
1750}
1751#endif
1752
1753#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
1754// nothing
1755#else
1756static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
1757{
1758 int i,j;
1759 unsigned char *good;
1760
1761 if (req_comp == img_n) return data;
1762 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1763
1764 good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
1765 if (good == NULL) {
1766 STBI_FREE(data);
1767 return stbi__errpuc("outofmem", "Out of memory");
1768 }
1769
1770 for (j=0; j < (int) y; ++j) {
1771 unsigned char *src = data + j * x * img_n ;
1772 unsigned char *dest = good + j * x * req_comp;
1773
1774 #define STBI__COMBO(a,b) ((a)*8+(b))
1775 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1776 // convert source image with img_n components to one with req_comp components;
1777 // avoid switch per pixel, so use switch per scanline and massive macros
1778 switch (STBI__COMBO(img_n, req_comp)) {
1779 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
1780 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1781 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
1782 STBI__CASE(2,1) { dest[0]=src[0]; } break;
1783 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1784 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
1785 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
1786 STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
1787 STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
1788 STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
1789 STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
1790 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
1791 default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
1792 }
1793 #undef STBI__CASE
1794 }
1795
1796 STBI_FREE(data);
1797 return good;
1798}
1799#endif
1800
1801#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1802// nothing
1803#else
1804static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
1805{
1806 return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
1807}
1808#endif
1809
1810#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
1811// nothing
1812#else
1813static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
1814{
1815 int i,j;
1816 stbi__uint16 *good;
1817
1818 if (req_comp == img_n) return data;
1819 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
1820
1821 good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
1822 if (good == NULL) {
1823 STBI_FREE(data);
1824 return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
1825 }
1826
1827 for (j=0; j < (int) y; ++j) {
1828 stbi__uint16 *src = data + j * x * img_n ;
1829 stbi__uint16 *dest = good + j * x * req_comp;
1830
1831 #define STBI__COMBO(a,b) ((a)*8+(b))
1832 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
1833 // convert source image with img_n components to one with req_comp components;
1834 // avoid switch per pixel, so use switch per scanline and massive macros
1835 switch (STBI__COMBO(img_n, req_comp)) {
1836 STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;
1837 STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1838 STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;
1839 STBI__CASE(2,1) { dest[0]=src[0]; } break;
1840 STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
1841 STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
1842 STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
1843 STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
1844 STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
1845 STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
1846 STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
1847 STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
1848 default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
1849 }
1850 #undef STBI__CASE
1851 }
1852
1853 STBI_FREE(data);
1854 return good;
1855}
1856#endif
1857
1858#ifndef STBI_NO_LINEAR
1859static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
1860{
1861 int i,k,n;
1862 float *output;
1863 if (!data) return NULL;
1864 output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
1865 if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
1866 // compute number of non-alpha components
1867 if (comp & 1) n = comp; else n = comp-1;
1868 for (i=0; i < x*y; ++i) {
1869 for (k=0; k < n; ++k) {
1870 output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
1871 }
1872 }
1873 if (n < comp) {
1874 for (i=0; i < x*y; ++i) {
1875 output[i*comp + n] = data[i*comp + n]/255.0f;
1876 }
1877 }
1878 STBI_FREE(data);
1879 return output;
1880}
1881#endif
1882
1883#ifndef STBI_NO_HDR
1884#define stbi__float2int(x) ((int) (x))
1885static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
1886{
1887 int i,k,n;
1888 stbi_uc *output;
1889 if (!data) return NULL;
1890 output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
1891 if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
1892 // compute number of non-alpha components
1893 if (comp & 1) n = comp; else n = comp-1;
1894 for (i=0; i < x*y; ++i) {
1895 for (k=0; k < n; ++k) {
1896 float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
1897 if (z < 0) z = 0;
1898 if (z > 255) z = 255;
1899 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
1900 }
1901 if (k < comp) {
1902 float z = data[i*comp+k] * 255 + 0.5f;
1903 if (z < 0) z = 0;
1904 if (z > 255) z = 255;
1905 output[i*comp + k] = (stbi_uc) stbi__float2int(z);
1906 }
1907 }
1908 STBI_FREE(data);
1909 return output;
1910}
1911#endif
1912
1913//////////////////////////////////////////////////////////////////////////////
1914//
1915// "baseline" JPEG/JFIF decoder
1916//
1917// simple implementation
1918// - doesn't support delayed output of y-dimension
1919// - simple interface (only one output format: 8-bit interleaved RGB)
1920// - doesn't try to recover corrupt jpegs
1921// - doesn't allow partial loading, loading multiple at once
1922// - still fast on x86 (copying globals into locals doesn't help x86)
1923// - allocates lots of intermediate memory (full size of all components)
1924// - non-interleaved case requires this anyway
1925// - allows good upsampling (see next)
1926// high-quality
1927// - upsampled channels are bilinearly interpolated, even across blocks
1928// - quality integer IDCT derived from IJG's 'slow'
1929// performance
1930// - fast huffman; reasonable integer IDCT
1931// - some SIMD kernels for common paths on targets with SSE2/NEON
1932// - uses a lot of intermediate memory, could cache poorly
1933
1934#ifndef STBI_NO_JPEG
1935
1936// huffman decoding acceleration
1937#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
1938
1939typedef struct
1940{
1941 stbi_uc fast[1 << FAST_BITS];
1942 // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
1943 stbi__uint16 code[256];
1944 stbi_uc values[256];
1945 stbi_uc size[257];
1946 unsigned int maxcode[18];
1947 int delta[17]; // old 'firstsymbol' - old 'firstcode'
1948} stbi__huffman;
1949
1950typedef struct
1951{
1952 stbi__context *s;
1953 stbi__huffman huff_dc[4];
1954 stbi__huffman huff_ac[4];
1955 stbi__uint16 dequant[4][64];
1956 stbi__int16 fast_ac[4][1 << FAST_BITS];
1957
1958// sizes for components, interleaved MCUs
1959 int img_h_max, img_v_max;
1960 int img_mcu_x, img_mcu_y;
1961 int img_mcu_w, img_mcu_h;
1962
1963// definition of jpeg image component
1964 struct
1965 {
1966 int id;
1967 int h,v;
1968 int tq;
1969 int hd,ha;
1970 int dc_pred;
1971
1972 int x,y,w2,h2;
1973 stbi_uc *data;
1974 void *raw_data, *raw_coeff;
1975 stbi_uc *linebuf;
1976 short *coeff; // progressive only
1977 int coeff_w, coeff_h; // number of 8x8 coefficient blocks
1978 } img_comp[4];
1979
1980 stbi__uint32 code_buffer; // jpeg entropy-coded buffer
1981 int code_bits; // number of valid bits
1982 unsigned char marker; // marker seen while filling entropy buffer
1983 int nomore; // flag if we saw a marker so must stop
1984
1985 int progressive;
1986 int spec_start;
1987 int spec_end;
1988 int succ_high;
1989 int succ_low;
1990 int eob_run;
1991 int jfif;
1992 int app14_color_transform; // Adobe APP14 tag
1993 int rgb;
1994
1995 int scan_n, order[4];
1996 int restart_interval, todo;
1997
1998// kernels
1999 void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
2000 void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
2001 stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
2002} stbi__jpeg;
2003
2004static int stbi__build_huffman(stbi__huffman *h, int *count)
2005{
2006 int i,j,k=0;
2007 unsigned int code;
2008 // build size list for each symbol (from JPEG spec)
2009 for (i=0; i < 16; ++i) {
2010 for (j=0; j < count[i]; ++j) {
2011 h->size[k++] = (stbi_uc) (i+1);
2012 if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
2013 }
2014 }
2015 h->size[k] = 0;
2016
2017 // compute actual symbols (from jpeg spec)
2018 code = 0;
2019 k = 0;
2020 for(j=1; j <= 16; ++j) {
2021 // compute delta to add to code to compute symbol id
2022 h->delta[j] = k - code;
2023 if (h->size[k] == j) {
2024 while (h->size[k] == j)
2025 h->code[k++] = (stbi__uint16) (code++);
2026 if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
2027 }
2028 // compute largest code + 1 for this size, preshifted as needed later
2029 h->maxcode[j] = code << (16-j);
2030 code <<= 1;
2031 }
2032 h->maxcode[j] = 0xffffffff;
2033
2034 // build non-spec acceleration table; 255 is flag for not-accelerated
2035 memset(h->fast, 255, 1 << FAST_BITS);
2036 for (i=0; i < k; ++i) {
2037 int s = h->size[i];
2038 if (s <= FAST_BITS) {
2039 int c = h->code[i] << (FAST_BITS-s);
2040 int m = 1 << (FAST_BITS-s);
2041 for (j=0; j < m; ++j) {
2042 h->fast[c+j] = (stbi_uc) i;
2043 }
2044 }
2045 }
2046 return 1;
2047}
2048
2049// build a table that decodes both magnitude and value of small ACs in
2050// one go.
2051static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
2052{
2053 int i;
2054 for (i=0; i < (1 << FAST_BITS); ++i) {
2055 stbi_uc fast = h->fast[i];
2056 fast_ac[i] = 0;
2057 if (fast < 255) {
2058 int rs = h->values[fast];
2059 int run = (rs >> 4) & 15;
2060 int magbits = rs & 15;
2061 int len = h->size[fast];
2062
2063 if (magbits && len + magbits <= FAST_BITS) {
2064 // magnitude code followed by receive_extend code
2065 int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
2066 int m = 1 << (magbits - 1);
2067 if (k < m) k += (~0U << magbits) + 1;
2068 // if the result is small enough, we can fit it in fast_ac table
2069 if (k >= -128 && k <= 127)
2070 fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
2071 }
2072 }
2073 }
2074}
2075
2076static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
2077{
2078 do {
2079 unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
2080 if (b == 0xff) {
2081 int c = stbi__get8(j->s);
2082 while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
2083 if (c != 0) {
2084 j->marker = (unsigned char) c;
2085 j->nomore = 1;
2086 return;
2087 }
2088 }
2089 j->code_buffer |= b << (24 - j->code_bits);
2090 j->code_bits += 8;
2091 } while (j->code_bits <= 24);
2092}
2093
2094// (1 << n) - 1
2095static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
2096
2097// decode a jpeg huffman value from the bitstream
2098stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
2099{
2100 unsigned int temp;
2101 int c,k;
2102
2103 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2104
2105 // look at the top FAST_BITS and determine what symbol ID it is,
2106 // if the code is <= FAST_BITS
2107 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2108 k = h->fast[c];
2109 if (k < 255) {
2110 int s = h->size[k];
2111 if (s > j->code_bits)
2112 return -1;
2113 j->code_buffer <<= s;
2114 j->code_bits -= s;
2115 return h->values[k];
2116 }
2117
2118 // naive test is to shift the code_buffer down so k bits are
2119 // valid, then test against maxcode. To speed this up, we've
2120 // preshifted maxcode left so that it has (16-k) 0s at the
2121 // end; in other words, regardless of the number of bits, it
2122 // wants to be compared against something shifted to have 16;
2123 // that way we don't need to shift inside the loop.
2124 temp = j->code_buffer >> 16;
2125 for (k=FAST_BITS+1 ; ; ++k)
2126 if (temp < h->maxcode[k])
2127 break;
2128 if (k == 17) {
2129 // error! code not found
2130 j->code_bits -= 16;
2131 return -1;
2132 }
2133
2134 if (k > j->code_bits)
2135 return -1;
2136
2137 // convert the huffman code to the symbol id
2138 c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
2139 if(c < 0 || c >= 256) // symbol id out of bounds!
2140 return -1;
2141 STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
2142
2143 // convert the id to a symbol
2144 j->code_bits -= k;
2145 j->code_buffer <<= k;
2146 return h->values[c];
2147}
2148
2149// bias[n] = (-1<<n) + 1
2150static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
2151
2152// combined JPEG 'receive' and JPEG 'extend', since baseline
2153// always extends everything it receives.
2154stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
2155{
2156 unsigned int k;
2157 int sgn;
2158 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
2159 if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
2160
2161 sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
2162 k = stbi_lrot(j->code_buffer, n);
2163 j->code_buffer = k & ~stbi__bmask[n];
2164 k &= stbi__bmask[n];
2165 j->code_bits -= n;
2166 return k + (stbi__jbias[n] & (sgn - 1));
2167}
2168
2169// get some unsigned bits
2170stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
2171{
2172 unsigned int k;
2173 if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
2174 if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
2175 k = stbi_lrot(j->code_buffer, n);
2176 j->code_buffer = k & ~stbi__bmask[n];
2177 k &= stbi__bmask[n];
2178 j->code_bits -= n;
2179 return k;
2180}
2181
2182stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
2183{
2184 unsigned int k;
2185 if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
2186 if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
2187 k = j->code_buffer;
2188 j->code_buffer <<= 1;
2189 --j->code_bits;
2190 return k & 0x80000000;
2191}
2192
2193// given a value that's at position X in the zigzag stream,
2194// where does it appear in the 8x8 matrix coded as row-major?
2195static const stbi_uc stbi__jpeg_dezigzag[64+15] =
2196{
2197 0, 1, 8, 16, 9, 2, 3, 10,
2198 17, 24, 32, 25, 18, 11, 4, 5,
2199 12, 19, 26, 33, 40, 48, 41, 34,
2200 27, 20, 13, 6, 7, 14, 21, 28,
2201 35, 42, 49, 56, 57, 50, 43, 36,
2202 29, 22, 15, 23, 30, 37, 44, 51,
2203 58, 59, 52, 45, 38, 31, 39, 46,
2204 53, 60, 61, 54, 47, 55, 62, 63,
2205 // let corrupt input sample past end
2206 63, 63, 63, 63, 63, 63, 63, 63,
2207 63, 63, 63, 63, 63, 63, 63
2208};
2209
2210// decode one 64-entry block--
2211static 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)
2212{
2213 int diff,dc,k;
2214 int t;
2215
2216 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2217 t = stbi__jpeg_huff_decode(j, hdc);
2218 if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
2219
2220 // 0 all the ac values now so we can do it 32-bits at a time
2221 memset(data,0,64*sizeof(data[0]));
2222
2223 diff = t ? stbi__extend_receive(j, t) : 0;
2224 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
2225 dc = j->img_comp[b].dc_pred + diff;
2226 j->img_comp[b].dc_pred = dc;
2227 if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2228 data[0] = (short) (dc * dequant[0]);
2229
2230 // decode AC components, see JPEG spec
2231 k = 1;
2232 do {
2233 unsigned int zig;
2234 int c,r,s;
2235 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2236 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2237 r = fac[c];
2238 if (r) { // fast-AC path
2239 k += (r >> 4) & 15; // run
2240 s = r & 15; // combined length
2241 if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
2242 j->code_buffer <<= s;
2243 j->code_bits -= s;
2244 // decode into unzigzag'd location
2245 zig = stbi__jpeg_dezigzag[k++];
2246 data[zig] = (short) ((r >> 8) * dequant[zig]);
2247 } else {
2248 int rs = stbi__jpeg_huff_decode(j, hac);
2249 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2250 s = rs & 15;
2251 r = rs >> 4;
2252 if (s == 0) {
2253 if (rs != 0xf0) break; // end block
2254 k += 16;
2255 } else {
2256 k += r;
2257 // decode into unzigzag'd location
2258 zig = stbi__jpeg_dezigzag[k++];
2259 data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
2260 }
2261 }
2262 } while (k < 64);
2263 return 1;
2264}
2265
2266static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
2267{
2268 int diff,dc;
2269 int t;
2270 if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2271
2272 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2273
2274 if (j->succ_high == 0) {
2275 // first scan for DC coefficient, must be first
2276 memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
2277 t = stbi__jpeg_huff_decode(j, hdc);
2278 if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2279 diff = t ? stbi__extend_receive(j, t) : 0;
2280
2281 if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
2282 dc = j->img_comp[b].dc_pred + diff;
2283 j->img_comp[b].dc_pred = dc;
2284 if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2285 data[0] = (short) (dc * (1 << j->succ_low));
2286 } else {
2287 // refinement scan for DC coefficient
2288 if (stbi__jpeg_get_bit(j))
2289 data[0] += (short) (1 << j->succ_low);
2290 }
2291 return 1;
2292}
2293
2294// @OPTIMIZE: store non-zigzagged during the decode passes,
2295// and only de-zigzag when dequantizing
2296static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
2297{
2298 int k;
2299 if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
2300
2301 if (j->succ_high == 0) {
2302 int shift = j->succ_low;
2303
2304 if (j->eob_run) {
2305 --j->eob_run;
2306 return 1;
2307 }
2308
2309 k = j->spec_start;
2310 do {
2311 unsigned int zig;
2312 int c,r,s;
2313 if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
2314 c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
2315 r = fac[c];
2316 if (r) { // fast-AC path
2317 k += (r >> 4) & 15; // run
2318 s = r & 15; // combined length
2319 if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
2320 j->code_buffer <<= s;
2321 j->code_bits -= s;
2322 zig = stbi__jpeg_dezigzag[k++];
2323 data[zig] = (short) ((r >> 8) * (1 << shift));
2324 } else {
2325 int rs = stbi__jpeg_huff_decode(j, hac);
2326 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2327 s = rs & 15;
2328 r = rs >> 4;
2329 if (s == 0) {
2330 if (r < 15) {
2331 j->eob_run = (1 << r);
2332 if (r)
2333 j->eob_run += stbi__jpeg_get_bits(j, r);
2334 --j->eob_run;
2335 break;
2336 }
2337 k += 16;
2338 } else {
2339 k += r;
2340 zig = stbi__jpeg_dezigzag[k++];
2341 data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
2342 }
2343 }
2344 } while (k <= j->spec_end);
2345 } else {
2346 // refinement scan for these AC coefficients
2347
2348 short bit = (short) (1 << j->succ_low);
2349
2350 if (j->eob_run) {
2351 --j->eob_run;
2352 for (k = j->spec_start; k <= j->spec_end; ++k) {
2353 short *p = &data[stbi__jpeg_dezigzag[k]];
2354 if (*p != 0)
2355 if (stbi__jpeg_get_bit(j))
2356 if ((*p & bit)==0) {
2357 if (*p > 0)
2358 *p += bit;
2359 else
2360 *p -= bit;
2361 }
2362 }
2363 } else {
2364 k = j->spec_start;
2365 do {
2366 int r,s;
2367 int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
2368 if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
2369 s = rs & 15;
2370 r = rs >> 4;
2371 if (s == 0) {
2372 if (r < 15) {
2373 j->eob_run = (1 << r) - 1;
2374 if (r)
2375 j->eob_run += stbi__jpeg_get_bits(j, r);
2376 r = 64; // force end of block
2377 } else {
2378 // r=15 s=0 should write 16 0s, so we just do
2379 // a run of 15 0s and then write s (which is 0),
2380 // so we don't have to do anything special here
2381 }
2382 } else {
2383 if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
2384 // sign bit
2385 if (stbi__jpeg_get_bit(j))
2386 s = bit;
2387 else
2388 s = -bit;
2389 }
2390
2391 // advance by r
2392 while (k <= j->spec_end) {
2393 short *p = &data[stbi__jpeg_dezigzag[k++]];
2394 if (*p != 0) {
2395 if (stbi__jpeg_get_bit(j))
2396 if ((*p & bit)==0) {
2397 if (*p > 0)
2398 *p += bit;
2399 else
2400 *p -= bit;
2401 }
2402 } else {
2403 if (r == 0) {
2404 *p = (short) s;
2405 break;
2406 }
2407 --r;
2408 }
2409 }
2410 } while (k <= j->spec_end);
2411 }
2412 }
2413 return 1;
2414}
2415
2416// take a -128..127 value and stbi__clamp it and convert to 0..255
2417stbi_inline static stbi_uc stbi__clamp(int x)
2418{
2419 // trick to use a single test to catch both cases
2420 if ((unsigned int) x > 255) {
2421 if (x < 0) return 0;
2422 if (x > 255) return 255;
2423 }
2424 return (stbi_uc) x;
2425}
2426
2427#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
2428#define stbi__fsh(x) ((x) * 4096)
2429
2430// derived from jidctint -- DCT_ISLOW
2431#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
2432 int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
2433 p2 = s2; \
2434 p3 = s6; \
2435 p1 = (p2+p3) * stbi__f2f(0.5411961f); \
2436 t2 = p1 + p3*stbi__f2f(-1.847759065f); \
2437 t3 = p1 + p2*stbi__f2f( 0.765366865f); \
2438 p2 = s0; \
2439 p3 = s4; \
2440 t0 = stbi__fsh(p2+p3); \
2441 t1 = stbi__fsh(p2-p3); \
2442 x0 = t0+t3; \
2443 x3 = t0-t3; \
2444 x1 = t1+t2; \
2445 x2 = t1-t2; \
2446 t0 = s7; \
2447 t1 = s5; \
2448 t2 = s3; \
2449 t3 = s1; \
2450 p3 = t0+t2; \
2451 p4 = t1+t3; \
2452 p1 = t0+t3; \
2453 p2 = t1+t2; \
2454 p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
2455 t0 = t0*stbi__f2f( 0.298631336f); \
2456 t1 = t1*stbi__f2f( 2.053119869f); \
2457 t2 = t2*stbi__f2f( 3.072711026f); \
2458 t3 = t3*stbi__f2f( 1.501321110f); \
2459 p1 = p5 + p1*stbi__f2f(-0.899976223f); \
2460 p2 = p5 + p2*stbi__f2f(-2.562915447f); \
2461 p3 = p3*stbi__f2f(-1.961570560f); \
2462 p4 = p4*stbi__f2f(-0.390180644f); \
2463 t3 += p1+p4; \
2464 t2 += p2+p3; \
2465 t1 += p2+p4; \
2466 t0 += p1+p3;
2467
2468static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
2469{
2470 int i,val[64],*v=val;
2471 stbi_uc *o;
2472 short *d = data;
2473
2474 // columns
2475 for (i=0; i < 8; ++i,++d, ++v) {
2476 // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
2477 if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
2478 && d[40]==0 && d[48]==0 && d[56]==0) {
2479 // no shortcut 0 seconds
2480 // (1|2|3|4|5|6|7)==0 0 seconds
2481 // all separate -0.047 seconds
2482 // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
2483 int dcterm = d[0]*4;
2484 v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
2485 } else {
2486 STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
2487 // constants scaled things up by 1<<12; let's bring them back
2488 // down, but keep 2 extra bits of precision
2489 x0 += 512; x1 += 512; x2 += 512; x3 += 512;
2490 v[ 0] = (x0+t3) >> 10;
2491 v[56] = (x0-t3) >> 10;
2492 v[ 8] = (x1+t2) >> 10;
2493 v[48] = (x1-t2) >> 10;
2494 v[16] = (x2+t1) >> 10;
2495 v[40] = (x2-t1) >> 10;
2496 v[24] = (x3+t0) >> 10;
2497 v[32] = (x3-t0) >> 10;
2498 }
2499 }
2500
2501 for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
2502 // no fast case since the first 1D IDCT spread components out
2503 STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
2504 // constants scaled things up by 1<<12, plus we had 1<<2 from first
2505 // loop, plus horizontal and vertical each scale by sqrt(8) so together
2506 // we've got an extra 1<<3, so 1<<17 total we need to remove.
2507 // so we want to round that, which means adding 0.5 * 1<<17,
2508 // aka 65536. Also, we'll end up with -128 to 127 that we want
2509 // to encode as 0..255 by adding 128, so we'll add that before the shift
2510 x0 += 65536 + (128<<17);
2511 x1 += 65536 + (128<<17);
2512 x2 += 65536 + (128<<17);
2513 x3 += 65536 + (128<<17);
2514 // tried computing the shifts into temps, or'ing the temps to see
2515 // if any were out of range, but that was slower
2516 o[0] = stbi__clamp((x0+t3) >> 17);
2517 o[7] = stbi__clamp((x0-t3) >> 17);
2518 o[1] = stbi__clamp((x1+t2) >> 17);
2519 o[6] = stbi__clamp((x1-t2) >> 17);
2520 o[2] = stbi__clamp((x2+t1) >> 17);
2521 o[5] = stbi__clamp((x2-t1) >> 17);
2522 o[3] = stbi__clamp((x3+t0) >> 17);
2523 o[4] = stbi__clamp((x3-t0) >> 17);
2524 }
2525}
2526
2527#ifdef STBI_SSE2
2528// sse2 integer IDCT. not the fastest possible implementation but it
2529// produces bit-identical results to the generic C version so it's
2530// fully "transparent".
2531static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
2532{
2533 // This is constructed to match our regular (generic) integer IDCT exactly.
2534 __m128i row0, row1, row2, row3, row4, row5, row6, row7;
2535 __m128i tmp;
2536
2537 // dot product constant: even elems=x, odd elems=y
2538 #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
2539
2540 // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)
2541 // out(1) = c1[even]*x + c1[odd]*y
2542 #define dct_rot(out0,out1, x,y,c0,c1) \
2543 __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
2544 __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
2545 __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
2546 __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
2547 __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
2548 __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
2549
2550 // out = in << 12 (in 16-bit, out 32-bit)
2551 #define dct_widen(out, in) \
2552 __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
2553 __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
2554
2555 // wide add
2556 #define dct_wadd(out, a, b) \
2557 __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
2558 __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
2559
2560 // wide sub
2561 #define dct_wsub(out, a, b) \
2562 __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
2563 __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
2564
2565 // butterfly a/b, add bias, then shift by "s" and pack
2566 #define dct_bfly32o(out0, out1, a,b,bias,s) \
2567 { \
2568 __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
2569 __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
2570 dct_wadd(sum, abiased, b); \
2571 dct_wsub(dif, abiased, b); \
2572 out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
2573 out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
2574 }
2575
2576 // 8-bit interleave step (for transposes)
2577 #define dct_interleave8(a, b) \
2578 tmp = a; \
2579 a = _mm_unpacklo_epi8(a, b); \
2580 b = _mm_unpackhi_epi8(tmp, b)
2581
2582 // 16-bit interleave step (for transposes)
2583 #define dct_interleave16(a, b) \
2584 tmp = a; \
2585 a = _mm_unpacklo_epi16(a, b); \
2586 b = _mm_unpackhi_epi16(tmp, b)
2587
2588 #define dct_pass(bias,shift) \
2589 { \
2590 /* even part */ \
2591 dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
2592 __m128i sum04 = _mm_add_epi16(row0, row4); \
2593 __m128i dif04 = _mm_sub_epi16(row0, row4); \
2594 dct_widen(t0e, sum04); \
2595 dct_widen(t1e, dif04); \
2596 dct_wadd(x0, t0e, t3e); \
2597 dct_wsub(x3, t0e, t3e); \
2598 dct_wadd(x1, t1e, t2e); \
2599 dct_wsub(x2, t1e, t2e); \
2600 /* odd part */ \
2601 dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
2602 dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
2603 __m128i sum17 = _mm_add_epi16(row1, row7); \
2604 __m128i sum35 = _mm_add_epi16(row3, row5); \
2605 dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
2606 dct_wadd(x4, y0o, y4o); \
2607 dct_wadd(x5, y1o, y5o); \
2608 dct_wadd(x6, y2o, y5o); \
2609 dct_wadd(x7, y3o, y4o); \
2610 dct_bfly32o(row0,row7, x0,x7,bias,shift); \
2611 dct_bfly32o(row1,row6, x1,x6,bias,shift); \
2612 dct_bfly32o(row2,row5, x2,x5,bias,shift); \
2613 dct_bfly32o(row3,row4, x3,x4,bias,shift); \
2614 }
2615
2616 __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
2617 __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
2618 __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
2619 __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
2620 __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
2621 __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
2622 __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
2623 __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
2624
2625 // rounding biases in column/row passes, see stbi__idct_block for explanation.
2626 __m128i bias_0 = _mm_set1_epi32(512);
2627 __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
2628
2629 // load
2630 row0 = _mm_load_si128((const __m128i *) (data + 0*8));
2631 row1 = _mm_load_si128((const __m128i *) (data + 1*8));
2632 row2 = _mm_load_si128((const __m128i *) (data + 2*8));
2633 row3 = _mm_load_si128((const __m128i *) (data + 3*8));
2634 row4 = _mm_load_si128((const __m128i *) (data + 4*8));
2635 row5 = _mm_load_si128((const __m128i *) (data + 5*8));
2636 row6 = _mm_load_si128((const __m128i *) (data + 6*8));
2637 row7 = _mm_load_si128((const __m128i *) (data + 7*8));
2638
2639 // column pass
2640 dct_pass(bias_0, 10);
2641
2642 {
2643 // 16bit 8x8 transpose pass 1
2644 dct_interleave16(row0, row4);
2645 dct_interleave16(row1, row5);
2646 dct_interleave16(row2, row6);
2647 dct_interleave16(row3, row7);
2648
2649 // transpose pass 2
2650 dct_interleave16(row0, row2);
2651 dct_interleave16(row1, row3);
2652 dct_interleave16(row4, row6);
2653 dct_interleave16(row5, row7);
2654
2655 // transpose pass 3
2656 dct_interleave16(row0, row1);
2657 dct_interleave16(row2, row3);
2658 dct_interleave16(row4, row5);
2659 dct_interleave16(row6, row7);
2660 }
2661
2662 // row pass
2663 dct_pass(bias_1, 17);
2664
2665 {
2666 // pack
2667 __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
2668 __m128i p1 = _mm_packus_epi16(row2, row3);
2669 __m128i p2 = _mm_packus_epi16(row4, row5);
2670 __m128i p3 = _mm_packus_epi16(row6, row7);
2671
2672 // 8bit 8x8 transpose pass 1
2673 dct_interleave8(p0, p2); // a0e0a1e1...
2674 dct_interleave8(p1, p3); // c0g0c1g1...
2675
2676 // transpose pass 2
2677 dct_interleave8(p0, p1); // a0c0e0g0...
2678 dct_interleave8(p2, p3); // b0d0f0h0...
2679
2680 // transpose pass 3
2681 dct_interleave8(p0, p2); // a0b0c0d0...
2682 dct_interleave8(p1, p3); // a4b4c4d4...
2683
2684 // store
2685 _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
2686 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
2687 _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
2688 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
2689 _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
2690 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
2691 _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
2692 _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
2693 }
2694
2695#undef dct_const
2696#undef dct_rot
2697#undef dct_widen
2698#undef dct_wadd
2699#undef dct_wsub
2700#undef dct_bfly32o
2701#undef dct_interleave8
2702#undef dct_interleave16
2703#undef dct_pass
2704}
2705
2706#endif // STBI_SSE2
2707
2708#ifdef STBI_NEON
2709
2710// NEON integer IDCT. should produce bit-identical
2711// results to the generic C version.
2712static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
2713{
2714 int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
2715
2716 int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
2717 int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
2718 int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
2719 int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
2720 int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
2721 int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
2722 int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
2723 int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
2724 int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
2725 int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
2726 int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
2727 int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
2728
2729#define dct_long_mul(out, inq, coeff) \
2730 int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
2731 int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
2732
2733#define dct_long_mac(out, acc, inq, coeff) \
2734 int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
2735 int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
2736
2737#define dct_widen(out, inq) \
2738 int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
2739 int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
2740
2741// wide add
2742#define dct_wadd(out, a, b) \
2743 int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
2744 int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
2745
2746// wide sub
2747#define dct_wsub(out, a, b) \
2748 int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
2749 int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
2750
2751// butterfly a/b, then shift using "shiftop" by "s" and pack
2752#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
2753 { \
2754 dct_wadd(sum, a, b); \
2755 dct_wsub(dif, a, b); \
2756 out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
2757 out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
2758 }
2759
2760#define dct_pass(shiftop, shift) \
2761 { \
2762 /* even part */ \
2763 int16x8_t sum26 = vaddq_s16(row2, row6); \
2764 dct_long_mul(p1e, sum26, rot0_0); \
2765 dct_long_mac(t2e, p1e, row6, rot0_1); \
2766 dct_long_mac(t3e, p1e, row2, rot0_2); \
2767 int16x8_t sum04 = vaddq_s16(row0, row4); \
2768 int16x8_t dif04 = vsubq_s16(row0, row4); \
2769 dct_widen(t0e, sum04); \
2770 dct_widen(t1e, dif04); \
2771 dct_wadd(x0, t0e, t3e); \
2772 dct_wsub(x3, t0e, t3e); \
2773 dct_wadd(x1, t1e, t2e); \
2774 dct_wsub(x2, t1e, t2e); \
2775 /* odd part */ \
2776 int16x8_t sum15 = vaddq_s16(row1, row5); \
2777 int16x8_t sum17 = vaddq_s16(row1, row7); \
2778 int16x8_t sum35 = vaddq_s16(row3, row5); \
2779 int16x8_t sum37 = vaddq_s16(row3, row7); \
2780 int16x8_t sumodd = vaddq_s16(sum17, sum35); \
2781 dct_long_mul(p5o, sumodd, rot1_0); \
2782 dct_long_mac(p1o, p5o, sum17, rot1_1); \
2783 dct_long_mac(p2o, p5o, sum35, rot1_2); \
2784 dct_long_mul(p3o, sum37, rot2_0); \
2785 dct_long_mul(p4o, sum15, rot2_1); \
2786 dct_wadd(sump13o, p1o, p3o); \
2787 dct_wadd(sump24o, p2o, p4o); \
2788 dct_wadd(sump23o, p2o, p3o); \
2789 dct_wadd(sump14o, p1o, p4o); \
2790 dct_long_mac(x4, sump13o, row7, rot3_0); \
2791 dct_long_mac(x5, sump24o, row5, rot3_1); \
2792 dct_long_mac(x6, sump23o, row3, rot3_2); \
2793 dct_long_mac(x7, sump14o, row1, rot3_3); \
2794 dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
2795 dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
2796 dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
2797 dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
2798 }
2799
2800 // load
2801 row0 = vld1q_s16(data + 0*8);
2802 row1 = vld1q_s16(data + 1*8);
2803 row2 = vld1q_s16(data + 2*8);
2804 row3 = vld1q_s16(data + 3*8);
2805 row4 = vld1q_s16(data + 4*8);
2806 row5 = vld1q_s16(data + 5*8);
2807 row6 = vld1q_s16(data + 6*8);
2808 row7 = vld1q_s16(data + 7*8);
2809
2810 // add DC bias
2811 row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
2812
2813 // column pass
2814 dct_pass(vrshrn_n_s32, 10);
2815
2816 // 16bit 8x8 transpose
2817 {
2818// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
2819// whether compilers actually get this is another story, sadly.
2820#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
2821#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]); }
2822#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)); }
2823
2824 // pass 1
2825 dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
2826 dct_trn16(row2, row3);
2827 dct_trn16(row4, row5);
2828 dct_trn16(row6, row7);
2829
2830 // pass 2
2831 dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
2832 dct_trn32(row1, row3);
2833 dct_trn32(row4, row6);
2834 dct_trn32(row5, row7);
2835
2836 // pass 3
2837 dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
2838 dct_trn64(row1, row5);
2839 dct_trn64(row2, row6);
2840 dct_trn64(row3, row7);
2841
2842#undef dct_trn16
2843#undef dct_trn32
2844#undef dct_trn64
2845 }
2846
2847 // row pass
2848 // vrshrn_n_s32 only supports shifts up to 16, we need
2849 // 17. so do a non-rounding shift of 16 first then follow
2850 // up with a rounding shift by 1.
2851 dct_pass(vshrn_n_s32, 16);
2852
2853 {
2854 // pack and round
2855 uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
2856 uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
2857 uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
2858 uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
2859 uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
2860 uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
2861 uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
2862 uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
2863
2864 // again, these can translate into one instruction, but often don't.
2865#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
2866#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]); }
2867#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]); }
2868
2869 // sadly can't use interleaved stores here since we only write
2870 // 8 bytes to each scan line!
2871
2872 // 8x8 8-bit transpose pass 1
2873 dct_trn8_8(p0, p1);
2874 dct_trn8_8(p2, p3);
2875 dct_trn8_8(p4, p5);
2876 dct_trn8_8(p6, p7);
2877
2878 // pass 2
2879 dct_trn8_16(p0, p2);
2880 dct_trn8_16(p1, p3);
2881 dct_trn8_16(p4, p6);
2882 dct_trn8_16(p5, p7);
2883
2884 // pass 3
2885 dct_trn8_32(p0, p4);
2886 dct_trn8_32(p1, p5);
2887 dct_trn8_32(p2, p6);
2888 dct_trn8_32(p3, p7);
2889
2890 // store
2891 vst1_u8(out, p0); out += out_stride;
2892 vst1_u8(out, p1); out += out_stride;
2893 vst1_u8(out, p2); out += out_stride;
2894 vst1_u8(out, p3); out += out_stride;
2895 vst1_u8(out, p4); out += out_stride;
2896 vst1_u8(out, p5); out += out_stride;
2897 vst1_u8(out, p6); out += out_stride;
2898 vst1_u8(out, p7);
2899
2900#undef dct_trn8_8
2901#undef dct_trn8_16
2902#undef dct_trn8_32
2903 }
2904
2905#undef dct_long_mul
2906#undef dct_long_mac
2907#undef dct_widen
2908#undef dct_wadd
2909#undef dct_wsub
2910#undef dct_bfly32o
2911#undef dct_pass
2912}
2913
2914#endif // STBI_NEON
2915
2916#define STBI__MARKER_none 0xff
2917// if there's a pending marker from the entropy stream, return that
2918// otherwise, fetch from the stream and get a marker. if there's no
2919// marker, return 0xff, which is never a valid marker value
2920static stbi_uc stbi__get_marker(stbi__jpeg *j)
2921{
2922 stbi_uc x;
2923 if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
2924 x = stbi__get8(j->s);
2925 if (x != 0xff) return STBI__MARKER_none;
2926 while (x == 0xff)
2927 x = stbi__get8(j->s); // consume repeated 0xff fill bytes
2928 return x;
2929}
2930
2931// in each scan, we'll have scan_n components, and the order
2932// of the components is specified by order[]
2933#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
2934
2935// after a restart interval, stbi__jpeg_reset the entropy decoder and
2936// the dc prediction
2937static void stbi__jpeg_reset(stbi__jpeg *j)
2938{
2939 j->code_bits = 0;
2940 j->code_buffer = 0;
2941 j->nomore = 0;
2942 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;
2943 j->marker = STBI__MARKER_none;
2944 j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
2945 j->eob_run = 0;
2946 // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
2947 // since we don't even allow 1<<30 pixels
2948}
2949
2950static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
2951{
2952 stbi__jpeg_reset(z);
2953 if (!z->progressive) {
2954 if (z->scan_n == 1) {
2955 int i,j;
2956 STBI_SIMD_ALIGN(short, data[64]);
2957 int n = z->order[0];
2958 // non-interleaved data, we just need to process one block at a time,
2959 // in trivial scanline order
2960 // number of blocks to do just depends on how many actual "pixels" this
2961 // component has, independent of interleaved MCU blocking and such
2962 int w = (z->img_comp[n].x+7) >> 3;
2963 int h = (z->img_comp[n].y+7) >> 3;
2964 for (j=0; j < h; ++j) {
2965 for (i=0; i < w; ++i) {
2966 int ha = z->img_comp[n].ha;
2967 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;
2968 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
2969 // every data block is an MCU, so countdown the restart interval
2970 if (--z->todo <= 0) {
2971 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
2972 // if it's NOT a restart, then just bail, so we get corrupt data
2973 // rather than no data
2974 if (!STBI__RESTART(z->marker)) return 1;
2975 stbi__jpeg_reset(z);
2976 }
2977 }
2978 }
2979 return 1;
2980 } else { // interleaved
2981 int i,j,k,x,y;
2982 STBI_SIMD_ALIGN(short, data[64]);
2983 for (j=0; j < z->img_mcu_y; ++j) {
2984 for (i=0; i < z->img_mcu_x; ++i) {
2985 // scan an interleaved mcu... process scan_n components in order
2986 for (k=0; k < z->scan_n; ++k) {
2987 int n = z->order[k];
2988 // scan out an mcu's worth of this component; that's just determined
2989 // by the basic H and V specified for the component
2990 for (y=0; y < z->img_comp[n].v; ++y) {
2991 for (x=0; x < z->img_comp[n].h; ++x) {
2992 int x2 = (i*z->img_comp[n].h + x)*8;
2993 int y2 = (j*z->img_comp[n].v + y)*8;
2994 int ha = z->img_comp[n].ha;
2995 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;
2996 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
2997 }
2998 }
2999 }
3000 // after all interleaved components, that's an interleaved MCU,
3001 // so now count down the restart interval
3002 if (--z->todo <= 0) {
3003 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3004 if (!STBI__RESTART(z->marker)) return 1;
3005 stbi__jpeg_reset(z);
3006 }
3007 }
3008 }
3009 return 1;
3010 }
3011 } else {
3012 if (z->scan_n == 1) {
3013 int i,j;
3014 int n = z->order[0];
3015 // non-interleaved data, we just need to process one block at a time,
3016 // in trivial scanline order
3017 // number of blocks to do just depends on how many actual "pixels" this
3018 // component has, independent of interleaved MCU blocking and such
3019 int w = (z->img_comp[n].x+7) >> 3;
3020 int h = (z->img_comp[n].y+7) >> 3;
3021 for (j=0; j < h; ++j) {
3022 for (i=0; i < w; ++i) {
3023 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3024 if (z->spec_start == 0) {
3025 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3026 return 0;
3027 } else {
3028 int ha = z->img_comp[n].ha;
3029 if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
3030 return 0;
3031 }
3032 // every data block is an MCU, so countdown the restart interval
3033 if (--z->todo <= 0) {
3034 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3035 if (!STBI__RESTART(z->marker)) return 1;
3036 stbi__jpeg_reset(z);
3037 }
3038 }
3039 }
3040 return 1;
3041 } else { // interleaved
3042 int i,j,k,x,y;
3043 for (j=0; j < z->img_mcu_y; ++j) {
3044 for (i=0; i < z->img_mcu_x; ++i) {
3045 // scan an interleaved mcu... process scan_n components in order
3046 for (k=0; k < z->scan_n; ++k) {
3047 int n = z->order[k];
3048 // scan out an mcu's worth of this component; that's just determined
3049 // by the basic H and V specified for the component
3050 for (y=0; y < z->img_comp[n].v; ++y) {
3051 for (x=0; x < z->img_comp[n].h; ++x) {
3052 int x2 = (i*z->img_comp[n].h + x);
3053 int y2 = (j*z->img_comp[n].v + y);
3054 short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
3055 if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
3056 return 0;
3057 }
3058 }
3059 }
3060 // after all interleaved components, that's an interleaved MCU,
3061 // so now count down the restart interval
3062 if (--z->todo <= 0) {
3063 if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
3064 if (!STBI__RESTART(z->marker)) return 1;
3065 stbi__jpeg_reset(z);
3066 }
3067 }
3068 }
3069 return 1;
3070 }
3071 }
3072}
3073
3074static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
3075{
3076 int i;
3077 for (i=0; i < 64; ++i)
3078 data[i] *= dequant[i];
3079}
3080
3081static void stbi__jpeg_finish(stbi__jpeg *z)
3082{
3083 if (z->progressive) {
3084 // dequantize and idct the data
3085 int i,j,n;
3086 for (n=0; n < z->s->img_n; ++n) {
3087 int w = (z->img_comp[n].x+7) >> 3;
3088 int h = (z->img_comp[n].y+7) >> 3;
3089 for (j=0; j < h; ++j) {
3090 for (i=0; i < w; ++i) {
3091 short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
3092 stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
3093 z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
3094 }
3095 }
3096 }
3097 }
3098}
3099
3100static int stbi__process_marker(stbi__jpeg *z, int m)
3101{
3102 int L;
3103 switch (m) {
3104 case STBI__MARKER_none: // no marker found
3105 return stbi__err("expected marker","Corrupt JPEG");
3106
3107 case 0xDD: // DRI - specify restart interval
3108 if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
3109 z->restart_interval = stbi__get16be(z->s);
3110 return 1;
3111
3112 case 0xDB: // DQT - define quantization table
3113 L = stbi__get16be(z->s)-2;
3114 while (L > 0) {
3115 int q = stbi__get8(z->s);
3116 int p = q >> 4, sixteen = (p != 0);
3117 int t = q & 15,i;
3118 if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
3119 if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
3120
3121 for (i=0; i < 64; ++i)
3122 z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
3123 L -= (sixteen ? 129 : 65);
3124 }
3125 return L==0;
3126
3127 case 0xC4: // DHT - define huffman table
3128 L = stbi__get16be(z->s)-2;
3129 while (L > 0) {
3130 stbi_uc *v;
3131 int sizes[16],i,n=0;
3132 int q = stbi__get8(z->s);
3133 int tc = q >> 4;
3134 int th = q & 15;
3135 if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
3136 for (i=0; i < 16; ++i) {
3137 sizes[i] = stbi__get8(z->s);
3138 n += sizes[i];
3139 }
3140 if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
3141 L -= 17;
3142 if (tc == 0) {
3143 if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
3144 v = z->huff_dc[th].values;
3145 } else {
3146 if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
3147 v = z->huff_ac[th].values;
3148 }
3149 for (i=0; i < n; ++i)
3150 v[i] = stbi__get8(z->s);
3151 if (tc != 0)
3152 stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
3153 L -= n;
3154 }
3155 return L==0;
3156 }
3157
3158 // check for comment block or APP blocks
3159 if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
3160 L = stbi__get16be(z->s);
3161 if (L < 2) {
3162 if (m == 0xFE)
3163 return stbi__err("bad COM len","Corrupt JPEG");
3164 else
3165 return stbi__err("bad APP len","Corrupt JPEG");
3166 }
3167 L -= 2;
3168
3169 if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
3170 static const unsigned char tag[5] = {'J','F','I','F','\0'};
3171 int ok = 1;
3172 int i;
3173 for (i=0; i < 5; ++i)
3174 if (stbi__get8(z->s) != tag[i])
3175 ok = 0;
3176 L -= 5;
3177 if (ok)
3178 z->jfif = 1;
3179 } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
3180 static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
3181 int ok = 1;
3182 int i;
3183 for (i=0; i < 6; ++i)
3184 if (stbi__get8(z->s) != tag[i])
3185 ok = 0;
3186 L -= 6;
3187 if (ok) {
3188 stbi__get8(z->s); // version
3189 stbi__get16be(z->s); // flags0
3190 stbi__get16be(z->s); // flags1
3191 z->app14_color_transform = stbi__get8(z->s); // color transform
3192 L -= 6;
3193 }
3194 }
3195
3196 stbi__skip(z->s, L);
3197 return 1;
3198 }
3199
3200 return stbi__err("unknown marker","Corrupt JPEG");
3201}
3202
3203// after we see SOS
3204static int stbi__process_scan_header(stbi__jpeg *z)
3205{
3206 int i;
3207 int Ls = stbi__get16be(z->s);
3208 z->scan_n = stbi__get8(z->s);
3209 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");
3210 if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
3211 for (i=0; i < z->scan_n; ++i) {
3212 int id = stbi__get8(z->s), which;
3213 int q = stbi__get8(z->s);
3214 for (which = 0; which < z->s->img_n; ++which)
3215 if (z->img_comp[which].id == id)
3216 break;
3217 if (which == z->s->img_n) return 0; // no match
3218 z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
3219 z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
3220 z->order[i] = which;
3221 }
3222
3223 {
3224 int aa;
3225 z->spec_start = stbi__get8(z->s);
3226 z->spec_end = stbi__get8(z->s); // should be 63, but might be 0
3227 aa = stbi__get8(z->s);
3228 z->succ_high = (aa >> 4);
3229 z->succ_low = (aa & 15);
3230 if (z->progressive) {
3231 if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
3232 return stbi__err("bad SOS", "Corrupt JPEG");
3233 } else {
3234 if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
3235 if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
3236 z->spec_end = 63;
3237 }
3238 }
3239
3240 return 1;
3241}
3242
3243static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
3244{
3245 int i;
3246 for (i=0; i < ncomp; ++i) {
3247 if (z->img_comp[i].raw_data) {
3248 STBI_FREE(z->img_comp[i].raw_data);
3249 z->img_comp[i].raw_data = NULL;
3250 z->img_comp[i].data = NULL;
3251 }
3252 if (z->img_comp[i].raw_coeff) {
3253 STBI_FREE(z->img_comp[i].raw_coeff);
3254 z->img_comp[i].raw_coeff = 0;
3255 z->img_comp[i].coeff = 0;
3256 }
3257 if (z->img_comp[i].linebuf) {
3258 STBI_FREE(z->img_comp[i].linebuf);
3259 z->img_comp[i].linebuf = NULL;
3260 }
3261 }
3262 return why;
3263}
3264
3265static int stbi__process_frame_header(stbi__jpeg *z, int scan)
3266{
3267 stbi__context *s = z->s;
3268 int Lf,p,i,q, h_max=1,v_max=1,c;
3269 Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
3270 p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
3271 s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
3272 s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
3273 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
3274 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
3275 c = stbi__get8(s);
3276 if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
3277 s->img_n = c;
3278 for (i=0; i < c; ++i) {
3279 z->img_comp[i].data = NULL;
3280 z->img_comp[i].linebuf = NULL;
3281 }
3282
3283 if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
3284
3285 z->rgb = 0;
3286 for (i=0; i < s->img_n; ++i) {
3287 static const unsigned char rgb[3] = { 'R', 'G', 'B' };
3288 z->img_comp[i].id = stbi__get8(s);
3289 if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
3290 ++z->rgb;
3291 q = stbi__get8(s);
3292 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");
3293 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");
3294 z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
3295 }
3296
3297 if (scan != STBI__SCAN_load) return 1;
3298
3299 if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
3300
3301 for (i=0; i < s->img_n; ++i) {
3302 if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
3303 if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
3304 }
3305
3306 // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
3307 // and I've never seen a non-corrupted JPEG file actually use them
3308 for (i=0; i < s->img_n; ++i) {
3309 if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
3310 if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
3311 }
3312
3313 // compute interleaved mcu info
3314 z->img_h_max = h_max;
3315 z->img_v_max = v_max;
3316 z->img_mcu_w = h_max * 8;
3317 z->img_mcu_h = v_max * 8;
3318 // these sizes can't be more than 17 bits
3319 z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
3320 z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
3321
3322 for (i=0; i < s->img_n; ++i) {
3323 // number of effective pixels (e.g. for non-interleaved MCU)
3324 z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
3325 z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
3326 // to simplify generation, we'll allocate enough memory to decode
3327 // the bogus oversized data from using interleaved MCUs and their
3328 // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
3329 // discard the extra data until colorspace conversion
3330 //
3331 // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
3332 // so these muls can't overflow with 32-bit ints (which we require)
3333 z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
3334 z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
3335 z->img_comp[i].coeff = 0;
3336 z->img_comp[i].raw_coeff = 0;
3337 z->img_comp[i].linebuf = NULL;
3338 z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
3339 if (z->img_comp[i].raw_data == NULL)
3340 return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
3341 // align blocks for idct using mmx/sse
3342 z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
3343 if (z->progressive) {
3344 // w2, h2 are multiples of 8 (see above)
3345 z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
3346 z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
3347 z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
3348 if (z->img_comp[i].raw_coeff == NULL)
3349 return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
3350 z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
3351 }
3352 }
3353
3354 return 1;
3355}
3356
3357// use comparisons since in some cases we handle more than one case (e.g. SOF)
3358#define stbi__DNL(x) ((x) == 0xdc)
3359#define stbi__SOI(x) ((x) == 0xd8)
3360#define stbi__EOI(x) ((x) == 0xd9)
3361#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
3362#define stbi__SOS(x) ((x) == 0xda)
3363
3364#define stbi__SOF_progressive(x) ((x) == 0xc2)
3365
3366static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
3367{
3368 int m;
3369 z->jfif = 0;
3370 z->app14_color_transform = -1; // valid values are 0,1,2
3371 z->marker = STBI__MARKER_none; // initialize cached marker to empty
3372 m = stbi__get_marker(z);
3373 if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
3374 if (scan == STBI__SCAN_type) return 1;
3375 m = stbi__get_marker(z);
3376 while (!stbi__SOF(m)) {
3377 if (!stbi__process_marker(z,m)) return 0;
3378 m = stbi__get_marker(z);
3379 while (m == STBI__MARKER_none) {
3380 // some files have extra padding after their blocks, so ok, we'll scan
3381 if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
3382 m = stbi__get_marker(z);
3383 }
3384 }
3385 z->progressive = stbi__SOF_progressive(m);
3386 if (!stbi__process_frame_header(z, scan)) return 0;
3387 return 1;
3388}
3389
3390static int stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
3391{
3392 // some JPEGs have junk at end, skip over it but if we find what looks
3393 // like a valid marker, resume there
3394 while (!stbi__at_eof(j->s)) {
3395 int x = stbi__get8(j->s);
3396 while (x == 255) { // might be a marker
3397 if (stbi__at_eof(j->s)) return STBI__MARKER_none;
3398 x = stbi__get8(j->s);
3399 if (x != 0x00 && x != 0xff) {
3400 // not a stuffed zero or lead-in to another marker, looks
3401 // like an actual marker, return it
3402 return x;
3403 }
3404 // stuffed zero has x=0 now which ends the loop, meaning we go
3405 // back to regular scan loop.
3406 // repeated 0xff keeps trying to read the next byte of the marker.
3407 }
3408 }
3409 return STBI__MARKER_none;
3410}
3411
3412// decode image to YCbCr format
3413static int stbi__decode_jpeg_image(stbi__jpeg *j)
3414{
3415 int m;
3416 for (m = 0; m < 4; m++) {
3417 j->img_comp[m].raw_data = NULL;
3418 j->img_comp[m].raw_coeff = NULL;
3419 }
3420 j->restart_interval = 0;
3421 if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
3422 m = stbi__get_marker(j);
3423 while (!stbi__EOI(m)) {
3424 if (stbi__SOS(m)) {
3425 if (!stbi__process_scan_header(j)) return 0;
3426 if (!stbi__parse_entropy_coded_data(j)) return 0;
3427 if (j->marker == STBI__MARKER_none ) {
3428 j->marker = stbi__skip_jpeg_junk_at_end(j);
3429 // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
3430 }
3431 m = stbi__get_marker(j);
3432 if (STBI__RESTART(m))
3433 m = stbi__get_marker(j);
3434 } else if (stbi__DNL(m)) {
3435 int Ld = stbi__get16be(j->s);
3436 stbi__uint32 NL = stbi__get16be(j->s);
3437 if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
3438 if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
3439 m = stbi__get_marker(j);
3440 } else {
3441 if (!stbi__process_marker(j, m)) return 1;
3442 m = stbi__get_marker(j);
3443 }
3444 }
3445 if (j->progressive)
3446 stbi__jpeg_finish(j);
3447 return 1;
3448}
3449
3450// static jfif-centered resampling (across block boundaries)
3451
3452typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
3453 int w, int hs);
3454
3455#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
3456
3457static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3458{
3459 STBI_NOTUSED(out);
3460 STBI_NOTUSED(in_far);
3461 STBI_NOTUSED(w);
3462 STBI_NOTUSED(hs);
3463 return in_near;
3464}
3465
3466static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3467{
3468 // need to generate two samples vertically for every one in input
3469 int i;
3470 STBI_NOTUSED(hs);
3471 for (i=0; i < w; ++i)
3472 out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
3473 return out;
3474}
3475
3476static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3477{
3478 // need to generate two samples horizontally for every one in input
3479 int i;
3480 stbi_uc *input = in_near;
3481
3482 if (w == 1) {
3483 // if only one sample, can't do any interpolation
3484 out[0] = out[1] = input[0];
3485 return out;
3486 }
3487
3488 out[0] = input[0];
3489 out[1] = stbi__div4(input[0]*3 + input[1] + 2);
3490 for (i=1; i < w-1; ++i) {
3491 int n = 3*input[i]+2;
3492 out[i*2+0] = stbi__div4(n+input[i-1]);
3493 out[i*2+1] = stbi__div4(n+input[i+1]);
3494 }
3495 out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
3496 out[i*2+1] = input[w-1];
3497
3498 STBI_NOTUSED(in_far);
3499 STBI_NOTUSED(hs);
3500
3501 return out;
3502}
3503
3504#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
3505
3506static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3507{
3508 // need to generate 2x2 samples for every one in input
3509 int i,t0,t1;
3510 if (w == 1) {
3511 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3512 return out;
3513 }
3514
3515 t1 = 3*in_near[0] + in_far[0];
3516 out[0] = stbi__div4(t1+2);
3517 for (i=1; i < w; ++i) {
3518 t0 = t1;
3519 t1 = 3*in_near[i]+in_far[i];
3520 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3521 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3522 }
3523 out[w*2-1] = stbi__div4(t1+2);
3524
3525 STBI_NOTUSED(hs);
3526
3527 return out;
3528}
3529
3530#if defined(STBI_SSE2) || defined(STBI_NEON)
3531static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3532{
3533 // need to generate 2x2 samples for every one in input
3534 int i=0,t0,t1;
3535
3536 if (w == 1) {
3537 out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
3538 return out;
3539 }
3540
3541 t1 = 3*in_near[0] + in_far[0];
3542 // process groups of 8 pixels for as long as we can.
3543 // note we can't handle the last pixel in a row in this loop
3544 // because we need to handle the filter boundary conditions.
3545 for (; i < ((w-1) & ~7); i += 8) {
3546#if defined(STBI_SSE2)
3547 // load and perform the vertical filtering pass
3548 // this uses 3*x + y = 4*x + (y - x)
3549 __m128i zero = _mm_setzero_si128();
3550 __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
3551 __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
3552 __m128i farw = _mm_unpacklo_epi8(farb, zero);
3553 __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
3554 __m128i diff = _mm_sub_epi16(farw, nearw);
3555 __m128i nears = _mm_slli_epi16(nearw, 2);
3556 __m128i curr = _mm_add_epi16(nears, diff); // current row
3557
3558 // horizontal filter works the same based on shifted vers of current
3559 // row. "prev" is current row shifted right by 1 pixel; we need to
3560 // insert the previous pixel value (from t1).
3561 // "next" is current row shifted left by 1 pixel, with first pixel
3562 // of next block of 8 pixels added in.
3563 __m128i prv0 = _mm_slli_si128(curr, 2);
3564 __m128i nxt0 = _mm_srli_si128(curr, 2);
3565 __m128i prev = _mm_insert_epi16(prv0, t1, 0);
3566 __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
3567
3568 // horizontal filter, polyphase implementation since it's convenient:
3569 // even pixels = 3*cur + prev = cur*4 + (prev - cur)
3570 // odd pixels = 3*cur + next = cur*4 + (next - cur)
3571 // note the shared term.
3572 __m128i bias = _mm_set1_epi16(8);
3573 __m128i curs = _mm_slli_epi16(curr, 2);
3574 __m128i prvd = _mm_sub_epi16(prev, curr);
3575 __m128i nxtd = _mm_sub_epi16(next, curr);
3576 __m128i curb = _mm_add_epi16(curs, bias);
3577 __m128i even = _mm_add_epi16(prvd, curb);
3578 __m128i odd = _mm_add_epi16(nxtd, curb);
3579
3580 // interleave even and odd pixels, then undo scaling.
3581 __m128i int0 = _mm_unpacklo_epi16(even, odd);
3582 __m128i int1 = _mm_unpackhi_epi16(even, odd);
3583 __m128i de0 = _mm_srli_epi16(int0, 4);
3584 __m128i de1 = _mm_srli_epi16(int1, 4);
3585
3586 // pack and write output
3587 __m128i outv = _mm_packus_epi16(de0, de1);
3588 _mm_storeu_si128((__m128i *) (out + i*2), outv);
3589#elif defined(STBI_NEON)
3590 // load and perform the vertical filtering pass
3591 // this uses 3*x + y = 4*x + (y - x)
3592 uint8x8_t farb = vld1_u8(in_far + i);
3593 uint8x8_t nearb = vld1_u8(in_near + i);
3594 int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
3595 int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
3596 int16x8_t curr = vaddq_s16(nears, diff); // current row
3597
3598 // horizontal filter works the same based on shifted vers of current
3599 // row. "prev" is current row shifted right by 1 pixel; we need to
3600 // insert the previous pixel value (from t1).
3601 // "next" is current row shifted left by 1 pixel, with first pixel
3602 // of next block of 8 pixels added in.
3603 int16x8_t prv0 = vextq_s16(curr, curr, 7);
3604 int16x8_t nxt0 = vextq_s16(curr, curr, 1);
3605 int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
3606 int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
3607
3608 // horizontal filter, polyphase implementation since it's convenient:
3609 // even pixels = 3*cur + prev = cur*4 + (prev - cur)
3610 // odd pixels = 3*cur + next = cur*4 + (next - cur)
3611 // note the shared term.
3612 int16x8_t curs = vshlq_n_s16(curr, 2);
3613 int16x8_t prvd = vsubq_s16(prev, curr);
3614 int16x8_t nxtd = vsubq_s16(next, curr);
3615 int16x8_t even = vaddq_s16(curs, prvd);
3616 int16x8_t odd = vaddq_s16(curs, nxtd);
3617
3618 // undo scaling and round, then store with even/odd phases interleaved
3619 uint8x8x2_t o;
3620 o.val[0] = vqrshrun_n_s16(even, 4);
3621 o.val[1] = vqrshrun_n_s16(odd, 4);
3622 vst2_u8(out + i*2, o);
3623#endif
3624
3625 // "previous" value for next iter
3626 t1 = 3*in_near[i+7] + in_far[i+7];
3627 }
3628
3629 t0 = t1;
3630 t1 = 3*in_near[i] + in_far[i];
3631 out[i*2] = stbi__div16(3*t1 + t0 + 8);
3632
3633 for (++i; i < w; ++i) {
3634 t0 = t1;
3635 t1 = 3*in_near[i]+in_far[i];
3636 out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
3637 out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
3638 }
3639 out[w*2-1] = stbi__div4(t1+2);
3640
3641 STBI_NOTUSED(hs);
3642
3643 return out;
3644}
3645#endif
3646
3647static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
3648{
3649 // resample with nearest-neighbor
3650 int i,j;
3651 STBI_NOTUSED(in_far);
3652 for (i=0; i < w; ++i)
3653 for (j=0; j < hs; ++j)
3654 out[i*hs+j] = in_near[i];
3655 return out;
3656}
3657
3658// this is a reduced-precision calculation of YCbCr-to-RGB introduced
3659// to make sure the code produces the same results in both SIMD and scalar
3660#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
3661static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
3662{
3663 int i;
3664 for (i=0; i < count; ++i) {
3665 int y_fixed = (y[i] << 20) + (1<<19); // rounding
3666 int r,g,b;
3667 int cr = pcr[i] - 128;
3668 int cb = pcb[i] - 128;
3669 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3670 g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3671 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3672 r >>= 20;
3673 g >>= 20;
3674 b >>= 20;
3675 if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
3676 if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
3677 if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
3678 out[0] = (stbi_uc)r;
3679 out[1] = (stbi_uc)g;
3680 out[2] = (stbi_uc)b;
3681 out[3] = 255;
3682 out += step;
3683 }
3684}
3685
3686#if defined(STBI_SSE2) || defined(STBI_NEON)
3687static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
3688{
3689 int i = 0;
3690
3691#ifdef STBI_SSE2
3692 // step == 3 is pretty ugly on the final interleave, and i'm not convinced
3693 // it's useful in practice (you wouldn't use it for textures, for example).
3694 // so just accelerate step == 4 case.
3695 if (step == 4) {
3696 // this is a fairly straightforward implementation and not super-optimized.
3697 __m128i signflip = _mm_set1_epi8(-0x80);
3698 __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));
3699 __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
3700 __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
3701 __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));
3702 __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
3703 __m128i xw = _mm_set1_epi16(255); // alpha channel
3704
3705 for (; i+7 < count; i += 8) {
3706 // load
3707 __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
3708 __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
3709 __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
3710 __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
3711 __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
3712
3713 // unpack to short (and left-shift cr, cb by 8)
3714 __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);
3715 __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
3716 __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
3717
3718 // color transform
3719 __m128i yws = _mm_srli_epi16(yw, 4);
3720 __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
3721 __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
3722 __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
3723 __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
3724 __m128i rws = _mm_add_epi16(cr0, yws);
3725 __m128i gwt = _mm_add_epi16(cb0, yws);
3726 __m128i bws = _mm_add_epi16(yws, cb1);
3727 __m128i gws = _mm_add_epi16(gwt, cr1);
3728
3729 // descale
3730 __m128i rw = _mm_srai_epi16(rws, 4);
3731 __m128i bw = _mm_srai_epi16(bws, 4);
3732 __m128i gw = _mm_srai_epi16(gws, 4);
3733
3734 // back to byte, set up for transpose
3735 __m128i brb = _mm_packus_epi16(rw, bw);
3736 __m128i gxb = _mm_packus_epi16(gw, xw);
3737
3738 // transpose to interleave channels
3739 __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
3740 __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
3741 __m128i o0 = _mm_unpacklo_epi16(t0, t1);
3742 __m128i o1 = _mm_unpackhi_epi16(t0, t1);
3743
3744 // store
3745 _mm_storeu_si128((__m128i *) (out + 0), o0);
3746 _mm_storeu_si128((__m128i *) (out + 16), o1);
3747 out += 32;
3748 }
3749 }
3750#endif
3751
3752#ifdef STBI_NEON
3753 // in this version, step=3 support would be easy to add. but is there demand?
3754 if (step == 4) {
3755 // this is a fairly straightforward implementation and not super-optimized.
3756 uint8x8_t signflip = vdup_n_u8(0x80);
3757 int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));
3758 int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
3759 int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
3760 int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));
3761
3762 for (; i+7 < count; i += 8) {
3763 // load
3764 uint8x8_t y_bytes = vld1_u8(y + i);
3765 uint8x8_t cr_bytes = vld1_u8(pcr + i);
3766 uint8x8_t cb_bytes = vld1_u8(pcb + i);
3767 int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
3768 int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
3769
3770 // expand to s16
3771 int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
3772 int16x8_t crw = vshll_n_s8(cr_biased, 7);
3773 int16x8_t cbw = vshll_n_s8(cb_biased, 7);
3774
3775 // color transform
3776 int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
3777 int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
3778 int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
3779 int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
3780 int16x8_t rws = vaddq_s16(yws, cr0);
3781 int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
3782 int16x8_t bws = vaddq_s16(yws, cb1);
3783
3784 // undo scaling, round, convert to byte
3785 uint8x8x4_t o;
3786 o.val[0] = vqrshrun_n_s16(rws, 4);
3787 o.val[1] = vqrshrun_n_s16(gws, 4);
3788 o.val[2] = vqrshrun_n_s16(bws, 4);
3789 o.val[3] = vdup_n_u8(255);
3790
3791 // store, interleaving r/g/b/a
3792 vst4_u8(out, o);
3793 out += 8*4;
3794 }
3795 }
3796#endif
3797
3798 for (; i < count; ++i) {
3799 int y_fixed = (y[i] << 20) + (1<<19); // rounding
3800 int r,g,b;
3801 int cr = pcr[i] - 128;
3802 int cb = pcb[i] - 128;
3803 r = y_fixed + cr* stbi__float2fixed(1.40200f);
3804 g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
3805 b = y_fixed + cb* stbi__float2fixed(1.77200f);
3806 r >>= 20;
3807 g >>= 20;
3808 b >>= 20;
3809 if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
3810 if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
3811 if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
3812 out[0] = (stbi_uc)r;
3813 out[1] = (stbi_uc)g;
3814 out[2] = (stbi_uc)b;
3815 out[3] = 255;
3816 out += step;
3817 }
3818}
3819#endif
3820
3821// set up the kernels
3822static void stbi__setup_jpeg(stbi__jpeg *j)
3823{
3824 j->idct_block_kernel = stbi__idct_block;
3825 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
3826 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
3827
3828#ifdef STBI_SSE2
3829 if (stbi__sse2_available()) {
3830 j->idct_block_kernel = stbi__idct_simd;
3831 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3832 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3833 }
3834#endif
3835
3836#ifdef STBI_NEON
3837 j->idct_block_kernel = stbi__idct_simd;
3838 j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
3839 j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
3840#endif
3841}
3842
3843// clean up the temporary component buffers
3844static void stbi__cleanup_jpeg(stbi__jpeg *j)
3845{
3846 stbi__free_jpeg_components(j, j->s->img_n, 0);
3847}
3848
3849typedef struct
3850{
3851 resample_row_func resample;
3852 stbi_uc *line0,*line1;
3853 int hs,vs; // expansion factor in each axis
3854 int w_lores; // horizontal pixels pre-expansion
3855 int ystep; // how far through vertical expansion we are
3856 int ypos; // which pre-expansion row we're on
3857} stbi__resample;
3858
3859// fast 0..255 * 0..255 => 0..255 rounded multiplication
3860static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
3861{
3862 unsigned int t = x*y + 128;
3863 return (stbi_uc) ((t + (t >>8)) >> 8);
3864}
3865
3866static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
3867{
3868 int n, decode_n, is_rgb;
3869 z->s->img_n = 0; // make stbi__cleanup_jpeg safe
3870
3871 // validate req_comp
3872 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
3873
3874 // load a jpeg image from whichever source, but leave in YCbCr format
3875 if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
3876
3877 // determine actual number of components to generate
3878 n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
3879
3880 is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
3881
3882 if (z->s->img_n == 3 && n < 3 && !is_rgb)
3883 decode_n = 1;
3884 else
3885 decode_n = z->s->img_n;
3886
3887 // nothing to do if no components requested; check this now to avoid
3888 // accessing uninitialized coutput[0] later
3889 if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
3890
3891 // resample and color-convert
3892 {
3893 int k;
3894 unsigned int i,j;
3895 stbi_uc *output;
3896 stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
3897
3898 stbi__resample res_comp[4];
3899
3900 for (k=0; k < decode_n; ++k) {
3901 stbi__resample *r = &res_comp[k];
3902
3903 // allocate line buffer big enough for upsampling off the edges
3904 // with upsample factor of 4
3905 z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
3906 if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
3907
3908 r->hs = z->img_h_max / z->img_comp[k].h;
3909 r->vs = z->img_v_max / z->img_comp[k].v;
3910 r->ystep = r->vs >> 1;
3911 r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
3912 r->ypos = 0;
3913 r->line0 = r->line1 = z->img_comp[k].data;
3914
3915 if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
3916 else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
3917 else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
3918 else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
3919 else r->resample = stbi__resample_row_generic;
3920 }
3921
3922 // can't error after this so, this is safe
3923 output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
3924 if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
3925
3926 // now go ahead and resample
3927 for (j=0; j < z->s->img_y; ++j) {
3928 stbi_uc *out = output + n * z->s->img_x * j;
3929 for (k=0; k < decode_n; ++k) {
3930 stbi__resample *r = &res_comp[k];
3931 int y_bot = r->ystep >= (r->vs >> 1);
3932 coutput[k] = r->resample(z->img_comp[k].linebuf,
3933 y_bot ? r->line1 : r->line0,
3934 y_bot ? r->line0 : r->line1,
3935 r->w_lores, r->hs);
3936 if (++r->ystep >= r->vs) {
3937 r->ystep = 0;
3938 r->line0 = r->line1;
3939 if (++r->ypos < z->img_comp[k].y)
3940 r->line1 += z->img_comp[k].w2;
3941 }
3942 }
3943 if (n >= 3) {
3944 stbi_uc *y = coutput[0];
3945 if (z->s->img_n == 3) {
3946 if (is_rgb) {
3947 for (i=0; i < z->s->img_x; ++i) {
3948 out[0] = y[i];
3949 out[1] = coutput[1][i];
3950 out[2] = coutput[2][i];
3951 out[3] = 255;
3952 out += n;
3953 }
3954 } else {
3955 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3956 }
3957 } else if (z->s->img_n == 4) {
3958 if (z->app14_color_transform == 0) { // CMYK
3959 for (i=0; i < z->s->img_x; ++i) {
3960 stbi_uc m = coutput[3][i];
3961 out[0] = stbi__blinn_8x8(coutput[0][i], m);
3962 out[1] = stbi__blinn_8x8(coutput[1][i], m);
3963 out[2] = stbi__blinn_8x8(coutput[2][i], m);
3964 out[3] = 255;
3965 out += n;
3966 }
3967 } else if (z->app14_color_transform == 2) { // YCCK
3968 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3969 for (i=0; i < z->s->img_x; ++i) {
3970 stbi_uc m = coutput[3][i];
3971 out[0] = stbi__blinn_8x8(255 - out[0], m);
3972 out[1] = stbi__blinn_8x8(255 - out[1], m);
3973 out[2] = stbi__blinn_8x8(255 - out[2], m);
3974 out += n;
3975 }
3976 } else { // YCbCr + alpha? Ignore the fourth channel for now
3977 z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
3978 }
3979 } else
3980 for (i=0; i < z->s->img_x; ++i) {
3981 out[0] = out[1] = out[2] = y[i];
3982 out[3] = 255; // not used if n==3
3983 out += n;
3984 }
3985 } else {
3986 if (is_rgb) {
3987 if (n == 1)
3988 for (i=0; i < z->s->img_x; ++i)
3989 *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3990 else {
3991 for (i=0; i < z->s->img_x; ++i, out += 2) {
3992 out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
3993 out[1] = 255;
3994 }
3995 }
3996 } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
3997 for (i=0; i < z->s->img_x; ++i) {
3998 stbi_uc m = coutput[3][i];
3999 stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
4000 stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
4001 stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
4002 out[0] = stbi__compute_y(r, g, b);
4003 out[1] = 255;
4004 out += n;
4005 }
4006 } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
4007 for (i=0; i < z->s->img_x; ++i) {
4008 out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
4009 out[1] = 255;
4010 out += n;
4011 }
4012 } else {
4013 stbi_uc *y = coutput[0];
4014 if (n == 1)
4015 for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
4016 else
4017 for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
4018 }
4019 }
4020 }
4021 stbi__cleanup_jpeg(z);
4022 *out_x = z->s->img_x;
4023 *out_y = z->s->img_y;
4024 if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
4025 return output;
4026 }
4027}
4028
4029static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
4030{
4031 unsigned char* result;
4032 stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
4033 if (!j) return stbi__errpuc("outofmem", "Out of memory");
4034 memset(j, 0, sizeof(stbi__jpeg));
4035 STBI_NOTUSED(ri);
4036 j->s = s;
4037 stbi__setup_jpeg(j);
4038 result = load_jpeg_image(j, x,y,comp,req_comp);
4039 STBI_FREE(j);
4040 return result;
4041}
4042
4043static int stbi__jpeg_test(stbi__context *s)
4044{
4045 int r;
4046 stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
4047 if (!j) return stbi__err("outofmem", "Out of memory");
4048 memset(j, 0, sizeof(stbi__jpeg));
4049 j->s = s;
4050 stbi__setup_jpeg(j);
4051 r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
4052 stbi__rewind(s);
4053 STBI_FREE(j);
4054 return r;
4055}
4056
4057static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
4058{
4059 if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
4060 stbi__rewind( j->s );
4061 return 0;
4062 }
4063 if (x) *x = j->s->img_x;
4064 if (y) *y = j->s->img_y;
4065 if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
4066 return 1;
4067}
4068
4069static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
4070{
4071 int result;
4072 stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
4073 if (!j) return stbi__err("outofmem", "Out of memory");
4074 memset(j, 0, sizeof(stbi__jpeg));
4075 j->s = s;
4076 result = stbi__jpeg_info_raw(j, x, y, comp);
4077 STBI_FREE(j);
4078 return result;
4079}
4080#endif
4081
4082// public domain zlib decode v0.2 Sean Barrett 2006-11-18
4083// simple implementation
4084// - all input must be provided in an upfront buffer
4085// - all output is written to a single output buffer (can malloc/realloc)
4086// performance
4087// - fast huffman
4088
4089#ifndef STBI_NO_ZLIB
4090
4091// fast-way is faster to check than jpeg huffman, but slow way is slower
4092#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
4093#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
4094#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
4095
4096// zlib-style huffman encoding
4097// (jpegs packs from left, zlib from right, so can't share code)
4098typedef struct
4099{
4100 stbi__uint16 fast[1 << STBI__ZFAST_BITS];
4101 stbi__uint16 firstcode[16];
4102 int maxcode[17];
4103 stbi__uint16 firstsymbol[16];
4104 stbi_uc size[STBI__ZNSYMS];
4105 stbi__uint16 value[STBI__ZNSYMS];
4106} stbi__zhuffman;
4107
4108stbi_inline static int stbi__bitreverse16(int n)
4109{
4110 n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
4111 n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
4112 n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
4113 n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
4114 return n;
4115}
4116
4117stbi_inline static int stbi__bit_reverse(int v, int bits)
4118{
4119 STBI_ASSERT(bits <= 16);
4120 // to bit reverse n bits, reverse 16 and shift
4121 // e.g. 11 bits, bit reverse and shift away 5
4122 return stbi__bitreverse16(v) >> (16-bits);
4123}
4124
4125static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
4126{
4127 int i,k=0;
4128 int code, next_code[16], sizes[17];
4129
4130 // DEFLATE spec for generating codes
4131 memset(sizes, 0, sizeof(sizes));
4132 memset(z->fast, 0, sizeof(z->fast));
4133 for (i=0; i < num; ++i)
4134 ++sizes[sizelist[i]];
4135 sizes[0] = 0;
4136 for (i=1; i < 16; ++i)
4137 if (sizes[i] > (1 << i))
4138 return stbi__err("bad sizes", "Corrupt PNG");
4139 code = 0;
4140 for (i=1; i < 16; ++i) {
4141 next_code[i] = code;
4142 z->firstcode[i] = (stbi__uint16) code;
4143 z->firstsymbol[i] = (stbi__uint16) k;
4144 code = (code + sizes[i]);
4145 if (sizes[i])
4146 if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
4147 z->maxcode[i] = code << (16-i); // preshift for inner loop
4148 code <<= 1;
4149 k += sizes[i];
4150 }
4151 z->maxcode[16] = 0x10000; // sentinel
4152 for (i=0; i < num; ++i) {
4153 int s = sizelist[i];
4154 if (s) {
4155 int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
4156 stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
4157 z->size [c] = (stbi_uc ) s;
4158 z->value[c] = (stbi__uint16) i;
4159 if (s <= STBI__ZFAST_BITS) {
4160 int j = stbi__bit_reverse(next_code[s],s);
4161 while (j < (1 << STBI__ZFAST_BITS)) {
4162 z->fast[j] = fastv;
4163 j += (1 << s);
4164 }
4165 }
4166 ++next_code[s];
4167 }
4168 }
4169 return 1;
4170}
4171
4172// zlib-from-memory implementation for PNG reading
4173// because PNG allows splitting the zlib stream arbitrarily,
4174// and it's annoying structurally to have PNG call ZLIB call PNG,
4175// we require PNG read all the IDATs and combine them into a single
4176// memory buffer
4177
4178typedef struct
4179{
4180 stbi_uc *zbuffer, *zbuffer_end;
4181 int num_bits;
4182 stbi__uint32 code_buffer;
4183
4184 char *zout;
4185 char *zout_start;
4186 char *zout_end;
4187 int z_expandable;
4188
4189 stbi__zhuffman z_length, z_distance;
4190} stbi__zbuf;
4191
4192stbi_inline static int stbi__zeof(stbi__zbuf *z)
4193{
4194 return (z->zbuffer >= z->zbuffer_end);
4195}
4196
4197stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
4198{
4199 return stbi__zeof(z) ? 0 : *z->zbuffer++;
4200}
4201
4202static void stbi__fill_bits(stbi__zbuf *z)
4203{
4204 do {
4205 if (z->code_buffer >= (1U << z->num_bits)) {
4206 z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
4207 return;
4208 }
4209 z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
4210 z->num_bits += 8;
4211 } while (z->num_bits <= 24);
4212}
4213
4214stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
4215{
4216 unsigned int k;
4217 if (z->num_bits < n) stbi__fill_bits(z);
4218 k = z->code_buffer & ((1 << n) - 1);
4219 z->code_buffer >>= n;
4220 z->num_bits -= n;
4221 return k;
4222}
4223
4224static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
4225{
4226 int b,s,k;
4227 // not resolved by fast table, so compute it the slow way
4228 // use jpeg approach, which requires MSbits at top
4229 k = stbi__bit_reverse(a->code_buffer, 16);
4230 for (s=STBI__ZFAST_BITS+1; ; ++s)
4231 if (k < z->maxcode[s])
4232 break;
4233 if (s >= 16) return -1; // invalid code!
4234 // code size is s, so:
4235 b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
4236 if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
4237 if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.
4238 a->code_buffer >>= s;
4239 a->num_bits -= s;
4240 return z->value[b];
4241}
4242
4243stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
4244{
4245 int b,s;
4246 if (a->num_bits < 16) {
4247 if (stbi__zeof(a)) {
4248 return -1; /* report error for unexpected end of data. */
4249 }
4250 stbi__fill_bits(a);
4251 }
4252 b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
4253 if (b) {
4254 s = b >> 9;
4255 a->code_buffer >>= s;
4256 a->num_bits -= s;
4257 return b & 511;
4258 }
4259 return stbi__zhuffman_decode_slowpath(a, z);
4260}
4261
4262static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
4263{
4264 char *q;
4265 unsigned int cur, limit, old_limit;
4266 z->zout = zout;
4267 if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
4268 cur = (unsigned int) (z->zout - z->zout_start);
4269 limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
4270 if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
4271 while (cur + n > limit) {
4272 if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
4273 limit *= 2;
4274 }
4275 q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
4276 STBI_NOTUSED(old_limit);
4277 if (q == NULL) return stbi__err("outofmem", "Out of memory");
4278 z->zout_start = q;
4279 z->zout = q + cur;
4280 z->zout_end = q + limit;
4281 return 1;
4282}
4283
4284static const int stbi__zlength_base[31] = {
4285 3,4,5,6,7,8,9,10,11,13,
4286 15,17,19,23,27,31,35,43,51,59,
4287 67,83,99,115,131,163,195,227,258,0,0 };
4288
4289static const int stbi__zlength_extra[31]=
4290{ 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 };
4291
4292static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
4293257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
4294
4295static const int stbi__zdist_extra[32] =
4296{ 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};
4297
4298static int stbi__parse_huffman_block(stbi__zbuf *a)
4299{
4300 char *zout = a->zout;
4301 for(;;) {
4302 int z = stbi__zhuffman_decode(a, &a->z_length);
4303 if (z < 256) {
4304 if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
4305 if (zout >= a->zout_end) {
4306 if (!stbi__zexpand(a, zout, 1)) return 0;
4307 zout = a->zout;
4308 }
4309 *zout++ = (char) z;
4310 } else {
4311 stbi_uc *p;
4312 int len,dist;
4313 if (z == 256) {
4314 a->zout = zout;
4315 return 1;
4316 }
4317 if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
4318 z -= 257;
4319 len = stbi__zlength_base[z];
4320 if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
4321 z = stbi__zhuffman_decode(a, &a->z_distance);
4322 if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
4323 dist = stbi__zdist_base[z];
4324 if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
4325 if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
4326 if (zout + len > a->zout_end) {
4327 if (!stbi__zexpand(a, zout, len)) return 0;
4328 zout = a->zout;
4329 }
4330 p = (stbi_uc *) (zout - dist);
4331 if (dist == 1) { // run of one byte; common in images.
4332 stbi_uc v = *p;
4333 if (len) { do *zout++ = v; while (--len); }
4334 } else {
4335 if (len) { do *zout++ = *p++; while (--len); }
4336 }
4337 }
4338 }
4339}
4340
4341static int stbi__compute_huffman_codes(stbi__zbuf *a)
4342{
4343 static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
4344 stbi__zhuffman z_codelength;
4345 stbi_uc lencodes[286+32+137];//padding for maximum single op
4346 stbi_uc codelength_sizes[19];
4347 int i,n;
4348
4349 int hlit = stbi__zreceive(a,5) + 257;
4350 int hdist = stbi__zreceive(a,5) + 1;
4351 int hclen = stbi__zreceive(a,4) + 4;
4352 int ntot = hlit + hdist;
4353
4354 memset(codelength_sizes, 0, sizeof(codelength_sizes));
4355 for (i=0; i < hclen; ++i) {
4356 int s = stbi__zreceive(a,3);
4357 codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
4358 }
4359 if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
4360
4361 n = 0;
4362 while (n < ntot) {
4363 int c = stbi__zhuffman_decode(a, &z_codelength);
4364 if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
4365 if (c < 16)
4366 lencodes[n++] = (stbi_uc) c;
4367 else {
4368 stbi_uc fill = 0;
4369 if (c == 16) {
4370 c = stbi__zreceive(a,2)+3;
4371 if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
4372 fill = lencodes[n-1];
4373 } else if (c == 17) {
4374 c = stbi__zreceive(a,3)+3;
4375 } else if (c == 18) {
4376 c = stbi__zreceive(a,7)+11;
4377 } else {
4378 return stbi__err("bad codelengths", "Corrupt PNG");
4379 }
4380 if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
4381 memset(lencodes+n, fill, c);
4382 n += c;
4383 }
4384 }
4385 if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
4386 if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
4387 if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
4388 return 1;
4389}
4390
4391static int stbi__parse_uncompressed_block(stbi__zbuf *a)
4392{
4393 stbi_uc header[4];
4394 int len,nlen,k;
4395 if (a->num_bits & 7)
4396 stbi__zreceive(a, a->num_bits & 7); // discard
4397 // drain the bit-packed data into header
4398 k = 0;
4399 while (a->num_bits > 0) {
4400 header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
4401 a->code_buffer >>= 8;
4402 a->num_bits -= 8;
4403 }
4404 if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
4405 // now fill header the normal way
4406 while (k < 4)
4407 header[k++] = stbi__zget8(a);
4408 len = header[1] * 256 + header[0];
4409 nlen = header[3] * 256 + header[2];
4410 if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
4411 if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
4412 if (a->zout + len > a->zout_end)
4413 if (!stbi__zexpand(a, a->zout, len)) return 0;
4414 memcpy(a->zout, a->zbuffer, len);
4415 a->zbuffer += len;
4416 a->zout += len;
4417 return 1;
4418}
4419
4420static int stbi__parse_zlib_header(stbi__zbuf *a)
4421{
4422 int cmf = stbi__zget8(a);
4423 int cm = cmf & 15;
4424 /* int cinfo = cmf >> 4; */
4425 int flg = stbi__zget8(a);
4426 if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
4427 if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
4428 if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
4429 if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
4430 // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
4431 return 1;
4432}
4433
4434static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
4435{
4436 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4437 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4438 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4439 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4440 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,
4441 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4442 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4443 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4444 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
4445};
4446static const stbi_uc stbi__zdefault_distance[32] =
4447{
4448 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
4449};
4450/*
4451Init algorithm:
4452{
4453 int i; // use <= to match clearly with spec
4454 for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;
4455 for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;
4456 for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;
4457 for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;
4458
4459 for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;
4460}
4461*/
4462
4463static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
4464{
4465 int final, type;
4466 if (parse_header)
4467 if (!stbi__parse_zlib_header(a)) return 0;
4468 a->num_bits = 0;
4469 a->code_buffer = 0;
4470 do {
4471 final = stbi__zreceive(a,1);
4472 type = stbi__zreceive(a,2);
4473 if (type == 0) {
4474 if (!stbi__parse_uncompressed_block(a)) return 0;
4475 } else if (type == 3) {
4476 return 0;
4477 } else {
4478 if (type == 1) {
4479 // use fixed code lengths
4480 if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0;
4481 if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;
4482 } else {
4483 if (!stbi__compute_huffman_codes(a)) return 0;
4484 }
4485 if (!stbi__parse_huffman_block(a)) return 0;
4486 }
4487 } while (!final);
4488 return 1;
4489}
4490
4491static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
4492{
4493 a->zout_start = obuf;
4494 a->zout = obuf;
4495 a->zout_end = obuf + olen;
4496 a->z_expandable = exp;
4497
4498 return stbi__parse_zlib(a, parse_header);
4499}
4500
4501STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
4502{
4503 stbi__zbuf a;
4504 char *p = (char *) stbi__malloc(initial_size);
4505 if (p == NULL) return NULL;
4506 a.zbuffer = (stbi_uc *) buffer;
4507 a.zbuffer_end = (stbi_uc *) buffer + len;
4508 if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
4509 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4510 return a.zout_start;
4511 } else {
4512 STBI_FREE(a.zout_start);
4513 return NULL;
4514 }
4515}
4516
4517STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
4518{
4519 return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
4520}
4521
4522STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
4523{
4524 stbi__zbuf a;
4525 char *p = (char *) stbi__malloc(initial_size);
4526 if (p == NULL) return NULL;
4527 a.zbuffer = (stbi_uc *) buffer;
4528 a.zbuffer_end = (stbi_uc *) buffer + len;
4529 if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
4530 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4531 return a.zout_start;
4532 } else {
4533 STBI_FREE(a.zout_start);
4534 return NULL;
4535 }
4536}
4537
4538STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
4539{
4540 stbi__zbuf a;
4541 a.zbuffer = (stbi_uc *) ibuffer;
4542 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
4543 if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
4544 return (int) (a.zout - a.zout_start);
4545 else
4546 return -1;
4547}
4548
4549STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
4550{
4551 stbi__zbuf a;
4552 char *p = (char *) stbi__malloc(16384);
4553 if (p == NULL) return NULL;
4554 a.zbuffer = (stbi_uc *) buffer;
4555 a.zbuffer_end = (stbi_uc *) buffer+len;
4556 if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
4557 if (outlen) *outlen = (int) (a.zout - a.zout_start);
4558 return a.zout_start;
4559 } else {
4560 STBI_FREE(a.zout_start);
4561 return NULL;
4562 }
4563}
4564
4565STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
4566{
4567 stbi__zbuf a;
4568 a.zbuffer = (stbi_uc *) ibuffer;
4569 a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
4570 if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
4571 return (int) (a.zout - a.zout_start);
4572 else
4573 return -1;
4574}
4575#endif
4576
4577// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
4578// simple implementation
4579// - only 8-bit samples
4580// - no CRC checking
4581// - allocates lots of intermediate memory
4582// - avoids problem of streaming data between subsystems
4583// - avoids explicit window management
4584// performance
4585// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
4586
4587#ifndef STBI_NO_PNG
4588typedef struct
4589{
4590 stbi__uint32 length;
4591 stbi__uint32 type;
4592} stbi__pngchunk;
4593
4594static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
4595{
4596 stbi__pngchunk c;
4597 c.length = stbi__get32be(s);
4598 c.type = stbi__get32be(s);
4599 return c;
4600}
4601
4602static int stbi__check_png_header(stbi__context *s)
4603{
4604 static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
4605 int i;
4606 for (i=0; i < 8; ++i)
4607 if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
4608 return 1;
4609}
4610
4611typedef struct
4612{
4613 stbi__context *s;
4614 stbi_uc *idata, *expanded, *out;
4615 int depth;
4616} stbi__png;
4617
4618
4619enum {
4620 STBI__F_none=0,
4621 STBI__F_sub=1,
4622 STBI__F_up=2,
4623 STBI__F_avg=3,
4624 STBI__F_paeth=4,
4625 // synthetic filters used for first scanline to avoid needing a dummy row of 0s
4626 STBI__F_avg_first,
4627 STBI__F_paeth_first
4628};
4629
4630static stbi_uc first_row_filter[5] =
4631{
4632 STBI__F_none,
4633 STBI__F_sub,
4634 STBI__F_none,
4635 STBI__F_avg_first,
4636 STBI__F_paeth_first
4637};
4638
4639static int stbi__paeth(int a, int b, int c)
4640{
4641 int p = a + b - c;
4642 int pa = abs(p-a);
4643 int pb = abs(p-b);
4644 int pc = abs(p-c);
4645 if (pa <= pb && pa <= pc) return a;
4646 if (pb <= pc) return b;
4647 return c;
4648}
4649
4650static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
4651
4652// create the png data from post-deflated data
4653static 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)
4654{
4655 int bytes = (depth == 16? 2 : 1);
4656 stbi__context *s = a->s;
4657 stbi__uint32 i,j,stride = x*out_n*bytes;
4658 stbi__uint32 img_len, img_width_bytes;
4659 int k;
4660 int img_n = s->img_n; // copy it into a local for later
4661
4662 int output_bytes = out_n*bytes;
4663 int filter_bytes = img_n*bytes;
4664 int width = x;
4665
4666 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
4667 a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
4668 if (!a->out) return stbi__err("outofmem", "Out of memory");
4669
4670 if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
4671 img_width_bytes = (((img_n * x * depth) + 7) >> 3);
4672 img_len = (img_width_bytes + 1) * y;
4673
4674 // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
4675 // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
4676 // so just check for raw_len < img_len always.
4677 if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
4678
4679 for (j=0; j < y; ++j) {
4680 stbi_uc *cur = a->out + stride*j;
4681 stbi_uc *prior;
4682 int filter = *raw++;
4683
4684 if (filter > 4)
4685 return stbi__err("invalid filter","Corrupt PNG");
4686
4687 if (depth < 8) {
4688 if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");
4689 cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place
4690 filter_bytes = 1;
4691 width = img_width_bytes;
4692 }
4693 prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above
4694
4695 // if first row, use special filter that doesn't sample previous row
4696 if (j == 0) filter = first_row_filter[filter];
4697
4698 // handle first byte explicitly
4699 for (k=0; k < filter_bytes; ++k) {
4700 switch (filter) {
4701 case STBI__F_none : cur[k] = raw[k]; break;
4702 case STBI__F_sub : cur[k] = raw[k]; break;
4703 case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
4704 case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
4705 case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;
4706 case STBI__F_avg_first : cur[k] = raw[k]; break;
4707 case STBI__F_paeth_first: cur[k] = raw[k]; break;
4708 }
4709 }
4710
4711 if (depth == 8) {
4712 if (img_n != out_n)
4713 cur[img_n] = 255; // first pixel
4714 raw += img_n;
4715 cur += out_n;
4716 prior += out_n;
4717 } else if (depth == 16) {
4718 if (img_n != out_n) {
4719 cur[filter_bytes] = 255; // first pixel top byte
4720 cur[filter_bytes+1] = 255; // first pixel bottom byte
4721 }
4722 raw += filter_bytes;
4723 cur += output_bytes;
4724 prior += output_bytes;
4725 } else {
4726 raw += 1;
4727 cur += 1;
4728 prior += 1;
4729 }
4730
4731 // this is a little gross, so that we don't switch per-pixel or per-component
4732 if (depth < 8 || img_n == out_n) {
4733 int nk = (width - 1)*filter_bytes;
4734 #define STBI__CASE(f) \
4735 case f: \
4736 for (k=0; k < nk; ++k)
4737 switch (filter) {
4738 // "none" filter turns into a memcpy here; make that explicit.
4739 case STBI__F_none: memcpy(cur, raw, nk); break;
4740 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
4741 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
4742 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
4743 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
4744 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
4745 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;
4746 }
4747 #undef STBI__CASE
4748 raw += nk;
4749 } else {
4750 STBI_ASSERT(img_n+1 == out_n);
4751 #define STBI__CASE(f) \
4752 case f: \
4753 for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
4754 for (k=0; k < filter_bytes; ++k)
4755 switch (filter) {
4756 STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break;
4757 STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
4758 STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
4759 STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
4760 STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
4761 STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
4762 STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;
4763 }
4764 #undef STBI__CASE
4765
4766 // the loop above sets the high byte of the pixels' alpha, but for
4767 // 16 bit png files we also need the low byte set. we'll do that here.
4768 if (depth == 16) {
4769 cur = a->out + stride*j; // start at the beginning of the row again
4770 for (i=0; i < x; ++i,cur+=output_bytes) {
4771 cur[filter_bytes+1] = 255;
4772 }
4773 }
4774 }
4775 }
4776
4777 // we make a separate pass to expand bits to pixels; for performance,
4778 // this could run two scanlines behind the above code, so it won't
4779 // intefere with filtering but will still be in the cache.
4780 if (depth < 8) {
4781 for (j=0; j < y; ++j) {
4782 stbi_uc *cur = a->out + stride*j;
4783 stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes;
4784 // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit
4785 // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop
4786 stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
4787
4788 // note that the final byte might overshoot and write more data than desired.
4789 // we can allocate enough data that this never writes out of memory, but it
4790 // could also overwrite the next scanline. can it overwrite non-empty data
4791 // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.
4792 // so we need to explicitly clamp the final ones
4793
4794 if (depth == 4) {
4795 for (k=x*img_n; k >= 2; k-=2, ++in) {
4796 *cur++ = scale * ((*in >> 4) );
4797 *cur++ = scale * ((*in ) & 0x0f);
4798 }
4799 if (k > 0) *cur++ = scale * ((*in >> 4) );
4800 } else if (depth == 2) {
4801 for (k=x*img_n; k >= 4; k-=4, ++in) {
4802 *cur++ = scale * ((*in >> 6) );
4803 *cur++ = scale * ((*in >> 4) & 0x03);
4804 *cur++ = scale * ((*in >> 2) & 0x03);
4805 *cur++ = scale * ((*in ) & 0x03);
4806 }
4807 if (k > 0) *cur++ = scale * ((*in >> 6) );
4808 if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
4809 if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
4810 } else if (depth == 1) {
4811 for (k=x*img_n; k >= 8; k-=8, ++in) {
4812 *cur++ = scale * ((*in >> 7) );
4813 *cur++ = scale * ((*in >> 6) & 0x01);
4814 *cur++ = scale * ((*in >> 5) & 0x01);
4815 *cur++ = scale * ((*in >> 4) & 0x01);
4816 *cur++ = scale * ((*in >> 3) & 0x01);
4817 *cur++ = scale * ((*in >> 2) & 0x01);
4818 *cur++ = scale * ((*in >> 1) & 0x01);
4819 *cur++ = scale * ((*in ) & 0x01);
4820 }
4821 if (k > 0) *cur++ = scale * ((*in >> 7) );
4822 if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
4823 if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
4824 if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
4825 if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
4826 if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
4827 if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
4828 }
4829 if (img_n != out_n) {
4830 int q;
4831 // insert alpha = 255
4832 cur = a->out + stride*j;
4833 if (img_n == 1) {
4834 for (q=x-1; q >= 0; --q) {
4835 cur[q*2+1] = 255;
4836 cur[q*2+0] = cur[q];
4837 }
4838 } else {
4839 STBI_ASSERT(img_n == 3);
4840 for (q=x-1; q >= 0; --q) {
4841 cur[q*4+3] = 255;
4842 cur[q*4+2] = cur[q*3+2];
4843 cur[q*4+1] = cur[q*3+1];
4844 cur[q*4+0] = cur[q*3+0];
4845 }
4846 }
4847 }
4848 }
4849 } else if (depth == 16) {
4850 // force the image data from big-endian to platform-native.
4851 // this is done in a separate pass due to the decoding relying
4852 // on the data being untouched, but could probably be done
4853 // per-line during decode if care is taken.
4854 stbi_uc *cur = a->out;
4855 stbi__uint16 *cur16 = (stbi__uint16*)cur;
4856
4857 for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
4858 *cur16 = (cur[0] << 8) | cur[1];
4859 }
4860 }
4861
4862 return 1;
4863}
4864
4865static 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)
4866{
4867 int bytes = (depth == 16 ? 2 : 1);
4868 int out_bytes = out_n * bytes;
4869 stbi_uc *final;
4870 int p;
4871 if (!interlaced)
4872 return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
4873
4874 // de-interlacing
4875 final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
4876 if (!final) return stbi__err("outofmem", "Out of memory");
4877 for (p=0; p < 7; ++p) {
4878 int xorig[] = { 0,4,0,2,0,1,0 };
4879 int yorig[] = { 0,0,4,0,2,0,1 };
4880 int xspc[] = { 8,8,4,4,2,2,1 };
4881 int yspc[] = { 8,8,8,4,4,2,2 };
4882 int i,j,x,y;
4883 // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
4884 x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
4885 y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
4886 if (x && y) {
4887 stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
4888 if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
4889 STBI_FREE(final);
4890 return 0;
4891 }
4892 for (j=0; j < y; ++j) {
4893 for (i=0; i < x; ++i) {
4894 int out_y = j*yspc[p]+yorig[p];
4895 int out_x = i*xspc[p]+xorig[p];
4896 memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
4897 a->out + (j*x+i)*out_bytes, out_bytes);
4898 }
4899 }
4900 STBI_FREE(a->out);
4901 image_data += img_len;
4902 image_data_len -= img_len;
4903 }
4904 }
4905 a->out = final;
4906
4907 return 1;
4908}
4909
4910static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
4911{
4912 stbi__context *s = z->s;
4913 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4914 stbi_uc *p = z->out;
4915
4916 // compute color-based transparency, assuming we've
4917 // already got 255 as the alpha value in the output
4918 STBI_ASSERT(out_n == 2 || out_n == 4);
4919
4920 if (out_n == 2) {
4921 for (i=0; i < pixel_count; ++i) {
4922 p[1] = (p[0] == tc[0] ? 0 : 255);
4923 p += 2;
4924 }
4925 } else {
4926 for (i=0; i < pixel_count; ++i) {
4927 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4928 p[3] = 0;
4929 p += 4;
4930 }
4931 }
4932 return 1;
4933}
4934
4935static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
4936{
4937 stbi__context *s = z->s;
4938 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
4939 stbi__uint16 *p = (stbi__uint16*) z->out;
4940
4941 // compute color-based transparency, assuming we've
4942 // already got 65535 as the alpha value in the output
4943 STBI_ASSERT(out_n == 2 || out_n == 4);
4944
4945 if (out_n == 2) {
4946 for (i = 0; i < pixel_count; ++i) {
4947 p[1] = (p[0] == tc[0] ? 0 : 65535);
4948 p += 2;
4949 }
4950 } else {
4951 for (i = 0; i < pixel_count; ++i) {
4952 if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
4953 p[3] = 0;
4954 p += 4;
4955 }
4956 }
4957 return 1;
4958}
4959
4960static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
4961{
4962 stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
4963 stbi_uc *p, *temp_out, *orig = a->out;
4964
4965 p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
4966 if (p == NULL) return stbi__err("outofmem", "Out of memory");
4967
4968 // between here and free(out) below, exitting would leak
4969 temp_out = p;
4970
4971 if (pal_img_n == 3) {
4972 for (i=0; i < pixel_count; ++i) {
4973 int n = orig[i]*4;
4974 p[0] = palette[n ];
4975 p[1] = palette[n+1];
4976 p[2] = palette[n+2];
4977 p += 3;
4978 }
4979 } else {
4980 for (i=0; i < pixel_count; ++i) {
4981 int n = orig[i]*4;
4982 p[0] = palette[n ];
4983 p[1] = palette[n+1];
4984 p[2] = palette[n+2];
4985 p[3] = palette[n+3];
4986 p += 4;
4987 }
4988 }
4989 STBI_FREE(a->out);
4990 a->out = temp_out;
4991
4992 STBI_NOTUSED(len);
4993
4994 return 1;
4995}
4996
4997static int stbi__unpremultiply_on_load_global = 0;
4998static int stbi__de_iphone_flag_global = 0;
4999
5000STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
5001{
5002 stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
5003}
5004
5005STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
5006{
5007 stbi__de_iphone_flag_global = flag_true_if_should_convert;
5008}
5009
5010#ifndef STBI_THREAD_LOCAL
5011#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global
5012#define stbi__de_iphone_flag stbi__de_iphone_flag_global
5013#else
5014static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
5015static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
5016
5017STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
5018{
5019 stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
5020 stbi__unpremultiply_on_load_set = 1;
5021}
5022
5023STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
5024{
5025 stbi__de_iphone_flag_local = flag_true_if_should_convert;
5026 stbi__de_iphone_flag_set = 1;
5027}
5028
5029#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \
5030 ? stbi__unpremultiply_on_load_local \
5031 : stbi__unpremultiply_on_load_global)
5032#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \
5033 ? stbi__de_iphone_flag_local \
5034 : stbi__de_iphone_flag_global)
5035#endif // STBI_THREAD_LOCAL
5036
5037static void stbi__de_iphone(stbi__png *z)
5038{
5039 stbi__context *s = z->s;
5040 stbi__uint32 i, pixel_count = s->img_x * s->img_y;
5041 stbi_uc *p = z->out;
5042
5043 if (s->img_out_n == 3) { // convert bgr to rgb
5044 for (i=0; i < pixel_count; ++i) {
5045 stbi_uc t = p[0];
5046 p[0] = p[2];
5047 p[2] = t;
5048 p += 3;
5049 }
5050 } else {
5051 STBI_ASSERT(s->img_out_n == 4);
5052 if (stbi__unpremultiply_on_load) {
5053 // convert bgr to rgb and unpremultiply
5054 for (i=0; i < pixel_count; ++i) {
5055 stbi_uc a = p[3];
5056 stbi_uc t = p[0];
5057 if (a) {
5058 stbi_uc half = a / 2;
5059 p[0] = (p[2] * 255 + half) / a;
5060 p[1] = (p[1] * 255 + half) / a;
5061 p[2] = ( t * 255 + half) / a;
5062 } else {
5063 p[0] = p[2];
5064 p[2] = t;
5065 }
5066 p += 4;
5067 }
5068 } else {
5069 // convert bgr to rgb
5070 for (i=0; i < pixel_count; ++i) {
5071 stbi_uc t = p[0];
5072 p[0] = p[2];
5073 p[2] = t;
5074 p += 4;
5075 }
5076 }
5077 }
5078}
5079
5080#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
5081
5082static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
5083{
5084 stbi_uc palette[1024], pal_img_n=0;
5085 stbi_uc has_trans=0, tc[3]={0};
5086 stbi__uint16 tc16[3];
5087 stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
5088 int first=1,k,interlace=0, color=0, is_iphone=0;
5089 stbi__context *s = z->s;
5090
5091 z->expanded = NULL;
5092 z->idata = NULL;
5093 z->out = NULL;
5094
5095 if (!stbi__check_png_header(s)) return 0;
5096
5097 if (scan == STBI__SCAN_type) return 1;
5098
5099 for (;;) {
5100 stbi__pngchunk c = stbi__get_chunk_header(s);
5101 switch (c.type) {
5102 case STBI__PNG_TYPE('C','g','B','I'):
5103 is_iphone = 1;
5104 stbi__skip(s, c.length);
5105 break;
5106 case STBI__PNG_TYPE('I','H','D','R'): {
5107 int comp,filter;
5108 if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
5109 first = 0;
5110 if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
5111 s->img_x = stbi__get32be(s);
5112 s->img_y = stbi__get32be(s);
5113 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
5114 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
5115 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");
5116 color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG");
5117 if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG");
5118 if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
5119 comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG");
5120 filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG");
5121 interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
5122 if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
5123 if (!pal_img_n) {
5124 s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
5125 if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
5126 } else {
5127 // if paletted, then pal_n is our final components, and
5128 // img_n is # components to decompress/filter.
5129 s->img_n = 1;
5130 if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
5131 }
5132 // even with SCAN_header, have to scan to see if we have a tRNS
5133 break;
5134 }
5135
5136 case STBI__PNG_TYPE('P','L','T','E'): {
5137 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5138 if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
5139 pal_len = c.length / 3;
5140 if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
5141 for (i=0; i < pal_len; ++i) {
5142 palette[i*4+0] = stbi__get8(s);
5143 palette[i*4+1] = stbi__get8(s);
5144 palette[i*4+2] = stbi__get8(s);
5145 palette[i*4+3] = 255;
5146 }
5147 break;
5148 }
5149
5150 case STBI__PNG_TYPE('t','R','N','S'): {
5151 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5152 if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
5153 if (pal_img_n) {
5154 if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
5155 if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
5156 if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
5157 pal_img_n = 4;
5158 for (i=0; i < c.length; ++i)
5159 palette[i*4+3] = stbi__get8(s);
5160 } else {
5161 if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
5162 if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
5163 has_trans = 1;
5164 // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
5165 if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
5166 if (z->depth == 16) {
5167 for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
5168 } else {
5169 for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
5170 }
5171 }
5172 break;
5173 }
5174
5175 case STBI__PNG_TYPE('I','D','A','T'): {
5176 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5177 if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
5178 if (scan == STBI__SCAN_header) {
5179 // header scan definitely stops at first IDAT
5180 if (pal_img_n)
5181 s->img_n = pal_img_n;
5182 return 1;
5183 }
5184 if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
5185 if ((int)(ioff + c.length) < (int)ioff) return 0;
5186 if (ioff + c.length > idata_limit) {
5187 stbi__uint32 idata_limit_old = idata_limit;
5188 stbi_uc *p;
5189 if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
5190 while (ioff + c.length > idata_limit)
5191 idata_limit *= 2;
5192 STBI_NOTUSED(idata_limit_old);
5193 p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
5194 z->idata = p;
5195 }
5196 if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
5197 ioff += c.length;
5198 break;
5199 }
5200
5201 case STBI__PNG_TYPE('I','E','N','D'): {
5202 stbi__uint32 raw_len, bpl;
5203 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5204 if (scan != STBI__SCAN_load) return 1;
5205 if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
5206 // initial guess for decoded data size to avoid unnecessary reallocs
5207 bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
5208 raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
5209 z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
5210 if (z->expanded == NULL) return 0; // zlib should set error
5211 STBI_FREE(z->idata); z->idata = NULL;
5212 if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
5213 s->img_out_n = s->img_n+1;
5214 else
5215 s->img_out_n = s->img_n;
5216 if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
5217 if (has_trans) {
5218 if (z->depth == 16) {
5219 if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
5220 } else {
5221 if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
5222 }
5223 }
5224 if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
5225 stbi__de_iphone(z);
5226 if (pal_img_n) {
5227 // pal_img_n == 3 or 4
5228 s->img_n = pal_img_n; // record the actual colors we had
5229 s->img_out_n = pal_img_n;
5230 if (req_comp >= 3) s->img_out_n = req_comp;
5231 if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
5232 return 0;
5233 } else if (has_trans) {
5234 // non-paletted image with tRNS -> source image has (constant) alpha
5235 ++s->img_n;
5236 }
5237 STBI_FREE(z->expanded); z->expanded = NULL;
5238 // end of PNG chunk, read and skip CRC
5239 stbi__get32be(s);
5240 return 1;
5241 }
5242
5243 default:
5244 // if critical, fail
5245 if (first) return stbi__err("first not IHDR", "Corrupt PNG");
5246 if ((c.type & (1 << 29)) == 0) {
5247 #ifndef STBI_NO_FAILURE_STRINGS
5248 // not threadsafe
5249 static char invalid_chunk[] = "XXXX PNG chunk not known";
5250 invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
5251 invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
5252 invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);
5253 invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);
5254 #endif
5255 return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
5256 }
5257 stbi__skip(s, c.length);
5258 break;
5259 }
5260 // end of PNG chunk, read and skip CRC
5261 stbi__get32be(s);
5262 }
5263}
5264
5265static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
5266{
5267 void *result=NULL;
5268 if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
5269 if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
5270 if (p->depth <= 8)
5271 ri->bits_per_channel = 8;
5272 else if (p->depth == 16)
5273 ri->bits_per_channel = 16;
5274 else
5275 return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
5276 result = p->out;
5277 p->out = NULL;
5278 if (req_comp && req_comp != p->s->img_out_n) {
5279 if (ri->bits_per_channel == 8)
5280 result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5281 else
5282 result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
5283 p->s->img_out_n = req_comp;
5284 if (result == NULL) return result;
5285 }
5286 *x = p->s->img_x;
5287 *y = p->s->img_y;
5288 if (n) *n = p->s->img_n;
5289 }
5290 STBI_FREE(p->out); p->out = NULL;
5291 STBI_FREE(p->expanded); p->expanded = NULL;
5292 STBI_FREE(p->idata); p->idata = NULL;
5293
5294 return result;
5295}
5296
5297static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5298{
5299 stbi__png p;
5300 p.s = s;
5301 return stbi__do_png(&p, x,y,comp,req_comp, ri);
5302}
5303
5304static int stbi__png_test(stbi__context *s)
5305{
5306 int r;
5307 r = stbi__check_png_header(s);
5308 stbi__rewind(s);
5309 return r;
5310}
5311
5312static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
5313{
5314 if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
5315 stbi__rewind( p->s );
5316 return 0;
5317 }
5318 if (x) *x = p->s->img_x;
5319 if (y) *y = p->s->img_y;
5320 if (comp) *comp = p->s->img_n;
5321 return 1;
5322}
5323
5324static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
5325{
5326 stbi__png p;
5327 p.s = s;
5328 return stbi__png_info_raw(&p, x, y, comp);
5329}
5330
5331static int stbi__png_is16(stbi__context *s)
5332{
5333 stbi__png p;
5334 p.s = s;
5335 if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
5336 return 0;
5337 if (p.depth != 16) {
5338 stbi__rewind(p.s);
5339 return 0;
5340 }
5341 return 1;
5342}
5343#endif
5344
5345// Microsoft/Windows BMP image
5346
5347#ifndef STBI_NO_BMP
5348static int stbi__bmp_test_raw(stbi__context *s)
5349{
5350 int r;
5351 int sz;
5352 if (stbi__get8(s) != 'B') return 0;
5353 if (stbi__get8(s) != 'M') return 0;
5354 stbi__get32le(s); // discard filesize
5355 stbi__get16le(s); // discard reserved
5356 stbi__get16le(s); // discard reserved
5357 stbi__get32le(s); // discard data offset
5358 sz = stbi__get32le(s);
5359 r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
5360 return r;
5361}
5362
5363static int stbi__bmp_test(stbi__context *s)
5364{
5365 int r = stbi__bmp_test_raw(s);
5366 stbi__rewind(s);
5367 return r;
5368}
5369
5370
5371// returns 0..31 for the highest set bit
5372static int stbi__high_bit(unsigned int z)
5373{
5374 int n=0;
5375 if (z == 0) return -1;
5376 if (z >= 0x10000) { n += 16; z >>= 16; }
5377 if (z >= 0x00100) { n += 8; z >>= 8; }
5378 if (z >= 0x00010) { n += 4; z >>= 4; }
5379 if (z >= 0x00004) { n += 2; z >>= 2; }
5380 if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
5381 return n;
5382}
5383
5384static int stbi__bitcount(unsigned int a)
5385{
5386 a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
5387 a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
5388 a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
5389 a = (a + (a >> 8)); // max 16 per 8 bits
5390 a = (a + (a >> 16)); // max 32 per 8 bits
5391 return a & 0xff;
5392}
5393
5394// extract an arbitrarily-aligned N-bit value (N=bits)
5395// from v, and then make it 8-bits long and fractionally
5396// extend it to full full range.
5397static int stbi__shiftsigned(unsigned int v, int shift, int bits)
5398{
5399 static unsigned int mul_table[9] = {
5400 0,
5401 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
5402 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
5403 };
5404 static unsigned int shift_table[9] = {
5405 0, 0,0,1,0,2,4,6,0,
5406 };
5407 if (shift < 0)
5408 v <<= -shift;
5409 else
5410 v >>= shift;
5411 STBI_ASSERT(v < 256);
5412 v >>= (8-bits);
5413 STBI_ASSERT(bits >= 0 && bits <= 8);
5414 return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
5415}
5416
5417typedef struct
5418{
5419 int bpp, offset, hsz;
5420 unsigned int mr,mg,mb,ma, all_a;
5421 int extra_read;
5422} stbi__bmp_data;
5423
5424static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
5425{
5426 // BI_BITFIELDS specifies masks explicitly, don't override
5427 if (compress == 3)
5428 return 1;
5429
5430 if (compress == 0) {
5431 if (info->bpp == 16) {
5432 info->mr = 31u << 10;
5433 info->mg = 31u << 5;
5434 info->mb = 31u << 0;
5435 } else if (info->bpp == 32) {
5436 info->mr = 0xffu << 16;
5437 info->mg = 0xffu << 8;
5438 info->mb = 0xffu << 0;
5439 info->ma = 0xffu << 24;
5440 info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
5441 } else {
5442 // otherwise, use defaults, which is all-0
5443 info->mr = info->mg = info->mb = info->ma = 0;
5444 }
5445 return 1;
5446 }
5447 return 0; // error
5448}
5449
5450static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
5451{
5452 int hsz;
5453 if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
5454 stbi__get32le(s); // discard filesize
5455 stbi__get16le(s); // discard reserved
5456 stbi__get16le(s); // discard reserved
5457 info->offset = stbi__get32le(s);
5458 info->hsz = hsz = stbi__get32le(s);
5459 info->mr = info->mg = info->mb = info->ma = 0;
5460 info->extra_read = 14;
5461
5462 if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
5463
5464 if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
5465 if (hsz == 12) {
5466 s->img_x = stbi__get16le(s);
5467 s->img_y = stbi__get16le(s);
5468 } else {
5469 s->img_x = stbi__get32le(s);
5470 s->img_y = stbi__get32le(s);
5471 }
5472 if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
5473 info->bpp = stbi__get16le(s);
5474 if (hsz != 12) {
5475 int compress = stbi__get32le(s);
5476 if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
5477 if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
5478 if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
5479 stbi__get32le(s); // discard sizeof
5480 stbi__get32le(s); // discard hres
5481 stbi__get32le(s); // discard vres
5482 stbi__get32le(s); // discard colorsused
5483 stbi__get32le(s); // discard max important
5484 if (hsz == 40 || hsz == 56) {
5485 if (hsz == 56) {
5486 stbi__get32le(s);
5487 stbi__get32le(s);
5488 stbi__get32le(s);
5489 stbi__get32le(s);
5490 }
5491 if (info->bpp == 16 || info->bpp == 32) {
5492 if (compress == 0) {
5493 stbi__bmp_set_mask_defaults(info, compress);
5494 } else if (compress == 3) {
5495 info->mr = stbi__get32le(s);
5496 info->mg = stbi__get32le(s);
5497 info->mb = stbi__get32le(s);
5498 info->extra_read += 12;
5499 // not documented, but generated by photoshop and handled by mspaint
5500 if (info->mr == info->mg && info->mg == info->mb) {
5501 // ?!?!?
5502 return stbi__errpuc("bad BMP", "bad BMP");
5503 }
5504 } else
5505 return stbi__errpuc("bad BMP", "bad BMP");
5506 }
5507 } else {
5508 // V4/V5 header
5509 int i;
5510 if (hsz != 108 && hsz != 124)
5511 return stbi__errpuc("bad BMP", "bad BMP");
5512 info->mr = stbi__get32le(s);
5513 info->mg = stbi__get32le(s);
5514 info->mb = stbi__get32le(s);
5515 info->ma = stbi__get32le(s);
5516 if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
5517 stbi__bmp_set_mask_defaults(info, compress);
5518 stbi__get32le(s); // discard color space
5519 for (i=0; i < 12; ++i)
5520 stbi__get32le(s); // discard color space parameters
5521 if (hsz == 124) {
5522 stbi__get32le(s); // discard rendering intent
5523 stbi__get32le(s); // discard offset of profile data
5524 stbi__get32le(s); // discard size of profile data
5525 stbi__get32le(s); // discard reserved
5526 }
5527 }
5528 }
5529 return (void *) 1;
5530}
5531
5532
5533static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5534{
5535 stbi_uc *out;
5536 unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
5537 stbi_uc pal[256][4];
5538 int psize=0,i,j,width;
5539 int flip_vertically, pad, target;
5540 stbi__bmp_data info;
5541 STBI_NOTUSED(ri);
5542
5543 info.all_a = 255;
5544 if (stbi__bmp_parse_header(s, &info) == NULL)
5545 return NULL; // error code already set
5546
5547 flip_vertically = ((int) s->img_y) > 0;
5548 s->img_y = abs((int) s->img_y);
5549
5550 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5551 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5552
5553 mr = info.mr;
5554 mg = info.mg;
5555 mb = info.mb;
5556 ma = info.ma;
5557 all_a = info.all_a;
5558
5559 if (info.hsz == 12) {
5560 if (info.bpp < 24)
5561 psize = (info.offset - info.extra_read - 24) / 3;
5562 } else {
5563 if (info.bpp < 16)
5564 psize = (info.offset - info.extra_read - info.hsz) >> 2;
5565 }
5566 if (psize == 0) {
5567 // accept some number of extra bytes after the header, but if the offset points either to before
5568 // the header ends or implies a large amount of extra data, reject the file as malformed
5569 int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
5570 int header_limit = 1024; // max we actually read is below 256 bytes currently.
5571 int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
5572 if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
5573 return stbi__errpuc("bad header", "Corrupt BMP");
5574 }
5575 // we established that bytes_read_so_far is positive and sensible.
5576 // the first half of this test rejects offsets that are either too small positives, or
5577 // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
5578 // ensures the number computed in the second half of the test can't overflow.
5579 if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
5580 return stbi__errpuc("bad offset", "Corrupt BMP");
5581 } else {
5582 stbi__skip(s, info.offset - bytes_read_so_far);
5583 }
5584 }
5585
5586 if (info.bpp == 24 && ma == 0xff000000)
5587 s->img_n = 3;
5588 else
5589 s->img_n = ma ? 4 : 3;
5590 if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
5591 target = req_comp;
5592 else
5593 target = s->img_n; // if they want monochrome, we'll post-convert
5594
5595 // sanity-check size
5596 if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
5597 return stbi__errpuc("too large", "Corrupt BMP");
5598
5599 out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
5600 if (!out) return stbi__errpuc("outofmem", "Out of memory");
5601 if (info.bpp < 16) {
5602 int z=0;
5603 if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
5604 for (i=0; i < psize; ++i) {
5605 pal[i][2] = stbi__get8(s);
5606 pal[i][1] = stbi__get8(s);
5607 pal[i][0] = stbi__get8(s);
5608 if (info.hsz != 12) stbi__get8(s);
5609 pal[i][3] = 255;
5610 }
5611 stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
5612 if (info.bpp == 1) width = (s->img_x + 7) >> 3;
5613 else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
5614 else if (info.bpp == 8) width = s->img_x;
5615 else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
5616 pad = (-width)&3;
5617 if (info.bpp == 1) {
5618 for (j=0; j < (int) s->img_y; ++j) {
5619 int bit_offset = 7, v = stbi__get8(s);
5620 for (i=0; i < (int) s->img_x; ++i) {
5621 int color = (v>>bit_offset)&0x1;
5622 out[z++] = pal[color][0];
5623 out[z++] = pal[color][1];
5624 out[z++] = pal[color][2];
5625 if (target == 4) out[z++] = 255;
5626 if (i+1 == (int) s->img_x) break;
5627 if((--bit_offset) < 0) {
5628 bit_offset = 7;
5629 v = stbi__get8(s);
5630 }
5631 }
5632 stbi__skip(s, pad);
5633 }
5634 } else {
5635 for (j=0; j < (int) s->img_y; ++j) {
5636 for (i=0; i < (int) s->img_x; i += 2) {
5637 int v=stbi__get8(s),v2=0;
5638 if (info.bpp == 4) {
5639 v2 = v & 15;
5640 v >>= 4;
5641 }
5642 out[z++] = pal[v][0];
5643 out[z++] = pal[v][1];
5644 out[z++] = pal[v][2];
5645 if (target == 4) out[z++] = 255;
5646 if (i+1 == (int) s->img_x) break;
5647 v = (info.bpp == 8) ? stbi__get8(s) : v2;
5648 out[z++] = pal[v][0];
5649 out[z++] = pal[v][1];
5650 out[z++] = pal[v][2];
5651 if (target == 4) out[z++] = 255;
5652 }
5653 stbi__skip(s, pad);
5654 }
5655 }
5656 } else {
5657 int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
5658 int z = 0;
5659 int easy=0;
5660 stbi__skip(s, info.offset - info.extra_read - info.hsz);
5661 if (info.bpp == 24) width = 3 * s->img_x;
5662 else if (info.bpp == 16) width = 2*s->img_x;
5663 else /* bpp = 32 and pad = 0 */ width=0;
5664 pad = (-width) & 3;
5665 if (info.bpp == 24) {
5666 easy = 1;
5667 } else if (info.bpp == 32) {
5668 if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
5669 easy = 2;
5670 }
5671 if (!easy) {
5672 if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
5673 // right shift amt to put high bit in position #7
5674 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
5675 gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
5676 bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
5677 ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
5678 if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
5679 }
5680 for (j=0; j < (int) s->img_y; ++j) {
5681 if (easy) {
5682 for (i=0; i < (int) s->img_x; ++i) {
5683 unsigned char a;
5684 out[z+2] = stbi__get8(s);
5685 out[z+1] = stbi__get8(s);
5686 out[z+0] = stbi__get8(s);
5687 z += 3;
5688 a = (easy == 2 ? stbi__get8(s) : 255);
5689 all_a |= a;
5690 if (target == 4) out[z++] = a;
5691 }
5692 } else {
5693 int bpp = info.bpp;
5694 for (i=0; i < (int) s->img_x; ++i) {
5695 stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
5696 unsigned int a;
5697 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
5698 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
5699 out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
5700 a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
5701 all_a |= a;
5702 if (target == 4) out[z++] = STBI__BYTECAST(a);
5703 }
5704 }
5705 stbi__skip(s, pad);
5706 }
5707 }
5708
5709 // if alpha channel is all 0s, replace with all 255s
5710 if (target == 4 && all_a == 0)
5711 for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
5712 out[i] = 255;
5713
5714 if (flip_vertically) {
5715 stbi_uc t;
5716 for (j=0; j < (int) s->img_y>>1; ++j) {
5717 stbi_uc *p1 = out + j *s->img_x*target;
5718 stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
5719 for (i=0; i < (int) s->img_x*target; ++i) {
5720 t = p1[i]; p1[i] = p2[i]; p2[i] = t;
5721 }
5722 }
5723 }
5724
5725 if (req_comp && req_comp != target) {
5726 out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
5727 if (out == NULL) return out; // stbi__convert_format frees input on failure
5728 }
5729
5730 *x = s->img_x;
5731 *y = s->img_y;
5732 if (comp) *comp = s->img_n;
5733 return out;
5734}
5735#endif
5736
5737// Targa Truevision - TGA
5738// by Jonathan Dummer
5739#ifndef STBI_NO_TGA
5740// returns STBI_rgb or whatever, 0 on error
5741static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
5742{
5743 // only RGB or RGBA (incl. 16bit) or grey allowed
5744 if (is_rgb16) *is_rgb16 = 0;
5745 switch(bits_per_pixel) {
5746 case 8: return STBI_grey;
5747 case 16: if(is_grey) return STBI_grey_alpha;
5748 // fallthrough
5749 case 15: if(is_rgb16) *is_rgb16 = 1;
5750 return STBI_rgb;
5751 case 24: // fallthrough
5752 case 32: return bits_per_pixel/8;
5753 default: return 0;
5754 }
5755}
5756
5757static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
5758{
5759 int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
5760 int sz, tga_colormap_type;
5761 stbi__get8(s); // discard Offset
5762 tga_colormap_type = stbi__get8(s); // colormap type
5763 if( tga_colormap_type > 1 ) {
5764 stbi__rewind(s);
5765 return 0; // only RGB or indexed allowed
5766 }
5767 tga_image_type = stbi__get8(s); // image type
5768 if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
5769 if (tga_image_type != 1 && tga_image_type != 9) {
5770 stbi__rewind(s);
5771 return 0;
5772 }
5773 stbi__skip(s,4); // skip index of first colormap entry and number of entries
5774 sz = stbi__get8(s); // check bits per palette color entry
5775 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
5776 stbi__rewind(s);
5777 return 0;
5778 }
5779 stbi__skip(s,4); // skip image x and y origin
5780 tga_colormap_bpp = sz;
5781 } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
5782 if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
5783 stbi__rewind(s);
5784 return 0; // only RGB or grey allowed, +/- RLE
5785 }
5786 stbi__skip(s,9); // skip colormap specification and image x/y origin
5787 tga_colormap_bpp = 0;
5788 }
5789 tga_w = stbi__get16le(s);
5790 if( tga_w < 1 ) {
5791 stbi__rewind(s);
5792 return 0; // test width
5793 }
5794 tga_h = stbi__get16le(s);
5795 if( tga_h < 1 ) {
5796 stbi__rewind(s);
5797 return 0; // test height
5798 }
5799 tga_bits_per_pixel = stbi__get8(s); // bits per pixel
5800 stbi__get8(s); // ignore alpha bits
5801 if (tga_colormap_bpp != 0) {
5802 if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
5803 // when using a colormap, tga_bits_per_pixel is the size of the indexes
5804 // I don't think anything but 8 or 16bit indexes makes sense
5805 stbi__rewind(s);
5806 return 0;
5807 }
5808 tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
5809 } else {
5810 tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
5811 }
5812 if(!tga_comp) {
5813 stbi__rewind(s);
5814 return 0;
5815 }
5816 if (x) *x = tga_w;
5817 if (y) *y = tga_h;
5818 if (comp) *comp = tga_comp;
5819 return 1; // seems to have passed everything
5820}
5821
5822static int stbi__tga_test(stbi__context *s)
5823{
5824 int res = 0;
5825 int sz, tga_color_type;
5826 stbi__get8(s); // discard Offset
5827 tga_color_type = stbi__get8(s); // color type
5828 if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed
5829 sz = stbi__get8(s); // image type
5830 if ( tga_color_type == 1 ) { // colormapped (paletted) image
5831 if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
5832 stbi__skip(s,4); // skip index of first colormap entry and number of entries
5833 sz = stbi__get8(s); // check bits per palette color entry
5834 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
5835 stbi__skip(s,4); // skip image x and y origin
5836 } else { // "normal" image w/o colormap
5837 if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
5838 stbi__skip(s,9); // skip colormap specification and image x/y origin
5839 }
5840 if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width
5841 if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height
5842 sz = stbi__get8(s); // bits per pixel
5843 if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
5844 if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
5845
5846 res = 1; // if we got this far, everything's good and we can return 1 instead of 0
5847
5848errorEnd:
5849 stbi__rewind(s);
5850 return res;
5851}
5852
5853// read 16bit value and convert to 24bit RGB
5854static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
5855{
5856 stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
5857 stbi__uint16 fiveBitMask = 31;
5858 // we have 3 channels with 5bits each
5859 int r = (px >> 10) & fiveBitMask;
5860 int g = (px >> 5) & fiveBitMask;
5861 int b = px & fiveBitMask;
5862 // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
5863 out[0] = (stbi_uc)((r * 255)/31);
5864 out[1] = (stbi_uc)((g * 255)/31);
5865 out[2] = (stbi_uc)((b * 255)/31);
5866
5867 // some people claim that the most significant bit might be used for alpha
5868 // (possibly if an alpha-bit is set in the "image descriptor byte")
5869 // but that only made 16bit test images completely translucent..
5870 // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
5871}
5872
5873static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
5874{
5875 // read in the TGA header stuff
5876 int tga_offset = stbi__get8(s);
5877 int tga_indexed = stbi__get8(s);
5878 int tga_image_type = stbi__get8(s);
5879 int tga_is_RLE = 0;
5880 int tga_palette_start = stbi__get16le(s);
5881 int tga_palette_len = stbi__get16le(s);
5882 int tga_palette_bits = stbi__get8(s);
5883 int tga_x_origin = stbi__get16le(s);
5884 int tga_y_origin = stbi__get16le(s);
5885 int tga_width = stbi__get16le(s);
5886 int tga_height = stbi__get16le(s);
5887 int tga_bits_per_pixel = stbi__get8(s);
5888 int tga_comp, tga_rgb16=0;
5889 int tga_inverted = stbi__get8(s);
5890 // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
5891 // image data
5892 unsigned char *tga_data;
5893 unsigned char *tga_palette = NULL;
5894 int i, j;
5895 unsigned char raw_data[4] = {0};
5896 int RLE_count = 0;
5897 int RLE_repeating = 0;
5898 int read_next_pixel = 1;
5899 STBI_NOTUSED(ri);
5900 STBI_NOTUSED(tga_x_origin); // @TODO
5901 STBI_NOTUSED(tga_y_origin); // @TODO
5902
5903 if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5904 if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
5905
5906 // do a tiny bit of precessing
5907 if ( tga_image_type >= 8 )
5908 {
5909 tga_image_type -= 8;
5910 tga_is_RLE = 1;
5911 }
5912 tga_inverted = 1 - ((tga_inverted >> 5) & 1);
5913
5914 // If I'm paletted, then I'll use the number of bits from the palette
5915 if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
5916 else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
5917
5918 if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
5919 return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
5920
5921 // tga info
5922 *x = tga_width;
5923 *y = tga_height;
5924 if (comp) *comp = tga_comp;
5925
5926 if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
5927 return stbi__errpuc("too large", "Corrupt TGA");
5928
5929 tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
5930 if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
5931
5932 // skip to the data's starting position (offset usually = 0)
5933 stbi__skip(s, tga_offset );
5934
5935 if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
5936 for (i=0; i < tga_height; ++i) {
5937 int row = tga_inverted ? tga_height -i - 1 : i;
5938 stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
5939 stbi__getn(s, tga_row, tga_width * tga_comp);
5940 }
5941 } else {
5942 // do I need to load a palette?
5943 if ( tga_indexed)
5944 {
5945 if (tga_palette_len == 0) { /* you have to have at least one entry! */
5946 STBI_FREE(tga_data);
5947 return stbi__errpuc("bad palette", "Corrupt TGA");
5948 }
5949
5950 // any data to skip? (offset usually = 0)
5951 stbi__skip(s, tga_palette_start );
5952 // load the palette
5953 tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
5954 if (!tga_palette) {
5955 STBI_FREE(tga_data);
5956 return stbi__errpuc("outofmem", "Out of memory");
5957 }
5958 if (tga_rgb16) {
5959 stbi_uc *pal_entry = tga_palette;
5960 STBI_ASSERT(tga_comp == STBI_rgb);
5961 for (i=0; i < tga_palette_len; ++i) {
5962 stbi__tga_read_rgb16(s, pal_entry);
5963 pal_entry += tga_comp;
5964 }
5965 } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
5966 STBI_FREE(tga_data);
5967 STBI_FREE(tga_palette);
5968 return stbi__errpuc("bad palette", "Corrupt TGA");
5969 }
5970 }
5971 // load the data
5972 for (i=0; i < tga_width * tga_height; ++i)
5973 {
5974 // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
5975 if ( tga_is_RLE )
5976 {
5977 if ( RLE_count == 0 )
5978 {
5979 // yep, get the next byte as a RLE command
5980 int RLE_cmd = stbi__get8(s);
5981 RLE_count = 1 + (RLE_cmd & 127);
5982 RLE_repeating = RLE_cmd >> 7;
5983 read_next_pixel = 1;
5984 } else if ( !RLE_repeating )
5985 {
5986 read_next_pixel = 1;
5987 }
5988 } else
5989 {
5990 read_next_pixel = 1;
5991 }
5992 // OK, if I need to read a pixel, do it now
5993 if ( read_next_pixel )
5994 {
5995 // load however much data we did have
5996 if ( tga_indexed )
5997 {
5998 // read in index, then perform the lookup
5999 int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
6000 if ( pal_idx >= tga_palette_len ) {
6001 // invalid index
6002 pal_idx = 0;
6003 }
6004 pal_idx *= tga_comp;
6005 for (j = 0; j < tga_comp; ++j) {
6006 raw_data[j] = tga_palette[pal_idx+j];
6007 }
6008 } else if(tga_rgb16) {
6009 STBI_ASSERT(tga_comp == STBI_rgb);
6010 stbi__tga_read_rgb16(s, raw_data);
6011 } else {
6012 // read in the data raw
6013 for (j = 0; j < tga_comp; ++j) {
6014 raw_data[j] = stbi__get8(s);
6015 }
6016 }
6017 // clear the reading flag for the next pixel
6018 read_next_pixel = 0;
6019 } // end of reading a pixel
6020
6021 // copy data
6022 for (j = 0; j < tga_comp; ++j)
6023 tga_data[i*tga_comp+j] = raw_data[j];
6024
6025 // in case we're in RLE mode, keep counting down
6026 --RLE_count;
6027 }
6028 // do I need to invert the image?
6029 if ( tga_inverted )
6030 {
6031 for (j = 0; j*2 < tga_height; ++j)
6032 {
6033 int index1 = j * tga_width * tga_comp;
6034 int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
6035 for (i = tga_width * tga_comp; i > 0; --i)
6036 {
6037 unsigned char temp = tga_data[index1];
6038 tga_data[index1] = tga_data[index2];
6039 tga_data[index2] = temp;
6040 ++index1;
6041 ++index2;
6042 }
6043 }
6044 }
6045 // clear my palette, if I had one
6046 if ( tga_palette != NULL )
6047 {
6048 STBI_FREE( tga_palette );
6049 }
6050 }
6051
6052 // swap RGB - if the source data was RGB16, it already is in the right order
6053 if (tga_comp >= 3 && !tga_rgb16)
6054 {
6055 unsigned char* tga_pixel = tga_data;
6056 for (i=0; i < tga_width * tga_height; ++i)
6057 {
6058 unsigned char temp = tga_pixel[0];
6059 tga_pixel[0] = tga_pixel[2];
6060 tga_pixel[2] = temp;
6061 tga_pixel += tga_comp;
6062 }
6063 }
6064
6065 // convert to target component count
6066 if (req_comp && req_comp != tga_comp)
6067 tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
6068
6069 // the things I do to get rid of an error message, and yet keep
6070 // Microsoft's C compilers happy... [8^(
6071 tga_palette_start = tga_palette_len = tga_palette_bits =
6072 tga_x_origin = tga_y_origin = 0;
6073 STBI_NOTUSED(tga_palette_start);
6074 // OK, done
6075 return tga_data;
6076}
6077#endif
6078
6079// *************************************************************************************************
6080// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
6081
6082#ifndef STBI_NO_PSD
6083static int stbi__psd_test(stbi__context *s)
6084{
6085 int r = (stbi__get32be(s) == 0x38425053);
6086 stbi__rewind(s);
6087 return r;
6088}
6089
6090static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
6091{
6092 int count, nleft, len;
6093
6094 count = 0;
6095 while ((nleft = pixelCount - count) > 0) {
6096 len = stbi__get8(s);
6097 if (len == 128) {
6098 // No-op.
6099 } else if (len < 128) {
6100 // Copy next len+1 bytes literally.
6101 len++;
6102 if (len > nleft) return 0; // corrupt data
6103 count += len;
6104 while (len) {
6105 *p = stbi__get8(s);
6106 p += 4;
6107 len--;
6108 }
6109 } else if (len > 128) {
6110 stbi_uc val;
6111 // Next -len+1 bytes in the dest are replicated from next source byte.
6112 // (Interpret len as a negative 8-bit int.)
6113 len = 257 - len;
6114 if (len > nleft) return 0; // corrupt data
6115 val = stbi__get8(s);
6116 count += len;
6117 while (len) {
6118 *p = val;
6119 p += 4;
6120 len--;
6121 }
6122 }
6123 }
6124
6125 return 1;
6126}
6127
6128static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
6129{
6130 int pixelCount;
6131 int channelCount, compression;
6132 int channel, i;
6133 int bitdepth;
6134 int w,h;
6135 stbi_uc *out;
6136 STBI_NOTUSED(ri);
6137
6138 // Check identifier
6139 if (stbi__get32be(s) != 0x38425053) // "8BPS"
6140 return stbi__errpuc("not PSD", "Corrupt PSD image");
6141
6142 // Check file type version.
6143 if (stbi__get16be(s) != 1)
6144 return stbi__errpuc("wrong version", "Unsupported version of PSD image");
6145
6146 // Skip 6 reserved bytes.
6147 stbi__skip(s, 6 );
6148
6149 // Read the number of channels (R, G, B, A, etc).
6150 channelCount = stbi__get16be(s);
6151 if (channelCount < 0 || channelCount > 16)
6152 return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
6153
6154 // Read the rows and columns of the image.
6155 h = stbi__get32be(s);
6156 w = stbi__get32be(s);
6157
6158 if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6159 if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6160
6161 // Make sure the depth is 8 bits.
6162 bitdepth = stbi__get16be(s);
6163 if (bitdepth != 8 && bitdepth != 16)
6164 return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
6165
6166 // Make sure the color mode is RGB.
6167 // Valid options are:
6168 // 0: Bitmap
6169 // 1: Grayscale
6170 // 2: Indexed color
6171 // 3: RGB color
6172 // 4: CMYK color
6173 // 7: Multichannel
6174 // 8: Duotone
6175 // 9: Lab color
6176 if (stbi__get16be(s) != 3)
6177 return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
6178
6179 // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
6180 stbi__skip(s,stbi__get32be(s) );
6181
6182 // Skip the image resources. (resolution, pen tool paths, etc)
6183 stbi__skip(s, stbi__get32be(s) );
6184
6185 // Skip the reserved data.
6186 stbi__skip(s, stbi__get32be(s) );
6187
6188 // Find out if the data is compressed.
6189 // Known values:
6190 // 0: no compression
6191 // 1: RLE compressed
6192 compression = stbi__get16be(s);
6193 if (compression > 1)
6194 return stbi__errpuc("bad compression", "PSD has an unknown compression format");
6195
6196 // Check size
6197 if (!stbi__mad3sizes_valid(4, w, h, 0))
6198 return stbi__errpuc("too large", "Corrupt PSD");
6199
6200 // Create the destination image.
6201
6202 if (!compression && bitdepth == 16 && bpc == 16) {
6203 out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
6204 ri->bits_per_channel = 16;
6205 } else
6206 out = (stbi_uc *) stbi__malloc(4 * w*h);
6207
6208 if (!out) return stbi__errpuc("outofmem", "Out of memory");
6209 pixelCount = w*h;
6210
6211 // Initialize the data to zero.
6212 //memset( out, 0, pixelCount * 4 );
6213
6214 // Finally, the image data.
6215 if (compression) {
6216 // RLE as used by .PSD and .TIFF
6217 // Loop until you get the number of unpacked bytes you are expecting:
6218 // Read the next source byte into n.
6219 // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
6220 // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
6221 // Else if n is 128, noop.
6222 // Endloop
6223
6224 // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
6225 // which we're going to just skip.
6226 stbi__skip(s, h * channelCount * 2 );
6227
6228 // Read the RLE data by channel.
6229 for (channel = 0; channel < 4; channel++) {
6230 stbi_uc *p;
6231
6232 p = out+channel;
6233 if (channel >= channelCount) {
6234 // Fill this channel with default data.
6235 for (i = 0; i < pixelCount; i++, p += 4)
6236 *p = (channel == 3 ? 255 : 0);
6237 } else {
6238 // Read the RLE data.
6239 if (!stbi__psd_decode_rle(s, p, pixelCount)) {
6240 STBI_FREE(out);
6241 return stbi__errpuc("corrupt", "bad RLE data");
6242 }
6243 }
6244 }
6245
6246 } else {
6247 // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
6248 // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
6249
6250 // Read the data by channel.
6251 for (channel = 0; channel < 4; channel++) {
6252 if (channel >= channelCount) {
6253 // Fill this channel with default data.
6254 if (bitdepth == 16 && bpc == 16) {
6255 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
6256 stbi__uint16 val = channel == 3 ? 65535 : 0;
6257 for (i = 0; i < pixelCount; i++, q += 4)
6258 *q = val;
6259 } else {
6260 stbi_uc *p = out+channel;
6261 stbi_uc val = channel == 3 ? 255 : 0;
6262 for (i = 0; i < pixelCount; i++, p += 4)
6263 *p = val;
6264 }
6265 } else {
6266 if (ri->bits_per_channel == 16) { // output bpc
6267 stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
6268 for (i = 0; i < pixelCount; i++, q += 4)
6269 *q = (stbi__uint16) stbi__get16be(s);
6270 } else {
6271 stbi_uc *p = out+channel;
6272 if (bitdepth == 16) { // input bpc
6273 for (i = 0; i < pixelCount; i++, p += 4)
6274 *p = (stbi_uc) (stbi__get16be(s) >> 8);
6275 } else {
6276 for (i = 0; i < pixelCount; i++, p += 4)
6277 *p = stbi__get8(s);
6278 }
6279 }
6280 }
6281 }
6282 }
6283
6284 // remove weird white matte from PSD
6285 if (channelCount >= 4) {
6286 if (ri->bits_per_channel == 16) {
6287 for (i=0; i < w*h; ++i) {
6288 stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
6289 if (pixel[3] != 0 && pixel[3] != 65535) {
6290 float a = pixel[3] / 65535.0f;
6291 float ra = 1.0f / a;
6292 float inv_a = 65535.0f * (1 - ra);
6293 pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
6294 pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
6295 pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
6296 }
6297 }
6298 } else {
6299 for (i=0; i < w*h; ++i) {
6300 unsigned char *pixel = out + 4*i;
6301 if (pixel[3] != 0 && pixel[3] != 255) {
6302 float a = pixel[3] / 255.0f;
6303 float ra = 1.0f / a;
6304 float inv_a = 255.0f * (1 - ra);
6305 pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
6306 pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
6307 pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
6308 }
6309 }
6310 }
6311 }
6312
6313 // convert to desired output format
6314 if (req_comp && req_comp != 4) {
6315 if (ri->bits_per_channel == 16)
6316 out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
6317 else
6318 out = stbi__convert_format(out, 4, req_comp, w, h);
6319 if (out == NULL) return out; // stbi__convert_format frees input on failure
6320 }
6321
6322 if (comp) *comp = 4;
6323 *y = h;
6324 *x = w;
6325
6326 return out;
6327}
6328#endif
6329
6330// *************************************************************************************************
6331// Softimage PIC loader
6332// by Tom Seddon
6333//
6334// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
6335// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
6336
6337#ifndef STBI_NO_PIC
6338static int stbi__pic_is4(stbi__context *s,const char *str)
6339{
6340 int i;
6341 for (i=0; i<4; ++i)
6342 if (stbi__get8(s) != (stbi_uc)str[i])
6343 return 0;
6344
6345 return 1;
6346}
6347
6348static int stbi__pic_test_core(stbi__context *s)
6349{
6350 int i;
6351
6352 if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
6353 return 0;
6354
6355 for(i=0;i<84;++i)
6356 stbi__get8(s);
6357
6358 if (!stbi__pic_is4(s,"PICT"))
6359 return 0;
6360
6361 return 1;
6362}
6363
6364typedef struct
6365{
6366 stbi_uc size,type,channel;
6367} stbi__pic_packet;
6368
6369static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
6370{
6371 int mask=0x80, i;
6372
6373 for (i=0; i<4; ++i, mask>>=1) {
6374 if (channel & mask) {
6375 if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
6376 dest[i]=stbi__get8(s);
6377 }
6378 }
6379
6380 return dest;
6381}
6382
6383static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
6384{
6385 int mask=0x80,i;
6386
6387 for (i=0;i<4; ++i, mask>>=1)
6388 if (channel&mask)
6389 dest[i]=src[i];
6390}
6391
6392static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
6393{
6394 int act_comp=0,num_packets=0,y,chained;
6395 stbi__pic_packet packets[10];
6396
6397 // this will (should...) cater for even some bizarre stuff like having data
6398 // for the same channel in multiple packets.
6399 do {
6400 stbi__pic_packet *packet;
6401
6402 if (num_packets==sizeof(packets)/sizeof(packets[0]))
6403 return stbi__errpuc("bad format","too many packets");
6404
6405 packet = &packets[num_packets++];
6406
6407 chained = stbi__get8(s);
6408 packet->size = stbi__get8(s);
6409 packet->type = stbi__get8(s);
6410 packet->channel = stbi__get8(s);
6411
6412 act_comp |= packet->channel;
6413
6414 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)");
6415 if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp");
6416 } while (chained);
6417
6418 *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
6419
6420 for(y=0; y<height; ++y) {
6421 int packet_idx;
6422
6423 for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
6424 stbi__pic_packet *packet = &packets[packet_idx];
6425 stbi_uc *dest = result+y*width*4;
6426
6427 switch (packet->type) {
6428 default:
6429 return stbi__errpuc("bad format","packet has bad compression type");
6430
6431 case 0: {//uncompressed
6432 int x;
6433
6434 for(x=0;x<width;++x, dest+=4)
6435 if (!stbi__readval(s,packet->channel,dest))
6436 return 0;
6437 break;
6438 }
6439
6440 case 1://Pure RLE
6441 {
6442 int left=width, i;
6443
6444 while (left>0) {
6445 stbi_uc count,value[4];
6446
6447 count=stbi__get8(s);
6448 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)");
6449
6450 if (count > left)
6451 count = (stbi_uc) left;
6452
6453 if (!stbi__readval(s,packet->channel,value)) return 0;
6454
6455 for(i=0; i<count; ++i,dest+=4)
6456 stbi__copyval(packet->channel,dest,value);
6457 left -= count;
6458 }
6459 }
6460 break;
6461
6462 case 2: {//Mixed RLE
6463 int left=width;
6464 while (left>0) {
6465 int count = stbi__get8(s), i;
6466 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)");
6467
6468 if (count >= 128) { // Repeated
6469 stbi_uc value[4];
6470
6471 if (count==128)
6472 count = stbi__get16be(s);
6473 else
6474 count -= 127;
6475 if (count > left)
6476 return stbi__errpuc("bad file","scanline overrun");
6477
6478 if (!stbi__readval(s,packet->channel,value))
6479 return 0;
6480
6481 for(i=0;i<count;++i, dest += 4)
6482 stbi__copyval(packet->channel,dest,value);
6483 } else { // Raw
6484 ++count;
6485 if (count>left) return stbi__errpuc("bad file","scanline overrun");
6486
6487 for(i=0;i<count;++i, dest+=4)
6488 if (!stbi__readval(s,packet->channel,dest))
6489 return 0;
6490 }
6491 left-=count;
6492 }
6493 break;
6494 }
6495 }
6496 }
6497 }
6498
6499 return result;
6500}
6501
6502static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
6503{
6504 stbi_uc *result;
6505 int i, x,y, internal_comp;
6506 STBI_NOTUSED(ri);
6507
6508 if (!comp) comp = &internal_comp;
6509
6510 for (i=0; i<92; ++i)
6511 stbi__get8(s);
6512
6513 x = stbi__get16be(s);
6514 y = stbi__get16be(s);
6515
6516 if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6517 if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
6518
6519 if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)");
6520 if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
6521
6522 stbi__get32be(s); //skip `ratio'
6523 stbi__get16be(s); //skip `fields'
6524 stbi__get16be(s); //skip `pad'
6525
6526 // intermediate buffer is RGBA
6527 result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
6528 if (!result) return stbi__errpuc("outofmem", "Out of memory");
6529 memset(result, 0xff, x*y*4);
6530
6531 if (!stbi__pic_load_core(s,x,y,comp, result)) {
6532 STBI_FREE(result);
6533 result=0;
6534 }
6535 *px = x;
6536 *py = y;
6537 if (req_comp == 0) req_comp = *comp;
6538 result=stbi__convert_format(result,4,req_comp,x,y);
6539
6540 return result;
6541}
6542
6543static int stbi__pic_test(stbi__context *s)
6544{
6545 int r = stbi__pic_test_core(s);
6546 stbi__rewind(s);
6547 return r;
6548}
6549#endif
6550
6551// *************************************************************************************************
6552// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
6553
6554#ifndef STBI_NO_GIF
6555typedef struct
6556{
6557 stbi__int16 prefix;
6558 stbi_uc first;
6559 stbi_uc suffix;
6560} stbi__gif_lzw;
6561
6562typedef struct
6563{
6564 int w,h;
6565 stbi_uc *out; // output buffer (always 4 components)
6566 stbi_uc *background; // The current "background" as far as a gif is concerned
6567 stbi_uc *history;
6568 int flags, bgindex, ratio, transparent, eflags;
6569 stbi_uc pal[256][4];
6570 stbi_uc lpal[256][4];
6571 stbi__gif_lzw codes[8192];
6572 stbi_uc *color_table;
6573 int parse, step;
6574 int lflags;
6575 int start_x, start_y;
6576 int max_x, max_y;
6577 int cur_x, cur_y;
6578 int line_size;
6579 int delay;
6580} stbi__gif;
6581
6582static int stbi__gif_test_raw(stbi__context *s)
6583{
6584 int sz;
6585 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
6586 sz = stbi__get8(s);
6587 if (sz != '9' && sz != '7') return 0;
6588 if (stbi__get8(s) != 'a') return 0;
6589 return 1;
6590}
6591
6592static int stbi__gif_test(stbi__context *s)
6593{
6594 int r = stbi__gif_test_raw(s);
6595 stbi__rewind(s);
6596 return r;
6597}
6598
6599static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
6600{
6601 int i;
6602 for (i=0; i < num_entries; ++i) {
6603 pal[i][2] = stbi__get8(s);
6604 pal[i][1] = stbi__get8(s);
6605 pal[i][0] = stbi__get8(s);
6606 pal[i][3] = transp == i ? 0 : 255;
6607 }
6608}
6609
6610static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
6611{
6612 stbi_uc version;
6613 if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
6614 return stbi__err("not GIF", "Corrupt GIF");
6615
6616 version = stbi__get8(s);
6617 if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF");
6618 if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF");
6619
6620 stbi__g_failure_reason = "";
6621 g->w = stbi__get16le(s);
6622 g->h = stbi__get16le(s);
6623 g->flags = stbi__get8(s);
6624 g->bgindex = stbi__get8(s);
6625 g->ratio = stbi__get8(s);
6626 g->transparent = -1;
6627
6628 if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
6629 if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
6630
6631 if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
6632
6633 if (is_info) return 1;
6634
6635 if (g->flags & 0x80)
6636 stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
6637
6638 return 1;
6639}
6640
6641static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
6642{
6643 stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
6644 if (!g) return stbi__err("outofmem", "Out of memory");
6645 if (!stbi__gif_header(s, g, comp, 1)) {
6646 STBI_FREE(g);
6647 stbi__rewind( s );
6648 return 0;
6649 }
6650 if (x) *x = g->w;
6651 if (y) *y = g->h;
6652 STBI_FREE(g);
6653 return 1;
6654}
6655
6656static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
6657{
6658 stbi_uc *p, *c;
6659 int idx;
6660
6661 // recurse to decode the prefixes, since the linked-list is backwards,
6662 // and working backwards through an interleaved image would be nasty
6663 if (g->codes[code].prefix >= 0)
6664 stbi__out_gif_code(g, g->codes[code].prefix);
6665
6666 if (g->cur_y >= g->max_y) return;
6667
6668 idx = g->cur_x + g->cur_y;
6669 p = &g->out[idx];
6670 g->history[idx / 4] = 1;
6671
6672 c = &g->color_table[g->codes[code].suffix * 4];
6673 if (c[3] > 128) { // don't render transparent pixels;
6674 p[0] = c[2];
6675 p[1] = c[1];
6676 p[2] = c[0];
6677 p[3] = c[3];
6678 }
6679 g->cur_x += 4;
6680
6681 if (g->cur_x >= g->max_x) {
6682 g->cur_x = g->start_x;
6683 g->cur_y += g->step;
6684
6685 while (g->cur_y >= g->max_y && g->parse > 0) {
6686 g->step = (1 << g->parse) * g->line_size;
6687 g->cur_y = g->start_y + (g->step >> 1);
6688 --g->parse;
6689 }
6690 }
6691}
6692
6693static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
6694{
6695 stbi_uc lzw_cs;
6696 stbi__int32 len, init_code;
6697 stbi__uint32 first;
6698 stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
6699 stbi__gif_lzw *p;
6700
6701 lzw_cs = stbi__get8(s);
6702 if (lzw_cs > 12) return NULL;
6703 clear = 1 << lzw_cs;
6704 first = 1;
6705 codesize = lzw_cs + 1;
6706 codemask = (1 << codesize) - 1;
6707 bits = 0;
6708 valid_bits = 0;
6709 for (init_code = 0; init_code < clear; init_code++) {
6710 g->codes[init_code].prefix = -1;
6711 g->codes[init_code].first = (stbi_uc) init_code;
6712 g->codes[init_code].suffix = (stbi_uc) init_code;
6713 }
6714
6715 // support no starting clear code
6716 avail = clear+2;
6717 oldcode = -1;
6718
6719 len = 0;
6720 for(;;) {
6721 if (valid_bits < codesize) {
6722 if (len == 0) {
6723 len = stbi__get8(s); // start new block
6724 if (len == 0)
6725 return g->out;
6726 }
6727 --len;
6728 bits |= (stbi__int32) stbi__get8(s) << valid_bits;
6729 valid_bits += 8;
6730 } else {
6731 stbi__int32 code = bits & codemask;
6732 bits >>= codesize;
6733 valid_bits -= codesize;
6734 // @OPTIMIZE: is there some way we can accelerate the non-clear path?
6735 if (code == clear) { // clear code
6736 codesize = lzw_cs + 1;
6737 codemask = (1 << codesize) - 1;
6738 avail = clear + 2;
6739 oldcode = -1;
6740 first = 0;
6741 } else if (code == clear + 1) { // end of stream code
6742 stbi__skip(s, len);
6743 while ((len = stbi__get8(s)) > 0)
6744 stbi__skip(s,len);
6745 return g->out;
6746 } else if (code <= avail) {
6747 if (first) {
6748 return stbi__errpuc("no clear code", "Corrupt GIF");
6749 }
6750
6751 if (oldcode >= 0) {
6752 p = &g->codes[avail++];
6753 if (avail > 8192) {
6754 return stbi__errpuc("too many codes", "Corrupt GIF");
6755 }
6756
6757 p->prefix = (stbi__int16) oldcode;
6758 p->first = g->codes[oldcode].first;
6759 p->suffix = (code == avail) ? p->first : g->codes[code].first;
6760 } else if (code == avail)
6761 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
6762
6763 stbi__out_gif_code(g, (stbi__uint16) code);
6764
6765 if ((avail & codemask) == 0 && avail <= 0x0FFF) {
6766 codesize++;
6767 codemask = (1 << codesize) - 1;
6768 }
6769
6770 oldcode = code;
6771 } else {
6772 return stbi__errpuc("illegal code in raster", "Corrupt GIF");
6773 }
6774 }
6775 }
6776}
6777
6778// this function is designed to support animated gifs, although stb_image doesn't support it
6779// two back is the image from two frames ago, used for a very specific disposal format
6780static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
6781{
6782 int dispose;
6783 int first_frame;
6784 int pi;
6785 int pcount;
6786 STBI_NOTUSED(req_comp);
6787
6788 // on first frame, any non-written pixels get the background colour (non-transparent)
6789 first_frame = 0;
6790 if (g->out == 0) {
6791 if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
6792 if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
6793 return stbi__errpuc("too large", "GIF image is too large");
6794 pcount = g->w * g->h;
6795 g->out = (stbi_uc *) stbi__malloc(4 * pcount);
6796 g->background = (stbi_uc *) stbi__malloc(4 * pcount);
6797 g->history = (stbi_uc *) stbi__malloc(pcount);
6798 if (!g->out || !g->background || !g->history)
6799 return stbi__errpuc("outofmem", "Out of memory");
6800
6801 // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
6802 // background colour is only used for pixels that are not rendered first frame, after that "background"
6803 // color refers to the color that was there the previous frame.
6804 memset(g->out, 0x00, 4 * pcount);
6805 memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
6806 memset(g->history, 0x00, pcount); // pixels that were affected previous frame
6807 first_frame = 1;
6808 } else {
6809 // second frame - how do we dispose of the previous one?
6810 dispose = (g->eflags & 0x1C) >> 2;
6811 pcount = g->w * g->h;
6812
6813 if ((dispose == 3) && (two_back == 0)) {
6814 dispose = 2; // if I don't have an image to revert back to, default to the old background
6815 }
6816
6817 if (dispose == 3) { // use previous graphic
6818 for (pi = 0; pi < pcount; ++pi) {
6819 if (g->history[pi]) {
6820 memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
6821 }
6822 }
6823 } else if (dispose == 2) {
6824 // restore what was changed last frame to background before that frame;
6825 for (pi = 0; pi < pcount; ++pi) {
6826 if (g->history[pi]) {
6827 memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
6828 }
6829 }
6830 } else {
6831 // This is a non-disposal case eithe way, so just
6832 // leave the pixels as is, and they will become the new background
6833 // 1: do not dispose
6834 // 0: not specified.
6835 }
6836
6837 // background is what out is after the undoing of the previou frame;
6838 memcpy( g->background, g->out, 4 * g->w * g->h );
6839 }
6840
6841 // clear my history;
6842 memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame
6843
6844 for (;;) {
6845 int tag = stbi__get8(s);
6846 switch (tag) {
6847 case 0x2C: /* Image Descriptor */
6848 {
6849 stbi__int32 x, y, w, h;
6850 stbi_uc *o;
6851
6852 x = stbi__get16le(s);
6853 y = stbi__get16le(s);
6854 w = stbi__get16le(s);
6855 h = stbi__get16le(s);
6856 if (((x + w) > (g->w)) || ((y + h) > (g->h)))
6857 return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
6858
6859 g->line_size = g->w * 4;
6860 g->start_x = x * 4;
6861 g->start_y = y * g->line_size;
6862 g->max_x = g->start_x + w * 4;
6863 g->max_y = g->start_y + h * g->line_size;
6864 g->cur_x = g->start_x;
6865 g->cur_y = g->start_y;
6866
6867 // if the width of the specified rectangle is 0, that means
6868 // we may not see *any* pixels or the image is malformed;
6869 // to make sure this is caught, move the current y down to
6870 // max_y (which is what out_gif_code checks).
6871 if (w == 0)
6872 g->cur_y = g->max_y;
6873
6874 g->lflags = stbi__get8(s);
6875
6876 if (g->lflags & 0x40) {
6877 g->step = 8 * g->line_size; // first interlaced spacing
6878 g->parse = 3;
6879 } else {
6880 g->step = g->line_size;
6881 g->parse = 0;
6882 }
6883
6884 if (g->lflags & 0x80) {
6885 stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
6886 g->color_table = (stbi_uc *) g->lpal;
6887 } else if (g->flags & 0x80) {
6888 g->color_table = (stbi_uc *) g->pal;
6889 } else
6890 return stbi__errpuc("missing color table", "Corrupt GIF");
6891
6892 o = stbi__process_gif_raster(s, g);
6893 if (!o) return NULL;
6894
6895 // if this was the first frame,
6896 pcount = g->w * g->h;
6897 if (first_frame && (g->bgindex > 0)) {
6898 // if first frame, any pixel not drawn to gets the background color
6899 for (pi = 0; pi < pcount; ++pi) {
6900 if (g->history[pi] == 0) {
6901 g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
6902 memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
6903 }
6904 }
6905 }
6906
6907 return o;
6908 }
6909
6910 case 0x21: // Comment Extension.
6911 {
6912 int len;
6913 int ext = stbi__get8(s);
6914 if (ext == 0xF9) { // Graphic Control Extension.
6915 len = stbi__get8(s);
6916 if (len == 4) {
6917 g->eflags = stbi__get8(s);
6918 g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
6919
6920 // unset old transparent
6921 if (g->transparent >= 0) {
6922 g->pal[g->transparent][3] = 255;
6923 }
6924 if (g->eflags & 0x01) {
6925 g->transparent = stbi__get8(s);
6926 if (g->transparent >= 0) {
6927 g->pal[g->transparent][3] = 0;
6928 }
6929 } else {
6930 // don't need transparent
6931 stbi__skip(s, 1);
6932 g->transparent = -1;
6933 }
6934 } else {
6935 stbi__skip(s, len);
6936 break;
6937 }
6938 }
6939 while ((len = stbi__get8(s)) != 0) {
6940 stbi__skip(s, len);
6941 }
6942 break;
6943 }
6944
6945 case 0x3B: // gif stream termination code
6946 return (stbi_uc *) s; // using '1' causes warning on some compilers
6947
6948 default:
6949 return stbi__errpuc("unknown code", "Corrupt GIF");
6950 }
6951 }
6952}
6953
6954static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
6955{
6956 STBI_FREE(g->out);
6957 STBI_FREE(g->history);
6958 STBI_FREE(g->background);
6959
6960 if (out) STBI_FREE(out);
6961 if (delays && *delays) STBI_FREE(*delays);
6962 return stbi__errpuc("outofmem", "Out of memory");
6963}
6964
6965static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
6966{
6967 if (stbi__gif_test(s)) {
6968 int layers = 0;
6969 stbi_uc *u = 0;
6970 stbi_uc *out = 0;
6971 stbi_uc *two_back = 0;
6972 stbi__gif g;
6973 int stride;
6974 int out_size = 0;
6975 int delays_size = 0;
6976
6977 STBI_NOTUSED(out_size);
6978 STBI_NOTUSED(delays_size);
6979
6980 memset(&g, 0, sizeof(g));
6981 if (delays) {
6982 *delays = 0;
6983 }
6984
6985 do {
6986 u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
6987 if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
6988
6989 if (u) {
6990 *x = g.w;
6991 *y = g.h;
6992 ++layers;
6993 stride = g.w * g.h * 4;
6994
6995 if (out) {
6996 void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
6997 if (!tmp)
6998 return stbi__load_gif_main_outofmem(&g, out, delays);
6999 else {
7000 out = (stbi_uc*) tmp;
7001 out_size = layers * stride;
7002 }
7003
7004 if (delays) {
7005 int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
7006 if (!new_delays)
7007 return stbi__load_gif_main_outofmem(&g, out, delays);
7008 *delays = new_delays;
7009 delays_size = layers * sizeof(int);
7010 }
7011 } else {
7012 out = (stbi_uc*)stbi__malloc( layers * stride );
7013 if (!out)
7014 return stbi__load_gif_main_outofmem(&g, out, delays);
7015 out_size = layers * stride;
7016 if (delays) {
7017 *delays = (int*) stbi__malloc( layers * sizeof(int) );
7018 if (!*delays)
7019 return stbi__load_gif_main_outofmem(&g, out, delays);
7020 delays_size = layers * sizeof(int);
7021 }
7022 }
7023 memcpy( out + ((layers - 1) * stride), u, stride );
7024 if (layers >= 2) {
7025 two_back = out - 2 * stride;
7026 }
7027
7028 if (delays) {
7029 (*delays)[layers - 1U] = g.delay;
7030 }
7031 }
7032 } while (u != 0);
7033
7034 // free temp buffer;
7035 STBI_FREE(g.out);
7036 STBI_FREE(g.history);
7037 STBI_FREE(g.background);
7038
7039 // do the final conversion after loading everything;
7040 if (req_comp && req_comp != 4)
7041 out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
7042
7043 *z = layers;
7044 return out;
7045 } else {
7046 return stbi__errpuc("not GIF", "Image was not as a gif type.");
7047 }
7048}
7049
7050static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7051{
7052 stbi_uc *u = 0;
7053 stbi__gif g;
7054 memset(&g, 0, sizeof(g));
7055 STBI_NOTUSED(ri);
7056
7057 u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
7058 if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
7059 if (u) {
7060 *x = g.w;
7061 *y = g.h;
7062
7063 // moved conversion to after successful load so that the same
7064 // can be done for multiple frames.
7065 if (req_comp && req_comp != 4)
7066 u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
7067 } else if (g.out) {
7068 // if there was an error and we allocated an image buffer, free it!
7069 STBI_FREE(g.out);
7070 }
7071
7072 // free buffers needed for multiple frame loading;
7073 STBI_FREE(g.history);
7074 STBI_FREE(g.background);
7075
7076 return u;
7077}
7078
7079static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
7080{
7081 return stbi__gif_info_raw(s,x,y,comp);
7082}
7083#endif
7084
7085// *************************************************************************************************
7086// Radiance RGBE HDR loader
7087// originally by Nicolas Schulz
7088#ifndef STBI_NO_HDR
7089static int stbi__hdr_test_core(stbi__context *s, const char *signature)
7090{
7091 int i;
7092 for (i=0; signature[i]; ++i)
7093 if (stbi__get8(s) != signature[i])
7094 return 0;
7095 stbi__rewind(s);
7096 return 1;
7097}
7098
7099static int stbi__hdr_test(stbi__context* s)
7100{
7101 int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
7102 stbi__rewind(s);
7103 if(!r) {
7104 r = stbi__hdr_test_core(s, "#?RGBE\n");
7105 stbi__rewind(s);
7106 }
7107 return r;
7108}
7109
7110#define STBI__HDR_BUFLEN 1024
7111static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
7112{
7113 int len=0;
7114 char c = '\0';
7115
7116 c = (char) stbi__get8(z);
7117
7118 while (!stbi__at_eof(z) && c != '\n') {
7119 buffer[len++] = c;
7120 if (len == STBI__HDR_BUFLEN-1) {
7121 // flush to end of line
7122 while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
7123 ;
7124 break;
7125 }
7126 c = (char) stbi__get8(z);
7127 }
7128
7129 buffer[len] = 0;
7130 return buffer;
7131}
7132
7133static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
7134{
7135 if ( input[3] != 0 ) {
7136 float f1;
7137 // Exponent
7138 f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
7139 if (req_comp <= 2)
7140 output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
7141 else {
7142 output[0] = input[0] * f1;
7143 output[1] = input[1] * f1;
7144 output[2] = input[2] * f1;
7145 }
7146 if (req_comp == 2) output[1] = 1;
7147 if (req_comp == 4) output[3] = 1;
7148 } else {
7149 switch (req_comp) {
7150 case 4: output[3] = 1; /* fallthrough */
7151 case 3: output[0] = output[1] = output[2] = 0;
7152 break;
7153 case 2: output[1] = 1; /* fallthrough */
7154 case 1: output[0] = 0;
7155 break;
7156 }
7157 }
7158}
7159
7160static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7161{
7162 char buffer[STBI__HDR_BUFLEN];
7163 char *token;
7164 int valid = 0;
7165 int width, height;
7166 stbi_uc *scanline;
7167 float *hdr_data;
7168 int len;
7169 unsigned char count, value;
7170 int i, j, k, c1,c2, z;
7171 const char *headerToken;
7172 STBI_NOTUSED(ri);
7173
7174 // Check identifier
7175 headerToken = stbi__hdr_gettoken(s,buffer);
7176 if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
7177 return stbi__errpf("not HDR", "Corrupt HDR image");
7178
7179 // Parse header
7180 for(;;) {
7181 token = stbi__hdr_gettoken(s,buffer);
7182 if (token[0] == 0) break;
7183 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
7184 }
7185
7186 if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format");
7187
7188 // Parse width and height
7189 // can't use sscanf() if we're not using stdio!
7190 token = stbi__hdr_gettoken(s,buffer);
7191 if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
7192 token += 3;
7193 height = (int) strtol(token, &token, 10);
7194 while (*token == ' ') ++token;
7195 if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format");
7196 token += 3;
7197 width = (int) strtol(token, NULL, 10);
7198
7199 if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
7200 if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
7201
7202 *x = width;
7203 *y = height;
7204
7205 if (comp) *comp = 3;
7206 if (req_comp == 0) req_comp = 3;
7207
7208 if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
7209 return stbi__errpf("too large", "HDR image is too large");
7210
7211 // Read data
7212 hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
7213 if (!hdr_data)
7214 return stbi__errpf("outofmem", "Out of memory");
7215
7216 // Load image data
7217 // image data is stored as some number of sca
7218 if ( width < 8 || width >= 32768) {
7219 // Read flat data
7220 for (j=0; j < height; ++j) {
7221 for (i=0; i < width; ++i) {
7222 stbi_uc rgbe[4];
7223 main_decode_loop:
7224 stbi__getn(s, rgbe, 4);
7225 stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
7226 }
7227 }
7228 } else {
7229 // Read RLE-encoded data
7230 scanline = NULL;
7231
7232 for (j = 0; j < height; ++j) {
7233 c1 = stbi__get8(s);
7234 c2 = stbi__get8(s);
7235 len = stbi__get8(s);
7236 if (c1 != 2 || c2 != 2 || (len & 0x80)) {
7237 // not run-length encoded, so we have to actually use THIS data as a decoded
7238 // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
7239 stbi_uc rgbe[4];
7240 rgbe[0] = (stbi_uc) c1;
7241 rgbe[1] = (stbi_uc) c2;
7242 rgbe[2] = (stbi_uc) len;
7243 rgbe[3] = (stbi_uc) stbi__get8(s);
7244 stbi__hdr_convert(hdr_data, rgbe, req_comp);
7245 i = 1;
7246 j = 0;
7247 STBI_FREE(scanline);
7248 goto main_decode_loop; // yes, this makes no sense
7249 }
7250 len <<= 8;
7251 len |= stbi__get8(s);
7252 if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
7253 if (scanline == NULL) {
7254 scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
7255 if (!scanline) {
7256 STBI_FREE(hdr_data);
7257 return stbi__errpf("outofmem", "Out of memory");
7258 }
7259 }
7260
7261 for (k = 0; k < 4; ++k) {
7262 int nleft;
7263 i = 0;
7264 while ((nleft = width - i) > 0) {
7265 count = stbi__get8(s);
7266 if (count > 128) {
7267 // Run
7268 value = stbi__get8(s);
7269 count -= 128;
7270 if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
7271 for (z = 0; z < count; ++z)
7272 scanline[i++ * 4 + k] = value;
7273 } else {
7274 // Dump
7275 if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
7276 for (z = 0; z < count; ++z)
7277 scanline[i++ * 4 + k] = stbi__get8(s);
7278 }
7279 }
7280 }
7281 for (i=0; i < width; ++i)
7282 stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
7283 }
7284 if (scanline)
7285 STBI_FREE(scanline);
7286 }
7287
7288 return hdr_data;
7289}
7290
7291static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
7292{
7293 char buffer[STBI__HDR_BUFLEN];
7294 char *token;
7295 int valid = 0;
7296 int dummy;
7297
7298 if (!x) x = &dummy;
7299 if (!y) y = &dummy;
7300 if (!comp) comp = &dummy;
7301
7302 if (stbi__hdr_test(s) == 0) {
7303 stbi__rewind( s );
7304 return 0;
7305 }
7306
7307 for(;;) {
7308 token = stbi__hdr_gettoken(s,buffer);
7309 if (token[0] == 0) break;
7310 if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
7311 }
7312
7313 if (!valid) {
7314 stbi__rewind( s );
7315 return 0;
7316 }
7317 token = stbi__hdr_gettoken(s,buffer);
7318 if (strncmp(token, "-Y ", 3)) {
7319 stbi__rewind( s );
7320 return 0;
7321 }
7322 token += 3;
7323 *y = (int) strtol(token, &token, 10);
7324 while (*token == ' ') ++token;
7325 if (strncmp(token, "+X ", 3)) {
7326 stbi__rewind( s );
7327 return 0;
7328 }
7329 token += 3;
7330 *x = (int) strtol(token, NULL, 10);
7331 *comp = 3;
7332 return 1;
7333}
7334#endif // STBI_NO_HDR
7335
7336#ifndef STBI_NO_BMP
7337static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
7338{
7339 void *p;
7340 stbi__bmp_data info;
7341
7342 info.all_a = 255;
7343 p = stbi__bmp_parse_header(s, &info);
7344 if (p == NULL) {
7345 stbi__rewind( s );
7346 return 0;
7347 }
7348 if (x) *x = s->img_x;
7349 if (y) *y = s->img_y;
7350 if (comp) {
7351 if (info.bpp == 24 && info.ma == 0xff000000)
7352 *comp = 3;
7353 else
7354 *comp = info.ma ? 4 : 3;
7355 }
7356 return 1;
7357}
7358#endif
7359
7360#ifndef STBI_NO_PSD
7361static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
7362{
7363 int channelCount, dummy, depth;
7364 if (!x) x = &dummy;
7365 if (!y) y = &dummy;
7366 if (!comp) comp = &dummy;
7367 if (stbi__get32be(s) != 0x38425053) {
7368 stbi__rewind( s );
7369 return 0;
7370 }
7371 if (stbi__get16be(s) != 1) {
7372 stbi__rewind( s );
7373 return 0;
7374 }
7375 stbi__skip(s, 6);
7376 channelCount = stbi__get16be(s);
7377 if (channelCount < 0 || channelCount > 16) {
7378 stbi__rewind( s );
7379 return 0;
7380 }
7381 *y = stbi__get32be(s);
7382 *x = stbi__get32be(s);
7383 depth = stbi__get16be(s);
7384 if (depth != 8 && depth != 16) {
7385 stbi__rewind( s );
7386 return 0;
7387 }
7388 if (stbi__get16be(s) != 3) {
7389 stbi__rewind( s );
7390 return 0;
7391 }
7392 *comp = 4;
7393 return 1;
7394}
7395
7396static int stbi__psd_is16(stbi__context *s)
7397{
7398 int channelCount, depth;
7399 if (stbi__get32be(s) != 0x38425053) {
7400 stbi__rewind( s );
7401 return 0;
7402 }
7403 if (stbi__get16be(s) != 1) {
7404 stbi__rewind( s );
7405 return 0;
7406 }
7407 stbi__skip(s, 6);
7408 channelCount = stbi__get16be(s);
7409 if (channelCount < 0 || channelCount > 16) {
7410 stbi__rewind( s );
7411 return 0;
7412 }
7413 STBI_NOTUSED(stbi__get32be(s));
7414 STBI_NOTUSED(stbi__get32be(s));
7415 depth = stbi__get16be(s);
7416 if (depth != 16) {
7417 stbi__rewind( s );
7418 return 0;
7419 }
7420 return 1;
7421}
7422#endif
7423
7424#ifndef STBI_NO_PIC
7425static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
7426{
7427 int act_comp=0,num_packets=0,chained,dummy;
7428 stbi__pic_packet packets[10];
7429
7430 if (!x) x = &dummy;
7431 if (!y) y = &dummy;
7432 if (!comp) comp = &dummy;
7433
7434 if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
7435 stbi__rewind(s);
7436 return 0;
7437 }
7438
7439 stbi__skip(s, 88);
7440
7441 *x = stbi__get16be(s);
7442 *y = stbi__get16be(s);
7443 if (stbi__at_eof(s)) {
7444 stbi__rewind( s);
7445 return 0;
7446 }
7447 if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
7448 stbi__rewind( s );
7449 return 0;
7450 }
7451
7452 stbi__skip(s, 8);
7453
7454 do {
7455 stbi__pic_packet *packet;
7456
7457 if (num_packets==sizeof(packets)/sizeof(packets[0]))
7458 return 0;
7459
7460 packet = &packets[num_packets++];
7461 chained = stbi__get8(s);
7462 packet->size = stbi__get8(s);
7463 packet->type = stbi__get8(s);
7464 packet->channel = stbi__get8(s);
7465 act_comp |= packet->channel;
7466
7467 if (stbi__at_eof(s)) {
7468 stbi__rewind( s );
7469 return 0;
7470 }
7471 if (packet->size != 8) {
7472 stbi__rewind( s );
7473 return 0;
7474 }
7475 } while (chained);
7476
7477 *comp = (act_comp & 0x10 ? 4 : 3);
7478
7479 return 1;
7480}
7481#endif
7482
7483// *************************************************************************************************
7484// Portable Gray Map and Portable Pixel Map loader
7485// by Ken Miller
7486//
7487// PGM: http://netpbm.sourceforge.net/doc/pgm.html
7488// PPM: http://netpbm.sourceforge.net/doc/ppm.html
7489//
7490// Known limitations:
7491// Does not support comments in the header section
7492// Does not support ASCII image data (formats P2 and P3)
7493
7494#ifndef STBI_NO_PNM
7495
7496static int stbi__pnm_test(stbi__context *s)
7497{
7498 char p, t;
7499 p = (char) stbi__get8(s);
7500 t = (char) stbi__get8(s);
7501 if (p != 'P' || (t != '5' && t != '6')) {
7502 stbi__rewind( s );
7503 return 0;
7504 }
7505 return 1;
7506}
7507
7508static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
7509{
7510 stbi_uc *out;
7511 STBI_NOTUSED(ri);
7512
7513 ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
7514 if (ri->bits_per_channel == 0)
7515 return 0;
7516
7517 if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
7518 if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
7519
7520 *x = s->img_x;
7521 *y = s->img_y;
7522 if (comp) *comp = s->img_n;
7523
7524 if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
7525 return stbi__errpuc("too large", "PNM too large");
7526
7527 out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
7528 if (!out) return stbi__errpuc("outofmem", "Out of memory");
7529 if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
7530 STBI_FREE(out);
7531 return stbi__errpuc("bad PNM", "PNM file truncated");
7532 }
7533
7534 if (req_comp && req_comp != s->img_n) {
7535 if (ri->bits_per_channel == 16) {
7536 out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
7537 } else {
7538 out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
7539 }
7540 if (out == NULL) return out; // stbi__convert_format frees input on failure
7541 }
7542 return out;
7543}
7544
7545static int stbi__pnm_isspace(char c)
7546{
7547 return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
7548}
7549
7550static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
7551{
7552 for (;;) {
7553 while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
7554 *c = (char) stbi__get8(s);
7555
7556 if (stbi__at_eof(s) || *c != '#')
7557 break;
7558
7559 while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
7560 *c = (char) stbi__get8(s);
7561 }
7562}
7563
7564static int stbi__pnm_isdigit(char c)
7565{
7566 return c >= '0' && c <= '9';
7567}
7568
7569static int stbi__pnm_getinteger(stbi__context *s, char *c)
7570{
7571 int value = 0;
7572
7573 while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
7574 value = value*10 + (*c - '0');
7575 *c = (char) stbi__get8(s);
7576 if((value > 214748364) || (value == 214748364 && *c > '7'))
7577 return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
7578 }
7579
7580 return value;
7581}
7582
7583static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
7584{
7585 int maxv, dummy;
7586 char c, p, t;
7587
7588 if (!x) x = &dummy;
7589 if (!y) y = &dummy;
7590 if (!comp) comp = &dummy;
7591
7592 stbi__rewind(s);
7593
7594 // Get identifier
7595 p = (char) stbi__get8(s);
7596 t = (char) stbi__get8(s);
7597 if (p != 'P' || (t != '5' && t != '6')) {
7598 stbi__rewind(s);
7599 return 0;
7600 }
7601
7602 *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm
7603
7604 c = (char) stbi__get8(s);
7605 stbi__pnm_skip_whitespace(s, &c);
7606
7607 *x = stbi__pnm_getinteger(s, &c); // read width
7608 if(*x == 0)
7609 return stbi__err("invalid width", "PPM image header had zero or overflowing width");
7610 stbi__pnm_skip_whitespace(s, &c);
7611
7612 *y = stbi__pnm_getinteger(s, &c); // read height
7613 if (*y == 0)
7614 return stbi__err("invalid width", "PPM image header had zero or overflowing width");
7615 stbi__pnm_skip_whitespace(s, &c);
7616
7617 maxv = stbi__pnm_getinteger(s, &c); // read max value
7618 if (maxv > 65535)
7619 return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
7620 else if (maxv > 255)
7621 return 16;
7622 else
7623 return 8;
7624}
7625
7626static int stbi__pnm_is16(stbi__context *s)
7627{
7628 if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
7629 return 1;
7630 return 0;
7631}
7632#endif
7633
7634static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
7635{
7636 #ifndef STBI_NO_JPEG
7637 if (stbi__jpeg_info(s, x, y, comp)) return 1;
7638 #endif
7639
7640 #ifndef STBI_NO_PNG
7641 if (stbi__png_info(s, x, y, comp)) return 1;
7642 #endif
7643
7644 #ifndef STBI_NO_GIF
7645 if (stbi__gif_info(s, x, y, comp)) return 1;
7646 #endif
7647
7648 #ifndef STBI_NO_BMP
7649 if (stbi__bmp_info(s, x, y, comp)) return 1;
7650 #endif
7651
7652 #ifndef STBI_NO_PSD
7653 if (stbi__psd_info(s, x, y, comp)) return 1;
7654 #endif
7655
7656 #ifndef STBI_NO_PIC
7657 if (stbi__pic_info(s, x, y, comp)) return 1;
7658 #endif
7659
7660 #ifndef STBI_NO_PNM
7661 if (stbi__pnm_info(s, x, y, comp)) return 1;
7662 #endif
7663
7664 #ifndef STBI_NO_HDR
7665 if (stbi__hdr_info(s, x, y, comp)) return 1;
7666 #endif
7667
7668 // test tga last because it's a crappy test!
7669 #ifndef STBI_NO_TGA
7670 if (stbi__tga_info(s, x, y, comp))
7671 return 1;
7672 #endif
7673 return stbi__err("unknown image type", "Image not of any known type, or corrupt");
7674}
7675
7676static int stbi__is_16_main(stbi__context *s)
7677{
7678 #ifndef STBI_NO_PNG
7679 if (stbi__png_is16(s)) return 1;
7680 #endif
7681
7682 #ifndef STBI_NO_PSD
7683 if (stbi__psd_is16(s)) return 1;
7684 #endif
7685
7686 #ifndef STBI_NO_PNM
7687 if (stbi__pnm_is16(s)) return 1;
7688 #endif
7689 return 0;
7690}
7691
7692#ifndef STBI_NO_STDIO
7693STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
7694{
7695 FILE *f = stbi__fopen(filename, "rb");
7696 int result;
7697 if (!f) return stbi__err("can't fopen", "Unable to open file");
7698 result = stbi_info_from_file(f, x, y, comp);
7699 fclose(f);
7700 return result;
7701}
7702
7703STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
7704{
7705 int r;
7706 stbi__context s;
7707 long pos = ftell(f);
7708 stbi__start_file(&s, f);
7709 r = stbi__info_main(&s,x,y,comp);
7710 fseek(f,pos,SEEK_SET);
7711 return r;
7712}
7713
7714STBIDEF int stbi_is_16_bit(char const *filename)
7715{
7716 FILE *f = stbi__fopen(filename, "rb");
7717 int result;
7718 if (!f) return stbi__err("can't fopen", "Unable to open file");
7719 result = stbi_is_16_bit_from_file(f);
7720 fclose(f);
7721 return result;
7722}
7723
7724STBIDEF int stbi_is_16_bit_from_file(FILE *f)
7725{
7726 int r;
7727 stbi__context s;
7728 long pos = ftell(f);
7729 stbi__start_file(&s, f);
7730 r = stbi__is_16_main(&s);
7731 fseek(f,pos,SEEK_SET);
7732 return r;
7733}
7734#endif // !STBI_NO_STDIO
7735
7736STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
7737{
7738 stbi__context s;
7739 stbi__start_mem(&s,buffer,len);
7740 return stbi__info_main(&s,x,y,comp);
7741}
7742
7743STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
7744{
7745 stbi__context s;
7746 stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
7747 return stbi__info_main(&s,x,y,comp);
7748}
7749
7750STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
7751{
7752 stbi__context s;
7753 stbi__start_mem(&s,buffer,len);
7754 return stbi__is_16_main(&s);
7755}
7756
7757STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
7758{
7759 stbi__context s;
7760 stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
7761 return stbi__is_16_main(&s);
7762}
7763
7764#endif // STB_IMAGE_IMPLEMENTATION
7765
7766/* 548/*
7767 revision history: 549 revision history:
7768 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 550 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
HIC SVNT DRACONES