2014-08-27 00:39:53 +04:00
/* stb_image - v1.46 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
2014-05-31 15:49:43 +04:00
when you control the images you ' re loading
no warranty implied ; use at your own risk
Do this :
# define STB_IMAGE_IMPLEMENTATION
before you include this file in * one * C or C + + file to create the implementation .
2014-07-10 10:35:25 +04:00
# define STBI_ASSERT(x) to avoid using assert.h.
2014-05-31 15:49:43 +04:00
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 )
PNG 8 - bit - per - channel only
TGA ( not sure what subset , if a subset )
BMP non - 1 bpp , non - RLE
PSD ( composited view only , no extra channels )
GIF ( * comp always reports as 4 - channel )
HDR ( radiance rgbE format )
PIC ( Softimage PIC )
2014-06-26 02:29:29 +04:00
- decode from memory or through FILE ( define STBI_NO_STDIO to remove code )
- decode from arbitrary I / O callbacks
2014-05-31 15:49:43 +04:00
- overridable dequantizing - IDCT , YCbCr - to - RGB conversion ( define STBI_SIMD )
Latest revisions :
2014-08-27 00:39:53 +04:00
1.46 ( 2014 - 08 - 26 ) fix broken tRNS chunk in non - paletted PNG
2014-08-17 00:45:32 +04:00
1.45 ( 2014 - 08 - 16 ) workaround MSVC - ARM internal compiler error by wrapping malloc
2014-08-07 15:44:17 +04:00
1.44 ( 2014 - 08 - 07 ) warnings
2014-07-16 09:26:01 +04:00
1.43 ( 2014 - 07 - 15 ) fix MSVC - only bug in 1.42
2014-07-10 10:35:25 +04:00
1.42 ( 2014 - 07 - 09 ) no _CRT_SECURE_NO_WARNINGS ; error - path fixes ; STBI_ASSERT
2014-06-26 02:29:29 +04:00
1.41 ( 2014 - 06 - 25 ) fix search & replace that messed up comments / error messages
2014-06-22 22:21:11 +04:00
1.40 ( 2014 - 06 - 22 ) gcc warning
2014-08-07 15:44:17 +04:00
1.39 ( 2014 - 06 - 15 ) TGA optimization bugfix , multiple BMP fixes
2014-06-06 23:17:39 +04:00
1.38 ( 2014 - 06 - 06 ) suppress MSVC run - time warnings , fix accidental rename of ' skip '
2014-06-05 04:56:18 +04:00
1.37 ( 2014 - 06 - 04 ) remove duplicate typedef
2014-06-03 19:45:34 +04:00
1.36 ( 2014 - 06 - 03 ) converted to header file , allow reading incorrect iphoned - images without iphone flag
2014-05-31 15:49:43 +04:00
1.35 ( 2014 - 05 - 27 ) warnings , bugfixes , TGA optimization , etc
See end of file for full revision history .
TODO :
stbi_info support for BMP , PSD , HDR , PIC
= = = = = = = = = = = = = = = = = = = = = = = = = = = = Contributors = = = = = = = = = = = = = = = = = = = = = = = = =
Image formats Bug fixes & warning fixes
Sean Barrett ( jpeg , png , bmp ) Marc LeBlanc
Nicolas Schulz ( hdr , psd ) Christpher Lloyd
Jonathan Dummer ( tga ) Dave Moore
Jean - Marc Lienher ( gif ) Won Chun
Tom Seddon ( pic ) the Horde3D community
Thatcher Ulrich ( psd ) Janez Zemva
Jonathan Blow
Laurent Gomila
Extensions , features Aruelien Pocheville
Jetro Lauha ( stbi_info ) Ryamond Barbiero
James " moose2000 " Brown ( iPhone PNG ) David Woo
Ben " Disch " Wenger ( io callbacks ) Roy Eltham
Martin " SpartanJ " Golini Luke Graham
Thomas Ruf
John Bartholomew
Optimizations & bugfixes Ken Hamada
Fabian " ryg " Giesen Cort Stratton
Arseny Kapoulkine Blazej Dariusz Roszkowski
Thibault Reuille
2014-08-07 15:44:17 +04:00
Paul Du Bois
Guillaume George
2014-06-16 00:08:12 +04:00
Jerry Jansson
2014-08-07 15:44:17 +04:00
If your name should be here but Hayaki Saito
isn ' t , let Sean know . Johan Duparc
Ronny Chevalier
2014-08-08 02:46:45 +04:00
Michal Cichon
2014-05-31 15:49:43 +04:00
*/
# ifndef STBI_INCLUDE_STB_IMAGE_H
# define STBI_INCLUDE_STB_IMAGE_H
// Limitations:
// - no jpeg progressive support
// - non-HDR formats support 8-bit samples only (jpeg, png)
// - no delayed line count (jpeg) -- IJG doesn't support either
// - no 1-bit BMP
// - GIF always returns *comp=4
//
// 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
// // ... but 'n' will always be the number that it would have been if you said 0
// 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, BMP, GIF, and PIC images are automatically depalettized.
//
// ===========================================================================
//
// iPhone PNG support:
//
// By default we convert iphone-formatted PNGs back to RGB; nominally they
// would silently load as BGR, except the existing code should have just
// failed on such iPhone PNGs. But you can disable this conversion by
// by calling stbi_convert_iphone_png_to_rgb(0), in which case
// you will always just get the native iphone "format" through.
//
// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
// pixel to remove any premultiplied alpha *only* if the image file explicitly
// says there's premultiplied data (currently only happens in iPhone images,
// and only if iPhone convert-to-rgb processing is on).
//
// ===========================================================================
//
// 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);
//
// ===========================================================================
//
// I/O callbacks
//
// I/O callbacks allow you to read from arbitrary sources, like packaged
// files or some other source. Data read from callbacks are processed
// through a small internal buffer (currently 128 bytes) to try to reduce
// overhead.
//
// The three functions you must define are "read" (reads some bytes of data),
2014-06-06 23:17:39 +04:00
// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
2014-05-31 15:49:43 +04:00
# ifndef STBI_NO_STDIO
# include <stdio.h>
# endif // STBI_NO_STDIO
# define STBI_VERSION 1
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
# ifdef STB_IMAGE_STATIC
# define STBIDEF static
# else
# define STBIDEF extern
# endif
//////////////////////////////////////////////////////////////////////////////
//
// PRIMARY API - works on images of any type
//
//
// load image by filename, open file, or memory buffer
//
STBIDEF stbi_uc * stbi_load_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp , int req_comp ) ;
# ifndef STBI_NO_STDIO
STBIDEF stbi_uc * stbi_load ( char const * filename , int * x , int * y , int * comp , int req_comp ) ;
STBIDEF stbi_uc * stbi_load_from_file ( FILE * f , int * x , int * y , int * comp , int req_comp ) ;
// for stbi_load_from_file, file pointer is left pointing immediately after image
# endif
typedef struct
{
int ( * read ) ( void * user , char * data , int size ) ; // fill 'data' with 'size' bytes. return number of bytes actually read
2014-06-06 23:17:39 +04:00
void ( * skip ) ( void * user , int n ) ; // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
2014-05-31 15:49:43 +04:00
int ( * eof ) ( void * user ) ; // returns nonzero if we are at end of file/data
} stbi_io_callbacks ;
STBIDEF stbi_uc * stbi_load_from_callbacks ( stbi_io_callbacks const * clbk , void * user , int * x , int * y , int * comp , int req_comp ) ;
# ifndef STBI_NO_HDR
STBIDEF float * stbi_loadf_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp , int req_comp ) ;
# ifndef STBI_NO_STDIO
STBIDEF float * stbi_loadf ( char const * filename , int * x , int * y , int * comp , int req_comp ) ;
STBIDEF float * stbi_loadf_from_file ( FILE * f , int * x , int * y , int * comp , int req_comp ) ;
# endif
STBIDEF float * stbi_loadf_from_callbacks ( stbi_io_callbacks const * clbk , void * user , int * x , int * y , int * comp , int req_comp ) ;
STBIDEF void stbi_hdr_to_ldr_gamma ( float gamma ) ;
STBIDEF void stbi_hdr_to_ldr_scale ( float scale ) ;
STBIDEF void stbi_ldr_to_hdr_gamma ( float gamma ) ;
STBIDEF void stbi_ldr_to_hdr_scale ( float scale ) ;
# endif // STBI_NO_HDR
// stbi_is_hdr is always defined
STBIDEF int stbi_is_hdr_from_callbacks ( stbi_io_callbacks const * clbk , void * user ) ;
STBIDEF int stbi_is_hdr_from_memory ( stbi_uc const * buffer , int len ) ;
# ifndef STBI_NO_STDIO
STBIDEF int stbi_is_hdr ( char const * filename ) ;
STBIDEF int stbi_is_hdr_from_file ( FILE * f ) ;
# endif // STBI_NO_STDIO
// get a VERY brief reason for failure
// NOT THREADSAFE
STBIDEF const char * stbi_failure_reason ( void ) ;
// free the loaded image -- this is just free()
STBIDEF void stbi_image_free ( void * retval_from_stbi_load ) ;
// get image dimensions & components without fully decoding
STBIDEF int stbi_info_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp ) ;
STBIDEF int stbi_info_from_callbacks ( stbi_io_callbacks const * clbk , void * user , int * x , int * y , int * comp ) ;
# ifndef STBI_NO_STDIO
STBIDEF int stbi_info ( char const * filename , int * x , int * y , int * comp ) ;
STBIDEF int stbi_info_from_file ( FILE * f , int * x , int * y , int * comp ) ;
# endif
// for image formats that explicitly notate that they have premultiplied alpha,
// we just return the colors as stored in the file. set this flag to force
// unpremultiplication. results are undefined if the unpremultiply overflow.
STBIDEF void stbi_set_unpremultiply_on_load ( int flag_true_if_should_unpremultiply ) ;
// indicate whether we should process iphone images back to canonical format,
// or just pass them through "as-is"
STBIDEF void stbi_convert_iphone_png_to_rgb ( int flag_true_if_should_convert ) ;
// ZLIB client - used by PNG, available for other purposes
STBIDEF char * stbi_zlib_decode_malloc_guesssize ( const char * buffer , int len , int initial_size , int * outlen ) ;
STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag ( const char * buffer , int len , int initial_size , int * outlen , int parse_header ) ;
STBIDEF char * stbi_zlib_decode_malloc ( const char * buffer , int len , int * outlen ) ;
STBIDEF int stbi_zlib_decode_buffer ( char * obuffer , int olen , const char * ibuffer , int ilen ) ;
STBIDEF char * stbi_zlib_decode_noheader_malloc ( const char * buffer , int len , int * outlen ) ;
STBIDEF int stbi_zlib_decode_noheader_buffer ( char * obuffer , int olen , const char * ibuffer , int ilen ) ;
// define faster low-level operations (typically SIMD support)
# ifdef STBI_SIMD
typedef void ( * stbi_idct_8x8 ) ( stbi_uc * 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 ) ( stbi_uc * output , stbi_uc const * y , stbi_uc const * cb , stbi_uc 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
// y: Y input channel
// cb: Cb input channel; scale/biased to be 0..255
// cr: Cr input channel; scale/biased to be 0..255
STBIDEF void stbi_install_idct ( stbi_idct_8x8 func ) ;
STBIDEF void stbi_install_YCbCr_to_RGB ( stbi_YCbCr_to_RGB_run func ) ;
# endif // STBI_SIMD
# ifdef __cplusplus
}
# endif
//
//
//// end header file /////////////////////////////////////////////////////
# endif // STBI_INCLUDE_STB_IMAGE_H
# ifdef STB_IMAGE_IMPLEMENTATION
# ifndef STBI_NO_HDR
# include <math.h> // ldexp
# include <string.h> // strcmp, strtok
# endif
# ifndef STBI_NO_STDIO
# include <stdio.h>
# endif
# include <stdlib.h>
2014-07-10 10:01:29 +04:00
# include <string.h>
2014-07-10 10:35:25 +04:00
# ifndef STBI_ASSERT
2014-05-31 15:49:43 +04:00
# include <assert.h>
2014-07-10 10:35:25 +04:00
# define STBI_ASSERT(x) assert(x)
# endif
2014-05-31 15:49:43 +04:00
# include <stdarg.h>
# include <stddef.h> // ptrdiff_t on osx
# ifndef _MSC_VER
# ifdef __cplusplus
# define stbi_inline inline
# else
# define stbi_inline
# endif
# else
# define stbi_inline __forceinline
# endif
# ifdef _MSC_VER
typedef unsigned short stbi__uint16 ;
typedef signed short stbi__int16 ;
typedef unsigned int stbi__uint32 ;
typedef signed int stbi__int32 ;
# else
# include <stdint.h>
typedef uint16_t stbi__uint16 ;
typedef int16_t stbi__int16 ;
typedef uint32_t stbi__uint32 ;
typedef int32_t stbi__int32 ;
# endif
// should produce compiler error if size is wrong
typedef unsigned char validate_uint32 [ sizeof ( stbi__uint32 ) = = 4 ? 1 : - 1 ] ;
# ifdef _MSC_VER
# define STBI_NOTUSED(v) (void)(v)
# else
# define STBI_NOTUSED(v) (void)sizeof(v)
# endif
# ifdef _MSC_VER
# define STBI_HAS_LROTL
# endif
# ifdef STBI_HAS_LROTL
# define stbi_lrot(x,y) _lrotl(x,y)
# else
# define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
# endif
///////////////////////////////////////////////
//
2014-05-31 16:38:26 +04:00
// stbi__context struct and start_xxx functions
2014-05-31 15:49:43 +04:00
2014-05-31 16:38:26 +04:00
// stbi__context structure is our basic context used by all images, so it
2014-05-31 15:49:43 +04:00
// contains all the IO context, plus some basic image information
typedef struct
{
stbi__uint32 img_x , img_y ;
int img_n , img_out_n ;
stbi_io_callbacks io ;
void * io_user_data ;
int read_from_callbacks ;
int buflen ;
2014-05-31 17:55:48 +04:00
stbi_uc buffer_start [ 128 ] ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
stbi_uc * img_buffer , * img_buffer_end ;
stbi_uc * img_buffer_original ;
2014-05-31 16:38:26 +04:00
} stbi__context ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:38:26 +04:00
static void stbi__refill_buffer ( stbi__context * s ) ;
2014-05-31 15:49:43 +04:00
2014-06-26 02:29:29 +04:00
// initialize a memory-decode context
2014-05-31 17:55:48 +04:00
static void stbi__start_mem ( stbi__context * s , stbi_uc const * buffer , int len )
2014-05-31 15:49:43 +04:00
{
s - > io . read = NULL ;
s - > read_from_callbacks = 0 ;
2014-05-31 17:55:48 +04:00
s - > img_buffer = s - > img_buffer_original = ( stbi_uc * ) buffer ;
s - > img_buffer_end = ( stbi_uc * ) buffer + len ;
2014-05-31 15:49:43 +04:00
}
// initialize a callback-based context
2014-05-31 16:38:26 +04:00
static void stbi__start_callbacks ( stbi__context * s , stbi_io_callbacks * c , void * user )
2014-05-31 15:49:43 +04:00
{
s - > io = * c ;
s - > io_user_data = user ;
s - > buflen = sizeof ( s - > buffer_start ) ;
s - > read_from_callbacks = 1 ;
s - > img_buffer_original = s - > buffer_start ;
2014-05-31 16:38:26 +04:00
stbi__refill_buffer ( s ) ;
2014-05-31 15:49:43 +04:00
}
# ifndef STBI_NO_STDIO
2014-05-31 17:55:48 +04:00
static int stbi__stdio_read ( void * user , char * data , int size )
2014-05-31 15:49:43 +04:00
{
return ( int ) fread ( data , 1 , size , ( FILE * ) user ) ;
}
2014-05-31 17:55:48 +04:00
static void stbi__stdio_skip ( void * user , int n )
2014-05-31 15:49:43 +04:00
{
fseek ( ( FILE * ) user , n , SEEK_CUR ) ;
}
2014-05-31 17:55:48 +04:00
static int stbi__stdio_eof ( void * user )
2014-05-31 15:49:43 +04:00
{
return feof ( ( FILE * ) user ) ;
}
2014-05-31 17:55:48 +04:00
static stbi_io_callbacks stbi__stdio_callbacks =
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi__stdio_read ,
stbi__stdio_skip ,
stbi__stdio_eof ,
2014-05-31 15:49:43 +04:00
} ;
2014-05-31 17:55:48 +04:00
static void stbi__start_file ( stbi__context * s , FILE * f )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi__start_callbacks ( s , & stbi__stdio_callbacks , ( void * ) f ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:38:26 +04:00
//static void stop_file(stbi__context *s) { }
2014-05-31 15:49:43 +04:00
# endif // !STBI_NO_STDIO
2014-05-31 17:55:48 +04:00
static void stbi__rewind ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
// conceptually rewind SHOULD rewind to the beginning of the stream,
// but we just rewind to the beginning of the initial buffer, because
// we only use it after doing 'test', which only ever looks at at most 92 bytes
s - > img_buffer = s - > img_buffer_original ;
}
2014-05-31 16:38:26 +04:00
static int stbi__jpeg_test ( stbi__context * s ) ;
static stbi_uc * stbi__jpeg_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__jpeg_info ( stbi__context * s , int * x , int * y , int * comp ) ;
static int stbi__png_test ( stbi__context * s ) ;
static stbi_uc * stbi__png_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__png_info ( stbi__context * s , int * x , int * y , int * comp ) ;
static int stbi__bmp_test ( stbi__context * s ) ;
static stbi_uc * stbi__bmp_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__tga_test ( stbi__context * s ) ;
static stbi_uc * stbi__tga_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__tga_info ( stbi__context * s , int * x , int * y , int * comp ) ;
static int stbi__psd_test ( stbi__context * s ) ;
static stbi_uc * stbi__psd_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
2014-05-31 15:49:43 +04:00
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
static int stbi__hdr_test ( stbi__context * s ) ;
static float * stbi__hdr_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
2014-05-31 15:49:43 +04:00
# endif
2014-05-31 16:38:26 +04:00
static int stbi__pic_test ( stbi__context * s ) ;
static stbi_uc * stbi__pic_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__gif_test ( stbi__context * s ) ;
static stbi_uc * stbi__gif_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp ) ;
static int stbi__gif_info ( stbi__context * s , int * x , int * y , int * comp ) ;
2014-05-31 15:49:43 +04:00
// this is not threadsafe
2014-05-31 17:55:48 +04:00
static const char * stbi__g_failure_reason ;
2014-05-31 15:49:43 +04:00
STBIDEF const char * stbi_failure_reason ( void )
{
2014-05-31 17:55:48 +04:00
return stbi__g_failure_reason ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:38:26 +04:00
static int stbi__err ( const char * str )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi__g_failure_reason = str ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-08-08 02:46:45 +04:00
static void * stbi__malloc ( size_t size )
{
return malloc ( size ) ;
}
2014-05-31 16:38:26 +04:00
// stbi__err - error
// stbi__errpf - error returning pointer to float
// stbi__errpuc - error returning pointer to unsigned char
2014-05-31 15:49:43 +04:00
# ifdef STBI_NO_FAILURE_STRINGS
2014-05-31 16:38:26 +04:00
# define stbi__err(x,y) 0
2014-05-31 15:49:43 +04:00
# elif defined(STBI_FAILURE_USERMSG)
2014-05-31 16:38:26 +04:00
# define stbi__err(x,y) stbi__err(y)
2014-05-31 15:49:43 +04:00
# else
2014-05-31 16:38:26 +04:00
# define stbi__err(x,y) stbi__err(x)
2014-05-31 15:49:43 +04:00
# endif
2014-05-31 16:38:26 +04:00
# 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))
2014-05-31 15:49:43 +04:00
STBIDEF void stbi_image_free ( void * retval_from_stbi_load )
{
free ( retval_from_stbi_load ) ;
}
# ifndef STBI_NO_HDR
2014-05-31 16:40:05 +04:00
static float * stbi__ldr_to_hdr ( stbi_uc * data , int x , int y , int comp ) ;
static stbi_uc * stbi__hdr_to_ldr ( float * data , int x , int y , int comp ) ;
2014-05-31 15:49:43 +04:00
# endif
2014-05-31 16:38:26 +04:00
static unsigned char * stbi_load_main ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
if ( stbi__jpeg_test ( s ) ) return stbi__jpeg_load ( s , x , y , comp , req_comp ) ;
if ( stbi__png_test ( s ) ) return stbi__png_load ( s , x , y , comp , req_comp ) ;
if ( stbi__bmp_test ( s ) ) return stbi__bmp_load ( s , x , y , comp , req_comp ) ;
if ( stbi__gif_test ( s ) ) return stbi__gif_load ( s , x , y , comp , req_comp ) ;
if ( stbi__psd_test ( s ) ) return stbi__psd_load ( s , x , y , comp , req_comp ) ;
if ( stbi__pic_test ( s ) ) return stbi__pic_load ( s , x , y , comp , req_comp ) ;
2014-05-31 15:49:43 +04:00
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
if ( stbi__hdr_test ( s ) ) {
float * hdr = stbi__hdr_load ( s , x , y , comp , req_comp ) ;
2014-05-31 16:40:05 +04:00
return stbi__hdr_to_ldr ( hdr , * x , * y , req_comp ? req_comp : * comp ) ;
2014-05-31 15:49:43 +04:00
}
# endif
// test tga last because it's a crappy test!
2014-05-31 16:38:26 +04:00
if ( stbi__tga_test ( s ) )
return stbi__tga_load ( s , x , y , comp , req_comp ) ;
return stbi__errpuc ( " unknown image type " , " Image not of any known type, or corrupt " ) ;
2014-05-31 15:49:43 +04:00
}
# ifndef STBI_NO_STDIO
2014-07-10 10:23:48 +04:00
FILE * stbi__fopen ( char const * filename , char const * mode )
{
FILE * f ;
2014-07-17 16:43:08 +04:00
# if defined(_MSC_VER) && _MSC_VER >= 1400
2014-07-17 16:44:11 +04:00
if ( 0 ! = fopen_s ( & f , filename , mode ) )
2014-07-10 10:23:48 +04:00
f = 0 ;
# else
2014-07-17 16:44:11 +04:00
f = fopen ( filename , mode ) ;
2014-07-10 10:23:48 +04:00
# endif
return f ;
}
2014-05-31 15:49:43 +04:00
STBIDEF unsigned char * stbi_load ( char const * filename , int * x , int * y , int * comp , int req_comp )
{
2014-07-10 10:23:48 +04:00
FILE * f = stbi__fopen ( filename , " rb " ) ;
2014-05-31 15:49:43 +04:00
unsigned char * result ;
2014-05-31 16:38:26 +04:00
if ( ! f ) return stbi__errpuc ( " can't fopen " , " Unable to open file " ) ;
2014-05-31 15:49:43 +04:00
result = stbi_load_from_file ( f , x , y , comp , req_comp ) ;
fclose ( f ) ;
return result ;
}
STBIDEF unsigned char * stbi_load_from_file ( FILE * f , int * x , int * y , int * comp , int req_comp )
{
unsigned char * result ;
2014-05-31 16:38:26 +04:00
stbi__context s ;
2014-05-31 17:55:48 +04:00
stbi__start_file ( & s , f ) ;
2014-05-31 15:49:43 +04:00
result = stbi_load_main ( & s , x , y , comp , req_comp ) ;
if ( result ) {
// need to 'unget' all the characters in the IO buffer
fseek ( f , - ( int ) ( s . img_buffer_end - s . img_buffer ) , SEEK_CUR ) ;
}
return result ;
}
# endif //!STBI_NO_STDIO
STBIDEF unsigned char * stbi_load_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp , int req_comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_mem ( & s , buffer , len ) ;
2014-05-31 15:49:43 +04:00
return stbi_load_main ( & s , x , y , comp , req_comp ) ;
}
unsigned char * stbi_load_from_callbacks ( stbi_io_callbacks const * clbk , void * user , int * x , int * y , int * comp , int req_comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_callbacks ( & s , ( stbi_io_callbacks * ) clbk , user ) ;
2014-05-31 15:49:43 +04:00
return stbi_load_main ( & s , x , y , comp , req_comp ) ;
}
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
float * stbi_loadf_main ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
unsigned char * data ;
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
if ( stbi__hdr_test ( s ) )
return stbi__hdr_load ( s , x , y , comp , req_comp ) ;
2014-05-31 15:49:43 +04:00
# endif
data = stbi_load_main ( s , x , y , comp , req_comp ) ;
if ( data )
2014-05-31 16:40:05 +04:00
return stbi__ldr_to_hdr ( data , * x , * y , req_comp ? req_comp : * comp ) ;
2014-05-31 16:38:26 +04:00
return stbi__errpf ( " unknown image type " , " Image not of any known type, or corrupt " ) ;
2014-05-31 15:49:43 +04:00
}
float * stbi_loadf_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp , int req_comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_mem ( & s , buffer , len ) ;
2014-05-31 15:49:43 +04:00
return stbi_loadf_main ( & s , x , y , comp , req_comp ) ;
}
float * stbi_loadf_from_callbacks ( stbi_io_callbacks const * clbk , void * user , int * x , int * y , int * comp , int req_comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_callbacks ( & s , ( stbi_io_callbacks * ) clbk , user ) ;
2014-05-31 15:49:43 +04:00
return stbi_loadf_main ( & s , x , y , comp , req_comp ) ;
}
# ifndef STBI_NO_STDIO
float * stbi_loadf ( char const * filename , int * x , int * y , int * comp , int req_comp )
{
float * result ;
2014-07-10 10:23:48 +04:00
FILE * f = stbi__fopen ( filename , " rb " ) ;
2014-05-31 16:38:26 +04:00
if ( ! f ) return stbi__errpf ( " can't fopen " , " Unable to open file " ) ;
2014-05-31 15:49:43 +04:00
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 )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
2014-05-31 17:55:48 +04:00
stbi__start_file ( & s , f ) ;
2014-05-31 15:49:43 +04:00
return stbi_loadf_main ( & s , x , y , comp , req_comp ) ;
}
# endif // !STBI_NO_STDIO
# endif // !STBI_NO_HDR
// 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!
int stbi_is_hdr_from_memory ( stbi_uc const * buffer , int len )
{
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_mem ( & s , buffer , len ) ;
return stbi__hdr_test ( & s ) ;
2014-05-31 15:49:43 +04:00
# else
STBI_NOTUSED ( buffer ) ;
STBI_NOTUSED ( len ) ;
return 0 ;
# endif
}
# ifndef STBI_NO_STDIO
STBIDEF int stbi_is_hdr ( char const * filename )
{
2014-07-10 10:23:48 +04:00
FILE * f = stbi__fopen ( filename , " rb " ) ;
2014-05-31 15:49:43 +04:00
int result = 0 ;
if ( f ) {
result = stbi_is_hdr_from_file ( f ) ;
fclose ( f ) ;
}
return result ;
}
STBIDEF int stbi_is_hdr_from_file ( FILE * f )
{
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
stbi__context s ;
2014-05-31 17:55:48 +04:00
stbi__start_file ( & s , f ) ;
2014-05-31 16:38:26 +04:00
return stbi__hdr_test ( & s ) ;
2014-05-31 15:49:43 +04:00
# else
return 0 ;
# endif
}
# endif // !STBI_NO_STDIO
STBIDEF int stbi_is_hdr_from_callbacks ( stbi_io_callbacks const * clbk , void * user )
{
# ifndef STBI_NO_HDR
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_callbacks ( & s , ( stbi_io_callbacks * ) clbk , user ) ;
return stbi__hdr_test ( & s ) ;
2014-05-31 15:49:43 +04:00
# else
return 0 ;
# endif
}
# ifndef STBI_NO_HDR
2014-05-31 16:40:05 +04:00
static float stbi__h2l_gamma_i = 1.0f / 2.2f , stbi__h2l_scale_i = 1.0f ;
static float stbi__l2h_gamma = 2.2f , stbi__l2h_scale = 1.0f ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
void stbi_hdr_to_ldr_gamma ( float gamma ) { stbi__h2l_gamma_i = 1 / gamma ; }
void stbi_hdr_to_ldr_scale ( float scale ) { stbi__h2l_scale_i = 1 / scale ; }
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
void stbi_ldr_to_hdr_gamma ( float gamma ) { stbi__l2h_gamma = gamma ; }
void stbi_ldr_to_hdr_scale ( float scale ) { stbi__l2h_scale = scale ; }
2014-05-31 15:49:43 +04:00
# endif
//////////////////////////////////////////////////////////////////////////////
//
// Common code used by all image loaders
//
enum
{
SCAN_load = 0 ,
SCAN_type ,
SCAN_header
} ;
2014-05-31 16:38:26 +04:00
static void stbi__refill_buffer ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
int n = ( s - > io . read ) ( s - > io_user_data , ( char * ) s - > buffer_start , s - > buflen ) ;
if ( n = = 0 ) {
// at end of file, treat same as if from memory, but need to handle case
2014-09-05 19:38:39 +04:00
// where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
2014-05-31 15:49:43 +04:00
s - > read_from_callbacks = 0 ;
s - > img_buffer = s - > buffer_start ;
s - > img_buffer_end = s - > buffer_start + 1 ;
* s - > img_buffer = 0 ;
} else {
s - > img_buffer = s - > buffer_start ;
s - > img_buffer_end = s - > buffer_start + n ;
}
}
2014-06-06 21:15:30 +04:00
stbi_inline static stbi_uc stbi__get8 ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
if ( s - > img_buffer < s - > img_buffer_end )
return * s - > img_buffer + + ;
if ( s - > read_from_callbacks ) {
2014-05-31 16:38:26 +04:00
stbi__refill_buffer ( s ) ;
2014-05-31 15:49:43 +04:00
return * s - > img_buffer + + ;
}
return 0 ;
}
2014-05-31 16:40:05 +04:00
stbi_inline static int stbi__at_eof ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
if ( s - > io . read ) {
if ( ! ( s - > io . eof ) ( s - > io_user_data ) ) return 0 ;
// if feof() is true, check if buffer = end
// special case: we've only got the special 0 character at the end
if ( s - > read_from_callbacks = = 0 ) return 1 ;
}
return s - > img_buffer > = s - > img_buffer_end ;
}
2014-05-31 16:40:05 +04:00
static void stbi__skip ( stbi__context * s , int n )
2014-05-31 15:49:43 +04:00
{
if ( s - > io . read ) {
int blen = ( int ) ( s - > img_buffer_end - s - > img_buffer ) ;
if ( blen < n ) {
s - > img_buffer = s - > img_buffer_end ;
2014-06-06 23:17:39 +04:00
( s - > io . skip ) ( s - > io_user_data , n - blen ) ;
2014-05-31 15:49:43 +04:00
return ;
}
}
s - > img_buffer + = n ;
}
2014-05-31 16:40:05 +04:00
static int stbi__getn ( stbi__context * s , stbi_uc * buffer , int n )
2014-05-31 15:49:43 +04:00
{
if ( s - > io . read ) {
int blen = ( int ) ( s - > img_buffer_end - s - > img_buffer ) ;
if ( blen < n ) {
int res , count ;
memcpy ( buffer , s - > img_buffer , blen ) ;
count = ( s - > io . read ) ( s - > io_user_data , ( char * ) buffer + blen , n - blen ) ;
res = ( count = = ( n - blen ) ) ;
s - > img_buffer = s - > img_buffer_end ;
return res ;
}
}
if ( s - > img_buffer + n < = s - > img_buffer_end ) {
memcpy ( buffer , s - > img_buffer , n ) ;
s - > img_buffer + = n ;
return 1 ;
} else
return 0 ;
}
2014-05-31 16:40:05 +04:00
static int stbi__get16be ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
int z = stbi__get8 ( s ) ;
return ( z < < 8 ) + stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
static stbi__uint32 stbi__get32be ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
stbi__uint32 z = stbi__get16be ( s ) ;
return ( z < < 16 ) + stbi__get16be ( s ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
static int stbi__get16le ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
int z = stbi__get8 ( s ) ;
return z + ( stbi__get8 ( s ) < < 8 ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
static stbi__uint32 stbi__get32le ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
stbi__uint32 z = stbi__get16le ( s ) ;
return z + ( stbi__get16le ( s ) < < 16 ) ;
2014-05-31 15:49:43 +04:00
}
//////////////////////////////////////////////////////////////////////////////
//
// generic converter from built-in img_n to req_comp
2014-09-05 19:38:39 +04:00
// individual types do this automatically as much as possible (e.g. jpeg
2014-05-31 15:49:43 +04:00
// 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
2014-05-31 17:55:48 +04:00
static stbi_uc stbi__compute_y ( int r , int g , int b )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
return ( stbi_uc ) ( ( ( r * 77 ) + ( g * 150 ) + ( 29 * b ) ) > > 8 ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
static unsigned char * stbi__convert_format ( unsigned char * data , int img_n , int req_comp , unsigned int x , unsigned int y )
2014-05-31 15:49:43 +04:00
{
int i , j ;
unsigned char * good ;
if ( req_comp = = img_n ) return data ;
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( req_comp > = 1 & & req_comp < = 4 ) ;
2014-05-31 15:49:43 +04:00
2014-08-08 02:46:45 +04:00
good = ( unsigned char * ) stbi__malloc ( req_comp * x * y ) ;
2014-05-31 15:49:43 +04:00
if ( good = = NULL ) {
free ( data ) ;
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
}
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
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 ;
2014-05-31 16:40:05 +04:00
CASE ( 3 , 1 ) dest [ 0 ] = stbi__compute_y ( src [ 0 ] , src [ 1 ] , src [ 2 ] ) ; break ;
CASE ( 3 , 2 ) dest [ 0 ] = stbi__compute_y ( src [ 0 ] , src [ 1 ] , src [ 2 ] ) , dest [ 1 ] = 255 ; break ;
CASE ( 4 , 1 ) dest [ 0 ] = stbi__compute_y ( src [ 0 ] , src [ 1 ] , src [ 2 ] ) ; break ;
CASE ( 4 , 2 ) dest [ 0 ] = stbi__compute_y ( src [ 0 ] , src [ 1 ] , src [ 2 ] ) , dest [ 1 ] = src [ 3 ] ; break ;
2014-05-31 15:49:43 +04:00
CASE ( 4 , 3 ) dest [ 0 ] = src [ 0 ] , dest [ 1 ] = src [ 1 ] , dest [ 2 ] = src [ 2 ] ; break ;
2014-07-10 10:35:25 +04:00
default : STBI_ASSERT ( 0 ) ;
2014-05-31 15:49:43 +04:00
}
# undef CASE
}
free ( data ) ;
return good ;
}
# ifndef STBI_NO_HDR
2014-05-31 16:40:05 +04:00
static float * stbi__ldr_to_hdr ( stbi_uc * data , int x , int y , int comp )
2014-05-31 15:49:43 +04:00
{
int i , k , n ;
2014-08-08 02:46:45 +04:00
float * output = ( float * ) stbi__malloc ( x * y * comp * sizeof ( float ) ) ;
2014-05-31 16:38:26 +04:00
if ( output = = NULL ) { free ( data ) ; return stbi__errpf ( " outofmem " , " Out of memory " ) ; }
2014-05-31 15:49:43 +04:00
// 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 ) {
2014-06-06 21:15:30 +04:00
output [ i * comp + k ] = ( float ) ( pow ( data [ i * comp + k ] / 255.0f , stbi__l2h_gamma ) * stbi__l2h_scale ) ;
2014-05-31 15:49:43 +04:00
}
if ( k < comp ) output [ i * comp + k ] = data [ i * comp + k ] / 255.0f ;
}
free ( data ) ;
return output ;
}
2014-05-31 16:40:05 +04:00
# define stbi__float2int(x) ((int) (x))
static stbi_uc * stbi__hdr_to_ldr ( float * data , int x , int y , int comp )
2014-05-31 15:49:43 +04:00
{
int i , k , n ;
2014-08-08 02:46:45 +04:00
stbi_uc * output = ( stbi_uc * ) stbi__malloc ( x * y * comp ) ;
2014-05-31 16:38:26 +04:00
if ( output = = NULL ) { free ( data ) ; return stbi__errpuc ( " outofmem " , " Out of memory " ) ; }
2014-05-31 15:49:43 +04:00
// 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 ) {
2014-05-31 16:40:05 +04:00
float z = ( float ) pow ( data [ i * comp + k ] * stbi__h2l_scale_i , stbi__h2l_gamma_i ) * 255 + 0.5f ;
2014-05-31 15:49:43 +04:00
if ( z < 0 ) z = 0 ;
if ( z > 255 ) z = 255 ;
2014-05-31 17:55:48 +04:00
output [ i * comp + k ] = ( stbi_uc ) stbi__float2int ( z ) ;
2014-05-31 15:49:43 +04:00
}
if ( k < comp ) {
float z = data [ i * comp + k ] * 255 + 0.5f ;
if ( z < 0 ) z = 0 ;
if ( z > 255 ) z = 255 ;
2014-05-31 17:55:48 +04:00
output [ i * comp + k ] = ( stbi_uc ) stbi__float2int ( z ) ;
2014-05-31 15:49:43 +04:00
}
}
free ( data ) ;
return output ;
}
# endif
//////////////////////////////////////////////////////////////////////////////
//
// "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)
// huffman decoding acceleration
# define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
typedef struct
{
2014-05-31 17:55:48 +04:00
stbi_uc fast [ 1 < < FAST_BITS ] ;
2014-05-31 15:49:43 +04:00
// weirdly, repacking this into AoS is a 10% speed loss, instead of a win
stbi__uint16 code [ 256 ] ;
2014-05-31 17:55:48 +04:00
stbi_uc values [ 256 ] ;
stbi_uc size [ 257 ] ;
2014-05-31 15:49:43 +04:00
unsigned int maxcode [ 18 ] ;
int delta [ 17 ] ; // old 'firstsymbol' - old 'firstcode'
2014-05-31 16:40:05 +04:00
} stbi__huffman ;
2014-05-31 15:49:43 +04:00
typedef struct
{
# ifdef STBI_SIMD
unsigned short dequant2 [ 4 ] [ 64 ] ;
# endif
2014-05-31 16:38:26 +04:00
stbi__context * s ;
2014-05-31 16:40:05 +04:00
stbi__huffman huff_dc [ 4 ] ;
stbi__huffman huff_ac [ 4 ] ;
2014-05-31 17:55:48 +04:00
stbi_uc dequant [ 4 ] [ 64 ] ;
2014-05-31 15:49:43 +04:00
// sizes for components, interleaved MCUs
int img_h_max , img_v_max ;
int img_mcu_x , img_mcu_y ;
int img_mcu_w , img_mcu_h ;
// definition of jpeg image component
struct
{
int id ;
int h , v ;
int tq ;
int hd , ha ;
int dc_pred ;
int x , y , w2 , h2 ;
2014-05-31 17:55:48 +04:00
stbi_uc * data ;
2014-05-31 15:49:43 +04:00
void * raw_data ;
2014-05-31 17:55:48 +04:00
stbi_uc * linebuf ;
2014-05-31 15:49:43 +04:00
} img_comp [ 4 ] ;
stbi__uint32 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
int scan_n , order [ 4 ] ;
int restart_interval , todo ;
2014-05-31 16:40:05 +04:00
} stbi__jpeg ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
static int stbi__build_huffman ( stbi__huffman * h , int * count )
2014-05-31 15:49:43 +04:00
{
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 )
2014-05-31 17:55:48 +04:00
h - > size [ k + + ] = ( stbi_uc ) ( i + 1 ) ;
2014-05-31 15:49:43 +04:00
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 + + ] = ( stbi__uint16 ) ( code + + ) ;
2014-05-31 16:38:26 +04:00
if ( code - 1 > = ( 1 < < j ) ) return stbi__err ( " bad code lengths " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
}
// 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 ) {
2014-05-31 17:55:48 +04:00
h - > fast [ c + j ] = ( stbi_uc ) i ;
2014-05-31 15:49:43 +04:00
}
}
}
return 1 ;
}
2014-05-31 16:40:05 +04:00
static void stbi__grow_buffer_unsafe ( stbi__jpeg * j )
2014-05-31 15:49:43 +04:00
{
do {
2014-05-31 16:40:05 +04:00
int b = j - > nomore ? 0 : stbi__get8 ( j - > s ) ;
2014-05-31 15:49:43 +04:00
if ( b = = 0xff ) {
2014-05-31 16:40:05 +04:00
int c = stbi__get8 ( j - > s ) ;
2014-05-31 15:49:43 +04:00
if ( c ! = 0 ) {
j - > marker = ( unsigned char ) c ;
j - > nomore = 1 ;
return ;
}
}
j - > code_buffer | = b < < ( 24 - j - > code_bits ) ;
j - > code_bits + = 8 ;
} while ( j - > code_bits < = 24 ) ;
}
// (1 << n) - 1
2014-05-31 16:40:05 +04:00
static stbi__uint32 stbi__bmask [ 17 ] = { 0 , 1 , 3 , 7 , 15 , 31 , 63 , 127 , 255 , 511 , 1023 , 2047 , 4095 , 8191 , 16383 , 32767 , 65535 } ;
2014-05-31 15:49:43 +04:00
2014-06-26 02:29:29 +04:00
// decode a jpeg huffman value from the bitstream
2014-05-31 16:40:05 +04:00
stbi_inline static int stbi__jpeg_huff_decode ( stbi__jpeg * j , stbi__huffman * h )
2014-05-31 15:49:43 +04:00
{
unsigned int temp ;
int c , k ;
2014-05-31 16:40:05 +04:00
if ( j - > code_bits < 16 ) stbi__grow_buffer_unsafe ( j ) ;
2014-05-31 15:49:43 +04:00
// look at the top FAST_BITS and determine what symbol ID it is,
// if the code is <= FAST_BITS
c = ( j - > code_buffer > > ( 32 - FAST_BITS ) ) & ( ( 1 < < FAST_BITS ) - 1 ) ;
k = h - > fast [ c ] ;
if ( k < 255 ) {
int s = h - > size [ k ] ;
if ( s > j - > code_bits )
return - 1 ;
j - > code_buffer < < = s ;
j - > code_bits - = s ;
return h - > values [ k ] ;
}
// naive test is to shift the code_buffer down so k bits are
// valid, then test against maxcode. To speed this up, we've
// preshifted maxcode left so that it has (16-k) 0s at the
// end; in other words, regardless of the number of bits, it
// wants to be compared against something shifted to have 16;
// that way we don't need to shift inside the loop.
temp = j - > code_buffer > > 16 ;
for ( k = FAST_BITS + 1 ; ; + + k )
if ( temp < h - > maxcode [ k ] )
break ;
if ( k = = 17 ) {
// error! code not found
j - > code_bits - = 16 ;
return - 1 ;
}
if ( k > j - > code_bits )
return - 1 ;
// convert the huffman code to the symbol id
2014-05-31 16:40:05 +04:00
c = ( ( j - > code_buffer > > ( 32 - k ) ) & stbi__bmask [ k ] ) + h - > delta [ k ] ;
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( ( ( ( j - > code_buffer ) > > ( 32 - h - > size [ c ] ) ) & stbi__bmask [ h - > size [ c ] ] ) = = h - > code [ c ] ) ;
2014-05-31 15:49:43 +04:00
// convert the id to a symbol
j - > code_bits - = k ;
j - > code_buffer < < = k ;
return h - > values [ c ] ;
}
// combined JPEG 'receive' and JPEG 'extend', since baseline
// always extends everything it receives.
2014-05-31 16:40:05 +04:00
stbi_inline static int stbi__extend_receive ( stbi__jpeg * j , int n )
2014-05-31 15:49:43 +04:00
{
unsigned int m = 1 < < ( n - 1 ) ;
unsigned int k ;
2014-05-31 16:40:05 +04:00
if ( j - > code_bits < n ) stbi__grow_buffer_unsafe ( j ) ;
2014-05-31 15:49:43 +04:00
# if 1
k = stbi_lrot ( j - > code_buffer , n ) ;
2014-05-31 16:40:05 +04:00
j - > code_buffer = k & ~ stbi__bmask [ n ] ;
k & = stbi__bmask [ n ] ;
2014-05-31 15:49:43 +04:00
j - > code_bits - = n ;
# else
2014-05-31 16:40:05 +04:00
k = ( j - > code_buffer > > ( 32 - n ) ) & stbi__bmask [ n ] ;
2014-05-31 15:49:43 +04:00
j - > code_bits - = n ;
j - > code_buffer < < = n ;
# endif
// the following test is probably a random branch that won't
// predict well. I tried to table accelerate it but failed.
// maybe it's compiling as a conditional move?
if ( k < m )
return ( - 1 < < n ) + k + 1 ;
else
return k ;
}
// given a value that's at position X in the zigzag stream,
// where does it appear in the 8x8 matrix coded as row-major?
2014-05-31 17:55:48 +04:00
static stbi_uc stbi__jpeg_dezigzag [ 64 + 15 ] =
2014-05-31 15:49:43 +04:00
{
0 , 1 , 8 , 16 , 9 , 2 , 3 , 10 ,
17 , 24 , 32 , 25 , 18 , 11 , 4 , 5 ,
12 , 19 , 26 , 33 , 40 , 48 , 41 , 34 ,
27 , 20 , 13 , 6 , 7 , 14 , 21 , 28 ,
35 , 42 , 49 , 56 , 57 , 50 , 43 , 36 ,
29 , 22 , 15 , 23 , 30 , 37 , 44 , 51 ,
58 , 59 , 52 , 45 , 38 , 31 , 39 , 46 ,
53 , 60 , 61 , 54 , 47 , 55 , 62 , 63 ,
// let corrupt input sample past end
63 , 63 , 63 , 63 , 63 , 63 , 63 , 63 ,
63 , 63 , 63 , 63 , 63 , 63 , 63
} ;
2014-06-26 02:29:29 +04:00
// decode one 64-entry block--
2014-05-31 16:40:05 +04:00
static int stbi__jpeg_decode_block ( stbi__jpeg * j , short data [ 64 ] , stbi__huffman * hdc , stbi__huffman * hac , int b )
2014-05-31 15:49:43 +04:00
{
int diff , dc , k ;
2014-05-31 16:40:05 +04:00
int t = stbi__jpeg_huff_decode ( j , hdc ) ;
2014-05-31 16:38:26 +04:00
if ( t < 0 ) return stbi__err ( " bad huffman code " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
// 0 all the ac values now so we can do it 32-bits at a time
memset ( data , 0 , 64 * sizeof ( data [ 0 ] ) ) ;
2014-05-31 16:40:05 +04:00
diff = t ? stbi__extend_receive ( j , t ) : 0 ;
2014-05-31 15:49:43 +04:00
dc = j - > img_comp [ b ] . dc_pred + diff ;
j - > img_comp [ b ] . dc_pred = dc ;
data [ 0 ] = ( short ) dc ;
2014-06-26 02:29:29 +04:00
// decode AC components, see JPEG spec
2014-05-31 15:49:43 +04:00
k = 1 ;
do {
int r , s ;
2014-05-31 16:40:05 +04:00
int rs = stbi__jpeg_huff_decode ( j , hac ) ;
2014-05-31 16:38:26 +04:00
if ( rs < 0 ) return stbi__err ( " bad huffman code " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
s = rs & 15 ;
r = rs > > 4 ;
if ( s = = 0 ) {
if ( rs ! = 0xf0 ) break ; // end block
k + = 16 ;
} else {
k + = r ;
2014-06-26 02:29:29 +04:00
// decode into unzigzag'd location
2014-05-31 16:40:05 +04:00
data [ stbi__jpeg_dezigzag [ k + + ] ] = ( short ) stbi__extend_receive ( j , s ) ;
2014-05-31 15:49:43 +04:00
}
} while ( k < 64 ) ;
return 1 ;
}
2014-05-31 16:40:05 +04:00
// take a -128..127 value and stbi__clamp it and convert to 0..255
2014-05-31 17:55:48 +04:00
stbi_inline static stbi_uc stbi__clamp ( int x )
2014-05-31 15:49:43 +04:00
{
// trick to use a single test to catch both cases
if ( ( unsigned int ) x > 255 ) {
if ( x < 0 ) return 0 ;
if ( x > 255 ) return 255 ;
}
2014-05-31 17:55:48 +04:00
return ( stbi_uc ) x ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
# define stbi__f2f(x) (int) (((x) * 4096 + 0.5))
# define stbi__fsh(x) ((x) << 12)
2014-05-31 15:49:43 +04:00
// derived from jidctint -- DCT_ISLOW
2014-05-31 16:40:05 +04:00
# define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
2014-05-31 15:49:43 +04:00
int t0 , t1 , t2 , t3 , p1 , p2 , p3 , p4 , p5 , x0 , x1 , x2 , x3 ; \
p2 = s2 ; \
p3 = s6 ; \
2014-05-31 16:40:05 +04:00
p1 = ( p2 + p3 ) * stbi__f2f ( 0.5411961f ) ; \
t2 = p1 + p3 * stbi__f2f ( - 1.847759065f ) ; \
t3 = p1 + p2 * stbi__f2f ( 0.765366865f ) ; \
2014-05-31 15:49:43 +04:00
p2 = s0 ; \
p3 = s4 ; \
2014-05-31 16:40:05 +04:00
t0 = stbi__fsh ( p2 + p3 ) ; \
t1 = stbi__fsh ( p2 - p3 ) ; \
2014-05-31 15:49:43 +04:00
x0 = t0 + t3 ; \
x3 = t0 - t3 ; \
x1 = t1 + t2 ; \
x2 = t1 - t2 ; \
t0 = s7 ; \
t1 = s5 ; \
t2 = s3 ; \
t3 = s1 ; \
p3 = t0 + t2 ; \
p4 = t1 + t3 ; \
p1 = t0 + t3 ; \
p2 = t1 + t2 ; \
2014-05-31 16:40:05 +04:00
p5 = ( p3 + p4 ) * stbi__f2f ( 1.175875602f ) ; \
t0 = t0 * stbi__f2f ( 0.298631336f ) ; \
t1 = t1 * stbi__f2f ( 2.053119869f ) ; \
t2 = t2 * stbi__f2f ( 3.072711026f ) ; \
t3 = t3 * stbi__f2f ( 1.501321110f ) ; \
p1 = p5 + p1 * stbi__f2f ( - 0.899976223f ) ; \
p2 = p5 + p2 * stbi__f2f ( - 2.562915447f ) ; \
p3 = p3 * stbi__f2f ( - 1.961570560f ) ; \
p4 = p4 * stbi__f2f ( - 0.390180644f ) ; \
2014-05-31 15:49:43 +04:00
t3 + = p1 + p4 ; \
t2 + = p2 + p3 ; \
t1 + = p2 + p4 ; \
t0 + = p1 + p3 ;
# ifdef STBI_SIMD
typedef unsigned short stbi_dequantize_t ;
# else
2014-05-31 17:55:48 +04:00
typedef stbi_uc stbi_dequantize_t ;
2014-05-31 15:49:43 +04:00
# endif
// .344 seconds on 3*anemones.jpg
2014-05-31 17:55:48 +04:00
static void stbi__idct_block ( stbi_uc * out , int out_stride , short data [ 64 ] , stbi_dequantize_t * dequantize )
2014-05-31 15:49:43 +04:00
{
int i , val [ 64 ] , * v = val ;
stbi_dequantize_t * dq = dequantize ;
2014-05-31 17:55:48 +04:00
stbi_uc * o ;
2014-05-31 15:49:43 +04:00
short * d = data ;
// columns
for ( i = 0 ; i < 8 ; + + i , + + d , + + dq , + + v ) {
// if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
if ( d [ 8 ] = = 0 & & d [ 16 ] = = 0 & & d [ 24 ] = = 0 & & d [ 32 ] = = 0
& & d [ 40 ] = = 0 & & d [ 48 ] = = 0 & & d [ 56 ] = = 0 ) {
// no shortcut 0 seconds
// (1|2|3|4|5|6|7)==0 0 seconds
// all separate -0.047 seconds
// 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
int dcterm = d [ 0 ] * dq [ 0 ] < < 2 ;
v [ 0 ] = v [ 8 ] = v [ 16 ] = v [ 24 ] = v [ 32 ] = v [ 40 ] = v [ 48 ] = v [ 56 ] = dcterm ;
} else {
2014-05-31 16:40:05 +04:00
STBI__IDCT_1D ( d [ 0 ] * dq [ 0 ] , d [ 8 ] * dq [ 8 ] , d [ 16 ] * dq [ 16 ] , d [ 24 ] * dq [ 24 ] ,
2014-05-31 15:49:43 +04:00
d [ 32 ] * dq [ 32 ] , d [ 40 ] * dq [ 40 ] , d [ 48 ] * dq [ 48 ] , d [ 56 ] * dq [ 56 ] )
// constants scaled things up by 1<<12; let's bring them back
// down, but keep 2 extra bits of precision
x0 + = 512 ; x1 + = 512 ; x2 + = 512 ; x3 + = 512 ;
v [ 0 ] = ( x0 + t3 ) > > 10 ;
v [ 56 ] = ( x0 - t3 ) > > 10 ;
v [ 8 ] = ( x1 + t2 ) > > 10 ;
v [ 48 ] = ( x1 - t2 ) > > 10 ;
v [ 16 ] = ( x2 + t1 ) > > 10 ;
v [ 40 ] = ( x2 - t1 ) > > 10 ;
v [ 24 ] = ( x3 + t0 ) > > 10 ;
v [ 32 ] = ( x3 - t0 ) > > 10 ;
}
}
for ( i = 0 , v = val , o = out ; i < 8 ; + + i , v + = 8 , o + = out_stride ) {
// no fast case since the first 1D IDCT spread components out
2014-05-31 16:40:05 +04:00
STBI__IDCT_1D ( v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] , v [ 4 ] , v [ 5 ] , v [ 6 ] , v [ 7 ] )
2014-05-31 15:49:43 +04:00
// constants scaled things up by 1<<12, plus we had 1<<2 from first
// loop, plus horizontal and vertical each scale by sqrt(8) so together
// we've got an extra 1<<3, so 1<<17 total we need to remove.
// so we want to round that, which means adding 0.5 * 1<<17,
// aka 65536. Also, we'll end up with -128 to 127 that we want
// to encode as 0..255 by adding 128, so we'll add that before the shift
x0 + = 65536 + ( 128 < < 17 ) ;
x1 + = 65536 + ( 128 < < 17 ) ;
x2 + = 65536 + ( 128 < < 17 ) ;
x3 + = 65536 + ( 128 < < 17 ) ;
// tried computing the shifts into temps, or'ing the temps to see
// if any were out of range, but that was slower
2014-05-31 16:40:05 +04:00
o [ 0 ] = stbi__clamp ( ( x0 + t3 ) > > 17 ) ;
o [ 7 ] = stbi__clamp ( ( x0 - t3 ) > > 17 ) ;
o [ 1 ] = stbi__clamp ( ( x1 + t2 ) > > 17 ) ;
o [ 6 ] = stbi__clamp ( ( x1 - t2 ) > > 17 ) ;
o [ 2 ] = stbi__clamp ( ( x2 + t1 ) > > 17 ) ;
o [ 5 ] = stbi__clamp ( ( x2 - t1 ) > > 17 ) ;
o [ 3 ] = stbi__clamp ( ( x3 + t0 ) > > 17 ) ;
o [ 4 ] = stbi__clamp ( ( x3 - t0 ) > > 17 ) ;
2014-05-31 15:49:43 +04:00
}
}
# ifdef STBI_SIMD
2014-05-31 16:40:05 +04:00
static stbi_idct_8x8 stbi__idct_installed = stbi__idct_block ;
2014-05-31 15:49:43 +04:00
STBIDEF void stbi_install_idct ( stbi_idct_8x8 func )
{
2014-05-31 16:40:05 +04:00
stbi__idct_installed = func ;
2014-05-31 15:49:43 +04:00
}
# endif
2014-05-31 16:40:05 +04:00
# define STBI__MARKER_none 0xff
2014-05-31 15:49:43 +04:00
// 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
2014-05-31 17:55:48 +04:00
static stbi_uc stbi__get_marker ( stbi__jpeg * j )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc x ;
2014-05-31 16:40:05 +04:00
if ( j - > marker ! = STBI__MARKER_none ) { x = j - > marker ; j - > marker = STBI__MARKER_none ; return x ; }
2014-06-06 21:15:30 +04:00
x = stbi__get8 ( j - > s ) ;
2014-05-31 16:40:05 +04:00
if ( x ! = 0xff ) return STBI__MARKER_none ;
2014-05-31 15:49:43 +04:00
while ( x = = 0xff )
2014-06-06 21:15:30 +04:00
x = stbi__get8 ( j - > s ) ;
2014-05-31 15:49:43 +04:00
return x ;
}
// in each scan, we'll have scan_n components, and the order
// of the components is specified by order[]
2014-05-31 16:40:05 +04:00
# define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
// after a restart interval, stbi__jpeg_reset the entropy decoder and
2014-05-31 15:49:43 +04:00
// the dc prediction
2014-05-31 16:40:05 +04:00
static void stbi__jpeg_reset ( stbi__jpeg * j )
2014-05-31 15:49:43 +04:00
{
j - > code_bits = 0 ;
j - > code_buffer = 0 ;
j - > nomore = 0 ;
j - > img_comp [ 0 ] . dc_pred = j - > img_comp [ 1 ] . dc_pred = j - > img_comp [ 2 ] . dc_pred = 0 ;
2014-05-31 16:40:05 +04:00
j - > marker = STBI__MARKER_none ;
2014-05-31 15:49:43 +04:00
j - > todo = j - > restart_interval ? j - > restart_interval : 0x7fffffff ;
// no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
// since we don't even allow 1<<30 pixels
}
2014-05-31 16:40:05 +04:00
static int stbi__parse_entropy_coded_data ( stbi__jpeg * z )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
stbi__jpeg_reset ( z ) ;
2014-05-31 15:49:43 +04:00
if ( z - > scan_n = = 1 ) {
int i , j ;
# ifdef STBI_SIMD
__declspec ( align ( 16 ) )
# endif
short data [ 64 ] ;
int n = z - > order [ 0 ] ;
// non-interleaved data, we just need to process one block at a time,
// in trivial scanline order
// number of blocks to do just depends on how many actual "pixels" this
// component has, independent of interleaved MCU blocking and such
int w = ( z - > img_comp [ n ] . x + 7 ) > > 3 ;
int h = ( z - > img_comp [ n ] . y + 7 ) > > 3 ;
for ( j = 0 ; j < h ; + + j ) {
for ( i = 0 ; i < w ; + + i ) {
2014-05-31 16:40:05 +04:00
if ( ! stbi__jpeg_decode_block ( z , data , z - > huff_dc + z - > img_comp [ n ] . hd , z - > huff_ac + z - > img_comp [ n ] . ha , n ) ) return 0 ;
2014-05-31 15:49:43 +04:00
# ifdef STBI_SIMD
2014-05-31 16:40:05 +04:00
stbi__idct_installed ( z - > img_comp [ n ] . data + z - > img_comp [ n ] . w2 * j * 8 + i * 8 , z - > img_comp [ n ] . w2 , data , z - > dequant2 [ z - > img_comp [ n ] . tq ] ) ;
2014-05-31 15:49:43 +04:00
# else
2014-05-31 16:40:05 +04:00
stbi__idct_block ( z - > img_comp [ n ] . data + z - > img_comp [ n ] . w2 * j * 8 + i * 8 , z - > img_comp [ n ] . w2 , data , z - > dequant [ z - > img_comp [ n ] . tq ] ) ;
2014-05-31 15:49:43 +04:00
# endif
// every data block is an MCU, so countdown the restart interval
if ( - - z - > todo < = 0 ) {
2014-05-31 16:40:05 +04:00
if ( z - > code_bits < 24 ) stbi__grow_buffer_unsafe ( z ) ;
2014-05-31 15:49:43 +04:00
// if it's NOT a restart, then just bail, so we get corrupt data
// rather than no data
2014-05-31 16:40:05 +04:00
if ( ! STBI__RESTART ( z - > marker ) ) return 1 ;
stbi__jpeg_reset ( z ) ;
2014-05-31 15:49:43 +04:00
}
}
}
} else { // interleaved!
int i , j , k , x , y ;
short data [ 64 ] ;
for ( j = 0 ; j < z - > img_mcu_y ; + + j ) {
for ( i = 0 ; i < z - > img_mcu_x ; + + i ) {
// scan an interleaved mcu... process scan_n components in order
for ( k = 0 ; k < z - > scan_n ; + + k ) {
int n = z - > order [ k ] ;
// scan out an mcu's worth of this component; that's just determined
// by the basic H and V specified for the component
for ( y = 0 ; y < z - > img_comp [ n ] . v ; + + y ) {
for ( x = 0 ; x < z - > img_comp [ n ] . h ; + + x ) {
int x2 = ( i * z - > img_comp [ n ] . h + x ) * 8 ;
int y2 = ( j * z - > img_comp [ n ] . v + y ) * 8 ;
2014-05-31 16:40:05 +04:00
if ( ! stbi__jpeg_decode_block ( z , data , z - > huff_dc + z - > img_comp [ n ] . hd , z - > huff_ac + z - > img_comp [ n ] . ha , n ) ) return 0 ;
2014-05-31 15:49:43 +04:00
# ifdef STBI_SIMD
2014-05-31 16:40:05 +04:00
stbi__idct_installed ( z - > img_comp [ n ] . data + z - > img_comp [ n ] . w2 * y2 + x2 , z - > img_comp [ n ] . w2 , data , z - > dequant2 [ z - > img_comp [ n ] . tq ] ) ;
2014-05-31 15:49:43 +04:00
# else
2014-05-31 16:40:05 +04:00
stbi__idct_block ( z - > img_comp [ n ] . data + z - > img_comp [ n ] . w2 * y2 + x2 , z - > img_comp [ n ] . w2 , data , z - > dequant [ z - > img_comp [ n ] . tq ] ) ;
2014-05-31 15:49:43 +04:00
# endif
}
}
}
// after all interleaved components, that's an interleaved MCU,
// so now count down the restart interval
if ( - - z - > todo < = 0 ) {
2014-05-31 16:40:05 +04:00
if ( z - > code_bits < 24 ) stbi__grow_buffer_unsafe ( z ) ;
2014-05-31 15:49:43 +04:00
// if it's NOT a restart, then just bail, so we get corrupt data
// rather than no data
2014-05-31 16:40:05 +04:00
if ( ! STBI__RESTART ( z - > marker ) ) return 1 ;
stbi__jpeg_reset ( z ) ;
2014-05-31 15:49:43 +04:00
}
}
}
}
return 1 ;
}
2014-05-31 16:40:05 +04:00
static int stbi__process_marker ( stbi__jpeg * z , int m )
2014-05-31 15:49:43 +04:00
{
int L ;
switch ( m ) {
2014-05-31 16:40:05 +04:00
case STBI__MARKER_none : // no marker found
2014-05-31 16:38:26 +04:00
return stbi__err ( " expected marker " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
case 0xC2 : // stbi__SOF - progressive
2014-05-31 16:38:26 +04:00
return stbi__err ( " progressive jpeg " , " JPEG format not supported (progressive) " ) ;
2014-05-31 15:49:43 +04:00
case 0xDD : // DRI - specify restart interval
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( z - > s ) ! = 4 ) return stbi__err ( " bad DRI len " , " Corrupt JPEG " ) ;
z - > restart_interval = stbi__get16be ( z - > s ) ;
2014-05-31 15:49:43 +04:00
return 1 ;
case 0xDB : // DQT - define quantization table
2014-05-31 16:40:05 +04:00
L = stbi__get16be ( z - > s ) - 2 ;
2014-05-31 15:49:43 +04:00
while ( L > 0 ) {
2014-05-31 16:40:05 +04:00
int q = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
int p = q > > 4 ;
int t = q & 15 , i ;
2014-05-31 16:38:26 +04:00
if ( p ! = 0 ) return stbi__err ( " bad DQT type " , " Corrupt JPEG " ) ;
if ( t > 3 ) return stbi__err ( " bad DQT table " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < 64 ; + + i )
2014-06-06 21:15:30 +04:00
z - > dequant [ t ] [ stbi__jpeg_dezigzag [ i ] ] = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
# ifdef STBI_SIMD
for ( i = 0 ; i < 64 ; + + i )
z - > dequant2 [ t ] [ i ] = z - > dequant [ t ] [ i ] ;
# endif
L - = 65 ;
}
return L = = 0 ;
case 0xC4 : // DHT - define huffman table
2014-05-31 16:40:05 +04:00
L = stbi__get16be ( z - > s ) - 2 ;
2014-05-31 15:49:43 +04:00
while ( L > 0 ) {
2014-05-31 17:55:48 +04:00
stbi_uc * v ;
2014-05-31 15:49:43 +04:00
int sizes [ 16 ] , i , n = 0 ;
2014-05-31 16:40:05 +04:00
int q = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
int tc = q > > 4 ;
int th = q & 15 ;
2014-05-31 16:38:26 +04:00
if ( tc > 1 | | th > 3 ) return stbi__err ( " bad DHT header " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < 16 ; + + i ) {
2014-05-31 16:40:05 +04:00
sizes [ i ] = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
n + = sizes [ i ] ;
}
L - = 17 ;
if ( tc = = 0 ) {
2014-05-31 16:40:05 +04:00
if ( ! stbi__build_huffman ( z - > huff_dc + th , sizes ) ) return 0 ;
2014-05-31 15:49:43 +04:00
v = z - > huff_dc [ th ] . values ;
} else {
2014-05-31 16:40:05 +04:00
if ( ! stbi__build_huffman ( z - > huff_ac + th , sizes ) ) return 0 ;
2014-05-31 15:49:43 +04:00
v = z - > huff_ac [ th ] . values ;
}
for ( i = 0 ; i < n ; + + i )
2014-06-06 21:15:30 +04:00
v [ i ] = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
L - = n ;
}
return L = = 0 ;
}
// check for comment block or APP blocks
if ( ( m > = 0xE0 & & m < = 0xEF ) | | m = = 0xFE ) {
2014-05-31 16:40:05 +04:00
stbi__skip ( z - > s , stbi__get16be ( z - > s ) - 2 ) ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
return 0 ;
}
2014-05-31 16:40:05 +04:00
// after we see stbi__SOS
static int stbi__process_scan_header ( stbi__jpeg * z )
2014-05-31 15:49:43 +04:00
{
int i ;
2014-05-31 16:40:05 +04:00
int Ls = stbi__get16be ( z - > s ) ;
z - > scan_n = stbi__get8 ( z - > s ) ;
if ( z - > scan_n < 1 | | z - > scan_n > 4 | | z - > scan_n > ( int ) z - > s - > img_n ) return stbi__err ( " bad stbi__SOS component count " , " Corrupt JPEG " ) ;
if ( Ls ! = 6 + 2 * z - > scan_n ) return stbi__err ( " bad stbi__SOS len " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < z - > scan_n ; + + i ) {
2014-05-31 16:40:05 +04:00
int id = stbi__get8 ( z - > s ) , which ;
int q = stbi__get8 ( z - > s ) ;
2014-05-31 15:49:43 +04:00
for ( which = 0 ; which < z - > s - > img_n ; + + which )
if ( z - > img_comp [ which ] . id = = id )
break ;
if ( which = = z - > s - > img_n ) return 0 ;
2014-05-31 16:38:26 +04:00
z - > img_comp [ which ] . hd = q > > 4 ; if ( z - > img_comp [ which ] . hd > 3 ) return stbi__err ( " bad DC huff " , " Corrupt JPEG " ) ;
z - > img_comp [ which ] . ha = q & 15 ; if ( z - > img_comp [ which ] . ha > 3 ) return stbi__err ( " bad AC huff " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
z - > order [ i ] = which ;
}
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( z - > s ) ! = 0 ) return stbi__err ( " bad stbi__SOS " , " Corrupt JPEG " ) ;
stbi__get8 ( z - > s ) ; // should be 63, but might be 0
if ( stbi__get8 ( z - > s ) ! = 0 ) return stbi__err ( " bad stbi__SOS " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 16:40:05 +04:00
static int stbi__process_frame_header ( stbi__jpeg * z , int scan )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
stbi__context * s = z - > s ;
2014-05-31 15:49:43 +04:00
int Lf , p , i , q , h_max = 1 , v_max = 1 , c ;
2014-05-31 16:40:05 +04:00
Lf = stbi__get16be ( s ) ; if ( Lf < 11 ) return stbi__err ( " bad stbi__SOF len " , " Corrupt JPEG " ) ; // JPEG
p = stbi__get8 ( s ) ; if ( p ! = 8 ) return stbi__err ( " only 8-bit " , " JPEG format not supported: 8-bit only " ) ; // JPEG baseline
s - > img_y = stbi__get16be ( s ) ; if ( s - > img_y = = 0 ) return stbi__err ( " no header height " , " JPEG format not supported: delayed height " ) ; // Legal, but we don't handle it--but neither does IJG
s - > img_x = stbi__get16be ( s ) ; if ( s - > img_x = = 0 ) return stbi__err ( " 0 width " , " Corrupt JPEG " ) ; // JPEG requires
c = stbi__get8 ( s ) ;
2014-05-31 16:38:26 +04:00
if ( c ! = 3 & & c ! = 1 ) return stbi__err ( " bad component count " , " Corrupt JPEG " ) ; // JFIF requires
2014-05-31 15:49:43 +04:00
s - > img_n = c ;
for ( i = 0 ; i < c ; + + i ) {
z - > img_comp [ i ] . data = NULL ;
z - > img_comp [ i ] . linebuf = NULL ;
}
2014-05-31 16:40:05 +04:00
if ( Lf ! = 8 + 3 * s - > img_n ) return stbi__err ( " bad stbi__SOF len " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < s - > img_n ; + + i ) {
2014-05-31 16:40:05 +04:00
z - > img_comp [ i ] . id = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( z - > img_comp [ i ] . id ! = i + 1 ) // JFIF requires
if ( z - > img_comp [ i ] . id ! = i ) // some version of jpegtran outputs non-JFIF-compliant files!
2014-05-31 16:38:26 +04:00
return stbi__err ( " bad component ID " , " Corrupt JPEG " ) ;
2014-05-31 16:40:05 +04:00
q = stbi__get8 ( s ) ;
2014-05-31 16:38:26 +04:00
z - > img_comp [ i ] . h = ( q > > 4 ) ; if ( ! z - > img_comp [ i ] . h | | z - > img_comp [ i ] . h > 4 ) return stbi__err ( " bad H " , " Corrupt JPEG " ) ;
z - > img_comp [ i ] . v = q & 15 ; if ( ! z - > img_comp [ i ] . v | | z - > img_comp [ i ] . v > 4 ) return stbi__err ( " bad V " , " Corrupt JPEG " ) ;
2014-05-31 16:40:05 +04:00
z - > img_comp [ i ] . tq = stbi__get8 ( s ) ; if ( z - > img_comp [ i ] . tq > 3 ) return stbi__err ( " bad TQ " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
}
if ( scan ! = SCAN_load ) return 1 ;
2014-06-26 02:29:29 +04:00
if ( ( 1 < < 30 ) / s - > img_x / s - > img_n < s - > img_y ) return stbi__err ( " too large " , " Image too large to decode " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < s - > img_n ; + + i ) {
if ( z - > img_comp [ i ] . h > h_max ) h_max = z - > img_comp [ i ] . h ;
if ( z - > img_comp [ i ] . v > v_max ) v_max = z - > img_comp [ i ] . v ;
}
// compute interleaved mcu info
z - > img_h_max = h_max ;
z - > img_v_max = v_max ;
z - > img_mcu_w = h_max * 8 ;
z - > img_mcu_h = v_max * 8 ;
z - > img_mcu_x = ( s - > img_x + z - > img_mcu_w - 1 ) / z - > img_mcu_w ;
z - > img_mcu_y = ( s - > img_y + z - > img_mcu_h - 1 ) / z - > img_mcu_h ;
for ( i = 0 ; i < s - > img_n ; + + i ) {
2014-09-05 19:38:39 +04:00
// number of effective pixels (e.g. for non-interleaved MCU)
2014-05-31 15:49:43 +04:00
z - > img_comp [ i ] . x = ( s - > img_x * z - > img_comp [ i ] . h + h_max - 1 ) / h_max ;
z - > img_comp [ i ] . y = ( s - > img_y * z - > img_comp [ i ] . v + v_max - 1 ) / v_max ;
2014-06-26 02:29:29 +04:00
// to simplify generation, we'll allocate enough memory to decode
2014-05-31 15:49:43 +04:00
// the bogus oversized data from using interleaved MCUs and their
2014-09-05 19:38:39 +04:00
// big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
2014-05-31 15:49:43 +04:00
// 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 ;
2014-08-08 02:46:45 +04:00
z - > img_comp [ i ] . raw_data = stbi__malloc ( z - > img_comp [ i ] . w2 * z - > img_comp [ i ] . h2 + 15 ) ;
2014-05-31 15:49:43 +04:00
if ( z - > img_comp [ i ] . raw_data = = NULL ) {
for ( - - i ; i > = 0 ; - - i ) {
free ( z - > img_comp [ i ] . raw_data ) ;
z - > img_comp [ i ] . data = NULL ;
}
2014-05-31 16:38:26 +04:00
return stbi__err ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
}
// align blocks for installable-idct using mmx/sse
2014-05-31 17:55:48 +04:00
z - > img_comp [ i ] . data = ( stbi_uc * ) ( ( ( size_t ) z - > img_comp [ i ] . raw_data + 15 ) & ~ 15 ) ;
2014-05-31 15:49:43 +04:00
z - > img_comp [ i ] . linebuf = NULL ;
}
return 1 ;
}
2014-09-05 19:38:39 +04:00
// use comparisons since in some cases we handle more than one case (e.g. stbi__SOF)
2014-05-31 16:40:05 +04:00
# define stbi__DNL(x) ((x) == 0xdc)
# define stbi__SOI(x) ((x) == 0xd8)
# define stbi__EOI(x) ((x) == 0xd9)
# define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1)
# define stbi__SOS(x) ((x) == 0xda)
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
static int decode_jpeg_header ( stbi__jpeg * z , int scan )
2014-05-31 15:49:43 +04:00
{
int m ;
2014-05-31 16:40:05 +04:00
z - > marker = STBI__MARKER_none ; // initialize cached marker to empty
m = stbi__get_marker ( z ) ;
if ( ! stbi__SOI ( m ) ) return stbi__err ( " no stbi__SOI " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
if ( scan = = SCAN_type ) return 1 ;
2014-05-31 16:40:05 +04:00
m = stbi__get_marker ( z ) ;
while ( ! stbi__SOF ( m ) ) {
if ( ! stbi__process_marker ( z , m ) ) return 0 ;
m = stbi__get_marker ( z ) ;
while ( m = = STBI__MARKER_none ) {
2014-05-31 15:49:43 +04:00
// some files have extra padding after their blocks, so ok, we'll scan
2014-05-31 16:40:05 +04:00
if ( stbi__at_eof ( z - > s ) ) return stbi__err ( " no stbi__SOF " , " Corrupt JPEG " ) ;
m = stbi__get_marker ( z ) ;
2014-05-31 15:49:43 +04:00
}
}
2014-05-31 16:40:05 +04:00
if ( ! stbi__process_frame_header ( z , scan ) ) return 0 ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 16:40:05 +04:00
static int decode_jpeg_image ( stbi__jpeg * j )
2014-05-31 15:49:43 +04:00
{
int m ;
j - > restart_interval = 0 ;
if ( ! decode_jpeg_header ( j , SCAN_load ) ) return 0 ;
2014-05-31 16:40:05 +04:00
m = stbi__get_marker ( j ) ;
while ( ! stbi__EOI ( m ) ) {
if ( stbi__SOS ( m ) ) {
if ( ! stbi__process_scan_header ( j ) ) return 0 ;
if ( ! stbi__parse_entropy_coded_data ( j ) ) return 0 ;
if ( j - > marker = = STBI__MARKER_none ) {
2014-05-31 15:49:43 +04:00
// handle 0s at the end of image data from IP Kamera 9060
2014-05-31 16:40:05 +04:00
while ( ! stbi__at_eof ( j - > s ) ) {
int x = stbi__get8 ( j - > s ) ;
2014-05-31 15:49:43 +04:00
if ( x = = 255 ) {
2014-06-06 21:15:30 +04:00
j - > marker = stbi__get8 ( j - > s ) ;
2014-05-31 15:49:43 +04:00
break ;
} else if ( x ! = 0 ) {
return 0 ;
}
}
2014-05-31 16:40:05 +04:00
// if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
2014-05-31 15:49:43 +04:00
}
} else {
2014-05-31 16:40:05 +04:00
if ( ! stbi__process_marker ( j , m ) ) return 0 ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
m = stbi__get_marker ( j ) ;
2014-05-31 15:49:43 +04:00
}
return 1 ;
}
// static jfif-centered resampling (across block boundaries)
2014-05-31 17:55:48 +04:00
typedef stbi_uc * ( * resample_row_func ) ( stbi_uc * out , stbi_uc * in0 , stbi_uc * in1 ,
2014-05-31 15:49:43 +04:00
int w , int hs ) ;
2014-05-31 17:55:48 +04:00
# define stbi__div4(x) ((stbi_uc) ((x) >> 2))
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
static stbi_uc * resample_row_1 ( stbi_uc * out , stbi_uc * in_near , stbi_uc * in_far , int w , int hs )
2014-05-31 15:49:43 +04:00
{
STBI_NOTUSED ( out ) ;
STBI_NOTUSED ( in_far ) ;
STBI_NOTUSED ( w ) ;
STBI_NOTUSED ( hs ) ;
return in_near ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__resample_row_v_2 ( stbi_uc * out , stbi_uc * in_near , stbi_uc * in_far , int w , int hs )
2014-05-31 15:49:43 +04:00
{
// need to generate two samples vertically for every one in input
int i ;
STBI_NOTUSED ( hs ) ;
for ( i = 0 ; i < w ; + + i )
2014-05-31 16:40:05 +04:00
out [ i ] = stbi__div4 ( 3 * in_near [ i ] + in_far [ i ] + 2 ) ;
2014-05-31 15:49:43 +04:00
return out ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__resample_row_h_2 ( stbi_uc * out , stbi_uc * in_near , stbi_uc * in_far , int w , int hs )
2014-05-31 15:49:43 +04:00
{
// need to generate two samples horizontally for every one in input
int i ;
2014-05-31 17:55:48 +04:00
stbi_uc * input = in_near ;
2014-05-31 15:49:43 +04:00
if ( w = = 1 ) {
// if only one sample, can't do any interpolation
out [ 0 ] = out [ 1 ] = input [ 0 ] ;
return out ;
}
out [ 0 ] = input [ 0 ] ;
2014-05-31 16:40:05 +04:00
out [ 1 ] = stbi__div4 ( input [ 0 ] * 3 + input [ 1 ] + 2 ) ;
2014-05-31 15:49:43 +04:00
for ( i = 1 ; i < w - 1 ; + + i ) {
int n = 3 * input [ i ] + 2 ;
2014-05-31 16:40:05 +04:00
out [ i * 2 + 0 ] = stbi__div4 ( n + input [ i - 1 ] ) ;
out [ i * 2 + 1 ] = stbi__div4 ( n + input [ i + 1 ] ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
out [ i * 2 + 0 ] = stbi__div4 ( input [ w - 2 ] * 3 + input [ w - 1 ] + 2 ) ;
2014-05-31 15:49:43 +04:00
out [ i * 2 + 1 ] = input [ w - 1 ] ;
STBI_NOTUSED ( in_far ) ;
STBI_NOTUSED ( hs ) ;
return out ;
}
2014-05-31 17:55:48 +04:00
# define stbi__div16(x) ((stbi_uc) ((x) >> 4))
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__resample_row_hv_2 ( stbi_uc * out , stbi_uc * in_near , stbi_uc * in_far , int w , int hs )
2014-05-31 15:49:43 +04:00
{
// need to generate 2x2 samples for every one in input
int i , t0 , t1 ;
if ( w = = 1 ) {
2014-05-31 16:40:05 +04:00
out [ 0 ] = out [ 1 ] = stbi__div4 ( 3 * in_near [ 0 ] + in_far [ 0 ] + 2 ) ;
2014-05-31 15:49:43 +04:00
return out ;
}
t1 = 3 * in_near [ 0 ] + in_far [ 0 ] ;
2014-05-31 16:40:05 +04:00
out [ 0 ] = stbi__div4 ( t1 + 2 ) ;
2014-05-31 15:49:43 +04:00
for ( i = 1 ; i < w ; + + i ) {
t0 = t1 ;
t1 = 3 * in_near [ i ] + in_far [ i ] ;
2014-05-31 16:40:05 +04:00
out [ i * 2 - 1 ] = stbi__div16 ( 3 * t0 + t1 + 8 ) ;
out [ i * 2 ] = stbi__div16 ( 3 * t1 + t0 + 8 ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
out [ w * 2 - 1 ] = stbi__div4 ( t1 + 2 ) ;
2014-05-31 15:49:43 +04:00
STBI_NOTUSED ( hs ) ;
return out ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__resample_row_generic ( stbi_uc * out , stbi_uc * in_near , stbi_uc * in_far , int w , int hs )
2014-05-31 15:49:43 +04:00
{
// resample with nearest-neighbor
int i , j ;
STBI_NOTUSED ( in_far ) ;
for ( i = 0 ; i < w ; + + i )
for ( j = 0 ; j < hs ; + + j )
out [ i * hs + j ] = in_near [ i ] ;
return out ;
}
# define float2fixed(x) ((int) ((x) * 65536 + 0.5))
// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro)
// VC6 without processor=Pro is generating multiple LEAs per multiply!
2014-05-31 17:55:48 +04:00
static void stbi__YCbCr_to_RGB_row ( stbi_uc * out , const stbi_uc * y , const stbi_uc * pcb , const stbi_uc * pcr , int count , int step )
2014-05-31 15:49:43 +04:00
{
int i ;
for ( i = 0 ; i < count ; + + i ) {
int y_fixed = ( y [ i ] < < 16 ) + 32768 ; // rounding
int r , g , b ;
int cr = pcr [ i ] - 128 ;
int cb = pcb [ i ] - 128 ;
r = y_fixed + cr * float2fixed ( 1.40200f ) ;
g = y_fixed - cr * float2fixed ( 0.71414f ) - cb * float2fixed ( 0.34414f ) ;
b = y_fixed + cb * float2fixed ( 1.77200f ) ;
r > > = 16 ;
g > > = 16 ;
b > > = 16 ;
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 ; }
2014-05-31 17:55:48 +04:00
out [ 0 ] = ( stbi_uc ) r ;
out [ 1 ] = ( stbi_uc ) g ;
out [ 2 ] = ( stbi_uc ) b ;
2014-05-31 15:49:43 +04:00
out [ 3 ] = 255 ;
out + = step ;
}
}
# ifdef STBI_SIMD
2014-05-31 16:40:05 +04:00
static stbi_YCbCr_to_RGB_run stbi__YCbCr_installed = stbi__YCbCr_to_RGB_row ;
2014-05-31 15:49:43 +04:00
STBIDEF void stbi_install_YCbCr_to_RGB ( stbi_YCbCr_to_RGB_run func )
{
2014-05-31 16:40:05 +04:00
stbi__YCbCr_installed = func ;
2014-05-31 15:49:43 +04:00
}
# endif
// clean up the temporary component buffers
2014-05-31 16:40:05 +04:00
static void stbi__cleanup_jpeg ( stbi__jpeg * j )
2014-05-31 15:49:43 +04:00
{
int i ;
for ( i = 0 ; i < j - > s - > img_n ; + + i ) {
2014-07-09 17:41:22 +04:00
if ( j - > img_comp [ i ] . raw_data ) {
2014-05-31 15:49:43 +04:00
free ( j - > img_comp [ i ] . raw_data ) ;
2014-07-09 17:41:22 +04:00
j - > img_comp [ i ] . raw_data = NULL ;
2014-05-31 15:49:43 +04:00
j - > img_comp [ i ] . data = NULL ;
}
if ( j - > img_comp [ i ] . linebuf ) {
free ( j - > img_comp [ i ] . linebuf ) ;
j - > img_comp [ i ] . linebuf = NULL ;
}
}
}
typedef struct
{
resample_row_func resample ;
2014-05-31 17:55:48 +04:00
stbi_uc * line0 , * line1 ;
2014-05-31 15:49:43 +04:00
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
2014-05-31 16:40:05 +04:00
} stbi__resample ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
static stbi_uc * load_jpeg_image ( stbi__jpeg * z , int * out_x , int * out_y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
int n , decode_n ;
2014-07-10 10:26:03 +04:00
z - > s - > img_n = 0 ; // make stbi__cleanup_jpeg safe
2014-05-31 15:49:43 +04:00
// validate req_comp
2014-05-31 16:38:26 +04:00
if ( req_comp < 0 | | req_comp > 4 ) return stbi__errpuc ( " bad req_comp " , " Internal error " ) ;
2014-05-31 15:49:43 +04:00
// load a jpeg image from whichever source
2014-05-31 16:40:05 +04:00
if ( ! decode_jpeg_image ( z ) ) { stbi__cleanup_jpeg ( z ) ; return NULL ; }
2014-05-31 15:49:43 +04:00
// determine actual number of components to generate
n = req_comp ? req_comp : z - > s - > img_n ;
if ( z - > s - > img_n = = 3 & & n < 3 )
decode_n = 1 ;
else
decode_n = z - > s - > img_n ;
// resample and color-convert
{
int k ;
unsigned int i , j ;
2014-05-31 17:55:48 +04:00
stbi_uc * output ;
stbi_uc * coutput [ 4 ] ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
stbi__resample res_comp [ 4 ] ;
2014-05-31 15:49:43 +04:00
for ( k = 0 ; k < decode_n ; + + k ) {
2014-05-31 16:40:05 +04:00
stbi__resample * r = & res_comp [ k ] ;
2014-05-31 15:49:43 +04:00
// allocate line buffer big enough for upsampling off the edges
// with upsample factor of 4
2014-08-08 02:46:45 +04:00
z - > img_comp [ k ] . linebuf = ( stbi_uc * ) stbi__malloc ( z - > s - > img_x + 3 ) ;
2014-05-31 16:40:05 +04:00
if ( ! z - > img_comp [ k ] . linebuf ) { stbi__cleanup_jpeg ( z ) ; return stbi__errpuc ( " outofmem " , " Out of memory " ) ; }
2014-05-31 15:49:43 +04:00
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 ;
2014-05-31 16:40:05 +04:00
else if ( r - > hs = = 1 & & r - > vs = = 2 ) r - > resample = stbi__resample_row_v_2 ;
else if ( r - > hs = = 2 & & r - > vs = = 1 ) r - > resample = stbi__resample_row_h_2 ;
else if ( r - > hs = = 2 & & r - > vs = = 2 ) r - > resample = stbi__resample_row_hv_2 ;
else r - > resample = stbi__resample_row_generic ;
2014-05-31 15:49:43 +04:00
}
// can't error after this so, this is safe
2014-08-08 02:46:45 +04:00
output = ( stbi_uc * ) stbi__malloc ( n * z - > s - > img_x * z - > s - > img_y + 1 ) ;
2014-05-31 16:40:05 +04:00
if ( ! output ) { stbi__cleanup_jpeg ( z ) ; return stbi__errpuc ( " outofmem " , " Out of memory " ) ; }
2014-05-31 15:49:43 +04:00
// now go ahead and resample
for ( j = 0 ; j < z - > s - > img_y ; + + j ) {
2014-05-31 17:55:48 +04:00
stbi_uc * out = output + n * z - > s - > img_x * j ;
2014-05-31 15:49:43 +04:00
for ( k = 0 ; k < decode_n ; + + k ) {
2014-05-31 16:40:05 +04:00
stbi__resample * r = & res_comp [ k ] ;
2014-05-31 15:49:43 +04:00
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 ) {
r - > ystep = 0 ;
r - > line0 = r - > line1 ;
if ( + + r - > ypos < z - > img_comp [ k ] . y )
r - > line1 + = z - > img_comp [ k ] . w2 ;
}
}
if ( n > = 3 ) {
2014-05-31 17:55:48 +04:00
stbi_uc * y = coutput [ 0 ] ;
2014-05-31 15:49:43 +04:00
if ( z - > s - > img_n = = 3 ) {
# ifdef STBI_SIMD
2014-05-31 16:40:05 +04:00
stbi__YCbCr_installed ( out , y , coutput [ 1 ] , coutput [ 2 ] , z - > s - > img_x , n ) ;
2014-05-31 15:49:43 +04:00
# else
2014-05-31 16:40:05 +04:00
stbi__YCbCr_to_RGB_row ( out , y , coutput [ 1 ] , coutput [ 2 ] , z - > s - > img_x , n ) ;
2014-05-31 15:49:43 +04:00
# endif
} else
for ( i = 0 ; i < z - > s - > img_x ; + + i ) {
out [ 0 ] = out [ 1 ] = out [ 2 ] = y [ i ] ;
out [ 3 ] = 255 ; // not used if n==3
out + = n ;
}
} else {
2014-05-31 17:55:48 +04:00
stbi_uc * y = coutput [ 0 ] ;
2014-05-31 15:49:43 +04:00
if ( n = = 1 )
for ( i = 0 ; i < z - > s - > img_x ; + + i ) out [ i ] = y [ i ] ;
else
for ( i = 0 ; i < z - > s - > img_x ; + + i ) * out + + = y [ i ] , * out + + = 255 ;
}
}
2014-05-31 16:40:05 +04:00
stbi__cleanup_jpeg ( z ) ;
2014-05-31 15:49:43 +04:00
* out_x = z - > s - > img_x ;
* out_y = z - > s - > img_y ;
if ( comp ) * comp = z - > s - > img_n ; // report original components, not output
return output ;
}
}
2014-05-31 16:38:26 +04:00
static unsigned char * stbi__jpeg_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
stbi__jpeg j ;
2014-05-31 15:49:43 +04:00
j . s = s ;
return load_jpeg_image ( & j , x , y , comp , req_comp ) ;
}
2014-05-31 16:38:26 +04:00
static int stbi__jpeg_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
int r ;
2014-05-31 16:40:05 +04:00
stbi__jpeg j ;
2014-05-31 15:49:43 +04:00
j . s = s ;
r = decode_jpeg_header ( & j , SCAN_type ) ;
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
2014-05-31 16:40:05 +04:00
static int stbi__jpeg_info_raw ( stbi__jpeg * j , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
if ( ! decode_jpeg_header ( j , SCAN_header ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( j - > s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
if ( x ) * x = j - > s - > img_x ;
if ( y ) * y = j - > s - > img_y ;
if ( comp ) * comp = j - > s - > img_n ;
return 1 ;
}
2014-05-31 16:38:26 +04:00
static int stbi__jpeg_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:40:05 +04:00
stbi__jpeg j ;
2014-05-31 15:49:43 +04:00
j . s = s ;
2014-05-31 16:40:05 +04:00
return stbi__jpeg_info_raw ( & j , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
}
2014-06-26 02:29:29 +04:00
// public domain zlib decode v0.2 Sean Barrett 2006-11-18
2014-05-31 15:49:43 +04:00
// simple implementation
// - all input must be provided in an upfront buffer
// - all output is written to a single output buffer (can malloc/realloc)
// performance
// - fast huffman
// fast-way is faster to check than jpeg huffman, but slow way is slower
2014-05-31 17:27:37 +04:00
# define STBI__ZFAST_BITS 9 // accelerate all cases in default tables
# define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
2014-05-31 15:49:43 +04:00
// zlib-style huffman encoding
// (jpegs packs from left, zlib from right, so can't share code)
typedef struct
{
2014-05-31 17:27:37 +04:00
stbi__uint16 fast [ 1 < < STBI__ZFAST_BITS ] ;
2014-05-31 15:49:43 +04:00
stbi__uint16 firstcode [ 16 ] ;
int maxcode [ 17 ] ;
stbi__uint16 firstsymbol [ 16 ] ;
2014-05-31 17:55:48 +04:00
stbi_uc size [ 288 ] ;
2014-05-31 15:49:43 +04:00
stbi__uint16 value [ 288 ] ;
2014-05-31 17:27:37 +04:00
} stbi__zhuffman ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:27:37 +04:00
stbi_inline static int stbi__bitreverse16 ( int n )
2014-05-31 15:49:43 +04:00
{
n = ( ( n & 0xAAAA ) > > 1 ) | ( ( n & 0x5555 ) < < 1 ) ;
n = ( ( n & 0xCCCC ) > > 2 ) | ( ( n & 0x3333 ) < < 2 ) ;
n = ( ( n & 0xF0F0 ) > > 4 ) | ( ( n & 0x0F0F ) < < 4 ) ;
n = ( ( n & 0xFF00 ) > > 8 ) | ( ( n & 0x00FF ) < < 8 ) ;
return n ;
}
2014-05-31 17:27:37 +04:00
stbi_inline static int stbi__bit_reverse ( int v , int bits )
2014-05-31 15:49:43 +04:00
{
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( bits < = 16 ) ;
2014-05-31 15:49:43 +04:00
// to bit reverse n bits, reverse 16 and shift
2014-09-05 19:38:39 +04:00
// e.g. 11 bits, bit reverse and shift away 5
2014-05-31 17:27:37 +04:00
return stbi__bitreverse16 ( v ) > > ( 16 - bits ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:55:48 +04:00
static int stbi__zbuild_huffman ( stbi__zhuffman * z , stbi_uc * sizelist , int num )
2014-05-31 15:49:43 +04:00
{
int i , k = 0 ;
int code , next_code [ 16 ] , sizes [ 17 ] ;
// DEFLATE spec for generating codes
memset ( sizes , 0 , sizeof ( sizes ) ) ;
memset ( z - > fast , 255 , sizeof ( z - > fast ) ) ;
for ( i = 0 ; i < num ; + + i )
+ + sizes [ sizelist [ i ] ] ;
sizes [ 0 ] = 0 ;
for ( i = 1 ; i < 16 ; + + i )
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( sizes [ i ] < = ( 1 < < i ) ) ;
2014-05-31 15:49:43 +04:00
code = 0 ;
for ( i = 1 ; i < 16 ; + + i ) {
next_code [ i ] = code ;
z - > firstcode [ i ] = ( stbi__uint16 ) code ;
z - > firstsymbol [ i ] = ( stbi__uint16 ) k ;
code = ( code + sizes [ i ] ) ;
if ( sizes [ i ] )
2014-05-31 16:38:26 +04:00
if ( code - 1 > = ( 1 < < i ) ) return stbi__err ( " bad codelengths " , " Corrupt JPEG " ) ;
2014-05-31 15:49:43 +04:00
z - > maxcode [ i ] = code < < ( 16 - i ) ; // preshift for inner loop
code < < = 1 ;
k + = sizes [ i ] ;
}
z - > maxcode [ 16 ] = 0x10000 ; // sentinel
for ( i = 0 ; i < num ; + + i ) {
int s = sizelist [ i ] ;
if ( s ) {
int c = next_code [ s ] - z - > firstcode [ s ] + z - > firstsymbol [ s ] ;
2014-06-06 21:15:30 +04:00
z - > size [ c ] = ( stbi_uc ) s ;
z - > value [ c ] = ( stbi__uint16 ) i ;
2014-05-31 17:27:37 +04:00
if ( s < = STBI__ZFAST_BITS ) {
int k = stbi__bit_reverse ( next_code [ s ] , s ) ;
while ( k < ( 1 < < STBI__ZFAST_BITS ) ) {
2014-05-31 15:49:43 +04:00
z - > fast [ k ] = ( stbi__uint16 ) c ;
k + = ( 1 < < s ) ;
}
}
+ + next_code [ s ] ;
}
}
return 1 ;
}
// zlib-from-memory implementation for PNG reading
// because PNG allows splitting the zlib stream arbitrarily,
// and it's annoying structurally to have PNG call ZLIB call PNG,
// we require PNG read all the IDATs and combine them into a single
// memory buffer
typedef struct
{
2014-05-31 17:55:48 +04:00
stbi_uc * zbuffer , * zbuffer_end ;
2014-05-31 15:49:43 +04:00
int num_bits ;
stbi__uint32 code_buffer ;
char * zout ;
char * zout_start ;
char * zout_end ;
int z_expandable ;
2014-05-31 17:27:37 +04:00
stbi__zhuffman z_length , z_distance ;
} stbi__zbuf ;
2014-05-31 15:49:43 +04:00
2014-06-06 21:15:30 +04:00
stbi_inline static stbi_uc stbi__zget8 ( stbi__zbuf * z )
2014-05-31 15:49:43 +04:00
{
if ( z - > zbuffer > = z - > zbuffer_end ) return 0 ;
return * z - > zbuffer + + ;
}
2014-05-31 17:27:37 +04:00
static void stbi__fill_bits ( stbi__zbuf * z )
2014-05-31 15:49:43 +04:00
{
do {
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( z - > code_buffer < ( 1U < < z - > num_bits ) ) ;
2014-05-31 17:27:37 +04:00
z - > code_buffer | = stbi__zget8 ( z ) < < z - > num_bits ;
2014-05-31 15:49:43 +04:00
z - > num_bits + = 8 ;
} while ( z - > num_bits < = 24 ) ;
}
2014-05-31 17:27:37 +04:00
stbi_inline static unsigned int stbi__zreceive ( stbi__zbuf * z , int n )
2014-05-31 15:49:43 +04:00
{
unsigned int k ;
2014-05-31 17:27:37 +04:00
if ( z - > num_bits < n ) stbi__fill_bits ( z ) ;
2014-05-31 15:49:43 +04:00
k = z - > code_buffer & ( ( 1 < < n ) - 1 ) ;
z - > code_buffer > > = n ;
z - > num_bits - = n ;
return k ;
}
2014-05-31 17:27:37 +04:00
stbi_inline static int stbi__zhuffman_decode ( stbi__zbuf * a , stbi__zhuffman * z )
2014-05-31 15:49:43 +04:00
{
int b , s , k ;
2014-05-31 17:27:37 +04:00
if ( a - > num_bits < 16 ) stbi__fill_bits ( a ) ;
b = z - > fast [ a - > code_buffer & STBI__ZFAST_MASK ] ;
2014-05-31 15:49:43 +04:00
if ( b < 0xffff ) {
s = z - > size [ b ] ;
a - > code_buffer > > = s ;
a - > num_bits - = s ;
return z - > value [ b ] ;
}
// not resolved by fast table, so compute it the slow way
// use jpeg approach, which requires MSbits at top
2014-05-31 17:27:37 +04:00
k = stbi__bit_reverse ( a - > code_buffer , 16 ) ;
for ( s = STBI__ZFAST_BITS + 1 ; ; + + s )
2014-05-31 15:49:43 +04:00
if ( k < z - > maxcode [ s ] )
break ;
if ( s = = 16 ) return - 1 ; // invalid code!
// code size is s, so:
b = ( k > > ( 16 - s ) ) - z - > firstcode [ s ] + z - > firstsymbol [ s ] ;
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( z - > size [ b ] = = s ) ;
2014-05-31 15:49:43 +04:00
a - > code_buffer > > = s ;
a - > num_bits - = s ;
return z - > value [ b ] ;
}
2014-05-31 17:27:37 +04:00
static int stbi__zexpand ( stbi__zbuf * z , int n ) // need to make room for n bytes
2014-05-31 15:49:43 +04:00
{
char * q ;
int cur , limit ;
2014-05-31 16:38:26 +04:00
if ( ! z - > z_expandable ) return stbi__err ( " output buffer limit " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
cur = ( int ) ( z - > zout - z - > zout_start ) ;
limit = ( int ) ( z - > zout_end - z - > zout_start ) ;
while ( cur + n > limit )
limit * = 2 ;
q = ( char * ) realloc ( z - > zout_start , limit ) ;
2014-05-31 16:38:26 +04:00
if ( q = = NULL ) return stbi__err ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
z - > zout_start = q ;
z - > zout = q + cur ;
z - > zout_end = q + limit ;
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__zlength_base [ 31 ] = {
2014-05-31 15:49:43 +04:00
3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 13 ,
15 , 17 , 19 , 23 , 27 , 31 , 35 , 43 , 51 , 59 ,
67 , 83 , 99 , 115 , 131 , 163 , 195 , 227 , 258 , 0 , 0 } ;
2014-05-31 17:27:37 +04:00
static int stbi__zlength_extra [ 31 ] =
2014-05-31 15:49:43 +04:00
{ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 2 , 2 , 2 , 2 , 3 , 3 , 3 , 3 , 4 , 4 , 4 , 4 , 5 , 5 , 5 , 5 , 0 , 0 , 0 } ;
2014-05-31 17:27:37 +04:00
static int stbi__zdist_base [ 32 ] = { 1 , 2 , 3 , 4 , 5 , 7 , 9 , 13 , 17 , 25 , 33 , 49 , 65 , 97 , 129 , 193 ,
2014-05-31 15:49:43 +04:00
257 , 385 , 513 , 769 , 1025 , 1537 , 2049 , 3073 , 4097 , 6145 , 8193 , 12289 , 16385 , 24577 , 0 , 0 } ;
2014-05-31 17:27:37 +04:00
static int stbi__zdist_extra [ 32 ] =
2014-05-31 15:49:43 +04:00
{ 0 , 0 , 0 , 0 , 1 , 1 , 2 , 2 , 3 , 3 , 4 , 4 , 5 , 5 , 6 , 6 , 7 , 7 , 8 , 8 , 9 , 9 , 10 , 10 , 11 , 11 , 12 , 12 , 13 , 13 } ;
2014-05-31 17:27:37 +04:00
static int stbi__parse_huffman_block ( stbi__zbuf * a )
2014-05-31 15:49:43 +04:00
{
for ( ; ; ) {
2014-05-31 17:27:37 +04:00
int z = stbi__zhuffman_decode ( a , & a - > z_length ) ;
2014-05-31 15:49:43 +04:00
if ( z < 256 ) {
2014-05-31 16:38:26 +04:00
if ( z < 0 ) return stbi__err ( " bad huffman code " , " Corrupt PNG " ) ; // error in huffman codes
2014-05-31 17:27:37 +04:00
if ( a - > zout > = a - > zout_end ) if ( ! stbi__zexpand ( a , 1 ) ) return 0 ;
2014-05-31 15:49:43 +04:00
* a - > zout + + = ( char ) z ;
} else {
2014-05-31 17:55:48 +04:00
stbi_uc * p ;
2014-05-31 15:49:43 +04:00
int len , dist ;
if ( z = = 256 ) return 1 ;
z - = 257 ;
2014-05-31 17:27:37 +04:00
len = stbi__zlength_base [ z ] ;
if ( stbi__zlength_extra [ z ] ) len + = stbi__zreceive ( a , stbi__zlength_extra [ z ] ) ;
z = stbi__zhuffman_decode ( a , & a - > z_distance ) ;
2014-05-31 16:38:26 +04:00
if ( z < 0 ) return stbi__err ( " bad huffman code " , " Corrupt PNG " ) ;
2014-05-31 17:27:37 +04:00
dist = stbi__zdist_base [ z ] ;
if ( stbi__zdist_extra [ z ] ) dist + = stbi__zreceive ( a , stbi__zdist_extra [ z ] ) ;
2014-05-31 16:38:26 +04:00
if ( a - > zout - a - > zout_start < dist ) return stbi__err ( " bad dist " , " Corrupt PNG " ) ;
2014-05-31 17:27:37 +04:00
if ( a - > zout + len > a - > zout_end ) if ( ! stbi__zexpand ( a , len ) ) return 0 ;
2014-05-31 17:55:48 +04:00
p = ( stbi_uc * ) ( a - > zout - dist ) ;
2014-05-31 15:49:43 +04:00
while ( len - - )
* a - > zout + + = * p + + ;
}
}
}
2014-05-31 17:27:37 +04:00
static int stbi__compute_huffman_codes ( stbi__zbuf * a )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
static stbi_uc length_dezigzag [ 19 ] = { 16 , 17 , 18 , 0 , 8 , 7 , 9 , 6 , 10 , 5 , 11 , 4 , 12 , 3 , 13 , 2 , 14 , 1 , 15 } ;
2014-05-31 17:27:37 +04:00
stbi__zhuffman z_codelength ;
2014-05-31 17:55:48 +04:00
stbi_uc lencodes [ 286 + 32 + 137 ] ; //padding for maximum single op
stbi_uc codelength_sizes [ 19 ] ;
2014-05-31 15:49:43 +04:00
int i , n ;
2014-05-31 17:27:37 +04:00
int hlit = stbi__zreceive ( a , 5 ) + 257 ;
int hdist = stbi__zreceive ( a , 5 ) + 1 ;
int hclen = stbi__zreceive ( a , 4 ) + 4 ;
2014-05-31 15:49:43 +04:00
memset ( codelength_sizes , 0 , sizeof ( codelength_sizes ) ) ;
for ( i = 0 ; i < hclen ; + + i ) {
2014-05-31 17:27:37 +04:00
int s = stbi__zreceive ( a , 3 ) ;
2014-05-31 17:55:48 +04:00
codelength_sizes [ length_dezigzag [ i ] ] = ( stbi_uc ) s ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:27:37 +04:00
if ( ! stbi__zbuild_huffman ( & z_codelength , codelength_sizes , 19 ) ) return 0 ;
2014-05-31 15:49:43 +04:00
n = 0 ;
while ( n < hlit + hdist ) {
2014-05-31 17:27:37 +04:00
int c = stbi__zhuffman_decode ( a , & z_codelength ) ;
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( c > = 0 & & c < 19 ) ;
2014-05-31 15:49:43 +04:00
if ( c < 16 )
2014-05-31 17:55:48 +04:00
lencodes [ n + + ] = ( stbi_uc ) c ;
2014-05-31 15:49:43 +04:00
else if ( c = = 16 ) {
2014-05-31 17:27:37 +04:00
c = stbi__zreceive ( a , 2 ) + 3 ;
2014-05-31 15:49:43 +04:00
memset ( lencodes + n , lencodes [ n - 1 ] , c ) ;
n + = c ;
} else if ( c = = 17 ) {
2014-05-31 17:27:37 +04:00
c = stbi__zreceive ( a , 3 ) + 3 ;
2014-05-31 15:49:43 +04:00
memset ( lencodes + n , 0 , c ) ;
n + = c ;
} else {
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( c = = 18 ) ;
2014-05-31 17:27:37 +04:00
c = stbi__zreceive ( a , 7 ) + 11 ;
2014-05-31 15:49:43 +04:00
memset ( lencodes + n , 0 , c ) ;
n + = c ;
}
}
2014-05-31 16:38:26 +04:00
if ( n ! = hlit + hdist ) return stbi__err ( " bad codelengths " , " Corrupt PNG " ) ;
2014-05-31 17:27:37 +04:00
if ( ! stbi__zbuild_huffman ( & a - > z_length , lencodes , hlit ) ) return 0 ;
if ( ! stbi__zbuild_huffman ( & a - > z_distance , lencodes + hlit , hdist ) ) return 0 ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__parse_uncomperssed_block ( stbi__zbuf * a )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc header [ 4 ] ;
2014-05-31 15:49:43 +04:00
int len , nlen , k ;
if ( a - > num_bits & 7 )
2014-05-31 17:27:37 +04:00
stbi__zreceive ( a , a - > num_bits & 7 ) ; // discard
2014-05-31 15:49:43 +04:00
// drain the bit-packed data into header
k = 0 ;
while ( a - > num_bits > 0 ) {
2014-06-06 21:15:30 +04:00
header [ k + + ] = ( stbi_uc ) ( a - > code_buffer & 255 ) ; // suppress MSVC run-time check
2014-05-31 15:49:43 +04:00
a - > code_buffer > > = 8 ;
a - > num_bits - = 8 ;
}
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( a - > num_bits = = 0 ) ;
2014-05-31 15:49:43 +04:00
// now fill header the normal way
while ( k < 4 )
2014-06-06 21:15:30 +04:00
header [ k + + ] = stbi__zget8 ( a ) ;
2014-05-31 15:49:43 +04:00
len = header [ 1 ] * 256 + header [ 0 ] ;
nlen = header [ 3 ] * 256 + header [ 2 ] ;
2014-05-31 16:38:26 +04:00
if ( nlen ! = ( len ^ 0xffff ) ) return stbi__err ( " zlib corrupt " , " Corrupt PNG " ) ;
if ( a - > zbuffer + len > a - > zbuffer_end ) return stbi__err ( " read past buffer " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( a - > zout + len > a - > zout_end )
2014-05-31 17:27:37 +04:00
if ( ! stbi__zexpand ( a , len ) ) return 0 ;
2014-05-31 15:49:43 +04:00
memcpy ( a - > zout , a - > zbuffer , len ) ;
a - > zbuffer + = len ;
a - > zout + = len ;
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__parse_zlib_header ( stbi__zbuf * a )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
int cmf = stbi__zget8 ( a ) ;
2014-05-31 15:49:43 +04:00
int cm = cmf & 15 ;
/* int cinfo = cmf >> 4; */
2014-05-31 17:27:37 +04:00
int flg = stbi__zget8 ( a ) ;
2014-05-31 16:38:26 +04:00
if ( ( cmf * 256 + flg ) % 31 ! = 0 ) return stbi__err ( " bad zlib header " , " Corrupt PNG " ) ; // zlib spec
if ( flg & 32 ) return stbi__err ( " no preset dict " , " Corrupt PNG " ) ; // preset dictionary not allowed in png
if ( cm ! = 8 ) return stbi__err ( " bad compression " , " Corrupt PNG " ) ; // DEFLATE required for png
2014-05-31 15:49:43 +04:00
// window = 1 << (8 + cinfo)... but who cares, we fully buffer output
return 1 ;
}
// @TODO: should statically initialize these for optimal thread safety
2014-05-31 17:55:48 +04:00
static stbi_uc stbi__zdefault_length [ 288 ] , stbi__zdefault_distance [ 32 ] ;
2014-05-31 17:27:37 +04:00
static void stbi__init_zdefaults ( void )
2014-05-31 15:49:43 +04:00
{
int i ; // use <= to match clearly with spec
2014-05-31 17:27:37 +04:00
for ( i = 0 ; i < = 143 ; + + i ) stbi__zdefault_length [ i ] = 8 ;
for ( ; i < = 255 ; + + i ) stbi__zdefault_length [ i ] = 9 ;
for ( ; i < = 279 ; + + i ) stbi__zdefault_length [ i ] = 7 ;
for ( ; i < = 287 ; + + i ) stbi__zdefault_length [ i ] = 8 ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:27:37 +04:00
for ( i = 0 ; i < = 31 ; + + i ) stbi__zdefault_distance [ i ] = 5 ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:27:37 +04:00
static int stbi__parse_zlib ( stbi__zbuf * a , int parse_header )
2014-05-31 15:49:43 +04:00
{
int final , type ;
if ( parse_header )
2014-05-31 17:27:37 +04:00
if ( ! stbi__parse_zlib_header ( a ) ) return 0 ;
2014-05-31 15:49:43 +04:00
a - > num_bits = 0 ;
a - > code_buffer = 0 ;
do {
2014-05-31 17:27:37 +04:00
final = stbi__zreceive ( a , 1 ) ;
type = stbi__zreceive ( a , 2 ) ;
2014-05-31 15:49:43 +04:00
if ( type = = 0 ) {
2014-05-31 17:27:37 +04:00
if ( ! stbi__parse_uncomperssed_block ( a ) ) return 0 ;
2014-05-31 15:49:43 +04:00
} else if ( type = = 3 ) {
return 0 ;
} else {
if ( type = = 1 ) {
// use fixed code lengths
2014-05-31 17:27:37 +04:00
if ( ! stbi__zdefault_distance [ 31 ] ) stbi__init_zdefaults ( ) ;
if ( ! stbi__zbuild_huffman ( & a - > z_length , stbi__zdefault_length , 288 ) ) return 0 ;
if ( ! stbi__zbuild_huffman ( & a - > z_distance , stbi__zdefault_distance , 32 ) ) return 0 ;
2014-05-31 15:49:43 +04:00
} else {
2014-05-31 17:27:37 +04:00
if ( ! stbi__compute_huffman_codes ( a ) ) return 0 ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:27:37 +04:00
if ( ! stbi__parse_huffman_block ( a ) ) return 0 ;
2014-05-31 15:49:43 +04:00
}
} while ( ! final ) ;
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__do_zlib ( stbi__zbuf * a , char * obuf , int olen , int exp , int parse_header )
2014-05-31 15:49:43 +04:00
{
a - > zout_start = obuf ;
a - > zout = obuf ;
a - > zout_end = obuf + olen ;
a - > z_expandable = exp ;
2014-05-31 17:27:37 +04:00
return stbi__parse_zlib ( a , parse_header ) ;
2014-05-31 15:49:43 +04:00
}
STBIDEF char * stbi_zlib_decode_malloc_guesssize ( const char * buffer , int len , int initial_size , int * outlen )
{
2014-05-31 17:27:37 +04:00
stbi__zbuf a ;
2014-08-08 02:46:45 +04:00
char * p = ( char * ) stbi__malloc ( initial_size ) ;
2014-05-31 15:49:43 +04:00
if ( p = = NULL ) return NULL ;
2014-05-31 17:55:48 +04:00
a . zbuffer = ( stbi_uc * ) buffer ;
a . zbuffer_end = ( stbi_uc * ) buffer + len ;
2014-05-31 17:27:37 +04:00
if ( stbi__do_zlib ( & a , p , initial_size , 1 , 1 ) ) {
2014-05-31 15:49:43 +04:00
if ( outlen ) * outlen = ( int ) ( a . zout - a . zout_start ) ;
return a . zout_start ;
} else {
free ( a . zout_start ) ;
return NULL ;
}
}
STBIDEF char * stbi_zlib_decode_malloc ( char const * buffer , int len , int * outlen )
{
return stbi_zlib_decode_malloc_guesssize ( buffer , len , 16384 , outlen ) ;
}
STBIDEF char * stbi_zlib_decode_malloc_guesssize_headerflag ( const char * buffer , int len , int initial_size , int * outlen , int parse_header )
{
2014-05-31 17:27:37 +04:00
stbi__zbuf a ;
2014-08-08 02:46:45 +04:00
char * p = ( char * ) stbi__malloc ( initial_size ) ;
2014-05-31 15:49:43 +04:00
if ( p = = NULL ) return NULL ;
2014-05-31 17:55:48 +04:00
a . zbuffer = ( stbi_uc * ) buffer ;
a . zbuffer_end = ( stbi_uc * ) buffer + len ;
2014-05-31 17:27:37 +04:00
if ( stbi__do_zlib ( & a , p , initial_size , 1 , parse_header ) ) {
2014-05-31 15:49:43 +04:00
if ( outlen ) * outlen = ( int ) ( a . zout - a . zout_start ) ;
return a . zout_start ;
} else {
free ( a . zout_start ) ;
return NULL ;
}
}
STBIDEF int stbi_zlib_decode_buffer ( char * obuffer , int olen , char const * ibuffer , int ilen )
{
2014-05-31 17:27:37 +04:00
stbi__zbuf a ;
2014-05-31 17:55:48 +04:00
a . zbuffer = ( stbi_uc * ) ibuffer ;
a . zbuffer_end = ( stbi_uc * ) ibuffer + ilen ;
2014-05-31 17:27:37 +04:00
if ( stbi__do_zlib ( & a , obuffer , olen , 0 , 1 ) )
2014-05-31 15:49:43 +04:00
return ( int ) ( a . zout - a . zout_start ) ;
else
return - 1 ;
}
STBIDEF char * stbi_zlib_decode_noheader_malloc ( char const * buffer , int len , int * outlen )
{
2014-05-31 17:27:37 +04:00
stbi__zbuf a ;
2014-08-08 02:46:45 +04:00
char * p = ( char * ) stbi__malloc ( 16384 ) ;
2014-05-31 15:49:43 +04:00
if ( p = = NULL ) return NULL ;
2014-05-31 17:55:48 +04:00
a . zbuffer = ( stbi_uc * ) buffer ;
a . zbuffer_end = ( stbi_uc * ) buffer + len ;
2014-05-31 17:27:37 +04:00
if ( stbi__do_zlib ( & a , p , 16384 , 1 , 0 ) ) {
2014-05-31 15:49:43 +04:00
if ( outlen ) * outlen = ( int ) ( a . zout - a . zout_start ) ;
return a . zout_start ;
} else {
free ( a . zout_start ) ;
return NULL ;
}
}
STBIDEF int stbi_zlib_decode_noheader_buffer ( char * obuffer , int olen , const char * ibuffer , int ilen )
{
2014-05-31 17:27:37 +04:00
stbi__zbuf a ;
2014-05-31 17:55:48 +04:00
a . zbuffer = ( stbi_uc * ) ibuffer ;
a . zbuffer_end = ( stbi_uc * ) ibuffer + ilen ;
2014-05-31 17:27:37 +04:00
if ( stbi__do_zlib ( & a , obuffer , olen , 0 , 0 ) )
2014-05-31 15:49:43 +04:00
return ( int ) ( a . zout - a . zout_start ) ;
else
return - 1 ;
}
// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
// simple implementation
// - only 8-bit samples
// - no CRC checking
// - allocates lots of intermediate memory
// - avoids problem of streaming data between subsystems
// - avoids explicit window management
// performance
// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
typedef struct
{
stbi__uint32 length ;
stbi__uint32 type ;
2014-05-31 17:27:37 +04:00
} stbi__pngchunk ;
2014-05-31 15:49:43 +04:00
# define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
2014-05-31 17:27:37 +04:00
static stbi__pngchunk stbi__get_chunk_header ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
stbi__pngchunk c ;
2014-05-31 16:40:05 +04:00
c . length = stbi__get32be ( s ) ;
c . type = stbi__get32be ( s ) ;
2014-05-31 15:49:43 +04:00
return c ;
}
2014-05-31 17:27:37 +04:00
static int stbi__check_png_header ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
static stbi_uc png_sig [ 8 ] = { 137 , 80 , 78 , 71 , 13 , 10 , 26 , 10 } ;
2014-05-31 15:49:43 +04:00
int i ;
for ( i = 0 ; i < 8 ; + + i )
2014-06-06 21:15:30 +04:00
if ( stbi__get8 ( s ) ! = png_sig [ i ] ) return stbi__err ( " bad png sig " , " Not a PNG " ) ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
typedef struct
{
2014-05-31 16:38:26 +04:00
stbi__context * s ;
2014-05-31 17:55:48 +04:00
stbi_uc * idata , * expanded , * out ;
2014-05-31 17:27:37 +04:00
} stbi__png ;
2014-05-31 15:49:43 +04:00
enum {
2014-05-31 17:27:37 +04:00
STBI__F_none = 0 , STBI__F_sub = 1 , STBI__F_up = 2 , STBI__F_avg = 3 , STBI__F_paeth = 4 ,
STBI__F_avg_first , STBI__F_paeth_first
2014-05-31 15:49:43 +04:00
} ;
2014-05-31 17:55:48 +04:00
static stbi_uc first_row_filter [ 5 ] =
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
STBI__F_none , STBI__F_sub , STBI__F_none , STBI__F_avg_first , STBI__F_paeth_first
2014-05-31 15:49:43 +04:00
} ;
2014-05-31 17:27:37 +04:00
static int stbi__paeth ( int a , int b , int c )
2014-05-31 15:49:43 +04:00
{
int p = a + b - c ;
int pa = abs ( p - a ) ;
int pb = abs ( p - b ) ;
int pc = abs ( p - c ) ;
if ( pa < = pb & & pa < = pc ) return a ;
if ( pb < = pc ) return b ;
return c ;
}
2014-06-06 21:15:30 +04:00
# define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings
2014-05-31 15:49:43 +04:00
// create the png data from post-deflated data
2014-05-31 17:55:48 +04:00
static int stbi__create_png_image_raw ( stbi__png * a , stbi_uc * raw , stbi__uint32 raw_len , int out_n , stbi__uint32 x , stbi__uint32 y )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
stbi__context * s = a - > s ;
2014-05-31 15:49:43 +04:00
stbi__uint32 i , j , stride = x * out_n ;
int k ;
int img_n = s - > img_n ; // copy it into a local for later
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( out_n = = s - > img_n | | out_n = = s - > img_n + 1 ) ;
2014-08-08 02:46:45 +04:00
a - > out = ( stbi_uc * ) stbi__malloc ( x * y * out_n ) ;
2014-05-31 16:38:26 +04:00
if ( ! a - > out ) return stbi__err ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
if ( s - > img_x = = x & & s - > img_y = = y ) {
2014-05-31 16:38:26 +04:00
if ( raw_len ! = ( img_n * x + 1 ) * y ) return stbi__err ( " not enough pixels " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
} else { // interlaced:
2014-05-31 16:38:26 +04:00
if ( raw_len < ( img_n * x + 1 ) * y ) return stbi__err ( " not enough pixels " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
}
for ( j = 0 ; j < y ; + + j ) {
2014-05-31 17:55:48 +04:00
stbi_uc * cur = a - > out + stride * j ;
stbi_uc * prior = cur - stride ;
2014-05-31 15:49:43 +04:00
int filter = * raw + + ;
2014-05-31 16:38:26 +04:00
if ( filter > 4 ) return stbi__err ( " invalid filter " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
// if first row, use special filter that doesn't sample previous row
if ( j = = 0 ) filter = first_row_filter [ filter ] ;
// handle first pixel explicitly
for ( k = 0 ; k < img_n ; + + k ) {
switch ( filter ) {
2014-05-31 17:27:37 +04:00
case STBI__F_none : cur [ k ] = raw [ k ] ; break ;
case STBI__F_sub : cur [ k ] = raw [ k ] ; break ;
2014-06-06 21:15:30 +04:00
case STBI__F_up : cur [ k ] = STBI__BYTECAST ( raw [ k ] + prior [ k ] ) ; break ;
case STBI__F_avg : cur [ k ] = STBI__BYTECAST ( raw [ k ] + ( prior [ k ] > > 1 ) ) ; break ;
case STBI__F_paeth : cur [ k ] = STBI__BYTECAST ( raw [ k ] + stbi__paeth ( 0 , prior [ k ] , 0 ) ) ; break ;
2014-05-31 17:27:37 +04:00
case STBI__F_avg_first : cur [ k ] = raw [ k ] ; break ;
case STBI__F_paeth_first : cur [ k ] = raw [ k ] ; break ;
2014-05-31 15:49:43 +04:00
}
}
if ( img_n ! = out_n ) cur [ img_n ] = 255 ;
raw + = img_n ;
cur + = out_n ;
prior + = out_n ;
// this is a little gross, so that we don't switch per-pixel or per-component
if ( img_n = = out_n ) {
# define CASE(f) \
case f : \
for ( i = x - 1 ; i > = 1 ; - - i , raw + = img_n , cur + = img_n , prior + = img_n ) \
for ( k = 0 ; k < img_n ; + + k )
switch ( filter ) {
2014-06-06 21:15:30 +04:00
CASE ( STBI__F_none ) cur [ k ] = raw [ k ] ; break ;
CASE ( STBI__F_sub ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + cur [ k - img_n ] ) ; break ;
CASE ( STBI__F_up ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + prior [ k ] ) ; break ;
CASE ( STBI__F_avg ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + ( ( prior [ k ] + cur [ k - img_n ] ) > > 1 ) ) ; break ;
CASE ( STBI__F_paeth ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + stbi__paeth ( cur [ k - img_n ] , prior [ k ] , prior [ k - img_n ] ) ) ; break ;
CASE ( STBI__F_avg_first ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + ( cur [ k - img_n ] > > 1 ) ) ; break ;
CASE ( STBI__F_paeth_first ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + stbi__paeth ( cur [ k - img_n ] , 0 , 0 ) ) ; break ;
2014-05-31 15:49:43 +04:00
}
# undef CASE
} else {
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( img_n + 1 = = out_n ) ;
2014-05-31 15:49:43 +04:00
# define CASE(f) \
case f : \
for ( i = x - 1 ; i > = 1 ; - - i , cur [ img_n ] = 255 , raw + = img_n , cur + = out_n , prior + = out_n ) \
for ( k = 0 ; k < img_n ; + + k )
switch ( filter ) {
2014-06-06 21:15:30 +04:00
CASE ( STBI__F_none ) cur [ k ] = raw [ k ] ; break ;
CASE ( STBI__F_sub ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + cur [ k - out_n ] ) ; break ;
CASE ( STBI__F_up ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + prior [ k ] ) ; break ;
CASE ( STBI__F_avg ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + ( ( prior [ k ] + cur [ k - out_n ] ) > > 1 ) ) ; break ;
CASE ( STBI__F_paeth ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + stbi__paeth ( cur [ k - out_n ] , prior [ k ] , prior [ k - out_n ] ) ) ; break ;
CASE ( STBI__F_avg_first ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + ( cur [ k - out_n ] > > 1 ) ) ; break ;
CASE ( STBI__F_paeth_first ) cur [ k ] = STBI__BYTECAST ( raw [ k ] + stbi__paeth ( cur [ k - out_n ] , 0 , 0 ) ) ; break ;
2014-05-31 15:49:43 +04:00
}
# undef CASE
}
}
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__create_png_image ( stbi__png * a , stbi_uc * raw , stbi__uint32 raw_len , int out_n , int interlaced )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc * final ;
2014-05-31 15:49:43 +04:00
int p ;
if ( ! interlaced )
2014-05-31 17:27:37 +04:00
return stbi__create_png_image_raw ( a , raw , raw_len , out_n , a - > s - > img_x , a - > s - > img_y ) ;
2014-05-31 15:49:43 +04:00
// de-interlacing
2014-08-08 02:46:45 +04:00
final = ( stbi_uc * ) stbi__malloc ( a - > s - > img_x * a - > s - > img_y * out_n ) ;
2014-05-31 15:49:43 +04:00
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 ) {
2014-05-31 17:27:37 +04:00
if ( ! stbi__create_png_image_raw ( a , raw , raw_len , out_n , x , y ) ) {
2014-05-31 15:49:43 +04:00
free ( final ) ;
return 0 ;
}
for ( j = 0 ; j < y ; + + j )
for ( i = 0 ; i < x ; + + i )
memcpy ( final + ( j * yspc [ p ] + yorig [ p ] ) * a - > s - > img_x * out_n + ( i * xspc [ p ] + xorig [ p ] ) * out_n ,
a - > out + ( j * x + i ) * out_n , out_n ) ;
free ( a - > out ) ;
raw + = ( x * out_n + 1 ) * y ;
raw_len - = ( x * out_n + 1 ) * y ;
}
}
a - > out = final ;
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__compute_transparency ( stbi__png * z , stbi_uc tc [ 3 ] , int out_n )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
stbi__context * s = z - > s ;
2014-05-31 15:49:43 +04:00
stbi__uint32 i , pixel_count = s - > img_x * s - > img_y ;
2014-05-31 17:55:48 +04:00
stbi_uc * p = z - > out ;
2014-05-31 15:49:43 +04:00
// compute color-based transparency, assuming we've
// already got 255 as the alpha value in the output
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( out_n = = 2 | | out_n = = 4 ) ;
2014-05-31 15:49:43 +04:00
if ( out_n = = 2 ) {
for ( i = 0 ; i < pixel_count ; + + i ) {
p [ 1 ] = ( p [ 0 ] = = tc [ 0 ] ? 0 : 255 ) ;
p + = 2 ;
}
} else {
for ( i = 0 ; i < pixel_count ; + + i ) {
if ( p [ 0 ] = = tc [ 0 ] & & p [ 1 ] = = tc [ 1 ] & & p [ 2 ] = = tc [ 2 ] )
p [ 3 ] = 0 ;
p + = 4 ;
}
}
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__expand_png_palette ( stbi__png * a , stbi_uc * palette , int len , int pal_img_n )
2014-05-31 15:49:43 +04:00
{
stbi__uint32 i , pixel_count = a - > s - > img_x * a - > s - > img_y ;
2014-05-31 17:55:48 +04:00
stbi_uc * p , * temp_out , * orig = a - > out ;
2014-05-31 15:49:43 +04:00
2014-08-08 02:46:45 +04:00
p = ( stbi_uc * ) stbi__malloc ( pixel_count * pal_img_n ) ;
2014-05-31 16:38:26 +04:00
if ( p = = NULL ) return stbi__err ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
// between here and free(out) below, exitting 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 ;
}
} else {
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 ] = palette [ n + 3 ] ;
p + = 4 ;
}
}
free ( a - > out ) ;
a - > out = temp_out ;
STBI_NOTUSED ( len ) ;
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__unpremultiply_on_load = 0 ;
static int stbi__de_iphone_flag = 0 ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:27:37 +04:00
STBIDEF void stbi_set_unpremultiply_on_load ( int flag_true_if_should_unpremultiply )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:27:37 +04:00
STBIDEF void stbi_convert_iphone_png_to_rgb ( int flag_true_if_should_convert )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
stbi__de_iphone_flag = flag_true_if_should_convert ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 17:27:37 +04:00
static void stbi__de_iphone ( stbi__png * z )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
stbi__context * s = z - > s ;
2014-05-31 15:49:43 +04:00
stbi__uint32 i , pixel_count = s - > img_x * s - > img_y ;
2014-05-31 17:55:48 +04:00
stbi_uc * p = z - > out ;
2014-05-31 15:49:43 +04:00
if ( s - > img_out_n = = 3 ) { // convert bgr to rgb
for ( i = 0 ; i < pixel_count ; + + i ) {
2014-05-31 17:55:48 +04:00
stbi_uc t = p [ 0 ] ;
2014-05-31 15:49:43 +04:00
p [ 0 ] = p [ 2 ] ;
p [ 2 ] = t ;
p + = 3 ;
}
} else {
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( s - > img_out_n = = 4 ) ;
2014-05-31 17:27:37 +04:00
if ( stbi__unpremultiply_on_load ) {
2014-05-31 15:49:43 +04:00
// convert bgr to rgb and unpremultiply
for ( i = 0 ; i < pixel_count ; + + i ) {
2014-05-31 17:55:48 +04:00
stbi_uc a = p [ 3 ] ;
stbi_uc t = p [ 0 ] ;
2014-05-31 15:49:43 +04:00
if ( a ) {
p [ 0 ] = p [ 2 ] * 255 / a ;
p [ 1 ] = p [ 1 ] * 255 / a ;
p [ 2 ] = t * 255 / a ;
} else {
p [ 0 ] = p [ 2 ] ;
p [ 2 ] = t ;
}
p + = 4 ;
}
} else {
// convert bgr to rgb
for ( i = 0 ; i < pixel_count ; + + i ) {
2014-05-31 17:55:48 +04:00
stbi_uc t = p [ 0 ] ;
2014-05-31 15:49:43 +04:00
p [ 0 ] = p [ 2 ] ;
p [ 2 ] = t ;
p + = 4 ;
}
}
}
}
2014-05-31 17:27:37 +04:00
static int stbi__parse_png_file ( stbi__png * z , int scan , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc palette [ 1024 ] , pal_img_n = 0 ;
stbi_uc has_trans = 0 , tc [ 3 ] ;
2014-05-31 15:49:43 +04:00
stbi__uint32 ioff = 0 , idata_limit = 0 , i , pal_len = 0 ;
2014-06-03 19:45:34 +04:00
int first = 1 , k , interlace = 0 , is_iphone = 0 ;
2014-05-31 16:38:26 +04:00
stbi__context * s = z - > s ;
2014-05-31 15:49:43 +04:00
z - > expanded = NULL ;
z - > idata = NULL ;
z - > out = NULL ;
2014-05-31 17:27:37 +04:00
if ( ! stbi__check_png_header ( s ) ) return 0 ;
2014-05-31 15:49:43 +04:00
if ( scan = = SCAN_type ) return 1 ;
for ( ; ; ) {
2014-05-31 17:27:37 +04:00
stbi__pngchunk c = stbi__get_chunk_header ( s ) ;
2014-05-31 15:49:43 +04:00
switch ( c . type ) {
case PNG_TYPE ( ' C ' , ' g ' , ' B ' , ' I ' ) :
2014-06-03 19:45:34 +04:00
is_iphone = 1 ;
2014-05-31 16:40:05 +04:00
stbi__skip ( s , c . length ) ;
2014-05-31 15:49:43 +04:00
break ;
case PNG_TYPE ( ' I ' , ' H ' , ' D ' , ' R ' ) : {
int depth , color , comp , filter ;
2014-05-31 16:38:26 +04:00
if ( ! first ) return stbi__err ( " multiple IHDR " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
first = 0 ;
2014-05-31 16:38:26 +04:00
if ( c . length ! = 13 ) return stbi__err ( " bad IHDR len " , " Corrupt PNG " ) ;
2014-05-31 16:40:05 +04:00
s - > img_x = stbi__get32be ( s ) ; if ( s - > img_x > ( 1 < < 24 ) ) return stbi__err ( " too large " , " Very large image (corrupt?) " ) ;
s - > img_y = stbi__get32be ( s ) ; if ( s - > img_y > ( 1 < < 24 ) ) return stbi__err ( " too large " , " Very large image (corrupt?) " ) ;
depth = stbi__get8 ( s ) ; if ( depth ! = 8 ) return stbi__err ( " 8bit only " , " PNG not supported: 8-bit only " ) ;
color = stbi__get8 ( s ) ; if ( color > 6 ) return stbi__err ( " bad ctype " , " Corrupt PNG " ) ;
2014-05-31 16:38:26 +04:00
if ( color = = 3 ) pal_img_n = 3 ; else if ( color & 1 ) return stbi__err ( " bad ctype " , " Corrupt PNG " ) ;
2014-05-31 16:40:05 +04:00
comp = stbi__get8 ( s ) ; if ( comp ) return stbi__err ( " bad comp method " , " Corrupt PNG " ) ;
filter = stbi__get8 ( s ) ; if ( filter ) return stbi__err ( " bad filter method " , " Corrupt PNG " ) ;
interlace = stbi__get8 ( s ) ; if ( interlace > 1 ) return stbi__err ( " bad interlace method " , " Corrupt PNG " ) ;
2014-05-31 16:38:26 +04:00
if ( ! s - > img_x | | ! s - > img_y ) return stbi__err ( " 0-pixel image " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( ! pal_img_n ) {
s - > img_n = ( color & 2 ? 3 : 1 ) + ( color & 4 ? 1 : 0 ) ;
2014-06-26 02:29:29 +04:00
if ( ( 1 < < 30 ) / s - > img_x / s - > img_n < s - > img_y ) return stbi__err ( " too large " , " Image too large to decode " ) ;
2014-05-31 15:49:43 +04:00
if ( scan = = SCAN_header ) return 1 ;
} else {
// if paletted, then pal_n is our final components, and
// img_n is # components to decompress/filter.
s - > img_n = 1 ;
2014-05-31 16:38:26 +04:00
if ( ( 1 < < 30 ) / s - > img_x / 4 < s - > img_y ) return stbi__err ( " too large " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
// if SCAN_header, have to scan to see if we have a tRNS
}
break ;
}
case PNG_TYPE ( ' P ' , ' L ' , ' T ' , ' E ' ) : {
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__err ( " first not IHDR " , " Corrupt PNG " ) ;
if ( c . length > 256 * 3 ) return stbi__err ( " invalid PLTE " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
pal_len = c . length / 3 ;
2014-05-31 16:38:26 +04:00
if ( pal_len * 3 ! = c . length ) return stbi__err ( " invalid PLTE " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < pal_len ; + + i ) {
2014-06-06 21:15:30 +04:00
palette [ i * 4 + 0 ] = stbi__get8 ( s ) ;
palette [ i * 4 + 1 ] = stbi__get8 ( s ) ;
palette [ i * 4 + 2 ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
palette [ i * 4 + 3 ] = 255 ;
}
break ;
}
case PNG_TYPE ( ' t ' , ' R ' , ' N ' , ' S ' ) : {
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__err ( " first not IHDR " , " Corrupt PNG " ) ;
if ( z - > idata ) return stbi__err ( " tRNS after IDAT " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( pal_img_n ) {
if ( scan = = SCAN_header ) { s - > img_n = 4 ; return 1 ; }
2014-05-31 16:38:26 +04:00
if ( pal_len = = 0 ) return stbi__err ( " tRNS before PLTE " , " Corrupt PNG " ) ;
if ( c . length > pal_len ) return stbi__err ( " bad tRNS len " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
pal_img_n = 4 ;
for ( i = 0 ; i < c . length ; + + i )
2014-06-06 21:15:30 +04:00
palette [ i * 4 + 3 ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
} else {
2014-05-31 16:38:26 +04:00
if ( ! ( s - > img_n & 1 ) ) return stbi__err ( " tRNS with alpha " , " Corrupt PNG " ) ;
if ( c . length ! = ( stbi__uint32 ) s - > img_n * 2 ) return stbi__err ( " bad tRNS len " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
has_trans = 1 ;
for ( k = 0 ; k < s - > img_n ; + + k )
2014-06-06 21:15:30 +04:00
tc [ k ] = ( stbi_uc ) ( stbi__get16be ( s ) & 255 ) ; // non 8-bit images will be larger
2014-05-31 15:49:43 +04:00
}
break ;
}
case PNG_TYPE ( ' I ' , ' D ' , ' A ' , ' T ' ) : {
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__err ( " first not IHDR " , " Corrupt PNG " ) ;
if ( pal_img_n & & ! pal_len ) return stbi__err ( " no PLTE " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( scan = = SCAN_header ) { s - > img_n = pal_img_n ; return 1 ; }
if ( ioff + c . length > idata_limit ) {
2014-05-31 17:55:48 +04:00
stbi_uc * p ;
2014-05-31 15:49:43 +04:00
if ( idata_limit = = 0 ) idata_limit = c . length > 4096 ? c . length : 4096 ;
while ( ioff + c . length > idata_limit )
idata_limit * = 2 ;
2014-05-31 17:55:48 +04:00
p = ( stbi_uc * ) realloc ( z - > idata , idata_limit ) ; if ( p = = NULL ) return stbi__err ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
z - > idata = p ;
}
2014-05-31 16:40:05 +04:00
if ( ! stbi__getn ( s , z - > idata + ioff , c . length ) ) return stbi__err ( " outofdata " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
ioff + = c . length ;
break ;
}
case PNG_TYPE ( ' I ' , ' E ' , ' N ' , ' D ' ) : {
stbi__uint32 raw_len ;
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__err ( " first not IHDR " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( scan ! = SCAN_load ) return 1 ;
2014-05-31 16:38:26 +04:00
if ( z - > idata = = NULL ) return stbi__err ( " no IDAT " , " Corrupt PNG " ) ;
2014-06-03 19:45:34 +04:00
z - > expanded = ( stbi_uc * ) stbi_zlib_decode_malloc_guesssize_headerflag ( ( char * ) z - > idata , ioff , 16384 , ( int * ) & raw_len , ! is_iphone ) ;
2014-05-31 15:49:43 +04:00
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 )
s - > img_out_n = s - > img_n + 1 ;
else
s - > img_out_n = s - > img_n ;
2014-05-31 17:27:37 +04:00
if ( ! stbi__create_png_image ( z , z - > expanded , raw_len , s - > img_out_n , interlace ) ) return 0 ;
2014-05-31 15:49:43 +04:00
if ( has_trans )
2014-05-31 17:27:37 +04:00
if ( ! stbi__compute_transparency ( z , tc , s - > img_out_n ) ) return 0 ;
2014-06-03 19:45:34 +04:00
if ( is_iphone & & stbi__de_iphone_flag & & s - > img_out_n > 2 )
2014-05-31 17:27:37 +04:00
stbi__de_iphone ( z ) ;
2014-05-31 15:49:43 +04:00
if ( pal_img_n ) {
// pal_img_n == 3 or 4
s - > img_n = pal_img_n ; // record the actual colors we had
s - > img_out_n = pal_img_n ;
if ( req_comp > = 3 ) s - > img_out_n = req_comp ;
2014-05-31 17:27:37 +04:00
if ( ! stbi__expand_png_palette ( z , palette , pal_len , s - > img_out_n ) )
2014-05-31 15:49:43 +04:00
return 0 ;
}
free ( z - > expanded ) ; z - > expanded = NULL ;
return 1 ;
}
default :
// if critical, fail
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__err ( " first not IHDR " , " Corrupt PNG " ) ;
2014-05-31 15:49:43 +04:00
if ( ( c . type & ( 1 < < 29 ) ) = = 0 ) {
# ifndef STBI_NO_FAILURE_STRINGS
// not threadsafe
2014-06-06 21:15:30 +04:00
static char invalid_chunk [ ] = " XXXX PNG chunk not known " ;
invalid_chunk [ 0 ] = STBI__BYTECAST ( c . type > > 24 ) ;
invalid_chunk [ 1 ] = STBI__BYTECAST ( c . type > > 16 ) ;
invalid_chunk [ 2 ] = STBI__BYTECAST ( c . type > > 8 ) ;
invalid_chunk [ 3 ] = STBI__BYTECAST ( c . type > > 0 ) ;
2014-05-31 15:49:43 +04:00
# endif
2014-06-06 21:15:30 +04:00
return stbi__err ( invalid_chunk , " PNG not supported: unknown PNG chunk type " ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , c . length ) ;
2014-05-31 15:49:43 +04:00
break ;
}
2014-06-06 21:15:30 +04:00
// end of PNG chunk, read and skip CRC
2014-05-31 16:40:05 +04:00
stbi__get32be ( s ) ;
2014-05-31 15:49:43 +04:00
}
}
2014-05-31 17:27:37 +04:00
static unsigned char * stbi__do_png ( stbi__png * p , int * x , int * y , int * n , int req_comp )
2014-05-31 15:49:43 +04:00
{
unsigned char * result = NULL ;
2014-05-31 16:38:26 +04:00
if ( req_comp < 0 | | req_comp > 4 ) return stbi__errpuc ( " bad req_comp " , " Internal error " ) ;
2014-05-31 17:27:37 +04:00
if ( stbi__parse_png_file ( p , SCAN_load , req_comp ) ) {
2014-05-31 15:49:43 +04:00
result = p - > out ;
p - > out = NULL ;
if ( req_comp & & req_comp ! = p - > s - > img_out_n ) {
2014-05-31 16:40:05 +04:00
result = stbi__convert_format ( result , p - > s - > img_out_n , req_comp , p - > s - > img_x , p - > s - > img_y ) ;
2014-05-31 15:49:43 +04:00
p - > s - > img_out_n = req_comp ;
if ( result = = NULL ) return result ;
}
* x = p - > s - > img_x ;
* y = p - > s - > img_y ;
2014-08-27 00:39:53 +04:00
if ( n ) * n = p - > s - > img_out_n ;
2014-05-31 15:49:43 +04:00
}
free ( p - > out ) ; p - > out = NULL ;
free ( p - > expanded ) ; p - > expanded = NULL ;
free ( p - > idata ) ; p - > idata = NULL ;
return result ;
}
2014-05-31 16:38:26 +04:00
static unsigned char * stbi__png_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
stbi__png p ;
2014-05-31 15:49:43 +04:00
p . s = s ;
2014-05-31 17:27:37 +04:00
return stbi__do_png ( & p , x , y , comp , req_comp ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:38:26 +04:00
static int stbi__png_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
int r ;
2014-05-31 17:27:37 +04:00
r = stbi__check_png_header ( s ) ;
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
2014-05-31 17:27:37 +04:00
static int stbi__png_info_raw ( stbi__png * p , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
if ( ! stbi__parse_png_file ( p , SCAN_header , 0 ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( p - > s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
if ( x ) * x = p - > s - > img_x ;
if ( y ) * y = p - > s - > img_y ;
if ( comp ) * comp = p - > s - > img_n ;
return 1 ;
}
2014-05-31 17:27:37 +04:00
static int stbi__png_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:27:37 +04:00
stbi__png p ;
2014-05-31 15:49:43 +04:00
p . s = s ;
2014-05-31 17:27:37 +04:00
return stbi__png_info_raw ( & p , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
}
// Microsoft/Windows BMP image
2014-06-15 08:57:03 +04:00
static int stbi__bmp_test_raw ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int r ;
2014-05-31 15:49:43 +04:00
int sz ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' B ' ) return 0 ;
if ( stbi__get8 ( s ) ! = ' M ' ) return 0 ;
stbi__get32le ( s ) ; // discard filesize
stbi__get16le ( s ) ; // discard reserved
stbi__get16le ( s ) ; // discard reserved
stbi__get32le ( s ) ; // discard data offset
sz = stbi__get32le ( s ) ;
2014-06-15 08:47:41 +04:00
r = ( sz = = 12 | | sz = = 40 | | sz = = 56 | | sz = = 108 | | sz = = 124 ) ;
2014-06-15 08:57:03 +04:00
return r ;
}
static int stbi__bmp_test ( stbi__context * s )
{
int r = stbi__bmp_test_raw ( s ) ;
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
// returns 0..31 for the highest set bit
2014-05-31 17:55:48 +04:00
static int stbi__high_bit ( unsigned int z )
2014-05-31 15:49:43 +04:00
{
int n = 0 ;
if ( z = = 0 ) return - 1 ;
if ( z > = 0x10000 ) n + = 16 , z > > = 16 ;
if ( z > = 0x00100 ) n + = 8 , z > > = 8 ;
if ( z > = 0x00010 ) n + = 4 , z > > = 4 ;
if ( z > = 0x00004 ) n + = 2 , z > > = 2 ;
if ( z > = 0x00002 ) n + = 1 , z > > = 1 ;
return n ;
}
2014-05-31 17:55:48 +04:00
static int stbi__bitcount ( unsigned int a )
2014-05-31 15:49:43 +04:00
{
a = ( a & 0x55555555 ) + ( ( a > > 1 ) & 0x55555555 ) ; // max 2
a = ( a & 0x33333333 ) + ( ( a > > 2 ) & 0x33333333 ) ; // max 4
a = ( a + ( a > > 4 ) ) & 0x0f0f0f0f ; // max 8 per 4, now 8 bits
a = ( a + ( a > > 8 ) ) ; // max 16 per 8 bits
a = ( a + ( a > > 16 ) ) ; // max 32 per 8 bits
return a & 0xff ;
}
2014-05-31 17:55:48 +04:00
static int stbi__shiftsigned ( int v , int shift , int bits )
2014-05-31 15:49:43 +04:00
{
int result ;
int z = 0 ;
if ( shift < 0 ) v < < = - shift ;
else v > > = shift ;
result = v ;
z = bits ;
while ( z < 8 ) {
result + = v > > z ;
z + = bits ;
}
return result ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__bmp_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc * out ;
2014-05-31 15:49:43 +04:00
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 ;
int bpp , flip_vertically , pad , target , offset , hsz ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' B ' | | stbi__get8 ( s ) ! = ' M ' ) return stbi__errpuc ( " not BMP " , " Corrupt BMP " ) ;
stbi__get32le ( s ) ; // discard filesize
stbi__get16le ( s ) ; // discard reserved
stbi__get16le ( s ) ; // discard reserved
offset = stbi__get32le ( s ) ;
hsz = stbi__get32le ( s ) ;
2014-06-15 08:47:41 +04:00
if ( hsz ! = 12 & & hsz ! = 40 & & hsz ! = 56 & & hsz ! = 108 & & hsz ! = 124 ) return stbi__errpuc ( " unknown BMP " , " BMP type not supported: unknown " ) ;
2014-05-31 15:49:43 +04:00
if ( hsz = = 12 ) {
2014-05-31 16:40:05 +04:00
s - > img_x = stbi__get16le ( s ) ;
s - > img_y = stbi__get16le ( s ) ;
2014-05-31 15:49:43 +04:00
} else {
2014-05-31 16:40:05 +04:00
s - > img_x = stbi__get32le ( s ) ;
s - > img_y = stbi__get32le ( s ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
if ( stbi__get16le ( s ) ! = 1 ) return stbi__errpuc ( " bad BMP " , " bad BMP " ) ;
bpp = stbi__get16le ( s ) ;
2014-05-31 16:38:26 +04:00
if ( bpp = = 1 ) return stbi__errpuc ( " monochrome " , " BMP type not supported: 1-bit " ) ;
2014-05-31 15:49:43 +04:00
flip_vertically = ( ( int ) s - > img_y ) > 0 ;
s - > img_y = abs ( ( int ) s - > img_y ) ;
if ( hsz = = 12 ) {
if ( bpp < 24 )
psize = ( offset - 14 - 24 ) / 3 ;
} else {
2014-05-31 16:40:05 +04:00
compress = stbi__get32le ( s ) ;
2014-05-31 16:38:26 +04:00
if ( compress = = 1 | | compress = = 2 ) return stbi__errpuc ( " BMP RLE " , " BMP type not supported: RLE " ) ;
2014-05-31 16:40:05 +04:00
stbi__get32le ( s ) ; // discard sizeof
stbi__get32le ( s ) ; // discard hres
stbi__get32le ( s ) ; // discard vres
stbi__get32le ( s ) ; // discard colorsused
stbi__get32le ( s ) ; // discard max important
2014-05-31 15:49:43 +04:00
if ( hsz = = 40 | | hsz = = 56 ) {
if ( hsz = = 56 ) {
2014-05-31 16:40:05 +04:00
stbi__get32le ( s ) ;
stbi__get32le ( s ) ;
stbi__get32le ( s ) ;
stbi__get32le ( s ) ;
2014-05-31 15:49:43 +04:00
}
if ( bpp = = 16 | | bpp = = 32 ) {
mr = mg = mb = 0 ;
if ( compress = = 0 ) {
if ( bpp = = 32 ) {
mr = 0xffu < < 16 ;
mg = 0xffu < < 8 ;
mb = 0xffu < < 0 ;
ma = 0xffu < < 24 ;
fake_a = 1 ; // @TODO: check for cases like alpha value is all 0 and switch it to 255
STBI_NOTUSED ( fake_a ) ;
} else {
mr = 31u < < 10 ;
mg = 31u < < 5 ;
mb = 31u < < 0 ;
}
} else if ( compress = = 3 ) {
2014-05-31 16:40:05 +04:00
mr = stbi__get32le ( s ) ;
mg = stbi__get32le ( s ) ;
mb = stbi__get32le ( s ) ;
2014-05-31 15:49:43 +04:00
// not documented, but generated by photoshop and handled by mspaint
if ( mr = = mg & & mg = = mb ) {
// ?!?!?
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad BMP " , " bad BMP " ) ;
2014-05-31 15:49:43 +04:00
}
} else
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad BMP " , " bad BMP " ) ;
2014-05-31 15:49:43 +04:00
}
} else {
2014-07-10 10:35:25 +04:00
STBI_ASSERT ( hsz = = 108 | | hsz = = 124 ) ;
2014-05-31 16:40:05 +04:00
mr = stbi__get32le ( s ) ;
mg = stbi__get32le ( s ) ;
mb = stbi__get32le ( s ) ;
ma = stbi__get32le ( s ) ;
stbi__get32le ( s ) ; // discard color space
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < 12 ; + + i )
2014-05-31 16:40:05 +04:00
stbi__get32le ( s ) ; // discard color space parameters
2014-06-15 08:47:41 +04:00
if ( hsz = = 124 ) {
stbi__get32le ( s ) ; // discard rendering intent
stbi__get32le ( s ) ; // discard offset of profile data
stbi__get32le ( s ) ; // discard size of profile data
stbi__get32le ( s ) ; // discard reserved
}
2014-05-31 15:49:43 +04:00
}
if ( bpp < 16 )
psize = ( offset - 14 - hsz ) > > 2 ;
}
s - > img_n = ma ? 4 : 3 ;
2014-06-26 02:29:29 +04:00
if ( req_comp & & req_comp > = 3 ) // we can directly decode 3 or 4
2014-05-31 15:49:43 +04:00
target = req_comp ;
else
target = s - > img_n ; // if they want monochrome, we'll post-convert
2014-08-08 02:46:45 +04:00
out = ( stbi_uc * ) stbi__malloc ( target * s - > img_x * s - > img_y ) ;
2014-05-31 16:38:26 +04:00
if ( ! out ) return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
if ( bpp < 16 ) {
int z = 0 ;
2014-05-31 16:38:26 +04:00
if ( psize = = 0 | | psize > 256 ) { free ( out ) ; return stbi__errpuc ( " invalid " , " Corrupt BMP " ) ; }
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < psize ; + + i ) {
2014-06-06 21:15:30 +04:00
pal [ i ] [ 2 ] = stbi__get8 ( s ) ;
pal [ i ] [ 1 ] = stbi__get8 ( s ) ;
pal [ i ] [ 0 ] = stbi__get8 ( s ) ;
2014-05-31 16:40:05 +04:00
if ( hsz ! = 12 ) stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
pal [ i ] [ 3 ] = 255 ;
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , offset - 14 - hsz - psize * ( hsz = = 12 ? 3 : 4 ) ) ;
2014-05-31 15:49:43 +04:00
if ( bpp = = 4 ) width = ( s - > img_x + 1 ) > > 1 ;
else if ( bpp = = 8 ) width = s - > img_x ;
2014-05-31 16:38:26 +04:00
else { free ( out ) ; return stbi__errpuc ( " bad bpp " , " Corrupt BMP " ) ; }
2014-05-31 15:49:43 +04:00
pad = ( - width ) & 3 ;
for ( j = 0 ; j < ( int ) s - > img_y ; + + j ) {
for ( i = 0 ; i < ( int ) s - > img_x ; i + = 2 ) {
2014-05-31 16:40:05 +04:00
int v = stbi__get8 ( s ) , v2 = 0 ;
2014-05-31 15:49:43 +04:00
if ( bpp = = 4 ) {
v2 = v & 15 ;
v > > = 4 ;
}
out [ z + + ] = pal [ v ] [ 0 ] ;
out [ z + + ] = pal [ v ] [ 1 ] ;
out [ z + + ] = pal [ v ] [ 2 ] ;
if ( target = = 4 ) out [ z + + ] = 255 ;
if ( i + 1 = = ( int ) s - > img_x ) break ;
2014-05-31 16:40:05 +04:00
v = ( bpp = = 8 ) ? stbi__get8 ( s ) : v2 ;
2014-05-31 15:49:43 +04:00
out [ z + + ] = pal [ v ] [ 0 ] ;
out [ z + + ] = pal [ v ] [ 1 ] ;
out [ z + + ] = pal [ v ] [ 2 ] ;
if ( target = = 4 ) out [ z + + ] = 255 ;
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , pad ) ;
2014-05-31 15:49:43 +04:00
}
} else {
int rshift = 0 , gshift = 0 , bshift = 0 , ashift = 0 , rcount = 0 , gcount = 0 , bcount = 0 , acount = 0 ;
int z = 0 ;
int easy = 0 ;
2014-05-31 16:40:05 +04:00
stbi__skip ( s , offset - 14 - hsz ) ;
2014-05-31 15:49:43 +04:00
if ( bpp = = 24 ) width = 3 * s - > img_x ;
else if ( bpp = = 16 ) width = 2 * s - > img_x ;
else /* bpp = 32 and pad = 0 */ width = 0 ;
pad = ( - width ) & 3 ;
if ( bpp = = 24 ) {
easy = 1 ;
} else if ( bpp = = 32 ) {
if ( mb = = 0xff & & mg = = 0xff00 & & mr = = 0x00ff0000 & & ma = = 0xff000000 )
easy = 2 ;
}
if ( ! easy ) {
2014-05-31 16:38:26 +04:00
if ( ! mr | | ! mg | | ! mb ) { free ( out ) ; return stbi__errpuc ( " bad masks " , " Corrupt BMP " ) ; }
2014-05-31 15:49:43 +04:00
// right shift amt to put high bit in position #7
2014-05-31 17:55:48 +04:00
rshift = stbi__high_bit ( mr ) - 7 ; rcount = stbi__bitcount ( mr ) ;
gshift = stbi__high_bit ( mg ) - 7 ; gcount = stbi__bitcount ( mg ) ;
bshift = stbi__high_bit ( mb ) - 7 ; bcount = stbi__bitcount ( mb ) ;
ashift = stbi__high_bit ( ma ) - 7 ; acount = stbi__bitcount ( ma ) ;
2014-05-31 15:49:43 +04:00
}
for ( j = 0 ; j < ( int ) s - > img_y ; + + j ) {
if ( easy ) {
for ( i = 0 ; i < ( int ) s - > img_x ; + + i ) {
2014-06-06 21:15:30 +04:00
unsigned char a ;
out [ z + 2 ] = stbi__get8 ( s ) ;
out [ z + 1 ] = stbi__get8 ( s ) ;
out [ z + 0 ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
z + = 3 ;
2014-05-31 16:40:05 +04:00
a = ( easy = = 2 ? stbi__get8 ( s ) : 255 ) ;
2014-06-06 21:15:30 +04:00
if ( target = = 4 ) out [ z + + ] = a ;
2014-05-31 15:49:43 +04:00
}
} else {
for ( i = 0 ; i < ( int ) s - > img_x ; + + i ) {
2014-05-31 16:40:05 +04:00
stbi__uint32 v = ( stbi__uint32 ) ( bpp = = 16 ? stbi__get16le ( s ) : stbi__get32le ( s ) ) ;
2014-05-31 15:49:43 +04:00
int a ;
2014-06-06 21:15:30 +04:00
out [ z + + ] = STBI__BYTECAST ( stbi__shiftsigned ( v & mr , rshift , rcount ) ) ;
out [ z + + ] = STBI__BYTECAST ( stbi__shiftsigned ( v & mg , gshift , gcount ) ) ;
out [ z + + ] = STBI__BYTECAST ( stbi__shiftsigned ( v & mb , bshift , bcount ) ) ;
2014-05-31 17:55:48 +04:00
a = ( ma ? stbi__shiftsigned ( v & ma , ashift , acount ) : 255 ) ;
2014-06-06 21:15:30 +04:00
if ( target = = 4 ) out [ z + + ] = STBI__BYTECAST ( a ) ;
2014-05-31 15:49:43 +04:00
}
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , pad ) ;
2014-05-31 15:49:43 +04:00
}
}
if ( flip_vertically ) {
stbi_uc t ;
for ( j = 0 ; j < ( int ) s - > img_y > > 1 ; + + j ) {
stbi_uc * p1 = out + j * s - > img_x * target ;
stbi_uc * p2 = out + ( s - > img_y - 1 - j ) * s - > img_x * target ;
for ( i = 0 ; i < ( int ) s - > img_x * target ; + + i ) {
t = p1 [ i ] , p1 [ i ] = p2 [ i ] , p2 [ i ] = t ;
}
}
}
if ( req_comp & & req_comp ! = target ) {
2014-05-31 16:40:05 +04:00
out = stbi__convert_format ( out , target , req_comp , s - > img_x , s - > img_y ) ;
if ( out = = NULL ) return out ; // stbi__convert_format frees input on failure
2014-05-31 15:49:43 +04:00
}
* x = s - > img_x ;
* y = s - > img_y ;
if ( comp ) * comp = s - > img_n ;
return out ;
}
// Targa Truevision - TGA
// by Jonathan Dummer
2014-05-31 17:55:48 +04:00
static int stbi__tga_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
int tga_w , tga_h , tga_comp ;
int sz ;
2014-06-06 21:15:30 +04:00
stbi__get8 ( s ) ; // discard Offset
sz = stbi__get8 ( s ) ; // color type
2014-05-31 15:49:43 +04:00
if ( sz > 1 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ; // only RGB or indexed allowed
}
2014-06-06 21:15:30 +04:00
sz = stbi__get8 ( s ) ; // image type
2014-05-31 15:49:43 +04:00
// only RGB or grey allowed, +/- RLE
if ( ( sz ! = 1 ) & & ( sz ! = 2 ) & & ( sz ! = 3 ) & & ( sz ! = 9 ) & & ( sz ! = 10 ) & & ( sz ! = 11 ) ) return 0 ;
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 9 ) ;
tga_w = stbi__get16le ( s ) ;
2014-05-31 15:49:43 +04:00
if ( tga_w < 1 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ; // test width
}
2014-05-31 16:40:05 +04:00
tga_h = stbi__get16le ( s ) ;
2014-05-31 15:49:43 +04:00
if ( tga_h < 1 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ; // test height
}
2014-05-31 16:40:05 +04:00
sz = stbi__get8 ( s ) ; // bits per pixel
2014-05-31 15:49:43 +04:00
// only RGB or RGBA or grey allowed
if ( ( sz ! = 8 ) & & ( sz ! = 16 ) & & ( sz ! = 24 ) & & ( sz ! = 32 ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
tga_comp = sz ;
if ( x ) * x = tga_w ;
if ( y ) * y = tga_h ;
if ( comp ) * comp = tga_comp / 8 ;
return 1 ; // seems to have passed everything
}
2014-05-31 17:55:48 +04:00
static int stbi__tga_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int res ;
2014-05-31 15:49:43 +04:00
int sz ;
2014-06-06 21:15:30 +04:00
stbi__get8 ( s ) ; // discard Offset
sz = stbi__get8 ( s ) ; // color type
2014-05-31 15:49:43 +04:00
if ( sz > 1 ) return 0 ; // only RGB or indexed allowed
2014-06-06 21:15:30 +04:00
sz = stbi__get8 ( s ) ; // image type
2014-05-31 15:49:43 +04:00
if ( ( sz ! = 1 ) & & ( sz ! = 2 ) & & ( sz ! = 3 ) & & ( sz ! = 9 ) & & ( sz ! = 10 ) & & ( sz ! = 11 ) ) return 0 ; // only RGB or grey allowed, +/- RLE
2014-05-31 16:40:05 +04:00
stbi__get16be ( s ) ; // discard palette start
stbi__get16be ( s ) ; // discard palette length
stbi__get8 ( s ) ; // discard bits per palette color entry
stbi__get16be ( s ) ; // discard x origin
stbi__get16be ( s ) ; // discard y origin
if ( stbi__get16be ( s ) < 1 ) return 0 ; // test width
if ( stbi__get16be ( s ) < 1 ) return 0 ; // test height
sz = stbi__get8 ( s ) ; // bits per pixel
2014-05-31 17:55:48 +04:00
if ( ( sz ! = 8 ) & & ( sz ! = 16 ) & & ( sz ! = 24 ) & & ( sz ! = 32 ) )
res = 0 ;
else
res = 1 ;
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return res ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__tga_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
// read in the TGA header stuff
2014-06-06 21:15:30 +04:00
int tga_offset = stbi__get8 ( s ) ;
int tga_indexed = stbi__get8 ( s ) ;
int tga_image_type = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
int tga_is_RLE = 0 ;
2014-05-31 16:40:05 +04:00
int tga_palette_start = stbi__get16le ( s ) ;
int tga_palette_len = stbi__get16le ( s ) ;
2014-06-06 21:15:30 +04:00
int tga_palette_bits = stbi__get8 ( s ) ;
2014-05-31 16:40:05 +04:00
int tga_x_origin = stbi__get16le ( s ) ;
int tga_y_origin = stbi__get16le ( s ) ;
int tga_width = stbi__get16le ( s ) ;
int tga_height = stbi__get16le ( s ) ;
2014-06-06 21:15:30 +04:00
int tga_bits_per_pixel = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
int tga_comp = tga_bits_per_pixel / 8 ;
2014-06-06 21:15:30 +04:00
int tga_inverted = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
// image data
unsigned char * tga_data ;
unsigned char * tga_palette = NULL ;
int i , j ;
unsigned char raw_data [ 4 ] ;
int RLE_count = 0 ;
int RLE_repeating = 0 ;
int read_next_pixel = 1 ;
// do a tiny bit of precessing
if ( tga_image_type > = 8 )
{
tga_image_type - = 8 ;
tga_is_RLE = 1 ;
}
/* int tga_alpha_bits = tga_inverted & 15; */
tga_inverted = 1 - ( ( tga_inverted > > 5 ) & 1 ) ;
// error check
if ( //(tga_indexed) ||
( tga_width < 1 ) | | ( tga_height < 1 ) | |
( tga_image_type < 1 ) | | ( tga_image_type > 3 ) | |
( ( tga_bits_per_pixel ! = 8 ) & & ( tga_bits_per_pixel ! = 16 ) & &
( tga_bits_per_pixel ! = 24 ) & & ( tga_bits_per_pixel ! = 32 ) )
)
{
return NULL ; // we don't report this as a bad TGA because we don't even know if it's TGA
}
// If I'm paletted, then I'll use the number of bits from the palette
if ( tga_indexed )
{
tga_comp = tga_palette_bits / 8 ;
}
// tga info
* x = tga_width ;
* y = tga_height ;
if ( comp ) * comp = tga_comp ;
2014-08-08 02:46:45 +04:00
tga_data = ( unsigned char * ) stbi__malloc ( tga_width * tga_height * tga_comp ) ;
2014-05-31 16:38:26 +04:00
if ( ! tga_data ) return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
2014-06-15 23:49:32 +04:00
// skip to the data's starting position (offset usually = 0)
2014-05-31 16:40:05 +04:00
stbi__skip ( s , tga_offset ) ;
2014-05-31 15:49:43 +04:00
if ( ! tga_indexed & & ! tga_is_RLE ) {
for ( i = 0 ; i < tga_height ; + + i ) {
int y = tga_inverted ? tga_height - i - 1 : i ;
2014-05-31 17:55:48 +04:00
stbi_uc * tga_row = tga_data + y * tga_width * tga_comp ;
2014-05-31 16:40:05 +04:00
stbi__getn ( s , tga_row , tga_width * tga_comp ) ;
2014-05-31 15:49:43 +04:00
}
} else {
// do I need to load a palette?
if ( tga_indexed )
{
2014-06-15 23:49:32 +04:00
// any data to skip? (offset usually = 0)
2014-05-31 16:40:05 +04:00
stbi__skip ( s , tga_palette_start ) ;
2014-05-31 15:49:43 +04:00
// load the palette
2014-08-08 02:46:45 +04:00
tga_palette = ( unsigned char * ) stbi__malloc ( tga_palette_len * tga_palette_bits / 8 ) ;
2014-05-31 15:49:43 +04:00
if ( ! tga_palette ) {
free ( tga_data ) ;
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
if ( ! stbi__getn ( s , tga_palette , tga_palette_len * tga_palette_bits / 8 ) ) {
2014-05-31 15:49:43 +04:00
free ( tga_data ) ;
free ( tga_palette ) ;
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad palette " , " Corrupt TGA " ) ;
2014-05-31 15:49:43 +04:00
}
}
// load the data
for ( i = 0 ; i < tga_width * tga_height ; + + i )
{
2014-05-31 17:27:37 +04:00
// if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
2014-05-31 15:49:43 +04:00
if ( tga_is_RLE )
{
if ( RLE_count = = 0 )
{
// yep, get the next byte as a RLE command
2014-06-06 21:15:30 +04:00
int RLE_cmd = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
RLE_count = 1 + ( RLE_cmd & 127 ) ;
RLE_repeating = RLE_cmd > > 7 ;
read_next_pixel = 1 ;
} else if ( ! RLE_repeating )
{
read_next_pixel = 1 ;
}
} else
{
read_next_pixel = 1 ;
}
// OK, if I need to read a pixel, do it now
if ( read_next_pixel )
{
// load however much data we did have
if ( tga_indexed )
{
// read in 1 byte, then perform the lookup
2014-06-06 21:15:30 +04:00
int pal_idx = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( pal_idx > = tga_palette_len )
{
// invalid index
pal_idx = 0 ;
}
pal_idx * = tga_bits_per_pixel / 8 ;
for ( j = 0 ; j * 8 < tga_bits_per_pixel ; + + j )
{
raw_data [ j ] = tga_palette [ pal_idx + j ] ;
}
} else
{
// read in the data raw
for ( j = 0 ; j * 8 < tga_bits_per_pixel ; + + j )
{
2014-06-06 21:15:30 +04:00
raw_data [ j ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
}
}
// clear the reading flag for the next pixel
read_next_pixel = 0 ;
} // end of reading a pixel
// copy data
for ( j = 0 ; j < tga_comp ; + + j )
tga_data [ i * tga_comp + j ] = raw_data [ j ] ;
// in case we're in RLE mode, keep counting down
- - RLE_count ;
}
// do I need to invert the image?
if ( tga_inverted )
{
for ( j = 0 ; j * 2 < tga_height ; + + j )
{
2014-06-16 00:00:00 +04:00
int index1 = j * tga_width * tga_comp ;
int index2 = ( tga_height - 1 - j ) * tga_width * tga_comp ;
for ( i = tga_width * tga_comp ; i > 0 ; - - i )
2014-05-31 15:49:43 +04:00
{
unsigned char temp = tga_data [ index1 ] ;
tga_data [ index1 ] = tga_data [ index2 ] ;
tga_data [ index2 ] = temp ;
+ + index1 ;
+ + index2 ;
}
}
}
// clear my palette, if I had one
if ( tga_palette ! = NULL )
{
free ( tga_palette ) ;
}
}
// swap RGB
if ( tga_comp > = 3 )
{
unsigned char * tga_pixel = tga_data ;
for ( i = 0 ; i < tga_width * tga_height ; + + i )
{
unsigned char temp = tga_pixel [ 0 ] ;
tga_pixel [ 0 ] = tga_pixel [ 2 ] ;
tga_pixel [ 2 ] = temp ;
tga_pixel + = tga_comp ;
}
}
// convert to target component count
if ( req_comp & & req_comp ! = tga_comp )
2014-05-31 16:40:05 +04:00
tga_data = stbi__convert_format ( tga_data , tga_comp , req_comp , tga_width , tga_height ) ;
2014-05-31 15:49:43 +04:00
// the things I do to get rid of an error message, and yet keep
// Microsoft's C compilers happy... [8^(
tga_palette_start = tga_palette_len = tga_palette_bits =
tga_x_origin = tga_y_origin = 0 ;
// OK, done
return tga_data ;
}
// *************************************************************************************************
// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
2014-05-31 16:38:26 +04:00
static int stbi__psd_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int r = ( stbi__get32be ( s ) = = 0x38425053 ) ;
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__psd_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
int pixelCount ;
int channelCount , compression ;
int channel , i , count , len ;
int w , h ;
2014-05-31 17:55:48 +04:00
stbi_uc * out ;
2014-05-31 15:49:43 +04:00
// Check identifier
2014-05-31 16:40:05 +04:00
if ( stbi__get32be ( s ) ! = 0x38425053 ) // "8BPS"
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " not PSD " , " Corrupt PSD image " ) ;
2014-05-31 15:49:43 +04:00
// Check file type version.
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( s ) ! = 1 )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " wrong version " , " Unsupported version of PSD image " ) ;
2014-05-31 15:49:43 +04:00
// Skip 6 reserved bytes.
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 6 ) ;
2014-05-31 15:49:43 +04:00
// Read the number of channels (R, G, B, A, etc).
2014-05-31 16:40:05 +04:00
channelCount = stbi__get16be ( s ) ;
2014-05-31 15:49:43 +04:00
if ( channelCount < 0 | | channelCount > 16 )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " wrong channel count " , " Unsupported number of channels in PSD image " ) ;
2014-05-31 15:49:43 +04:00
// Read the rows and columns of the image.
2014-05-31 16:40:05 +04:00
h = stbi__get32be ( s ) ;
w = stbi__get32be ( s ) ;
2014-05-31 15:49:43 +04:00
// Make sure the depth is 8 bits.
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( s ) ! = 8 )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " unsupported bit depth " , " PSD bit depth is not 8 bit " ) ;
2014-05-31 15:49:43 +04:00
// Make sure the color mode is RGB.
// Valid options are:
// 0: Bitmap
// 1: Grayscale
// 2: Indexed color
// 3: RGB color
// 4: CMYK color
// 7: Multichannel
// 8: Duotone
// 9: Lab color
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( s ) ! = 3 )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " wrong color format " , " PSD is not in RGB color format " ) ;
2014-05-31 15:49:43 +04:00
// Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
2014-05-31 16:40:05 +04:00
stbi__skip ( s , stbi__get32be ( s ) ) ;
2014-05-31 15:49:43 +04:00
// Skip the image resources. (resolution, pen tool paths, etc)
2014-05-31 16:40:05 +04:00
stbi__skip ( s , stbi__get32be ( s ) ) ;
2014-05-31 15:49:43 +04:00
// Skip the reserved data.
2014-05-31 16:40:05 +04:00
stbi__skip ( s , stbi__get32be ( s ) ) ;
2014-05-31 15:49:43 +04:00
// Find out if the data is compressed.
// Known values:
// 0: no compression
// 1: RLE compressed
2014-05-31 16:40:05 +04:00
compression = stbi__get16be ( s ) ;
2014-05-31 15:49:43 +04:00
if ( compression > 1 )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad compression " , " PSD has an unknown compression format " ) ;
2014-05-31 15:49:43 +04:00
// Create the destination image.
2014-08-08 02:46:45 +04:00
out = ( stbi_uc * ) stbi__malloc ( 4 * w * h ) ;
2014-05-31 16:38:26 +04:00
if ( ! out ) return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
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.
// Else if n is 128, noop.
// Endloop
// The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
2014-06-15 23:49:32 +04:00
// which we're going to just skip.
2014-05-31 16:40:05 +04:00
stbi__skip ( s , h * channelCount * 2 ) ;
2014-05-31 15:49:43 +04:00
// Read the RLE data by channel.
for ( channel = 0 ; channel < 4 ; channel + + ) {
2014-05-31 17:55:48 +04:00
stbi_uc * p ;
2014-05-31 15:49:43 +04:00
p = out + channel ;
if ( channel > = channelCount ) {
// Fill this channel with default data.
for ( i = 0 ; i < pixelCount ; i + + ) * p = ( channel = = 3 ? 255 : 0 ) , p + = 4 ;
} else {
// Read the RLE data.
count = 0 ;
while ( count < pixelCount ) {
2014-05-31 16:40:05 +04:00
len = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( len = = 128 ) {
// No-op.
} else if ( len < 128 ) {
// Copy next len+1 bytes literally.
len + + ;
count + = len ;
while ( len ) {
2014-06-06 21:15:30 +04:00
* p = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
p + = 4 ;
len - - ;
}
} else if ( len > 128 ) {
2014-05-31 17:55:48 +04:00
stbi_uc val ;
2014-05-31 15:49:43 +04:00
// Next -len+1 bytes in the dest are replicated from next source byte.
// (Interpret len as a negative 8-bit int.)
len ^ = 0x0FF ;
len + = 2 ;
2014-06-06 21:15:30 +04:00
val = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
count + = len ;
while ( len ) {
* p = val ;
p + = 4 ;
len - - ;
}
}
}
}
}
} else {
// We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
// where each channel consists of an 8-bit value for each pixel in the image.
// Read the data by channel.
for ( channel = 0 ; channel < 4 ; channel + + ) {
2014-05-31 17:55:48 +04:00
stbi_uc * p ;
2014-05-31 15:49:43 +04:00
p = out + channel ;
if ( channel > channelCount ) {
// Fill this channel with default data.
for ( i = 0 ; i < pixelCount ; i + + ) * p = channel = = 3 ? 255 : 0 , p + = 4 ;
} else {
// Read the data.
for ( i = 0 ; i < pixelCount ; i + + )
2014-06-06 21:15:30 +04:00
* p = stbi__get8 ( s ) , p + = 4 ;
2014-05-31 15:49:43 +04:00
}
}
}
if ( req_comp & & req_comp ! = 4 ) {
2014-05-31 16:40:05 +04:00
out = stbi__convert_format ( out , 4 , req_comp , w , h ) ;
if ( out = = NULL ) return out ; // stbi__convert_format frees input on failure
2014-05-31 15:49:43 +04:00
}
if ( comp ) * comp = channelCount ;
* y = h ;
* x = w ;
return out ;
}
// *************************************************************************************************
// Softimage PIC loader
// by Tom Seddon
//
// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
2014-05-31 17:55:48 +04:00
static int stbi__pic_is4 ( stbi__context * s , const char * str )
2014-05-31 15:49:43 +04:00
{
int i ;
for ( i = 0 ; i < 4 ; + + i )
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ( stbi_uc ) str [ i ] )
2014-05-31 15:49:43 +04:00
return 0 ;
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__pic_test_core ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
int i ;
2014-05-31 17:55:48 +04:00
if ( ! stbi__pic_is4 ( s , " \x53 \x80 \xF6 \x34 " ) )
2014-05-31 15:49:43 +04:00
return 0 ;
for ( i = 0 ; i < 84 ; + + i )
2014-05-31 16:40:05 +04:00
stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
if ( ! stbi__pic_is4 ( s , " PICT " ) )
2014-05-31 15:49:43 +04:00
return 0 ;
return 1 ;
}
typedef struct
{
stbi_uc size , type , channel ;
2014-05-31 17:55:48 +04:00
} stbi__pic_packet ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__readval ( stbi__context * s , int channel , stbi_uc * dest )
2014-05-31 15:49:43 +04:00
{
int mask = 0x80 , i ;
for ( i = 0 ; i < 4 ; + + i , mask > > = 1 ) {
if ( channel & mask ) {
2014-05-31 16:40:05 +04:00
if ( stbi__at_eof ( s ) ) return stbi__errpuc ( " bad file " , " PIC file too short " ) ;
2014-06-06 21:15:30 +04:00
dest [ i ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
}
}
return dest ;
}
2014-05-31 17:55:48 +04:00
static void stbi__copyval ( int channel , stbi_uc * dest , const stbi_uc * src )
2014-05-31 15:49:43 +04:00
{
int mask = 0x80 , i ;
for ( i = 0 ; i < 4 ; + + i , mask > > = 1 )
if ( channel & mask )
dest [ i ] = src [ i ] ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__pic_load_core ( stbi__context * s , int width , int height , int * comp , stbi_uc * result )
2014-05-31 15:49:43 +04:00
{
int act_comp = 0 , num_packets = 0 , y , chained ;
2014-05-31 17:55:48 +04:00
stbi__pic_packet packets [ 10 ] ;
2014-05-31 15:49:43 +04:00
// this will (should...) cater for even some bizarre stuff like having data
// for the same channel in multiple packets.
do {
2014-05-31 17:55:48 +04:00
stbi__pic_packet * packet ;
2014-05-31 15:49:43 +04:00
if ( num_packets = = sizeof ( packets ) / sizeof ( packets [ 0 ] ) )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad format " , " too many packets " ) ;
2014-05-31 15:49:43 +04:00
packet = & packets [ num_packets + + ] ;
2014-05-31 16:40:05 +04:00
chained = stbi__get8 ( s ) ;
2014-06-06 21:15:30 +04:00
packet - > size = stbi__get8 ( s ) ;
packet - > type = stbi__get8 ( s ) ;
packet - > channel = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
act_comp | = packet - > channel ;
2014-05-31 16:40:05 +04:00
if ( stbi__at_eof ( s ) ) return stbi__errpuc ( " bad file " , " file too short (reading packets) " ) ;
2014-05-31 16:38:26 +04:00
if ( packet - > size ! = 8 ) return stbi__errpuc ( " bad format " , " packet isn't 8bpp " ) ;
2014-05-31 15:49:43 +04:00
} while ( chained ) ;
* comp = ( act_comp & 0x10 ? 4 : 3 ) ; // has alpha channel?
for ( y = 0 ; y < height ; + + y ) {
int packet_idx ;
for ( packet_idx = 0 ; packet_idx < num_packets ; + + packet_idx ) {
2014-05-31 17:55:48 +04:00
stbi__pic_packet * packet = & packets [ packet_idx ] ;
2014-05-31 15:49:43 +04:00
stbi_uc * dest = result + y * width * 4 ;
switch ( packet - > type ) {
default :
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad format " , " packet has bad compression type " ) ;
2014-05-31 15:49:43 +04:00
case 0 : { //uncompressed
int x ;
for ( x = 0 ; x < width ; + + x , dest + = 4 )
2014-05-31 17:55:48 +04:00
if ( ! stbi__readval ( s , packet - > channel , dest ) )
2014-05-31 15:49:43 +04:00
return 0 ;
break ;
}
case 1 : //Pure RLE
{
int left = width , i ;
while ( left > 0 ) {
stbi_uc count , value [ 4 ] ;
2014-06-06 21:15:30 +04:00
count = stbi__get8 ( s ) ;
2014-05-31 16:40:05 +04:00
if ( stbi__at_eof ( s ) ) return stbi__errpuc ( " bad file " , " file too short (pure read count) " ) ;
2014-05-31 15:49:43 +04:00
if ( count > left )
2014-05-31 17:55:48 +04:00
count = ( stbi_uc ) left ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
if ( ! stbi__readval ( s , packet - > channel , value ) ) return 0 ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < count ; + + i , dest + = 4 )
2014-05-31 17:55:48 +04:00
stbi__copyval ( packet - > channel , dest , value ) ;
2014-05-31 15:49:43 +04:00
left - = count ;
}
}
break ;
case 2 : { //Mixed RLE
int left = width ;
while ( left > 0 ) {
2014-05-31 16:40:05 +04:00
int count = stbi__get8 ( s ) , i ;
if ( stbi__at_eof ( s ) ) return stbi__errpuc ( " bad file " , " file too short (mixed read count) " ) ;
2014-05-31 15:49:43 +04:00
if ( count > = 128 ) { // Repeated
stbi_uc value [ 4 ] ;
int i ;
if ( count = = 128 )
2014-05-31 16:40:05 +04:00
count = stbi__get16be ( s ) ;
2014-05-31 15:49:43 +04:00
else
count - = 127 ;
if ( count > left )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad file " , " scanline overrun " ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
if ( ! stbi__readval ( s , packet - > channel , value ) )
2014-05-31 15:49:43 +04:00
return 0 ;
for ( i = 0 ; i < count ; + + i , dest + = 4 )
2014-05-31 17:55:48 +04:00
stbi__copyval ( packet - > channel , dest , value ) ;
2014-05-31 15:49:43 +04:00
} else { // Raw
+ + count ;
2014-05-31 16:38:26 +04:00
if ( count > left ) return stbi__errpuc ( " bad file " , " scanline overrun " ) ;
2014-05-31 15:49:43 +04:00
for ( i = 0 ; i < count ; + + i , dest + = 4 )
2014-05-31 17:55:48 +04:00
if ( ! stbi__readval ( s , packet - > channel , dest ) )
2014-05-31 15:49:43 +04:00
return 0 ;
}
left - = count ;
}
break ;
}
}
}
}
return result ;
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__pic_load ( stbi__context * s , int * px , int * py , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
stbi_uc * result ;
int i , x , y ;
for ( i = 0 ; i < 92 ; + + i )
2014-05-31 16:40:05 +04:00
stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
x = stbi__get16be ( s ) ;
y = stbi__get16be ( s ) ;
if ( stbi__at_eof ( s ) ) return stbi__errpuc ( " bad file " , " file too short (pic header) " ) ;
2014-06-26 02:29:29 +04:00
if ( ( 1 < < 28 ) / x < y ) return stbi__errpuc ( " too large " , " Image too large to decode " ) ;
2014-05-31 15:49:43 +04:00
2014-06-06 23:17:39 +04:00
stbi__get32be ( s ) ; //skip `ratio'
stbi__get16be ( s ) ; //skip `fields'
stbi__get16be ( s ) ; //skip `pad'
2014-05-31 15:49:43 +04:00
// intermediate buffer is RGBA
2014-08-08 02:46:45 +04:00
result = ( stbi_uc * ) stbi__malloc ( x * y * 4 ) ;
2014-05-31 15:49:43 +04:00
memset ( result , 0xff , x * y * 4 ) ;
2014-05-31 17:55:48 +04:00
if ( ! stbi__pic_load_core ( s , x , y , comp , result ) ) {
2014-05-31 15:49:43 +04:00
free ( result ) ;
result = 0 ;
}
* px = x ;
* py = y ;
if ( req_comp = = 0 ) req_comp = * comp ;
2014-05-31 16:40:05 +04:00
result = stbi__convert_format ( result , 4 , req_comp , x , y ) ;
2014-05-31 15:49:43 +04:00
return result ;
}
2014-05-31 16:38:26 +04:00
static int stbi__pic_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int r = stbi__pic_test_core ( s ) ;
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
// *************************************************************************************************
// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
2014-05-31 17:55:48 +04:00
typedef struct
{
2014-05-31 15:49:43 +04:00
stbi__int16 prefix ;
2014-05-31 17:55:48 +04:00
stbi_uc first ;
stbi_uc suffix ;
} stbi__gif_lzw ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
typedef struct
2014-05-31 15:49:43 +04:00
{
int w , h ;
stbi_uc * out ; // output buffer (always 4 components)
int flags , bgindex , ratio , transparent , eflags ;
2014-05-31 17:55:48 +04:00
stbi_uc pal [ 256 ] [ 4 ] ;
stbi_uc lpal [ 256 ] [ 4 ] ;
stbi__gif_lzw codes [ 4096 ] ;
stbi_uc * color_table ;
2014-05-31 15:49:43 +04:00
int parse , step ;
int lflags ;
int start_x , start_y ;
int max_x , max_y ;
int cur_x , cur_y ;
int line_size ;
2014-05-31 17:55:48 +04:00
} stbi__gif ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
static int stbi__gif_test_raw ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
int sz ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' G ' | | stbi__get8 ( s ) ! = ' I ' | | stbi__get8 ( s ) ! = ' F ' | | stbi__get8 ( s ) ! = ' 8 ' ) return 0 ;
sz = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( sz ! = ' 9 ' & & sz ! = ' 7 ' ) return 0 ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' a ' ) return 0 ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 16:38:26 +04:00
static int stbi__gif_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int r = stbi__gif_test_raw ( s ) ;
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
2014-05-31 17:55:48 +04:00
static void stbi__gif_parse_colortable ( stbi__context * s , stbi_uc pal [ 256 ] [ 4 ] , int num_entries , int transp )
2014-05-31 15:49:43 +04:00
{
int i ;
for ( i = 0 ; i < num_entries ; + + i ) {
2014-06-06 21:15:30 +04:00
pal [ i ] [ 2 ] = stbi__get8 ( s ) ;
pal [ i ] [ 1 ] = stbi__get8 ( s ) ;
pal [ i ] [ 0 ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
pal [ i ] [ 3 ] = transp ? 0 : 255 ;
}
}
2014-05-31 17:55:48 +04:00
static int stbi__gif_header ( stbi__context * s , stbi__gif * g , int * comp , int is_info )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc version ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' G ' | | stbi__get8 ( s ) ! = ' I ' | | stbi__get8 ( s ) ! = ' F ' | | stbi__get8 ( s ) ! = ' 8 ' )
2014-05-31 16:38:26 +04:00
return stbi__err ( " not GIF " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
2014-06-06 21:15:30 +04:00
version = stbi__get8 ( s ) ;
2014-05-31 16:38:26 +04:00
if ( version ! = ' 7 ' & & version ! = ' 9 ' ) return stbi__err ( " not GIF " , " Corrupt GIF " ) ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' a ' ) return stbi__err ( " not GIF " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
stbi__g_failure_reason = " " ;
2014-05-31 16:40:05 +04:00
g - > w = stbi__get16le ( s ) ;
g - > h = stbi__get16le ( s ) ;
g - > flags = stbi__get8 ( s ) ;
g - > bgindex = stbi__get8 ( s ) ;
g - > ratio = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
g - > transparent = - 1 ;
if ( comp ! = 0 ) * comp = 4 ; // can't actually tell whether it's 3 or 4 until we parse the comments
if ( is_info ) return 1 ;
if ( g - > flags & 0x80 )
2014-05-31 17:55:48 +04:00
stbi__gif_parse_colortable ( s , g - > pal , 2 < < ( g - > flags & 7 ) , - 1 ) ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__gif_info_raw ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi__gif g ;
if ( ! stbi__gif_header ( s , & g , comp , 1 ) ) {
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
if ( x ) * x = g . w ;
if ( y ) * y = g . h ;
return 1 ;
}
2014-05-31 17:55:48 +04:00
static void stbi__out_gif_code ( stbi__gif * g , stbi__uint16 code )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc * p , * c ;
2014-05-31 15:49:43 +04:00
2014-06-26 02:29:29 +04:00
// recurse to decode the prefixes, since the linked-list is backwards,
2014-05-31 15:49:43 +04:00
// and working backwards through an interleaved image would be nasty
if ( g - > codes [ code ] . prefix > = 0 )
2014-05-31 17:55:48 +04:00
stbi__out_gif_code ( g , g - > codes [ code ] . prefix ) ;
2014-05-31 15:49:43 +04:00
if ( g - > cur_y > = g - > max_y ) return ;
p = & g - > out [ g - > cur_x + g - > cur_y ] ;
c = & g - > color_table [ g - > codes [ code ] . suffix * 4 ] ;
if ( c [ 3 ] > = 128 ) {
p [ 0 ] = c [ 2 ] ;
p [ 1 ] = c [ 1 ] ;
p [ 2 ] = c [ 0 ] ;
p [ 3 ] = c [ 3 ] ;
}
g - > cur_x + = 4 ;
if ( g - > cur_x > = g - > max_x ) {
g - > cur_x = g - > start_x ;
g - > cur_y + = g - > step ;
while ( g - > cur_y > = g - > max_y & & g - > parse > 0 ) {
g - > step = ( 1 < < g - > parse ) * g - > line_size ;
g - > cur_y = g - > start_y + ( g - > step > > 1 ) ;
- - g - > parse ;
}
}
}
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__process_gif_raster ( stbi__context * s , stbi__gif * g )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc lzw_cs ;
2014-05-31 15:49:43 +04:00
stbi__int32 len , code ;
stbi__uint32 first ;
stbi__int32 codesize , codemask , avail , oldcode , bits , valid_bits , clear ;
2014-05-31 17:55:48 +04:00
stbi__gif_lzw * p ;
2014-05-31 15:49:43 +04:00
2014-06-06 21:15:30 +04:00
lzw_cs = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
clear = 1 < < lzw_cs ;
first = 1 ;
codesize = lzw_cs + 1 ;
codemask = ( 1 < < codesize ) - 1 ;
bits = 0 ;
valid_bits = 0 ;
for ( code = 0 ; code < clear ; code + + ) {
g - > codes [ code ] . prefix = - 1 ;
2014-05-31 17:55:48 +04:00
g - > codes [ code ] . first = ( stbi_uc ) code ;
g - > codes [ code ] . suffix = ( stbi_uc ) code ;
2014-05-31 15:49:43 +04:00
}
// support no starting clear code
avail = clear + 2 ;
oldcode = - 1 ;
len = 0 ;
for ( ; ; ) {
if ( valid_bits < codesize ) {
if ( len = = 0 ) {
2014-05-31 16:40:05 +04:00
len = stbi__get8 ( s ) ; // start new block
2014-05-31 15:49:43 +04:00
if ( len = = 0 )
return g - > out ;
}
- - len ;
2014-05-31 16:40:05 +04:00
bits | = ( stbi__int32 ) stbi__get8 ( s ) < < valid_bits ;
2014-05-31 15:49:43 +04:00
valid_bits + = 8 ;
} else {
stbi__int32 code = bits & codemask ;
bits > > = codesize ;
valid_bits - = codesize ;
// @OPTIMIZE: is there some way we can accelerate the non-clear path?
if ( code = = clear ) { // clear code
codesize = lzw_cs + 1 ;
codemask = ( 1 < < codesize ) - 1 ;
avail = clear + 2 ;
oldcode = - 1 ;
first = 0 ;
} else if ( code = = clear + 1 ) { // end of stream code
2014-05-31 16:40:05 +04:00
stbi__skip ( s , len ) ;
while ( ( len = stbi__get8 ( s ) ) > 0 )
stbi__skip ( s , len ) ;
2014-05-31 15:49:43 +04:00
return g - > out ;
} else if ( code < = avail ) {
2014-05-31 16:38:26 +04:00
if ( first ) return stbi__errpuc ( " no clear code " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
if ( oldcode > = 0 ) {
p = & g - > codes [ avail + + ] ;
2014-05-31 16:38:26 +04:00
if ( avail > 4096 ) return stbi__errpuc ( " too many codes " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
p - > prefix = ( stbi__int16 ) oldcode ;
p - > first = g - > codes [ oldcode ] . first ;
p - > suffix = ( code = = avail ) ? p - > first : g - > codes [ code ] . first ;
} else if ( code = = avail )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " illegal code in raster " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
stbi__out_gif_code ( g , ( stbi__uint16 ) code ) ;
2014-05-31 15:49:43 +04:00
if ( ( avail & codemask ) = = 0 & & avail < = 0x0FFF ) {
codesize + + ;
codemask = ( 1 < < codesize ) - 1 ;
}
oldcode = code ;
} else {
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " illegal code in raster " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
}
}
}
}
2014-05-31 17:55:48 +04:00
static void stbi__fill_gif_background ( stbi__gif * g )
2014-05-31 15:49:43 +04:00
{
int i ;
2014-05-31 17:55:48 +04:00
stbi_uc * c = g - > pal [ g - > bgindex ] ;
2014-05-31 15:49:43 +04:00
// @OPTIMIZE: write a dword at a time
for ( i = 0 ; i < g - > w * g - > h * 4 ; i + = 4 ) {
2014-05-31 17:55:48 +04:00
stbi_uc * p = & g - > out [ i ] ;
2014-05-31 15:49:43 +04:00
p [ 0 ] = c [ 2 ] ;
p [ 1 ] = c [ 1 ] ;
p [ 2 ] = c [ 0 ] ;
p [ 3 ] = c [ 3 ] ;
}
}
// this function is designed to support animated gifs, although stb_image doesn't support it
2014-05-31 17:55:48 +04:00
static stbi_uc * stbi__gif_load_next ( stbi__context * s , stbi__gif * g , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
int i ;
2014-05-31 17:55:48 +04:00
stbi_uc * old_out = 0 ;
2014-05-31 15:49:43 +04:00
if ( g - > out = = 0 ) {
2014-05-31 17:55:48 +04:00
if ( ! stbi__gif_header ( s , g , comp , 0 ) ) return 0 ; // stbi__g_failure_reason set by stbi__gif_header
2014-08-08 02:46:45 +04:00
g - > out = ( stbi_uc * ) stbi__malloc ( 4 * g - > w * g - > h ) ;
2014-05-31 16:38:26 +04:00
if ( g - > out = = 0 ) return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 17:55:48 +04:00
stbi__fill_gif_background ( g ) ;
2014-05-31 15:49:43 +04:00
} else {
// animated-gif-only path
if ( ( ( g - > eflags & 0x1C ) > > 2 ) = = 3 ) {
old_out = g - > out ;
2014-08-08 02:46:45 +04:00
g - > out = ( stbi_uc * ) stbi__malloc ( 4 * g - > w * g - > h ) ;
2014-05-31 16:38:26 +04:00
if ( g - > out = = 0 ) return stbi__errpuc ( " outofmem " , " Out of memory " ) ;
2014-05-31 15:49:43 +04:00
memcpy ( g - > out , old_out , g - > w * g - > h * 4 ) ;
}
}
for ( ; ; ) {
2014-05-31 16:40:05 +04:00
switch ( stbi__get8 ( s ) ) {
2014-05-31 15:49:43 +04:00
case 0x2C : /* Image Descriptor */
{
stbi__int32 x , y , w , h ;
2014-05-31 17:55:48 +04:00
stbi_uc * o ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
x = stbi__get16le ( s ) ;
y = stbi__get16le ( s ) ;
w = stbi__get16le ( s ) ;
h = stbi__get16le ( s ) ;
2014-05-31 15:49:43 +04:00
if ( ( ( x + w ) > ( g - > w ) ) | | ( ( y + h ) > ( g - > h ) ) )
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " bad Image Descriptor " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
g - > line_size = g - > w * 4 ;
g - > start_x = x * 4 ;
g - > start_y = y * g - > line_size ;
g - > max_x = g - > start_x + w * 4 ;
g - > max_y = g - > start_y + h * g - > line_size ;
g - > cur_x = g - > start_x ;
g - > cur_y = g - > start_y ;
2014-05-31 16:40:05 +04:00
g - > lflags = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( g - > lflags & 0x40 ) {
g - > step = 8 * g - > line_size ; // first interlaced spacing
g - > parse = 3 ;
} else {
g - > step = g - > line_size ;
g - > parse = 0 ;
}
if ( g - > lflags & 0x80 ) {
2014-05-31 17:55:48 +04:00
stbi__gif_parse_colortable ( s , g - > lpal , 2 < < ( g - > lflags & 7 ) , g - > eflags & 0x01 ? g - > transparent : - 1 ) ;
g - > color_table = ( stbi_uc * ) g - > lpal ;
2014-05-31 15:49:43 +04:00
} else if ( g - > flags & 0x80 ) {
2014-05-31 16:40:05 +04:00
for ( i = 0 ; i < 256 ; + + i ) // @OPTIMIZE: stbi__jpeg_reset only the previous transparent
2014-05-31 15:49:43 +04:00
g - > pal [ i ] [ 3 ] = 255 ;
if ( g - > transparent > = 0 & & ( g - > eflags & 0x01 ) )
g - > pal [ g - > transparent ] [ 3 ] = 0 ;
2014-05-31 17:55:48 +04:00
g - > color_table = ( stbi_uc * ) g - > pal ;
2014-05-31 15:49:43 +04:00
} else
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " missing color table " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
o = stbi__process_gif_raster ( s , g ) ;
2014-05-31 15:49:43 +04:00
if ( o = = NULL ) return NULL ;
if ( req_comp & & req_comp ! = 4 )
2014-05-31 16:40:05 +04:00
o = stbi__convert_format ( o , 4 , req_comp , g - > w , g - > h ) ;
2014-05-31 15:49:43 +04:00
return o ;
}
case 0x21 : // Comment Extension.
{
int len ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) = = 0xF9 ) { // Graphic Control Extension.
len = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( len = = 4 ) {
2014-05-31 16:40:05 +04:00
g - > eflags = stbi__get8 ( s ) ;
stbi__get16le ( s ) ; // delay
g - > transparent = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
} else {
2014-05-31 16:40:05 +04:00
stbi__skip ( s , len ) ;
2014-05-31 15:49:43 +04:00
break ;
}
}
2014-05-31 16:40:05 +04:00
while ( ( len = stbi__get8 ( s ) ) ! = 0 )
stbi__skip ( s , len ) ;
2014-05-31 15:49:43 +04:00
break ;
}
case 0x3B : // gif stream termination code
2014-07-10 10:01:29 +04:00
return ( stbi_uc * ) s ; // using '1' causes warning on some compilers
2014-05-31 15:49:43 +04:00
default :
2014-05-31 16:38:26 +04:00
return stbi__errpuc ( " unknown code " , " Corrupt GIF " ) ;
2014-05-31 15:49:43 +04:00
}
}
}
2014-05-31 16:38:26 +04:00
static stbi_uc * stbi__gif_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
stbi_uc * u = 0 ;
2014-06-22 21:47:17 +04:00
stbi__gif g ;
memset ( & g , 0 , sizeof ( g ) ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 17:55:48 +04:00
u = stbi__gif_load_next ( s , & g , comp , req_comp ) ;
2014-07-10 10:01:29 +04:00
if ( u = = ( stbi_uc * ) s ) u = 0 ; // end of animated gif marker
2014-05-31 15:49:43 +04:00
if ( u ) {
* x = g . w ;
* y = g . h ;
}
return u ;
}
2014-05-31 16:38:26 +04:00
static int stbi__gif_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
return stbi__gif_info_raw ( s , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
}
// *************************************************************************************************
// Radiance RGBE HDR loader
// originally by Nicolas Schulz
# ifndef STBI_NO_HDR
2014-05-31 17:55:48 +04:00
static int stbi__hdr_test_core ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
const char * signature = " #?RADIANCE \n " ;
int i ;
for ( i = 0 ; signature [ i ] ; + + i )
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = signature [ i ] )
2014-05-31 15:49:43 +04:00
return 0 ;
return 1 ;
}
2014-05-31 16:38:26 +04:00
static int stbi__hdr_test ( stbi__context * s )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
int r = stbi__hdr_test_core ( s ) ;
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return r ;
}
2014-05-31 17:55:48 +04:00
# define STBI__HDR_BUFLEN 1024
static char * stbi__hdr_gettoken ( stbi__context * z , char * buffer )
2014-05-31 15:49:43 +04:00
{
int len = 0 ;
char c = ' \0 ' ;
2014-05-31 16:40:05 +04:00
c = ( char ) stbi__get8 ( z ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
while ( ! stbi__at_eof ( z ) & & c ! = ' \n ' ) {
2014-05-31 15:49:43 +04:00
buffer [ len + + ] = c ;
2014-05-31 17:55:48 +04:00
if ( len = = STBI__HDR_BUFLEN - 1 ) {
2014-05-31 15:49:43 +04:00
// flush to end of line
2014-05-31 16:40:05 +04:00
while ( ! stbi__at_eof ( z ) & & stbi__get8 ( z ) ! = ' \n ' )
2014-05-31 15:49:43 +04:00
;
break ;
}
2014-05-31 16:40:05 +04:00
c = ( char ) stbi__get8 ( z ) ;
2014-05-31 15:49:43 +04:00
}
buffer [ len ] = 0 ;
return buffer ;
}
2014-05-31 17:55:48 +04:00
static void stbi__hdr_convert ( float * output , stbi_uc * input , int req_comp )
2014-05-31 15:49:43 +04:00
{
if ( input [ 3 ] ! = 0 ) {
float f1 ;
// Exponent
f1 = ( float ) ldexp ( 1.0f , input [ 3 ] - ( int ) ( 128 + 8 ) ) ;
if ( req_comp < = 2 )
output [ 0 ] = ( input [ 0 ] + input [ 1 ] + input [ 2 ] ) * f1 / 3 ;
else {
output [ 0 ] = input [ 0 ] * f1 ;
output [ 1 ] = input [ 1 ] * f1 ;
output [ 2 ] = input [ 2 ] * f1 ;
}
if ( req_comp = = 2 ) output [ 1 ] = 1 ;
if ( req_comp = = 4 ) output [ 3 ] = 1 ;
} else {
switch ( req_comp ) {
case 4 : output [ 3 ] = 1 ; /* fallthrough */
case 3 : output [ 0 ] = output [ 1 ] = output [ 2 ] = 0 ;
break ;
case 2 : output [ 1 ] = 1 ; /* fallthrough */
case 1 : output [ 0 ] = 0 ;
break ;
}
}
}
2014-05-31 17:55:48 +04:00
static float * stbi__hdr_load ( stbi__context * s , int * x , int * y , int * comp , int req_comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
char buffer [ STBI__HDR_BUFLEN ] ;
2014-05-31 15:49:43 +04:00
char * token ;
int valid = 0 ;
int width , height ;
stbi_uc * scanline ;
float * hdr_data ;
int len ;
unsigned char count , value ;
int i , j , k , c1 , c2 , z ;
// Check identifier
2014-05-31 17:55:48 +04:00
if ( strcmp ( stbi__hdr_gettoken ( s , buffer ) , " #?RADIANCE " ) ! = 0 )
2014-05-31 16:38:26 +04:00
return stbi__errpf ( " not HDR " , " Corrupt HDR image " ) ;
2014-05-31 15:49:43 +04:00
// Parse header
for ( ; ; ) {
2014-05-31 17:55:48 +04:00
token = stbi__hdr_gettoken ( s , buffer ) ;
2014-05-31 15:49:43 +04:00
if ( token [ 0 ] = = 0 ) break ;
if ( strcmp ( token , " FORMAT=32-bit_rle_rgbe " ) = = 0 ) valid = 1 ;
}
2014-05-31 16:38:26 +04:00
if ( ! valid ) return stbi__errpf ( " unsupported format " , " Unsupported HDR format " ) ;
2014-05-31 15:49:43 +04:00
// Parse width and height
// can't use sscanf() if we're not using stdio!
2014-05-31 17:55:48 +04:00
token = stbi__hdr_gettoken ( s , buffer ) ;
2014-05-31 16:38:26 +04:00
if ( strncmp ( token , " -Y " , 3 ) ) return stbi__errpf ( " unsupported data layout " , " Unsupported HDR format " ) ;
2014-05-31 15:49:43 +04:00
token + = 3 ;
height = ( int ) strtol ( token , & token , 10 ) ;
while ( * token = = ' ' ) + + token ;
2014-05-31 16:38:26 +04:00
if ( strncmp ( token , " +X " , 3 ) ) return stbi__errpf ( " unsupported data layout " , " Unsupported HDR format " ) ;
2014-05-31 15:49:43 +04:00
token + = 3 ;
width = ( int ) strtol ( token , NULL , 10 ) ;
* x = width ;
* y = height ;
2014-06-03 19:45:34 +04:00
if ( comp ) * comp = 3 ;
2014-05-31 15:49:43 +04:00
if ( req_comp = = 0 ) req_comp = 3 ;
// Read data
2014-08-08 02:46:45 +04:00
hdr_data = ( float * ) stbi__malloc ( height * width * req_comp * sizeof ( float ) ) ;
2014-05-31 15:49:43 +04:00
// 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 :
2014-05-31 16:40:05 +04:00
stbi__getn ( s , rgbe , 4 ) ;
2014-05-31 17:55:48 +04:00
stbi__hdr_convert ( hdr_data + j * width * req_comp + i * req_comp , rgbe , req_comp ) ;
2014-05-31 15:49:43 +04:00
}
}
} else {
// Read RLE-encoded data
scanline = NULL ;
for ( j = 0 ; j < height ; + + j ) {
2014-05-31 16:40:05 +04:00
c1 = stbi__get8 ( s ) ;
c2 = stbi__get8 ( s ) ;
len = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( c1 ! = 2 | | c2 ! = 2 | | ( len & 0x80 ) ) {
// not run-length encoded, so we have to actually use THIS data as a decoded
// pixel (note this can't be a valid pixel--one of RGB must be >= 128)
2014-05-31 17:55:48 +04:00
stbi_uc rgbe [ 4 ] ;
rgbe [ 0 ] = ( stbi_uc ) c1 ;
rgbe [ 1 ] = ( stbi_uc ) c2 ;
rgbe [ 2 ] = ( stbi_uc ) len ;
2014-06-06 21:15:30 +04:00
rgbe [ 3 ] = ( stbi_uc ) stbi__get8 ( s ) ;
2014-05-31 17:55:48 +04:00
stbi__hdr_convert ( hdr_data , rgbe , req_comp ) ;
2014-05-31 15:49:43 +04:00
i = 1 ;
j = 0 ;
free ( scanline ) ;
goto main_decode_loop ; // yes, this makes no sense
}
len < < = 8 ;
2014-05-31 16:40:05 +04:00
len | = stbi__get8 ( s ) ;
2014-05-31 16:38:26 +04:00
if ( len ! = width ) { free ( hdr_data ) ; free ( scanline ) ; return stbi__errpf ( " invalid decoded scanline length " , " corrupt HDR " ) ; }
2014-08-08 02:46:45 +04:00
if ( scanline = = NULL ) scanline = ( stbi_uc * ) stbi__malloc ( width * 4 ) ;
2014-05-31 15:49:43 +04:00
for ( k = 0 ; k < 4 ; + + k ) {
i = 0 ;
while ( i < width ) {
2014-06-06 21:15:30 +04:00
count = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
if ( count > 128 ) {
// Run
2014-06-06 21:15:30 +04:00
value = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
count - = 128 ;
for ( z = 0 ; z < count ; + + z )
scanline [ i + + * 4 + k ] = value ;
} else {
// Dump
for ( z = 0 ; z < count ; + + z )
2014-06-06 21:15:30 +04:00
scanline [ i + + * 4 + k ] = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
}
}
}
for ( i = 0 ; i < width ; + + i )
2014-05-31 17:55:48 +04:00
stbi__hdr_convert ( hdr_data + ( j * width + i ) * req_comp , scanline + i * 4 , req_comp ) ;
2014-05-31 15:49:43 +04:00
}
free ( scanline ) ;
}
return hdr_data ;
}
2014-05-31 17:55:48 +04:00
static int stbi__hdr_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 17:55:48 +04:00
char buffer [ STBI__HDR_BUFLEN ] ;
2014-05-31 15:49:43 +04:00
char * token ;
int valid = 0 ;
2014-05-31 17:55:48 +04:00
if ( strcmp ( stbi__hdr_gettoken ( s , buffer ) , " #?RADIANCE " ) ! = 0 ) {
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
for ( ; ; ) {
2014-05-31 17:55:48 +04:00
token = stbi__hdr_gettoken ( s , buffer ) ;
2014-05-31 15:49:43 +04:00
if ( token [ 0 ] = = 0 ) break ;
if ( strcmp ( token , " FORMAT=32-bit_rle_rgbe " ) = = 0 ) valid = 1 ;
}
if ( ! valid ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 17:55:48 +04:00
token = stbi__hdr_gettoken ( s , buffer ) ;
2014-05-31 15:49:43 +04:00
if ( strncmp ( token , " -Y " , 3 ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
token + = 3 ;
* y = ( int ) strtol ( token , & token , 10 ) ;
while ( * token = = ' ' ) + + token ;
if ( strncmp ( token , " +X " , 3 ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
token + = 3 ;
* x = ( int ) strtol ( token , NULL , 10 ) ;
* comp = 3 ;
return 1 ;
}
# endif // STBI_NO_HDR
2014-05-31 17:55:48 +04:00
static int stbi__bmp_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
int hsz ;
2014-05-31 16:40:05 +04:00
if ( stbi__get8 ( s ) ! = ' B ' | | stbi__get8 ( s ) ! = ' M ' ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 12 ) ;
hsz = stbi__get32le ( s ) ;
2014-06-15 08:47:41 +04:00
if ( hsz ! = 12 & & hsz ! = 40 & & hsz ! = 56 & & hsz ! = 108 & & hsz ! = 124 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
if ( hsz = = 12 ) {
2014-05-31 16:40:05 +04:00
* x = stbi__get16le ( s ) ;
* y = stbi__get16le ( s ) ;
2014-05-31 15:49:43 +04:00
} else {
2014-05-31 16:40:05 +04:00
* x = stbi__get32le ( s ) ;
* y = stbi__get32le ( s ) ;
2014-05-31 15:49:43 +04:00
}
2014-05-31 16:40:05 +04:00
if ( stbi__get16le ( s ) ! = 1 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
* comp = stbi__get16le ( s ) / 8 ;
2014-05-31 15:49:43 +04:00
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__psd_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
int channelCount ;
2014-05-31 16:40:05 +04:00
if ( stbi__get32be ( s ) ! = 0x38425053 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( s ) ! = 1 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 6 ) ;
channelCount = stbi__get16be ( s ) ;
2014-05-31 15:49:43 +04:00
if ( channelCount < 0 | | channelCount > 16 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
* y = stbi__get32be ( s ) ;
* x = stbi__get32be ( s ) ;
if ( stbi__get16be ( s ) ! = 8 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
if ( stbi__get16be ( s ) ! = 3 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
* comp = 4 ;
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__pic_info ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
int act_comp = 0 , num_packets = 0 , chained ;
2014-05-31 17:55:48 +04:00
stbi__pic_packet packets [ 10 ] ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 92 ) ;
2014-05-31 15:49:43 +04:00
2014-05-31 16:40:05 +04:00
* x = stbi__get16be ( s ) ;
* y = stbi__get16be ( s ) ;
if ( stbi__at_eof ( s ) ) return 0 ;
2014-05-31 15:49:43 +04:00
if ( ( * x ) ! = 0 & & ( 1 < < 28 ) / ( * x ) < ( * y ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
2014-05-31 16:40:05 +04:00
stbi__skip ( s , 8 ) ;
2014-05-31 15:49:43 +04:00
do {
2014-05-31 17:55:48 +04:00
stbi__pic_packet * packet ;
2014-05-31 15:49:43 +04:00
if ( num_packets = = sizeof ( packets ) / sizeof ( packets [ 0 ] ) )
return 0 ;
packet = & packets [ num_packets + + ] ;
2014-05-31 16:40:05 +04:00
chained = stbi__get8 ( s ) ;
2014-06-06 21:15:30 +04:00
packet - > size = stbi__get8 ( s ) ;
packet - > type = stbi__get8 ( s ) ;
packet - > channel = stbi__get8 ( s ) ;
2014-05-31 15:49:43 +04:00
act_comp | = packet - > channel ;
2014-05-31 16:40:05 +04:00
if ( stbi__at_eof ( s ) ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
if ( packet - > size ! = 8 ) {
2014-05-31 17:55:48 +04:00
stbi__rewind ( s ) ;
2014-05-31 15:49:43 +04:00
return 0 ;
}
} while ( chained ) ;
* comp = ( act_comp & 0x10 ? 4 : 3 ) ;
return 1 ;
}
2014-05-31 17:55:48 +04:00
static int stbi__info_main ( stbi__context * s , int * x , int * y , int * comp )
2014-05-31 15:49:43 +04:00
{
2014-05-31 16:38:26 +04:00
if ( stbi__jpeg_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 16:38:26 +04:00
if ( stbi__png_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 16:38:26 +04:00
if ( stbi__gif_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 17:55:48 +04:00
if ( stbi__bmp_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 17:55:48 +04:00
if ( stbi__psd_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 17:55:48 +04:00
if ( stbi__pic_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
# ifndef STBI_NO_HDR
2014-05-31 17:55:48 +04:00
if ( stbi__hdr_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
# endif
// test tga last because it's a crappy test!
2014-05-31 16:38:26 +04:00
if ( stbi__tga_info ( s , x , y , comp ) )
2014-05-31 15:49:43 +04:00
return 1 ;
2014-05-31 16:38:26 +04:00
return stbi__err ( " unknown image type " , " Image not of any known type, or corrupt " ) ;
2014-05-31 15:49:43 +04:00
}
# ifndef STBI_NO_STDIO
STBIDEF int stbi_info ( char const * filename , int * x , int * y , int * comp )
{
2014-07-10 10:23:48 +04:00
FILE * f = stbi__fopen ( filename , " rb " ) ;
2014-05-31 15:49:43 +04:00
int result ;
2014-05-31 16:38:26 +04:00
if ( ! f ) return stbi__err ( " can't fopen " , " Unable to open file " ) ;
2014-05-31 15:49:43 +04:00
result = stbi_info_from_file ( f , x , y , comp ) ;
fclose ( f ) ;
return result ;
}
STBIDEF int stbi_info_from_file ( FILE * f , int * x , int * y , int * comp )
{
int r ;
2014-05-31 16:38:26 +04:00
stbi__context s ;
2014-05-31 15:49:43 +04:00
long pos = ftell ( f ) ;
2014-05-31 17:55:48 +04:00
stbi__start_file ( & s , f ) ;
r = stbi__info_main ( & s , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
fseek ( f , pos , SEEK_SET ) ;
return r ;
}
# endif // !STBI_NO_STDIO
STBIDEF int stbi_info_from_memory ( stbi_uc const * buffer , int len , int * x , int * y , int * comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_mem ( & s , buffer , len ) ;
2014-05-31 17:55:48 +04:00
return stbi__info_main ( & s , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
}
STBIDEF int stbi_info_from_callbacks ( stbi_io_callbacks const * c , void * user , int * x , int * y , int * comp )
{
2014-05-31 16:38:26 +04:00
stbi__context s ;
stbi__start_callbacks ( & s , ( stbi_io_callbacks * ) c , user ) ;
2014-05-31 17:55:48 +04:00
return stbi__info_main ( & s , x , y , comp ) ;
2014-05-31 15:49:43 +04:00
}
# endif // STB_IMAGE_IMPLEMENTATION
/*
revision history :
2014-08-27 00:39:53 +04:00
1.46 ( 2014 - 08 - 26 )
fix broken tRNS chunk ( colorkey - style transparency ) in non - paletted PNG
1.45 ( 2014 - 08 - 16 )
2014-08-08 02:46:45 +04:00
fix MSVC - ARM internal compiler error by wrapping malloc
2014-08-17 00:45:32 +04:00
1.44 ( 2014 - 08 - 07 )
various warning fixes from Ronny Chevalier
2014-07-16 09:26:01 +04:00
1.43 ( 2014 - 07 - 15 )
fix MSVC - only compiler problem in code changed in 1.42
2014-07-10 10:35:25 +04:00
1.42 ( 2014 - 07 - 09 )
don ' t define _CRT_SECURE_NO_WARNINGS ( affects user code )
fixes to stbi__cleanup_jpeg path
added STBI_ASSERT to avoid requiring assert . h
2014-06-26 02:29:29 +04:00
1.41 ( 2014 - 06 - 25 )
fix search & replace from 1.36 that messed up comments / error messages
2014-06-22 22:21:11 +04:00
1.40 ( 2014 - 06 - 22 )
fix gcc struct - initialization warning
2014-06-16 00:11:10 +04:00
1.39 ( 2014 - 06 - 15 )
fix to TGA optimization when req_comp ! = number of components in TGA ;
fix to GIF loading because BMP wasn ' t rewinding ( whoops , no GIFs in my test suite )
add support for BMP version 5 ( more ignored fields )
2014-06-06 21:17:32 +04:00
1.38 ( 2014 - 06 - 06 )
suppress MSVC warnings on integer casts truncating values
2014-06-06 23:17:39 +04:00
fix accidental rename of ' skip ' field of I / O
2014-06-05 04:56:18 +04:00
1.37 ( 2014 - 06 - 04 )
remove duplicate typedef
2014-06-03 19:45:34 +04:00
1.36 ( 2014 - 06 - 03 )
convert to header file single - file library
if de - iphone isn ' t set , load iphone images color - swapped instead of returning NULL
2014-05-31 15:49:43 +04:00
1.35 ( 2014 - 05 - 27 )
various warnings
fix broken STBI_SIMD path
fix bug where stbi_load_from_file no longer left file pointer in correct place
fix broken non - easy path for 32 - bit BMP ( possibly never used )
TGA optimization by Arseny Kapoulkine
1.34 ( unknown )
2014-05-31 16:40:05 +04:00
use STBI_NOTUSED in stbi__resample_row_generic ( ) , fix one more leak in tga failure case
2014-05-31 15:49:43 +04:00
1.33 ( 2011 - 07 - 14 )
make stbi_is_hdr work in STBI_NO_HDR ( as specified ) , minor compiler - friendly improvements
1.32 ( 2011 - 07 - 13 )
support for " info " function for all supported filetypes ( SpartanJ )
1.31 ( 2011 - 06 - 20 )
a few more leak fixes , bug in PNG handling ( SpartanJ )
1.30 ( 2011 - 06 - 11 )
added ability to load files via callbacks to accomidate custom input streams ( Ben Wenger )
removed deprecated format - specific test / load functions
removed support for installable file formats ( stbi_loader ) - - would have been broken for IO callbacks anyway
error cases in bmp and tga give messages and don ' t leak ( Raymond Barbiero , grisha )
fix inefficiency in decoding 32 - bit BMP ( David Woo )
1.29 ( 2010 - 08 - 16 )
various warning fixes from Aurelien Pocheville
1.28 ( 2010 - 08 - 01 )
fix bug in GIF palette transparency ( SpartanJ )
1.27 ( 2010 - 08 - 01 )
2014-05-31 17:55:48 +04:00
cast - to - stbi_uc to fix warnings
2014-05-31 15:49:43 +04:00
1.26 ( 2010 - 07 - 24 )
fix bug in file buffering for PNG reported by SpartanJ
1.25 ( 2010 - 07 - 17 )
refix trans_data warning ( Won Chun )
1.24 ( 2010 - 07 - 12 )
perf improvements reading from files on platforms with lock - heavy fgetc ( )
minor perf improvements for jpeg
deprecated type - specific functions so we ' ll get feedback if they ' re needed
attempt to fix trans_data warning ( Won Chun )
1.23 fixed bug in iPhone support
1.22 ( 2010 - 07 - 10 )
removed image * writing * support
stbi_info support from Jetro Lauha
GIF support from Jean - Marc Lienher
iPhone PNG - extensions from James Brown
2014-05-31 16:38:26 +04:00
warning - fixes from Nicolas Schulz and Janez Zemva ( i . stbi__err . Janez ( U + 017 D ) emva )
2014-05-31 17:55:48 +04:00
1.21 fix use of ' stbi_uc ' in header ( reported by jon blow )
2014-05-31 15:49:43 +04:00
1.20 added support for Softimage PIC , by Tom Seddon
1.19 bug in interlaced PNG corruption check ( found by ryg )
1.18 2008 - 08 - 02
fix a threading bug ( local mutable static )
1.17 support interlaced PNG
2014-05-31 16:40:05 +04:00
1.16 major bugfix - stbi__convert_format converted one too many pixels
2014-05-31 15:49:43 +04:00
1.15 initialize some fields for thread safety
1.14 fix threadsafe conversion bug
header - file - only version ( # define STBI_HEADER_FILE_ONLY before including )
1.13 threadsafe
1.12 const qualifiers in the API
1.11 Support installable IDCT , colorspace conversion routines
1.10 Fixes for 64 - bit ( don ' t use " unsigned long " )
optimized upsampling by Fabian " ryg " Giesen
1.09 Fix format - conversion for PSD code ( bad global variables ! )
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
2014-05-31 16:38:26 +04:00
fix bug : the stbi__bmp_load ( ) and stbi__tga_load ( ) functions didn ' t work at all
2014-05-31 15:49:43 +04:00
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
0.50 first released version
*/