 @@ -420,27 +420,27 @@ extern int      stbi_gif_info_from_file
 #ifndef STBI_HEADER_FILE_ONLY
 #ifndef STBI_NO_HDR
 #include <math.h>  // ldexp
 #include <string.h> // strcmp
 #endif
 #ifndef STBI_NO_STDIO
 #include <stdio.h>
 #endif
 #ifdef _KERNEL
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: stb_image.c,v 1.6 2013/09/15 14:06:10 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: stb_image.c,v 1.7 2016/01/21 17:16:48 christos Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/types.h>
 #include <sys/malloc.h>
 #else
 #include <stdlib.h>
 #include <memory.h>
 #include <assert.h>
 #include <stdarg.h>
 #endif
 #ifdef _KERNEL
 @@ -975,27 +975,27 @@ static uint32 get32le(stbi *s)
 static uint8 compute_y(int r, int g, int b)
+{
    return (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)
+{
    int i,j;
    unsigned char *good;
    if (req_comp == img_n) return data;
    assert(req_comp >= 1 && req_comp <= 4);
-   good = (unsigned char *) MALLOC(req_comp * x * y);
+   good = MALLOC(req_comp * x * y);
    if (good == NULL) {
       FREE(data);
       return epuc("outofmem", "Out of memory");
+   }
    for (j=0; j < (int) y; ++j) {
       unsigned char *src  = data + j * x * img_n   ;
       unsigned char *dest = good + j * x * req_comp;
       #define COMBO(a,b)  ((a)*8+(b))
       #define CASE(a,b)   case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
       // convert source image with img_n components to one with req_comp components;
       // avoid switch per pixel, so use switch per scanline and massive macros
 @@ -1015,45 +1015,45 @@ static unsigned char *convert_format(uns
          default: assert(0);
+      }
       #undef CASE
+   }
    FREE(data);
    return good;
+}
 #ifndef STBI_NO_HDR
 static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
    int i,k,n;
-   float *output = (float *) MALLOC(x * y * comp * sizeof(float));
+   float *output = MALLOC(x * y * comp * sizeof(float));
    if (output == NULL) { FREE(data); return epf("outofmem", "Out of memory"); }
    // compute number of non-alpha components
    if (comp & 1) n = comp; else n = comp-1;
    for (i=0; i < x*y; ++i) {
       for (k=0; k < n; ++k) {
          output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale;
+      }
       if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+   }
    FREE(data);
    return output;
+}
 #define float2int(x)   ((int) (x))
 static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
+{
    int i,k,n;
-   stbi_uc *output = (stbi_uc *) MALLOC(x * y * comp);
+   stbi_uc *output = MALLOC(x * y * comp);
    if (output == NULL) { FREE(data); return epuc("outofmem", "Out of memory"); }
    // compute number of non-alpha components
    if (comp & 1) n = comp; else n = comp-1;
    for (i=0; i < x*y; ++i) {
       for (k=0; k < n; ++k) {
          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);
+      }
       if (k < comp) {
          float z = data[i*comp+k] * 255 + 0.5f;
          if (z < 0) z = 0;
 @@ -1973,45 +1973,45 @@ static uint8 *load_jpeg_image(jpeg *z, i
+   {
       int k;
       uint i,j;
       uint8 *output;
       uint8 *coutput[4];
       stbi_resample res_comp[4];
       for (k=0; k < decode_n; ++k) {
          stbi_resample *r = &res_comp[k];
          // 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 = 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;
          r->vs      = z->img_v_max / z->img_comp[k].v;
          r->ystep   = r->vs >> 1;
          r->w_lores = (z->s.img_x + r->hs-1) / r->hs;
          r->ypos    = 0;
          r->line0   = r->line1 = z->img_comp[k].data;
          if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
          else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2;
          else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
          else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
          else                               r->resample = resample_row_generic;
+      }
       // can't error after this so, this is safe
-      output = (uint8 *) MALLOC(n * z->s.img_x * z->s.img_y + 1);
+      output = 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;
          for (k=0; k < decode_n; ++k) {
             stbi_resample *r = &res_comp[k];
             int y_bot = r->ystep >= (r->vs >> 1);
             coutput[k] = r->resample(z->img_comp[k].linebuf,
                                      y_bot ? r->line1 : r->line0,
                                      y_bot ? r->line0 : r->line1,
                                      r->w_lores, r->hs);
             if (++r->ystep >= r->vs) {
 @@ -2064,27 +2064,27 @@ unsigned char *stbi_jpeg_load(char const
    unsigned char *data;
    FILE *f = fopen(filename, "rb");
    if (!f) return NULL;
    data = stbi_jpeg_load_from_file(f,x,y,comp,req_comp);
    fclose(f);
    return data;
+}
 #endif
 unsigned char *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
    #ifdef STBI_SMALL_STACK
    unsigned char *result;
-   jpeg *j = (jpeg *) MALLOC(sizeof(*j));
+   jpeg *j = MALLOC(sizeof(*j));
    start_mem(&j->s, buffer, len);
    result = load_jpeg_image(j,x,y,comp,req_comp);
    FREE(j);
    return result;
    #else
    jpeg j;
    start_mem(&j.s, buffer,len);
    return load_jpeg_image(&j, x,y,comp,req_comp);
    #endif
+}
 static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp)
+{
 @@ -2502,75 +2502,75 @@ static int parse_zlib(zbuf *a, int parse
 static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
    a->zout_start = obuf;
    a->zout       = obuf;
    a->zout_end   = obuf + olen;
    a->z_expandable = exp;
    return parse_zlib(a, parse_header);
+}
 char *stbi_zlib_decode_malloc_guesssize(const char * buffer, int len, int initial_size, int *outlen)
+{
    zbuf a;
-   char *p = (char *) MALLOC(initial_size);
+   char *p = MALLOC(initial_size);
    if (p == NULL) return NULL;
    a.zbuffer = (uint8 const *) buffer;
    a.zbuffer_end = (uint8 const *) buffer + len;
    if (do_zlib(&a, p, initial_size, 1, 1)) {
       if (outlen) *outlen = (int) (a.zout - a.zout_start);
       return a.zout_start;
    } else {
       FREE(a.zout_start);
       return NULL;
+   }
+}
 char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
    return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
 char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
    zbuf a;
-   char *p = (char *) MALLOC(initial_size);
+   char *p = MALLOC(initial_size);
    if (p == NULL) return NULL;
    a.zbuffer = (uint8 const *) buffer;
    a.zbuffer_end = (uint8 const *) 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;
    } else {
       FREE(a.zout_start);
       return NULL;
+   }
+}
 int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
    zbuf a;
    a.zbuffer = (uint8 const *) ibuffer;
    a.zbuffer_end = (uint8 const *) ibuffer + ilen;
    if (do_zlib(&a, obuffer, olen, 0, 1))
       return (int) (a.zout - a.zout_start);
    else
       return -1;
+}
 char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
    zbuf a;
-   char *p = (char *) MALLOC(16384);
+   char *p = MALLOC(16384);
    if (p == NULL) return NULL;
    a.zbuffer = (uint8 const *) buffer;
    a.zbuffer_end = (uint8 const *) buffer+len;
    if (do_zlib(&a, p, 16384, 1, 0)) {
       if (outlen) *outlen = (int) (a.zout - a.zout_start);
       return a.zout_start;
    } else {
       FREE(a.zout_start);
       return NULL;
+   }
+}
 int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
 @@ -2647,27 +2647,27 @@ static int paeth(int a, int b, int c)
    if (pb <= pc) return b;
    return 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)
+{
    stbi *s = &a->s;
    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 = 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) {
          if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
       } else { // interlaced:
          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;
       int filter = *raw++;
       if (filter > 4) return e("invalid filter","Corrupt PNG");
 @@ -2727,27 +2727,27 @@ static int create_png_image_raw(png *a,
+}
 static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int interlaced)
+{
    uint8 *final;
    int p;
    int save;
    if (!interlaced)
       return create_png_image_raw(a, raw, raw_len, out_n, a->s.img_x, a->s.img_y);
    save = stbi_png_partial;
    stbi_png_partial = 0;
    // de-interlacing
-   final = (uint8 *) MALLOC(a->s.img_x * a->s.img_y * out_n);
+   final = 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 };
       int xspc[]  = { 8,8,4,4,2,2,1 };
       int yspc[]  = { 8,8,8,4,4,2,2 };
       int i,j,x,y;
       // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
       x = (a->s.img_x - xorig[p] + xspc[p]-1) / xspc[p];
       y = (a->s.img_y - yorig[p] + yspc[p]-1) / yspc[p];
       if (x && y) {
          if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) {
             FREE(final);
             return 0;
 @@ -2787,27 +2787,27 @@ static int compute_transparency(png *z,
          if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
             p[3] = 0;
          p += 4;
+      }
+   }
    return 1;
+}
 static int expand_palette(png *a, 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;
-   p = (uint8 *) MALLOC(pixel_count * pal_img_n);
+   p = MALLOC(pixel_count * pal_img_n);
    if (p == NULL) return e("outofmem", "Out of memory");
    // between here and FREE(out) below, exiting would leak
    temp_out = p;
    if (pal_img_n == 3) {
       for (i=0; i < pixel_count; ++i) {
          int n = orig[i]*4;
          p[0] = palette[n  ];
          p[1] = palette[n+1];
          p[2] = palette[n+2];
          p += 3;
+      }
 @@ -3295,27 +3295,27 @@ static stbi_uc *bmp_load(stbi *s, int *x
          ma = get32le(s);
          get32le(s); // discard color space
          for (i=0; i < 12; ++i)
             get32le(s); // discard color space parameters
+      }
       if (bpp < 16)
          psize = (offset - 14 - hsz) >> 2;
+   }
    s->img_n = ma ? 4 : 3;
    if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
       target = req_comp;
    else
       target = s->img_n; // if they want monochrome, we'll post-convert
-   out = (stbi_uc *) MALLOC(target * s->img_x * s->img_y);
+   out = MALLOC(target * s->img_x * s->img_y);
    if (!out) return epuc("outofmem", "Out of memory");
    if (bpp < 16) {
       int z=0;
       if (psize == 0 || psize > 256) { FREE(out); return epuc("invalid", "Corrupt BMP"); }
       for (i=0; i < psize; ++i) {
          pal[i][2] = get8u(s);
          pal[i][1] = get8u(s);
          pal[i][0] = get8u(s);
          if (hsz != 12) get8(s);
          pal[i][3] = 255;
+      }
       skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
       if (bpp == 4) width = (s->img_x + 1) >> 1;
 @@ -3584,37 +3584,37 @@ static stbi_uc *tga_load(stbi *s, int *x
    //   tga info
    *x = tga_width;
    *y = tga_height;
    if ( (req_comp < 1) || (req_comp > 4) )
+   {
       //   just use whatever the file was
       req_comp = tga_bits_per_pixel / 8;
       *comp = req_comp;
    } else
+   {
       //   force a new number of components
       *comp = tga_bits_per_pixel/8;
+   }
-   tga_data = (unsigned char*)MALLOC( tga_width * tga_height * req_comp );
+   tga_data = MALLOC( tga_width * tga_height * req_comp );
    //   skip to the data's starting position (offset usually = 0)
    skip(s, tga_offset );
    //   do I need to load a palette?
    if ( tga_indexed )
+   {
       //   any data to skip? (offset usually = 0)
       skip(s, tga_palette_start );
       //   load the palette
-      tga_palette = (unsigned char*)MALLOC( tga_palette_len * tga_palette_bits / 8 );
+      tga_palette = MALLOC( tga_palette_len * tga_palette_bits / 8 );
       if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 ))
          return NULL;
+   }
    //   load the data
    trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0;
    for (i=0; i < tga_width * tga_height; ++i)
+   {
       //   if I'm in RLE mode, do I need to get a RLE chunk?
       if ( tga_is_RLE )
+      {
          if ( RLE_count == 0 )
+         {
             //   yep, get the next byte as a RLE command
 @@ -3858,27 +3858,27 @@ static stbi_uc *psd_load(stbi *s, int *x
    // Skip the reserved data.
    skip(s, get32(s) );
    // Find out if the data is compressed.
    // Known values:
    //   0: no compression
    //   1: RLE compressed
    compression = get16(s);
    if (compression > 1)
       return epuc("bad compression", "PSD has an unknown compression format");
    // Create the destination image.
-   out = (stbi_uc *) MALLOC(4 * w*h);
+   out = MALLOC(4 * w*h);
    if (!out) return epuc("outofmem", "Out of memory");
    pixelCount = w*h;
    // Initialize the data to zero.
    //memset( out, 0, pixelCount * 4 );
    // Finally, the image data.
    if (compression) {
       // RLE as used by .PSD and .TIFF
       // Loop until you get the number of unpacked bytes you are expecting:
       //     Read the next source byte into n.
       //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
       //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
 @@ -4168,27 +4168,27 @@ static stbi_uc *pic_load(stbi *s,int *px
    for (i=0; i<92; ++i)
       get8(s);
    x = get16(s);
    y = get16(s);
    if (at_eof(s))  return epuc("bad file","file too short (pic header)");
    if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode");
    get32(s); //skip `ratio'
    get16(s); //skip `fields'
    get16(s); //skip `pad'
    // intermediate buffer is RGBA
-   result = (stbi_uc *) MALLOC(x*y*4);
+   result = MALLOC(x*y*4);
    memset(result, 0xff, x*y*4);
    if (!pic_load2(s,x,y,comp, result)) {
       FREE(result);
       result=0;
+   }
    *px = x;
    *py = y;
    if (req_comp == 0) req_comp = *comp;
    result=convert_format(result,4,req_comp,x,y);
    return result;
+}
 @@ -4464,34 +4464,34 @@ static void stbi_fill_gif_background(stb
       p[2] = c[0];
       p[3] = c[3];
+   }
+}
 // 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)
+{
    int i;
    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 = 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 = 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);
+      }
+   }
    for (;;) {
       switch (get8(s)) {
          case 0x2C: /* Image Descriptor */
+         {
             int32 x, y, w, h;
             uint8 *o;
             x = get16le(s);
 @@ -4593,27 +4593,27 @@ stbi_uc *stbi_gif_load_from_file   (FILE
+   }
    return u;
+}
 #endif
 stbi_uc *stbi_gif_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
    uint8 *u = 0;
    stbi s;
    stbi_gif *pg;
    #ifdef STBI_SMALL_STACK
-   pg = (stbi_gif *) MALLOC(sizeof(*pg));
+   pg = MALLOC(sizeof(*pg));
    if (pg == NULL)
       return NULL;
    #else
    stbi_gif g;
    pg = &g;
    #endif
    memset(pg, 0, sizeof(*pg));
    start_mem(&s, buffer, len);
    u = stbi_gif_load_next(&s, pg, comp, req_comp);
    if (u == (void *) 1) u = 0;  // end of animated gif marker
    if (u) {
       *x = pg->w;
 @@ -4778,27 +4778,27 @@ static float *hdr_load(stbi *s, int *x,
    height = strtol(token, &token, 10);
    while (*token == ' ') ++token;
    if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
    token += 3;
    width = strtol(token, NULL, 10);
    *x = width;
    *y = height;
    *comp = 3;
    if (req_comp == 0) req_comp = 3;
    // Read data
-   hdr_data = (float *) MALLOC(height * width * req_comp * sizeof(float));
+   hdr_data = MALLOC(height * width * req_comp * sizeof(float));
    // Load image data
    // image data is stored as some number of sca
    if ( width < 8 || width >= 32768) {
       // Read flat data
       for (j=0; j < height; ++j) {
          for (i=0; i < width; ++i) {
             stbi_uc rgbe[4];
            main_decode_loop:
             getn(s, rgbe, 4);
             hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
 @@ -4817,27 +4817,27 @@ static float *hdr_load(stbi *s, int *x,
             rgbe[0] = (uint8) c1;
             rgbe[1] = (uint8) c2;
             rgbe[2] = (uint8) len;
             rgbe[3] = (uint8) get8u(s);
             hdr_convert(hdr_data, rgbe, req_comp);
             i = 1;
             j = 0;
             FREE(scanline);
             goto main_decode_loop; // yes, this makes no sense
+         }
          len <<= 8;
          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);
+         if (scanline == NULL) scanline = MALLOC(width * 4);
          for (k = 0; k < 4; ++k) {
             i = 0;
             while (i < width) {
                count = get8u(s);
                if (count > 128) {
                   // Run
                   value = get8u(s);
                   count -= 128;
                   for (z = 0; z < count; ++z)
                      scanline[i++ * 4 + k] = value;
                } else {
                   // Dump