From 54735dec849a0f687d71288f458ab1050b7dd806 Mon Sep 17 00:00:00 2001 From: Robert Bragg Date: Mon, 16 Apr 2012 21:56:40 +0100 Subject: Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0) --- cogl/stb_image.c | 342 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 173 insertions(+), 169 deletions(-) (limited to 'cogl/stb_image.c') diff --git a/cogl/stb_image.c b/cogl/stb_image.c index 1aaef606..ed884851 100644 --- a/cogl/stb_image.c +++ b/cogl/stb_image.c @@ -14,10 +14,10 @@ writes BMP,TGA (define STBI_NO_WRITE to remove code) decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code) supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) - + TODO: stbi_info_* - + history: 1.18 fix a threading bug (local mutable static) 1.17 support interlaced PNG @@ -82,7 +82,7 @@ // Basic usage (see HDR discussion below): // int x,y,n; // unsigned char *data = stbi_load(filename, &x, &y, &n, 0); -// // ... process data if not NULL ... +// // ... process data if not NULL ... // // ... x = width, y = height, n = # 8-bit components per pixel ... // // ... replace '0' with '1'..'4' to force that many components per pixel // stbi_image_free(data) @@ -143,7 +143,7 @@ // (linear) floats to preserve the full dynamic range: // // float *data = stbi_loadf(filename, &x, &y, &n, 0); -// +// // If you load LDR images through this interface, those images will // be promoted to floating point values, run through the inverse of // constants corresponding to the above: @@ -218,7 +218,7 @@ extern void stbi_ldr_to_hdr_scale(float scale); // get a VERY brief reason for failure // NOT THREADSAFE -extern char *stbi_failure_reason (void); +extern char *stbi_failure_reason (void); // free the loaded image -- this is just free() extern void stbi_image_free (void *retval_from_stbi_load); @@ -328,12 +328,12 @@ extern int stbi_register_loader(stbi_loader *loader); // define faster low-level operations (typically SIMD support) #if STBI_SIMD -typedef void (*stbi_idct_8x8)(guint8 *out, int out_stride, short data[64], unsigned short *dequantize); +typedef void (*stbi_idct_8x8)(uint8_t *out, int out_stride, short data[64], unsigned short *dequantize); // compute an integer IDCT on "input" // input[x] = data[x] * dequantize[x] // write results to 'out': 64 samples, each run of 8 spaced by 'out_stride' // CLAMP results to 0..255 -typedef void (*stbi_YCbCr_to_RGB_run)(guint8 *output, guint8 const *y, guint8 const *cb, guint8 const *cr, int count, int step); +typedef void (*stbi_YCbCr_to_RGB_run)(uint8_t *output, uint8_t const *y, uint8_t const *cb, uint8_t const *cr, int count, int step); // compute a conversion from YCbCr to RGB // 'count' pixels // write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B @@ -379,7 +379,7 @@ extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); // should produce compiler error if size is wrong -typedef unsigned char validate_guint32[sizeof(guint32)==4]; +typedef unsigned char validate_uint32_t[sizeof(uint32_t)==4]; #if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE) #define STBI_NO_WRITE @@ -621,13 +621,13 @@ enum typedef struct { - guint32 img_x, img_y; + uint32_t img_x, img_y; int img_n, img_out_n; #ifndef STBI_NO_STDIO FILE *img_file; #endif - guint8 *img_buffer, *img_buffer_end; + uint8_t *img_buffer, *img_buffer_end; } stbi; #ifndef STBI_NO_STDIO @@ -637,13 +637,13 @@ static void start_file(stbi *s, FILE *f) } #endif -static void start_mem(stbi *s, guint8 const *buffer, int len) +static void start_mem(stbi *s, uint8_t const *buffer, int len) { #ifndef STBI_NO_STDIO s->img_file = NULL; #endif - s->img_buffer = (guint8 *) buffer; - s->img_buffer_end = (guint8 *) buffer+len; + s->img_buffer = (uint8_t *) buffer; + s->img_buffer_end = (uint8_t *) buffer+len; } __forceinline static int get8(stbi *s) @@ -665,12 +665,12 @@ __forceinline static int at_eof(stbi *s) if (s->img_file) return feof(s->img_file); #endif - return s->img_buffer >= s->img_buffer_end; + return s->img_buffer >= s->img_buffer_end; } -__forceinline static guint8 get8u(stbi *s) +__forceinline static uint8_t get8u(stbi *s) { - return (guint8) get8(s); + return (uint8_t) get8(s); } static void skip(stbi *s, int n) @@ -689,9 +689,9 @@ static int get16(stbi *s) return (z << 8) + get8(s); } -static guint32 get32(stbi *s) +static uint32_t get32(stbi *s) { - guint32 z = get16(s); + uint32_t z = get16(s); return (z << 16) + get16(s); } @@ -701,9 +701,9 @@ static int get16le(stbi *s) return z + (get8(s) << 8); } -static guint32 get32le(stbi *s) +static uint32_t get32le(stbi *s) { - guint32 z = get16le(s); + uint32_t z = get16le(s); return z + (get16le(s) << 16); } @@ -730,12 +730,16 @@ static void getn(stbi *s, stbi_uc *buffer, int n) // assume data buffer is malloced, so malloc a new one and free that one // only failure mode is malloc failing -static guint8 compute_y(int r, int g, int b) +static uint8_t compute_y(int r, int g, int b) { - return (guint8) (((r*77) + (g*150) + (29*b)) >> 8); + return (uint8_t) (((r*77) + (g*150) + (29*b)) >> 8); } -static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, guint x, guint 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; @@ -856,13 +860,13 @@ static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp) typedef struct { - guint8 fast[1 << FAST_BITS]; + uint8_t fast[1 << FAST_BITS]; // weirdly, repacking this into AoS is a 10% speed loss, instead of a win - guint16 code[256]; - guint8 values[256]; - guint8 size[257]; + uint16_t code[256]; + uint8_t values[256]; + uint8_t size[257]; unsigned int maxcode[18]; - int delta[17]; // old 'firstsymbol' - old 'firstcode' + int delta[17]; // old 'firstsymbol' - old 'firstcode' } huffman; typedef struct @@ -873,7 +877,7 @@ typedef struct stbi s; huffman huff_dc[4]; huffman huff_ac[4]; - guint8 dequant[4][64]; + uint8_t dequant[4][64]; // sizes for components, interleaved MCUs int img_h_max, img_v_max; @@ -890,12 +894,12 @@ typedef struct int dc_pred; int x,y,w2,h2; - guint8 *data; + uint8_t *data; void *raw_data; - guint8 *linebuf; + uint8_t *linebuf; } img_comp[4]; - guint32 code_buffer; // jpeg entropy-coded buffer + uint32_t 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 @@ -910,7 +914,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++] = (guint8) (i+1); + h->size[k++] = (uint8_t) (i+1); h->size[k] = 0; // compute actual symbols (from jpeg spec) @@ -921,7 +925,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++] = (guint16) (code++); + h->code[k++] = (uint16_t) (code++); if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG"); } // compute largest code + 1 for this size, preshifted as needed later @@ -938,7 +942,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] = (guint8) i; + h->fast[c+j] = (uint8_t) i; } } } @@ -963,7 +967,7 @@ static void grow_buffer_unsafe(jpeg *j) } // (1 << n) - 1 -static guint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; +static uint32_t 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 __forceinline static int decode(jpeg *j, huffman *h) @@ -1035,7 +1039,7 @@ __forceinline 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 guint8 dezigzag[64+15] = +static uint8_t dezigzag[64+15] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, @@ -1086,7 +1090,7 @@ 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 -__forceinline static guint8 clamp(int x) +__forceinline static uint8_t clamp(int x) { x += 128; // trick to use a single test to catch both cases @@ -1094,7 +1098,7 @@ __forceinline static guint8 clamp(int x) if (x < 0) return 0; if (x > 255) return 255; } - return (guint8) x; + return (uint8_t) x; } #define f2f(x) (int) (((x) * 4096 + 0.5)) @@ -1140,10 +1144,10 @@ __forceinline static guint8 clamp(int x) #if !STBI_SIMD // .344 seconds on 3*anemones.jpg -static void idct_block(guint8 *out, int out_stride, short data[64], guint8 *dequantize) +static void idct_block(uint8_t *out, int out_stride, short data[64], uint8_t *dequantize) { int i,val[64],*v=val; - guint8 *o,*dq = dequantize; + uint8_t *o,*dq = dequantize; short *d = data; // columns @@ -1192,10 +1196,10 @@ static void idct_block(guint8 *out, int out_stride, short data[64], guint8 *dequ } } #else -static void idct_block(guint8 *out, int out_stride, short data[64], unsigned short *dequantize) +static void idct_block(uint8_t *out, int out_stride, short data[64], unsigned short *dequantize) { int i,val[64],*v=val; - guint8 *o; + uint8_t *o; unsigned short *dq = dequantize; short *d = data; @@ -1256,9 +1260,9 @@ extern 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 guint8 get_marker(jpeg *j) +static uint8_t get_marker(jpeg *j) { - guint8 x; + uint8_t 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; @@ -1393,7 +1397,7 @@ static int process_marker(jpeg *z, int m) case 0xC4: // DHT - define huffman table L = get16(&z->s)-2; while (L > 0) { - guint8 *v; + uint8_t *v; int sizes[16],i,m=0; int q = get8(&z->s); int tc = q >> 4; @@ -1516,7 +1520,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 = (guint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].data = (uint8_t*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); z->img_comp[i].linebuf = NULL; } @@ -1571,17 +1575,17 @@ static int decode_jpeg_image(jpeg *j) // static jfif-centered resampling (across block boundaries) -typedef guint8 *(*resample_row_func)(guint8 *out, guint8 *in0, guint8 *in1, - int w, int hs); +typedef uint8_t *(*resample_row_func)(uint8_t *out, uint8_t *in0, uint8_t *in1, + int w, int hs); -#define div4(x) ((guint8) ((x) >> 2)) +#define div4(x) ((uint8_t) ((x) >> 2)) -static guint8 *resample_row_1(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs) +static uint8_t *resample_row_1(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs) { return in_near; } -static guint8* resample_row_v_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs) +static uint8_t* resample_row_v_2(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs) { // need to generate two samples vertically for every one in input int i; @@ -1590,11 +1594,11 @@ static guint8* resample_row_v_2(guint8 *out, guint8 *in_near, guint8 *in_far, in return out; } -static guint8* resample_row_h_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs) +static uint8_t* resample_row_h_2(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs) { // need to generate two samples horizontally for every one in input int i; - guint8 *input = in_near; + uint8_t *input = in_near; if (w == 1) { // if only one sample, can't do any interpolation out[0] = out[1] = input[0]; @@ -1613,9 +1617,9 @@ static guint8* resample_row_h_2(guint8 *out, guint8 *in_near, guint8 *in_far, i return out; } -#define div16(x) ((guint8) ((x) >> 4)) +#define div16(x) ((uint8_t) ((x) >> 4)) -static guint8 *resample_row_hv_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs) +static uint8_t *resample_row_hv_2(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs) { // need to generate 2x2 samples for every one in input int i,t0,t1; @@ -1636,7 +1640,7 @@ static guint8 *resample_row_hv_2(guint8 *out, guint8 *in_near, guint8 *in_far, i return out; } -static guint8 *resample_row_generic(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs) +static uint8_t *resample_row_generic(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs) { // resample with nearest-neighbor int i,j; @@ -1650,7 +1654,7 @@ static guint8 *resample_row_generic(guint8 *out, guint8 *in_near, guint8 *in_far // 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(guint8 *out, const guint8 *y, const guint8 *pcb, const guint8 *pcr, int count, int step) +static void YCbCr_to_RGB_row(uint8_t *out, const uint8_t *y, const uint8_t *pcb, const uint8_t *pcr, int count, int step) { int i; for (i=0; i < count; ++i) { @@ -1667,9 +1671,9 @@ static void YCbCr_to_RGB_row(guint8 *out, const guint8 *y, const guint8 *pcb, co 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] = (guint8)r; - out[1] = (guint8)g; - out[2] = (guint8)b; + out[0] = (uint8_t)r; + out[1] = (uint8_t)g; + out[2] = (uint8_t)b; out[3] = 255; out += step; } @@ -1704,14 +1708,14 @@ static void cleanup_jpeg(jpeg *j) typedef struct { resample_row_func resample; - guint8 *line0,*line1; + uint8_t *line0,*line1; int hs,vs; // expansion factor in each axis - int w_lores; // horizontal pixels pre-expansion + 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 guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +static uint8_t *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) { int n, decode_n; // validate req_comp @@ -1732,9 +1736,9 @@ static guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int r // resample and color-convert { int k; - guint i,j; - guint8 *output; - guint8 *coutput[4]; + unsigned int i,j; + uint8_t *output; + uint8_t *coutput[4]; stbi_resample res_comp[4]; @@ -1743,7 +1747,7 @@ static guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int r // allocate line buffer big enough for upsampling off the edges // with upsample factor of 4 - z->img_comp[k].linebuf = (guint8 *) malloc(z->s.img_x + 3); + z->img_comp[k].linebuf = (uint8_t *) 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; @@ -1761,12 +1765,12 @@ static guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int r } // can't error after this so, this is safe - output = (guint8 *) malloc(n * z->s.img_x * z->s.img_y + 1); + output = (uint8_t *) 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) { - guint8 *out = output + n * z->s.img_x * j; + uint8_t *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); @@ -1782,7 +1786,7 @@ static guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int r } } if (n >= 3) { - guint8 *y = coutput[0]; + uint8_t *y = coutput[0]; if (z->s.img_n == 3) { #if STBI_SIMD stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n); @@ -1796,7 +1800,7 @@ static guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int r out += n; } } else { - guint8 *y = coutput[0]; + uint8_t *y = coutput[0]; if (n == 1) for (i=0; i < z->s.img_x; ++i) out[i] = y[i]; else @@ -1879,12 +1883,12 @@ extern int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int * // (jpegs packs from left, zlib from right, so can't share code) typedef struct { - guint16 fast[1 << ZFAST_BITS]; - guint16 firstcode[16]; + uint16_t fast[1 << ZFAST_BITS]; + uint16_t firstcode[16]; int maxcode[17]; - guint16 firstsymbol[16]; - guint8 size[288]; - guint16 value[288]; + uint16_t firstsymbol[16]; + uint8_t size[288]; + uint16_t value[288]; } zhuffman; __forceinline static int bitreverse16(int n) @@ -1904,7 +1908,7 @@ __forceinline static int bit_reverse(int v, int bits) return bitreverse16(v) >> (16-bits); } -static int zbuild_huffman(zhuffman *z, guint8 *sizelist, int num) +static int zbuild_huffman(zhuffman *z, uint8_t *sizelist, int num) { int i,k=0; int code, next_code[16], sizes[17]; @@ -1912,7 +1916,7 @@ static int zbuild_huffman(zhuffman *z, guint8 *sizelist, int num) // DEFLATE spec for generating codes memset(sizes, 0, sizeof(sizes)); memset(z->fast, 255, sizeof(z->fast)); - for (i=0; i < num; ++i) + for (i=0; i < num; ++i) ++sizes[sizelist[i]]; sizes[0] = 0; for (i=1; i < 16; ++i) @@ -1920,8 +1924,8 @@ static int zbuild_huffman(zhuffman *z, guint8 *sizelist, int num) code = 0; for (i=1; i < 16; ++i) { next_code[i] = code; - z->firstcode[i] = (guint16) code; - z->firstsymbol[i] = (guint16) k; + z->firstcode[i] = (uint16_t) code; + z->firstsymbol[i] = (uint16_t) k; code = (code + sizes[i]); if (sizes[i]) if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG"); @@ -1934,12 +1938,12 @@ static int zbuild_huffman(zhuffman *z, guint8 *sizelist, int num) int s = sizelist[i]; if (s) { int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; - z->size[c] = (guint8)s; - z->value[c] = (guint16)i; + z->size[c] = (uint8_t)s; + z->value[c] = (uint16_t)i; if (s <= ZFAST_BITS) { int k = bit_reverse(next_code[s],s); while (k < (1 << ZFAST_BITS)) { - z->fast[k] = (guint16) c; + z->fast[k] = (uint16_t) c; k += (1 << s); } } @@ -1957,9 +1961,9 @@ static int zbuild_huffman(zhuffman *z, guint8 *sizelist, int num) typedef struct { - guint8 *zbuffer, *zbuffer_end; + uint8_t *zbuffer, *zbuffer_end; int num_bits; - guint32 code_buffer; + uint32_t code_buffer; char *zout; char *zout_start; @@ -1991,7 +1995,7 @@ __forceinline static unsigned int zreceive(zbuf *z, int n) k = z->code_buffer & ((1 << n) - 1); z->code_buffer >>= n; z->num_bits -= n; - return k; + return k; } __forceinline static int zhuffman_decode(zbuf *a, zhuffman *z) @@ -2043,7 +2047,7 @@ static int length_base[31] = { 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 }; -static int length_extra[31]= +static int length_extra[31]= { 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 }; static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, @@ -2061,7 +2065,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 { - guint8 *p; + uint8_t *p; int len,dist; if (z == 256) return 1; z -= 257; @@ -2073,7 +2077,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 = (guint8 *) (a->zout - dist); + p = (uint8_t *) (a->zout - dist); while (len--) *a->zout++ = *p++; } @@ -2082,10 +2086,10 @@ static int parse_huffman_block(zbuf *a) static int compute_huffman_codes(zbuf *a) { - static guint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + static uint8_t 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; - guint8 lencodes[286+32+137];//padding for maximum single op - guint8 codelength_sizes[19]; + uint8_t lencodes[286+32+137];//padding for maximum single op + uint8_t codelength_sizes[19]; int i,n; int hlit = zreceive(a,5) + 257; @@ -2095,7 +2099,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]] = (guint8) s; + codelength_sizes[length_dezigzag[i]] = (uint8_t) s; } if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; @@ -2104,7 +2108,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++] = (guint8) c; + lencodes[n++] = (uint8_t) c; else if (c == 16) { c = zreceive(a,2)+3; memset(lencodes+n, lencodes[n-1], c); @@ -2128,21 +2132,21 @@ static int compute_huffman_codes(zbuf *a) static int parse_uncompressed_block(zbuf *a) { - guint8 header[4]; + uint8_t 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++] = (guint8) (a->code_buffer & 255); // wtf this warns? + header[k++] = (uint8_t) (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++] = (guint8) zget8(a); + header[k++] = (uint8_t) zget8(a); len = header[1] * 256 + header[0]; nlen = header[3] * 256 + header[2]; if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG"); @@ -2169,7 +2173,7 @@ static int parse_zlib_header(zbuf *a) } // @TODO: should statically initialize these for optimal thread safety -static guint8 default_length[288], default_distance[32]; +static uint8_t default_length[288], default_distance[32]; static void init_defaults(void) { int i; // use <= to match clearly with spec @@ -2228,8 +2232,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 = (guint8 *) buffer; - a.zbuffer_end = (guint8 *) buffer + len; + a.zbuffer = (uint8_t *) buffer; + a.zbuffer_end = (uint8_t *) buffer + len; if (do_zlib(&a, p, initial_size, 1, 1)) { if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; @@ -2247,8 +2251,8 @@ char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) { zbuf a; - a.zbuffer = (guint8 *) ibuffer; - a.zbuffer_end = (guint8 *) ibuffer + ilen; + a.zbuffer = (uint8_t *) ibuffer; + a.zbuffer_end = (uint8_t *) ibuffer + ilen; if (do_zlib(&a, obuffer, olen, 0, 1)) return (int) (a.zout - a.zout_start); else @@ -2260,8 +2264,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 = (guint8 *) buffer; - a.zbuffer_end = (guint8 *) buffer+len; + a.zbuffer = (uint8_t *) buffer; + a.zbuffer_end = (uint8_t *) buffer+len; if (do_zlib(&a, p, 16384, 1, 0)) { if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; @@ -2274,8 +2278,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 = (guint8 *) ibuffer; - a.zbuffer_end = (guint8 *) ibuffer + ilen; + a.zbuffer = (uint8_t *) ibuffer; + a.zbuffer_end = (uint8_t *) ibuffer + ilen; if (do_zlib(&a, obuffer, olen, 0, 0)) return (int) (a.zout - a.zout_start); else @@ -2295,8 +2299,8 @@ int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffe typedef struct { - guint32 length; - guint32 type; + uint32_t length; + uint32_t type; } chunk; #define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) @@ -2311,7 +2315,7 @@ static chunk get_chunk_header(stbi *s) static int check_png_header(stbi *s) { - static guint8 png_sig[8] = { 137,80,78,71,13,10,26,10 }; + static uint8_t png_sig[8] = { 137,80,78,71,13,10,26,10 }; int i; for (i=0; i < 8; ++i) if (get8(s) != png_sig[i]) return e("bad png sig","Not a PNG"); @@ -2321,7 +2325,7 @@ static int check_png_header(stbi *s) typedef struct { stbi s; - guint8 *idata, *expanded, *out; + uint8_t *idata, *expanded, *out; } png; @@ -2330,7 +2334,7 @@ enum { F_avg_first, F_paeth_first, }; -static guint8 first_row_filter[5] = +static uint8_t first_row_filter[5] = { F_none, F_sub, F_none, F_avg_first, F_paeth_first }; @@ -2347,15 +2351,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, guint8 *raw, guint32 raw_len, int out_n, guint32 x, guint32 y) +static int create_png_image_raw(png *a, uint8_t *raw, uint32_t raw_len, int out_n, uint32_t x, uint32_t y) { stbi *s = &a->s; - guint32 i,j,stride = x*out_n; + uint32_t 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 = (guint8 *) malloc(x * y * out_n); + a->out = (uint8_t *) 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) @@ -2364,8 +2368,8 @@ static int create_png_image_raw(png *a, guint8 *raw, guint32 raw_len, int out_n, if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG"); } for (j=0; j < y; ++j) { - guint8 *cur = a->out + stride*j; - guint8 *prior = cur - stride; + uint8_t *cur = a->out + stride*j; + uint8_t *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 @@ -2377,7 +2381,7 @@ static int create_png_image_raw(png *a, guint8 *raw, guint32 raw_len, int out_n, 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] = (guint8) (raw[k] + paeth(0,prior[k],0)); break; + case F_paeth : cur[k] = (uint8_t) (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; } @@ -2397,9 +2401,9 @@ static int create_png_image_raw(png *a, guint8 *raw, guint32 raw_len, int out_n, 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] = (guint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; + CASE(F_paeth) cur[k] = (uint8_t) (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] = (guint8) (raw[k] + paeth(cur[k-img_n],0,0)); break; + CASE(F_paeth_first) cur[k] = (uint8_t) (raw[k] + paeth(cur[k-img_n],0,0)); break; } #undef CASE } else { @@ -2413,9 +2417,9 @@ static int create_png_image_raw(png *a, guint8 *raw, guint32 raw_len, int out_n, 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] = (guint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; + CASE(F_paeth) cur[k] = (uint8_t) (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] = (guint8) (raw[k] + paeth(cur[k-out_n],0,0)); break; + CASE(F_paeth_first) cur[k] = (uint8_t) (raw[k] + paeth(cur[k-out_n],0,0)); break; } #undef CASE } @@ -2423,9 +2427,9 @@ static int create_png_image_raw(png *a, guint8 *raw, guint32 raw_len, int out_n, return 1; } -static int create_png_image(png *a, guint8 *raw, guint32 raw_len, int out_n, int interlaced) +static int create_png_image(png *a, uint8_t *raw, uint32_t raw_len, int out_n, int interlaced) { - guint8 *final; + uint8_t *final; int p; int save; if (!interlaced) @@ -2434,7 +2438,7 @@ static int create_png_image(png *a, guint8 *raw, guint32 raw_len, int out_n, int stbi_png_partial = 0; // de-interlacing - final = (guint8 *) malloc(a->s.img_x * a->s.img_y * out_n); + final = (uint8_t *) 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 }; @@ -2464,11 +2468,11 @@ static int create_png_image(png *a, guint8 *raw, guint32 raw_len, int out_n, int return 1; } -static int compute_transparency(png *z, guint8 tc[3], int out_n) +static int compute_transparency(png *z, uint8_t tc[3], int out_n) { stbi *s = &z->s; - guint32 i, pixel_count = s->img_x * s->img_y; - guint8 *p = z->out; + uint32_t i, pixel_count = s->img_x * s->img_y; + uint8_t *p = z->out; // compute color-based transparency, assuming we've // already got 255 as the alpha value in the output @@ -2489,12 +2493,12 @@ static int compute_transparency(png *z, guint8 tc[3], int out_n) return 1; } -static int expand_palette(png *a, guint8 *palette, int len, int pal_img_n) +static int expand_palette(png *a, uint8_t *palette, int len, int pal_img_n) { - guint32 i, pixel_count = a->s.img_x * a->s.img_y; - guint8 *p, *temp_out, *orig = a->out; + uint32_t i, pixel_count = a->s.img_x * a->s.img_y; + uint8_t *p, *temp_out, *orig = a->out; - p = (guint8 *) malloc(pixel_count * pal_img_n); + p = (uint8_t *) malloc(pixel_count * pal_img_n); if (p == NULL) return e("outofmem", "Out of memory"); // between here and free(out) below, exitting would leak @@ -2525,9 +2529,9 @@ static int expand_palette(png *a, guint8 *palette, int len, int pal_img_n) static int parse_png_file(png *z, int scan, int req_comp) { - guint8 palette[1024], pal_img_n=0; - guint8 has_trans=0, tc[3]; - guint32 ioff=0, idata_limit=0, i, pal_len=0; + uint8_t palette[1024], pal_img_n=0; + uint8_t has_trans=0, tc[3]; + uint32_t ioff=0, idata_limit=0, i, pal_len=0; int first=1,k,interlace=0; stbi *s = &z->s; @@ -2591,10 +2595,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 != (guint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); + if (c.length != (uint32_t) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); has_trans = 1; for (k=0; k < s->img_n; ++k) - tc[k] = (guint8) get16(s); // non 8-bit images will be larger + tc[k] = (uint8_t) get16(s); // non 8-bit images will be larger } break; } @@ -2603,11 +2607,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) { - guint8 *p; + uint8_t *p; if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; while (ioff + c.length > idata_limit) idata_limit *= 2; - p = (guint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); + p = (uint8_t *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); z->idata = p; } #ifndef STBI_NO_STDIO @@ -2626,10 +2630,10 @@ static int parse_png_file(png *z, int scan, int req_comp) } case PNG_TYPE('I','E','N','D'): { - guint32 raw_len; + uint32_t raw_len; if (scan != SCAN_load) return 1; if (z->idata == NULL) return e("no IDAT","Corrupt PNG"); - z->expanded = (guint8 *) stbi_zlib_decode_malloc((char *) z->idata, ioff, (int *) &raw_len); + z->expanded = (uint8_t *) stbi_zlib_decode_malloc((char *) z->idata, ioff, (int *) &raw_len); 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) @@ -2657,10 +2661,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] = (guint8) (c.type >> 24); - invalid_chunk[1] = (guint8) (c.type >> 16); - invalid_chunk[2] = (guint8) (c.type >> 8); - invalid_chunk[3] = (guint8) (c.type >> 0); + invalid_chunk[0] = (uint8_t) (c.type >> 24); + invalid_chunk[1] = (uint8_t) (c.type >> 16); + invalid_chunk[2] = (uint8_t) (c.type >> 8); + invalid_chunk[3] = (uint8_t) (c.type >> 0); #endif return e(invalid_chunk, "PNG not supported: unknown chunk type"); } @@ -2844,7 +2848,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) { - guint8 *out; + uint8_t *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; @@ -3004,13 +3008,13 @@ static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp) } } else { for (i=0; i < (int) s->img_x; ++i) { - guint32 v = (bpp == 16 ? get16le(s) : get32le(s)); + uint32_t v = (bpp == 16 ? get16le(s) : get32le(s)); int a; out[z++] = shiftsigned(v & mr, rshift, rcount); out[z++] = shiftsigned(v & mg, gshift, gcount); out[z++] = shiftsigned(v & mb, bshift, bcount); a = (ma ? shiftsigned(v & ma, ashift, acount) : 255); - if (target == 4) out[z++] = a; + if (target == 4) out[z++] = a; } } skip(s, pad); @@ -3385,7 +3389,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; - guint8 *out; + uint8_t *out; // Check identifier if (get32(s) != 0x38425053) // "8BPS" @@ -3406,7 +3410,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) // Read the rows and columns of the image. h = get32(s); w = get32(s); - + // Make sure the depth is 8 bits. if (get16(s) != 8) return epuc("unsupported bit depth", "PSD bit depth is not 8 bit"); @@ -3448,7 +3452,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) // Initialize the data to zero. //memset( out, 0, pixelCount * 4 ); - + // Finally, the image data. if (compression) { // RLE as used by .PSD and .TIFF @@ -3465,8 +3469,8 @@ 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++) { - guint8 *p; - + uint8_t *p; + p = out+channel; if (channel >= channelCount) { // Fill this channel with default data. @@ -3488,7 +3492,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) len--; } } else if (len > 128) { - guint32 val; + uint32_t val; // Next -len+1 bytes in the dest are replicated from next source byte. // (Interpret len as a negative 8-bit int.) len ^= 0x0FF; @@ -3504,15 +3508,15 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) } } } - + } else { // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) // where each channel consists of an 8-bit value for each pixel in the image. - + // Read the data by channel. for (channel = 0; channel < 4; channel++) { - guint8 *p; - + uint8_t *p; + p = out + channel; if (channel > channelCount) { // Fill this channel with default data. @@ -3534,7 +3538,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) if (comp) *comp = channelCount; *y = h; *x = w; - + return out; } @@ -3665,7 +3669,7 @@ static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) // Check identifier if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) return epf("not HDR", "Corrupt HDR image"); - + // Parse header while(1) { token = hdr_gettoken(s,buffer); @@ -3729,7 +3733,7 @@ static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) len |= get8(s); if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); } if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4); - + for (k = 0; k < 4; ++k) { i = 0; while (i < width) { @@ -3778,16 +3782,16 @@ float *stbi_hdr_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, #ifndef STBI_NO_WRITE -static void write8(FILE *f, int x) { guint8 z = (guint8) x; fwrite(&z,1,1,f); } +static void write8(FILE *f, int x) { uint8_t z = (uint8_t) x; fwrite(&z,1,1,f); } static void writefv(FILE *f, char *fmt, va_list v) { while (*fmt) { switch (*fmt++) { case ' ': break; - case '1': { guint8 x = va_arg(v, int); write8(f,x); break; } - case '2': { gint16 x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; } - case '4': { gint32 x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); break; } + case '1': { uint8_t x = va_arg(v, int); write8(f,x); break; } + case '2': { int16_t x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; } + case '4': { int32_t x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); break; } default: assert(0); va_end(v); @@ -3806,18 +3810,18 @@ static void writef(FILE *f, char *fmt, ...) static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad) { - guint8 bg[3] = { 255, 0, 255}, px[3]; - guint32 zero = 0; + uint8_t bg[3] = { 255, 0, 255}, px[3]; + uint32_t zero = 0; int i,j,k, j_end; - if (vdir < 0) + if (vdir < 0) j_end = -1, j = y-1; else j_end = y, j = 0; for (; j != j_end; j += vdir) { for (i=0; i < x; ++i) { - guint8 *d = (guint8 *) data + (j*x+i)*comp; + uint8_t *d = (uint8_t *) data + (j*x+i)*comp; if (write_alpha < 0) fwrite(&d[comp-1], 1, 1, f); switch (comp) { -- cgit v1.2.1