diff --git a/stb_image.c b/stb_image.c index 9426bf5..0c08d88 100644 --- a/stb_image.c +++ b/stb_image.c @@ -22,13 +22,14 @@ - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) Latest revisions: + 1.34 (unknown ) warning fix 1.33 (2011-07-14) minor fixes suggested by Dave Moore 1.32 (2011-07-13) info support for all filetypes (SpartanJ) 1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ) 1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger) 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) - 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila) + 1.27 (2010-08-01) cast-to-stbi__uint8 to fix warnings (Laurent Gomila) allow trailing 0s at end of image data (Laurent Gomila) 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ @@ -55,7 +56,7 @@ Ben "Disch" Wenger (io callbacks) Aruelien Pocheville Martin "SpartanJ" Golini Ryamond Barbiero David Woo - + If your name should be here but isn't, let Sean know. @@ -358,15 +359,14 @@ extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); // implementation: -typedef unsigned char uint8; -typedef unsigned short uint16; -typedef signed short int16; -typedef unsigned int uint32; -typedef signed int int32; -typedef unsigned int uint; +typedef unsigned char stbi__uint8; +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; // should produce compiler error if size is wrong -typedef unsigned char validate_uint32[sizeof(uint32)==4 ? 1 : -1]; +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; #if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE) #define STBI_NO_WRITE @@ -392,7 +392,7 @@ typedef unsigned char validate_uint32[sizeof(uint32)==4 ? 1 : -1]; // contains all the IO context, plus some basic image information typedef struct { - uint32 img_x, img_y; + stbi__uint32 img_x, img_y; int img_n, img_out_n; stbi_io_callbacks io; @@ -400,22 +400,22 @@ typedef struct int read_from_callbacks; int buflen; - uint8 buffer_start[128]; + stbi__uint8 buffer_start[128]; - uint8 *img_buffer, *img_buffer_end; - uint8 *img_buffer_original; + stbi__uint8 *img_buffer, *img_buffer_end; + stbi__uint8 *img_buffer_original; } stbi; static void refill_buffer(stbi *s); // initialize a memory-decode context -static void start_mem(stbi *s, uint8 const *buffer, int len) +static void start_mem(stbi *s, stbi__uint8 const *buffer, int len) { s->io.read = NULL; s->read_from_callbacks = 0; - s->img_buffer = s->img_buffer_original = (uint8 *) buffer; - s->img_buffer_end = (uint8 *) buffer+len; + s->img_buffer = s->img_buffer_original = (stbi__uint8 *) buffer; + s->img_buffer_end = (stbi__uint8 *) buffer+len; } // initialize a callback-based context @@ -749,9 +749,9 @@ stbi_inline static int at_eof(stbi *s) return s->img_buffer >= s->img_buffer_end; } -stbi_inline static uint8 get8u(stbi *s) +stbi_inline static stbi__uint8 get8u(stbi *s) { - return (uint8) get8(s); + return (stbi__uint8) get8(s); } static void skip(stbi *s, int n) @@ -797,9 +797,9 @@ static int get16(stbi *s) return (z << 8) + get8(s); } -static uint32 get32(stbi *s) +static stbi__uint32 get32(stbi *s) { - uint32 z = get16(s); + stbi__uint32 z = get16(s); return (z << 16) + get16(s); } @@ -809,9 +809,9 @@ static int get16le(stbi *s) return z + (get8(s) << 8); } -static uint32 get32le(stbi *s) +static stbi__uint32 get32le(stbi *s) { - uint32 z = get16le(s); + stbi__uint32 z = get16le(s); return z + (get16le(s) << 16); } @@ -826,12 +826,12 @@ static uint32 get32le(stbi *s) // assume data buffer is malloced, so malloc a new one and free that one // only failure mode is malloc failing -static uint8 compute_y(int r, int g, int b) +static stbi__uint8 compute_y(int r, int g, int b) { - return (uint8) (((r*77) + (g*150) + (29*b)) >> 8); + return (stbi__uint8) (((r*77) + (g*150) + (29*b)) >> 8); } -static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y) +static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) { int i,j; unsigned char *good; @@ -906,13 +906,13 @@ static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp) float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f; if (z < 0) z = 0; if (z > 255) z = 255; - output[i*comp + k] = (uint8) float2int(z); + output[i*comp + k] = (stbi__uint8) float2int(z); } if (k < comp) { float z = data[i*comp+k] * 255 + 0.5f; if (z < 0) z = 0; if (z > 255) z = 255; - output[i*comp + k] = (uint8) float2int(z); + output[i*comp + k] = (stbi__uint8) float2int(z); } } free(data); @@ -952,11 +952,11 @@ static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp) typedef struct { - uint8 fast[1 << FAST_BITS]; + stbi__uint8 fast[1 << FAST_BITS]; // weirdly, repacking this into AoS is a 10% speed loss, instead of a win - uint16 code[256]; - uint8 values[256]; - uint8 size[257]; + stbi__uint16 code[256]; + stbi__uint8 values[256]; + stbi__uint8 size[257]; unsigned int maxcode[18]; int delta[17]; // old 'firstsymbol' - old 'firstcode' } huffman; @@ -969,7 +969,7 @@ typedef struct stbi *s; huffman huff_dc[4]; huffman huff_ac[4]; - uint8 dequant[4][64]; + stbi__uint8 dequant[4][64]; // sizes for components, interleaved MCUs int img_h_max, img_v_max; @@ -986,12 +986,12 @@ typedef struct int dc_pred; int x,y,w2,h2; - uint8 *data; + stbi__uint8 *data; void *raw_data; - uint8 *linebuf; + stbi__uint8 *linebuf; } img_comp[4]; - uint32 code_buffer; // jpeg entropy-coded buffer + stbi__uint32 code_buffer; // jpeg entropy-coded buffer int code_bits; // number of valid bits unsigned char marker; // marker seen while filling entropy buffer int nomore; // flag if we saw a marker so must stop @@ -1006,7 +1006,7 @@ static int build_huffman(huffman *h, int *count) // build size list for each symbol (from JPEG spec) for (i=0; i < 16; ++i) for (j=0; j < count[i]; ++j) - h->size[k++] = (uint8) (i+1); + h->size[k++] = (stbi__uint8) (i+1); h->size[k] = 0; // compute actual symbols (from jpeg spec) @@ -1017,7 +1017,7 @@ static int build_huffman(huffman *h, int *count) h->delta[j] = k - code; if (h->size[k] == j) { while (h->size[k] == j) - h->code[k++] = (uint16) (code++); + h->code[k++] = (stbi__uint16) (code++); if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG"); } // compute largest code + 1 for this size, preshifted as needed later @@ -1034,7 +1034,7 @@ static int build_huffman(huffman *h, int *count) int c = h->code[i] << (FAST_BITS-s); int m = 1 << (FAST_BITS-s); for (j=0; j < m; ++j) { - h->fast[c+j] = (uint8) i; + h->fast[c+j] = (stbi__uint8) i; } } } @@ -1059,7 +1059,7 @@ static void grow_buffer_unsafe(jpeg *j) } // (1 << n) - 1 -static uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; +static stbi__uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; // decode a jpeg huffman value from the bitstream stbi_inline static int decode(jpeg *j, huffman *h) @@ -1140,7 +1140,7 @@ stbi_inline static int extend_receive(jpeg *j, int n) // given a value that's at position X in the zigzag stream, // where does it appear in the 8x8 matrix coded as row-major? -static uint8 dezigzag[64+15] = +static stbi__uint8 dezigzag[64+15] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, @@ -1191,14 +1191,14 @@ static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int } // take a -128..127 value and clamp it and convert to 0..255 -stbi_inline static uint8 clamp(int x) +stbi_inline static stbi__uint8 clamp(int x) { // trick to use a single test to catch both cases if ((unsigned int) x > 255) { if (x < 0) return 0; if (x > 255) return 255; } - return (uint8) x; + return (stbi__uint8) x; } #define f2f(x) (int) (((x) * 4096 + 0.5)) @@ -1245,15 +1245,15 @@ stbi_inline static uint8 clamp(int x) #ifdef STBI_SIMD typedef unsigned short stbi_dequantize_t; #else -typedef uint8 stbi_dequantize_t; +typedef stbi__uint8 stbi_dequantize_t; #endif // .344 seconds on 3*anemones.jpg -static void idct_block(uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize) +static void idct_block(stbi__uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize) { int i,val[64],*v=val; stbi_dequantize_t *dq = dequantize; - uint8 *o; + stbi__uint8 *o; short *d = data; // columns @@ -1323,9 +1323,9 @@ void stbi_install_idct(stbi_idct_8x8 func) // if there's a pending marker from the entropy stream, return that // otherwise, fetch from the stream and get a marker. if there's no // marker, return 0xff, which is never a valid marker value -static uint8 get_marker(jpeg *j) +static stbi__uint8 get_marker(jpeg *j) { - uint8 x; + stbi__uint8 x; if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; } x = get8u(j->s); if (x != 0xff) return MARKER_none; @@ -1460,15 +1460,15 @@ static int process_marker(jpeg *z, int m) case 0xC4: // DHT - define huffman table L = get16(z->s)-2; while (L > 0) { - uint8 *v; - int sizes[16],i,m=0; + stbi__uint8 *v; + int sizes[16],i,n=0; int q = get8(z->s); int tc = q >> 4; int th = q & 15; if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG"); for (i=0; i < 16; ++i) { sizes[i] = get8(z->s); - m += sizes[i]; + n += sizes[i]; } L -= 17; if (tc == 0) { @@ -1478,9 +1478,9 @@ static int process_marker(jpeg *z, int m) if (!build_huffman(z->huff_ac+th, sizes)) return 0; v = z->huff_ac[th].values; } - for (i=0; i < m; ++i) + for (i=0; i < n; ++i) v[i] = get8u(z->s); - L -= m; + L -= n; } return L==0; } @@ -1583,7 +1583,7 @@ static int process_frame_header(jpeg *z, int scan) return e("outofmem", "Out of memory"); } // align blocks for installable-idct using mmx/sse - z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].data = (stbi__uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); z->img_comp[i].linebuf = NULL; } @@ -1651,12 +1651,12 @@ static int decode_jpeg_image(jpeg *j) // static jfif-centered resampling (across block boundaries) -typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1, +typedef stbi__uint8 *(*resample_row_func)(stbi__uint8 *out, stbi__uint8 *in0, stbi__uint8 *in1, int w, int hs); -#define div4(x) ((uint8) ((x) >> 2)) +#define div4(x) ((stbi__uint8) ((x) >> 2)) -static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +static stbi__uint8 *resample_row_1(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs) { STBI_NOTUSED(out); STBI_NOTUSED(in_far); @@ -1665,7 +1665,7 @@ static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, i return in_near; } -static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +static stbi__uint8* resample_row_v_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs) { // need to generate two samples vertically for every one in input int i; @@ -1675,11 +1675,11 @@ static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, return out; } -static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +static stbi__uint8* resample_row_h_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs) { // need to generate two samples horizontally for every one in input int i; - uint8 *input = in_near; + stbi__uint8 *input = in_near; if (w == 1) { // if only one sample, can't do any interpolation @@ -1703,9 +1703,9 @@ static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w return out; } -#define div16(x) ((uint8) ((x) >> 4)) +#define div16(x) ((stbi__uint8) ((x) >> 4)) -static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +static stbi__uint8 *resample_row_hv_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs) { // need to generate 2x2 samples for every one in input int i,t0,t1; @@ -1729,11 +1729,11 @@ static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w return out; } -static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +static stbi__uint8 *resample_row_generic(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs) { // resample with nearest-neighbor int i,j; - in_far = in_far; + STBI_NOTUSED(in_far); for (i=0; i < w; ++i) for (j=0; j < hs; ++j) out[i*hs+j] = in_near[i]; @@ -1744,7 +1744,7 @@ static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, in // 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro) // VC6 without processor=Pro is generating multiple LEAs per multiply! -static void YCbCr_to_RGB_row(uint8 *out, const uint8 *y, const uint8 *pcb, const uint8 *pcr, int count, int step) +static void YCbCr_to_RGB_row(stbi__uint8 *out, const stbi__uint8 *y, const stbi__uint8 *pcb, const stbi__uint8 *pcr, int count, int step) { int i; for (i=0; i < count; ++i) { @@ -1761,9 +1761,9 @@ static void YCbCr_to_RGB_row(uint8 *out, const uint8 *y, const uint8 *pcb, const if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } - out[0] = (uint8)r; - out[1] = (uint8)g; - out[2] = (uint8)b; + out[0] = (stbi__uint8)r; + out[1] = (stbi__uint8)g; + out[2] = (stbi__uint8)b; out[3] = 255; out += step; } @@ -1798,14 +1798,14 @@ static void cleanup_jpeg(jpeg *j) typedef struct { resample_row_func resample; - uint8 *line0,*line1; + stbi__uint8 *line0,*line1; int hs,vs; // expansion factor in each axis int w_lores; // horizontal pixels pre-expansion int ystep; // how far through vertical expansion we are int ypos; // which pre-expansion row we're on } stbi_resample; -static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +static stbi__uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) { int n, decode_n; // validate req_comp @@ -1826,9 +1826,9 @@ static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int re // resample and color-convert { int k; - uint i,j; - uint8 *output; - uint8 *coutput[4]; + unsigned int i,j; + stbi__uint8 *output; + stbi__uint8 *coutput[4]; stbi_resample res_comp[4]; @@ -1837,7 +1837,7 @@ static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int re // allocate line buffer big enough for upsampling off the edges // with upsample factor of 4 - z->img_comp[k].linebuf = (uint8 *) malloc(z->s->img_x + 3); + z->img_comp[k].linebuf = (stbi__uint8 *) malloc(z->s->img_x + 3); if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } r->hs = z->img_h_max / z->img_comp[k].h; @@ -1855,12 +1855,12 @@ static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int re } // can't error after this so, this is safe - output = (uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1); + output = (stbi__uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1); if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } // now go ahead and resample for (j=0; j < z->s->img_y; ++j) { - uint8 *out = output + n * z->s->img_x * j; + stbi__uint8 *out = output + n * z->s->img_x * j; for (k=0; k < decode_n; ++k) { stbi_resample *r = &res_comp[k]; int y_bot = r->ystep >= (r->vs >> 1); @@ -1876,7 +1876,7 @@ static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int re } } if (n >= 3) { - uint8 *y = coutput[0]; + stbi__uint8 *y = coutput[0]; if (z->s->img_n == 3) { #ifdef STBI_SIMD stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n); @@ -1890,7 +1890,7 @@ static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int re out += n; } } else { - uint8 *y = coutput[0]; + stbi__uint8 *y = coutput[0]; if (n == 1) for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; else @@ -1956,12 +1956,12 @@ static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp) // (jpegs packs from left, zlib from right, so can't share code) typedef struct { - uint16 fast[1 << ZFAST_BITS]; - uint16 firstcode[16]; + stbi__uint16 fast[1 << ZFAST_BITS]; + stbi__uint16 firstcode[16]; int maxcode[17]; - uint16 firstsymbol[16]; - uint8 size[288]; - uint16 value[288]; + stbi__uint16 firstsymbol[16]; + stbi__uint8 size[288]; + stbi__uint16 value[288]; } zhuffman; stbi_inline static int bitreverse16(int n) @@ -1981,7 +1981,7 @@ stbi_inline static int bit_reverse(int v, int bits) return bitreverse16(v) >> (16-bits); } -static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num) +static int zbuild_huffman(zhuffman *z, stbi__uint8 *sizelist, int num) { int i,k=0; int code, next_code[16], sizes[17]; @@ -1997,8 +1997,8 @@ static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num) code = 0; for (i=1; i < 16; ++i) { next_code[i] = code; - z->firstcode[i] = (uint16) code; - z->firstsymbol[i] = (uint16) k; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; code = (code + sizes[i]); if (sizes[i]) if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG"); @@ -2011,12 +2011,12 @@ static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num) int s = sizelist[i]; if (s) { int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; - z->size[c] = (uint8)s; - z->value[c] = (uint16)i; + z->size[c] = (stbi__uint8)s; + z->value[c] = (stbi__uint16)i; if (s <= ZFAST_BITS) { int k = bit_reverse(next_code[s],s); while (k < (1 << ZFAST_BITS)) { - z->fast[k] = (uint16) c; + z->fast[k] = (stbi__uint16) c; k += (1 << s); } } @@ -2034,9 +2034,9 @@ static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num) typedef struct { - uint8 *zbuffer, *zbuffer_end; + stbi__uint8 *zbuffer, *zbuffer_end; int num_bits; - uint32 code_buffer; + stbi__uint32 code_buffer; char *zout; char *zout_start; @@ -2138,7 +2138,7 @@ static int parse_huffman_block(zbuf *a) if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0; *a->zout++ = (char) z; } else { - uint8 *p; + stbi__uint8 *p; int len,dist; if (z == 256) return 1; z -= 257; @@ -2150,7 +2150,7 @@ static int parse_huffman_block(zbuf *a) if (dist_extra[z]) dist += zreceive(a, dist_extra[z]); if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG"); if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0; - p = (uint8 *) (a->zout - dist); + p = (stbi__uint8 *) (a->zout - dist); while (len--) *a->zout++ = *p++; } @@ -2159,10 +2159,10 @@ static int parse_huffman_block(zbuf *a) static int compute_huffman_codes(zbuf *a) { - static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + static stbi__uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; zhuffman z_codelength; - uint8 lencodes[286+32+137];//padding for maximum single op - uint8 codelength_sizes[19]; + stbi__uint8 lencodes[286+32+137];//padding for maximum single op + stbi__uint8 codelength_sizes[19]; int i,n; int hlit = zreceive(a,5) + 257; @@ -2172,7 +2172,7 @@ static int compute_huffman_codes(zbuf *a) memset(codelength_sizes, 0, sizeof(codelength_sizes)); for (i=0; i < hclen; ++i) { int s = zreceive(a,3); - codelength_sizes[length_dezigzag[i]] = (uint8) s; + codelength_sizes[length_dezigzag[i]] = (stbi__uint8) s; } if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; @@ -2181,7 +2181,7 @@ static int compute_huffman_codes(zbuf *a) int c = zhuffman_decode(a, &z_codelength); assert(c >= 0 && c < 19); if (c < 16) - lencodes[n++] = (uint8) c; + lencodes[n++] = (stbi__uint8) c; else if (c == 16) { c = zreceive(a,2)+3; memset(lencodes+n, lencodes[n-1], c); @@ -2205,21 +2205,21 @@ static int compute_huffman_codes(zbuf *a) static int parse_uncompressed_block(zbuf *a) { - uint8 header[4]; + stbi__uint8 header[4]; int len,nlen,k; if (a->num_bits & 7) zreceive(a, a->num_bits & 7); // discard // drain the bit-packed data into header k = 0; while (a->num_bits > 0) { - header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns? + header[k++] = (stbi__uint8) (a->code_buffer & 255); // wtf this warns? a->code_buffer >>= 8; a->num_bits -= 8; } assert(a->num_bits == 0); // now fill header the normal way while (k < 4) - header[k++] = (uint8) zget8(a); + header[k++] = (stbi__uint8) zget8(a); len = header[1] * 256 + header[0]; nlen = header[3] * 256 + header[2]; if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG"); @@ -2246,7 +2246,7 @@ static int parse_zlib_header(zbuf *a) } // @TODO: should statically initialize these for optimal thread safety -static uint8 default_length[288], default_distance[32]; +static stbi__uint8 default_length[288], default_distance[32]; static void init_defaults(void) { int i; // use <= to match clearly with spec @@ -2305,8 +2305,8 @@ char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial zbuf a; char *p = (char *) malloc(initial_size); if (p == NULL) return NULL; - a.zbuffer = (uint8 *) buffer; - a.zbuffer_end = (uint8 *) buffer + len; + a.zbuffer = (stbi__uint8 *) buffer; + a.zbuffer_end = (stbi__uint8 *) buffer + len; if (do_zlib(&a, p, initial_size, 1, 1)) { if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; @@ -2326,8 +2326,8 @@ char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, zbuf a; char *p = (char *) malloc(initial_size); if (p == NULL) return NULL; - a.zbuffer = (uint8 *) buffer; - a.zbuffer_end = (uint8 *) buffer + len; + a.zbuffer = (stbi__uint8 *) buffer; + a.zbuffer_end = (stbi__uint8 *) buffer + len; if (do_zlib(&a, p, initial_size, 1, parse_header)) { if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; @@ -2340,8 +2340,8 @@ char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) { zbuf a; - a.zbuffer = (uint8 *) ibuffer; - a.zbuffer_end = (uint8 *) ibuffer + ilen; + a.zbuffer = (stbi__uint8 *) ibuffer; + a.zbuffer_end = (stbi__uint8 *) ibuffer + ilen; if (do_zlib(&a, obuffer, olen, 0, 1)) return (int) (a.zout - a.zout_start); else @@ -2353,8 +2353,8 @@ char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) zbuf a; char *p = (char *) malloc(16384); if (p == NULL) return NULL; - a.zbuffer = (uint8 *) buffer; - a.zbuffer_end = (uint8 *) buffer+len; + a.zbuffer = (stbi__uint8 *) buffer; + a.zbuffer_end = (stbi__uint8 *) buffer+len; if (do_zlib(&a, p, 16384, 1, 0)) { if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; @@ -2367,8 +2367,8 @@ char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) { zbuf a; - a.zbuffer = (uint8 *) ibuffer; - a.zbuffer_end = (uint8 *) ibuffer + ilen; + a.zbuffer = (stbi__uint8 *) ibuffer; + a.zbuffer_end = (stbi__uint8 *) ibuffer + ilen; if (do_zlib(&a, obuffer, olen, 0, 0)) return (int) (a.zout - a.zout_start); else @@ -2388,8 +2388,8 @@ int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffe typedef struct { - uint32 length; - uint32 type; + stbi__uint32 length; + stbi__uint32 type; } chunk; #define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) @@ -2404,7 +2404,7 @@ static chunk get_chunk_header(stbi *s) static int check_png_header(stbi *s) { - static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 }; + static stbi__uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 }; int i; for (i=0; i < 8; ++i) if (get8u(s) != png_sig[i]) return e("bad png sig","Not a PNG"); @@ -2414,7 +2414,7 @@ static int check_png_header(stbi *s) typedef struct { stbi *s; - uint8 *idata, *expanded, *out; + stbi__uint8 *idata, *expanded, *out; } png; @@ -2423,7 +2423,7 @@ enum { F_avg_first, F_paeth_first }; -static uint8 first_row_filter[5] = +static stbi__uint8 first_row_filter[5] = { F_none, F_sub, F_none, F_avg_first, F_paeth_first }; @@ -2440,15 +2440,15 @@ static int paeth(int a, int b, int c) } // create the png data from post-deflated data -static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, uint32 x, uint32 y) +static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y) { stbi *s = a->s; - uint32 i,j,stride = x*out_n; + stbi__uint32 i,j,stride = x*out_n; int k; int img_n = s->img_n; // copy it into a local for later assert(out_n == s->img_n || out_n == s->img_n+1); if (stbi_png_partial) y = 1; - a->out = (uint8 *) malloc(x * y * out_n); + a->out = (stbi__uint8 *) malloc(x * y * out_n); if (!a->out) return e("outofmem", "Out of memory"); if (!stbi_png_partial) { if (s->img_x == x && s->img_y == y) { @@ -2458,8 +2458,8 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u } } for (j=0; j < y; ++j) { - uint8 *cur = a->out + stride*j; - uint8 *prior = cur - stride; + stbi__uint8 *cur = a->out + stride*j; + stbi__uint8 *prior = cur - stride; int filter = *raw++; if (filter > 4) return e("invalid filter","Corrupt PNG"); // if first row, use special filter that doesn't sample previous row @@ -2471,7 +2471,7 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u case F_sub : cur[k] = raw[k]; break; case F_up : cur[k] = raw[k] + prior[k]; break; case F_avg : cur[k] = raw[k] + (prior[k]>>1); break; - case F_paeth : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break; + case F_paeth : cur[k] = (stbi__uint8) (raw[k] + paeth(0,prior[k],0)); break; case F_avg_first : cur[k] = raw[k]; break; case F_paeth_first: cur[k] = raw[k]; break; } @@ -2491,9 +2491,9 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u CASE(F_sub) cur[k] = raw[k] + cur[k-img_n]; break; CASE(F_up) cur[k] = raw[k] + prior[k]; break; CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break; - CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; + CASE(F_paeth) cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; CASE(F_avg_first) cur[k] = raw[k] + (cur[k-img_n] >> 1); break; - CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break; + CASE(F_paeth_first) cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break; } #undef CASE } else { @@ -2507,9 +2507,9 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u CASE(F_sub) cur[k] = raw[k] + cur[k-out_n]; break; CASE(F_up) cur[k] = raw[k] + prior[k]; break; CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break; - CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; + CASE(F_paeth) cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; CASE(F_avg_first) cur[k] = raw[k] + (cur[k-out_n] >> 1); break; - CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break; + CASE(F_paeth_first) cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break; } #undef CASE } @@ -2517,9 +2517,9 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u return 1; } -static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int interlaced) +static int create_png_image(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int out_n, int interlaced) { - uint8 *final; + stbi__uint8 *final; int p; int save; if (!interlaced) @@ -2528,7 +2528,7 @@ static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int i stbi_png_partial = 0; // de-interlacing - final = (uint8 *) malloc(a->s->img_x * a->s->img_y * out_n); + final = (stbi__uint8 *) malloc(a->s->img_x * a->s->img_y * out_n); for (p=0; p < 7; ++p) { int xorig[] = { 0,4,0,2,0,1,0 }; int yorig[] = { 0,0,4,0,2,0,1 }; @@ -2558,11 +2558,11 @@ static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int i return 1; } -static int compute_transparency(png *z, uint8 tc[3], int out_n) +static int compute_transparency(png *z, stbi__uint8 tc[3], int out_n) { stbi *s = z->s; - uint32 i, pixel_count = s->img_x * s->img_y; - uint8 *p = z->out; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint8 *p = z->out; // compute color-based transparency, assuming we've // already got 255 as the alpha value in the output @@ -2583,12 +2583,12 @@ static int compute_transparency(png *z, uint8 tc[3], int out_n) return 1; } -static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n) +static int expand_palette(png *a, stbi__uint8 *palette, int len, int pal_img_n) { - uint32 i, pixel_count = a->s->img_x * a->s->img_y; - uint8 *p, *temp_out, *orig = a->out; + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi__uint8 *p, *temp_out, *orig = a->out; - p = (uint8 *) malloc(pixel_count * pal_img_n); + p = (stbi__uint8 *) malloc(pixel_count * pal_img_n); if (p == NULL) return e("outofmem", "Out of memory"); // between here and free(out) below, exitting would leak @@ -2635,12 +2635,12 @@ void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) static void stbi_de_iphone(png *z) { stbi *s = z->s; - uint32 i, pixel_count = s->img_x * s->img_y; - uint8 *p = z->out; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint8 *p = z->out; if (s->img_out_n == 3) { // convert bgr to rgb for (i=0; i < pixel_count; ++i) { - uint8 t = p[0]; + stbi__uint8 t = p[0]; p[0] = p[2]; p[2] = t; p += 3; @@ -2650,8 +2650,8 @@ static void stbi_de_iphone(png *z) if (stbi_unpremultiply_on_load) { // convert bgr to rgb and unpremultiply for (i=0; i < pixel_count; ++i) { - uint8 a = p[3]; - uint8 t = p[0]; + stbi__uint8 a = p[3]; + stbi__uint8 t = p[0]; if (a) { p[0] = p[2] * 255 / a; p[1] = p[1] * 255 / a; @@ -2665,7 +2665,7 @@ static void stbi_de_iphone(png *z) } else { // convert bgr to rgb for (i=0; i < pixel_count; ++i) { - uint8 t = p[0]; + stbi__uint8 t = p[0]; p[0] = p[2]; p[2] = t; p += 4; @@ -2676,9 +2676,9 @@ static void stbi_de_iphone(png *z) static int parse_png_file(png *z, int scan, int req_comp) { - uint8 palette[1024], pal_img_n=0; - uint8 has_trans=0, tc[3]; - uint32 ioff=0, idata_limit=0, i, pal_len=0; + stbi__uint8 palette[1024], pal_img_n=0; + stbi__uint8 has_trans=0, tc[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; int first=1,k,interlace=0, iphone=0; stbi *s = z->s; @@ -2751,10 +2751,10 @@ static int parse_png_file(png *z, int scan, int req_comp) palette[i*4+3] = get8u(s); } else { if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG"); - if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); has_trans = 1; for (k=0; k < s->img_n; ++k) - tc[k] = (uint8) get16(s); // non 8-bit images will be larger + tc[k] = (stbi__uint8) get16(s); // non 8-bit images will be larger } break; } @@ -2764,11 +2764,11 @@ static int parse_png_file(png *z, int scan, int req_comp) if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG"); if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; } if (ioff + c.length > idata_limit) { - uint8 *p; + stbi__uint8 *p; if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; while (ioff + c.length > idata_limit) idata_limit *= 2; - p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); + p = (stbi__uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); z->idata = p; } if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG"); @@ -2777,11 +2777,11 @@ static int parse_png_file(png *z, int scan, int req_comp) } case PNG_TYPE('I','E','N','D'): { - uint32 raw_len; + stbi__uint32 raw_len; if (first) return e("first not IHDR", "Corrupt PNG"); if (scan != SCAN_load) return 1; if (z->idata == NULL) return e("no IDAT","Corrupt PNG"); - z->expanded = (uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone); + z->expanded = (stbi__uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone); if (z->expanded == NULL) return 0; // zlib should set error free(z->idata); z->idata = NULL; if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) @@ -2812,10 +2812,10 @@ static int parse_png_file(png *z, int scan, int req_comp) #ifndef STBI_NO_FAILURE_STRINGS // not threadsafe static char invalid_chunk[] = "XXXX chunk not known"; - invalid_chunk[0] = (uint8) (c.type >> 24); - invalid_chunk[1] = (uint8) (c.type >> 16); - invalid_chunk[2] = (uint8) (c.type >> 8); - invalid_chunk[3] = (uint8) (c.type >> 0); + invalid_chunk[0] = (stbi__uint8) (c.type >> 24); + invalid_chunk[1] = (stbi__uint8) (c.type >> 16); + invalid_chunk[2] = (stbi__uint8) (c.type >> 8); + invalid_chunk[3] = (stbi__uint8) (c.type >> 0); #endif return e(invalid_chunk, "PNG not supported: unknown chunk type"); } @@ -2950,7 +2950,7 @@ static int shiftsigned(int v, int shift, int bits) static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp) { - uint8 *out; + stbi__uint8 *out; unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0; stbi_uc pal[256][4]; int psize=0,i,j,compress=0,width; @@ -3105,17 +3105,17 @@ static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp) out[z+0] = get8u(s); z += 3; a = (easy == 2 ? get8(s) : 255); - if (target == 4) out[z++] = (uint8) a; + if (target == 4) out[z++] = (stbi__uint8) a; } } else { for (i=0; i < (int) s->img_x; ++i) { - uint32 v = (bpp == 16 ? get16le(s) : get32le(s)); + stbi__uint32 v = (bpp == 16 ? get16le(s) : get32le(s)); int a; - out[z++] = (uint8) shiftsigned(v & mr, rshift, rcount); - out[z++] = (uint8) shiftsigned(v & mg, gshift, gcount); - out[z++] = (uint8) shiftsigned(v & mb, bshift, bcount); + out[z++] = (stbi__uint8) shiftsigned(v & mr, rshift, rcount); + out[z++] = (stbi__uint8) shiftsigned(v & mg, gshift, gcount); + out[z++] = (stbi__uint8) shiftsigned(v & mb, bshift, bcount); a = (ma ? shiftsigned(v & ma, ashift, acount) : 255); - if (target == 4) out[z++] = (uint8) a; + if (target == 4) out[z++] = (stbi__uint8) a; } } skip(s, pad); @@ -3298,7 +3298,10 @@ static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp) skip(s, tga_palette_start ); // load the palette tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 ); - if (!tga_palette) return epuc("outofmem", "Out of memory"); + if (!tga_palette) { + free(tga_data); + return epuc("outofmem", "Out of memory"); + } if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { free(tga_data); free(tga_palette); @@ -3475,7 +3478,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) int channelCount, compression; int channel, i, count, len; int w,h; - uint8 *out; + stbi__uint8 *out; // Check identifier if (get32(s) != 0x38425053) // "8BPS" @@ -3555,7 +3558,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) // Read the RLE data by channel. for (channel = 0; channel < 4; channel++) { - uint8 *p; + stbi__uint8 *p; p = out+channel; if (channel >= channelCount) { @@ -3578,7 +3581,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) len--; } } else if (len > 128) { - uint8 val; + stbi__uint8 val; // Next -len+1 bytes in the dest are replicated from next source byte. // (Interpret len as a negative 8-bit int.) len ^= 0x0FF; @@ -3601,7 +3604,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) // Read the data by channel. for (channel = 0; channel < 4; channel++) { - uint8 *p; + stbi__uint8 *p; p = out + channel; if (channel > channelCount) { @@ -3752,7 +3755,7 @@ static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *resul if (at_eof(s)) return epuc("bad file","file too short (pure read count)"); if (count > left) - count = (uint8) left; + count = (stbi__uint8) left; if (!pic_readval(s,packet->channel,value)) return 0; @@ -3852,9 +3855,9 @@ static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp) // ************************************************************************************************* // GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb typedef struct stbi_gif_lzw_struct { - int16 prefix; - uint8 first; - uint8 suffix; + stbi__int16 prefix; + stbi__uint8 first; + stbi__uint8 suffix; } stbi_gif_lzw; typedef struct stbi_gif_struct @@ -3862,10 +3865,10 @@ typedef struct stbi_gif_struct int w,h; stbi_uc *out; // output buffer (always 4 components) int flags, bgindex, ratio, transparent, eflags; - uint8 pal[256][4]; - uint8 lpal[256][4]; + stbi__uint8 pal[256][4]; + stbi__uint8 lpal[256][4]; stbi_gif_lzw codes[4096]; - uint8 *color_table; + stbi__uint8 *color_table; int parse, step; int lflags; int start_x, start_y; @@ -3891,7 +3894,7 @@ static int stbi_gif_test(stbi *s) return r; } -static void stbi_gif_parse_colortable(stbi *s, uint8 pal[256][4], int num_entries, int transp) +static void stbi_gif_parse_colortable(stbi *s, stbi__uint8 pal[256][4], int num_entries, int transp) { int i; for (i=0; i < num_entries; ++i) { @@ -3904,7 +3907,7 @@ static void stbi_gif_parse_colortable(stbi *s, uint8 pal[256][4], int num_entrie static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info) { - uint8 version; + stbi__uint8 version; if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return e("not GIF", "Corrupt GIF"); @@ -3942,9 +3945,9 @@ static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp) return 1; } -static void stbi_out_gif_code(stbi_gif *g, uint16 code) +static void stbi_out_gif_code(stbi_gif *g, stbi__uint16 code) { - uint8 *p, *c; + stbi__uint8 *p, *c; // recurse to decode the prefixes, since the linked-list is backwards, // and working backwards through an interleaved image would be nasty @@ -3976,12 +3979,12 @@ static void stbi_out_gif_code(stbi_gif *g, uint16 code) } } -static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) +static stbi__uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) { - uint8 lzw_cs; - int32 len, code; - uint32 first; - int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__uint8 lzw_cs; + stbi__int32 len, code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; stbi_gif_lzw *p; lzw_cs = get8u(s); @@ -3993,8 +3996,8 @@ static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) valid_bits = 0; for (code = 0; code < clear; code++) { g->codes[code].prefix = -1; - g->codes[code].first = (uint8) code; - g->codes[code].suffix = (uint8) code; + g->codes[code].first = (stbi__uint8) code; + g->codes[code].suffix = (stbi__uint8) code; } // support no starting clear code @@ -4010,10 +4013,10 @@ static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) return g->out; } --len; - bits |= (int32) get8(s) << valid_bits; + bits |= (stbi__int32) get8(s) << valid_bits; valid_bits += 8; } else { - int32 code = bits & codemask; + stbi__int32 code = bits & codemask; bits >>= codesize; valid_bits -= codesize; // @OPTIMIZE: is there some way we can accelerate the non-clear path? @@ -4034,13 +4037,13 @@ static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) if (oldcode >= 0) { p = &g->codes[avail++]; if (avail > 4096) return epuc("too many codes", "Corrupt GIF"); - p->prefix = (int16) oldcode; + p->prefix = (stbi__int16) oldcode; p->first = g->codes[oldcode].first; p->suffix = (code == avail) ? p->first : g->codes[code].first; } else if (code == avail) return epuc("illegal code in raster", "Corrupt GIF"); - stbi_out_gif_code(g, (uint16) code); + stbi_out_gif_code(g, (stbi__uint16) code); if ((avail & codemask) == 0 && avail <= 0x0FFF) { codesize++; @@ -4058,10 +4061,10 @@ static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) static void stbi_fill_gif_background(stbi_gif *g) { int i; - uint8 *c = g->pal[g->bgindex]; + stbi__uint8 *c = g->pal[g->bgindex]; // @OPTIMIZE: write a dword at a time for (i = 0; i < g->w * g->h * 4; i += 4) { - uint8 *p = &g->out[i]; + stbi__uint8 *p = &g->out[i]; p[0] = c[2]; p[1] = c[1]; p[2] = c[0]; @@ -4070,21 +4073,21 @@ static void stbi_fill_gif_background(stbi_gif *g) } // this function is designed to support animated gifs, although stb_image doesn't support it -static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) +static stbi__uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) { int i; - uint8 *old_out = 0; + stbi__uint8 *old_out = 0; if (g->out == 0) { if (!stbi_gif_header(s, g, comp,0)) return 0; // failure_reason set by stbi_gif_header - g->out = (uint8 *) malloc(4 * g->w * g->h); + g->out = (stbi__uint8 *) malloc(4 * g->w * g->h); if (g->out == 0) return epuc("outofmem", "Out of memory"); stbi_fill_gif_background(g); } else { // animated-gif-only path if (((g->eflags & 0x1C) >> 2) == 3) { old_out = g->out; - g->out = (uint8 *) malloc(4 * g->w * g->h); + g->out = (stbi__uint8 *) malloc(4 * g->w * g->h); if (g->out == 0) return epuc("outofmem", "Out of memory"); memcpy(g->out, old_out, g->w*g->h*4); } @@ -4094,8 +4097,8 @@ static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) switch (get8(s)) { case 0x2C: /* Image Descriptor */ { - int32 x, y, w, h; - uint8 *o; + stbi__int32 x, y, w, h; + stbi__uint8 *o; x = get16le(s); y = get16le(s); @@ -4124,13 +4127,13 @@ static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) if (g->lflags & 0x80) { stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); - g->color_table = (uint8 *) g->lpal; + g->color_table = (stbi__uint8 *) g->lpal; } else if (g->flags & 0x80) { for (i=0; i < 256; ++i) // @OPTIMIZE: reset only the previous transparent g->pal[i][3] = 255; if (g->transparent >= 0 && (g->eflags & 0x01)) g->pal[g->transparent][3] = 0; - g->color_table = (uint8 *) g->pal; + g->color_table = (stbi__uint8 *) g->pal; } else return epuc("missing color table", "Corrupt GIF"); @@ -4162,7 +4165,7 @@ static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) } case 0x3B: // gif stream termination code - return (uint8 *) 1; + return (stbi__uint8 *) 1; default: return epuc("unknown code", "Corrupt GIF"); @@ -4172,7 +4175,7 @@ static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp) { - uint8 *u = 0; + stbi__uint8 *u = 0; stbi_gif g={0}; u = stbi_gif_load_next(s, &g, comp, req_comp); @@ -4331,11 +4334,11 @@ static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) if (c1 != 2 || c2 != 2 || (len & 0x80)) { // not run-length encoded, so we have to actually use THIS data as a decoded // pixel (note this can't be a valid pixel--one of RGB must be >= 128) - uint8 rgbe[4]; - rgbe[0] = (uint8) c1; - rgbe[1] = (uint8) c2; - rgbe[2] = (uint8) len; - rgbe[3] = (uint8) get8u(s); + stbi__uint8 rgbe[4]; + rgbe[0] = (stbi__uint8) c1; + rgbe[1] = (stbi__uint8) c2; + rgbe[2] = (stbi__uint8) len; + rgbe[3] = (stbi__uint8) get8u(s); hdr_convert(hdr_data, rgbe, req_comp); i = 1; j = 0; @@ -4587,6 +4590,9 @@ int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int /* revision history: + 1.35 (2014-05-27) + 1.34 (unknown) + use STBI_NOTUSED in resample_row_generic(), fix one more leak in tga failure case 1.33 (2011-07-14) make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements 1.32 (2011-07-13) @@ -4604,7 +4610,7 @@ int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) 1.27 (2010-08-01) - cast-to-uint8 to fix warnings + cast-to-stbi__uint8 to fix warnings 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ 1.25 (2010-07-17) @@ -4621,7 +4627,7 @@ int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int GIF support from Jean-Marc Lienher iPhone PNG-extensions from James Brown warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva) - 1.21 fix use of 'uint8' in header (reported by jon blow) + 1.21 fix use of 'stbi__uint8' in header (reported by jon blow) 1.20 added support for Softimage PIC, by Tom Seddon 1.19 bug in interlaced PNG corruption check (found by ryg) 1.18 2008-08-02