[cogl/wip/rib/master-next: 4/12] stb_image: use glib sized types



commit db2a24dd6d4f63df1fcbdf8d67c0ad210dc24ac0
Author: Robert Bragg <robert linux intel com>
Date:   Thu Aug 4 15:09:17 2011 +0100

    stb_image: use glib sized types
    
    Instead of creating typedefs like uint8, uint16 and uint32 we now use
    the glib sized typedefs in stb_image to avoid conflict with the uint8,
    uint16 and uint32 typedefs on android.
    
    Reviewed-by: Neil Roberts <neil linux intel com>

 cogl/stb_image.c |  301 ++++++++++++++++++++++++++----------------------------
 1 files changed, 147 insertions(+), 154 deletions(-)
---
diff --git a/cogl/stb_image.c b/cogl/stb_image.c
index 75562f6..1aaef60 100644
--- a/cogl/stb_image.c
+++ b/cogl/stb_image.c
@@ -65,6 +65,7 @@
              on 'test' only check type, not whether we support this variant
 */
 
+#include <glib.h>
 
 #ifndef STBI_INCLUDE_STB_IMAGE_H
 #define STBI_INCLUDE_STB_IMAGE_H
@@ -327,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)(uint8 *out, int out_stride, short data[64], unsigned short *dequantize);
+typedef void (*stbi_idct_8x8)(guint8 *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)(uint8 *output, uint8 const *y, uint8 const *cb, uint8 const *cr, int count, int step);
+typedef void (*stbi_YCbCr_to_RGB_run)(guint8 *output, guint8 const *y, guint8 const *cb, guint8 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
@@ -377,16 +378,8 @@ extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
 #endif
 
 
-// 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;
-
 // should produce compiler error if size is wrong
-typedef unsigned char validate_uint32[sizeof(uint32)==4];
+typedef unsigned char validate_guint32[sizeof(guint32)==4];
 
 #if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
 #define STBI_NO_WRITE
@@ -628,13 +621,13 @@ enum
 
 typedef struct
 {
-   uint32 img_x, img_y;
+   guint32 img_x, img_y;
    int img_n, img_out_n;
 
    #ifndef STBI_NO_STDIO
    FILE  *img_file;
    #endif
-   uint8 *img_buffer, *img_buffer_end;
+   guint8 *img_buffer, *img_buffer_end;
 } stbi;
 
 #ifndef STBI_NO_STDIO
@@ -644,13 +637,13 @@ static void start_file(stbi *s, FILE *f)
 }
 #endif
 
-static void start_mem(stbi *s, uint8 const *buffer, int len)
+static void start_mem(stbi *s, guint8 const *buffer, int len)
 {
 #ifndef STBI_NO_STDIO
    s->img_file = NULL;
 #endif
-   s->img_buffer = (uint8 *) buffer;
-   s->img_buffer_end = (uint8 *) buffer+len;
+   s->img_buffer = (guint8 *) buffer;
+   s->img_buffer_end = (guint8 *) buffer+len;
 }
 
 __forceinline static int get8(stbi *s)
@@ -675,9 +668,9 @@ __forceinline static int at_eof(stbi *s)
    return s->img_buffer >= s->img_buffer_end;   
 }
 
-__forceinline static uint8 get8u(stbi *s)
+__forceinline static guint8 get8u(stbi *s)
 {
-   return (uint8) get8(s);
+   return (guint8) get8(s);
 }
 
 static void skip(stbi *s, int n)
@@ -696,9 +689,9 @@ static int get16(stbi *s)
    return (z << 8) + get8(s);
 }
 
-static uint32 get32(stbi *s)
+static guint32 get32(stbi *s)
 {
-   uint32 z = get16(s);
+   guint32 z = get16(s);
    return (z << 16) + get16(s);
 }
 
@@ -708,9 +701,9 @@ static int get16le(stbi *s)
    return z + (get8(s) << 8);
 }
 
-static uint32 get32le(stbi *s)
+static guint32 get32le(stbi *s)
 {
-   uint32 z = get16le(s);
+   guint32 z = get16le(s);
    return z + (get16le(s) << 16);
 }
 
@@ -737,12 +730,12 @@ 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 uint8 compute_y(int r, int g, int b)
+static guint8 compute_y(int r, int g, int b)
 {
-   return (uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
+   return (guint8) (((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, guint x, guint y)
 {
    int i,j;
    unsigned char *good;
@@ -863,11 +856,11 @@ static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
 
 typedef struct
 {
-   uint8  fast[1 << FAST_BITS];
+   guint8  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];
+   guint16 code[256];
+   guint8  values[256];
+   guint8  size[257];
    unsigned int maxcode[18];
    int    delta[17];   // old 'firstsymbol' - old 'firstcode'
 } huffman;
@@ -880,7 +873,7 @@ typedef struct
    stbi s;
    huffman huff_dc[4];
    huffman huff_ac[4];
-   uint8 dequant[4][64];
+   guint8 dequant[4][64];
 
 // sizes for components, interleaved MCUs
    int img_h_max, img_v_max;
@@ -897,12 +890,12 @@ typedef struct
       int dc_pred;
 
       int x,y,w2,h2;
-      uint8 *data;
+      guint8 *data;
       void *raw_data;
-      uint8 *linebuf;
+      guint8 *linebuf;
    } img_comp[4];
 
-   uint32         code_buffer; // jpeg entropy-coded buffer
+   guint32         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
@@ -917,7 +910,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++] = (guint8) (i+1);
    h->size[k] = 0;
 
    // compute actual symbols (from jpeg spec)
@@ -928,7 +921,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++] = (guint16) (code++);
          if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG");
       }
       // compute largest code + 1 for this size, preshifted as needed later
@@ -945,7 +938,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] = (guint8) i;
          }
       }
    }
@@ -970,7 +963,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 guint32 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)
@@ -1042,7 +1035,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 uint8 dezigzag[64+15] =
+static guint8 dezigzag[64+15] =
 {
     0,  1,  8, 16,  9,  2,  3, 10,
    17, 24, 32, 25, 18, 11,  4,  5,
@@ -1093,7 +1086,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 uint8 clamp(int x)
+__forceinline static guint8 clamp(int x)
 {
    x += 128;
    // trick to use a single test to catch both cases
@@ -1101,7 +1094,7 @@ __forceinline static uint8 clamp(int x)
       if (x < 0) return 0;
       if (x > 255) return 255;
    }
-   return (uint8) x;
+   return (guint8) x;
 }
 
 #define f2f(x)  (int) (((x) * 4096 + 0.5))
@@ -1147,10 +1140,10 @@ __forceinline static uint8 clamp(int x)
 
 #if !STBI_SIMD
 // .344 seconds on 3*anemones.jpg
-static void idct_block(uint8 *out, int out_stride, short data[64], uint8 *dequantize)
+static void idct_block(guint8 *out, int out_stride, short data[64], guint8 *dequantize)
 {
    int i,val[64],*v=val;
-   uint8 *o,*dq = dequantize;
+   guint8 *o,*dq = dequantize;
    short *d = data;
 
    // columns
@@ -1199,10 +1192,10 @@ static void idct_block(uint8 *out, int out_stride, short data[64], uint8 *dequan
    }
 }
 #else
-static void idct_block(uint8 *out, int out_stride, short data[64], unsigned short *dequantize)
+static void idct_block(guint8 *out, int out_stride, short data[64], unsigned short *dequantize)
 {
    int i,val[64],*v=val;
-   uint8 *o;
+   guint8 *o;
    unsigned short *dq = dequantize;
    short *d = data;
 
@@ -1263,9 +1256,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 uint8 get_marker(jpeg *j)
+static guint8 get_marker(jpeg *j)
 {
-   uint8 x;
+   guint8 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;
@@ -1400,7 +1393,7 @@ static int process_marker(jpeg *z, int m)
       case 0xC4: // DHT - define huffman table
          L = get16(&z->s)-2;
          while (L > 0) {
-            uint8 *v;
+            guint8 *v;
             int sizes[16],i,m=0;
             int q = get8(&z->s);
             int tc = q >> 4;
@@ -1523,7 +1516,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 = (guint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
       z->img_comp[i].linebuf = NULL;
    }
 
@@ -1578,17 +1571,17 @@ 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 guint8 *(*resample_row_func)(guint8 *out, guint8 *in0, guint8 *in1,
                                     int w, int hs);
 
-#define div4(x) ((uint8) ((x) >> 2))
+#define div4(x) ((guint8) ((x) >> 2))
 
-static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+static guint8 *resample_row_1(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs)
 {
    return in_near;
 }
 
-static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+static guint8* resample_row_v_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs)
 {
    // need to generate two samples vertically for every one in input
    int i;
@@ -1597,11 +1590,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 guint8*  resample_row_h_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs)
 {
    // need to generate two samples horizontally for every one in input
    int i;
-   uint8 *input = in_near;
+   guint8 *input = in_near;
    if (w == 1) {
       // if only one sample, can't do any interpolation
       out[0] = out[1] = input[0];
@@ -1620,9 +1613,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) ((guint8) ((x) >> 4))
 
-static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+static guint8 *resample_row_hv_2(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs)
 {
    // need to generate 2x2 samples for every one in input
    int i,t0,t1;
@@ -1643,7 +1636,7 @@ 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 guint8 *resample_row_generic(guint8 *out, guint8 *in_near, guint8 *in_far, int w, int hs)
 {
    // resample with nearest-neighbor
    int i,j;
@@ -1657,7 +1650,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(guint8 *out, const guint8 *y, const guint8 *pcb, const guint8 *pcr, int count, int step)
 {
    int i;
    for (i=0; i < count; ++i) {
@@ -1674,9 +1667,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] = (guint8)r;
+      out[1] = (guint8)g;
+      out[2] = (guint8)b;
       out[3] = 255;
       out += step;
    }
@@ -1711,14 +1704,14 @@ static void cleanup_jpeg(jpeg *j)
 typedef struct
 {
    resample_row_func resample;
-   uint8 *line0,*line1;
+   guint8 *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 guint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
 {
    int n, decode_n;
    // validate req_comp
@@ -1739,9 +1732,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];
+      guint i,j;
+      guint8 *output;
+      guint8 *coutput[4];
 
       stbi_resample res_comp[4];
 
@@ -1750,7 +1743,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 = (guint8 *) 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;
@@ -1768,12 +1761,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 = (guint8 *) 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;
+         guint8 *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);
@@ -1789,7 +1782,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];
+            guint8 *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);
@@ -1803,7 +1796,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];
+            guint8 *y = coutput[0];
             if (n == 1)
                for (i=0; i < z->s.img_x; ++i) out[i] = y[i];
             else
@@ -1886,12 +1879,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
 {
-   uint16 fast[1 << ZFAST_BITS];
-   uint16 firstcode[16];
+   guint16 fast[1 << ZFAST_BITS];
+   guint16 firstcode[16];
    int maxcode[17];
-   uint16 firstsymbol[16];
-   uint8  size[288];
-   uint16 value[288]; 
+   guint16 firstsymbol[16];
+   guint8  size[288];
+   guint16 value[288]; 
 } zhuffman;
 
 __forceinline static int bitreverse16(int n)
@@ -1911,7 +1904,7 @@ __forceinline 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, guint8 *sizelist, int num)
 {
    int i,k=0;
    int code, next_code[16], sizes[17];
@@ -1927,8 +1920,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] = (guint16) code;
+      z->firstsymbol[i] = (guint16) k;
       code = (code + sizes[i]);
       if (sizes[i])
          if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
@@ -1941,12 +1934,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] = (guint8)s;
+         z->value[c] = (guint16)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] = (guint16) c;
                k += (1 << s);
             }
          }
@@ -1964,9 +1957,9 @@ static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num)
 
 typedef struct
 {
-   uint8 *zbuffer, *zbuffer_end;
+   guint8 *zbuffer, *zbuffer_end;
    int num_bits;
-   uint32 code_buffer;
+   guint32 code_buffer;
 
    char *zout;
    char *zout_start;
@@ -2068,7 +2061,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;
+         guint8 *p;
          int len,dist;
          if (z == 256) return 1;
          z -= 257;
@@ -2080,7 +2073,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 = (guint8 *) (a->zout - dist);
          while (len--)
             *a->zout++ = *p++;
       }
@@ -2089,10 +2082,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 guint8 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];
+   guint8 lencodes[286+32+137];//padding for maximum single op
+   guint8 codelength_sizes[19];
    int i,n;
 
    int hlit  = zreceive(a,5) + 257;
@@ -2102,7 +2095,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]] = (guint8) s;
    }
    if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
 
@@ -2111,7 +2104,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++] = (guint8) c;
       else if (c == 16) {
          c = zreceive(a,2)+3;
          memset(lencodes+n, lencodes[n-1], c);
@@ -2135,21 +2128,21 @@ static int compute_huffman_codes(zbuf *a)
 
 static int parse_uncompressed_block(zbuf *a)
 {
-   uint8 header[4];
+   guint8 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++] = (guint8) (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++] = (guint8) zget8(a);
    len  = header[1] * 256 + header[0];
    nlen = header[3] * 256 + header[2];
    if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
@@ -2176,7 +2169,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 guint8 default_length[288], default_distance[32];
 static void init_defaults(void)
 {
    int i;   // use <= to match clearly with spec
@@ -2235,8 +2228,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 = (guint8 *) buffer;
+   a.zbuffer_end = (guint8 *) buffer + len;
    if (do_zlib(&a, p, initial_size, 1, 1)) {
       if (outlen) *outlen = (int) (a.zout - a.zout_start);
       return a.zout_start;
@@ -2254,8 +2247,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 = (uint8 *) ibuffer;
-   a.zbuffer_end = (uint8 *) ibuffer + ilen;
+   a.zbuffer = (guint8 *) ibuffer;
+   a.zbuffer_end = (guint8 *) ibuffer + ilen;
    if (do_zlib(&a, obuffer, olen, 0, 1))
       return (int) (a.zout - a.zout_start);
    else
@@ -2267,8 +2260,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 = (guint8 *) buffer;
+   a.zbuffer_end = (guint8 *) buffer+len;
    if (do_zlib(&a, p, 16384, 1, 0)) {
       if (outlen) *outlen = (int) (a.zout - a.zout_start);
       return a.zout_start;
@@ -2281,8 +2274,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 = (guint8 *) ibuffer;
+   a.zbuffer_end = (guint8 *) ibuffer + ilen;
    if (do_zlib(&a, obuffer, olen, 0, 0))
       return (int) (a.zout - a.zout_start);
    else
@@ -2302,8 +2295,8 @@ int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffe
 
 typedef struct
 {
-   uint32 length;
-   uint32 type;
+   guint32 length;
+   guint32 type;
 } chunk;
 
 #define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
@@ -2318,7 +2311,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 guint8 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");
@@ -2328,7 +2321,7 @@ static int check_png_header(stbi *s)
 typedef struct
 {
    stbi s;
-   uint8 *idata, *expanded, *out;
+   guint8 *idata, *expanded, *out;
 } png;
 
 
@@ -2337,7 +2330,7 @@ enum {
    F_avg_first, F_paeth_first,
 };
 
-static uint8 first_row_filter[5] =
+static guint8 first_row_filter[5] =
 {
    F_none, F_sub, F_none, F_avg_first, F_paeth_first
 };
@@ -2354,15 +2347,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, guint8 *raw, guint32 raw_len, int out_n, guint32 x, guint32 y)
 {
    stbi *s = &a->s;
-   uint32 i,j,stride = x*out_n;
+   guint32 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 = (guint8 *) 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)
@@ -2371,8 +2364,8 @@ static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, u
          if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
    }
    for (j=0; j < y; ++j) {
-      uint8 *cur = a->out + stride*j;
-      uint8 *prior = cur - stride;
+      guint8 *cur = a->out + stride*j;
+      guint8 *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
@@ -2384,7 +2377,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] = (guint8) (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;
          }
@@ -2404,9 +2397,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] = (guint8) (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] = (guint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
          }
          #undef CASE
       } else {
@@ -2420,9 +2413,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] = (guint8) (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] = (guint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
          }
          #undef CASE
       }
@@ -2430,9 +2423,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, guint8 *raw, guint32 raw_len, int out_n, int interlaced)
 {
-   uint8 *final;
+   guint8 *final;
    int p;
    int save;
    if (!interlaced)
@@ -2441,7 +2434,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 = (guint8 *) 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 };
@@ -2471,11 +2464,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, guint8 tc[3], int out_n)
 {
    stbi *s = &z->s;
-   uint32 i, pixel_count = s->img_x * s->img_y;
-   uint8 *p = z->out;
+   guint32 i, pixel_count = s->img_x * s->img_y;
+   guint8 *p = z->out;
 
    // compute color-based transparency, assuming we've
    // already got 255 as the alpha value in the output
@@ -2496,12 +2489,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, guint8 *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;
+   guint32 i, pixel_count = a->s.img_x * a->s.img_y;
+   guint8 *p, *temp_out, *orig = a->out;
 
-   p = (uint8 *) malloc(pixel_count * pal_img_n);
+   p = (guint8 *) malloc(pixel_count * pal_img_n);
    if (p == NULL) return e("outofmem", "Out of memory");
 
    // between here and free(out) below, exitting would leak
@@ -2532,9 +2525,9 @@ static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
 
 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;
+   guint8 palette[1024], pal_img_n=0;
+   guint8 has_trans=0, tc[3];
+   guint32 ioff=0, idata_limit=0, i, pal_len=0;
    int first=1,k,interlace=0;
    stbi *s = &z->s;
 
@@ -2598,10 +2591,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 != (guint32) 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] = (guint8) get16(s); // non 8-bit images will be larger
             }
             break;
          }
@@ -2610,11 +2603,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;
+               guint8 *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 = (guint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
                z->idata = p;
             }
             #ifndef STBI_NO_STDIO
@@ -2633,10 +2626,10 @@ static int parse_png_file(png *z, int scan, int req_comp)
          }
 
          case PNG_TYPE('I','E','N','D'): {
-            uint32 raw_len;
+            guint32 raw_len;
             if (scan != SCAN_load) return 1;
             if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
-            z->expanded = (uint8 *) stbi_zlib_decode_malloc((char *) z->idata, ioff, (int *) &raw_len);
+            z->expanded = (guint8 *) 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)
@@ -2664,10 +2657,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] = (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);
                #endif
                return e(invalid_chunk, "PNG not supported: unknown chunk type");
             }
@@ -2851,7 +2844,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;
+   guint8 *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;
@@ -3011,7 +3004,7 @@ 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) {
-               uint32 v = (bpp == 16 ? get16le(s) : get32le(s));
+               guint32 v = (bpp == 16 ? get16le(s) : get32le(s));
                int a;
                out[z++] = shiftsigned(v & mr, rshift, rcount);
                out[z++] = shiftsigned(v & mg, gshift, gcount);
@@ -3392,7 +3385,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;
+   guint8 *out;
 
 	// Check identifier
 	if (get32(s) != 0x38425053)	// "8BPS"
@@ -3472,7 +3465,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;
+			guint8 *p;
 			
          p = out+channel;
 			if (channel >= channelCount) {
@@ -3495,7 +3488,7 @@ static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
 							len--;
 						}
 					} else if (len > 128) {
-						uint32	val;
+						guint32	val;
 						// Next -len+1 bytes in the dest are replicated from next source byte.
 						// (Interpret len as a negative 8-bit int.)
 						len ^= 0x0FF;
@@ -3518,7 +3511,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;
+			guint8 *p;
 			
          p = out + channel;
 			if (channel > channelCount) {
@@ -3785,16 +3778,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) { uint8 z = (uint8) x; fwrite(&z,1,1,f); }
+static void write8(FILE *f, int x) { guint8 z = (guint8) x; fwrite(&z,1,1,f); }
 
 static void writefv(FILE *f, char *fmt, va_list v)
 {
    while (*fmt) {
       switch (*fmt++) {
          case ' ': break;
-         case '1': { uint8 x = va_arg(v, int); write8(f,x); break; }
-         case '2': { int16 x = va_arg(v, int); write8(f,x); write8(f,x>>8); break; }
-         case '4': { int32 x = va_arg(v, int); write8(f,x); write8(f,x>>8); write8(f,x>>16); write8(f,x>>24); 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; }
          default:
             assert(0);
             va_end(v);
@@ -3813,8 +3806,8 @@ 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)
 {
-   uint8 bg[3] = { 255, 0, 255}, px[3];
-   uint32 zero = 0;
+   guint8 bg[3] = { 255, 0, 255}, px[3];
+   guint32 zero = 0;
    int i,j,k, j_end;
 
    if (vdir < 0) 
@@ -3824,7 +3817,7 @@ static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp,
 
    for (; j != j_end; j += vdir) {
       for (i=0; i < x; ++i) {
-         uint8 *d = (uint8 *) data + (j*x+i)*comp;
+         guint8 *d = (guint8 *) data + (j*x+i)*comp;
          if (write_alpha < 0)
             fwrite(&d[comp-1], 1, 1, f);
          switch (comp) {



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]