// (Changes to this code are wrapped in __MOJOSETUP__ sections. --ryan.)

// (Changes to JUST THIS FILE are also public domain. The rest of MojoSetup

// falls under different licensing terms. --ryan.)

#if !__MOJOSETUP__

#error This file is probably miscompiled.

#endif

/* stbi-1.08 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c

when you control the images you're loading

QUICK NOTES:

Primarily of interest to game developers and other people who can

avoid problematic images and only need the trivial interface

JPEG baseline (no JPEG progressive, no oddball channel decimations)

PNG non-interlaced

BMP non-1bpp, non-RLE

TGA (not sure what subset, if a subset)

PSD (composite view only, no extra channels)

HDR (radiance rgbE format)

writes BMP,TGA (define STBI_NO_WRITE to remove code)

decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code)

TODO:

stbi_info_*

history:

1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz

1.07 attempt to fix C++ warning/errors again

1.06 attempt to fix C++ warning/errors again

1.05 fix TGA loading to return correct *comp and use good luminance calc

1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free

1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR

1.02 support for (subset of) HDR files, float interface for preferred access to them

1.01 fix bug: possible bug in handling right-side up bmps... not sure

fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all

1.00 interface to zlib that skips zlib header

0.99 correct handling of alpha in palette

0.98 TGA loader by lonesock; dynamically add loaders (untested)

0.97 jpeg errors on too large a file; also catch another malloc failure

0.96 fix detection of invalid v value - particleman@mollyrocket forum

0.95 during header scan, seek to markers in case of padding

0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same

0.93 handle jpegtran output; verbose errors

0.92 read 4,8,16,24,32-bit BMP files of several formats

0.91 output 24-bit Windows 3.0 BMP files

0.90 fix a few more warnings; bump version number to approach 1.0

0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd

0.60 fix compiling as c++

0.59 fix warnings: merge Dave Moore's -Wall fixes

0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian

0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less

than 16 available

0.56 fix bug: zlib uncompressed mode len vs. nlen

0.55 fix bug: restart_interval not initialized to 0

0.54 allow NULL for 'int *comp'

0.53 fix bug in png 3->4; speedup png decoding

0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments

0.51 obey req_comp requests, 1-component jpegs return as 1-component,

on 'test' only check type, not whether we support this variant

*/

#if __MOJOSETUP__

# include "universal.h" // catches xmalloc() defines, etc.

# undef malloc

# define malloc(x) xmalloc(x)

# undef realloc

# define realloc(x, y) xrealloc(x, y)

# define STBI_NO_WRITE 1

# define STBI_NO_STDIO 1

# define STBI_NO_FAILURE_STRINGS 1

# define STBI_NO_HDR 1

# endif

# define STBI_NO_TGA 1

# endif

# define STBI_NO_JPEG 1

# endif

# define STBI_NO_BMP 1

# endif

# define STBI_NO_PSD 1

# endif

# define STBI_NO_PNG 1

# define STBI_NO_ZLIB 1

# endif

#endif

//// begin header file ////////////////////////////////////////////////////

//

// Limitations:

// - no progressive/interlaced support (jpeg, png)

// - 8-bit samples only (jpeg, png)

// - not threadsafe

// - channel subsampling of at most 2 in each dimension (jpeg)

// - no delayed line count (jpeg) -- IJG doesn't support either

//

// 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 ...

// // ... 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)

//

// Standard parameters:

// int *x -- outputs image width in pixels

// int *y -- outputs image height in pixels

// 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

// to the pixel data. The pixel data consists of *y scanlines of *x pixels,

// with each pixel consisting of N interleaved 8-bit components; the first

// pixel pointed to is top-left-most in the image. There is no padding between

// image scanlines or between pixels, regardless of format. The number of

// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.

// If req_comp is non-zero, *comp has the number of components that _would_

// have been output otherwise. E.g. if you set req_comp to 4, you will always

// get RGBA output, but you can check *comp to easily see if it's opaque.

//

// An output image with N components has the following components interleaved

// in this order in each pixel:

//

// N=#comp components

// 1 grey

// 2 grey, alpha

// 3 red, green, blue

// 4 red, green, blue, alpha

//

// If image loading fails for any reason, the return value will be NULL,

// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()

// can be queried for an extremely brief, end-user unfriendly explanation

// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid

// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly

// more user-friendly ones.

//

// Paletted PNG and BMP images are automatically depalettized.

//

//

// ===========================================================================

//

// HDR image support (disable by defining STBI_NO_HDR)

//

// stb_image now supports loading HDR images in general, and currently

// the Radiance .HDR file format, although the support is provided

// generically. You can still load any file through the existing interface;

// if you attempt to load an HDR file, it will be automatically remapped to

// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;

// both of these constants can be reconfigured through this interface:

//

// stbi_hdr_to_ldr_gamma(2.2f);

// stbi_hdr_to_ldr_scale(1.0f);

//

// (note, do not use _inverse_ constants; stbi_image will invert them

// appropriately).

//

// Additionally, there is a new, parallel interface for loading files as

// (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:

//

// stbi_ldr_to_hdr_scale(1.0f);

// stbi_ldr_to_hdr_gamma(2.2f);

//

// Finally, given a filename (or an open file or memory block--see header

// file for details) containing image data, you can query for the "most

// appropriate" interface to use (that is, whether the image is HDR or

// not), using:

//

// stbi_is_hdr(char *filename);

#ifndef STBI_NO_STDIO

#include <stdio.h>

#endif

#ifndef STBI_NO_HDR

#include <math.h> // ldexp

#include <string.h> // strcmp

#endif

enum

{

STBI_default = 0, // only used for req_comp

STBI_grey = 1,

STBI_grey_alpha = 2,

STBI_rgb = 3,

STBI_rgb_alpha = 4,

};

typedef unsigned char stbi_uc;

#ifdef __cplusplus

extern "C" {

#endif

// WRITING API

#if !defined(STBI_NO_WRITE) && !defined(STBI_NO_STDIO)

// write a BMP/TGA file given tightly packed 'comp' channels (no padding, nor bmp-stride-padding)

// (you must include the appropriate extension in the filename).

// returns TRUE on success, FALSE if couldn't open file, error writing file

extern int stbi_write_bmp (char *filename, int x, int y, int comp, void *data);

extern int stbi_write_tga (char *filename, int x, int y, int comp, void *data);

#endif

// PRIMARY API - works on images of any type

// load image by filename, open file, or memory buffer

#ifndef STBI_NO_STDIO

extern stbi_uc *stbi_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);

#endif

extern stbi_uc *stbi_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

// for stbi_load_from_file, file pointer is left pointing immediately after image

#ifndef STBI_NO_HDR

#ifndef STBI_NO_STDIO

extern float *stbi_loadf (char *filename, int *x, int *y, int *comp, int req_comp);

extern float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

extern float *stbi_loadf_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

extern void stbi_hdr_to_ldr_gamma(float gamma);

extern void stbi_hdr_to_ldr_scale(float scale);

extern void stbi_ldr_to_hdr_gamma(float gamma);

extern void stbi_ldr_to_hdr_scale(float scale);

#endif // STBI_NO_HDR

// get a VERY brief reason for failure

extern char *stbi_failure_reason (void);

// free the loaded image -- this is just free()

extern void stbi_image_free (void *retval_from_stbi_load);

// get image dimensions & components without fully decoding

extern int stbi_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);

extern int stbi_is_hdr_from_memory(stbi_uc *buffer, int len);

#ifndef STBI_NO_STDIO

extern int stbi_info (char *filename, int *x, int *y, int *comp);

extern int stbi_is_hdr (char *filename);

extern int stbi_is_hdr_from_file(FILE *f);

#endif

// ZLIB client - used by PNG, available for other purposes

extern char *stbi_zlib_decode_malloc_guesssize(int initial_size, int *outlen);

extern char *stbi_zlib_decode_malloc(char *buffer, int len, int *outlen);

extern int stbi_zlib_decode_buffer(char *obuffer, int olen, char *ibuffer, int ilen);

extern char *stbi_zlib_decode_noheader_malloc(char *buffer, int len, int *outlen);

extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, char *ibuffer, int ilen);

// TYPE-SPECIFIC ACCESS

// is it a jpeg?

extern int stbi_jpeg_test_memory (stbi_uc *buffer, int len);

extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

extern int stbi_jpeg_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);

#ifndef STBI_NO_STDIO

extern stbi_uc *stbi_jpeg_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern int stbi_jpeg_test_file (FILE *f);

extern stbi_uc *stbi_jpeg_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

extern int stbi_jpeg_info (char *filename, int *x, int *y, int *comp);

extern int stbi_jpeg_info_from_file (FILE *f, int *x, int *y, int *comp);

#endif

extern int stbi_jpeg_dc_only; // only decode DC component

// is it a png?

extern int stbi_png_test_memory (stbi_uc *buffer, int len);

extern stbi_uc *stbi_png_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

extern int stbi_png_info_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp);

#ifndef STBI_NO_STDIO

extern stbi_uc *stbi_png_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern int stbi_png_info (char *filename, int *x, int *y, int *comp);

extern int stbi_png_test_file (FILE *f);

extern stbi_uc *stbi_png_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

extern int stbi_png_info_from_file (FILE *f, int *x, int *y, int *comp);

#endif

// is it a bmp?

extern int stbi_bmp_test_memory (stbi_uc *buffer, int len);

extern stbi_uc *stbi_bmp_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

#ifndef STBI_NO_STDIO

extern int stbi_bmp_test_file (FILE *f);

extern stbi_uc *stbi_bmp_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

// is it a tga?

extern int stbi_tga_test_memory (stbi_uc *buffer, int len);

extern stbi_uc *stbi_tga_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern stbi_uc *stbi_tga_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

#ifndef STBI_NO_STDIO

extern int stbi_tga_test_file (FILE *f);

extern stbi_uc *stbi_tga_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

// is it a psd?

extern int stbi_psd_test_memory (stbi_uc *buffer, int len);

extern stbi_uc *stbi_psd_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern stbi_uc *stbi_psd_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

#ifndef STBI_NO_STDIO

extern int stbi_psd_test_file (FILE *f);

extern stbi_uc *stbi_psd_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

// is it an hdr?

extern int stbi_hdr_test_memory (stbi_uc *buffer, int len);

extern float * stbi_hdr_load (char *filename, int *x, int *y, int *comp, int req_comp);

extern float * stbi_hdr_load_from_memory (stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

#ifndef STBI_NO_STDIO

extern int stbi_hdr_test_file (FILE *f);

extern float * stbi_hdr_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

// define new loaders

typedef struct

{

int (*test_memory)(stbi_uc *buffer, int len);

stbi_uc * (*load_from_memory)(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp);

#ifndef STBI_NO_STDIO

int (*test_file)(FILE *f);

stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp);

#endif

} stbi_loader;

// register a loader by filling out the above structure (you must defined ALL functions)

// returns 1 if added or already added, 0 if not added (too many loaders)

extern int stbi_register_loader(stbi_loader *loader);

#ifdef __cplusplus

}

#endif

//

//

//// end header file /////////////////////////////////////////////////////

#ifndef STBI_NO_STDIO

#include <stdio.h>

#endif

#include <stdlib.h>

#include <memory.h>

#include <assert.h>

#include <stdarg.h>

#ifndef _MSC_VER

#define __forceinline

#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];

#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)

#define STBI_NO_WRITE

#endif

//////////////////////////////////////////////////////////////////////////////

//

// Generic API that works on all image types

//

static char *failure_reason;

char *stbi_failure_reason(void)

{

return failure_reason;

}

static int e(char *str)

{

failure_reason = str;

return 0;

}

#ifdef STBI_NO_FAILURE_STRINGS

#define e(x,y) 0

#elif defined(STBI_FAILURE_USERMSG)

#define e(x,y) e(y)

#else

#define e(x,y) e(x)

#endif

#define epf(x,y) ((float *) (e(x,y)?NULL:NULL))

#define epuc(x,y) ((unsigned char *) (e(x,y)?NULL:NULL))

void stbi_image_free(void *retval_from_stbi_load)

{

free(retval_from_stbi_load);

}

#define MAX_LOADERS 32

stbi_loader *loaders[MAX_LOADERS];

static int max_loaders = 0;

int stbi_register_loader(stbi_loader *loader)

{

int i;

for (i=0; i < MAX_LOADERS; ++i) {

// already present?

if (loaders[i] == loader)

return 1;

// end of the list?

if (loaders[i] == NULL) {

loaders[i] = loader;

max_loaders = i+1;

return 1;

}

}

// no room for it

return 0;

}

#ifndef STBI_NO_HDR

static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);

static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp);

#endif

#ifndef STBI_NO_STDIO

unsigned char *stbi_load(char *filename, int *x, int *y, int *comp, int req_comp)

{

FILE *f = fopen(filename, "rb");

unsigned char *result;

if (!f) return epuc("can't fopen", "Unable to open file");

result = stbi_load_from_file(f,x,y,comp,req_comp);

fclose(f);

return result;

}

unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)

{

int i;

#ifndef STBI_NO_JPEG // __MOJOSETUP__

if (stbi_jpeg_test_file(f))

return stbi_jpeg_load_from_file(f,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_PNG // __MOJOSETUP__

if (stbi_png_test_file(f))

return stbi_png_load_from_file(f,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_BMP // __MOJOSETUP__

if (stbi_bmp_test_file(f))

return stbi_bmp_load_from_file(f,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_PSD // __MOJOSETUP__

if (stbi_psd_test_file(f))

return stbi_psd_load_from_file(f,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_HDR

if (stbi_hdr_test_file(f)) {

float *hdr = stbi_hdr_load_from_file(f, x,y,comp,req_comp);

return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);

}

#endif

for (i=0; i < max_loaders; ++i)

if (loaders[i]->test_file(f))

return loaders[i]->load_from_file(f,x,y,comp,req_comp);

#ifndef STBI_NO_TGA // __MOJOSETUP__

// test tga last because it's a crappy test!

if (stbi_tga_test_file(f))

return stbi_tga_load_from_file(f,x,y,comp,req_comp);

#endif // __MOJOSETUP__

return epuc("unknown image type", "Image not of any known type, or corrupt");

}

#endif

unsigned char *stbi_load_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)

{

int i;

#ifndef STBI_NO_JPEG // __MOJOSETUP__

if (stbi_jpeg_test_memory(buffer,len))

return stbi_jpeg_load_from_memory(buffer,len,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_PNG // __MOJOSETUP__

if (stbi_png_test_memory(buffer,len))

return stbi_png_load_from_memory(buffer,len,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_BMP // __MOJOSETUP__

if (stbi_bmp_test_memory(buffer,len))

return stbi_bmp_load_from_memory(buffer,len,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_PSD // __MOJOSETUP__

if (stbi_psd_test_memory(buffer,len))

return stbi_psd_load_from_memory(buffer,len,x,y,comp,req_comp);

#endif // __MOJOSETUP__

#ifndef STBI_NO_HDR

if (stbi_hdr_test_memory(buffer, len)) {

float *hdr = stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);

return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);

}

#endif

for (i=0; i < max_loaders; ++i)

if (loaders[i]->test_memory(buffer,len))

return loaders[i]->load_from_memory(buffer,len,x,y,comp,req_comp);

#ifndef STBI_NO_TGA // __MOJOSETUP__

// test tga last because it's a crappy test!

if (stbi_tga_test_memory(buffer,len))

return stbi_tga_load_from_memory(buffer,len,x,y,comp,req_comp);

#endif // __MOJOSETUP__

return epuc("unknown image type", "Image not of any known type, or corrupt");

}

#ifndef STBI_NO_HDR

#ifndef STBI_NO_STDIO

float *stbi_loadf(char *filename, int *x, int *y, int *comp, int req_comp)

{

FILE *f = fopen(filename, "rb");

float *result;

if (!f) return epf("can't fopen", "Unable to open file");

result = stbi_loadf_from_file(f,x,y,comp,req_comp);

fclose(f);

return result;

}

float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)

{

unsigned char *data;

#ifndef STBI_NO_HDR

if (stbi_hdr_test_file(f))

return stbi_hdr_load_from_file(f,x,y,comp,req_comp);

#endif

data = stbi_load_from_file(f, x, y, comp, req_comp);

if (data)

return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);

return epf("unknown image type", "Image not of any known type, or corrupt");

}

#endif

float *stbi_loadf_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp, int req_comp)

{

stbi_uc *data;

#ifndef STBI_NO_HDR

if (stbi_hdr_test_memory(buffer, len))

return stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp);

#endif

data = stbi_load_from_memory(buffer, len, x, y, comp, req_comp);

if (data)

return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);

return epf("unknown image type", "Image not of any known type, or corrupt");

}

#endif

// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is

// defined, for API simplicity; if STBI_NO_HDR is defined, it always

// reports false!

extern int stbi_is_hdr_from_memory(stbi_uc *buffer, int len)

{

#ifndef STBI_NO_HDR

return stbi_hdr_test_memory(buffer, len);

#else

return 0;

#endif

}

#ifndef STBI_NO_STDIO

extern int stbi_is_hdr (char *filename)

{

FILE *f = fopen(filename, "rb");

int result=0;

if (f) {

result = stbi_is_hdr_from_file(f);

fclose(f);

}

return result;

}

extern int stbi_is_hdr_from_file(FILE *f)

{

#ifndef STBI_NO_HDR

return stbi_hdr_test_file(f);

#else

return 0;

#endif

}

#endif

// @TODO: get image dimensions & components without fully decoding

#ifndef STBI_NO_STDIO

extern int stbi_info (char *filename, int *x, int *y, int *comp);

extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);

#endif

extern int stbi_info_from_memory(stbi_uc *buffer, int len, int *x, int *y, int *comp);

#ifndef STBI_NO_HDR

static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;

static float l2h_gamma=2.2f, l2h_scale=1.0f;

void stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }

void stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }

void stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }

void stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }

#endif

//////////////////////////////////////////////////////////////////////////////

//

// Common code used by all image loaders

//

// image width, height, # components

static uint32 img_x, img_y;

static int img_n, img_out_n;

#if __MOJOSETUP__ // moved here from elsewhere for #ifdef safety.

static uint8 *idata, *expanded, *out;

#endif

enum

{

SCAN_load=0,

SCAN_type,

SCAN_header,

};

// An API for reading either from memory or file.

#ifndef STBI_NO_STDIO

static FILE *img_file;

#endif

static uint8 *img_buffer, *img_buffer_end;

#ifndef STBI_NO_STDIO

static void start_file(FILE *f)

{

img_file = f;

}

#endif

static void start_mem(uint8 *buffer, int len)

{

#ifndef STBI_NO_STDIO

img_file = NULL;

#endif

img_buffer = buffer;

img_buffer_end = buffer+len;

}

static int get8(void)

{

#ifndef STBI_NO_STDIO

if (img_file) {

int c = fgetc(img_file);

return c == EOF ? 0 : c;

}

#endif

if (img_buffer < img_buffer_end)

return *img_buffer++;

return 0;

}

static int at_eof(void)

{

#ifndef STBI_NO_STDIO

if (img_file)

return feof(img_file);

#endif

return img_buffer >= img_buffer_end;

}

static uint8 get8u(void)

{

return (uint8) get8();

}

static void skip(int n)

{

#ifndef STBI_NO_STDIO

if (img_file)

fseek(img_file, n, SEEK_CUR);

else

#endif

img_buffer += n;

}

static int get16(void)

{

int z = get8();

return (z << 8) + get8();

}

static uint32 get32(void)

{

uint32 z = get16();

return (z << 16) + get16();

}

static int get16le(void)

{

int z = get8();

return z + (get8() << 8);

}

static uint32 get32le(void)

{

uint32 z = get16le();

return z + (get16le() << 16);

}

static void getn(stbi_uc *buffer, int n)

{

#ifndef STBI_NO_STDIO

if (img_file) {

fread(buffer, 1, n, img_file);

return;

}

#endif

memcpy(buffer, img_buffer, n);

img_buffer += n;

}

//////////////////////////////////////////////////////////////////////////////

//

// generic converter from built-in img_n to req_comp

// individual types do this automatically as much as possible (e.g. jpeg

// does all cases internally since it needs to colorspace convert anyway,

// and it never has alpha, so very few cases ). png can automatically

// interleave an alpha=255 channel, but falls back to this for other cases

//

// 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)

{

return (uint8) (((r*77) + (g*150) + (29*b)) >> 8);

}

static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp)

{

#if __MOJOSETUP__

//uint i,j;

uint32 i,j;

#endif

unsigned char *good;

if (req_comp == img_n) return data;

assert(req_comp >= 1 && req_comp <= 4);

good = (unsigned char *) malloc(req_comp * img_x * img_y);

if (good == NULL) {

free(data);

return epuc("outofmem", "Out of memory");

}

for (j=0; j < img_y; ++j) {

unsigned char *src = data + j * img_x * img_n ;

unsigned char *dest = good + j * img_x * req_comp;

#define COMBO(a,b) ((a)*8+(b))

#define CASE(a,b) case COMBO(a,b): for(i=0; i < img_x; ++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

switch(COMBO(img_n, req_comp)) {

CASE(1,2) dest[0]=src[0], dest[1]=255; break;

CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;

CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;

CASE(2,1) dest[0]=src[0]; break;

CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;

CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;

CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;

CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;

CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;

CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;

CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;

CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;

default: assert(0);

}

#undef CASE

}

free(data);

img_out_n = req_comp;

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));

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);

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] = float2int(z);

}

if (k < comp) {

float z = data[i*comp+k] * 255 + 0.5f;

if (z < 0) z = 0;

if (z > 255) z = 255;

output[i*comp + k] = float2int(z);

}

}

free(data);

return output;

}

#endif

#ifndef STBI_NO_JPEG // __MOJOSETUP__

//////////////////////////////////////////////////////////////////////////////

//

// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)

//

// simple implementation

// - channel subsampling of at most 2 in each dimension

// - doesn't support delayed output of y-dimension

// - simple interface (only one output format: 8-bit interleaved RGB)

// - doesn't try to recover corrupt jpegs

// - doesn't allow partial loading, loading multiple at once

// - still fast on x86 (copying globals into locals doesn't help x86)

// - allocates lots of intermediate memory (full size of all components)

// - non-interleaved case requires this anyway

// - allows good upsampling (see next)

// high-quality

// - upsampled channels are bilinearly interpolated, even across blocks

// - quality integer IDCT derived from IJG's 'slow'

// performance

// - fast huffman; reasonable integer IDCT

// - uses a lot of intermediate memory, could cache poorly

// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4

// stb_jpeg: 1.34 seconds (MSVC6, default release build)

// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro)

// IJL11.dll: 1.08 seconds (compiled by intel)

// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG)

// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro)

int stbi_jpeg_dc_only;

// huffman decoding acceleration

#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache

typedef struct

{

uint8 fast[1 << FAST_BITS];

// weirdly, repacking this into AoS is a 10% speed loss, instead of a win

uint16 code[256];

uint8 values[256];

uint8 size[257];

unsigned int maxcode[18];

int delta[17]; // old 'firstsymbol' - old 'firstcode'

} huffman;

static huffman huff_dc[4]; // baseline is 2 tables, extended is 4

static huffman huff_ac[4];

static uint8 dequant[4][64];

static int build_huffman(huffman *h, int *count)

{

int i,j,k=0,code;

// 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] = 0;

// compute actual symbols (from jpeg spec)

code = 0;

k = 0;

for(j=1; j <= 16; ++j) {

// compute delta to add to code to compute symbol id

h->delta[j] = k - code;

if (h->size[k] == j) {

while (h->size[k] == j)

h->code[k++] = (uint16) (code++);

if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG");

}

// compute largest code + 1 for this size, preshifted as needed later

h->maxcode[j] = code << (16-j);

code <<= 1;

}

h->maxcode[j] = 0xffffffff;

// build non-spec acceleration table; 255 is flag for not-accelerated

memset(h->fast, 255, 1 << FAST_BITS);

for (i=0; i < k; ++i) {

int s = h->size[i];

if (s <= FAST_BITS) {

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;

}

}

}

return 1;

}

// sizes for components, interleaved MCUs

static int img_h_max, img_v_max;

static int img_mcu_x, img_mcu_y;

static int img_mcu_w, img_mcu_h;

// definition of jpeg image component

static struct

{

int id;

int h,v;

int tq;

int hd,ha;

int dc_pred;

int x,y,w2,h2;

uint8 *data;

} img_comp[4];

static int code_bits; // number of valid bits

static unsigned char marker; // marker seen while filling entropy buffer

static int nomore; // flag if we saw a marker so must stop

static void grow_buffer_unsafe(void)

{

do {

int b = nomore ? 0 : get8();

if (b == 0xff) {

int c = get8();

if (c != 0) {

marker = (unsigned char) c;