Mercurial > hg > dmlib
changeset 1165:737ae4718c8f
Use dmMemset, dmMalloc, dmRealloc and dmFree directly.
Use Uint8 instead of unsigned char.
| author | Matti Hamalainen <ccr@tnsp.org> |
|---|---|
| date | Thu, 05 Mar 2015 07:27:54 +0200 |
| parents | fa59b65149e6 |
| children | f29fa5b6b748 |
| files | src/dmimage.c src/stb_image.c |
| diffstat | 2 files changed, 85 insertions(+), 109 deletions(-) [+] |
line wrap: on
line diff
--- a/src/dmimage.c Thu Mar 05 07:22:23 2015 +0200 +++ b/src/dmimage.c Thu Mar 05 07:27:54 2015 +0200 @@ -22,10 +22,6 @@ #define STB_IMAGE_IMPLEMENTATION 1 #define STBI_NO_STDIO 1 -#define STBI_MALLOC(sz) dmMalloc(sz) -#define STBI_REALLOC(p,sz) dmRealloc(p,sz) -#define STBI_FREE(p) dmFree(p) - #include "stb_image.c"
--- a/src/stb_image.c Thu Mar 05 07:22:23 2015 +0200 +++ b/src/stb_image.c Thu Mar 05 07:27:54 2015 +0200 @@ -218,7 +218,7 @@ // // Basic usage (see HDR discussion below for HDR usage): // int x,y,n; -// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// Uint8 *data = stbi_load(filename, &x, &y, &n, 0); // // ... 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 @@ -231,7 +231,7 @@ // int *comp -- outputs # of image components in image file // int req_comp -- if non-zero, # of image components requested in result // -// The return value from an image loader is an 'unsigned char *' which points +// The return value from an image loader is an 'Uint8 *' which points // to the pixel data, or NULL on an allocation failure or if the image is // corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, // with each pixel consisting of N interleaved 8-bit components; the first @@ -563,21 +563,6 @@ #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) #endif -#if defined(STBI_MALLOC) && defined(STBI_FREE) && defined(STBI_REALLOC) -// ok -#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) -// ok -#else -#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC." -#endif - -#ifndef STBI_MALLOC -#define STBI_MALLOC(sz) malloc(sz) -#define STBI_REALLOC(p,sz) realloc(p,sz) -#define STBI_FREE(p) free(p) -#define STBI_MEMSET(p, v, s) memset(p,v,s) -#endif - #if defined(__GNUC__) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) // gcc doesn't support sse2 intrinsics unless you compile with -msse2, // (but compiling with -msse2 allows the compiler to use SSE2 everywhere; @@ -808,14 +793,10 @@ } #endif -static void *stbi__malloc(size_t size) -{ - return STBI_MALLOC(size); -} // stbi__err - error // stbi__errpf - error returning pointer to float -// stbi__errpuc - error returning pointer to unsigned char +// stbi__errpuc - error returning pointer to Uint8 #ifdef STBI_NO_FAILURE_STRINGS #define stbi__err(x,y) 0 @@ -826,11 +807,11 @@ #endif #define stbi__errpf(x,y) ((float *) (stbi__err(x,y)?NULL:NULL)) -#define stbi__errpuc(x,y) ((unsigned char *) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((Uint8 *) (stbi__err(x,y)?NULL:NULL)) STBIDEF void stbi_image_free(void *retval_from_stbi_load) { - STBI_FREE(retval_from_stbi_load); + dmFree(retval_from_stbi_load); } #ifndef STBI_NO_LINEAR @@ -841,7 +822,7 @@ static Uint8 *stbi__hdr_to_ldr(float *data, int x, int y, int comp); #endif -static unsigned char *stbi_load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +static Uint8 *stbi_load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) { #ifndef STBI_NO_JPEG if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp); @@ -899,7 +880,7 @@ STBIDEF Uint8 *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) { FILE *f = stbi__fopen(filename, "rb"); - unsigned char *result; + Uint8 *result; if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); result = stbi_load_from_file(f,x,y,comp,req_comp); fclose(f); @@ -908,7 +889,7 @@ STBIDEF Uint8 *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) { - unsigned char *result; + Uint8 *result; stbi__context s; stbi__start_file(&s,f); result = stbi_load_main(&s,x,y,comp,req_comp); @@ -937,7 +918,7 @@ #ifndef STBI_NO_LINEAR static float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) { - unsigned char *data; + Uint8 *data; #ifndef STBI_NO_HDR if (stbi__hdr_test(s)) return stbi__hdr_load(s,x,y,comp,req_comp); @@ -1184,23 +1165,23 @@ return (Uint8) (((r*77) + (g*150) + (29*b)) >> 8); } -static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +static Uint8 *stbi__convert_format(Uint8 *data, int img_n, int req_comp, unsigned int x, unsigned int y) { int i,j; - unsigned char *good; + Uint8 *good; if (req_comp == img_n) return data; STBI_ASSERT(req_comp >= 1 && req_comp <= 4); - good = (unsigned char *) stbi__malloc(req_comp * x * y); + good = (Uint8 *) dmMalloc(req_comp * x * y); if (good == NULL) { - STBI_FREE(data); + dmFree(data); return stbi__errpuc("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; + Uint8 *src = data + j * x * img_n ; + Uint8 *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) @@ -1224,7 +1205,7 @@ #undef CASE } - STBI_FREE(data); + dmFree(data); return good; } @@ -1232,8 +1213,8 @@ static float *stbi__ldr_to_hdr(Uint8 *data, int x, int y, int comp) { int i,k,n; - float *output = (float *) stbi__malloc(x * y * comp * sizeof(float)); - if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + float *output = (float *) dmMalloc(x * y * comp * sizeof(float)); + if (output == NULL) { dmFree(data); return stbi__errpf("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) { @@ -1242,7 +1223,7 @@ } if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; } - STBI_FREE(data); + dmFree(data); return output; } #endif @@ -1252,8 +1233,8 @@ static Uint8 *stbi__hdr_to_ldr(float *data, int x, int y, int comp) { int i,k,n; - Uint8 *output = (Uint8 *) stbi__malloc(x * y * comp); - if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + Uint8 *output = (Uint8 *) dmMalloc(x * y * comp); + if (output == NULL) { dmFree(data); return stbi__errpuc("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) { @@ -1270,7 +1251,7 @@ output[i*comp + k] = (Uint8) stbi__float2int(z); } } - STBI_FREE(data); + dmFree(data); return output; } #endif @@ -1344,7 +1325,7 @@ Uint32 code_buffer; // jpeg entropy-coded buffer int code_bits; // number of valid bits - unsigned char marker; // marker seen while filling entropy buffer + Uint8 marker; // marker seen while filling entropy buffer int nomore; // flag if we saw a marker so must stop int progressive; @@ -1390,7 +1371,7 @@ h->maxcode[j] = 0xffffffff; // build non-spec acceleration table; 255 is flag for not-accelerated - STBI_MEMSET(h->fast, 255, 1 << FAST_BITS); + dmMemset(h->fast, 255, 1 << FAST_BITS); for (i=0; i < k; ++i) { int s = h->size[i]; if (s <= FAST_BITS) { @@ -1438,7 +1419,7 @@ if (b == 0xff) { int c = stbi__get8(j->s); if (c != 0) { - j->marker = (unsigned char) c; + j->marker = (Uint8) c; j->nomore = 1; return; } @@ -1570,7 +1551,7 @@ if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); // 0 all the ac values now so we can do it 32-bits at a time - STBI_MEMSET(data,0,64*sizeof(data[0])); + dmMemset(data,0,64*sizeof(data[0])); diff = t ? stbi__extend_receive(j, t) : 0; dc = j->img_comp[b].dc_pred + diff; @@ -1622,7 +1603,7 @@ if (j->succ_high == 0) { // first scan for DC coefficient, must be first - STBI_MEMSET(data,0,64*sizeof(data[0])); // 0 all the ac values now + dmMemset(data,0,64*sizeof(data[0])); // 0 all the ac values now t = stbi__jpeg_huff_decode(j, hdc); diff = t ? stbi__extend_receive(j, t) : 0; @@ -2601,11 +2582,11 @@ // discard the extra data until colorspace conversion z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; - z->img_comp[i].raw_data = stbi__malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); + z->img_comp[i].raw_data = dmMalloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); if (z->img_comp[i].raw_data == NULL) { for(--i; i >= 0; --i) { - STBI_FREE(z->img_comp[i].raw_data); + dmFree(z->img_comp[i].raw_data); z->img_comp[i].data = NULL; } return stbi__err("outofmem", "Out of memory"); @@ -2616,7 +2597,7 @@ if (z->progressive) { z->img_comp[i].coeff_w = (z->img_comp[i].w2 + 7) >> 3; z->img_comp[i].coeff_h = (z->img_comp[i].h2 + 7) >> 3; - z->img_comp[i].raw_coeff = STBI_MALLOC(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15); + z->img_comp[i].raw_coeff = dmMalloc(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15); z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); } else { z->img_comp[i].coeff = 0; @@ -2974,7 +2955,7 @@ __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); - __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i y_bias = _mm_set1_epi8((char) (Uint8) 128); __m128i xw = _mm_set1_epi16(255); // alpha channel for (; i+7 < count; i += 8) { @@ -3125,17 +3106,17 @@ int i; for (i=0; i < j->s->img_n; ++i) { if (j->img_comp[i].raw_data) { - STBI_FREE(j->img_comp[i].raw_data); + dmFree(j->img_comp[i].raw_data); j->img_comp[i].raw_data = NULL; j->img_comp[i].data = NULL; } if (j->img_comp[i].raw_coeff) { - STBI_FREE(j->img_comp[i].raw_coeff); + dmFree(j->img_comp[i].raw_coeff); j->img_comp[i].raw_coeff = 0; j->img_comp[i].coeff = 0; } if (j->img_comp[i].linebuf) { - STBI_FREE(j->img_comp[i].linebuf); + dmFree(j->img_comp[i].linebuf); j->img_comp[i].linebuf = NULL; } } @@ -3184,7 +3165,7 @@ // allocate line buffer big enough for upsampling off the edges // with upsample factor of 4 - z->img_comp[k].linebuf = (Uint8 *) stbi__malloc(z->s->img_x + 3); + z->img_comp[k].linebuf = (Uint8 *) dmMalloc(z->s->img_x + 3); if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } r->hs = z->img_h_max / z->img_comp[k].h; @@ -3202,7 +3183,7 @@ } // can't error after this so, this is safe - output = (Uint8 *) stbi__malloc(n * z->s->img_x * z->s->img_y + 1); + output = (Uint8 *) dmMalloc(n * z->s->img_x * z->s->img_y + 1); if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } // now go ahead and resample @@ -3248,7 +3229,7 @@ } } -static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +static Uint8 *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) { stbi__jpeg j; j.s = s; @@ -3372,7 +3353,7 @@ int img_n = s->img_n; // copy it into a local for later STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); - a->out = (Uint8 *) stbi__malloc(x * y * out_n); // extra bytes to write off the end into + a->out = (Uint8 *) dmMalloc(x * y * out_n); // extra bytes to write off the end into if (!a->out) return stbi__err("outofmem", "Out of memory"); img_width_bytes = (((img_n * x * depth) + 7) >> 3); @@ -3549,7 +3530,7 @@ return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); // de-interlacing - final = (Uint8 *) stbi__malloc(a->s->img_x * a->s->img_y * out_n); + final = (Uint8 *) dmMalloc(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 }; @@ -3562,7 +3543,7 @@ if (x && y) { Uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { - STBI_FREE(final); + dmFree(final); return 0; } for (j=0; j < y; ++j) { @@ -3573,7 +3554,7 @@ a->out + (j*x+i)*out_n, out_n); } } - STBI_FREE(a->out); + dmFree(a->out); image_data += img_len; image_data_len -= img_len; } @@ -3613,7 +3594,7 @@ Uint32 i, pixel_count = a->s->img_x * a->s->img_y; Uint8 *p, *temp_out, *orig = a->out; - p = (Uint8 *) stbi__malloc(pixel_count * pal_img_n); + p = (Uint8 *) dmMalloc(pixel_count * pal_img_n); if (p == NULL) return stbi__err("outofmem", "Out of memory"); // between here and free(out) below, exitting would leak @@ -3637,7 +3618,7 @@ p += 4; } } - STBI_FREE(a->out); + dmFree(a->out); a->out = temp_out; STBI_NOTUSED(len); @@ -3844,7 +3825,7 @@ if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; while (ioff + c.length > idata_limit) idata_limit *= 2; - p = (Uint8 *) STBI_REALLOC(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + p = (Uint8 *) dmRealloc(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); z->idata = p; } if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); @@ -3867,7 +3848,7 @@ raw_len, !is_iphone) != DMERR_OK) return 0; - STBI_FREE(z->idata); z->idata = NULL; + dmFree(z->idata); z->idata = NULL; if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) s->img_out_n = s->img_n+1; @@ -3886,7 +3867,7 @@ if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) return 0; } - STBI_FREE(z->expanded); z->expanded = NULL; + dmFree(z->expanded); z->expanded = NULL; return 1; } @@ -3912,9 +3893,9 @@ } } -static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp) +static Uint8 *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp) { - unsigned char *result=NULL; + Uint8 *result=NULL; if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { result = p->out; @@ -3928,14 +3909,14 @@ *y = p->s->img_y; if (n) *n = p->s->img_out_n; } - STBI_FREE(p->out); p->out = NULL; - STBI_FREE(p->expanded); p->expanded = NULL; - STBI_FREE(p->idata); p->idata = NULL; + dmFree(p->out); p->out = NULL; + dmFree(p->expanded); p->expanded = NULL; + dmFree(p->idata); p->idata = NULL; return result; } -static unsigned char *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +static Uint8 *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) { stbi__png p; p.s = s; @@ -4130,11 +4111,11 @@ target = req_comp; else target = s->img_n; // if they want monochrome, we'll post-convert - out = (Uint8 *) stbi__malloc(target * s->img_x * s->img_y); + out = (Uint8 *) dmMalloc(target * s->img_x * s->img_y); if (!out) return stbi__errpuc("outofmem", "Out of memory"); if (bpp < 16) { int z=0; - if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + if (psize == 0 || psize > 256) { dmFree(out); return stbi__errpuc("invalid", "Corrupt BMP"); } for (i=0; i < psize; ++i) { pal[i][2] = stbi__get8(s); pal[i][1] = stbi__get8(s); @@ -4145,7 +4126,7 @@ stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); if (bpp == 4) width = (s->img_x + 1) >> 1; else if (bpp == 8) width = s->img_x; - else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + else { dmFree(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } pad = (-width)&3; for (j=0; j < (int) s->img_y; ++j) { for (i=0; i < (int) s->img_x; i += 2) { @@ -4183,7 +4164,7 @@ easy = 2; } if (!easy) { - if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + if (!mr || !mg || !mb) { dmFree(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } // right shift amt to put high bit in position #7 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); @@ -4193,7 +4174,7 @@ for (j=0; j < (int) s->img_y; ++j) { if (easy) { for (i=0; i < (int) s->img_x; ++i) { - unsigned char a; + Uint8 a; out[z+2] = stbi__get8(s); out[z+1] = stbi__get8(s); out[z+0] = stbi__get8(s); @@ -4321,10 +4302,10 @@ int tga_comp = tga_bits_per_pixel / 8; int tga_inverted = stbi__get8(s); // image data - unsigned char *tga_data; - unsigned char *tga_palette = NULL; + Uint8 *tga_data; + Uint8 *tga_palette = NULL; int i, j; - unsigned char raw_data[4]; + Uint8 raw_data[4]; int RLE_count = 0; int RLE_repeating = 0; int read_next_pixel = 1; @@ -4360,7 +4341,7 @@ *y = tga_height; if (comp) *comp = tga_comp; - tga_data = (unsigned char*)stbi__malloc( tga_width * tga_height * tga_comp ); + tga_data = (Uint8*)dmMalloc( tga_width * tga_height * tga_comp ); if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); // skip to the data's starting position (offset usually = 0) @@ -4379,14 +4360,14 @@ // any data to skip? (offset usually = 0) stbi__skip(s, tga_palette_start ); // load the palette - tga_palette = (unsigned char*)stbi__malloc( tga_palette_len * tga_palette_bits / 8 ); + tga_palette = (Uint8*)dmMalloc( tga_palette_len * tga_palette_bits / 8 ); if (!tga_palette) { - STBI_FREE(tga_data); + dmFree(tga_data); return stbi__errpuc("outofmem", "Out of memory"); } if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { - STBI_FREE(tga_data); - STBI_FREE(tga_palette); + dmFree(tga_data); + dmFree(tga_palette); return stbi__errpuc("bad palette", "Corrupt TGA"); } } @@ -4457,7 +4438,7 @@ int index2 = (tga_height - 1 - j) * tga_width * tga_comp; for (i = tga_width * tga_comp; i > 0; --i) { - unsigned char temp = tga_data[index1]; + Uint8 temp = tga_data[index1]; tga_data[index1] = tga_data[index2]; tga_data[index2] = temp; ++index1; @@ -4468,17 +4449,17 @@ // clear my palette, if I had one if ( tga_palette != NULL ) { - STBI_FREE( tga_palette ); + dmFree( tga_palette ); } } // swap RGB if (tga_comp >= 3) { - unsigned char* tga_pixel = tga_data; + Uint8* tga_pixel = tga_data; for (i=0; i < tga_width * tga_height; ++i) { - unsigned char temp = tga_pixel[0]; + Uint8 temp = tga_pixel[0]; tga_pixel[0] = tga_pixel[2]; tga_pixel[2] = temp; tga_pixel += tga_comp; @@ -4572,12 +4553,12 @@ return stbi__errpuc("bad compression", "PSD has an unknown compression format"); // Create the destination image. - out = (Uint8 *) stbi__malloc(4 * w*h); + out = (Uint8 *) dmMalloc(4 * w*h); if (!out) return stbi__errpuc("outofmem", "Out of memory"); pixelCount = w*h; // Initialize the data to zero. - //STBI_MEMSET( out, 0, pixelCount * 4 ); + //dmMemset( out, 0, pixelCount * 4 ); // Finally, the image data. if (compression) { @@ -4859,11 +4840,11 @@ stbi__get16be(s); //skip `pad' // intermediate buffer is RGBA - result = (Uint8 *) stbi__malloc(x*y*4); - STBI_MEMSET(result, 0xff, x*y*4); + result = (Uint8 *) dmMalloc(x*y*4); + dmMemset(result, 0xff, x*y*4); if (!stbi__pic_load_core(s,x,y,comp, result)) { - STBI_FREE(result); + dmFree(result); result=0; } *px = x; @@ -5113,14 +5094,14 @@ if (g->out == 0) { if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header - g->out = (Uint8 *) stbi__malloc(4 * g->w * g->h); + g->out = (Uint8 *) dmMalloc(4 * g->w * g->h); if (g->out == 0) return stbi__errpuc("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 *) stbi__malloc(4 * g->w * g->h); + g->out = (Uint8 *) dmMalloc(4 * g->w * g->h); if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); memcpy(g->out, old_out, g->w*g->h*4); } @@ -5210,7 +5191,7 @@ { Uint8 *u = 0; stbi__gif g; - STBI_MEMSET(&g, 0, sizeof(g)); + dmMemset(&g, 0, sizeof(g)); u = stbi__gif_load_next(s, &g, comp, req_comp); if (u == (Uint8 *) s) u = 0; // end of animated gif marker @@ -5308,7 +5289,7 @@ Uint8 *scanline; float *hdr_data; int len; - unsigned char count, value; + Uint8 count, value; int i, j, k, c1,c2, z; @@ -5343,7 +5324,7 @@ if (req_comp == 0) req_comp = 3; // Read data - hdr_data = (float *) stbi__malloc(height * width * req_comp * sizeof(float)); + hdr_data = (float *) dmMalloc(height * width * req_comp * sizeof(float)); // Load image data // image data is stored as some number of sca @@ -5376,13 +5357,13 @@ stbi__hdr_convert(hdr_data, rgbe, req_comp); i = 1; j = 0; - STBI_FREE(scanline); + dmFree(scanline); goto main_decode_loop; // yes, this makes no sense } len <<= 8; len |= stbi__get8(s); - if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } - if (scanline == NULL) scanline = (Uint8 *) stbi__malloc(width * 4); + if (len != width) { dmFree(hdr_data); dmFree(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) scanline = (Uint8 *) dmMalloc(width * 4); for (k = 0; k < 4; ++k) { i = 0; @@ -5404,7 +5385,7 @@ for (i=0; i < width; ++i) stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); } - STBI_FREE(scanline); + dmFree(scanline); } return hdr_data; @@ -5595,7 +5576,7 @@ *y = s->img_y; *comp = s->img_n; - out = (Uint8 *) stbi__malloc(s->img_n * s->img_x * s->img_y); + out = (Uint8 *) dmMalloc(s->img_n * s->img_x * s->img_y); if (!out) return stbi__errpuc("outofmem", "Out of memory"); stbi__getn(s, out, s->img_n * s->img_x * s->img_y); @@ -5754,11 +5735,10 @@ revision history: 2.02 (2015-01-19) fix incorrect assert, fix warning 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 - 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00b (2014-12-25) fix dmMalloc in progressive JPEG 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) progressive JPEG (stb) PGM/PPM support (Ken Miller) - STBI_MALLOC,STBI_REALLOC,STBI_FREE GIF bugfix -- seemingly never worked STBI_NO_*, STBI_ONLY_* 1.48 (2014-12-14) fix incorrectly-named assert()