From 5540790ff1f29548e4221ba80564cc8e7934de91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ed=C3=AAnis=20Freindorfer=20Azevedo?= Date: Mon, 25 Mar 2019 17:30:16 -0300 Subject: [PATCH] fix some compilation warnings Signed-off-by: Rafael Kitover Merged #396 --- fex/7z_C/7zAlloc.c | 4 + fex/fex/Data_Reader.cpp | 8 +- headers/stb/stb_image.h | 14922 ++++++++++++++--------------- src/Util.cpp | 4 +- src/Util.h | 2 + src/common/ConfigManager.cpp | 2732 +++--- src/common/ConfigManager.h | 366 +- src/common/SoundDriver.h | 2 +- src/common/SoundSDL.cpp | 2 +- src/common/SoundSDL.h | 2 +- src/common/iniparser.c | 2 +- src/filters/interframe.cpp | 16 +- src/filters/interframe.hpp | 2 +- src/filters/xBRZ/config.h | 74 +- src/filters/xBRZ/xbrz.cpp | 2452 ++--- src/filters/xBRZ/xbrz.h | 204 +- src/gb/GB.cpp | 14 +- src/gb/gbCheats.cpp | 6 +- src/gb/gbMemory.cpp | 11 +- src/gb/gbSGB.cpp | 2 +- src/gba/BreakpointStructures.cpp | 1739 ++-- src/gba/Cheats.cpp | 40 +- src/gba/GBA.cpp | 18 +- src/gba/GBA.h | 1 + src/gba/GBALink.cpp | 11 +- src/gba/GBASockClient.cpp | 1 + src/gba/GBAinline.h | 2 +- src/gba/debugger-expr-yacc.cpp | 3506 +++---- src/gba/ereader.cpp | 1169 +-- src/gba/ereader.h | 18 +- src/gba/remote.cpp | 21 +- src/gba/remote.h | 158 +- src/libretro/SoundRetro.cpp | 6 + src/libretro/SoundRetro.h | 1 + src/libretro/UtilRetro.cpp | 2 +- src/sdl/SDL.cpp | 12 +- src/sdl/expr.cpp | 1 + src/sdl/exprNode.cpp | 3 + src/sdl/filters.cpp | 1 + src/wx/cmdevents.cpp | 22 +- src/wx/copy-events.cmake | 2 +- src/wx/faudio.cpp | 10 +- src/wx/gfxviewers.cpp | 29 +- src/wx/guiinit.cpp | 120 +- src/wx/openal.cpp | 5 +- src/wx/opts.cpp | 127 +- src/wx/opts.h | 8 + src/wx/panel.cpp | 32 +- src/wx/sys.cpp | 18 +- src/wx/viewers.cpp | 41 +- src/wx/viewsupt.cpp | 45 +- src/wx/viewsupt.h | 2 + src/wx/widgets/joyedit.cpp | 15 +- src/wx/widgets/keyedit.cpp | 31 +- src/wx/widgets/sdljoy.cpp | 9 +- src/wx/widgets/wx/joyedit.h | 4 + src/wx/widgets/wx/keyedit.h | 1 + src/wx/widgets/wx/wxmisc.h | 10 +- src/wx/widgets/wxmisc.cpp | 3 +- src/wx/wxvbam.cpp | 46 +- src/wx/wxvbam.h | 5 + 61 files changed, 14193 insertions(+), 13929 deletions(-) diff --git a/fex/7z_C/7zAlloc.c b/fex/7z_C/7zAlloc.c index 7e1cc921..bff20f9f 100644 --- a/fex/7z_C/7zAlloc.c +++ b/fex/7z_C/7zAlloc.c @@ -20,6 +20,7 @@ int g_allocCountTemp = 0; void* SzAlloc(void* p, size_t size) { + (void)p; // unused param if (size == 0) return 0; #ifdef _SZ_ALLOC_DEBUG @@ -31,6 +32,7 @@ void* SzAlloc(void* p, size_t size) void SzFree(void* p, void* address) { + (void)p; // unused param #ifdef _SZ_ALLOC_DEBUG if (address != 0) { g_allocCount--; @@ -42,6 +44,7 @@ void SzFree(void* p, void* address) void* SzAllocTemp(void* p, size_t size) { + (void)p; // unused param if (size == 0) return 0; #ifdef _SZ_ALLOC_DEBUG @@ -56,6 +59,7 @@ void* SzAllocTemp(void* p, size_t size) void SzFreeTemp(void* p, void* address) { + (void)p; // unused param #ifdef _SZ_ALLOC_DEBUG if (address != 0) { g_allocCountTemp--; diff --git a/fex/fex/Data_Reader.cpp b/fex/fex/Data_Reader.cpp index 04a7a3b9..bbdfaae4 100644 --- a/fex/fex/Data_Reader.cpp +++ b/fex/fex/Data_Reader.cpp @@ -325,24 +325,30 @@ size_t utf8_encode_char( unsigned wide, char * target ) target[5] = 0x80 | ( wide & 0x3F ); wide = wide >> 6; wide |= 0x4000000; + break; case 5: target[4] = 0x80 | ( wide & 0x3F ); wide = wide >> 6; wide |= 0x200000; + break; case 4: target[3] = 0x80 | ( wide & 0x3F ); wide = wide >> 6; wide |= 0x10000; + break; case 3: target[2] = 0x80 | ( wide & 0x3F ); wide = wide >> 6; wide |= 0x800; + break; case 2: target[1] = 0x80 | ( wide & 0x3F ); wide = wide >> 6; wide |= 0xC0; - case 1: + break; + case 1: target[0] = wide; + break; } return count; diff --git a/headers/stb/stb_image.h b/headers/stb/stb_image.h index f65e43c2..571b0dce 100644 --- a/headers/stb/stb_image.h +++ b/headers/stb/stb_image.h @@ -1,7462 +1,7462 @@ -/* stb_image - v2.19 - public domain image loader - http://nothings.org/stb - 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. - - // i.e. it should look like this: - #include ... - #include ... - #include ... - #define STB_IMAGE_IMPLEMENTATION - #include "stb_image.h" - - You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. - And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free - - - QUICK NOTES: - Primarily of interest to game developers and other people who can - avoid problematic images and only need the trivial interface - - JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) - PNG 1/2/4/8/16-bit-per-channel - - TGA (not sure what subset, if a subset) - BMP non-1bpp, non-RLE - PSD (composited view only, no extra channels, 8/16 bit-per-channel) - - GIF (*comp always reports as 4-channel) - HDR (radiance rgbE format) - PIC (Softimage PIC) - PNM (PPM and PGM binary only) - - Animated GIF still needs a proper API, but here's one way to do it: - http://gist.github.com/urraka/685d9a6340b26b830d49 - - - decode from memory or through FILE (define STBI_NO_STDIO to remove code) - - decode from arbitrary I/O callbacks - - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) - - Full documentation under "DOCUMENTATION" below. - - -LICENSE - - See end of file for license information. - -RECENT REVISION HISTORY: - - 2.19 (2018-02-11) fix warning - 2.18 (2018-01-30) fix warnings - 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings - 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes - 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC - 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs - 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes - 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes - 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 - RGB-format JPEG; remove white matting in PSD; - allocate large structures on the stack; - correct channel count for PNG & BMP - 2.10 (2016-01-22) avoid warning introduced in 2.09 - 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED - - See end of file for full revision history. - - - ============================ Contributors ========================= - - Image formats Extensions, features - Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) - Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) - Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) - Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) - Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) - Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) - Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) - github:urraka (animated gif) Junggon Kim (PNM comments) - Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) - socks-the-fox (16-bit PNG) - Jeremy Sawicki (handle all ImageNet JPGs) - Optimizations & bugfixes Mikhail Morozov (1-bit BMP) - Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) - Arseny Kapoulkine - John-Mark Allen - - Bug & warning fixes - Marc LeBlanc David Woo Guillaume George Martins Mozeiko - Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan - Dave Moore Roy Eltham Hayaki Saito Nathan Reed - Won Chun Luke Graham Johan Duparc Nick Verigakis - the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh - Janez Zemva John Bartholomew Michal Cichon github:romigrou - Jonathan Blow Ken Hamada Tero Hanninen github:svdijk - Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar - Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex - Ryamond Barbiero Paul Du Bois Engin Manap github:grim210 - Aldo Culquicondor Philipp Wiesemann Dale Weiler github:sammyhw - Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus - Julian Raschke Gregory Mullen Baldur Karlsson github:poppolopoppo - Christian Floisand Kevin Schmidt github:darealshinji - Blazej Dariusz Roszkowski github:Michaelangel007 -*/ - -#ifndef STBI_INCLUDE_STB_IMAGE_H -#define STBI_INCLUDE_STB_IMAGE_H - -// DOCUMENTATION -// -// Limitations: -// - no 12-bit-per-channel JPEG -// - no JPEGs with arithmetic coding -// - GIF always returns *comp=4 -// -// Basic usage (see HDR discussion below for HDR usage): -// 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 *channels_in_file -- outputs # of image components in image file -// int desired_channels -- 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, or NULL on an allocation failure or if the image is -// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, -// with each pixel consisting of N interleaved 8-bit components; the first -// 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 'desired_channels' if desired_channels is non-zero, or -// *channels_in_file otherwise. If desired_channels is non-zero, -// *channels_in_file has the number of components that _would_ have been -// output otherwise. E.g. if you set desired_channels to 4, you will always -// get RGBA output, but you can check *channels_in_file to see if it's trivially -// opaque because e.g. there were only 3 channels in the source image. -// -// 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, *channels_in_file 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. -// -// =========================================================================== -// -// Philosophy -// -// stb libraries are designed with the following priorities: -// -// 1. easy to use -// 2. easy to maintain -// 3. good performance -// -// Sometimes I let "good performance" creep up in priority over "easy to maintain", -// and for best performance I may provide less-easy-to-use APIs that give higher -// performance, in addition to the easy to use ones. Nevertheless, it's important -// to keep in mind that from the standpoint of you, a client of this library, -// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. -// -// Some secondary priorities arise directly from the first two, some of which -// make more explicit reasons why performance can't be emphasized. -// -// - Portable ("ease of use") -// - Small source code footprint ("easy to maintain") -// - No dependencies ("ease of use") -// -// =========================================================================== -// -// 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), -// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). -// -// =========================================================================== -// -// SIMD support -// -// The JPEG decoder will try to automatically use SIMD kernels on x86 when -// supported by the compiler. For ARM Neon support, you must explicitly -// request it. -// -// (The old do-it-yourself SIMD API is no longer supported in the current -// code.) -// -// On x86, SSE2 will automatically be used when available based on a run-time -// test; if not, the generic C versions are used as a fall-back. On ARM targets, -// the typical path is to have separate builds for NEON and non-NEON devices -// (at least this is true for iOS and Android). Therefore, the NEON support is -// toggled by a build flag: define STBI_NEON to get NEON loops. -// -// If for some reason you do not want to use any of SIMD code, or if -// you have issues compiling it, you can disable it entirely by -// defining STBI_NO_SIMD. -// -// =========================================================================== -// -// 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); -// -// =========================================================================== -// -// iPhone PNG support: -// -// By default we convert iphone-formatted PNGs back to RGB, even though -// they are internally encoded differently. 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 (which -// is BGR stored in RGB). -// -// 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). -// -// =========================================================================== -// -// ADDITIONAL CONFIGURATION -// -// - You can suppress implementation of any of the decoders to reduce -// your code footprint by #defining one or more of the following -// symbols before creating the implementation. -// -// STBI_NO_JPEG -// STBI_NO_PNG -// STBI_NO_BMP -// STBI_NO_PSD -// STBI_NO_TGA -// STBI_NO_GIF -// STBI_NO_HDR -// STBI_NO_PIC -// STBI_NO_PNM (.ppm and .pgm) -// -// - You can request *only* certain decoders and suppress all other ones -// (this will be more forward-compatible, as addition of new decoders -// doesn't require you to disable them explicitly): -// -// STBI_ONLY_JPEG -// STBI_ONLY_PNG -// STBI_ONLY_BMP -// STBI_ONLY_PSD -// STBI_ONLY_TGA -// STBI_ONLY_GIF -// STBI_ONLY_HDR -// STBI_ONLY_PIC -// STBI_ONLY_PNM (.ppm and .pgm) -// -// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still -// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB -// - - -#ifndef STBI_NO_STDIO -#include -#endif // STBI_NO_STDIO - -#define STBI_VERSION 1 - -enum -{ - STBI_default = 0, // only used for desired_channels - - STBI_grey = 1, - STBI_grey_alpha = 2, - STBI_rgb = 3, - STBI_rgb_alpha = 4 -}; - -typedef unsigned char stbi_uc; -typedef unsigned short stbi_us; - -#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 -// - -typedef struct -{ - int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read - void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative - int (*eof) (void *user); // returns nonzero if we are at end of file/data -} stbi_io_callbacks; - -//////////////////////////////////// -// -// 8-bits-per-channel interface -// - -STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); -STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); -#ifndef STBI_NO_GIF -STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); -#endif - - -#ifndef STBI_NO_STDIO -STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); -STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); -// for stbi_load_from_file, file pointer is left pointing immediately after image -#endif - -//////////////////////////////////// -// -// 16-bits-per-channel interface -// - -STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); -STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); - -#ifndef STBI_NO_STDIO -STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); -STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); -#endif - -//////////////////////////////////// -// -// float-per-channel interface -// -#ifndef STBI_NO_LINEAR - STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); - STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); - - #ifndef STBI_NO_STDIO - STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); - STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); - #endif -#endif - -#ifndef STBI_NO_HDR - STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); - STBIDEF void stbi_hdr_to_ldr_scale(float scale); -#endif // STBI_NO_HDR - -#ifndef STBI_NO_LINEAR - STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); - STBIDEF void stbi_ldr_to_hdr_scale(float scale); -#endif // STBI_NO_LINEAR - -// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR -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); -STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); -STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); - -#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); -STBIDEF int stbi_is_16_bit (char const *filename); -STBIDEF int stbi_is_16_bit_from_file(FILE *f); -#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); - -// flip the image vertically, so the first pixel in the output array is the bottom left -STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); - -// 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); - - -#ifdef __cplusplus -} -#endif - -// -// -//// end header file ///////////////////////////////////////////////////// -#endif // STBI_INCLUDE_STB_IMAGE_H - -#ifdef STB_IMAGE_IMPLEMENTATION - -#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ - || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ - || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ - || defined(STBI_ONLY_ZLIB) - #ifndef STBI_ONLY_JPEG - #define STBI_NO_JPEG - #endif - #ifndef STBI_ONLY_PNG - #define STBI_NO_PNG - #endif - #ifndef STBI_ONLY_BMP - #define STBI_NO_BMP - #endif - #ifndef STBI_ONLY_PSD - #define STBI_NO_PSD - #endif - #ifndef STBI_ONLY_TGA - #define STBI_NO_TGA - #endif - #ifndef STBI_ONLY_GIF - #define STBI_NO_GIF - #endif - #ifndef STBI_ONLY_HDR - #define STBI_NO_HDR - #endif - #ifndef STBI_ONLY_PIC - #define STBI_NO_PIC - #endif - #ifndef STBI_ONLY_PNM - #define STBI_NO_PNM - #endif -#endif - -#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) -#define STBI_NO_ZLIB -#endif - - -#include -#include // ptrdiff_t on osx -#include -#include -#include - -#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) -#include // ldexp, pow -#endif - -#ifndef STBI_NO_STDIO -#include -#endif - -#ifndef STBI_ASSERT -#include -#define STBI_ASSERT(x) assert(x) -#endif - - -#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 -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 - -#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) -// ok -#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) -// ok -#else -#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." -#endif - -#ifndef STBI_MALLOC -#define STBI_MALLOC(sz) malloc(sz) -#define STBI_REALLOC(p,newsz) realloc(p,newsz) -#define STBI_FREE(p) free(p) -#endif - -#ifndef STBI_REALLOC_SIZED -#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) -#endif - -// x86/x64 detection -#if defined(__x86_64__) || defined(_M_X64) -#define STBI__X64_TARGET -#elif defined(__i386) || defined(_M_IX86) -#define STBI__X86_TARGET -#endif - -#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) -// gcc doesn't support sse2 intrinsics unless you compile with -msse2, -// which in turn means it gets to use SSE2 everywhere. This is unfortunate, -// but previous attempts to provide the SSE2 functions with runtime -// detection caused numerous issues. The way architecture extensions are -// exposed in GCC/Clang is, sadly, not really suited for one-file libs. -// New behavior: if compiled with -msse2, we use SSE2 without any -// detection; if not, we don't use it at all. -#define STBI_NO_SIMD -#endif - -#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) -// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET -// -// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the -// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. -// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not -// simultaneously enabling "-mstackrealign". -// -// See https://github.com/nothings/stb/issues/81 for more information. -// -// So default to no SSE2 on 32-bit MinGW. If you've read this far and added -// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. -#define STBI_NO_SIMD -#endif - -#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) -#define STBI_SSE2 -#include - -#ifdef _MSC_VER - -#if _MSC_VER >= 1400 // not VC6 -#include // __cpuid -static int stbi__cpuid3(void) -{ - int info[4]; - __cpuid(info,1); - return info[3]; -} -#else -static int stbi__cpuid3(void) -{ - int res; - __asm { - mov eax,1 - cpuid - mov res,edx - } - return res; -} -#endif - -#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name - -static int stbi__sse2_available(void) -{ - int info3 = stbi__cpuid3(); - return ((info3 >> 26) & 1) != 0; -} -#else // assume GCC-style if not VC++ -#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) - -static int stbi__sse2_available(void) -{ - // If we're even attempting to compile this on GCC/Clang, that means - // -msse2 is on, which means the compiler is allowed to use SSE2 - // instructions at will, and so are we. - return 1; -} -#endif -#endif - -// ARM NEON -#if defined(STBI_NO_SIMD) && defined(STBI_NEON) -#undef STBI_NEON -#endif - -#ifdef STBI_NEON -#include -// assume GCC or Clang on ARM targets -#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) -#endif - -#ifndef STBI_SIMD_ALIGN -#define STBI_SIMD_ALIGN(type, name) type name -#endif - -/////////////////////////////////////////////// -// -// stbi__context struct and start_xxx functions - -// stbi__context structure is our basic context used by all images, so it -// 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; - stbi_uc buffer_start[128]; - - stbi_uc *img_buffer, *img_buffer_end; - stbi_uc *img_buffer_original, *img_buffer_original_end; -} stbi__context; - - -static void stbi__refill_buffer(stbi__context *s); - -// initialize a memory-decode context -static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) -{ - s->io.read = NULL; - s->read_from_callbacks = 0; - s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; - s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; -} - -// initialize a callback-based context -static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) -{ - 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; - stbi__refill_buffer(s); - s->img_buffer_original_end = s->img_buffer_end; -} - -#ifndef STBI_NO_STDIO - -static int stbi__stdio_read(void *user, char *data, int size) -{ - return (int) fread(data,1,size,(FILE*) user); -} - -static void stbi__stdio_skip(void *user, int n) -{ - fseek((FILE*) user, n, SEEK_CUR); -} - -static int stbi__stdio_eof(void *user) -{ - return feof((FILE*) user); -} - -static stbi_io_callbacks stbi__stdio_callbacks = -{ - stbi__stdio_read, - stbi__stdio_skip, - stbi__stdio_eof, -}; - -static void stbi__start_file(stbi__context *s, FILE *f) -{ - stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); -} - -//static void stop_file(stbi__context *s) { } - -#endif // !STBI_NO_STDIO - -static void stbi__rewind(stbi__context *s) -{ - // 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; - s->img_buffer_end = s->img_buffer_original_end; -} - -enum -{ - STBI_ORDER_RGB, - STBI_ORDER_BGR -}; - -typedef struct -{ - int bits_per_channel; - int num_channels; - int channel_order; -} stbi__result_info; - -#ifndef STBI_NO_JPEG -static int stbi__jpeg_test(stbi__context *s); -static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_PNG -static int stbi__png_test(stbi__context *s); -static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); -static int stbi__png_is16(stbi__context *s); -#endif - -#ifndef STBI_NO_BMP -static int stbi__bmp_test(stbi__context *s); -static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_TGA -static int stbi__tga_test(stbi__context *s); -static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_PSD -static int stbi__psd_test(stbi__context *s); -static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); -static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); -static int stbi__psd_is16(stbi__context *s); -#endif - -#ifndef STBI_NO_HDR -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, stbi__result_info *ri); -static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_PIC -static int stbi__pic_test(stbi__context *s); -static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_GIF -static int stbi__gif_test(stbi__context *s); -static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); -static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -#ifndef STBI_NO_PNM -static int stbi__pnm_test(stbi__context *s); -static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); -static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); -#endif - -// this is not threadsafe -static const char *stbi__g_failure_reason; - -STBIDEF const char *stbi_failure_reason(void) -{ - return stbi__g_failure_reason; -} - -static int stbi__err(const char *str) -{ - stbi__g_failure_reason = str; - return 0; -} - -static void *stbi__malloc(size_t size) -{ - return STBI_MALLOC(size); -} - -// stb_image uses ints pervasively, including for offset calculations. -// therefore the largest decoded image size we can support with the -// current code, even on 64-bit targets, is INT_MAX. this is not a -// significant limitation for the intended use case. -// -// we do, however, need to make sure our size calculations don't -// overflow. hence a few helper functions for size calculations that -// multiply integers together, making sure that they're non-negative -// and no overflow occurs. - -// return 1 if the sum is valid, 0 on overflow. -// negative terms are considered invalid. -static int stbi__addsizes_valid(int a, int b) -{ - if (b < 0) return 0; - // now 0 <= b <= INT_MAX, hence also - // 0 <= INT_MAX - b <= INTMAX. - // And "a + b <= INT_MAX" (which might overflow) is the - // same as a <= INT_MAX - b (no overflow) - return a <= INT_MAX - b; -} - -// returns 1 if the product is valid, 0 on overflow. -// negative factors are considered invalid. -static int stbi__mul2sizes_valid(int a, int b) -{ - if (a < 0 || b < 0) return 0; - if (b == 0) return 1; // mul-by-0 is always safe - // portable way to check for no overflows in a*b - return a <= INT_MAX/b; -} - -// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow -static int stbi__mad2sizes_valid(int a, int b, int add) -{ - return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); -} - -// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow -static int stbi__mad3sizes_valid(int a, int b, int c, int add) -{ - return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && - stbi__addsizes_valid(a*b*c, add); -} - -// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow -#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) -static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) -{ - return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && - stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); -} -#endif - -// mallocs with size overflow checking -static void *stbi__malloc_mad2(int a, int b, int add) -{ - if (!stbi__mad2sizes_valid(a, b, add)) return NULL; - return stbi__malloc(a*b + add); -} - -static void *stbi__malloc_mad3(int a, int b, int c, int add) -{ - if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; - return stbi__malloc(a*b*c + add); -} - -#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) -static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) -{ - if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; - return stbi__malloc(a*b*c*d + add); -} -#endif - -// stbi__err - error -// stbi__errpf - error returning pointer to float -// stbi__errpuc - error returning pointer to unsigned char - -#ifdef STBI_NO_FAILURE_STRINGS - #define stbi__err(x,y) 0 -#elif defined(STBI_FAILURE_USERMSG) - #define stbi__err(x,y) stbi__err(y) -#else - #define stbi__err(x,y) stbi__err(x) -#endif - -#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) -#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) - -STBIDEF void stbi_image_free(void *retval_from_stbi_load) -{ - STBI_FREE(retval_from_stbi_load); -} - -#ifndef STBI_NO_LINEAR -static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); -#endif - -#ifndef STBI_NO_HDR -static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); -#endif - -static int stbi__vertically_flip_on_load = 0; - -STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) -{ - stbi__vertically_flip_on_load = flag_true_if_should_flip; -} - -static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) -{ - memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields - ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed - ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order - ri->num_channels = 0; - - #ifndef STBI_NO_JPEG - if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); - #endif - #ifndef STBI_NO_PNG - if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); - #endif - #ifndef STBI_NO_BMP - if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); - #endif - #ifndef STBI_NO_GIF - if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); - #endif - #ifndef STBI_NO_PSD - if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); - #endif - #ifndef STBI_NO_PIC - if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); - #endif - #ifndef STBI_NO_PNM - if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); - #endif - - #ifndef STBI_NO_HDR - if (stbi__hdr_test(s)) { - float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); - return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); - } - #endif - - #ifndef STBI_NO_TGA - // test tga last because it's a crappy test! - if (stbi__tga_test(s)) - return stbi__tga_load(s,x,y,comp,req_comp, ri); - #endif - - return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); -} - -static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) -{ - int i; - int img_len = w * h * channels; - stbi_uc *reduced; - - reduced = (stbi_uc *) stbi__malloc(img_len); - if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); - - for (i = 0; i < img_len; ++i) - reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling - - STBI_FREE(orig); - return reduced; -} - -static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) -{ - int i; - int img_len = w * h * channels; - stbi__uint16 *enlarged; - - enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); - if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); - - for (i = 0; i < img_len; ++i) - enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff - - STBI_FREE(orig); - return enlarged; -} - -static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) -{ - int row; - size_t bytes_per_row = (size_t)w * bytes_per_pixel; - stbi_uc temp[2048]; - stbi_uc *bytes = (stbi_uc *)image; - - for (row = 0; row < (h>>1); row++) { - stbi_uc *row0 = bytes + row*bytes_per_row; - stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; - // swap row0 with row1 - size_t bytes_left = bytes_per_row; - while (bytes_left) { - size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); - memcpy(temp, row0, bytes_copy); - memcpy(row0, row1, bytes_copy); - memcpy(row1, temp, bytes_copy); - row0 += bytes_copy; - row1 += bytes_copy; - bytes_left -= bytes_copy; - } - } -} - -static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) -{ - int slice; - int slice_size = w * h * bytes_per_pixel; - - stbi_uc *bytes = (stbi_uc *)image; - for (slice = 0; slice < z; ++slice) { - stbi__vertical_flip(bytes, w, h, bytes_per_pixel); - bytes += slice_size; - } -} - -static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) -{ - stbi__result_info ri; - void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); - - if (result == NULL) - return NULL; - - if (ri.bits_per_channel != 8) { - STBI_ASSERT(ri.bits_per_channel == 16); - result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); - ri.bits_per_channel = 8; - } - - // @TODO: move stbi__convert_format to here - - if (stbi__vertically_flip_on_load) { - int channels = req_comp ? req_comp : *comp; - stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); - } - - return (unsigned char *) result; -} - -static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) -{ - stbi__result_info ri; - void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); - - if (result == NULL) - return NULL; - - if (ri.bits_per_channel != 16) { - STBI_ASSERT(ri.bits_per_channel == 8); - result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); - ri.bits_per_channel = 16; - } - - // @TODO: move stbi__convert_format16 to here - // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision - - if (stbi__vertically_flip_on_load) { - int channels = req_comp ? req_comp : *comp; - stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); - } - - return (stbi__uint16 *) result; -} - -#if !defined(STBI_NO_HDR) || !defined(STBI_NO_LINEAR) -static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) -{ - if (stbi__vertically_flip_on_load && result != NULL) { - int channels = req_comp ? req_comp : *comp; - stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); - } -} -#endif - -#ifndef STBI_NO_STDIO - -static FILE *stbi__fopen(char const *filename, char const *mode) -{ - FILE *f; -#if defined(_MSC_VER) && _MSC_VER >= 1400 - if (0 != fopen_s(&f, filename, mode)) - f=0; -#else - f = fopen(filename, mode); -#endif - return f; -} - - -STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) -{ - FILE *f = stbi__fopen(filename, "rb"); - unsigned char *result; - if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); - result = stbi_load_from_file(f,x,y,comp,req_comp); - fclose(f); - return result; -} - -STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) -{ - unsigned char *result; - stbi__context s; - stbi__start_file(&s,f); - result = stbi__load_and_postprocess_8bit(&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; -} - -STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) -{ - stbi__uint16 *result; - stbi__context s; - stbi__start_file(&s,f); - result = stbi__load_and_postprocess_16bit(&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; -} - -STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) -{ - FILE *f = stbi__fopen(filename, "rb"); - stbi__uint16 *result; - if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); - result = stbi_load_from_file_16(f,x,y,comp,req_comp); - fclose(f); - return result; -} - - -#endif //!STBI_NO_STDIO - -STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) -{ - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); -} - -STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) -{ - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); - return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); -} - -STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) -{ - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); -} - -STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) -{ - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); - return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); -} - -#ifndef STBI_NO_GIF -STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) -{ - unsigned char *result; - stbi__context s; - stbi__start_mem(&s,buffer,len); - - result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); - if (stbi__vertically_flip_on_load) { - stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); - } - - return result; -} -#endif - -#ifndef STBI_NO_LINEAR -static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) -{ - unsigned char *data; - #ifndef STBI_NO_HDR - if (stbi__hdr_test(s)) { - stbi__result_info ri; - float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); - if (hdr_data) - stbi__float_postprocess(hdr_data,x,y,comp,req_comp); - return hdr_data; - } - #endif - data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); - if (data) - return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); - return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); -} - -STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) -{ - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__loadf_main(&s,x,y,comp,req_comp); -} - -STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) -{ - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); - return stbi__loadf_main(&s,x,y,comp,req_comp); -} - -#ifndef STBI_NO_STDIO -STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) -{ - float *result; - FILE *f = stbi__fopen(filename, "rb"); - if (!f) return stbi__errpf("can't fopen", "Unable to open file"); - result = stbi_loadf_from_file(f,x,y,comp,req_comp); - fclose(f); - return result; -} - -STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) -{ - stbi__context s; - stbi__start_file(&s,f); - return stbi__loadf_main(&s,x,y,comp,req_comp); -} -#endif // !STBI_NO_STDIO - -#endif // !STBI_NO_LINEAR - -// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is -// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always -// reports false! - -STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) -{ - #ifndef STBI_NO_HDR - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__hdr_test(&s); - #else - STBI_NOTUSED(buffer); - STBI_NOTUSED(len); - return 0; - #endif -} - -#ifndef STBI_NO_STDIO -STBIDEF int stbi_is_hdr (char const *filename) -{ - FILE *f = stbi__fopen(filename, "rb"); - 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 - long pos = ftell(f); - int res; - stbi__context s; - stbi__start_file(&s,f); - res = stbi__hdr_test(&s); - fseek(f, pos, SEEK_SET); - return res; - #else - STBI_NOTUSED(f); - 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 - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); - return stbi__hdr_test(&s); - #else - STBI_NOTUSED(clbk); - STBI_NOTUSED(user); - return 0; - #endif -} - -#ifndef STBI_NO_LINEAR -static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; - -STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } -STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } -#endif - -static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; - -STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } -STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } - - -////////////////////////////////////////////////////////////////////////////// -// -// Common code used by all image loaders -// - -enum -{ - STBI__SCAN_load=0, - STBI__SCAN_type, - STBI__SCAN_header -}; - -static void stbi__refill_buffer(stbi__context *s) -{ - 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 - // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file - 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; - } -} - -stbi_inline static stbi_uc stbi__get8(stbi__context *s) -{ - if (s->img_buffer < s->img_buffer_end) - return *s->img_buffer++; - if (s->read_from_callbacks) { - stbi__refill_buffer(s); - return *s->img_buffer++; - } - return 0; -} - -stbi_inline static int stbi__at_eof(stbi__context *s) -{ - 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; -} - -static void stbi__skip(stbi__context *s, int n) -{ - if (n < 0) { - s->img_buffer = s->img_buffer_end; - return; - } - if (s->io.read) { - int blen = (int) (s->img_buffer_end - s->img_buffer); - if (blen < n) { - s->img_buffer = s->img_buffer_end; - (s->io.skip)(s->io_user_data, n - blen); - return; - } - } - s->img_buffer += n; -} - -static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) -{ - 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; -} - -static int stbi__get16be(stbi__context *s) -{ - int z = stbi__get8(s); - return (z << 8) + stbi__get8(s); -} - -static stbi__uint32 stbi__get32be(stbi__context *s) -{ - stbi__uint32 z = stbi__get16be(s); - return (z << 16) + stbi__get16be(s); -} - -#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) -// nothing -#else -static int stbi__get16le(stbi__context *s) -{ - int z = stbi__get8(s); - return z + (stbi__get8(s) << 8); -} -#endif - -#ifndef STBI_NO_BMP -static stbi__uint32 stbi__get32le(stbi__context *s) -{ - stbi__uint32 z = stbi__get16le(s); - return z + (stbi__get16le(s) << 16); -} -#endif - -#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings - - -////////////////////////////////////////////////////////////////////////////// -// -// generic converter from built-in img_n to req_comp -// individual types do this automatically as much as possible (e.g. jpeg -// does all cases internally since it needs to colorspace convert anyway, -// and it never has alpha, so very few cases ). png can automatically -// interleave an alpha=255 channel, but falls back to this for other cases -// -// assume data buffer is malloced, so malloc a new one and free that one -// only failure mode is malloc failing - -static stbi_uc stbi__compute_y(int r, int g, int b) -{ - return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); -} - -static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) -{ - int i,j; - unsigned char *good; - - if (req_comp == img_n) return data; - STBI_ASSERT(req_comp >= 1 && req_comp <= 4); - - good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); - if (good == NULL) { - STBI_FREE(data); - return stbi__errpuc("outofmem", "Out of memory"); - } - - for (j=0; j < (int) y; ++j) { - unsigned char *src = data + j * x * img_n ; - unsigned char *dest = good + j * x * req_comp; - - #define STBI__COMBO(a,b) ((a)*8+(b)) - #define STBI__CASE(a,b) case STBI__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 (STBI__COMBO(img_n, req_comp)) { - STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255; } break; - STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; - STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; } break; - STBI__CASE(2,1) { dest[0]=src[0]; } break; - STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; - STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; - STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; } break; - STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; - STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; } break; - STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; - STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break; - STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; - default: STBI_ASSERT(0); - } - #undef STBI__CASE - } - - STBI_FREE(data); - return good; -} - -static stbi__uint16 stbi__compute_y_16(int r, int g, int b) -{ - return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); -} - -static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) -{ - int i,j; - stbi__uint16 *good; - - if (req_comp == img_n) return data; - STBI_ASSERT(req_comp >= 1 && req_comp <= 4); - - good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); - if (good == NULL) { - STBI_FREE(data); - return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); - } - - for (j=0; j < (int) y; ++j) { - stbi__uint16 *src = data + j * x * img_n ; - stbi__uint16 *dest = good + j * x * req_comp; - - #define STBI__COMBO(a,b) ((a)*8+(b)) - #define STBI__CASE(a,b) case STBI__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 (STBI__COMBO(img_n, req_comp)) { - STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff; } break; - STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; - STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff; } break; - STBI__CASE(2,1) { dest[0]=src[0]; } break; - STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; - STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; - STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; } break; - STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; - STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break; - STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; - STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break; - STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; - default: STBI_ASSERT(0); - } - #undef STBI__CASE - } - - STBI_FREE(data); - return good; -} - -#ifndef STBI_NO_LINEAR -static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) -{ - int i,k,n; - float *output; - if (!data) return NULL; - output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); - if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } - // compute number of non-alpha components - if (comp & 1) n = comp; else n = comp-1; - for (i=0; i < x*y; ++i) { - for (k=0; k < n; ++k) { - output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); - } - if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; - } - STBI_FREE(data); - return output; -} -#endif - -#ifndef STBI_NO_HDR -#define stbi__float2int(x) ((int) (x)) -static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) -{ - int i,k,n; - stbi_uc *output; - if (!data) return NULL; - output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); - if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } - // compute number of non-alpha components - if (comp & 1) n = comp; else n = comp-1; - for (i=0; i < x*y; ++i) { - for (k=0; k < n; ++k) { - float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; - if (z < 0) z = 0; - if (z > 255) z = 255; - output[i*comp + k] = (stbi_uc) stbi__float2int(z); - } - if (k < comp) { - float z = data[i*comp+k] * 255 + 0.5f; - if (z < 0) z = 0; - if (z > 255) z = 255; - output[i*comp + k] = (stbi_uc) stbi__float2int(z); - } - } - STBI_FREE(data); - return output; -} -#endif - -////////////////////////////////////////////////////////////////////////////// -// -// "baseline" JPEG/JFIF decoder -// -// simple implementation -// - 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 -// - some SIMD kernels for common paths on targets with SSE2/NEON -// - uses a lot of intermediate memory, could cache poorly - -#ifndef STBI_NO_JPEG - -// huffman decoding acceleration -#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache - -typedef struct -{ - stbi_uc fast[1 << FAST_BITS]; - // weirdly, repacking this into AoS is a 10% speed loss, instead of a win - stbi__uint16 code[256]; - stbi_uc values[256]; - stbi_uc size[257]; - unsigned int maxcode[18]; - int delta[17]; // old 'firstsymbol' - old 'firstcode' -} stbi__huffman; - -typedef struct -{ - stbi__context *s; - stbi__huffman huff_dc[4]; - stbi__huffman huff_ac[4]; - stbi__uint16 dequant[4][64]; - stbi__int16 fast_ac[4][1 << FAST_BITS]; - -// 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; - stbi_uc *data; - void *raw_data, *raw_coeff; - stbi_uc *linebuf; - short *coeff; // progressive only - int coeff_w, coeff_h; // number of 8x8 coefficient blocks - } 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 progressive; - int spec_start; - int spec_end; - int succ_high; - int succ_low; - int eob_run; - int jfif; - int app14_color_transform; // Adobe APP14 tag - int rgb; - - int scan_n, order[4]; - int restart_interval, todo; - -// kernels - void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); - void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); - stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); -} stbi__jpeg; - -static int stbi__build_huffman(stbi__huffman *h, int *count) -{ - int i,j,k=0; - unsigned int code; - // build size list for each symbol (from JPEG spec) - for (i=0; i < 16; ++i) - for (j=0; j < count[i]; ++j) - h->size[k++] = (stbi_uc) (i+1); - h->size[k] = 0; - - // compute actual symbols (from jpeg spec) - code = 0; - k = 0; - for(j=1; j <= 16; ++j) { - // compute delta to add to code to compute symbol id - h->delta[j] = k - code; - if (h->size[k] == j) { - while (h->size[k] == j) - h->code[k++] = (stbi__uint16) (code++); - if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); - } - // compute largest code + 1 for this size, preshifted as needed later - h->maxcode[j] = code << (16-j); - code <<= 1; - } - h->maxcode[j] = 0xffffffff; - - // build non-spec acceleration table; 255 is flag for not-accelerated - memset(h->fast, 255, 1 << FAST_BITS); - for (i=0; i < k; ++i) { - int s = h->size[i]; - if (s <= FAST_BITS) { - int c = h->code[i] << (FAST_BITS-s); - int m = 1 << (FAST_BITS-s); - for (j=0; j < m; ++j) { - h->fast[c+j] = (stbi_uc) i; - } - } - } - return 1; -} - -// build a table that decodes both magnitude and value of small ACs in -// one go. -static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) -{ - int i; - for (i=0; i < (1 << FAST_BITS); ++i) { - stbi_uc fast = h->fast[i]; - fast_ac[i] = 0; - if (fast < 255) { - int rs = h->values[fast]; - int run = (rs >> 4) & 15; - int magbits = rs & 15; - int len = h->size[fast]; - - if (magbits && len + magbits <= FAST_BITS) { - // magnitude code followed by receive_extend code - int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); - int m = 1 << (magbits - 1); - if (k < m) k += (~0U << magbits) + 1; - // if the result is small enough, we can fit it in fast_ac table - if (k >= -128 && k <= 127) - fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); - } - } - } -} - -static void stbi__grow_buffer_unsafe(stbi__jpeg *j) -{ - do { - unsigned int b = j->nomore ? 0 : stbi__get8(j->s); - if (b == 0xff) { - int c = stbi__get8(j->s); - while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes - 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 -static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; - -// decode a jpeg huffman value from the bitstream -stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) -{ - unsigned int temp; - int c,k; - - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); - - // 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 - c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; - STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); - - // convert the id to a symbol - j->code_bits -= k; - j->code_buffer <<= k; - return h->values[c]; -} - -// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); - - sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB - k = stbi_lrot(j->code_buffer, n); - STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); - j->code_buffer = k & ~stbi__bmask[n]; - k &= stbi__bmask[n]; - j->code_bits -= n; - return k + (stbi__jbias[n] & ~sgn); -} - -// get some unsigned bits -stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) -{ - unsigned int k; - if (j->code_bits < n) stbi__grow_buffer_unsafe(j); - k = stbi_lrot(j->code_buffer, n); - j->code_buffer = k & ~stbi__bmask[n]; - k &= stbi__bmask[n]; - j->code_bits -= n; - return k; -} - -stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) -{ - unsigned int k; - if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); - k = j->code_buffer; - j->code_buffer <<= 1; - --j->code_bits; - return k & 0x80000000; -} - -// given a value that's at position X in the zigzag stream, -// where does it appear in the 8x8 matrix coded as row-major? -static const stbi_uc stbi__jpeg_dezigzag[64+15] = -{ - 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 -}; - -// decode one 64-entry block-- -static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) -{ - int diff,dc,k; - int t; - - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); - t = stbi__jpeg_huff_decode(j, hdc); - if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); - - // 0 all the ac values now so we can do it 32-bits at a time - memset(data,0,64*sizeof(data[0])); - - diff = t ? stbi__extend_receive(j, t) : 0; - dc = j->img_comp[b].dc_pred + diff; - j->img_comp[b].dc_pred = dc; - data[0] = (short) (dc * dequant[0]); - - // decode AC components, see JPEG spec - k = 1; - do { - unsigned int zig; - int c,r,s; - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); - c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); - r = fac[c]; - if (r) { // fast-AC path - k += (r >> 4) & 15; // run - s = r & 15; // combined length - j->code_buffer <<= s; - j->code_bits -= s; - // decode into unzigzag'd location - zig = stbi__jpeg_dezigzag[k++]; - data[zig] = (short) ((r >> 8) * dequant[zig]); - } else { - int rs = stbi__jpeg_huff_decode(j, hac); - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); - s = rs & 15; - r = rs >> 4; - if (s == 0) { - if (rs != 0xf0) break; // end block - k += 16; - } else { - k += r; - // decode into unzigzag'd location - zig = stbi__jpeg_dezigzag[k++]; - data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); - } - } - } while (k < 64); - return 1; -} - -static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) -{ - int diff,dc; - int t; - if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); - - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); - - if (j->succ_high == 0) { - // first scan for DC coefficient, must be first - memset(data,0,64*sizeof(data[0])); // 0 all the ac values now - t = stbi__jpeg_huff_decode(j, hdc); - diff = t ? stbi__extend_receive(j, t) : 0; - - dc = j->img_comp[b].dc_pred + diff; - j->img_comp[b].dc_pred = dc; - data[0] = (short) (dc << j->succ_low); - } else { - // refinement scan for DC coefficient - if (stbi__jpeg_get_bit(j)) - data[0] += (short) (1 << j->succ_low); - } - return 1; -} - -// @OPTIMIZE: store non-zigzagged during the decode passes, -// and only de-zigzag when dequantizing -static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) -{ - int k; - if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); - - if (j->succ_high == 0) { - int shift = j->succ_low; - - if (j->eob_run) { - --j->eob_run; - return 1; - } - - k = j->spec_start; - do { - unsigned int zig; - int c,r,s; - if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); - c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); - r = fac[c]; - if (r) { // fast-AC path - k += (r >> 4) & 15; // run - s = r & 15; // combined length - j->code_buffer <<= s; - j->code_bits -= s; - zig = stbi__jpeg_dezigzag[k++]; - data[zig] = (short) ((r >> 8) << shift); - } else { - int rs = stbi__jpeg_huff_decode(j, hac); - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); - s = rs & 15; - r = rs >> 4; - if (s == 0) { - if (r < 15) { - j->eob_run = (1 << r); - if (r) - j->eob_run += stbi__jpeg_get_bits(j, r); - --j->eob_run; - break; - } - k += 16; - } else { - k += r; - zig = stbi__jpeg_dezigzag[k++]; - data[zig] = (short) (stbi__extend_receive(j,s) << shift); - } - } - } while (k <= j->spec_end); - } else { - // refinement scan for these AC coefficients - - short bit = (short) (1 << j->succ_low); - - if (j->eob_run) { - --j->eob_run; - for (k = j->spec_start; k <= j->spec_end; ++k) { - short *p = &data[stbi__jpeg_dezigzag[k]]; - if (*p != 0) - if (stbi__jpeg_get_bit(j)) - if ((*p & bit)==0) { - if (*p > 0) - *p += bit; - else - *p -= bit; - } - } - } else { - k = j->spec_start; - do { - int r,s; - int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); - s = rs & 15; - r = rs >> 4; - if (s == 0) { - if (r < 15) { - j->eob_run = (1 << r) - 1; - if (r) - j->eob_run += stbi__jpeg_get_bits(j, r); - r = 64; // force end of block - } else { - // r=15 s=0 should write 16 0s, so we just do - // a run of 15 0s and then write s (which is 0), - // so we don't have to do anything special here - } - } else { - if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); - // sign bit - if (stbi__jpeg_get_bit(j)) - s = bit; - else - s = -bit; - } - - // advance by r - while (k <= j->spec_end) { - short *p = &data[stbi__jpeg_dezigzag[k++]]; - if (*p != 0) { - if (stbi__jpeg_get_bit(j)) - if ((*p & bit)==0) { - if (*p > 0) - *p += bit; - else - *p -= bit; - } - } else { - if (r == 0) { - *p = (short) s; - break; - } - --r; - } - } - } while (k <= j->spec_end); - } - } - return 1; -} - -// take a -128..127 value and stbi__clamp it and convert to 0..255 -stbi_inline static stbi_uc stbi__clamp(int x) -{ - // 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; - } - return (stbi_uc) x; -} - -#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) -#define stbi__fsh(x) ((x) * 4096) - -// derived from jidctint -- DCT_ISLOW -#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ - int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ - p2 = s2; \ - p3 = s6; \ - p1 = (p2+p3) * stbi__f2f(0.5411961f); \ - t2 = p1 + p3*stbi__f2f(-1.847759065f); \ - t3 = p1 + p2*stbi__f2f( 0.765366865f); \ - p2 = s0; \ - p3 = s4; \ - t0 = stbi__fsh(p2+p3); \ - t1 = stbi__fsh(p2-p3); \ - 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; \ - 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); \ - t3 += p1+p4; \ - t2 += p2+p3; \ - t1 += p2+p4; \ - t0 += p1+p3; - -static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) -{ - int i,val[64],*v=val; - stbi_uc *o; - short *d = data; - - // columns - for (i=0; i < 8; ++i,++d, ++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]*4; - v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; - } else { - STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[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 - STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) - // 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 - 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); - } -} - -#ifdef STBI_SSE2 -// sse2 integer IDCT. not the fastest possible implementation but it -// produces bit-identical results to the generic C version so it's -// fully "transparent". -static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) -{ - // This is constructed to match our regular (generic) integer IDCT exactly. - __m128i row0, row1, row2, row3, row4, row5, row6, row7; - __m128i tmp; - - // dot product constant: even elems=x, odd elems=y - #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) - - // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) - // out(1) = c1[even]*x + c1[odd]*y - #define dct_rot(out0,out1, x,y,c0,c1) \ - __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ - __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ - __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ - __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ - __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ - __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) - - // out = in << 12 (in 16-bit, out 32-bit) - #define dct_widen(out, in) \ - __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ - __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) - - // wide add - #define dct_wadd(out, a, b) \ - __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ - __m128i out##_h = _mm_add_epi32(a##_h, b##_h) - - // wide sub - #define dct_wsub(out, a, b) \ - __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ - __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) - - // butterfly a/b, add bias, then shift by "s" and pack - #define dct_bfly32o(out0, out1, a,b,bias,s) \ - { \ - __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ - __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ - dct_wadd(sum, abiased, b); \ - dct_wsub(dif, abiased, b); \ - out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ - out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ - } - - // 8-bit interleave step (for transposes) - #define dct_interleave8(a, b) \ - tmp = a; \ - a = _mm_unpacklo_epi8(a, b); \ - b = _mm_unpackhi_epi8(tmp, b) - - // 16-bit interleave step (for transposes) - #define dct_interleave16(a, b) \ - tmp = a; \ - a = _mm_unpacklo_epi16(a, b); \ - b = _mm_unpackhi_epi16(tmp, b) - - #define dct_pass(bias,shift) \ - { \ - /* even part */ \ - dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ - __m128i sum04 = _mm_add_epi16(row0, row4); \ - __m128i dif04 = _mm_sub_epi16(row0, row4); \ - dct_widen(t0e, sum04); \ - dct_widen(t1e, dif04); \ - dct_wadd(x0, t0e, t3e); \ - dct_wsub(x3, t0e, t3e); \ - dct_wadd(x1, t1e, t2e); \ - dct_wsub(x2, t1e, t2e); \ - /* odd part */ \ - dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ - dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ - __m128i sum17 = _mm_add_epi16(row1, row7); \ - __m128i sum35 = _mm_add_epi16(row3, row5); \ - dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ - dct_wadd(x4, y0o, y4o); \ - dct_wadd(x5, y1o, y5o); \ - dct_wadd(x6, y2o, y5o); \ - dct_wadd(x7, y3o, y4o); \ - dct_bfly32o(row0,row7, x0,x7,bias,shift); \ - dct_bfly32o(row1,row6, x1,x6,bias,shift); \ - dct_bfly32o(row2,row5, x2,x5,bias,shift); \ - dct_bfly32o(row3,row4, x3,x4,bias,shift); \ - } - - __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); - __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); - __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); - __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); - __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); - __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); - __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); - __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); - - // rounding biases in column/row passes, see stbi__idct_block for explanation. - __m128i bias_0 = _mm_set1_epi32(512); - __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); - - // load - row0 = _mm_load_si128((const __m128i *) (data + 0*8)); - row1 = _mm_load_si128((const __m128i *) (data + 1*8)); - row2 = _mm_load_si128((const __m128i *) (data + 2*8)); - row3 = _mm_load_si128((const __m128i *) (data + 3*8)); - row4 = _mm_load_si128((const __m128i *) (data + 4*8)); - row5 = _mm_load_si128((const __m128i *) (data + 5*8)); - row6 = _mm_load_si128((const __m128i *) (data + 6*8)); - row7 = _mm_load_si128((const __m128i *) (data + 7*8)); - - // column pass - dct_pass(bias_0, 10); - - { - // 16bit 8x8 transpose pass 1 - dct_interleave16(row0, row4); - dct_interleave16(row1, row5); - dct_interleave16(row2, row6); - dct_interleave16(row3, row7); - - // transpose pass 2 - dct_interleave16(row0, row2); - dct_interleave16(row1, row3); - dct_interleave16(row4, row6); - dct_interleave16(row5, row7); - - // transpose pass 3 - dct_interleave16(row0, row1); - dct_interleave16(row2, row3); - dct_interleave16(row4, row5); - dct_interleave16(row6, row7); - } - - // row pass - dct_pass(bias_1, 17); - - { - // pack - __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 - __m128i p1 = _mm_packus_epi16(row2, row3); - __m128i p2 = _mm_packus_epi16(row4, row5); - __m128i p3 = _mm_packus_epi16(row6, row7); - - // 8bit 8x8 transpose pass 1 - dct_interleave8(p0, p2); // a0e0a1e1... - dct_interleave8(p1, p3); // c0g0c1g1... - - // transpose pass 2 - dct_interleave8(p0, p1); // a0c0e0g0... - dct_interleave8(p2, p3); // b0d0f0h0... - - // transpose pass 3 - dct_interleave8(p0, p2); // a0b0c0d0... - dct_interleave8(p1, p3); // a4b4c4d4... - - // store - _mm_storel_epi64((__m128i *) out, p0); out += out_stride; - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; - _mm_storel_epi64((__m128i *) out, p2); out += out_stride; - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; - _mm_storel_epi64((__m128i *) out, p1); out += out_stride; - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; - _mm_storel_epi64((__m128i *) out, p3); out += out_stride; - _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); - } - -#undef dct_const -#undef dct_rot -#undef dct_widen -#undef dct_wadd -#undef dct_wsub -#undef dct_bfly32o -#undef dct_interleave8 -#undef dct_interleave16 -#undef dct_pass -} - -#endif // STBI_SSE2 - -#ifdef STBI_NEON - -// NEON integer IDCT. should produce bit-identical -// results to the generic C version. -static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) -{ - int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; - - int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); - int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); - int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); - int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); - int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); - int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); - int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); - int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); - int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); - int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); - int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); - int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); - -#define dct_long_mul(out, inq, coeff) \ - int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ - int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) - -#define dct_long_mac(out, acc, inq, coeff) \ - int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ - int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) - -#define dct_widen(out, inq) \ - int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ - int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) - -// wide add -#define dct_wadd(out, a, b) \ - int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ - int32x4_t out##_h = vaddq_s32(a##_h, b##_h) - -// wide sub -#define dct_wsub(out, a, b) \ - int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ - int32x4_t out##_h = vsubq_s32(a##_h, b##_h) - -// butterfly a/b, then shift using "shiftop" by "s" and pack -#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ - { \ - dct_wadd(sum, a, b); \ - dct_wsub(dif, a, b); \ - out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ - out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ - } - -#define dct_pass(shiftop, shift) \ - { \ - /* even part */ \ - int16x8_t sum26 = vaddq_s16(row2, row6); \ - dct_long_mul(p1e, sum26, rot0_0); \ - dct_long_mac(t2e, p1e, row6, rot0_1); \ - dct_long_mac(t3e, p1e, row2, rot0_2); \ - int16x8_t sum04 = vaddq_s16(row0, row4); \ - int16x8_t dif04 = vsubq_s16(row0, row4); \ - dct_widen(t0e, sum04); \ - dct_widen(t1e, dif04); \ - dct_wadd(x0, t0e, t3e); \ - dct_wsub(x3, t0e, t3e); \ - dct_wadd(x1, t1e, t2e); \ - dct_wsub(x2, t1e, t2e); \ - /* odd part */ \ - int16x8_t sum15 = vaddq_s16(row1, row5); \ - int16x8_t sum17 = vaddq_s16(row1, row7); \ - int16x8_t sum35 = vaddq_s16(row3, row5); \ - int16x8_t sum37 = vaddq_s16(row3, row7); \ - int16x8_t sumodd = vaddq_s16(sum17, sum35); \ - dct_long_mul(p5o, sumodd, rot1_0); \ - dct_long_mac(p1o, p5o, sum17, rot1_1); \ - dct_long_mac(p2o, p5o, sum35, rot1_2); \ - dct_long_mul(p3o, sum37, rot2_0); \ - dct_long_mul(p4o, sum15, rot2_1); \ - dct_wadd(sump13o, p1o, p3o); \ - dct_wadd(sump24o, p2o, p4o); \ - dct_wadd(sump23o, p2o, p3o); \ - dct_wadd(sump14o, p1o, p4o); \ - dct_long_mac(x4, sump13o, row7, rot3_0); \ - dct_long_mac(x5, sump24o, row5, rot3_1); \ - dct_long_mac(x6, sump23o, row3, rot3_2); \ - dct_long_mac(x7, sump14o, row1, rot3_3); \ - dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ - dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ - dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ - dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ - } - - // load - row0 = vld1q_s16(data + 0*8); - row1 = vld1q_s16(data + 1*8); - row2 = vld1q_s16(data + 2*8); - row3 = vld1q_s16(data + 3*8); - row4 = vld1q_s16(data + 4*8); - row5 = vld1q_s16(data + 5*8); - row6 = vld1q_s16(data + 6*8); - row7 = vld1q_s16(data + 7*8); - - // add DC bias - row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); - - // column pass - dct_pass(vrshrn_n_s32, 10); - - // 16bit 8x8 transpose - { -// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. -// whether compilers actually get this is another story, sadly. -#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } -#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } -#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } - - // pass 1 - dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 - dct_trn16(row2, row3); - dct_trn16(row4, row5); - dct_trn16(row6, row7); - - // pass 2 - dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 - dct_trn32(row1, row3); - dct_trn32(row4, row6); - dct_trn32(row5, row7); - - // pass 3 - dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 - dct_trn64(row1, row5); - dct_trn64(row2, row6); - dct_trn64(row3, row7); - -#undef dct_trn16 -#undef dct_trn32 -#undef dct_trn64 - } - - // row pass - // vrshrn_n_s32 only supports shifts up to 16, we need - // 17. so do a non-rounding shift of 16 first then follow - // up with a rounding shift by 1. - dct_pass(vshrn_n_s32, 16); - - { - // pack and round - uint8x8_t p0 = vqrshrun_n_s16(row0, 1); - uint8x8_t p1 = vqrshrun_n_s16(row1, 1); - uint8x8_t p2 = vqrshrun_n_s16(row2, 1); - uint8x8_t p3 = vqrshrun_n_s16(row3, 1); - uint8x8_t p4 = vqrshrun_n_s16(row4, 1); - uint8x8_t p5 = vqrshrun_n_s16(row5, 1); - uint8x8_t p6 = vqrshrun_n_s16(row6, 1); - uint8x8_t p7 = vqrshrun_n_s16(row7, 1); - - // again, these can translate into one instruction, but often don't. -#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } -#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } -#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } - - // sadly can't use interleaved stores here since we only write - // 8 bytes to each scan line! - - // 8x8 8-bit transpose pass 1 - dct_trn8_8(p0, p1); - dct_trn8_8(p2, p3); - dct_trn8_8(p4, p5); - dct_trn8_8(p6, p7); - - // pass 2 - dct_trn8_16(p0, p2); - dct_trn8_16(p1, p3); - dct_trn8_16(p4, p6); - dct_trn8_16(p5, p7); - - // pass 3 - dct_trn8_32(p0, p4); - dct_trn8_32(p1, p5); - dct_trn8_32(p2, p6); - dct_trn8_32(p3, p7); - - // store - vst1_u8(out, p0); out += out_stride; - vst1_u8(out, p1); out += out_stride; - vst1_u8(out, p2); out += out_stride; - vst1_u8(out, p3); out += out_stride; - vst1_u8(out, p4); out += out_stride; - vst1_u8(out, p5); out += out_stride; - vst1_u8(out, p6); out += out_stride; - vst1_u8(out, p7); - -#undef dct_trn8_8 -#undef dct_trn8_16 -#undef dct_trn8_32 - } - -#undef dct_long_mul -#undef dct_long_mac -#undef dct_widen -#undef dct_wadd -#undef dct_wsub -#undef dct_bfly32o -#undef dct_pass -} - -#endif // STBI_NEON - -#define STBI__MARKER_none 0xff -// if there's a pending marker from the entropy stream, return that -// otherwise, fetch from the stream and get a marker. if there's no -// marker, return 0xff, which is never a valid marker value -static stbi_uc stbi__get_marker(stbi__jpeg *j) -{ - stbi_uc x; - if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } - x = stbi__get8(j->s); - if (x != 0xff) return STBI__MARKER_none; - while (x == 0xff) - x = stbi__get8(j->s); // consume repeated 0xff fill bytes - return x; -} - -// in each scan, we'll have scan_n components, and the order -// of the components is specified by order[] -#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) - -// after a restart interval, stbi__jpeg_reset the entropy decoder and -// the dc prediction -static void stbi__jpeg_reset(stbi__jpeg *j) -{ - 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 = j->img_comp[3].dc_pred = 0; - j->marker = STBI__MARKER_none; - j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; - j->eob_run = 0; - // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, - // since we don't even allow 1<<30 pixels -} - -static int stbi__parse_entropy_coded_data(stbi__jpeg *z) -{ - stbi__jpeg_reset(z); - if (!z->progressive) { - if (z->scan_n == 1) { - int i,j; - STBI_SIMD_ALIGN(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) { - int ha = z->img_comp[n].ha; - if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); - // every data block is an MCU, so countdown the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - // if it's NOT a restart, then just bail, so we get corrupt data - // rather than no data - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); - } - } - } - return 1; - } else { // interleaved - int i,j,k,x,y; - STBI_SIMD_ALIGN(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; - int ha = z->img_comp[n].ha; - if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); - } - } - } - // after all interleaved components, that's an interleaved MCU, - // so now count down the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); - } - } - } - return 1; - } - } else { - if (z->scan_n == 1) { - int i,j; - 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) { - short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); - if (z->spec_start == 0) { - if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) - return 0; - } else { - int ha = z->img_comp[n].ha; - if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) - return 0; - } - // every data block is an MCU, so countdown the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); - } - } - } - return 1; - } else { // interleaved - int i,j,k,x,y; - 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); - int y2 = (j*z->img_comp[n].v + y); - short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); - if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) - return 0; - } - } - } - // after all interleaved components, that's an interleaved MCU, - // so now count down the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); - } - } - } - return 1; - } - } -} - -static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) -{ - int i; - for (i=0; i < 64; ++i) - data[i] *= dequant[i]; -} - -static void stbi__jpeg_finish(stbi__jpeg *z) -{ - if (z->progressive) { - // dequantize and idct the data - int i,j,n; - for (n=0; n < z->s->img_n; ++n) { - 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) { - short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); - stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); - z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); - } - } - } - } -} - -static int stbi__process_marker(stbi__jpeg *z, int m) -{ - int L; - switch (m) { - case STBI__MARKER_none: // no marker found - return stbi__err("expected marker","Corrupt JPEG"); - - case 0xDD: // DRI - specify restart interval - if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); - z->restart_interval = stbi__get16be(z->s); - return 1; - - case 0xDB: // DQT - define quantization table - L = stbi__get16be(z->s)-2; - while (L > 0) { - int q = stbi__get8(z->s); - int p = q >> 4, sixteen = (p != 0); - int t = q & 15,i; - if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); - if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); - - for (i=0; i < 64; ++i) - z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); - L -= (sixteen ? 129 : 65); - } - return L==0; - - case 0xC4: // DHT - define huffman table - L = stbi__get16be(z->s)-2; - while (L > 0) { - stbi_uc *v; - int sizes[16],i,n=0; - int q = stbi__get8(z->s); - int tc = q >> 4; - int th = q & 15; - if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); - for (i=0; i < 16; ++i) { - sizes[i] = stbi__get8(z->s); - n += sizes[i]; - } - L -= 17; - if (tc == 0) { - if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; - v = z->huff_dc[th].values; - } else { - if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; - v = z->huff_ac[th].values; - } - for (i=0; i < n; ++i) - v[i] = stbi__get8(z->s); - if (tc != 0) - stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); - L -= n; - } - return L==0; - } - - // check for comment block or APP blocks - if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { - L = stbi__get16be(z->s); - if (L < 2) { - if (m == 0xFE) - return stbi__err("bad COM len","Corrupt JPEG"); - else - return stbi__err("bad APP len","Corrupt JPEG"); - } - L -= 2; - - if (m == 0xE0 && L >= 5) { // JFIF APP0 segment - static const unsigned char tag[5] = {'J','F','I','F','\0'}; - int ok = 1; - int i; - for (i=0; i < 5; ++i) - if (stbi__get8(z->s) != tag[i]) - ok = 0; - L -= 5; - if (ok) - z->jfif = 1; - } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment - static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; - int ok = 1; - int i; - for (i=0; i < 6; ++i) - if (stbi__get8(z->s) != tag[i]) - ok = 0; - L -= 6; - if (ok) { - stbi__get8(z->s); // version - stbi__get16be(z->s); // flags0 - stbi__get16be(z->s); // flags1 - z->app14_color_transform = stbi__get8(z->s); // color transform - L -= 6; - } - } - - stbi__skip(z->s, L); - return 1; - } - - return stbi__err("unknown marker","Corrupt JPEG"); -} - -// after we see SOS -static int stbi__process_scan_header(stbi__jpeg *z) -{ - int i; - 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 SOS component count","Corrupt JPEG"); - if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); - for (i=0; i < z->scan_n; ++i) { - int id = stbi__get8(z->s), which; - int q = stbi__get8(z->s); - 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; // no match - 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"); - z->order[i] = which; - } - - { - int aa; - z->spec_start = stbi__get8(z->s); - z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 - aa = stbi__get8(z->s); - z->succ_high = (aa >> 4); - z->succ_low = (aa & 15); - if (z->progressive) { - if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) - return stbi__err("bad SOS", "Corrupt JPEG"); - } else { - if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); - if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); - z->spec_end = 63; - } - } - - return 1; -} - -static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) -{ - int i; - for (i=0; i < ncomp; ++i) { - if (z->img_comp[i].raw_data) { - STBI_FREE(z->img_comp[i].raw_data); - z->img_comp[i].raw_data = NULL; - z->img_comp[i].data = NULL; - } - if (z->img_comp[i].raw_coeff) { - STBI_FREE(z->img_comp[i].raw_coeff); - z->img_comp[i].raw_coeff = 0; - z->img_comp[i].coeff = 0; - } - if (z->img_comp[i].linebuf) { - STBI_FREE(z->img_comp[i].linebuf); - z->img_comp[i].linebuf = NULL; - } - } - return why; -} - -static int stbi__process_frame_header(stbi__jpeg *z, int scan) -{ - stbi__context *s = z->s; - int Lf,p,i,q, h_max=1,v_max=1,c; - Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad 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); - if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); - s->img_n = c; - for (i=0; i < c; ++i) { - z->img_comp[i].data = NULL; - z->img_comp[i].linebuf = NULL; - } - - if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); - - z->rgb = 0; - for (i=0; i < s->img_n; ++i) { - static const unsigned char rgb[3] = { 'R', 'G', 'B' }; - z->img_comp[i].id = stbi__get8(s); - if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) - ++z->rgb; - q = stbi__get8(s); - 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"); - z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); - } - - if (scan != STBI__SCAN_load) return 1; - - if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); - - 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; - // these sizes can't be more than 17 bits - 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) { - // number of effective pixels (e.g. for non-interleaved MCU) - 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; - // to simplify generation, we'll allocate enough memory to decode - // the bogus oversized data from using interleaved MCUs and their - // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't - // discard the extra data until colorspace conversion - // - // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) - // so these muls can't overflow with 32-bit ints (which we require) - z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; - z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; - z->img_comp[i].coeff = 0; - z->img_comp[i].raw_coeff = 0; - z->img_comp[i].linebuf = NULL; - z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); - if (z->img_comp[i].raw_data == NULL) - return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); - // align blocks for idct using mmx/sse - z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); - if (z->progressive) { - // w2, h2 are multiples of 8 (see above) - z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; - z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; - z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); - if (z->img_comp[i].raw_coeff == NULL) - return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); - z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); - } - } - - return 1; -} - -// use comparisons since in some cases we handle more than one case (e.g. SOF) -#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 || (x) == 0xc2) -#define stbi__SOS(x) ((x) == 0xda) - -#define stbi__SOF_progressive(x) ((x) == 0xc2) - -static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) -{ - int m; - z->jfif = 0; - z->app14_color_transform = -1; // valid values are 0,1,2 - z->marker = STBI__MARKER_none; // initialize cached marker to empty - m = stbi__get_marker(z); - if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); - if (scan == STBI__SCAN_type) return 1; - 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) { - // some files have extra padding after their blocks, so ok, we'll scan - if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); - m = stbi__get_marker(z); - } - } - z->progressive = stbi__SOF_progressive(m); - if (!stbi__process_frame_header(z, scan)) return 0; - return 1; -} - -// decode image to YCbCr format -static int stbi__decode_jpeg_image(stbi__jpeg *j) -{ - int m; - for (m = 0; m < 4; m++) { - j->img_comp[m].raw_data = NULL; - j->img_comp[m].raw_coeff = NULL; - } - j->restart_interval = 0; - if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; - 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 ) { - // handle 0s at the end of image data from IP Kamera 9060 - while (!stbi__at_eof(j->s)) { - int x = stbi__get8(j->s); - if (x == 255) { - j->marker = stbi__get8(j->s); - break; - } - } - // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 - } - } else if (stbi__DNL(m)) { - int Ld = stbi__get16be(j->s); - stbi__uint32 NL = stbi__get16be(j->s); - if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); - if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); - } else { - if (!stbi__process_marker(j, m)) return 0; - } - m = stbi__get_marker(j); - } - if (j->progressive) - stbi__jpeg_finish(j); - return 1; -} - -// static jfif-centered resampling (across block boundaries) - -typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, - int w, int hs); - -#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) - -static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - STBI_NOTUSED(out); - STBI_NOTUSED(in_far); - STBI_NOTUSED(w); - STBI_NOTUSED(hs); - return in_near; -} - -static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - // need to generate two samples vertically for every one in input - int i; - STBI_NOTUSED(hs); - for (i=0; i < w; ++i) - out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); - return out; -} - -static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - // need to generate two samples horizontally for every one in input - int i; - stbi_uc *input = in_near; - - if (w == 1) { - // if only one sample, can't do any interpolation - out[0] = out[1] = input[0]; - return out; - } - - out[0] = input[0]; - out[1] = stbi__div4(input[0]*3 + input[1] + 2); - for (i=1; i < w-1; ++i) { - int n = 3*input[i]+2; - out[i*2+0] = stbi__div4(n+input[i-1]); - out[i*2+1] = stbi__div4(n+input[i+1]); - } - out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); - out[i*2+1] = input[w-1]; - - STBI_NOTUSED(in_far); - STBI_NOTUSED(hs); - - return out; -} - -#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) - -static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - // need to generate 2x2 samples for every one in input - int i,t0,t1; - if (w == 1) { - out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); - return out; - } - - t1 = 3*in_near[0] + in_far[0]; - out[0] = stbi__div4(t1+2); - for (i=1; i < w; ++i) { - t0 = t1; - t1 = 3*in_near[i]+in_far[i]; - out[i*2-1] = stbi__div16(3*t0 + t1 + 8); - out[i*2 ] = stbi__div16(3*t1 + t0 + 8); - } - out[w*2-1] = stbi__div4(t1+2); - - STBI_NOTUSED(hs); - - return out; -} - -#if defined(STBI_SSE2) || defined(STBI_NEON) -static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - // need to generate 2x2 samples for every one in input - int i=0,t0,t1; - - if (w == 1) { - out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); - return out; - } - - t1 = 3*in_near[0] + in_far[0]; - // process groups of 8 pixels for as long as we can. - // note we can't handle the last pixel in a row in this loop - // because we need to handle the filter boundary conditions. - for (; i < ((w-1) & ~7); i += 8) { -#if defined(STBI_SSE2) - // load and perform the vertical filtering pass - // this uses 3*x + y = 4*x + (y - x) - __m128i zero = _mm_setzero_si128(); - __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); - __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); - __m128i farw = _mm_unpacklo_epi8(farb, zero); - __m128i nearw = _mm_unpacklo_epi8(nearb, zero); - __m128i diff = _mm_sub_epi16(farw, nearw); - __m128i nears = _mm_slli_epi16(nearw, 2); - __m128i curr = _mm_add_epi16(nears, diff); // current row - - // horizontal filter works the same based on shifted vers of current - // row. "prev" is current row shifted right by 1 pixel; we need to - // insert the previous pixel value (from t1). - // "next" is current row shifted left by 1 pixel, with first pixel - // of next block of 8 pixels added in. - __m128i prv0 = _mm_slli_si128(curr, 2); - __m128i nxt0 = _mm_srli_si128(curr, 2); - __m128i prev = _mm_insert_epi16(prv0, t1, 0); - __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); - - // horizontal filter, polyphase implementation since it's convenient: - // even pixels = 3*cur + prev = cur*4 + (prev - cur) - // odd pixels = 3*cur + next = cur*4 + (next - cur) - // note the shared term. - __m128i bias = _mm_set1_epi16(8); - __m128i curs = _mm_slli_epi16(curr, 2); - __m128i prvd = _mm_sub_epi16(prev, curr); - __m128i nxtd = _mm_sub_epi16(next, curr); - __m128i curb = _mm_add_epi16(curs, bias); - __m128i even = _mm_add_epi16(prvd, curb); - __m128i odd = _mm_add_epi16(nxtd, curb); - - // interleave even and odd pixels, then undo scaling. - __m128i int0 = _mm_unpacklo_epi16(even, odd); - __m128i int1 = _mm_unpackhi_epi16(even, odd); - __m128i de0 = _mm_srli_epi16(int0, 4); - __m128i de1 = _mm_srli_epi16(int1, 4); - - // pack and write output - __m128i outv = _mm_packus_epi16(de0, de1); - _mm_storeu_si128((__m128i *) (out + i*2), outv); -#elif defined(STBI_NEON) - // load and perform the vertical filtering pass - // this uses 3*x + y = 4*x + (y - x) - uint8x8_t farb = vld1_u8(in_far + i); - uint8x8_t nearb = vld1_u8(in_near + i); - int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); - int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); - int16x8_t curr = vaddq_s16(nears, diff); // current row - - // horizontal filter works the same based on shifted vers of current - // row. "prev" is current row shifted right by 1 pixel; we need to - // insert the previous pixel value (from t1). - // "next" is current row shifted left by 1 pixel, with first pixel - // of next block of 8 pixels added in. - int16x8_t prv0 = vextq_s16(curr, curr, 7); - int16x8_t nxt0 = vextq_s16(curr, curr, 1); - int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); - int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); - - // horizontal filter, polyphase implementation since it's convenient: - // even pixels = 3*cur + prev = cur*4 + (prev - cur) - // odd pixels = 3*cur + next = cur*4 + (next - cur) - // note the shared term. - int16x8_t curs = vshlq_n_s16(curr, 2); - int16x8_t prvd = vsubq_s16(prev, curr); - int16x8_t nxtd = vsubq_s16(next, curr); - int16x8_t even = vaddq_s16(curs, prvd); - int16x8_t odd = vaddq_s16(curs, nxtd); - - // undo scaling and round, then store with even/odd phases interleaved - uint8x8x2_t o; - o.val[0] = vqrshrun_n_s16(even, 4); - o.val[1] = vqrshrun_n_s16(odd, 4); - vst2_u8(out + i*2, o); -#endif - - // "previous" value for next iter - t1 = 3*in_near[i+7] + in_far[i+7]; - } - - t0 = t1; - t1 = 3*in_near[i] + in_far[i]; - out[i*2] = stbi__div16(3*t1 + t0 + 8); - - for (++i; i < w; ++i) { - t0 = t1; - t1 = 3*in_near[i]+in_far[i]; - out[i*2-1] = stbi__div16(3*t0 + t1 + 8); - out[i*2 ] = stbi__div16(3*t1 + t0 + 8); - } - out[w*2-1] = stbi__div4(t1+2); - - STBI_NOTUSED(hs); - - return out; -} -#endif - -static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) -{ - // 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; -} - -// this is a reduced-precision calculation of YCbCr-to-RGB introduced -// to make sure the code produces the same results in both SIMD and scalar -#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) -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) -{ - int i; - for (i=0; i < count; ++i) { - int y_fixed = (y[i] << 20) + (1<<19); // rounding - int r,g,b; - int cr = pcr[i] - 128; - int cb = pcb[i] - 128; - r = y_fixed + cr* stbi__float2fixed(1.40200f); - g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); - b = y_fixed + cb* stbi__float2fixed(1.77200f); - r >>= 20; - g >>= 20; - b >>= 20; - if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } - if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } - if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } - out[0] = (stbi_uc)r; - out[1] = (stbi_uc)g; - out[2] = (stbi_uc)b; - out[3] = 255; - out += step; - } -} - -#if defined(STBI_SSE2) || defined(STBI_NEON) -static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) -{ - int i = 0; - -#ifdef STBI_SSE2 - // step == 3 is pretty ugly on the final interleave, and i'm not convinced - // it's useful in practice (you wouldn't use it for textures, for example). - // so just accelerate step == 4 case. - if (step == 4) { - // this is a fairly straightforward implementation and not super-optimized. - __m128i signflip = _mm_set1_epi8(-0x80); - __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); - __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); - __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); - __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); - __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); - __m128i xw = _mm_set1_epi16(255); // alpha channel - - for (; i+7 < count; i += 8) { - // load - __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); - __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); - __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); - __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 - __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 - - // unpack to short (and left-shift cr, cb by 8) - __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); - __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); - __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); - - // color transform - __m128i yws = _mm_srli_epi16(yw, 4); - __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); - __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); - __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); - __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); - __m128i rws = _mm_add_epi16(cr0, yws); - __m128i gwt = _mm_add_epi16(cb0, yws); - __m128i bws = _mm_add_epi16(yws, cb1); - __m128i gws = _mm_add_epi16(gwt, cr1); - - // descale - __m128i rw = _mm_srai_epi16(rws, 4); - __m128i bw = _mm_srai_epi16(bws, 4); - __m128i gw = _mm_srai_epi16(gws, 4); - - // back to byte, set up for transpose - __m128i brb = _mm_packus_epi16(rw, bw); - __m128i gxb = _mm_packus_epi16(gw, xw); - - // transpose to interleave channels - __m128i t0 = _mm_unpacklo_epi8(brb, gxb); - __m128i t1 = _mm_unpackhi_epi8(brb, gxb); - __m128i o0 = _mm_unpacklo_epi16(t0, t1); - __m128i o1 = _mm_unpackhi_epi16(t0, t1); - - // store - _mm_storeu_si128((__m128i *) (out + 0), o0); - _mm_storeu_si128((__m128i *) (out + 16), o1); - out += 32; - } - } -#endif - -#ifdef STBI_NEON - // in this version, step=3 support would be easy to add. but is there demand? - if (step == 4) { - // this is a fairly straightforward implementation and not super-optimized. - uint8x8_t signflip = vdup_n_u8(0x80); - int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); - int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); - int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); - int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); - - for (; i+7 < count; i += 8) { - // load - uint8x8_t y_bytes = vld1_u8(y + i); - uint8x8_t cr_bytes = vld1_u8(pcr + i); - uint8x8_t cb_bytes = vld1_u8(pcb + i); - int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); - int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); - - // expand to s16 - int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); - int16x8_t crw = vshll_n_s8(cr_biased, 7); - int16x8_t cbw = vshll_n_s8(cb_biased, 7); - - // color transform - int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); - int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); - int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); - int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); - int16x8_t rws = vaddq_s16(yws, cr0); - int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); - int16x8_t bws = vaddq_s16(yws, cb1); - - // undo scaling, round, convert to byte - uint8x8x4_t o; - o.val[0] = vqrshrun_n_s16(rws, 4); - o.val[1] = vqrshrun_n_s16(gws, 4); - o.val[2] = vqrshrun_n_s16(bws, 4); - o.val[3] = vdup_n_u8(255); - - // store, interleaving r/g/b/a - vst4_u8(out, o); - out += 8*4; - } - } -#endif - - for (; i < count; ++i) { - int y_fixed = (y[i] << 20) + (1<<19); // rounding - int r,g,b; - int cr = pcr[i] - 128; - int cb = pcb[i] - 128; - r = y_fixed + cr* stbi__float2fixed(1.40200f); - g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); - b = y_fixed + cb* stbi__float2fixed(1.77200f); - r >>= 20; - g >>= 20; - b >>= 20; - if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } - if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } - if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } - out[0] = (stbi_uc)r; - out[1] = (stbi_uc)g; - out[2] = (stbi_uc)b; - out[3] = 255; - out += step; - } -} -#endif - -// set up the kernels -static void stbi__setup_jpeg(stbi__jpeg *j) -{ - j->idct_block_kernel = stbi__idct_block; - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; - -#ifdef STBI_SSE2 - if (stbi__sse2_available()) { - j->idct_block_kernel = stbi__idct_simd; - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; - } -#endif - -#ifdef STBI_NEON - j->idct_block_kernel = stbi__idct_simd; - j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; - j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; -#endif -} - -// clean up the temporary component buffers -static void stbi__cleanup_jpeg(stbi__jpeg *j) -{ - stbi__free_jpeg_components(j, j->s->img_n, 0); -} - -typedef struct -{ - resample_row_func resample; - stbi_uc *line0,*line1; - int hs,vs; // expansion factor in each axis - int w_lores; // horizontal pixels pre-expansion - int ystep; // how far through vertical expansion we are - int ypos; // which pre-expansion row we're on -} stbi__resample; - -// fast 0..255 * 0..255 => 0..255 rounded multiplication -static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) -{ - unsigned int t = x*y + 128; - return (stbi_uc) ((t + (t >>8)) >> 8); -} - -static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) -{ - int n, decode_n, is_rgb; - z->s->img_n = 0; // make stbi__cleanup_jpeg safe - - // validate req_comp - if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); - - // load a jpeg image from whichever source, but leave in YCbCr format - if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } - - // determine actual number of components to generate - n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; - - is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); - - if (z->s->img_n == 3 && n < 3 && !is_rgb) - decode_n = 1; - else - decode_n = z->s->img_n; - - // resample and color-convert - { - int k; - unsigned int i,j; - stbi_uc *output; - stbi_uc *coutput[4]; - - stbi__resample res_comp[4]; - - for (k=0; k < decode_n; ++k) { - stbi__resample *r = &res_comp[k]; - - // allocate line buffer big enough for upsampling off the edges - // with upsample factor of 4 - z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); - if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } - - r->hs = z->img_h_max / z->img_comp[k].h; - r->vs = z->img_v_max / z->img_comp[k].v; - r->ystep = r->vs >> 1; - r->w_lores = (z->s->img_x + r->hs-1) / r->hs; - r->ypos = 0; - r->line0 = r->line1 = z->img_comp[k].data; - - if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; - else if (r->hs == 1 && r->vs == 2) r->resample = 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 = z->resample_row_hv_2_kernel; - else r->resample = stbi__resample_row_generic; - } - - // can't error after this so, this is safe - output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); - if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } - - // now go ahead and resample - for (j=0; j < z->s->img_y; ++j) { - stbi_uc *out = output + n * z->s->img_x * j; - for (k=0; k < decode_n; ++k) { - stbi__resample *r = &res_comp[k]; - int y_bot = r->ystep >= (r->vs >> 1); - coutput[k] = r->resample(z->img_comp[k].linebuf, - y_bot ? r->line1 : r->line0, - y_bot ? r->line0 : r->line1, - r->w_lores, r->hs); - if (++r->ystep >= r->vs) { - 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) { - stbi_uc *y = coutput[0]; - if (z->s->img_n == 3) { - if (is_rgb) { - for (i=0; i < z->s->img_x; ++i) { - out[0] = y[i]; - out[1] = coutput[1][i]; - out[2] = coutput[2][i]; - out[3] = 255; - out += n; - } - } else { - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); - } - } else if (z->s->img_n == 4) { - if (z->app14_color_transform == 0) { // CMYK - for (i=0; i < z->s->img_x; ++i) { - stbi_uc m = coutput[3][i]; - out[0] = stbi__blinn_8x8(coutput[0][i], m); - out[1] = stbi__blinn_8x8(coutput[1][i], m); - out[2] = stbi__blinn_8x8(coutput[2][i], m); - out[3] = 255; - out += n; - } - } else if (z->app14_color_transform == 2) { // YCCK - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); - for (i=0; i < z->s->img_x; ++i) { - stbi_uc m = coutput[3][i]; - out[0] = stbi__blinn_8x8(255 - out[0], m); - out[1] = stbi__blinn_8x8(255 - out[1], m); - out[2] = stbi__blinn_8x8(255 - out[2], m); - out += n; - } - } else { // YCbCr + alpha? Ignore the fourth channel for now - z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); - } - } 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 { - if (is_rgb) { - if (n == 1) - for (i=0; i < z->s->img_x; ++i) - *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); - else { - for (i=0; i < z->s->img_x; ++i, out += 2) { - out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); - out[1] = 255; - } - } - } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { - for (i=0; i < z->s->img_x; ++i) { - stbi_uc m = coutput[3][i]; - stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); - stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); - stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); - out[0] = stbi__compute_y(r, g, b); - out[1] = 255; - out += n; - } - } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { - for (i=0; i < z->s->img_x; ++i) { - out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); - out[1] = 255; - out += n; - } - } else { - stbi_uc *y = coutput[0]; - 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; - } - } - } - stbi__cleanup_jpeg(z); - *out_x = z->s->img_x; - *out_y = z->s->img_y; - if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output - return output; - } -} - -static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - unsigned char* result; - stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); - STBI_NOTUSED(ri); - j->s = s; - stbi__setup_jpeg(j); - result = load_jpeg_image(j, x,y,comp,req_comp); - STBI_FREE(j); - return result; -} - -static int stbi__jpeg_test(stbi__context *s) -{ - int r; - stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); - j->s = s; - stbi__setup_jpeg(j); - r = stbi__decode_jpeg_header(j, STBI__SCAN_type); - stbi__rewind(s); - STBI_FREE(j); - return r; -} - -static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) -{ - if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { - stbi__rewind( j->s ); - return 0; - } - if (x) *x = j->s->img_x; - if (y) *y = j->s->img_y; - if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; - return 1; -} - -static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) -{ - int result; - stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); - j->s = s; - result = stbi__jpeg_info_raw(j, x, y, comp); - STBI_FREE(j); - return result; -} -#endif - -// public domain zlib decode v0.2 Sean Barrett 2006-11-18 -// 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 - -#ifndef STBI_NO_ZLIB - -// fast-way is faster to check than jpeg huffman, but slow way is slower -#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables -#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) - -// zlib-style huffman encoding -// (jpegs packs from left, zlib from right, so can't share code) -typedef struct -{ - stbi__uint16 fast[1 << STBI__ZFAST_BITS]; - stbi__uint16 firstcode[16]; - int maxcode[17]; - stbi__uint16 firstsymbol[16]; - stbi_uc size[288]; - stbi__uint16 value[288]; -} stbi__zhuffman; - -stbi_inline static int stbi__bitreverse16(int n) -{ - 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; -} - -stbi_inline static int stbi__bit_reverse(int v, int bits) -{ - STBI_ASSERT(bits <= 16); - // to bit reverse n bits, reverse 16 and shift - // e.g. 11 bits, bit reverse and shift away 5 - return stbi__bitreverse16(v) >> (16-bits); -} - -static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) -{ - int i,k=0; - int code, next_code[16], sizes[17]; - - // DEFLATE spec for generating codes - memset(sizes, 0, sizeof(sizes)); - memset(z->fast, 0, sizeof(z->fast)); - for (i=0; i < num; ++i) - ++sizes[sizelist[i]]; - sizes[0] = 0; - for (i=1; i < 16; ++i) - if (sizes[i] > (1 << i)) - return stbi__err("bad sizes", "Corrupt PNG"); - 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]) - if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); - 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]; - stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); - z->size [c] = (stbi_uc ) s; - z->value[c] = (stbi__uint16) i; - if (s <= STBI__ZFAST_BITS) { - int j = stbi__bit_reverse(next_code[s],s); - while (j < (1 << STBI__ZFAST_BITS)) { - z->fast[j] = fastv; - j += (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 -{ - stbi_uc *zbuffer, *zbuffer_end; - int num_bits; - stbi__uint32 code_buffer; - - char *zout; - char *zout_start; - char *zout_end; - int z_expandable; - - stbi__zhuffman z_length, z_distance; -} stbi__zbuf; - -stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) -{ - if (z->zbuffer >= z->zbuffer_end) return 0; - return *z->zbuffer++; -} - -static void stbi__fill_bits(stbi__zbuf *z) -{ - do { - STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); - z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; - z->num_bits += 8; - } while (z->num_bits <= 24); -} - -stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) -{ - unsigned int k; - if (z->num_bits < n) stbi__fill_bits(z); - k = z->code_buffer & ((1 << n) - 1); - z->code_buffer >>= n; - z->num_bits -= n; - return k; -} - -static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) -{ - int b,s,k; - // not resolved by fast table, so compute it the slow way - // use jpeg approach, which requires MSbits at top - k = stbi__bit_reverse(a->code_buffer, 16); - for (s=STBI__ZFAST_BITS+1; ; ++s) - 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]; - STBI_ASSERT(z->size[b] == s); - a->code_buffer >>= s; - a->num_bits -= s; - return z->value[b]; -} - -stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) -{ - int b,s; - if (a->num_bits < 16) stbi__fill_bits(a); - b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; - if (b) { - s = b >> 9; - a->code_buffer >>= s; - a->num_bits -= s; - return b & 511; - } - return stbi__zhuffman_decode_slowpath(a, z); -} - -static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes -{ - char *q; - int cur, limit, old_limit; - z->zout = zout; - if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); - cur = (int) (z->zout - z->zout_start); - limit = old_limit = (int) (z->zout_end - z->zout_start); - while (cur + n > limit) - limit *= 2; - q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); - STBI_NOTUSED(old_limit); - if (q == NULL) return stbi__err("outofmem", "Out of memory"); - z->zout_start = q; - z->zout = q + cur; - z->zout_end = q + limit; - return 1; -} - -static const int stbi__zlength_base[31] = { - 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 }; - -static const int stbi__zlength_extra[31]= -{ 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 }; - -static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, -257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; - -static const int stbi__zdist_extra[32] = -{ 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}; - -static int stbi__parse_huffman_block(stbi__zbuf *a) -{ - char *zout = a->zout; - for(;;) { - int z = stbi__zhuffman_decode(a, &a->z_length); - if (z < 256) { - if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes - if (zout >= a->zout_end) { - if (!stbi__zexpand(a, zout, 1)) return 0; - zout = a->zout; - } - *zout++ = (char) z; - } else { - stbi_uc *p; - int len,dist; - if (z == 256) { - a->zout = zout; - return 1; - } - z -= 257; - 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); - if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); - dist = stbi__zdist_base[z]; - if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); - if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); - if (zout + len > a->zout_end) { - if (!stbi__zexpand(a, zout, len)) return 0; - zout = a->zout; - } - p = (stbi_uc *) (zout - dist); - if (dist == 1) { // run of one byte; common in images. - stbi_uc v = *p; - if (len) { do *zout++ = v; while (--len); } - } else { - if (len) { do *zout++ = *p++; while (--len); } - } - } - } -} - -static int stbi__compute_huffman_codes(stbi__zbuf *a) -{ - static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; - stbi__zhuffman z_codelength; - stbi_uc lencodes[286+32+137];//padding for maximum single op - stbi_uc codelength_sizes[19]; - int i,n; - - int hlit = stbi__zreceive(a,5) + 257; - int hdist = stbi__zreceive(a,5) + 1; - int hclen = stbi__zreceive(a,4) + 4; - int ntot = hlit + hdist; - - memset(codelength_sizes, 0, sizeof(codelength_sizes)); - for (i=0; i < hclen; ++i) { - int s = stbi__zreceive(a,3); - codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; - } - if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; - - n = 0; - while (n < ntot) { - int c = stbi__zhuffman_decode(a, &z_codelength); - if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); - if (c < 16) - lencodes[n++] = (stbi_uc) c; - else { - stbi_uc fill = 0; - if (c == 16) { - c = stbi__zreceive(a,2)+3; - if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); - fill = lencodes[n-1]; - } else if (c == 17) - c = stbi__zreceive(a,3)+3; - else { - STBI_ASSERT(c == 18); - c = stbi__zreceive(a,7)+11; - } - if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); - memset(lencodes+n, fill, c); - n += c; - } - } - if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); - if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; - if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; - return 1; -} - -static int stbi__parse_uncompressed_block(stbi__zbuf *a) -{ - stbi_uc header[4]; - int len,nlen,k; - if (a->num_bits & 7) - stbi__zreceive(a, a->num_bits & 7); // discard - // drain the bit-packed data into header - k = 0; - while (a->num_bits > 0) { - header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check - a->code_buffer >>= 8; - a->num_bits -= 8; - } - STBI_ASSERT(a->num_bits == 0); - // now fill header the normal way - while (k < 4) - header[k++] = stbi__zget8(a); - len = header[1] * 256 + header[0]; - nlen = header[3] * 256 + header[2]; - 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"); - if (a->zout + len > a->zout_end) - if (!stbi__zexpand(a, a->zout, len)) return 0; - memcpy(a->zout, a->zbuffer, len); - a->zbuffer += len; - a->zout += len; - return 1; -} - -static int stbi__parse_zlib_header(stbi__zbuf *a) -{ - int cmf = stbi__zget8(a); - int cm = cmf & 15; - /* int cinfo = cmf >> 4; */ - int flg = stbi__zget8(a); - 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 - // window = 1 << (8 + cinfo)... but who cares, we fully buffer output - return 1; -} - -static const stbi_uc stbi__zdefault_length[288] = -{ - 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, - 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, - 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, - 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, - 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, - 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, - 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, - 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, - 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 -}; -static const stbi_uc stbi__zdefault_distance[32] = -{ - 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 -}; -/* -Init algorithm: -{ - int i; // use <= to match clearly with spec - 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; - - for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; -} -*/ - -static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) -{ - int final, type; - if (parse_header) - if (!stbi__parse_zlib_header(a)) return 0; - a->num_bits = 0; - a->code_buffer = 0; - do { - final = stbi__zreceive(a,1); - type = stbi__zreceive(a,2); - if (type == 0) { - if (!stbi__parse_uncompressed_block(a)) return 0; - } else if (type == 3) { - return 0; - } else { - if (type == 1) { - // use fixed code lengths - 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; - } else { - if (!stbi__compute_huffman_codes(a)) return 0; - } - if (!stbi__parse_huffman_block(a)) return 0; - } - } while (!final); - return 1; -} - -static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) -{ - a->zout_start = obuf; - a->zout = obuf; - a->zout_end = obuf + olen; - a->z_expandable = exp; - - return stbi__parse_zlib(a, parse_header); -} - -STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) -{ - stbi__zbuf a; - char *p = (char *) stbi__malloc(initial_size); - if (p == NULL) return NULL; - a.zbuffer = (stbi_uc *) buffer; - a.zbuffer_end = (stbi_uc *) buffer + len; - if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { - if (outlen) *outlen = (int) (a.zout - a.zout_start); - return a.zout_start; - } else { - STBI_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) -{ - stbi__zbuf a; - char *p = (char *) stbi__malloc(initial_size); - if (p == NULL) return NULL; - a.zbuffer = (stbi_uc *) buffer; - a.zbuffer_end = (stbi_uc *) buffer + len; - if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { - if (outlen) *outlen = (int) (a.zout - a.zout_start); - return a.zout_start; - } else { - STBI_FREE(a.zout_start); - return NULL; - } -} - -STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) -{ - stbi__zbuf a; - a.zbuffer = (stbi_uc *) ibuffer; - a.zbuffer_end = (stbi_uc *) ibuffer + ilen; - if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) - return (int) (a.zout - a.zout_start); - else - return -1; -} - -STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) -{ - stbi__zbuf a; - char *p = (char *) stbi__malloc(16384); - if (p == NULL) return NULL; - a.zbuffer = (stbi_uc *) buffer; - a.zbuffer_end = (stbi_uc *) buffer+len; - if (stbi__do_zlib(&a, p, 16384, 1, 0)) { - if (outlen) *outlen = (int) (a.zout - a.zout_start); - return a.zout_start; - } else { - STBI_FREE(a.zout_start); - return NULL; - } -} - -STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) -{ - stbi__zbuf a; - a.zbuffer = (stbi_uc *) ibuffer; - a.zbuffer_end = (stbi_uc *) ibuffer + ilen; - if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) - return (int) (a.zout - a.zout_start); - else - return -1; -} -#endif - -// 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 - -#ifndef STBI_NO_PNG -typedef struct -{ - stbi__uint32 length; - stbi__uint32 type; -} stbi__pngchunk; - -static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) -{ - stbi__pngchunk c; - c.length = stbi__get32be(s); - c.type = stbi__get32be(s); - return c; -} - -static int stbi__check_png_header(stbi__context *s) -{ - static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; - int i; - for (i=0; i < 8; ++i) - if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); - return 1; -} - -typedef struct -{ - stbi__context *s; - stbi_uc *idata, *expanded, *out; - int depth; -} stbi__png; - - -enum { - STBI__F_none=0, - STBI__F_sub=1, - STBI__F_up=2, - STBI__F_avg=3, - STBI__F_paeth=4, - // synthetic filters used for first scanline to avoid needing a dummy row of 0s - STBI__F_avg_first, - STBI__F_paeth_first -}; - -static stbi_uc first_row_filter[5] = -{ - STBI__F_none, - STBI__F_sub, - STBI__F_none, - STBI__F_avg_first, - STBI__F_paeth_first -}; - -static int stbi__paeth(int a, int b, int c) -{ - 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; -} - -static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; - -// create the png data from post-deflated data -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, int depth, int color) -{ - int bytes = (depth == 16? 2 : 1); - stbi__context *s = a->s; - stbi__uint32 i,j,stride = x*out_n*bytes; - stbi__uint32 img_len, img_width_bytes; - int k; - int img_n = s->img_n; // copy it into a local for later - - int output_bytes = out_n*bytes; - int filter_bytes = img_n*bytes; - int width = x; - - STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); - a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into - if (!a->out) return stbi__err("outofmem", "Out of memory"); - - if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); - img_width_bytes = (((img_n * x * depth) + 7) >> 3); - img_len = (img_width_bytes + 1) * y; - - // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, - // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), - // so just check for raw_len < img_len always. - if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); - - for (j=0; j < y; ++j) { - stbi_uc *cur = a->out + stride*j; - stbi_uc *prior; - int filter = *raw++; - - if (filter > 4) - return stbi__err("invalid filter","Corrupt PNG"); - - if (depth < 8) { - STBI_ASSERT(img_width_bytes <= x); - cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place - filter_bytes = 1; - width = img_width_bytes; - } - prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above - - // if first row, use special filter that doesn't sample previous row - if (j == 0) filter = first_row_filter[filter]; - - // handle first byte explicitly - for (k=0; k < filter_bytes; ++k) { - switch (filter) { - case STBI__F_none : cur[k] = raw[k]; break; - case STBI__F_sub : cur[k] = raw[k]; 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]>>1)); break; - case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; - case STBI__F_avg_first : cur[k] = raw[k]; break; - case STBI__F_paeth_first: cur[k] = raw[k]; break; - } - } - - if (depth == 8) { - if (img_n != out_n) - cur[img_n] = 255; // first pixel - raw += img_n; - cur += out_n; - prior += out_n; - } else if (depth == 16) { - if (img_n != out_n) { - cur[filter_bytes] = 255; // first pixel top byte - cur[filter_bytes+1] = 255; // first pixel bottom byte - } - raw += filter_bytes; - cur += output_bytes; - prior += output_bytes; - } else { - raw += 1; - cur += 1; - prior += 1; - } - - // this is a little gross, so that we don't switch per-pixel or per-component - if (depth < 8 || img_n == out_n) { - int nk = (width - 1)*filter_bytes; - #define STBI__CASE(f) \ - case f: \ - for (k=0; k < nk; ++k) - switch (filter) { - // "none" filter turns into a memcpy here; make that explicit. - case STBI__F_none: memcpy(cur, raw, nk); break; - STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; - STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; - STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; - STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; - STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; - STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; - } - #undef STBI__CASE - raw += nk; - } else { - STBI_ASSERT(img_n+1 == out_n); - #define STBI__CASE(f) \ - case f: \ - for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ - for (k=0; k < filter_bytes; ++k) - switch (filter) { - STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; - STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; - STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; - STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; - STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; - STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; - STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; - } - #undef STBI__CASE - - // the loop above sets the high byte of the pixels' alpha, but for - // 16 bit png files we also need the low byte set. we'll do that here. - if (depth == 16) { - cur = a->out + stride*j; // start at the beginning of the row again - for (i=0; i < x; ++i,cur+=output_bytes) { - cur[filter_bytes+1] = 255; - } - } - } - } - - // we make a separate pass to expand bits to pixels; for performance, - // this could run two scanlines behind the above code, so it won't - // intefere with filtering but will still be in the cache. - if (depth < 8) { - for (j=0; j < y; ++j) { - stbi_uc *cur = a->out + stride*j; - stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; - // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit - // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop - stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range - - // note that the final byte might overshoot and write more data than desired. - // we can allocate enough data that this never writes out of memory, but it - // could also overwrite the next scanline. can it overwrite non-empty data - // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. - // so we need to explicitly clamp the final ones - - if (depth == 4) { - for (k=x*img_n; k >= 2; k-=2, ++in) { - *cur++ = scale * ((*in >> 4) ); - *cur++ = scale * ((*in ) & 0x0f); - } - if (k > 0) *cur++ = scale * ((*in >> 4) ); - } else if (depth == 2) { - for (k=x*img_n; k >= 4; k-=4, ++in) { - *cur++ = scale * ((*in >> 6) ); - *cur++ = scale * ((*in >> 4) & 0x03); - *cur++ = scale * ((*in >> 2) & 0x03); - *cur++ = scale * ((*in ) & 0x03); - } - if (k > 0) *cur++ = scale * ((*in >> 6) ); - if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); - if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); - } else if (depth == 1) { - for (k=x*img_n; k >= 8; k-=8, ++in) { - *cur++ = scale * ((*in >> 7) ); - *cur++ = scale * ((*in >> 6) & 0x01); - *cur++ = scale * ((*in >> 5) & 0x01); - *cur++ = scale * ((*in >> 4) & 0x01); - *cur++ = scale * ((*in >> 3) & 0x01); - *cur++ = scale * ((*in >> 2) & 0x01); - *cur++ = scale * ((*in >> 1) & 0x01); - *cur++ = scale * ((*in ) & 0x01); - } - if (k > 0) *cur++ = scale * ((*in >> 7) ); - if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); - if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); - if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); - if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); - if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); - if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); - } - if (img_n != out_n) { - int q; - // insert alpha = 255 - cur = a->out + stride*j; - if (img_n == 1) { - for (q=x-1; q >= 0; --q) { - cur[q*2+1] = 255; - cur[q*2+0] = cur[q]; - } - } else { - STBI_ASSERT(img_n == 3); - for (q=x-1; q >= 0; --q) { - cur[q*4+3] = 255; - cur[q*4+2] = cur[q*3+2]; - cur[q*4+1] = cur[q*3+1]; - cur[q*4+0] = cur[q*3+0]; - } - } - } - } - } else if (depth == 16) { - // force the image data from big-endian to platform-native. - // this is done in a separate pass due to the decoding relying - // on the data being untouched, but could probably be done - // per-line during decode if care is taken. - stbi_uc *cur = a->out; - stbi__uint16 *cur16 = (stbi__uint16*)cur; - - for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { - *cur16 = (cur[0] << 8) | cur[1]; - } - } - - return 1; -} - -static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) -{ - int bytes = (depth == 16 ? 2 : 1); - int out_bytes = out_n * bytes; - stbi_uc *final; - int p; - if (!interlaced) - return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); - - // de-interlacing - final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); - 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) { - stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; - if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { - STBI_FREE(final); - return 0; - } - for (j=0; j < y; ++j) { - for (i=0; i < x; ++i) { - int out_y = j*yspc[p]+yorig[p]; - int out_x = i*xspc[p]+xorig[p]; - memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, - a->out + (j*x+i)*out_bytes, out_bytes); - } - } - STBI_FREE(a->out); - image_data += img_len; - image_data_len -= img_len; - } - } - a->out = final; - - return 1; -} - -static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) -{ - stbi__context *s = z->s; - stbi__uint32 i, pixel_count = s->img_x * s->img_y; - stbi_uc *p = z->out; - - // compute color-based transparency, assuming we've - // already got 255 as the alpha value in the output - STBI_ASSERT(out_n == 2 || out_n == 4); - - 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; -} - -static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) -{ - stbi__context *s = z->s; - stbi__uint32 i, pixel_count = s->img_x * s->img_y; - stbi__uint16 *p = (stbi__uint16*) z->out; - - // compute color-based transparency, assuming we've - // already got 65535 as the alpha value in the output - STBI_ASSERT(out_n == 2 || out_n == 4); - - if (out_n == 2) { - for (i = 0; i < pixel_count; ++i) { - p[1] = (p[0] == tc[0] ? 0 : 65535); - 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; -} - -static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) -{ - stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; - stbi_uc *p, *temp_out, *orig = a->out; - - p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); - if (p == NULL) return stbi__err("outofmem", "Out of memory"); - - // 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; - } - } - STBI_FREE(a->out); - a->out = temp_out; - - STBI_NOTUSED(len); - - return 1; -} - -static int stbi__unpremultiply_on_load = 0; -static int stbi__de_iphone_flag = 0; - -STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) -{ - stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; -} - -STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) -{ - stbi__de_iphone_flag = flag_true_if_should_convert; -} - -static void stbi__de_iphone(stbi__png *z) -{ - stbi__context *s = z->s; - stbi__uint32 i, pixel_count = s->img_x * s->img_y; - stbi_uc *p = z->out; - - if (s->img_out_n == 3) { // convert bgr to rgb - for (i=0; i < pixel_count; ++i) { - stbi_uc t = p[0]; - p[0] = p[2]; - p[2] = t; - p += 3; - } - } else { - STBI_ASSERT(s->img_out_n == 4); - if (stbi__unpremultiply_on_load) { - // convert bgr to rgb and unpremultiply - for (i=0; i < pixel_count; ++i) { - stbi_uc a = p[3]; - stbi_uc t = p[0]; - if (a) { - stbi_uc half = a / 2; - p[0] = (p[2] * 255 + half) / a; - p[1] = (p[1] * 255 + half) / a; - p[2] = ( t * 255 + half) / a; - } else { - p[0] = p[2]; - p[2] = t; - } - p += 4; - } - } else { - // convert bgr to rgb - for (i=0; i < pixel_count; ++i) { - stbi_uc t = p[0]; - p[0] = p[2]; - p[2] = t; - p += 4; - } - } - } -} - -#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) - -static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) -{ - stbi_uc palette[1024], pal_img_n=0; - stbi_uc has_trans=0, tc[3]; - stbi__uint16 tc16[3]; - stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; - int first=1,k,interlace=0, color=0, is_iphone=0; - stbi__context *s = z->s; - - z->expanded = NULL; - z->idata = NULL; - z->out = NULL; - - if (!stbi__check_png_header(s)) return 0; - - if (scan == STBI__SCAN_type) return 1; - - for (;;) { - stbi__pngchunk c = stbi__get_chunk_header(s); - switch (c.type) { - case STBI__PNG_TYPE('C','g','B','I'): - is_iphone = 1; - stbi__skip(s, c.length); - break; - case STBI__PNG_TYPE('I','H','D','R'): { - int comp,filter; - if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); - first = 0; - if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); - 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?)"); - z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); - color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); - if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); - if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); - 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"); - if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); - if (!pal_img_n) { - s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); - if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); - if (scan == STBI__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; - if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); - // if SCAN_header, have to scan to see if we have a tRNS - } - break; - } - - case STBI__PNG_TYPE('P','L','T','E'): { - if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); - pal_len = c.length / 3; - if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); - for (i=0; i < pal_len; ++i) { - palette[i*4+0] = stbi__get8(s); - palette[i*4+1] = stbi__get8(s); - palette[i*4+2] = stbi__get8(s); - palette[i*4+3] = 255; - } - break; - } - - case STBI__PNG_TYPE('t','R','N','S'): { - if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); - if (pal_img_n) { - if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } - 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"); - pal_img_n = 4; - for (i=0; i < c.length; ++i) - palette[i*4+3] = stbi__get8(s); - } else { - 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"); - has_trans = 1; - if (z->depth == 16) { - for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is - } else { - for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger - } - } - break; - } - - case STBI__PNG_TYPE('I','D','A','T'): { - if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); - if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } - if ((int)(ioff + c.length) < (int)ioff) return 0; - if (ioff + c.length > idata_limit) { - stbi__uint32 idata_limit_old = idata_limit; - stbi_uc *p; - if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; - while (ioff + c.length > idata_limit) - idata_limit *= 2; - STBI_NOTUSED(idata_limit_old); - p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); - z->idata = p; - } - if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); - ioff += c.length; - break; - } - - case STBI__PNG_TYPE('I','E','N','D'): { - stbi__uint32 raw_len, bpl; - if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (scan != STBI__SCAN_load) return 1; - if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); - // initial guess for decoded data size to avoid unnecessary reallocs - bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component - raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; - z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); - if (z->expanded == NULL) return 0; // zlib should set error - STBI_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; - if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; - if (has_trans) { - if (z->depth == 16) { - if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; - } else { - if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; - } - } - if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) - stbi__de_iphone(z); - 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; - if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) - return 0; - } else if (has_trans) { - // non-paletted image with tRNS -> source image has (constant) alpha - ++s->img_n; - } - STBI_FREE(z->expanded); z->expanded = NULL; - return 1; - } - - default: - // if critical, fail - if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if ((c.type & (1 << 29)) == 0) { - #ifndef STBI_NO_FAILURE_STRINGS - // not threadsafe - 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); - #endif - return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); - } - stbi__skip(s, c.length); - break; - } - // end of PNG chunk, read and skip CRC - stbi__get32be(s); - } -} - -static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) -{ - void *result=NULL; - if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); - if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { - if (p->depth < 8) - ri->bits_per_channel = 8; - else - ri->bits_per_channel = p->depth; - result = p->out; - p->out = NULL; - if (req_comp && req_comp != p->s->img_out_n) { - if (ri->bits_per_channel == 8) - result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); - else - result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); - p->s->img_out_n = req_comp; - if (result == NULL) return result; - } - *x = p->s->img_x; - *y = p->s->img_y; - if (n) *n = p->s->img_n; - } - STBI_FREE(p->out); p->out = NULL; - STBI_FREE(p->expanded); p->expanded = NULL; - STBI_FREE(p->idata); p->idata = NULL; - - return result; -} - -static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - stbi__png p; - p.s = s; - return stbi__do_png(&p, x,y,comp,req_comp, ri); -} - -static int stbi__png_test(stbi__context *s) -{ - int r; - r = stbi__check_png_header(s); - stbi__rewind(s); - return r; -} - -static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) -{ - if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { - stbi__rewind( p->s ); - 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; -} - -static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) -{ - stbi__png p; - p.s = s; - return stbi__png_info_raw(&p, x, y, comp); -} - -static int stbi__png_is16(stbi__context *s) -{ - stbi__png p; - p.s = s; - if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) - return 0; - if (p.depth != 16) { - stbi__rewind(p.s); - return 0; - } - return 1; -} -#endif - -// Microsoft/Windows BMP image - -#ifndef STBI_NO_BMP -static int stbi__bmp_test_raw(stbi__context *s) -{ - int r; - int sz; - 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); - r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); - return r; -} - -static int stbi__bmp_test(stbi__context *s) -{ - int r = stbi__bmp_test_raw(s); - stbi__rewind(s); - return r; -} - - -// returns 0..31 for the highest set bit -static int stbi__high_bit(unsigned int z) -{ - 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; -} - -static int stbi__bitcount(unsigned int a) -{ - 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; -} - -// extract an arbitrarily-aligned N-bit value (N=bits) -// from v, and then make it 8-bits long and fractionally -// extend it to full full range. -static int stbi__shiftsigned(int v, int shift, int bits) -{ - static unsigned int mul_table[9] = { - 0, - 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, - 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, - }; - static unsigned int shift_table[9] = { - 0, 0,0,1,0,2,4,6,0, - }; - if (shift < 0) - v <<= -shift; - else - v >>= shift; - STBI_ASSERT(v >= 0 && v < 256); - v >>= (8-bits); - STBI_ASSERT(bits >= 0 && bits <= 8); - return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; -} - -typedef struct -{ - int bpp, offset, hsz; - unsigned int mr,mg,mb,ma, all_a; -} stbi__bmp_data; - -static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) -{ - int hsz; - 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 - info->offset = stbi__get32le(s); - info->hsz = hsz = stbi__get32le(s); - info->mr = info->mg = info->mb = info->ma = 0; - - if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); - if (hsz == 12) { - s->img_x = stbi__get16le(s); - s->img_y = stbi__get16le(s); - } else { - s->img_x = stbi__get32le(s); - s->img_y = stbi__get32le(s); - } - if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); - info->bpp = stbi__get16le(s); - if (hsz != 12) { - int compress = stbi__get32le(s); - if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); - 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 - if (hsz == 40 || hsz == 56) { - if (hsz == 56) { - stbi__get32le(s); - stbi__get32le(s); - stbi__get32le(s); - stbi__get32le(s); - } - if (info->bpp == 16 || info->bpp == 32) { - if (compress == 0) { - if (info->bpp == 32) { - info->mr = 0xffu << 16; - info->mg = 0xffu << 8; - info->mb = 0xffu << 0; - info->ma = 0xffu << 24; - info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 - } else { - info->mr = 31u << 10; - info->mg = 31u << 5; - info->mb = 31u << 0; - } - } else if (compress == 3) { - info->mr = stbi__get32le(s); - info->mg = stbi__get32le(s); - info->mb = stbi__get32le(s); - // not documented, but generated by photoshop and handled by mspaint - if (info->mr == info->mg && info->mg == info->mb) { - // ?!?!? - return stbi__errpuc("bad BMP", "bad BMP"); - } - } else - return stbi__errpuc("bad BMP", "bad BMP"); - } - } else { - int i; - if (hsz != 108 && hsz != 124) - return stbi__errpuc("bad BMP", "bad BMP"); - info->mr = stbi__get32le(s); - info->mg = stbi__get32le(s); - info->mb = stbi__get32le(s); - info->ma = stbi__get32le(s); - stbi__get32le(s); // discard color space - for (i=0; i < 12; ++i) - stbi__get32le(s); // discard color space parameters - 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 - } - } - } - return (void *) 1; -} - - -static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - stbi_uc *out; - unsigned int mr=0,mg=0,mb=0,ma=0, all_a; - stbi_uc pal[256][4]; - int psize=0,i,j,width; - int flip_vertically, pad, target; - stbi__bmp_data info; - STBI_NOTUSED(ri); - - info.all_a = 255; - if (stbi__bmp_parse_header(s, &info) == NULL) - return NULL; // error code already set - - flip_vertically = ((int) s->img_y) > 0; - s->img_y = abs((int) s->img_y); - - mr = info.mr; - mg = info.mg; - mb = info.mb; - ma = info.ma; - all_a = info.all_a; - - if (info.hsz == 12) { - if (info.bpp < 24) - psize = (info.offset - 14 - 24) / 3; - } else { - if (info.bpp < 16) - psize = (info.offset - 14 - info.hsz) >> 2; - } - - s->img_n = ma ? 4 : 3; - if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 - target = req_comp; - else - target = s->img_n; // if they want monochrome, we'll post-convert - - // sanity-check size - if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) - return stbi__errpuc("too large", "Corrupt BMP"); - - out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); - if (!out) return stbi__errpuc("outofmem", "Out of memory"); - if (info.bpp < 16) { - int z=0; - if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } - for (i=0; i < psize; ++i) { - pal[i][2] = stbi__get8(s); - pal[i][1] = stbi__get8(s); - pal[i][0] = stbi__get8(s); - if (info.hsz != 12) stbi__get8(s); - pal[i][3] = 255; - } - stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); - if (info.bpp == 1) width = (s->img_x + 7) >> 3; - else if (info.bpp == 4) width = (s->img_x + 1) >> 1; - else if (info.bpp == 8) width = s->img_x; - else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } - pad = (-width)&3; - if (info.bpp == 1) { - for (j=0; j < (int) s->img_y; ++j) { - int bit_offset = 7, v = stbi__get8(s); - for (i=0; i < (int) s->img_x; ++i) { - int color = (v>>bit_offset)&0x1; - out[z++] = pal[color][0]; - out[z++] = pal[color][1]; - out[z++] = pal[color][2]; - if((--bit_offset) < 0) { - bit_offset = 7; - v = stbi__get8(s); - } - } - stbi__skip(s, pad); - } - } else { - for (j=0; j < (int) s->img_y; ++j) { - for (i=0; i < (int) s->img_x; i += 2) { - int v=stbi__get8(s),v2=0; - if (info.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; - v = (info.bpp == 8) ? stbi__get8(s) : v2; - out[z++] = pal[v][0]; - out[z++] = pal[v][1]; - out[z++] = pal[v][2]; - if (target == 4) out[z++] = 255; - } - stbi__skip(s, pad); - } - } - } else { - int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; - int z = 0; - int easy=0; - stbi__skip(s, info.offset - 14 - info.hsz); - if (info.bpp == 24) width = 3 * s->img_x; - else if (info.bpp == 16) width = 2*s->img_x; - else /* bpp = 32 and pad = 0 */ width=0; - pad = (-width) & 3; - if (info.bpp == 24) { - easy = 1; - } else if (info.bpp == 32) { - if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) - easy = 2; - } - if (!easy) { - if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } - // right shift amt to put high bit in position #7 - rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); - gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); - bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); - ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); - } - for (j=0; j < (int) s->img_y; ++j) { - if (easy) { - for (i=0; i < (int) s->img_x; ++i) { - unsigned char a; - out[z+2] = stbi__get8(s); - out[z+1] = stbi__get8(s); - out[z+0] = stbi__get8(s); - z += 3; - a = (easy == 2 ? stbi__get8(s) : 255); - all_a |= a; - if (target == 4) out[z++] = a; - } - } else { - int bpp = info.bpp; - for (i=0; i < (int) s->img_x; ++i) { - stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); - unsigned int a; - 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)); - a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); - all_a |= a; - if (target == 4) out[z++] = STBI__BYTECAST(a); - } - } - stbi__skip(s, pad); - } - } - - // if alpha channel is all 0s, replace with all 255s - if (target == 4 && all_a == 0) - for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) - out[i] = 255; - - 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) { - 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 - } - - *x = s->img_x; - *y = s->img_y; - if (comp) *comp = s->img_n; - return out; -} -#endif - -// Targa Truevision - TGA -// by Jonathan Dummer -#ifndef STBI_NO_TGA -// returns STBI_rgb or whatever, 0 on error -static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) -{ - // only RGB or RGBA (incl. 16bit) or grey allowed - if (is_rgb16) *is_rgb16 = 0; - switch(bits_per_pixel) { - case 8: return STBI_grey; - case 16: if(is_grey) return STBI_grey_alpha; - // fallthrough - case 15: if(is_rgb16) *is_rgb16 = 1; - return STBI_rgb; - case 24: // fallthrough - case 32: return bits_per_pixel/8; - default: return 0; - } -} - -static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) -{ - int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; - int sz, tga_colormap_type; - stbi__get8(s); // discard Offset - tga_colormap_type = stbi__get8(s); // colormap type - if( tga_colormap_type > 1 ) { - stbi__rewind(s); - return 0; // only RGB or indexed allowed - } - tga_image_type = stbi__get8(s); // image type - if ( tga_colormap_type == 1 ) { // colormapped (paletted) image - if (tga_image_type != 1 && tga_image_type != 9) { - stbi__rewind(s); - return 0; - } - stbi__skip(s,4); // skip index of first colormap entry and number of entries - sz = stbi__get8(s); // check bits per palette color entry - if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { - stbi__rewind(s); - return 0; - } - stbi__skip(s,4); // skip image x and y origin - tga_colormap_bpp = sz; - } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE - if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { - stbi__rewind(s); - return 0; // only RGB or grey allowed, +/- RLE - } - stbi__skip(s,9); // skip colormap specification and image x/y origin - tga_colormap_bpp = 0; - } - tga_w = stbi__get16le(s); - if( tga_w < 1 ) { - stbi__rewind(s); - return 0; // test width - } - tga_h = stbi__get16le(s); - if( tga_h < 1 ) { - stbi__rewind(s); - return 0; // test height - } - tga_bits_per_pixel = stbi__get8(s); // bits per pixel - stbi__get8(s); // ignore alpha bits - if (tga_colormap_bpp != 0) { - if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { - // when using a colormap, tga_bits_per_pixel is the size of the indexes - // I don't think anything but 8 or 16bit indexes makes sense - stbi__rewind(s); - return 0; - } - tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); - } else { - tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); - } - if(!tga_comp) { - stbi__rewind(s); - return 0; - } - if (x) *x = tga_w; - if (y) *y = tga_h; - if (comp) *comp = tga_comp; - return 1; // seems to have passed everything -} - -static int stbi__tga_test(stbi__context *s) -{ - int res = 0; - int sz, tga_color_type; - stbi__get8(s); // discard Offset - tga_color_type = stbi__get8(s); // color type - if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed - sz = stbi__get8(s); // image type - if ( tga_color_type == 1 ) { // colormapped (paletted) image - if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 - stbi__skip(s,4); // skip index of first colormap entry and number of entries - sz = stbi__get8(s); // check bits per palette color entry - if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; - stbi__skip(s,4); // skip image x and y origin - } else { // "normal" image w/o colormap - if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE - stbi__skip(s,9); // skip colormap specification and image x/y origin - } - if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width - if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height - sz = stbi__get8(s); // bits per pixel - if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index - if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; - - res = 1; // if we got this far, everything's good and we can return 1 instead of 0 - -errorEnd: - stbi__rewind(s); - return res; -} - -// read 16bit value and convert to 24bit RGB -static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) -{ - stbi__uint16 px = (stbi__uint16)stbi__get16le(s); - stbi__uint16 fiveBitMask = 31; - // we have 3 channels with 5bits each - int r = (px >> 10) & fiveBitMask; - int g = (px >> 5) & fiveBitMask; - int b = px & fiveBitMask; - // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later - out[0] = (stbi_uc)((r * 255)/31); - out[1] = (stbi_uc)((g * 255)/31); - out[2] = (stbi_uc)((b * 255)/31); - - // some people claim that the most significant bit might be used for alpha - // (possibly if an alpha-bit is set in the "image descriptor byte") - // but that only made 16bit test images completely translucent.. - // so let's treat all 15 and 16bit TGAs as RGB with no alpha. -} - -static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - // read in the TGA header stuff - int tga_offset = stbi__get8(s); - int tga_indexed = stbi__get8(s); - int tga_image_type = stbi__get8(s); - int tga_is_RLE = 0; - int tga_palette_start = stbi__get16le(s); - int tga_palette_len = stbi__get16le(s); - int tga_palette_bits = stbi__get8(s); - 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); - int tga_bits_per_pixel = stbi__get8(s); - int tga_comp, tga_rgb16=0; - int tga_inverted = stbi__get8(s); - // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) - // image data - unsigned char *tga_data; - unsigned char *tga_palette = NULL; - int i, j; - unsigned char raw_data[4] = {0}; - int RLE_count = 0; - int RLE_repeating = 0; - int read_next_pixel = 1; - STBI_NOTUSED(ri); - - // do a tiny bit of precessing - if ( tga_image_type >= 8 ) - { - tga_image_type -= 8; - tga_is_RLE = 1; - } - tga_inverted = 1 - ((tga_inverted >> 5) & 1); - - // If I'm paletted, then I'll use the number of bits from the palette - if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); - else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); - - if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency - return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); - - // tga info - *x = tga_width; - *y = tga_height; - if (comp) *comp = tga_comp; - - if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) - return stbi__errpuc("too large", "Corrupt TGA"); - - tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); - if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); - - // skip to the data's starting position (offset usually = 0) - stbi__skip(s, tga_offset ); - - if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { - for (i=0; i < tga_height; ++i) { - int row = tga_inverted ? tga_height -i - 1 : i; - stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; - stbi__getn(s, tga_row, tga_width * tga_comp); - } - } else { - // do I need to load a palette? - if ( tga_indexed) - { - // any data to skip? (offset usually = 0) - stbi__skip(s, tga_palette_start ); - // load the palette - tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); - if (!tga_palette) { - STBI_FREE(tga_data); - return stbi__errpuc("outofmem", "Out of memory"); - } - if (tga_rgb16) { - stbi_uc *pal_entry = tga_palette; - STBI_ASSERT(tga_comp == STBI_rgb); - for (i=0; i < tga_palette_len; ++i) { - stbi__tga_read_rgb16(s, pal_entry); - pal_entry += tga_comp; - } - } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { - STBI_FREE(tga_data); - STBI_FREE(tga_palette); - return stbi__errpuc("bad palette", "Corrupt TGA"); - } - } - // load the data - for (i=0; i < tga_width * tga_height; ++i) - { - // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? - if ( tga_is_RLE ) - { - if ( RLE_count == 0 ) - { - // yep, get the next byte as a RLE command - int RLE_cmd = stbi__get8(s); - 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 index, then perform the lookup - int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); - if ( pal_idx >= tga_palette_len ) { - // invalid index - pal_idx = 0; - } - pal_idx *= tga_comp; - for (j = 0; j < tga_comp; ++j) { - raw_data[j] = tga_palette[pal_idx+j]; - } - } else if(tga_rgb16) { - STBI_ASSERT(tga_comp == STBI_rgb); - stbi__tga_read_rgb16(s, raw_data); - } else { - // read in the data raw - for (j = 0; j < tga_comp; ++j) { - raw_data[j] = stbi__get8(s); - } - } - // 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) - { - 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) - { - 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 ) - { - STBI_FREE( tga_palette ); - } - } - - // swap RGB - if the source data was RGB16, it already is in the right order - if (tga_comp >= 3 && !tga_rgb16) - { - 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) - tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); - - // 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; -} -#endif - -// ************************************************************************************************* -// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB - -#ifndef STBI_NO_PSD -static int stbi__psd_test(stbi__context *s) -{ - int r = (stbi__get32be(s) == 0x38425053); - stbi__rewind(s); - return r; -} - -static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) -{ - int count, nleft, len; - - count = 0; - while ((nleft = pixelCount - count) > 0) { - len = stbi__get8(s); - if (len == 128) { - // No-op. - } else if (len < 128) { - // Copy next len+1 bytes literally. - len++; - if (len > nleft) return 0; // corrupt data - count += len; - while (len) { - *p = stbi__get8(s); - p += 4; - len--; - } - } else if (len > 128) { - stbi_uc val; - // Next -len+1 bytes in the dest are replicated from next source byte. - // (Interpret len as a negative 8-bit int.) - len = 257 - len; - if (len > nleft) return 0; // corrupt data - val = stbi__get8(s); - count += len; - while (len) { - *p = val; - p += 4; - len--; - } - } - } - - return 1; -} - -static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) -{ - int pixelCount; - int channelCount, compression; - int channel, i; - int bitdepth; - int w,h; - stbi_uc *out; - STBI_NOTUSED(ri); - - // Check identifier - if (stbi__get32be(s) != 0x38425053) // "8BPS" - return stbi__errpuc("not PSD", "Corrupt PSD image"); - - // Check file type version. - if (stbi__get16be(s) != 1) - return stbi__errpuc("wrong version", "Unsupported version of PSD image"); - - // Skip 6 reserved bytes. - stbi__skip(s, 6 ); - - // Read the number of channels (R, G, B, A, etc). - channelCount = stbi__get16be(s); - if (channelCount < 0 || channelCount > 16) - return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); - - // Read the rows and columns of the image. - h = stbi__get32be(s); - w = stbi__get32be(s); - - // Make sure the depth is 8 bits. - bitdepth = stbi__get16be(s); - if (bitdepth != 8 && bitdepth != 16) - return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); - - // 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 - if (stbi__get16be(s) != 3) - return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); - - // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) - stbi__skip(s,stbi__get32be(s) ); - - // Skip the image resources. (resolution, pen tool paths, etc) - stbi__skip(s, stbi__get32be(s) ); - - // Skip the reserved data. - stbi__skip(s, stbi__get32be(s) ); - - // Find out if the data is compressed. - // Known values: - // 0: no compression - // 1: RLE compressed - compression = stbi__get16be(s); - if (compression > 1) - return stbi__errpuc("bad compression", "PSD has an unknown compression format"); - - // Check size - if (!stbi__mad3sizes_valid(4, w, h, 0)) - return stbi__errpuc("too large", "Corrupt PSD"); - - // Create the destination image. - - if (!compression && bitdepth == 16 && bpc == 16) { - out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); - ri->bits_per_channel = 16; - } else - out = (stbi_uc *) stbi__malloc(4 * w*h); - - if (!out) return stbi__errpuc("outofmem", "Out of memory"); - pixelCount = w*h; - - // Initialize the data to zero. - //memset( out, 0, pixelCount * 4 ); - - // Finally, the image data. - if (compression) { - // RLE as used by .PSD and .TIFF - // Loop until you get the number of unpacked bytes you are expecting: - // Read the next source byte into n. - // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. - // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. - // 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, - // which we're going to just skip. - stbi__skip(s, h * channelCount * 2 ); - - // Read the RLE data by channel. - for (channel = 0; channel < 4; channel++) { - stbi_uc *p; - - p = out+channel; - if (channel >= channelCount) { - // Fill this channel with default data. - for (i = 0; i < pixelCount; i++, p += 4) - *p = (channel == 3 ? 255 : 0); - } else { - // Read the RLE data. - if (!stbi__psd_decode_rle(s, p, pixelCount)) { - STBI_FREE(out); - return stbi__errpuc("corrupt", "bad RLE data"); - } - } - } - - } 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 (or 16-bit) value for each pixel in the image. - - // Read the data by channel. - for (channel = 0; channel < 4; channel++) { - if (channel >= channelCount) { - // Fill this channel with default data. - if (bitdepth == 16 && bpc == 16) { - stbi__uint16 *q = ((stbi__uint16 *) out) + channel; - stbi__uint16 val = channel == 3 ? 65535 : 0; - for (i = 0; i < pixelCount; i++, q += 4) - *q = val; - } else { - stbi_uc *p = out+channel; - stbi_uc val = channel == 3 ? 255 : 0; - for (i = 0; i < pixelCount; i++, p += 4) - *p = val; - } - } else { - if (ri->bits_per_channel == 16) { // output bpc - stbi__uint16 *q = ((stbi__uint16 *) out) + channel; - for (i = 0; i < pixelCount; i++, q += 4) - *q = (stbi__uint16) stbi__get16be(s); - } else { - stbi_uc *p = out+channel; - if (bitdepth == 16) { // input bpc - for (i = 0; i < pixelCount; i++, p += 4) - *p = (stbi_uc) (stbi__get16be(s) >> 8); - } else { - for (i = 0; i < pixelCount; i++, p += 4) - *p = stbi__get8(s); - } - } - } - } - } - - // remove weird white matte from PSD - if (channelCount >= 4) { - if (ri->bits_per_channel == 16) { - for (i=0; i < w*h; ++i) { - stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; - if (pixel[3] != 0 && pixel[3] != 65535) { - float a = pixel[3] / 65535.0f; - float ra = 1.0f / a; - float inv_a = 65535.0f * (1 - ra); - pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); - pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); - pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); - } - } - } else { - for (i=0; i < w*h; ++i) { - unsigned char *pixel = out + 4*i; - if (pixel[3] != 0 && pixel[3] != 255) { - float a = pixel[3] / 255.0f; - float ra = 1.0f / a; - float inv_a = 255.0f * (1 - ra); - pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); - pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); - pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); - } - } - } - } - - // convert to desired output format - if (req_comp && req_comp != 4) { - if (ri->bits_per_channel == 16) - out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); - else - out = stbi__convert_format(out, 4, req_comp, w, h); - if (out == NULL) return out; // stbi__convert_format frees input on failure - } - - if (comp) *comp = 4; - *y = h; - *x = w; - - return out; -} -#endif - -// ************************************************************************************************* -// 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/ - -#ifndef STBI_NO_PIC -static int stbi__pic_is4(stbi__context *s,const char *str) -{ - int i; - for (i=0; i<4; ++i) - if (stbi__get8(s) != (stbi_uc)str[i]) - return 0; - - return 1; -} - -static int stbi__pic_test_core(stbi__context *s) -{ - int i; - - if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) - return 0; - - for(i=0;i<84;++i) - stbi__get8(s); - - if (!stbi__pic_is4(s,"PICT")) - return 0; - - return 1; -} - -typedef struct -{ - stbi_uc size,type,channel; -} stbi__pic_packet; - -static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) -{ - int mask=0x80, i; - - for (i=0; i<4; ++i, mask>>=1) { - if (channel & mask) { - if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); - dest[i]=stbi__get8(s); - } - } - - return dest; -} - -static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) -{ - int mask=0x80,i; - - for (i=0;i<4; ++i, mask>>=1) - if (channel&mask) - dest[i]=src[i]; -} - -static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) -{ - int act_comp=0,num_packets=0,y,chained; - stbi__pic_packet packets[10]; - - // this will (should...) cater for even some bizarre stuff like having data - // for the same channel in multiple packets. - do { - stbi__pic_packet *packet; - - if (num_packets==sizeof(packets)/sizeof(packets[0])) - return stbi__errpuc("bad format","too many packets"); - - packet = &packets[num_packets++]; - - chained = stbi__get8(s); - packet->size = stbi__get8(s); - packet->type = stbi__get8(s); - packet->channel = stbi__get8(s); - - act_comp |= packet->channel; - - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); - if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); - } while (chained); - - *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? - - for(y=0; ytype) { - default: - return stbi__errpuc("bad format","packet has bad compression type"); - - case 0: {//uncompressed - int x; - - for(x=0;xchannel,dest)) - return 0; - break; - } - - case 1://Pure RLE - { - int left=width, i; - - while (left>0) { - stbi_uc count,value[4]; - - count=stbi__get8(s); - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); - - if (count > left) - count = (stbi_uc) left; - - if (!stbi__readval(s,packet->channel,value)) return 0; - - for(i=0; ichannel,dest,value); - left -= count; - } - } - break; - - case 2: {//Mixed RLE - int left=width; - while (left>0) { - int count = stbi__get8(s), i; - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); - - if (count >= 128) { // Repeated - stbi_uc value[4]; - - if (count==128) - count = stbi__get16be(s); - else - count -= 127; - if (count > left) - return stbi__errpuc("bad file","scanline overrun"); - - if (!stbi__readval(s,packet->channel,value)) - return 0; - - for(i=0;ichannel,dest,value); - } else { // Raw - ++count; - if (count>left) return stbi__errpuc("bad file","scanline overrun"); - - for(i=0;ichannel,dest)) - return 0; - } - left-=count; - } - break; - } - } - } - } - - return result; -} - -static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) -{ - stbi_uc *result; - int i, x,y, internal_comp; - STBI_NOTUSED(ri); - - if (!comp) comp = &internal_comp; - - for (i=0; i<92; ++i) - stbi__get8(s); - - x = stbi__get16be(s); - y = stbi__get16be(s); - if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); - if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); - - stbi__get32be(s); //skip `ratio' - stbi__get16be(s); //skip `fields' - stbi__get16be(s); //skip `pad' - - // intermediate buffer is RGBA - result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); - memset(result, 0xff, x*y*4); - - if (!stbi__pic_load_core(s,x,y,comp, result)) { - STBI_FREE(result); - result=0; - } - *px = x; - *py = y; - if (req_comp == 0) req_comp = *comp; - result=stbi__convert_format(result,4,req_comp,x,y); - - return result; -} - -static int stbi__pic_test(stbi__context *s) -{ - int r = stbi__pic_test_core(s); - stbi__rewind(s); - return r; -} -#endif - -// ************************************************************************************************* -// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb - -#ifndef STBI_NO_GIF -typedef struct -{ - stbi__int16 prefix; - stbi_uc first; - stbi_uc suffix; -} stbi__gif_lzw; - -typedef struct -{ - int w,h; - stbi_uc *out; // output buffer (always 4 components) - stbi_uc *background; // The current "background" as far as a gif is concerned - stbi_uc *history; - int flags, bgindex, ratio, transparent, eflags; - stbi_uc pal[256][4]; - stbi_uc lpal[256][4]; - stbi__gif_lzw codes[8192]; - stbi_uc *color_table; - int parse, step; - int lflags; - int start_x, start_y; - int max_x, max_y; - int cur_x, cur_y; - int line_size; - int delay; -} stbi__gif; - -static int stbi__gif_test_raw(stbi__context *s) -{ - int sz; - if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; - sz = stbi__get8(s); - if (sz != '9' && sz != '7') return 0; - if (stbi__get8(s) != 'a') return 0; - return 1; -} - -static int stbi__gif_test(stbi__context *s) -{ - int r = stbi__gif_test_raw(s); - stbi__rewind(s); - return r; -} - -static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) -{ - int i; - for (i=0; i < num_entries; ++i) { - pal[i][2] = stbi__get8(s); - pal[i][1] = stbi__get8(s); - pal[i][0] = stbi__get8(s); - pal[i][3] = transp == i ? 0 : 255; - } -} - -static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) -{ - stbi_uc version; - if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') - return stbi__err("not GIF", "Corrupt GIF"); - - version = stbi__get8(s); - if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); - if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); - - stbi__g_failure_reason = ""; - 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); - 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) - stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); - - return 1; -} - -static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) -{ - stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); - if (!stbi__gif_header(s, g, comp, 1)) { - STBI_FREE(g); - stbi__rewind( s ); - return 0; - } - if (x) *x = g->w; - if (y) *y = g->h; - STBI_FREE(g); - return 1; -} - -static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) -{ - stbi_uc *p, *c; - int idx; - - // recurse to decode the prefixes, since the linked-list is backwards, - // and working backwards through an interleaved image would be nasty - if (g->codes[code].prefix >= 0) - stbi__out_gif_code(g, g->codes[code].prefix); - - if (g->cur_y >= g->max_y) return; - - idx = g->cur_x + g->cur_y; - p = &g->out[idx]; - g->history[idx / 4] = 1; - - c = &g->color_table[g->codes[code].suffix * 4]; - if (c[3] > 128) { // don't render transparent pixels; - 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; - } - } -} - -static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) -{ - stbi_uc lzw_cs; - stbi__int32 len, init_code; - stbi__uint32 first; - stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; - stbi__gif_lzw *p; - - lzw_cs = stbi__get8(s); - if (lzw_cs > 12) return NULL; - clear = 1 << lzw_cs; - first = 1; - codesize = lzw_cs + 1; - codemask = (1 << codesize) - 1; - bits = 0; - valid_bits = 0; - for (init_code = 0; init_code < clear; init_code++) { - g->codes[init_code].prefix = -1; - g->codes[init_code].first = (stbi_uc) init_code; - g->codes[init_code].suffix = (stbi_uc) init_code; - } - - // support no starting clear code - avail = clear+2; - oldcode = -1; - - len = 0; - for(;;) { - if (valid_bits < codesize) { - if (len == 0) { - len = stbi__get8(s); // start new block - if (len == 0) - return g->out; - } - --len; - bits |= (stbi__int32) stbi__get8(s) << valid_bits; - 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 - stbi__skip(s, len); - while ((len = stbi__get8(s)) > 0) - stbi__skip(s,len); - return g->out; - } else if (code <= avail) { - if (first) { - return stbi__errpuc("no clear code", "Corrupt GIF"); - } - - if (oldcode >= 0) { - p = &g->codes[avail++]; - if (avail > 8192) { - return stbi__errpuc("too many codes", "Corrupt GIF"); - } - - 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) - return stbi__errpuc("illegal code in raster", "Corrupt GIF"); - - stbi__out_gif_code(g, (stbi__uint16) code); - - if ((avail & codemask) == 0 && avail <= 0x0FFF) { - codesize++; - codemask = (1 << codesize) - 1; - } - - oldcode = code; - } else { - return stbi__errpuc("illegal code in raster", "Corrupt GIF"); - } - } - } -} - -// this function is designed to support animated gifs, although stb_image doesn't support it -// two back is the image from two frames ago, used for a very specific disposal format -static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) -{ - int dispose; - int first_frame; - int pi; - int pcount; - - // on first frame, any non-written pixels get the background colour (non-transparent) - first_frame = 0; - if (g->out == 0) { - if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header - g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h); - g->background = (stbi_uc *) stbi__malloc(4 * g->w * g->h); - g->history = (stbi_uc *) stbi__malloc(g->w * g->h); - if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); - - // image is treated as "tranparent" at the start - ie, nothing overwrites the current background; - // background colour is only used for pixels that are not rendered first frame, after that "background" - // color refers to teh color that was there the previous frame. - memset( g->out, 0x00, 4 * g->w * g->h ); - memset( g->background, 0x00, 4 * g->w * g->h ); // state of the background (starts transparent) - memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame - first_frame = 1; - } else { - // second frame - how do we dispoase of the previous one? - dispose = (g->eflags & 0x1C) >> 2; - pcount = g->w * g->h; - - if ((dispose == 3) && (two_back == 0)) { - dispose = 2; // if I don't have an image to revert back to, default to the old background - } - - if (dispose == 3) { // use previous graphic - for (pi = 0; pi < pcount; ++pi) { - if (g->history[pi]) { - memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); - } - } - } else if (dispose == 2) { - // restore what was changed last frame to background before that frame; - for (pi = 0; pi < pcount; ++pi) { - if (g->history[pi]) { - memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); - } - } - } else { - // This is a non-disposal case eithe way, so just - // leave the pixels as is, and they will become the new background - // 1: do not dispose - // 0: not specified. - } - - // background is what out is after the undoing of the previou frame; - memcpy( g->background, g->out, 4 * g->w * g->h ); - } - - // clear my history; - memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame - - for (;;) { - int tag = stbi__get8(s); - switch (tag) { - case 0x2C: /* Image Descriptor */ - { - stbi__int32 x, y, w, h; - stbi_uc *o; - - x = stbi__get16le(s); - y = stbi__get16le(s); - w = stbi__get16le(s); - h = stbi__get16le(s); - if (((x + w) > (g->w)) || ((y + h) > (g->h))) - return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); - - 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; - - g->lflags = stbi__get8(s); - - 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) { - stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); - g->color_table = (stbi_uc *) g->lpal; - } else if (g->flags & 0x80) { - g->color_table = (stbi_uc *) g->pal; - } else - return stbi__errpuc("missing color table", "Corrupt GIF"); - - o = stbi__process_gif_raster(s, g); - if (o == NULL) return NULL; - - // if this was the first frame, - pcount = g->w * g->h; - if (first_frame && (g->bgindex > 0)) { - // if first frame, any pixel not drawn to gets the background color - for (pi = 0; pi < pcount; ++pi) { - if (g->history[pi] == 0) { - g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; - memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); - } - } - } - - return o; - } - - case 0x21: // Comment Extension. - { - int len; - int ext = stbi__get8(s); - if (ext == 0xF9) { // Graphic Control Extension. - len = stbi__get8(s); - if (len == 4) { - g->eflags = stbi__get8(s); - g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. - - // unset old transparent - if (g->transparent >= 0) { - g->pal[g->transparent][3] = 255; - } - if (g->eflags & 0x01) { - g->transparent = stbi__get8(s); - if (g->transparent >= 0) { - g->pal[g->transparent][3] = 0; - } - } else { - // don't need transparent - stbi__skip(s, 1); - g->transparent = -1; - } - } else { - stbi__skip(s, len); - break; - } - } - while ((len = stbi__get8(s)) != 0) { - stbi__skip(s, len); - } - break; - } - - case 0x3B: // gif stream termination code - return (stbi_uc *) s; // using '1' causes warning on some compilers - - default: - return stbi__errpuc("unknown code", "Corrupt GIF"); - } - } -} - -static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) -{ - if (stbi__gif_test(s)) { - int layers = 0; - stbi_uc *u = 0; - stbi_uc *out = 0; - stbi_uc *two_back = 0; - stbi__gif g; - int stride; - memset(&g, 0, sizeof(g)); - if (delays) { - *delays = 0; - } - - do { - u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); - if (u == (stbi_uc *) s) u = 0; // end of animated gif marker - - if (u) { - *x = g.w; - *y = g.h; - ++layers; - stride = g.w * g.h * 4; - - if (out) { - out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); - if (delays) { - *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); - } - } else { - out = (stbi_uc*)stbi__malloc( layers * stride ); - if (delays) { - *delays = (int*) stbi__malloc( layers * sizeof(int) ); - } - } - memcpy( out + ((layers - 1) * stride), u, stride ); - if (layers >= 2) { - two_back = out - 2 * stride; - } - - if (delays) { - (*delays)[layers - 1U] = g.delay; - } - } - } while (u != 0); - - // free temp buffer; - STBI_FREE(g.out); - STBI_FREE(g.history); - STBI_FREE(g.background); - - // do the final conversion after loading everything; - if (req_comp && req_comp != 4) - out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); - - *z = layers; - return out; - } else { - return stbi__errpuc("not GIF", "Image was not as a gif type."); - } -} - -static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - stbi_uc *u = 0; - stbi__gif g; - memset(&g, 0, sizeof(g)); - - u = stbi__gif_load_next(s, &g, comp, req_comp, 0); - if (u == (stbi_uc *) s) u = 0; // end of animated gif marker - if (u) { - *x = g.w; - *y = g.h; - - // moved conversion to after successful load so that the same - // can be done for multiple frames. - if (req_comp && req_comp != 4) - u = stbi__convert_format(u, 4, req_comp, g.w, g.h); - } - - // free buffers needed for multiple frame loading; - STBI_FREE(g.history); - STBI_FREE(g.background); - - return u; -} - -static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) -{ - return stbi__gif_info_raw(s,x,y,comp); -} -#endif - -// ************************************************************************************************* -// Radiance RGBE HDR loader -// originally by Nicolas Schulz -#ifndef STBI_NO_HDR -static int stbi__hdr_test_core(stbi__context *s, const char *signature) -{ - int i; - for (i=0; signature[i]; ++i) - if (stbi__get8(s) != signature[i]) - return 0; - stbi__rewind(s); - return 1; -} - -static int stbi__hdr_test(stbi__context* s) -{ - int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); - stbi__rewind(s); - if(!r) { - r = stbi__hdr_test_core(s, "#?RGBE\n"); - stbi__rewind(s); - } - return r; -} - -#define STBI__HDR_BUFLEN 1024 -static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) -{ - int len=0; - char c = '\0'; - - c = (char) stbi__get8(z); - - while (!stbi__at_eof(z) && c != '\n') { - buffer[len++] = c; - if (len == STBI__HDR_BUFLEN-1) { - // flush to end of line - while (!stbi__at_eof(z) && stbi__get8(z) != '\n') - ; - break; - } - c = (char) stbi__get8(z); - } - - buffer[len] = 0; - return buffer; -} - -static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) -{ - 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; - } - } -} - -static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - char buffer[STBI__HDR_BUFLEN]; - 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; - const char *headerToken; - STBI_NOTUSED(ri); - - // Check identifier - headerToken = stbi__hdr_gettoken(s,buffer); - if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) - return stbi__errpf("not HDR", "Corrupt HDR image"); - - // Parse header - for(;;) { - token = stbi__hdr_gettoken(s,buffer); - if (token[0] == 0) break; - if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; - } - - if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); - - // Parse width and height - // can't use sscanf() if we're not using stdio! - token = stbi__hdr_gettoken(s,buffer); - if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); - token += 3; - height = (int) strtol(token, &token, 10); - while (*token == ' ') ++token; - if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); - token += 3; - width = (int) strtol(token, NULL, 10); - - *x = width; - *y = height; - - if (comp) *comp = 3; - if (req_comp == 0) req_comp = 3; - - if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) - return stbi__errpf("too large", "HDR image is too large"); - - // Read data - hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); - if (!hdr_data) - return stbi__errpf("outofmem", "Out of memory"); - - // 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: - stbi__getn(s, rgbe, 4); - stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); - } - } - } else { - // Read RLE-encoded data - scanline = NULL; - - for (j = 0; j < height; ++j) { - c1 = stbi__get8(s); - c2 = stbi__get8(s); - len = stbi__get8(s); - 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) - stbi_uc rgbe[4]; - rgbe[0] = (stbi_uc) c1; - rgbe[1] = (stbi_uc) c2; - rgbe[2] = (stbi_uc) len; - rgbe[3] = (stbi_uc) stbi__get8(s); - stbi__hdr_convert(hdr_data, rgbe, req_comp); - i = 1; - j = 0; - STBI_FREE(scanline); - goto main_decode_loop; // yes, this makes no sense - } - len <<= 8; - len |= stbi__get8(s); - if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } - if (scanline == NULL) { - scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); - if (!scanline) { - STBI_FREE(hdr_data); - return stbi__errpf("outofmem", "Out of memory"); - } - } - - for (k = 0; k < 4; ++k) { - int nleft; - i = 0; - while ((nleft = width - i) > 0) { - count = stbi__get8(s); - if (count > 128) { - // Run - value = stbi__get8(s); - count -= 128; - if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } - for (z = 0; z < count; ++z) - scanline[i++ * 4 + k] = value; - } else { - // Dump - if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } - for (z = 0; z < count; ++z) - scanline[i++ * 4 + k] = stbi__get8(s); - } - } - } - for (i=0; i < width; ++i) - stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); - } - if (scanline) - STBI_FREE(scanline); - } - - return hdr_data; -} - -static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) -{ - char buffer[STBI__HDR_BUFLEN]; - char *token; - int valid = 0; - int dummy; - - if (!x) x = &dummy; - if (!y) y = &dummy; - if (!comp) comp = &dummy; - - if (stbi__hdr_test(s) == 0) { - stbi__rewind( s ); - return 0; - } - - for(;;) { - token = stbi__hdr_gettoken(s,buffer); - if (token[0] == 0) break; - if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; - } - - if (!valid) { - stbi__rewind( s ); - return 0; - } - token = stbi__hdr_gettoken(s,buffer); - if (strncmp(token, "-Y ", 3)) { - stbi__rewind( s ); - return 0; - } - token += 3; - *y = (int) strtol(token, &token, 10); - while (*token == ' ') ++token; - if (strncmp(token, "+X ", 3)) { - stbi__rewind( s ); - return 0; - } - token += 3; - *x = (int) strtol(token, NULL, 10); - *comp = 3; - return 1; -} -#endif // STBI_NO_HDR - -#ifndef STBI_NO_BMP -static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) -{ - void *p; - stbi__bmp_data info; - - info.all_a = 255; - p = stbi__bmp_parse_header(s, &info); - stbi__rewind( s ); - if (p == NULL) - return 0; - if (x) *x = s->img_x; - if (y) *y = s->img_y; - if (comp) *comp = info.ma ? 4 : 3; - return 1; -} -#endif - -#ifndef STBI_NO_PSD -static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) -{ - int channelCount, dummy, depth; - if (!x) x = &dummy; - if (!y) y = &dummy; - if (!comp) comp = &dummy; - if (stbi__get32be(s) != 0x38425053) { - stbi__rewind( s ); - return 0; - } - if (stbi__get16be(s) != 1) { - stbi__rewind( s ); - return 0; - } - stbi__skip(s, 6); - channelCount = stbi__get16be(s); - if (channelCount < 0 || channelCount > 16) { - stbi__rewind( s ); - return 0; - } - *y = stbi__get32be(s); - *x = stbi__get32be(s); - depth = stbi__get16be(s); - if (depth != 8 && depth != 16) { - stbi__rewind( s ); - return 0; - } - if (stbi__get16be(s) != 3) { - stbi__rewind( s ); - return 0; - } - *comp = 4; - return 1; -} - -static int stbi__psd_is16(stbi__context *s) -{ - int channelCount, depth; - if (stbi__get32be(s) != 0x38425053) { - stbi__rewind( s ); - return 0; - } - if (stbi__get16be(s) != 1) { - stbi__rewind( s ); - return 0; - } - stbi__skip(s, 6); - channelCount = stbi__get16be(s); - if (channelCount < 0 || channelCount > 16) { - stbi__rewind( s ); - return 0; - } - (void) stbi__get32be(s); - (void) stbi__get32be(s); - depth = stbi__get16be(s); - if (depth != 16) { - stbi__rewind( s ); - return 0; - } - return 1; -} -#endif - -#ifndef STBI_NO_PIC -static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) -{ - int act_comp=0,num_packets=0,chained,dummy; - stbi__pic_packet packets[10]; - - if (!x) x = &dummy; - if (!y) y = &dummy; - if (!comp) comp = &dummy; - - if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { - stbi__rewind(s); - return 0; - } - - stbi__skip(s, 88); - - *x = stbi__get16be(s); - *y = stbi__get16be(s); - if (stbi__at_eof(s)) { - stbi__rewind( s); - return 0; - } - if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { - stbi__rewind( s ); - return 0; - } - - stbi__skip(s, 8); - - do { - stbi__pic_packet *packet; - - if (num_packets==sizeof(packets)/sizeof(packets[0])) - return 0; - - packet = &packets[num_packets++]; - chained = stbi__get8(s); - packet->size = stbi__get8(s); - packet->type = stbi__get8(s); - packet->channel = stbi__get8(s); - act_comp |= packet->channel; - - if (stbi__at_eof(s)) { - stbi__rewind( s ); - return 0; - } - if (packet->size != 8) { - stbi__rewind( s ); - return 0; - } - } while (chained); - - *comp = (act_comp & 0x10 ? 4 : 3); - - return 1; -} -#endif - -// ************************************************************************************************* -// Portable Gray Map and Portable Pixel Map loader -// by Ken Miller -// -// PGM: http://netpbm.sourceforge.net/doc/pgm.html -// PPM: http://netpbm.sourceforge.net/doc/ppm.html -// -// Known limitations: -// Does not support comments in the header section -// Does not support ASCII image data (formats P2 and P3) -// Does not support 16-bit-per-channel - -#ifndef STBI_NO_PNM - -static int stbi__pnm_test(stbi__context *s) -{ - char p, t; - p = (char) stbi__get8(s); - t = (char) stbi__get8(s); - if (p != 'P' || (t != '5' && t != '6')) { - stbi__rewind( s ); - return 0; - } - return 1; -} - -static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) -{ - stbi_uc *out; - STBI_NOTUSED(ri); - - if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) - return 0; - - *x = s->img_x; - *y = s->img_y; - if (comp) *comp = s->img_n; - - if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) - return stbi__errpuc("too large", "PNM too large"); - - out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); - if (!out) return stbi__errpuc("outofmem", "Out of memory"); - stbi__getn(s, out, s->img_n * s->img_x * s->img_y); - - if (req_comp && req_comp != s->img_n) { - out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); - if (out == NULL) return out; // stbi__convert_format frees input on failure - } - return out; -} - -static int stbi__pnm_isspace(char c) -{ - return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; -} - -static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) -{ - for (;;) { - while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) - *c = (char) stbi__get8(s); - - if (stbi__at_eof(s) || *c != '#') - break; - - while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) - *c = (char) stbi__get8(s); - } -} - -static int stbi__pnm_isdigit(char c) -{ - return c >= '0' && c <= '9'; -} - -static int stbi__pnm_getinteger(stbi__context *s, char *c) -{ - int value = 0; - - while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { - value = value*10 + (*c - '0'); - *c = (char) stbi__get8(s); - } - - return value; -} - -static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) -{ - int maxv, dummy; - char c, p, t; - - if (!x) x = &dummy; - if (!y) y = &dummy; - if (!comp) comp = &dummy; - - stbi__rewind(s); - - // Get identifier - p = (char) stbi__get8(s); - t = (char) stbi__get8(s); - if (p != 'P' || (t != '5' && t != '6')) { - stbi__rewind(s); - return 0; - } - - *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm - - c = (char) stbi__get8(s); - stbi__pnm_skip_whitespace(s, &c); - - *x = stbi__pnm_getinteger(s, &c); // read width - stbi__pnm_skip_whitespace(s, &c); - - *y = stbi__pnm_getinteger(s, &c); // read height - stbi__pnm_skip_whitespace(s, &c); - - maxv = stbi__pnm_getinteger(s, &c); // read max value - - if (maxv > 255) - return stbi__err("max value > 255", "PPM image not 8-bit"); - else - return 1; -} -#endif - -static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) -{ - #ifndef STBI_NO_JPEG - if (stbi__jpeg_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_PNG - if (stbi__png_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_GIF - if (stbi__gif_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_BMP - if (stbi__bmp_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_PSD - if (stbi__psd_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_PIC - if (stbi__pic_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_PNM - if (stbi__pnm_info(s, x, y, comp)) return 1; - #endif - - #ifndef STBI_NO_HDR - if (stbi__hdr_info(s, x, y, comp)) return 1; - #endif - - // test tga last because it's a crappy test! - #ifndef STBI_NO_TGA - if (stbi__tga_info(s, x, y, comp)) - return 1; - #endif - return stbi__err("unknown image type", "Image not of any known type, or corrupt"); -} - -static int stbi__is_16_main(stbi__context *s) -{ - #ifndef STBI_NO_PNG - if (stbi__png_is16(s)) return 1; - #endif - - #ifndef STBI_NO_PSD - if (stbi__psd_is16(s)) return 1; - #endif - - return 0; -} - -#ifndef STBI_NO_STDIO -STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) -{ - FILE *f = stbi__fopen(filename, "rb"); - int result; - if (!f) return stbi__err("can't fopen", "Unable to open file"); - 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; - stbi__context s; - long pos = ftell(f); - stbi__start_file(&s, f); - r = stbi__info_main(&s,x,y,comp); - fseek(f,pos,SEEK_SET); - return r; -} - -STBIDEF int stbi_is_16_bit(char const *filename) -{ - FILE *f = stbi__fopen(filename, "rb"); - int result; - if (!f) return stbi__err("can't fopen", "Unable to open file"); - result = stbi_is_16_bit_from_file(f); - fclose(f); - return result; -} - -STBIDEF int stbi_is_16_bit_from_file(FILE *f) -{ - int r; - stbi__context s; - long pos = ftell(f); - stbi__start_file(&s, f); - r = stbi__is_16_main(&s); - 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) -{ - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__info_main(&s,x,y,comp); -} - -STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) -{ - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); - return stbi__info_main(&s,x,y,comp); -} - -STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) -{ - stbi__context s; - stbi__start_mem(&s,buffer,len); - return stbi__is_16_main(&s); -} - -STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) -{ - stbi__context s; - stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); - return stbi__is_16_main(&s); -} - -#endif // STB_IMAGE_IMPLEMENTATION - -/* - revision history: - 2.19 (2018-02-11) fix warning - 2.18 (2018-01-30) fix warnings - 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug - 1-bit BMP - *_is_16_bit api - avoid warnings - 2.16 (2017-07-23) all functions have 16-bit variants; - STBI_NO_STDIO works again; - compilation fixes; - fix rounding in unpremultiply; - optimize vertical flip; - disable raw_len validation; - documentation fixes - 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; - warning fixes; disable run-time SSE detection on gcc; - uniform handling of optional "return" values; - thread-safe initialization of zlib tables - 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs - 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now - 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes - 2.11 (2016-04-02) allocate large structures on the stack - remove white matting for transparent PSD - fix reported channel count for PNG & BMP - re-enable SSE2 in non-gcc 64-bit - support RGB-formatted JPEG - read 16-bit PNGs (only as 8-bit) - 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED - 2.09 (2016-01-16) allow comments in PNM files - 16-bit-per-pixel TGA (not bit-per-component) - info() for TGA could break due to .hdr handling - info() for BMP to shares code instead of sloppy parse - can use STBI_REALLOC_SIZED if allocator doesn't support realloc - code cleanup - 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA - 2.07 (2015-09-13) fix compiler warnings - partial animated GIF support - limited 16-bpc PSD support - #ifdef unused functions - bug with < 92 byte PIC,PNM,HDR,TGA - 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value - 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning - 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit - 2.03 (2015-04-12) extra corruption checking (mmozeiko) - stbi_set_flip_vertically_on_load (nguillemot) - fix NEON support; fix mingw support - 2.02 (2015-01-19) fix incorrect assert, fix warning - 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 - 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG - 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) - progressive JPEG (stb) - PGM/PPM support (Ken Miller) - STBI_MALLOC,STBI_REALLOC,STBI_FREE - GIF bugfix -- seemingly never worked - STBI_NO_*, STBI_ONLY_* - 1.48 (2014-12-14) fix incorrectly-named assert() - 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) - optimize PNG (ryg) - fix bug in interlaced PNG with user-specified channel count (stb) - 1.46 (2014-08-26) - fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG - 1.45 (2014-08-16) - fix MSVC-ARM internal compiler error by wrapping malloc - 1.44 (2014-08-07) - various warning fixes from Ronny Chevalier - 1.43 (2014-07-15) - fix MSVC-only compiler problem in code changed in 1.42 - 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 - 1.41 (2014-06-25) - fix search&replace from 1.36 that messed up comments/error messages - 1.40 (2014-06-22) - fix gcc struct-initialization warning - 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) - 1.38 (2014-06-06) - suppress MSVC warnings on integer casts truncating values - fix accidental rename of 'skip' field of I/O - 1.37 (2014-06-04) - remove duplicate typedef - 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 - 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) - use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case - 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) - cast-to-stbi_uc to fix warnings - 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 - warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) - 1.21 fix use of 'stbi_uc' in header (reported by jon blow) - 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 - 1.16 major bugfix - stbi__convert_format converted one too many pixels - 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 - fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all - 1.00 interface to zlib that skips zlib header - 0.99 correct handling of alpha in palette - 0.98 TGA loader by lonesock; dynamically add loaders (untested) - 0.97 jpeg errors on too large a file; also catch another malloc failure - 0.96 fix detection of invalid v value - particleman@mollyrocket forum - 0.95 during header scan, seek to markers in case of padding - 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same - 0.93 handle jpegtran output; verbose errors - 0.92 read 4,8,16,24,32-bit BMP files of several formats - 0.91 output 24-bit Windows 3.0 BMP files - 0.90 fix a few more warnings; bump version number to approach 1.0 - 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd - 0.60 fix compiling as c++ - 0.59 fix warnings: merge Dave Moore's -Wall fixes - 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian - 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available - 0.56 fix bug: zlib uncompressed mode len vs. nlen - 0.55 fix bug: restart_interval not initialized to 0 - 0.54 allow NULL for 'int *comp' - 0.53 fix bug in png 3->4; speedup png decoding - 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments - 0.51 obey req_comp requests, 1-component jpegs return as 1-component, - on 'test' only check type, not whether we support this variant - 0.50 (2006-11-19) - first released version -*/ - - -/* ------------------------------------------------------------------------------- -This software is available under 2 licenses -- choose whichever you prefer. ------------------------------------------------------------------------------- -ALTERNATIVE A - MIT License -Copyright (c) 2017 Sean Barrett -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. ------------------------------------------------------------------------------- -ALTERNATIVE B - Public Domain (www.unlicense.org) -This is free and unencumbered software released into the public domain. -Anyone is free to copy, modify, publish, use, compile, sell, or distribute this -software, either in source code form or as a compiled binary, for any purpose, -commercial or non-commercial, and by any means. -In jurisdictions that recognize copyright laws, the author or authors of this -software dedicate any and all copyright interest in the software to the public -domain. We make this dedication for the benefit of the public at large and to -the detriment of our heirs and successors. We intend this dedication to be an -overt act of relinquishment in perpetuity of all present and future rights to -this software under copyright law. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------- +/* stb_image - v2.19 - public domain image loader - http://nothings.org/stb + 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. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine + John-Mark Allen + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan + Dave Moore Roy Eltham Hayaki Saito Nathan Reed + Won Chun Luke Graham Johan Duparc Nick Verigakis + the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar + Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex + Ryamond Barbiero Paul Du Bois Engin Manap github:grim210 + Aldo Culquicondor Philipp Wiesemann Dale Weiler github:sammyhw + Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus + Julian Raschke Gregory Mullen Baldur Karlsson github:poppolopoppo + Christian Floisand Kevin Schmidt github:darealshinji + Blazej Dariusz Roszkowski github:Michaelangel007 +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// 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 *channels_in_file -- outputs # of image components in image file +// int desired_channels -- 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, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// 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 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// 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, *channels_in_file 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. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy to use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// make more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// 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), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// 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); +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB, even though +// they are internally encoded differently. 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 (which +// is BGR stored in RGB). +// +// 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). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// + + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#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 +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +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); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#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); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#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); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// 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); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + + +#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 +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 + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// 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; + stbi_uc buffer_start[128]; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + 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; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + fseek((FILE*) user, n, SEEK_CUR); +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // 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; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +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, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +// this is not threadsafe +static const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load = flag_true_if_should_flip; +} + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 8) { + STBI_ASSERT(ri.bits_per_channel == 16); + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 16) { + STBI_ASSERT(ri.bits_per_channel == 8); + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) || !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&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; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&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; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + 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 + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + 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 + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + 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 + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + 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; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + 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; +} + +static void stbi__skip(stbi__context *s, int n) +{ + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + 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; +} + +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} + +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + return z + (stbi__get16le(s) << 16); +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__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 (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__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 (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - 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 +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// 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; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } 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 progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uc) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + 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 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // 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 + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB + k = stbi_lrot(j->code_buffer, n); + STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & ~sgn); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 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 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc << j->succ_low); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) << shift); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) << shift); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // 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; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + 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; \ + 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); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++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]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[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 + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // 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 + 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); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + 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 = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(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) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(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; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + 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) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + 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); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + 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) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + 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 SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + 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; // no match + 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"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad 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); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + 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"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + 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; + // these sizes can't be more than 17 bits + 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) { + // number of effective pixels (e.g. for non-interleaved MCU) + 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; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#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 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + 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) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + 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 ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!stbi__at_eof(j->s)) { + int x = stbi__get8(j->s); + if (x == 255) { + j->marker = stbi__get8(j->s); + break; + } + } + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + } else { + if (!stbi__process_marker(j, m)) return 0; + } + m = stbi__get_marker(j); + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // 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; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +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) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4]; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = 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 = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + 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) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } 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 { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + 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; + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// 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 + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[288]; + stbi__uint16 value[288]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + 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; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + 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]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + 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]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (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 +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + 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]; + STBI_ASSERT(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) stbi__fill_bits(a); + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = old_limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 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 }; + +static const int stbi__zlength_extra[31]= +{ 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 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 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}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + return 1; + } + z -= 257; + 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); + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) + c = stbi__zreceive(a,3)+3; + else { + STBI_ASSERT(c == 18); + c = stbi__zreceive(a,7)+11; + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + STBI_ASSERT(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + 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"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + 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 + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[288] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + 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; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + 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; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_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) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// 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 + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static int stbi__paeth(int a, int b, int c) +{ + 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; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// create the png data from post-deflated data +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, int depth, int color) +{ + int bytes = (depth == 16? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *prior; + int filter = *raw++; + + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + STBI_ASSERT(img_width_bytes <= x); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { + switch (filter) { + case STBI__F_none : cur[k] = raw[k]; break; + case STBI__F_sub : cur[k] = raw[k]; 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]>>1)); break; + case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; + case STBI__F_avg_first : cur[k] = raw[k]; break; + case STBI__F_paeth_first: cur[k] = raw[k]; break; + } + } + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else if (depth == 16) { + if (img_n != out_n) { + cur[filter_bytes] = 255; // first pixel top byte + cur[filter_bytes+1] = 255; // first pixel bottom byte + } + raw += filter_bytes; + cur += output_bytes; + prior += output_bytes; + } else { + raw += 1; + cur += 1; + prior += 1; + } + + // this is a little gross, so that we don't switch per-pixel or per-component + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*filter_bytes; + #define STBI__CASE(f) \ + case f: \ + for (k=0; k < nk; ++k) + switch (filter) { + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; + } + #undef STBI__CASE + raw += nk; + } else { + STBI_ASSERT(img_n+1 == out_n); + #define STBI__CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ + for (k=0; k < filter_bytes; ++k) + switch (filter) { + STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; + } + #undef STBI__CASE + + // the loop above sets the high byte of the pixels' alpha, but for + // 16 bit png files we also need the low byte set. we'll do that here. + if (depth == 16) { + cur = a->out + stride*j; // start at the beginning of the row again + for (i=0; i < x; ++i,cur+=output_bytes) { + cur[filter_bytes+1] = 255; + } + } + } + } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + int q; + // insert alpha = 255 + cur = a->out + stride*j; + if (img_n == 1) { + for (q=x-1; q >= 0; --q) { + cur[q*2+1] = 255; + cur[q*2+0] = cur[q]; + } + } else { + STBI_ASSERT(img_n == 3); + for (q=x-1; q >= 0; --q) { + cur[q*4+3] = 255; + cur[q*4+2] = cur[q*3+2]; + cur[q*4+1] = cur[q*3+1]; + cur[q*4+0] = cur[q*3+0]; + } + } + } + } + } else if (depth == 16) { + // force the image data from big-endian to platform-native. + // this is done in a separate pass due to the decoding relying + // on the data being untouched, but could probably be done + // per-line during decode if care is taken. + stbi_uc *cur = a->out; + stbi__uint16 *cur16 = (stbi__uint16*)cur; + + for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { + *cur16 = (cur[0] << 8) | cur[1]; + } + } + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + 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) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + 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; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + 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; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // 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; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load = 0; +static int stbi__de_iphone_flag = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + 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?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + 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"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + if (scan == STBI__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; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + 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"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + 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"); + has_trans = 1; + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_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; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + 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; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + 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); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth < 8) + ri->bits_per_channel = 8; + else + ri->bits_per_channel = p->depth; + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + 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; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + 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); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + 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; +} + +static int stbi__bitcount(unsigned int a) +{ + 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; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v >= 0 && v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; +} stbi__bmp_data; + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + 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 + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + 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 + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + 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 + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - 14 - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - 14 - info.hsz) >> 2; + } + + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.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; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - 14 - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + 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)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + 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) { + 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 + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + 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); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + 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 index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // 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) + { + 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) + { + 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 ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + 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) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // 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; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // 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 + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // 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, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } 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 (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// 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/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + 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); + 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) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + 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; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + 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 + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + 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) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + g->out = (stbi_uc *) stbi__malloc(4 * g->w * g->h); + g->background = (stbi_uc *) stbi__malloc(4 * g->w * g->h); + g->history = (stbi_uc *) stbi__malloc(g->w * g->h); + if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "tranparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to teh color that was there the previous frame. + memset( g->out, 0x00, 4 * g->w * g->h ); + memset( g->background, 0x00, 4 * g->w * g->h ); // state of the background (starts transparent) + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispoase of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + 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; + + g->lflags = stbi__get8(s); + + 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) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (o == NULL) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + out = (stbi_uc*) STBI_REALLOC( out, layers * stride ); + if (delays) { + *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers ); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + 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; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + 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; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // 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: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + 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) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + stbi__rewind( s ); + if (p == NULL) + return 0; + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) *comp = info.ma ? 4 : 3; + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + (void) stbi__get32be(s); + (void) stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) +// Does not support 16-bit-per-channel + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + return 0; + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + + if (maxv > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + 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; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + 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) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 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 + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 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) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 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 + 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) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 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) + cast-to-stbi_uc to fix warnings + 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 + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 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 + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 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 + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ */ \ No newline at end of file diff --git a/src/Util.cpp b/src/Util.cpp index 8366a1bb..9b97bcf3 100644 --- a/src/Util.cpp +++ b/src/Util.cpp @@ -66,7 +66,7 @@ bool FileExists(const char *filename) // Get user-specific config dir manually. // apple: ~/Library/Application Support/ -// windows: %APPDATA%\ +// windows: %APPDATA%/ // unix: ${XDG_CONFIG_HOME:-~/.config}/ std::string get_xdg_user_config_home() { @@ -94,7 +94,7 @@ std::string get_xdg_user_config_home() // Get user-specific data dir manually. // apple: ~/Library/Application Support/ -// windows: %APPDATA%\ +// windows: %APPDATA%/ // unix: ${XDG_DATA_HOME:-~/.local/share}/ std::string get_xdg_user_data_home() { diff --git a/src/Util.h b/src/Util.h index a37141c0..5f738576 100644 --- a/src/Util.h +++ b/src/Util.h @@ -10,6 +10,8 @@ #define FILE_SEP '/' #endif +#define FREAD_UNCHECKED(A,B,C,D) (void)(fread(A,B,C,D) + 1) + enum IMAGE_TYPE { IMAGE_UNKNOWN = -1, IMAGE_GBA = 0, IMAGE_GB = 1 }; // save game diff --git a/src/common/ConfigManager.cpp b/src/common/ConfigManager.cpp index 2f2b756d..11a74c9c 100644 --- a/src/common/ConfigManager.cpp +++ b/src/common/ConfigManager.cpp @@ -1,1366 +1,1366 @@ -// necessary to get portable strerror_r -#undef _GNU_SOURCE -#include -#define _GNU_SOURCE 1 - -#include "ConfigManager.h" -extern "C" { -#include "../common/iniparser.h" -} - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "../common/Patch.h" -#include "../common/ConfigManager.h" -#include "../gba/GBA.h" -#include "../gba/agbprint.h" -#include "../gba/Flash.h" -#include "../gba/Cheats.h" -#include "../gba/remote.h" -#include "../gba/RTC.h" -#include "../gba/Sound.h" -#include "../gb/gb.h" -#include "../gb/gbGlobals.h" -#include "../gb/gbCheats.h" -#include "../gb/gbSound.h" -#include "../Util.h" - -#ifndef _WIN32 -#define GETCWD getcwd -#else // _WIN32 -#include -#define GETCWD _getcwd -#define snprintf sprintf -#define stat _stat -#define mkdir(X,Y) (_mkdir(X)) -// from: https://www.linuxquestions.org/questions/programming-9/porting-to-win32-429334/ -#ifndef S_ISDIR - #define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR) -#endif -#endif // _WIN32 - -#ifndef __GNUC__ -#define HAVE_DECL_GETOPT 0 -#define __STDC__ 1 -#include "getopt.h" -#else // ! __GNUC__ -#define HAVE_DECL_GETOPT 1 -#include -#endif // ! __GNUC__ -#include -#include - -enum named_opts -{ - OPT_AGB_PRINT = 1000, - OPT_AUTOFIRE, - OPT_AUTO_FRAME_SKIP, - OPT_AVI_RECORD_DIR, - OPT_BATTERY_DIR, - OPT_BIOS_FILE_NAME_GB, - OPT_BIOS_FILE_NAME_GBA, - OPT_BIOS_FILE_NAME_GBC, - OPT_CAPTURE_FORMAT, - OPT_CHEAT, - OPT_CPU_SAVE_TYPE, - OPT_DOTCODE_FILE_NAME_LOAD, - OPT_DOTCODE_FILE_NAME_SAVE, - OPT_EMULATOR_TYPE, - OPT_FS_ADAPTER, - OPT_FS_COLOR_DEPTH, - OPT_FS_FREQUENCY, - OPT_FS_HEIGHT, - OPT_FS_WIDTH, - OPT_GB_EMULATOR_TYPE, - OPT_GB_FRAME_SKIP, - OPT_GB_PALETTE_OPTION, - OPT_GDB_PORT, - OPT_GL_FILTER, - OPT_IFB_TYPE, - OPT_JOYPAD_DEFAULT, - OPT_LANGUAGE_OPTION, - OPT_LINK_AUTO, - OPT_LINK_HACKS, - OPT_LINK_HOST_ADDR, - OPT_LINK_MODE, - OPT_LINK_NUM_PLAYERS, - OPT_LINK_TIMEOUT, - OPT_MAX_SCALE, - OPT_MOVIE_RECORD_DIR, - OPT_OPT_FLASH_SIZE, - OPT_REWIND_TIMER, - OPT_ROM_DIR_GB, - OPT_ROM_DIR_GBA, - OPT_ROM_DIR_GBC, - OPT_RTC_ENABLED, - OPT_SAVE_DIR, - OPT_SCREEN_SHOT_DIR, - OPT_SHOW_SPEED, - OPT_SHOW_SPEED_TRANSPARENT, - OPT_SOUND_FILTERING, - OPT_SOUND_RECORD_DIR, - OPT_SYNCHRONIZE, - OPT_THREAD_PRIORITY, - OPT_VIDEO_OPTION, - OPT_WINDOW_HEIGHT, - OPT_WINDOW_POSITION_X, - OPT_WINDOW_POSITION_Y, - OPT_WINDOW_WIDTH, - OPT_SPEEDUP_THROTTLE, - OPT_SPEEDUP_FRAME_SKIP -}; - -#define SOUND_MAX_VOLUME 2.0 -#define SOUND_ECHO 0.2 -#define SOUND_STEREO 0.15 - -#define REWIND_NUM 8 -#define REWIND_SIZE 400000 - -char path[2048]; - -dictionary* preferences; - -bool cpuIsMultiBoot = false; -bool mirroringEnable = true; -bool parseDebug = true; -bool speedHack = false; -bool speedup = false; -const char* aviRecordDir; -const char* batteryDir; -const char* biosFileNameGB; -const char* biosFileNameGBA; -const char* biosFileNameGBC; -const char* loadDotCodeFile; -const char* saveDotCodeFile; -const char* linkHostAddr; -const char* movieRecordDir; -char* rewindMemory = NULL; -const char* romDirGB; -const char* romDirGBA; -const char* romDirGBC; -const char* saveDir; -const char* screenShotDir; -const char* soundRecordDir; -int active = 1; -int agbPrint; -int autoFire; -int autoFireMaxCount = 1; -int autoFireToggle; -int autoFrameSkip = 0; -int autoLoadMostRecent; -int autoPatch; -int autoSaveLoadCheatList; -int aviRecording; -int captureFormat = 0; -int cheatsEnabled = true; -int cpuDisableSfx = false; -int cpuSaveType = 0; -int disableMMX; -int disableStatusMessages = 0; -int dsoundDisableHardwareAcceleration; -int filterHeight; -int filterMagnification; -int filterMT; // enable multi-threading for pixel filters -int filter = kStretch2x; -int filterWidth; -int frameSkip = 1; -int frameskipadjust; -int fsAdapter; -int fsColorDepth; -int fsForceChange; -int fsFrequency; -int fsHeight; -int fsWidth; -int fullScreen; -int fullScreenStretch; -int gdbBreakOnLoad; -int gdbPort; -int glFilter; -int ifbType = kIFBNone; -int joypadDefault; -int languageOption; -int layerEnable = 0xff00; -int layerSettings = 0xff00; -int linkAuto; -int linkHacks = 1; -int linkMode; -int linkNumPlayers; -int linkTimeout = 1; -int maxScale; -int mouseCounter = 0; -int movieFrame; -int moviePlayFrame; -int moviePlaying; -int movieRecording; -int openGL; -int optFlashSize; -int optPrintUsage; -int paused; -int pauseWhenInactive = 0; -int preparedCheats = 0; -int recentFreeze; -int renderedFrames; -int rewindCount; -int rewindCounter; -int rewindPos; -int rewindSaveNeeded = 0; -int rewindTimer = 0; -int rewindTopPos; -int rtcEnabled; -int saveType = GBA_SAVE_AUTO; -int screenMessage; -int sensorX; -int sensorY; -int showRenderedFrames; -int showSpeed; -int showSpeedTransparent; -int sizeX; -int sizeY; -int skipBios = 0; -int skipSaveGameBattery = false; -int skipSaveGameCheats = false; -int soundRecording; -int speedupToggle; -int sunBars; -int surfaceSizeX; -int surfaceSizeY; -int threadPriority; -int tripleBuffering; -int useBios = 0; -int useBiosFileGB; -int useBiosFileGBA; -int useBiosFileGBC; -int videoOption; -int vsync; -int wasPaused = 0; -uint32_t windowHeight; -int windowPositionX; -int windowPositionY; -uint32_t windowWidth; -int winFlashSize; -int winGbBorderOn; -int winGbPrinterEnabled; -int winPauseNextFrame; -int* rewindSerials = NULL; -uint32_t autoFrameSkipLastTime; -uint32_t movieLastJoypad; -uint32_t movieNextJoypad; -uint32_t throttle = 100; -uint32_t speedup_throttle = 0; -uint32_t speedup_frame_skip = 9; - -const char* preparedCheatCodes[MAX_CHEATS]; - -FilterFunc filterFunction = 0; -IFBFilterFunc ifbFunction = 0; - -// allow up to 100 IPS/UPS/PPF patches given on commandline -int patchNum = 0; -char *(patchNames[PATCH_MAX_NUM]) = { NULL }; // and so on - -void(*dbgMain)() = remoteStubMain; -void(*dbgSignal)(int, int) = remoteStubSignal; -void(*dbgOutput)(const char *, uint32_t) = debuggerOutput; - -char* homeDir = NULL; -char* arg0 = NULL; - - -struct option argOptions[] = { - - { "agb-print", required_argument, 0, OPT_AGB_PRINT }, - { "auto-frame-skip", required_argument, 0, OPT_AUTO_FRAME_SKIP }, - { "auto-load-most-recent", no_argument, &autoLoadMostRecent, 1 }, - { "auto-patch", no_argument, &autoPatch, 1 }, - { "auto-save-cheat-list", no_argument, &autoSaveLoadCheatList, 1 }, - { "auto-save-load-cheat-list", no_argument, &autoSaveLoadCheatList, 1 }, - { "autofire", required_argument, 0, OPT_AUTOFIRE }, - { "avi-record-dir", required_argument, 0, OPT_AVI_RECORD_DIR }, - { "battery-dir", required_argument, 0, OPT_BATTERY_DIR }, - { "bios", required_argument, 0, 'b' }, - { "bios-file-name-gb", required_argument, 0, OPT_BIOS_FILE_NAME_GB }, - { "bios-file-name-gba", required_argument, 0, OPT_BIOS_FILE_NAME_GBA }, - { "bios-file-name-gbc", required_argument, 0, OPT_BIOS_FILE_NAME_GBC }, - { "border-automatic", no_argument, &gbBorderAutomatic, 1 }, - { "border-on", no_argument, &gbBorderOn, 1 }, - { "capture-format", required_argument, 0, OPT_CAPTURE_FORMAT }, - { "cheat", required_argument, 0, OPT_CHEAT }, - { "cheats-enabled", no_argument, &cheatsEnabled, 1 }, - { "color-option", no_argument, &gbColorOption, 1 }, - { "config", required_argument, 0, 'c' }, - { "cpu-disable-sfx", no_argument, &cpuDisableSfx, 1 }, - { "cpu-save-type", required_argument, 0, OPT_CPU_SAVE_TYPE }, - { "debug", no_argument, 0, 'd' }, - { "disable-mmx", no_argument, &disableMMX, 1 }, - { "disable-sfx", no_argument, &cpuDisableSfx, 1 }, - { "disable-status-messages", no_argument, &disableStatusMessages, 1 }, - { "dotcode-file-name-load", required_argument, 0, OPT_DOTCODE_FILE_NAME_LOAD }, - { "dotcode-file-name-save", required_argument, 0, OPT_DOTCODE_FILE_NAME_SAVE }, - { "emulator-type", required_argument, 0, OPT_EMULATOR_TYPE }, - { "filter", required_argument, 0, 'f' }, - { "filter-enable-multi-threading", no_argument, &filterMT, 1 }, - { "filter-mt", no_argument, &filterMT, 1 }, - { "flash-128k", no_argument, &optFlashSize, 1 }, - { "flash-64k", no_argument, &optFlashSize, 0 }, - { "flash-size", required_argument, 0, 'S' }, - { "frameskip", required_argument, 0, 's' }, - { "fs-adapter", required_argument, 0, OPT_FS_ADAPTER }, - { "fs-color-depth", required_argument, 0, OPT_FS_COLOR_DEPTH }, - { "fs-frequency", required_argument, 0, OPT_FS_FREQUENCY }, - { "fs-height", required_argument, 0, OPT_FS_HEIGHT }, - { "fs-width", required_argument, 0, OPT_FS_WIDTH }, - { "full-screen", no_argument, &fullScreen, 1 }, - { "full-screen-stretch", no_argument, &fullScreenStretch, 1 }, - { "gb-border-automatic", no_argument, &gbBorderAutomatic, 1 }, - { "gb-border-on", no_argument, &gbBorderOn, 1 }, - { "gb-color-option", no_argument, &gbColorOption, 1 }, - { "gb-emulator-type", required_argument, 0, OPT_GB_EMULATOR_TYPE }, - { "gb-frame-skip", required_argument, 0, OPT_GB_FRAME_SKIP }, - { "gb-palette-option", required_argument, 0, OPT_GB_PALETTE_OPTION }, - { "gb-printer", no_argument, &winGbPrinterEnabled, 1 }, - { "gdb", required_argument, 0, 'G' }, - { "gdb-break-on-load", no_argument, &gdbBreakOnLoad, 1 }, - { "gdb-port", required_argument, 0, OPT_GDB_PORT }, - { "gl-filter", required_argument, 0, OPT_GL_FILTER }, - { "help", no_argument, &optPrintUsage, 1 }, - { "ifb-filter", required_argument, 0, 'I' }, - { "ifb-type", required_argument, 0, OPT_IFB_TYPE }, - { "joypad-default", required_argument, 0, OPT_JOYPAD_DEFAULT }, - { "language-option", required_argument, 0, OPT_LANGUAGE_OPTION }, - { "link-auto", required_argument, 0, OPT_LINK_AUTO }, - { "link-hacks", required_argument, 0, OPT_LINK_HACKS }, - { "link-host-addr", required_argument, 0, OPT_LINK_HOST_ADDR }, - { "link-mode", required_argument, 0, OPT_LINK_MODE }, - { "link-num-players", required_argument, 0, OPT_LINK_NUM_PLAYERS }, - { "link-timeout", required_argument, 0, OPT_LINK_TIMEOUT }, - { "max-scale", required_argument, 0, OPT_MAX_SCALE }, - { "movie-record-dir", required_argument, 0, OPT_MOVIE_RECORD_DIR }, - { "no-agb-print", no_argument, &agbPrint, 0 }, - { "no-auto-frameskip", no_argument, &autoFrameSkip, 0 }, - { "no-debug", no_argument, 0, 'N' }, - { "no-opengl", no_argument, &openGL, 0 }, - { "no-patch", no_argument, &autoPatch, 0 }, - { "no-pause-when-inactive", no_argument, &pauseWhenInactive, 0 }, - { "no-rtc", no_argument, &rtcEnabled, 0 }, - { "no-show-speed", no_argument, &showSpeed, 0 }, - { "opengl", required_argument, 0, 'O' }, - { "opengl-bilinear", no_argument, &openGL, 2 }, - { "opengl-nearest", no_argument, &openGL, 1 }, - { "opt-flash-size", required_argument, 0, OPT_OPT_FLASH_SIZE }, - { "patch", required_argument, 0, 'i' }, - { "pause-when-inactive", no_argument, &pauseWhenInactive, 1 }, - { "profile", optional_argument, 0, 'p' }, - { "recent-freeze", no_argument, &recentFreeze, 1 }, - { "rewind-timer", required_argument, 0, OPT_REWIND_TIMER }, - { "rom-dir-gb", required_argument, 0, OPT_ROM_DIR_GB }, - { "rom-dir-gba", required_argument, 0, OPT_ROM_DIR_GBA }, - { "rom-dir-gbc", required_argument, 0, OPT_ROM_DIR_GBC }, - { "rtc", no_argument, &rtcEnabled, 1 }, - { "rtc-enabled", required_argument, 0, OPT_RTC_ENABLED }, - { "save-auto", no_argument, &cpuSaveType, 0 }, - { "save-dir", required_argument, 0, OPT_SAVE_DIR }, - { "save-eeprom", no_argument, &cpuSaveType, 1 }, - { "save-flash", no_argument, &cpuSaveType, 3 }, - { "save-none", no_argument, &cpuSaveType, 5 }, - { "save-sensor", no_argument, &cpuSaveType, 4 }, - { "save-sram", no_argument, &cpuSaveType, 2 }, - { "save-type", required_argument, 0, 't' }, - { "screen-shot-dir", required_argument, 0, OPT_SCREEN_SHOT_DIR }, - { "show-speed", required_argument, 0, OPT_SHOW_SPEED }, - { "show-speed-detailed", no_argument, &showSpeed, 2 }, - { "show-speed-normal", no_argument, &showSpeed, 1 }, - { "show-speed-transparent", required_argument, 0, OPT_SHOW_SPEED_TRANSPARENT }, - { "skip-bios", no_argument, &skipBios, 1 }, - { "skip-save-game-battery", no_argument, &skipSaveGameBattery, 1 }, - { "skip-save-game-cheats", no_argument, &skipSaveGameCheats, 1 }, - { "sound-filtering", required_argument, 0, OPT_SOUND_FILTERING }, - { "sound-record-dir", required_argument, 0, OPT_SOUND_RECORD_DIR }, - { "stretch", no_argument, &fullScreenStretch, 1 }, - { "synchronize", required_argument, 0, OPT_SYNCHRONIZE }, - { "thread-priority", required_argument, 0, OPT_THREAD_PRIORITY }, - { "throttle", required_argument, 0, 'T' }, - { "speedup_throttle", required_argument, 0, OPT_SPEEDUP_THROTTLE }, - { "speedup_frame_skip", required_argument, 0, OPT_SPEEDUP_FRAME_SKIP }, - { "triple-buffering", no_argument, &tripleBuffering, 1 }, - { "use-bios", no_argument, &useBios, 1 }, - { "use-bios-file-gb", no_argument, &useBiosFileGB, 1 }, - { "use-bios-file-gba", no_argument, &useBiosFileGBA, 1 }, - { "use-bios-file-gbc", no_argument, &useBiosFileGBC, 1 }, - { "verbose", required_argument, 0, 'v' }, - { "video-option", required_argument, 0, OPT_VIDEO_OPTION }, - { "vsync", no_argument, &vsync, 1 }, - { "win-gb-printer-enabled", no_argument, &winGbPrinterEnabled, 1 }, - { "window-height", required_argument, 0, OPT_WINDOW_HEIGHT }, - { "window-position-x", required_argument, 0, OPT_WINDOW_POSITION_X }, - { "window-position-y", required_argument, 0, OPT_WINDOW_POSITION_Y }, - { "window-width", required_argument, 0, OPT_WINDOW_WIDTH }, - - - { NULL, no_argument, NULL, 0 } -}; - - -uint32_t fromHex(const char *s) -{ - if (!s) - return 0; - uint32_t value; - sscanf(s, "%x", &value); - return value; -} - -uint32_t fromDec(const char *s) -{ - if (!s) - return 0; - uint32_t value = 0; - sscanf(s, "%u", &value); - return value; -} - -void SetHome(char *_arg0) -{ - arg0 = _arg0; -} - -void OpenPreferences(const char *name) -{ - if (!preferences && name) - preferences = iniparser_load(name); -} - -void ValidateConfig() -{ - if (gbEmulatorType < 0 || gbEmulatorType > 5) - gbEmulatorType = 1; - if (frameSkip < 0 || frameSkip > 9) - frameSkip = 2; - if (gbFrameSkip < 0 || gbFrameSkip > 9) - gbFrameSkip = 0; - if (filter < kStretch1x || filter >= kInvalidFilter) - filter = kStretch2x; - - if (cpuSaveType < 0 || cpuSaveType > 5) - cpuSaveType = 0; - if (optFlashSize != 0 && optFlashSize != 1) - optFlashSize = 0; - if (ifbType < kIFBNone || ifbType >= kInvalidIFBFilter) - ifbType = kIFBNone; - if (showSpeed < 0 || showSpeed > 2) - showSpeed = 1; - if (rewindTimer < 0 || rewindTimer > 600) - rewindTimer = 0; - if (autoFireMaxCount < 1) - autoFireMaxCount = 1; - - if (rewindTimer) { - rewindMemory = (char *)malloc(REWIND_NUM*REWIND_SIZE); - rewindSerials = (int *)calloc(REWIND_NUM, sizeof(int)); // init to zeroes - } -} - -void LoadConfig() -{ - agbPrint = ReadPrefHex("agbPrint"); - autoFireMaxCount = fromDec(ReadPrefString("autoFireMaxCount")); - autoFrameSkip = ReadPref("autoFrameSkip", 0); - autoLoadMostRecent = ReadPref("autoLoadMostRecent", 0); - autoPatch = ReadPref("autoPatch", 1); - autoSaveLoadCheatList = ReadPref("autoSaveCheatList", 1); - aviRecordDir = ReadPrefString("aviRecordDir"); - batteryDir = ReadPrefString("batteryDir"); - biosFileNameGB = ReadPrefString("biosFileGB"); - biosFileNameGBA = ReadPrefString("biosFileGBA"); - biosFileNameGBC = ReadPrefString("biosFileGBC"); - captureFormat = ReadPref("captureFormat", 0); - cheatsEnabled = ReadPref("cheatsEnabled", 0); - cpuDisableSfx = ReadPref("disableSfx", 0); - cpuSaveType = ReadPrefHex("saveType"); - disableMMX = ReadPref("disableMMX", 0); - disableStatusMessages = ReadPrefHex("disableStatus"); - filterMT = ReadPref("filterEnableMultiThreading", 0); - filter = ReadPref("filter", 0); - frameSkip = ReadPref("frameSkip", 0); - fsAdapter = ReadPref("fsAdapter", 0); - fsColorDepth = ReadPref("fsColorDepth", 32); - fsFrequency = ReadPref("fsFrequency", 60); - fsHeight = ReadPref("fsHeight", 600); - fsWidth = ReadPref("fsWidth", 800); - fullScreen = ReadPrefHex("fullScreen"); - fullScreenStretch = ReadPref("stretch", 0); - gbBorderAutomatic = ReadPref("borderAutomatic", 0); - gbBorderOn = ReadPrefHex("borderOn"); - gbColorOption = ReadPref("colorOption", 0); - gbEmulatorType = ReadPref("emulatorType", 1); - gbFrameSkip = ReadPref("gbFrameSkip", 0); - gbPaletteOption = ReadPref("gbPaletteOption", 0); - gbSoundSetDeclicking(ReadPref("gbSoundDeclicking", 1)); - gb_effects_config.echo = (float)ReadPref("gbSoundEffectsEcho", 20) / 100.0f; - gb_effects_config.enabled = ReadPref("gbSoundEffectsEnabled", 0); - gb_effects_config.stereo = (float)ReadPref("gbSoundEffectsStereo", 15) / 100.0f; - gb_effects_config.surround = ReadPref("gbSoundEffectsSurround", 0); - gdbBreakOnLoad = ReadPref("gdbBreakOnLoad", 0); - gdbPort = ReadPref("gdbPort", 55555); - glFilter = ReadPref("glFilter", 1); - ifbType = ReadPref("ifbType", 0); - joypadDefault = ReadPref("joypadDefault", 0); - languageOption = ReadPref("language", 1); - linkAuto = ReadPref("LinkAuto", 1); - linkHacks = ReadPref("LinkHacks", 0); - linkHostAddr = ReadPrefString("LinkHostAddr", "localhost"); - linkMode = ReadPref("LinkMode", 0); // LINK_DISCONNECTED = 0 - linkNumPlayers = ReadPref("LinkNumPlayers", 2); - linkTimeout = ReadPref("LinkTimeout", 1); - loadDotCodeFile = ReadPrefString("loadDotCodeFile"); - maxScale = ReadPref("maxScale", 0); - movieRecordDir = ReadPrefString("movieRecordDir"); - openGL = ReadPrefHex("openGL"); - optFlashSize = ReadPrefHex("flashSize"); - pauseWhenInactive = ReadPref("pauseWhenInactive", 1); - recentFreeze = ReadPref("recentFreeze", 0); - rewindTimer = ReadPref("rewindTimer", 0); - romDirGB = ReadPrefString("romDirGB"); - romDirGBA = ReadPrefString("romDirGBA"); - romDirGBC = ReadPrefString("romDirGBC"); - rtcEnabled = ReadPref("rtcEnabled", 0); - saveDir = ReadPrefString("saveDir"); - saveDotCodeFile = ReadPrefString("saveDotCodeFile"); - screenShotDir = ReadPrefString("screenShotDir"); - showSpeed = ReadPref("showSpeed", 0); - showSpeedTransparent = ReadPref("showSpeedTransparent", 1); - skipBios = ReadPref("skipBios", 0); - skipSaveGameBattery = ReadPref("skipSaveGameBattery", 0); - skipSaveGameCheats = ReadPref("skipSaveGameCheats", 0); - soundFiltering = (float)ReadPref("gbaSoundFiltering", 50) / 100.0f; - soundInterpolation = ReadPref("gbaSoundInterpolation", 1); - soundRecordDir = ReadPrefString("soundRecordDir"); - threadPriority = ReadPref("priority", 2); - throttle = ReadPref("throttle", 100); - speedup_throttle = ReadPref("speedup_throttle", 0); - speedup_frame_skip = ReadPref("speedup_frame_skip", 9); - tripleBuffering = ReadPref("tripleBuffering", 0); - useBios = ReadPrefHex("useBiosGBA"); - useBiosFileGB = ReadPref("useBiosGB", 0); - useBiosFileGBA = ReadPref("useBiosGBA", 0); - useBiosFileGBC = ReadPref("useBiosGBC", 0); - videoOption = ReadPref("video", 2); // VIDEO_3X = 2 - vsync = ReadPref("vsync", false); - windowHeight = ReadPref("windowHeight", 0); - windowPositionX = ReadPref("windowX", -1); - windowPositionY = ReadPref("windowY", -1); - windowWidth = ReadPref("windowWidth", 0); - winFlashSize = ReadPref("flashSize", 0x10000); - winGbBorderOn = ReadPref("borderOn", 0); - winGbPrinterEnabled = ReadPref("gbPrinter", 0); - - int soundQuality = (ReadPrefHex("soundQuality", 1)); - switch (soundQuality) { - case 1: - case 2: - case 4: - break; - default: - log("Unknown sound quality %d. Defaulting to 44Khz\n", soundQuality); - soundQuality = 1; - break; - } - soundSetSampleRate(44100 / soundQuality); - int volume = ReadPref("soundVolume", 100); - float volume_percent = volume / 100.0f; - if (volume_percent < 0.0 || volume_percent > SOUND_MAX_VOLUME) - volume_percent = 1.0; - soundSetVolume(volume_percent); - - soundSetEnable((ReadPrefHex("soundEnable", 0x30f)) & 0x30f); - if ((ReadPrefHex("soundStereo"))) { - gb_effects_config.enabled = true; - } - if ((ReadPrefHex("soundEcho"))) { - gb_effects_config.enabled = true; - } - if ((ReadPrefHex("soundSurround"))) { - gb_effects_config.surround = true; - gb_effects_config.enabled = true; - } - - if (optFlashSize == 0) - flashSetSize(0x10000); - else - flashSetSize(0x20000); - - rtcEnable(rtcEnabled ? true : false); - agbPrintEnable(agbPrint ? true : false); - - for (int i = 0; i < 24;) { - systemGbPalette[i++] = (0x1f) | (0x1f << 5) | (0x1f << 10); - systemGbPalette[i++] = (0x15) | (0x15 << 5) | (0x15 << 10); - systemGbPalette[i++] = (0x0c) | (0x0c << 5) | (0x0c << 10); - systemGbPalette[i++] = 0; - } - - systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED; - - optPrintUsage = 0; - - // TODO - //int s = ReadPref("mapViewStretch", 0); - //m_size = ReadPref("memViewerDataSize", 0); - //m_stretch = ReadPref("GBOamViewStretch", 0); - //m_stretch = ReadPref("tileViewStretch", 0); - //numberType = ReadPref("cheatsNumberType", 2); - //numberType = ReadPref("gbCheatsNumberType", 2); - //restoreValues = ReadPref("cheatsRestore", 0) ? - //scale = ReadPref("printerScale", 0); - //searchType = ReadPref("cheatsSearchType", SEARCH_EQ); - //searchType = ReadPref("gbCheatsSearchType", - //selectedFilter = ReadPref(("selectedFilter"), 0); - //sizeType = ReadPref("cheatsSizeType", 0); - //sizeType = ReadPref("gbCheatsSizeType", 0); - //updateValues = ReadPref("cheatsUpdate", 0); - //updateValues = ReadPref("gbCheatsUpdate", 0); - //valueType = ReadPref("cheatsValueType", 0); - //valueType = ReadPref("gbCheatsValueType", 0); - - ValidateConfig(); -} - -void CloseConfig() -{ - if (preferences) - iniparser_freedict(preferences); -} - -const char* FindConfigFile(const char *name) -{ - char buffer[4096]; - -#ifdef _WIN32 -#define PATH_SEP ";" -#define EXE_NAME "vbam.exe" -#else // ! _WIN32 -#define PATH_SEP ":" -#define EXE_NAME "vbam" -#endif // ! _WIN32 - - if (GETCWD(buffer, 2048)) { - } - - if (FileExists(name)) - { - return name; - } - - if (homeDir) { - sprintf(path, "%s%c%s", homeDir, FILE_SEP, name); - if (FileExists(path)) - { - return path; - } - } - -#ifdef _WIN32 - char *home = getenv("USERPROFILE"); - if (home != NULL) { - sprintf(path, "%s%c%s", home, FILE_SEP, name); - if (FileExists(path)) - { - return path; - } - } - - if (!strchr(arg0, '/') && - !strchr(arg0, '\\')) { - char *path = getenv("PATH"); - - if (path != NULL) { - strncpy(buffer, path, 4096); - buffer[4095] = 0; - char *tok = strtok(buffer, PATH_SEP); - - while (tok) { - sprintf(path, "%s%c%s", tok, FILE_SEP, EXE_NAME); - if (FileExists(path)) { - static char path2[2048]; - sprintf(path2, "%s%c%s", tok, FILE_SEP, name); - if (FileExists(path2)) { - return path2; - } - } - tok = strtok(NULL, PATH_SEP); - } - } - } - else { - // executable is relative to some directory - strcpy(buffer, arg0); - char *p = strrchr(buffer, FILE_SEP); - if (p) { - *p = 0; - sprintf(path, "%s%c%s", buffer, FILE_SEP, name); - if (FileExists(path)) - { - return path; - } - } - } -#else // ! _WIN32 - sprintf(path, "%s%c%s", PKGDATADIR, FILE_SEP, name); - if (FileExists(path)) - { - return path; - } - - sprintf(path, "%s%c%s", SYSCONF_INSTALL_DIR, FILE_SEP, name); - if (FileExists(path)) - { - return path; - } -#endif // ! _WIN32 - return 0; -} - -void LoadConfigFile() -{ - struct stat s; - std::string homeDirTmp = get_xdg_user_config_home() + DOT_DIR; - homeDir = (char *)homeDirTmp.c_str(); - if (stat(homeDir, &s) == -1 || !S_ISDIR(s.st_mode)) - mkdir(homeDir, 0755); - - if (preferences == NULL) - { - const char* configFile = FindConfigFile("vbam.ini"); - OpenPreferences(configFile); - } -} - -void SaveConfigFile() -{ - struct stat s; - std::string homeDirTmp = get_xdg_user_config_home() + DOT_DIR; - homeDir = (char *)homeDirTmp.c_str(); - if (stat(homeDir, &s) == -1 || !S_ISDIR(s.st_mode)) - mkdir(homeDir, 0755); - - const char* configFile = FindConfigFile("vbam.ini"); - - if (configFile != NULL) - { - FILE *f = fopen(configFile, "w"); - if (f == NULL) { - char err_msg[4096] = "unknown error"; - strncpy(err_msg, strerror(errno), 4096); - fprintf(stderr, "Configuration file '%s' could not be written to: %s\n", configFile, err_msg); - return; - } - // Needs mixed case version of the option name to add new options into the ini - //for (int i = 0; i < (sizeof(argOptions) / sizeof(option)); i++) - //{ - // std::string pref = "preferences:"; - // pref.append(argOptions[i].name); - // if (!iniparser_find_entry(preferences, pref.c_str())) - // { - // iniparser_set(preferences, pref.c_str(), NULL); - // } - //} - iniparser_dump_ini(preferences, f); - fclose(f); - } -} - -uint32_t ReadPrefHex(const char* pref_key, int default_value) -{ - std::stringstream ss; - std::string default_string; - ss.setf(std::ios::hex|std::ios::showbase, std::ios::basefield); - ss << default_value; - ss >> default_string; - LoadConfigFile(); - std::string pref = "preferences:"; - pref.append(pref_key); - return fromHex(iniparser_getstring(preferences, pref.c_str(), default_string.c_str())); -} - -uint32_t ReadPrefHex(const char* pref_key) -{ - LoadConfigFile(); - std::string pref = "preferences:"; - pref.append(pref_key); - return fromHex(iniparser_getstring(preferences, pref.c_str(), 0)); -} - -uint32_t ReadPref(const char* pref_key, int default_value) -{ - LoadConfigFile(); - std::string pref = "preferences:"; - pref.append(pref_key); - return iniparser_getint(preferences, pref.c_str(), default_value); -} - -uint32_t ReadPref(const char* pref_key) -{ - return ReadPref(pref_key, 0); -} - -const char* ReadPrefString(const char* pref_key, const char* default_value) -{ - LoadConfigFile(); - std::string pref = "preferences:"; - pref.append(pref_key); - return iniparser_getstring(preferences, pref.c_str(), default_value); -} - -const char* ReadPrefString(const char* pref_key) -{ - return ReadPrefString(pref_key, ""); -} - -/*-------------------------------------------------------------------------*/ -/** - @brief Duplicate a string - @param s String to duplicate - @return Pointer to a newly allocated string, to be freed with free() - - This is a replacement for strdup(). This implementation is provided - for systems that do not have it. - */ -/*--------------------------------------------------------------------------*/ -static char *xstrdup(const char *s) -{ - char *t; - if (!s) - return NULL; - t = (char *)malloc(strlen(s) + 1); - if (t) { - strcpy(t, s); - } - return t; -} - -int ReadOpts(int argc, char ** argv) -{ - int op = -1; - while ((op = getopt_long(argc, - argv, - "FNO:T:Y:G:I:D:b:c:df:hi:p::s:t:v:", - argOptions, - NULL)) != -1) { - switch (op) { - case 0: - // long option already processed by getopt_long - break; - case OPT_CHEAT: - // --cheat - if (preparedCheats >= MAX_CHEATS) { - log("Warning: cannot add more than %d cheats.\n", MAX_CHEATS); - break; - } - { - //char* cpy; - //cpy = (char *)malloc(1 + strlen(optarg)); - //strcpy(cpy, optarg); - //preparedCheatCodes[preparedCheats++] = cpy; - std::string cpy = optarg; - preparedCheatCodes[preparedCheats++] = cpy.c_str(); - } - break; - case OPT_AUTOFIRE: - // --autofire - autoFireMaxCount = fromDec(optarg); - if (autoFireMaxCount < 1) - autoFireMaxCount = 1; - break; - case 'b': - useBios = true; - if (optarg == NULL) { - log("Missing BIOS file name\n"); - break; - } - biosFileNameGBA = xstrdup(optarg); - break; - case 'c': - { - if (optarg == NULL) { - log("Missing config file name\n"); - break; - } - FILE *f = fopen(optarg, "r"); - if (f == NULL) { - log("File not found %s\n", optarg); - break; - } - preferences = NULL; - OpenPreferences(optarg); - fclose(f); - } - break; - case 'd': - debugger = true; - break; - case 'h': - optPrintUsage = 1; - break; - case 'i': - if (optarg == NULL) { - log("Missing patch name\n"); - break; - } - if (patchNum >= PATCH_MAX_NUM) { - log("Too many patches given at %s (max is %d). Ignoring.\n", optarg, PATCH_MAX_NUM); - } - else { - patchNames[patchNum] = (char *)malloc(1 + strlen(optarg)); - strcpy(patchNames[patchNum], optarg); - patchNum++; - } - break; - case 'G': - dbgMain = remoteStubMain; - dbgSignal = remoteStubSignal; - dbgOutput = remoteOutput; - debugger = true; - if (optarg) { - char *s = optarg; - if (strncmp(s, "tcp:", 4) == 0) { - s += 4; - int port = atoi(s); - remoteSetProtocol(0); - remoteSetPort(port); - } - else if (strcmp(s, "tcp") == 0) { - remoteSetProtocol(0); - } - else if (strcmp(s, "pipe") == 0) { - remoteSetProtocol(1); - } - else { - log("Unknown protocol %s\n", s); - break; - } - } - else { - remoteSetProtocol(0); - } - break; - case 'N': - parseDebug = false; - break; - case 'F': - fullScreen = 1; - mouseCounter = 120; - break; - case 'f': - if (optarg) { - filter = (Filter)atoi(optarg); - } - else { - filter = kStretch2x; - } - break; - case 'T': - if (optarg) - throttle = atoi(optarg); - break; - case 'I': - if (optarg) { - ifbType = (IFBFilter)atoi(optarg); - } - else { - ifbType = kIFBNone; - } - break; - case 'p': -#ifdef PROFILING - if (optarg) { - cpuEnableProfiling(atoi(optarg)); - } - else - cpuEnableProfiling(100); -#endif - break; - case 'S': - optFlashSize = atoi(optarg); - if (optFlashSize < 0 || optFlashSize > 1) - optFlashSize = 0; - break; - case 's': - if (optarg) { - int a = atoi(optarg); - if (a >= 0 && a <= 9) { - gbFrameSkip = a; - frameSkip = a; - } - } - else { - frameSkip = 2; - gbFrameSkip = 0; - } - break; - case 't': - if (optarg) { - int a = atoi(optarg); - if (a < 0 || a > 5) - a = 0; - cpuSaveType = a; - } - break; - case 'v': - if (optarg) { - systemVerbose = atoi(optarg); - } - else - systemVerbose = 0; - break; - case '?': - optPrintUsage = 1; - break; - case 'O': - if (optarg) { - openGL = atoi(optarg); - if (openGL < 0 || openGL > 2) - openGL = 1; - } - else - openGL = 0; - break; - - case OPT_CAPTURE_FORMAT: - // --capture-format - if (optarg) { - captureFormat = atoi(optarg); - } - break; - - case OPT_SHOW_SPEED_TRANSPARENT: - // --show-speed-transparent - if (optarg) { - showSpeedTransparent = atoi(optarg); - } - break; - - case OPT_AUTO_FRAME_SKIP: - // --auto-frame-skip - if (optarg) { - autoFrameSkip = atoi(optarg); - } - break; - - case OPT_AGB_PRINT: - // --agb-print - if (optarg) { - agbPrint = atoi(optarg); - } - break; - - case OPT_RTC_ENABLED: - // --rtc-enabled - if (optarg) { - rtcEnabled = atoi(optarg); - } - break; - - case OPT_VIDEO_OPTION: - // --video-option - if (optarg) { - videoOption = atoi(optarg); - } - break; - - case OPT_LANGUAGE_OPTION: - // --language-option - if (optarg) { - languageOption = atoi(optarg); - } - break; - - case OPT_GB_FRAME_SKIP: - // --gb-frame-skip - if (optarg) { - gbFrameSkip = atoi(optarg); - } - break; - - case OPT_FS_ADAPTER: - // --fs-adapter - if (optarg) { - fsAdapter = atoi(optarg); - } - break; - - case OPT_FS_WIDTH: - // --fs-width - if (optarg) { - fsWidth = atoi(optarg); - } - break; - - case OPT_FS_HEIGHT: - // --fs-height - if (optarg) { - fsHeight = atoi(optarg); - } - break; - - case OPT_FS_COLOR_DEPTH: - // --fs-color-depth - if (optarg) { - fsColorDepth = atoi(optarg); - } - break; - - case OPT_FS_FREQUENCY: - // --fs-frequency - if (optarg) { - fsFrequency = atoi(optarg); - } - break; - - case OPT_WINDOW_POSITION_X: - // --window-position-x - if (optarg) { - windowPositionX = atoi(optarg); - } - break; - - case OPT_WINDOW_POSITION_Y: - // --window-position-y - if (optarg) { - windowPositionY = atoi(optarg); - } - break; - - case OPT_SOUND_FILTERING: - // --sound-filtering - if (optarg) { - soundFiltering = atoi(optarg); - } - break; - - case OPT_GL_FILTER: - // --gl-filter - if (optarg) { - glFilter = atoi(optarg); - } - break; - - case OPT_SHOW_SPEED: - // --show-speed - if (optarg) { - showSpeed = atoi(optarg); - } - break; - - case OPT_IFB_TYPE: - // --ifb-type - if (optarg) { - ifbType = atoi(optarg); - } - break; - - case OPT_GB_EMULATOR_TYPE: - // --gb-emulator-type - if (optarg) { - gbEmulatorType = atoi(optarg); - } - break; - - case OPT_THREAD_PRIORITY: - // --thread-priority - if (optarg) { - threadPriority = atoi(optarg); - } - break; - - case OPT_GB_PALETTE_OPTION: - // --gb-palette-option - if (optarg) { - gbPaletteOption = atoi(optarg); - } - break; - - case OPT_REWIND_TIMER: - // --rewind-timer - if (optarg) { - rewindTimer = atoi(optarg); - } - break; - - case OPT_JOYPAD_DEFAULT: - // --joypad-default - if (optarg) { - joypadDefault = atoi(optarg); - } - break; - - case OPT_MAX_SCALE: - // --max-scale - if (optarg) { - maxScale = atoi(optarg); - } - break; - - case OPT_LINK_TIMEOUT: - // --link-timeout - if (optarg) { - linkTimeout = atoi(optarg); - } - break; - - case OPT_LINK_MODE: - // --link-mode - if (optarg) { - linkMode = atoi(optarg); - } - break; - - case OPT_LINK_AUTO: - // --link-auto - if (optarg) { - linkAuto = atoi(optarg); - } - break; - - case OPT_LINK_HACKS: - // --link-hacks - if (optarg) { - linkHacks = atoi(optarg); - } - break; - - case OPT_LINK_NUM_PLAYERS: - // --link-num-players - if (optarg) { - linkNumPlayers = atoi(optarg); - } - break; - - case OPT_GDB_PORT: - // --gdb-port - if (optarg) { - gdbPort = atoi(optarg); - } - break; - - case OPT_BIOS_FILE_NAME_GB: - // --bios-file-name-gb - biosFileNameGB = optarg; - break; - - case OPT_BIOS_FILE_NAME_GBA: - // --bios-file-name-gba - biosFileNameGBA = optarg; - break; - - case OPT_BIOS_FILE_NAME_GBC: - // --bios-file-name-gbc - biosFileNameGBC = optarg; - break; - - case OPT_AVI_RECORD_DIR: - // --avi-record-dir - aviRecordDir = optarg; - break; - - case OPT_MOVIE_RECORD_DIR: - // --movie-record-dir - movieRecordDir = optarg; - break; - - case OPT_SOUND_RECORD_DIR: - // --sound-record-dir - soundRecordDir = optarg; - break; - - case OPT_SCREEN_SHOT_DIR: - // --screen-shot-dir - screenShotDir = optarg; - break; - - case OPT_SAVE_DIR: - // --save-dir - saveDir = optarg; - break; - - case OPT_BATTERY_DIR: - // --battery-dir - batteryDir = optarg; - break; - - case OPT_ROM_DIR_GBC: - // --rom-dir-gbc - romDirGBC = optarg; - break; - - case OPT_ROM_DIR_GB: - // --rom-dir-gb - romDirGB = optarg; - break; - - case OPT_ROM_DIR_GBA: - // --rom-dir-gba - romDirGBA = optarg; - break; - - case OPT_LINK_HOST_ADDR: - // --link-host-addr - linkHostAddr = optarg; - break; - - case OPT_CPU_SAVE_TYPE: - // --cpu-save-type - if (optarg) { - cpuSaveType = atoi(optarg); - } - break; - - case OPT_OPT_FLASH_SIZE: - // --opt-flash-size - if (optarg) { - optFlashSize = atoi(optarg); - } - break; - - case OPT_WINDOW_HEIGHT: - // --window-height - if (optarg) { - windowHeight = atoi(optarg); - } - break; - - case OPT_WINDOW_WIDTH: - // --window-width - if (optarg) { - windowWidth = atoi(optarg); - } - break; - - case OPT_DOTCODE_FILE_NAME_LOAD: - // --dotcode-file-name-load - loadDotCodeFile = optarg; - break; - - case OPT_DOTCODE_FILE_NAME_SAVE: - // --dotcode-file-name-save - saveDotCodeFile = optarg; - break; - case OPT_SPEEDUP_THROTTLE: - if (optarg) - speedup_throttle = atoi(optarg); - break; - case OPT_SPEEDUP_FRAME_SKIP: - if (optarg) - speedup_frame_skip = atoi(optarg); - break; - } - } - return op; -} - +// necessary to get portable strerror_r +#undef _GNU_SOURCE +#include +#define _GNU_SOURCE 1 + +#include "ConfigManager.h" +extern "C" { +#include "../common/iniparser.h" +} + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../common/Patch.h" +#include "../common/ConfigManager.h" +#include "../gba/GBA.h" +#include "../gba/agbprint.h" +#include "../gba/Flash.h" +#include "../gba/Cheats.h" +#include "../gba/remote.h" +#include "../gba/RTC.h" +#include "../gba/Sound.h" +#include "../gb/gb.h" +#include "../gb/gbGlobals.h" +#include "../gb/gbCheats.h" +#include "../gb/gbSound.h" +#include "../Util.h" + +#ifndef _WIN32 +#define GETCWD getcwd +#else // _WIN32 +#include +#define GETCWD _getcwd +#define snprintf sprintf +#define stat _stat +#define mkdir(X,Y) (_mkdir(X)) +// from: https://www.linuxquestions.org/questions/programming-9/porting-to-win32-429334/ +#ifndef S_ISDIR + #define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR) +#endif +#endif // _WIN32 + +#ifndef __GNUC__ +#define HAVE_DECL_GETOPT 0 +#define __STDC__ 1 +#include "getopt.h" +#else // ! __GNUC__ +#define HAVE_DECL_GETOPT 1 +#include +#endif // ! __GNUC__ +#include +#include + +enum named_opts +{ + OPT_AGB_PRINT = 1000, + OPT_AUTOFIRE, + OPT_AUTO_FRAME_SKIP, + OPT_AVI_RECORD_DIR, + OPT_BATTERY_DIR, + OPT_BIOS_FILE_NAME_GB, + OPT_BIOS_FILE_NAME_GBA, + OPT_BIOS_FILE_NAME_GBC, + OPT_CAPTURE_FORMAT, + OPT_CHEAT, + OPT_CPU_SAVE_TYPE, + OPT_DOTCODE_FILE_NAME_LOAD, + OPT_DOTCODE_FILE_NAME_SAVE, + OPT_EMULATOR_TYPE, + OPT_FS_ADAPTER, + OPT_FS_COLOR_DEPTH, + OPT_FS_FREQUENCY, + OPT_FS_HEIGHT, + OPT_FS_WIDTH, + OPT_GB_EMULATOR_TYPE, + OPT_GB_FRAME_SKIP, + OPT_GB_PALETTE_OPTION, + OPT_GDB_PORT, + OPT_GL_FILTER, + OPT_IFB_TYPE, + OPT_JOYPAD_DEFAULT, + OPT_LANGUAGE_OPTION, + OPT_LINK_AUTO, + OPT_LINK_HACKS, + OPT_LINK_HOST_ADDR, + OPT_LINK_MODE, + OPT_LINK_NUM_PLAYERS, + OPT_LINK_TIMEOUT, + OPT_MAX_SCALE, + OPT_MOVIE_RECORD_DIR, + OPT_OPT_FLASH_SIZE, + OPT_REWIND_TIMER, + OPT_ROM_DIR_GB, + OPT_ROM_DIR_GBA, + OPT_ROM_DIR_GBC, + OPT_RTC_ENABLED, + OPT_SAVE_DIR, + OPT_SCREEN_SHOT_DIR, + OPT_SHOW_SPEED, + OPT_SHOW_SPEED_TRANSPARENT, + OPT_SOUND_FILTERING, + OPT_SOUND_RECORD_DIR, + OPT_SYNCHRONIZE, + OPT_THREAD_PRIORITY, + OPT_VIDEO_OPTION, + OPT_WINDOW_HEIGHT, + OPT_WINDOW_POSITION_X, + OPT_WINDOW_POSITION_Y, + OPT_WINDOW_WIDTH, + OPT_SPEEDUP_THROTTLE, + OPT_SPEEDUP_FRAME_SKIP +}; + +#define SOUND_MAX_VOLUME 2.0 +#define SOUND_ECHO 0.2 +#define SOUND_STEREO 0.15 + +#define REWIND_NUM 8 +#define REWIND_SIZE 400000 + +char path[2048]; + +dictionary* preferences; + +bool cpuIsMultiBoot = false; +bool mirroringEnable = true; +bool parseDebug = true; +bool speedHack = false; +bool speedup = false; +const char* aviRecordDir; +const char* batteryDir; +const char* biosFileNameGB; +const char* biosFileNameGBA; +const char* biosFileNameGBC; +const char* loadDotCodeFile; +const char* saveDotCodeFile; +const char* linkHostAddr; +const char* movieRecordDir; +char* rewindMemory = NULL; +const char* romDirGB; +const char* romDirGBA; +const char* romDirGBC; +const char* saveDir; +const char* screenShotDir; +const char* soundRecordDir; +int active = 1; +int agbPrint; +int autoFire; +int autoFireMaxCount = 1; +int autoFireToggle; +int autoFrameSkip = 0; +int autoLoadMostRecent; +int autoPatch; +int autoSaveLoadCheatList; +int aviRecording; +int captureFormat = 0; +int cheatsEnabled = true; +int cpuDisableSfx = false; +int cpuSaveType = 0; +int disableMMX; +int disableStatusMessages = 0; +int dsoundDisableHardwareAcceleration; +int filterHeight; +int filterMagnification; +int filterMT; // enable multi-threading for pixel filters +int filter = kStretch2x; +int filterWidth; +int frameSkip = 1; +int frameskipadjust; +int fsAdapter; +int fsColorDepth; +int fsForceChange; +int fsFrequency; +int fsHeight; +int fsWidth; +int fullScreen; +int fullScreenStretch; +int gdbBreakOnLoad; +int gdbPort; +int glFilter; +int ifbType = kIFBNone; +int joypadDefault; +int languageOption; +int layerEnable = 0xff00; +int layerSettings = 0xff00; +int linkAuto; +int linkHacks = 1; +int linkMode; +int linkNumPlayers; +int linkTimeout = 1; +int maxScale; +int mouseCounter = 0; +int movieFrame; +int moviePlayFrame; +int moviePlaying; +int movieRecording; +int openGL; +int optFlashSize; +int optPrintUsage; +int paused; +int pauseWhenInactive = 0; +int preparedCheats = 0; +int recentFreeze; +int renderedFrames; +int rewindCount; +int rewindCounter; +int rewindPos; +int rewindSaveNeeded = 0; +int rewindTimer = 0; +int rewindTopPos; +int rtcEnabled; +int saveType = GBA_SAVE_AUTO; +int screenMessage; +int sensorX; +int sensorY; +int showRenderedFrames; +int showSpeed; +int showSpeedTransparent; +int sizeX; +int sizeY; +int skipBios = 0; +int skipSaveGameBattery = false; +int skipSaveGameCheats = false; +int soundRecording; +int speedupToggle; +int sunBars; +int surfaceSizeX; +int surfaceSizeY; +int threadPriority; +int tripleBuffering; +int useBios = 0; +int useBiosFileGB; +int useBiosFileGBA; +int useBiosFileGBC; +int videoOption; +int vsync; +int wasPaused = 0; +uint32_t windowHeight; +int windowPositionX; +int windowPositionY; +uint32_t windowWidth; +int winFlashSize; +int winGbBorderOn; +int winGbPrinterEnabled; +int winPauseNextFrame; +int* rewindSerials = NULL; +uint32_t autoFrameSkipLastTime; +uint32_t movieLastJoypad; +uint32_t movieNextJoypad; +uint32_t throttle = 100; +uint32_t speedup_throttle = 0; +uint32_t speedup_frame_skip = 9; + +const char* preparedCheatCodes[MAX_CHEATS]; + +FilterFunc filterFunction = 0; +IFBFilterFunc ifbFunction = 0; + +// allow up to 100 IPS/UPS/PPF patches given on commandline +int patchNum = 0; +char *patchNames[PATCH_MAX_NUM] = { NULL }; // and so on + +void(*dbgMain)() = remoteStubMain; +void(*dbgSignal)(int, int) = remoteStubSignal; +void(*dbgOutput)(const char *, uint32_t) = debuggerOutput; + +char* homeDir = NULL; +char* arg0 = NULL; + + +struct option argOptions[] = { + + { "agb-print", required_argument, 0, OPT_AGB_PRINT }, + { "auto-frame-skip", required_argument, 0, OPT_AUTO_FRAME_SKIP }, + { "auto-load-most-recent", no_argument, &autoLoadMostRecent, 1 }, + { "auto-patch", no_argument, &autoPatch, 1 }, + { "auto-save-cheat-list", no_argument, &autoSaveLoadCheatList, 1 }, + { "auto-save-load-cheat-list", no_argument, &autoSaveLoadCheatList, 1 }, + { "autofire", required_argument, 0, OPT_AUTOFIRE }, + { "avi-record-dir", required_argument, 0, OPT_AVI_RECORD_DIR }, + { "battery-dir", required_argument, 0, OPT_BATTERY_DIR }, + { "bios", required_argument, 0, 'b' }, + { "bios-file-name-gb", required_argument, 0, OPT_BIOS_FILE_NAME_GB }, + { "bios-file-name-gba", required_argument, 0, OPT_BIOS_FILE_NAME_GBA }, + { "bios-file-name-gbc", required_argument, 0, OPT_BIOS_FILE_NAME_GBC }, + { "border-automatic", no_argument, &gbBorderAutomatic, 1 }, + { "border-on", no_argument, &gbBorderOn, 1 }, + { "capture-format", required_argument, 0, OPT_CAPTURE_FORMAT }, + { "cheat", required_argument, 0, OPT_CHEAT }, + { "cheats-enabled", no_argument, &cheatsEnabled, 1 }, + { "color-option", no_argument, &gbColorOption, 1 }, + { "config", required_argument, 0, 'c' }, + { "cpu-disable-sfx", no_argument, &cpuDisableSfx, 1 }, + { "cpu-save-type", required_argument, 0, OPT_CPU_SAVE_TYPE }, + { "debug", no_argument, 0, 'd' }, + { "disable-mmx", no_argument, &disableMMX, 1 }, + { "disable-sfx", no_argument, &cpuDisableSfx, 1 }, + { "disable-status-messages", no_argument, &disableStatusMessages, 1 }, + { "dotcode-file-name-load", required_argument, 0, OPT_DOTCODE_FILE_NAME_LOAD }, + { "dotcode-file-name-save", required_argument, 0, OPT_DOTCODE_FILE_NAME_SAVE }, + { "emulator-type", required_argument, 0, OPT_EMULATOR_TYPE }, + { "filter", required_argument, 0, 'f' }, + { "filter-enable-multi-threading", no_argument, &filterMT, 1 }, + { "filter-mt", no_argument, &filterMT, 1 }, + { "flash-128k", no_argument, &optFlashSize, 1 }, + { "flash-64k", no_argument, &optFlashSize, 0 }, + { "flash-size", required_argument, 0, 'S' }, + { "frameskip", required_argument, 0, 's' }, + { "fs-adapter", required_argument, 0, OPT_FS_ADAPTER }, + { "fs-color-depth", required_argument, 0, OPT_FS_COLOR_DEPTH }, + { "fs-frequency", required_argument, 0, OPT_FS_FREQUENCY }, + { "fs-height", required_argument, 0, OPT_FS_HEIGHT }, + { "fs-width", required_argument, 0, OPT_FS_WIDTH }, + { "full-screen", no_argument, &fullScreen, 1 }, + { "full-screen-stretch", no_argument, &fullScreenStretch, 1 }, + { "gb-border-automatic", no_argument, &gbBorderAutomatic, 1 }, + { "gb-border-on", no_argument, &gbBorderOn, 1 }, + { "gb-color-option", no_argument, &gbColorOption, 1 }, + { "gb-emulator-type", required_argument, 0, OPT_GB_EMULATOR_TYPE }, + { "gb-frame-skip", required_argument, 0, OPT_GB_FRAME_SKIP }, + { "gb-palette-option", required_argument, 0, OPT_GB_PALETTE_OPTION }, + { "gb-printer", no_argument, &winGbPrinterEnabled, 1 }, + { "gdb", required_argument, 0, 'G' }, + { "gdb-break-on-load", no_argument, &gdbBreakOnLoad, 1 }, + { "gdb-port", required_argument, 0, OPT_GDB_PORT }, + { "gl-filter", required_argument, 0, OPT_GL_FILTER }, + { "help", no_argument, &optPrintUsage, 1 }, + { "ifb-filter", required_argument, 0, 'I' }, + { "ifb-type", required_argument, 0, OPT_IFB_TYPE }, + { "joypad-default", required_argument, 0, OPT_JOYPAD_DEFAULT }, + { "language-option", required_argument, 0, OPT_LANGUAGE_OPTION }, + { "link-auto", required_argument, 0, OPT_LINK_AUTO }, + { "link-hacks", required_argument, 0, OPT_LINK_HACKS }, + { "link-host-addr", required_argument, 0, OPT_LINK_HOST_ADDR }, + { "link-mode", required_argument, 0, OPT_LINK_MODE }, + { "link-num-players", required_argument, 0, OPT_LINK_NUM_PLAYERS }, + { "link-timeout", required_argument, 0, OPT_LINK_TIMEOUT }, + { "max-scale", required_argument, 0, OPT_MAX_SCALE }, + { "movie-record-dir", required_argument, 0, OPT_MOVIE_RECORD_DIR }, + { "no-agb-print", no_argument, &agbPrint, 0 }, + { "no-auto-frameskip", no_argument, &autoFrameSkip, 0 }, + { "no-debug", no_argument, 0, 'N' }, + { "no-opengl", no_argument, &openGL, 0 }, + { "no-patch", no_argument, &autoPatch, 0 }, + { "no-pause-when-inactive", no_argument, &pauseWhenInactive, 0 }, + { "no-rtc", no_argument, &rtcEnabled, 0 }, + { "no-show-speed", no_argument, &showSpeed, 0 }, + { "opengl", required_argument, 0, 'O' }, + { "opengl-bilinear", no_argument, &openGL, 2 }, + { "opengl-nearest", no_argument, &openGL, 1 }, + { "opt-flash-size", required_argument, 0, OPT_OPT_FLASH_SIZE }, + { "patch", required_argument, 0, 'i' }, + { "pause-when-inactive", no_argument, &pauseWhenInactive, 1 }, + { "profile", optional_argument, 0, 'p' }, + { "recent-freeze", no_argument, &recentFreeze, 1 }, + { "rewind-timer", required_argument, 0, OPT_REWIND_TIMER }, + { "rom-dir-gb", required_argument, 0, OPT_ROM_DIR_GB }, + { "rom-dir-gba", required_argument, 0, OPT_ROM_DIR_GBA }, + { "rom-dir-gbc", required_argument, 0, OPT_ROM_DIR_GBC }, + { "rtc", no_argument, &rtcEnabled, 1 }, + { "rtc-enabled", required_argument, 0, OPT_RTC_ENABLED }, + { "save-auto", no_argument, &cpuSaveType, 0 }, + { "save-dir", required_argument, 0, OPT_SAVE_DIR }, + { "save-eeprom", no_argument, &cpuSaveType, 1 }, + { "save-flash", no_argument, &cpuSaveType, 3 }, + { "save-none", no_argument, &cpuSaveType, 5 }, + { "save-sensor", no_argument, &cpuSaveType, 4 }, + { "save-sram", no_argument, &cpuSaveType, 2 }, + { "save-type", required_argument, 0, 't' }, + { "screen-shot-dir", required_argument, 0, OPT_SCREEN_SHOT_DIR }, + { "show-speed", required_argument, 0, OPT_SHOW_SPEED }, + { "show-speed-detailed", no_argument, &showSpeed, 2 }, + { "show-speed-normal", no_argument, &showSpeed, 1 }, + { "show-speed-transparent", required_argument, 0, OPT_SHOW_SPEED_TRANSPARENT }, + { "skip-bios", no_argument, &skipBios, 1 }, + { "skip-save-game-battery", no_argument, &skipSaveGameBattery, 1 }, + { "skip-save-game-cheats", no_argument, &skipSaveGameCheats, 1 }, + { "sound-filtering", required_argument, 0, OPT_SOUND_FILTERING }, + { "sound-record-dir", required_argument, 0, OPT_SOUND_RECORD_DIR }, + { "stretch", no_argument, &fullScreenStretch, 1 }, + { "synchronize", required_argument, 0, OPT_SYNCHRONIZE }, + { "thread-priority", required_argument, 0, OPT_THREAD_PRIORITY }, + { "throttle", required_argument, 0, 'T' }, + { "speedup_throttle", required_argument, 0, OPT_SPEEDUP_THROTTLE }, + { "speedup_frame_skip", required_argument, 0, OPT_SPEEDUP_FRAME_SKIP }, + { "triple-buffering", no_argument, &tripleBuffering, 1 }, + { "use-bios", no_argument, &useBios, 1 }, + { "use-bios-file-gb", no_argument, &useBiosFileGB, 1 }, + { "use-bios-file-gba", no_argument, &useBiosFileGBA, 1 }, + { "use-bios-file-gbc", no_argument, &useBiosFileGBC, 1 }, + { "verbose", required_argument, 0, 'v' }, + { "video-option", required_argument, 0, OPT_VIDEO_OPTION }, + { "vsync", no_argument, &vsync, 1 }, + { "win-gb-printer-enabled", no_argument, &winGbPrinterEnabled, 1 }, + { "window-height", required_argument, 0, OPT_WINDOW_HEIGHT }, + { "window-position-x", required_argument, 0, OPT_WINDOW_POSITION_X }, + { "window-position-y", required_argument, 0, OPT_WINDOW_POSITION_Y }, + { "window-width", required_argument, 0, OPT_WINDOW_WIDTH }, + + + { NULL, no_argument, NULL, 0 } +}; + + +uint32_t fromHex(const char *s) +{ + if (!s) + return 0; + uint32_t value; + sscanf(s, "%x", &value); + return value; +} + +uint32_t fromDec(const char *s) +{ + if (!s) + return 0; + uint32_t value = 0; + sscanf(s, "%u", &value); + return value; +} + +void SetHome(char *_arg0) +{ + arg0 = _arg0; +} + +void OpenPreferences(const char *name) +{ + if (!preferences && name) + preferences = iniparser_load(name); +} + +void ValidateConfig() +{ + if (gbEmulatorType < 0 || gbEmulatorType > 5) + gbEmulatorType = 1; + if (frameSkip < 0 || frameSkip > 9) + frameSkip = 2; + if (gbFrameSkip < 0 || gbFrameSkip > 9) + gbFrameSkip = 0; + if (filter < kStretch1x || filter >= kInvalidFilter) + filter = kStretch2x; + + if (cpuSaveType < 0 || cpuSaveType > 5) + cpuSaveType = 0; + if (optFlashSize != 0 && optFlashSize != 1) + optFlashSize = 0; + if (ifbType < kIFBNone || ifbType >= kInvalidIFBFilter) + ifbType = kIFBNone; + if (showSpeed < 0 || showSpeed > 2) + showSpeed = 1; + if (rewindTimer < 0 || rewindTimer > 600) + rewindTimer = 0; + if (autoFireMaxCount < 1) + autoFireMaxCount = 1; + + if (rewindTimer) { + rewindMemory = (char *)malloc(REWIND_NUM*REWIND_SIZE); + rewindSerials = (int *)calloc(REWIND_NUM, sizeof(int)); // init to zeroes + } +} + +void LoadConfig() +{ + agbPrint = ReadPrefHex("agbPrint"); + autoFireMaxCount = fromDec(ReadPrefString("autoFireMaxCount")); + autoFrameSkip = ReadPref("autoFrameSkip", 0); + autoLoadMostRecent = ReadPref("autoLoadMostRecent", 0); + autoPatch = ReadPref("autoPatch", 1); + autoSaveLoadCheatList = ReadPref("autoSaveCheatList", 1); + aviRecordDir = ReadPrefString("aviRecordDir"); + batteryDir = ReadPrefString("batteryDir"); + biosFileNameGB = ReadPrefString("biosFileGB"); + biosFileNameGBA = ReadPrefString("biosFileGBA"); + biosFileNameGBC = ReadPrefString("biosFileGBC"); + captureFormat = ReadPref("captureFormat", 0); + cheatsEnabled = ReadPref("cheatsEnabled", 0); + cpuDisableSfx = ReadPref("disableSfx", 0); + cpuSaveType = ReadPrefHex("saveType"); + disableMMX = ReadPref("disableMMX", 0); + disableStatusMessages = ReadPrefHex("disableStatus"); + filterMT = ReadPref("filterEnableMultiThreading", 0); + filter = ReadPref("filter", 0); + frameSkip = ReadPref("frameSkip", 0); + fsAdapter = ReadPref("fsAdapter", 0); + fsColorDepth = ReadPref("fsColorDepth", 32); + fsFrequency = ReadPref("fsFrequency", 60); + fsHeight = ReadPref("fsHeight", 600); + fsWidth = ReadPref("fsWidth", 800); + fullScreen = ReadPrefHex("fullScreen"); + fullScreenStretch = ReadPref("stretch", 0); + gbBorderAutomatic = ReadPref("borderAutomatic", 0); + gbBorderOn = ReadPrefHex("borderOn"); + gbColorOption = ReadPref("colorOption", 0); + gbEmulatorType = ReadPref("emulatorType", 1); + gbFrameSkip = ReadPref("gbFrameSkip", 0); + gbPaletteOption = ReadPref("gbPaletteOption", 0); + gbSoundSetDeclicking(ReadPref("gbSoundDeclicking", 1)); + gb_effects_config.echo = (float)ReadPref("gbSoundEffectsEcho", 20) / 100.0f; + gb_effects_config.enabled = ReadPref("gbSoundEffectsEnabled", 0); + gb_effects_config.stereo = (float)ReadPref("gbSoundEffectsStereo", 15) / 100.0f; + gb_effects_config.surround = ReadPref("gbSoundEffectsSurround", 0); + gdbBreakOnLoad = ReadPref("gdbBreakOnLoad", 0); + gdbPort = ReadPref("gdbPort", 55555); + glFilter = ReadPref("glFilter", 1); + ifbType = ReadPref("ifbType", 0); + joypadDefault = ReadPref("joypadDefault", 0); + languageOption = ReadPref("language", 1); + linkAuto = ReadPref("LinkAuto", 1); + linkHacks = ReadPref("LinkHacks", 0); + linkHostAddr = ReadPrefString("LinkHostAddr", "localhost"); + linkMode = ReadPref("LinkMode", 0); // LINK_DISCONNECTED = 0 + linkNumPlayers = ReadPref("LinkNumPlayers", 2); + linkTimeout = ReadPref("LinkTimeout", 1); + loadDotCodeFile = ReadPrefString("loadDotCodeFile"); + maxScale = ReadPref("maxScale", 0); + movieRecordDir = ReadPrefString("movieRecordDir"); + openGL = ReadPrefHex("openGL"); + optFlashSize = ReadPrefHex("flashSize"); + pauseWhenInactive = ReadPref("pauseWhenInactive", 1); + recentFreeze = ReadPref("recentFreeze", 0); + rewindTimer = ReadPref("rewindTimer", 0); + romDirGB = ReadPrefString("romDirGB"); + romDirGBA = ReadPrefString("romDirGBA"); + romDirGBC = ReadPrefString("romDirGBC"); + rtcEnabled = ReadPref("rtcEnabled", 0); + saveDir = ReadPrefString("saveDir"); + saveDotCodeFile = ReadPrefString("saveDotCodeFile"); + screenShotDir = ReadPrefString("screenShotDir"); + showSpeed = ReadPref("showSpeed", 0); + showSpeedTransparent = ReadPref("showSpeedTransparent", 1); + skipBios = ReadPref("skipBios", 0); + skipSaveGameBattery = ReadPref("skipSaveGameBattery", 0); + skipSaveGameCheats = ReadPref("skipSaveGameCheats", 0); + soundFiltering = (float)ReadPref("gbaSoundFiltering", 50) / 100.0f; + soundInterpolation = ReadPref("gbaSoundInterpolation", 1); + soundRecordDir = ReadPrefString("soundRecordDir"); + threadPriority = ReadPref("priority", 2); + throttle = ReadPref("throttle", 100); + speedup_throttle = ReadPref("speedup_throttle", 0); + speedup_frame_skip = ReadPref("speedup_frame_skip", 9); + tripleBuffering = ReadPref("tripleBuffering", 0); + useBios = ReadPrefHex("useBiosGBA"); + useBiosFileGB = ReadPref("useBiosGB", 0); + useBiosFileGBA = ReadPref("useBiosGBA", 0); + useBiosFileGBC = ReadPref("useBiosGBC", 0); + videoOption = ReadPref("video", 2); // VIDEO_3X = 2 + vsync = ReadPref("vsync", false); + windowHeight = ReadPref("windowHeight", 0); + windowPositionX = ReadPref("windowX", -1); + windowPositionY = ReadPref("windowY", -1); + windowWidth = ReadPref("windowWidth", 0); + winFlashSize = ReadPref("flashSize", 0x10000); + winGbBorderOn = ReadPref("borderOn", 0); + winGbPrinterEnabled = ReadPref("gbPrinter", 0); + + int soundQuality = (ReadPrefHex("soundQuality", 1)); + switch (soundQuality) { + case 1: + case 2: + case 4: + break; + default: + log("Unknown sound quality %d. Defaulting to 44Khz\n", soundQuality); + soundQuality = 1; + break; + } + soundSetSampleRate(44100 / soundQuality); + int volume = ReadPref("soundVolume", 100); + float volume_percent = volume / 100.0f; + if (volume_percent < 0.0 || volume_percent > SOUND_MAX_VOLUME) + volume_percent = 1.0; + soundSetVolume(volume_percent); + + soundSetEnable((ReadPrefHex("soundEnable", 0x30f)) & 0x30f); + if ((ReadPrefHex("soundStereo"))) { + gb_effects_config.enabled = true; + } + if ((ReadPrefHex("soundEcho"))) { + gb_effects_config.enabled = true; + } + if ((ReadPrefHex("soundSurround"))) { + gb_effects_config.surround = true; + gb_effects_config.enabled = true; + } + + if (optFlashSize == 0) + flashSetSize(0x10000); + else + flashSetSize(0x20000); + + rtcEnable(rtcEnabled ? true : false); + agbPrintEnable(agbPrint ? true : false); + + for (int i = 0; i < 24;) { + systemGbPalette[i++] = (0x1f) | (0x1f << 5) | (0x1f << 10); + systemGbPalette[i++] = (0x15) | (0x15 << 5) | (0x15 << 10); + systemGbPalette[i++] = (0x0c) | (0x0c << 5) | (0x0c << 10); + systemGbPalette[i++] = 0; + } + + systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED; + + optPrintUsage = 0; + + // TODO + //int s = ReadPref("mapViewStretch", 0); + //m_size = ReadPref("memViewerDataSize", 0); + //m_stretch = ReadPref("GBOamViewStretch", 0); + //m_stretch = ReadPref("tileViewStretch", 0); + //numberType = ReadPref("cheatsNumberType", 2); + //numberType = ReadPref("gbCheatsNumberType", 2); + //restoreValues = ReadPref("cheatsRestore", 0) ? + //scale = ReadPref("printerScale", 0); + //searchType = ReadPref("cheatsSearchType", SEARCH_EQ); + //searchType = ReadPref("gbCheatsSearchType", + //selectedFilter = ReadPref(("selectedFilter"), 0); + //sizeType = ReadPref("cheatsSizeType", 0); + //sizeType = ReadPref("gbCheatsSizeType", 0); + //updateValues = ReadPref("cheatsUpdate", 0); + //updateValues = ReadPref("gbCheatsUpdate", 0); + //valueType = ReadPref("cheatsValueType", 0); + //valueType = ReadPref("gbCheatsValueType", 0); + + ValidateConfig(); +} + +void CloseConfig() +{ + if (preferences) + iniparser_freedict(preferences); +} + +const char* FindConfigFile(const char *name) +{ + char buffer[4096]; + +#ifdef _WIN32 +#define PATH_SEP ";" +#define EXE_NAME "vbam.exe" +#else // ! _WIN32 +#define PATH_SEP ":" +#define EXE_NAME "vbam" +#endif // ! _WIN32 + + if (GETCWD(buffer, 2048)) { + } + + if (FileExists(name)) + { + return name; + } + + if (homeDir) { + sprintf(path, "%s%c%s", homeDir, FILE_SEP, name); + if (FileExists(path)) + { + return path; + } + } + +#ifdef _WIN32 + char *home = getenv("USERPROFILE"); + if (home != NULL) { + sprintf(path, "%s%c%s", home, FILE_SEP, name); + if (FileExists(path)) + { + return path; + } + } + + if (!strchr(arg0, '/') && + !strchr(arg0, '\\')) { + char *path = getenv("PATH"); + + if (path != NULL) { + strncpy(buffer, path, 4096); + buffer[4095] = 0; + char *tok = strtok(buffer, PATH_SEP); + + while (tok) { + sprintf(path, "%s%c%s", tok, FILE_SEP, EXE_NAME); + if (FileExists(path)) { + static char path2[2048]; + sprintf(path2, "%s%c%s", tok, FILE_SEP, name); + if (FileExists(path2)) { + return path2; + } + } + tok = strtok(NULL, PATH_SEP); + } + } + } + else { + // executable is relative to some directory + strcpy(buffer, arg0); + char *p = strrchr(buffer, FILE_SEP); + if (p) { + *p = 0; + sprintf(path, "%s%c%s", buffer, FILE_SEP, name); + if (FileExists(path)) + { + return path; + } + } + } +#else // ! _WIN32 + sprintf(path, "%s%c%s", PKGDATADIR, FILE_SEP, name); + if (FileExists(path)) + { + return path; + } + + sprintf(path, "%s%c%s", SYSCONF_INSTALL_DIR, FILE_SEP, name); + if (FileExists(path)) + { + return path; + } +#endif // ! _WIN32 + return 0; +} + +void LoadConfigFile() +{ + struct stat s; + std::string homeDirTmp = get_xdg_user_config_home() + DOT_DIR; + homeDir = (char *)homeDirTmp.c_str(); + if (stat(homeDir, &s) == -1 || !S_ISDIR(s.st_mode)) + mkdir(homeDir, 0755); + + if (preferences == NULL) + { + const char* configFile = FindConfigFile("vbam.ini"); + OpenPreferences(configFile); + } +} + +void SaveConfigFile() +{ + struct stat s; + std::string homeDirTmp = get_xdg_user_config_home() + DOT_DIR; + homeDir = (char *)homeDirTmp.c_str(); + if (stat(homeDir, &s) == -1 || !S_ISDIR(s.st_mode)) + mkdir(homeDir, 0755); + + const char* configFile = FindConfigFile("vbam.ini"); + + if (configFile != NULL) + { + FILE *f = fopen(configFile, "w"); + if (f == NULL) { + char err_msg[4096] = "unknown error"; + strncpy(err_msg, strerror(errno), 4096); + fprintf(stderr, "Configuration file '%s' could not be written to: %s\n", configFile, err_msg); + return; + } + // Needs mixed case version of the option name to add new options into the ini + //for (int i = 0; i < (sizeof(argOptions) / sizeof(option)); i++) + //{ + // std::string pref = "preferences:"; + // pref.append(argOptions[i].name); + // if (!iniparser_find_entry(preferences, pref.c_str())) + // { + // iniparser_set(preferences, pref.c_str(), NULL); + // } + //} + iniparser_dump_ini(preferences, f); + fclose(f); + } +} + +uint32_t ReadPrefHex(const char* pref_key, int default_value) +{ + std::stringstream ss; + std::string default_string; + ss.setf(std::ios::hex|std::ios::showbase, std::ios::basefield); + ss << default_value; + ss >> default_string; + LoadConfigFile(); + std::string pref = "preferences:"; + pref.append(pref_key); + return fromHex(iniparser_getstring(preferences, pref.c_str(), default_string.c_str())); +} + +uint32_t ReadPrefHex(const char* pref_key) +{ + LoadConfigFile(); + std::string pref = "preferences:"; + pref.append(pref_key); + return fromHex(iniparser_getstring(preferences, pref.c_str(), 0)); +} + +uint32_t ReadPref(const char* pref_key, int default_value) +{ + LoadConfigFile(); + std::string pref = "preferences:"; + pref.append(pref_key); + return iniparser_getint(preferences, pref.c_str(), default_value); +} + +uint32_t ReadPref(const char* pref_key) +{ + return ReadPref(pref_key, 0); +} + +const char* ReadPrefString(const char* pref_key, const char* default_value) +{ + LoadConfigFile(); + std::string pref = "preferences:"; + pref.append(pref_key); + return iniparser_getstring(preferences, pref.c_str(), default_value); +} + +const char* ReadPrefString(const char* pref_key) +{ + return ReadPrefString(pref_key, ""); +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Duplicate a string + @param s String to duplicate + @return Pointer to a newly allocated string, to be freed with free() + + This is a replacement for strdup(). This implementation is provided + for systems that do not have it. + */ +/*--------------------------------------------------------------------------*/ +static char *xstrdup(const char *s) +{ + char *t; + if (!s) + return NULL; + t = (char *)malloc(strlen(s) + 1); + if (t) { + strcpy(t, s); + } + return t; +} + +int ReadOpts(int argc, char ** argv) +{ + int op = -1; + while ((op = getopt_long(argc, + argv, + "FNO:T:Y:G:I:D:b:c:df:hi:p::s:t:v:", + argOptions, + NULL)) != -1) { + switch (op) { + case 0: + // long option already processed by getopt_long + break; + case OPT_CHEAT: + // --cheat + if (preparedCheats >= MAX_CHEATS) { + log("Warning: cannot add more than %d cheats.\n", MAX_CHEATS); + break; + } + { + //char* cpy; + //cpy = (char *)malloc(1 + strlen(optarg)); + //strcpy(cpy, optarg); + //preparedCheatCodes[preparedCheats++] = cpy; + std::string cpy = optarg; + preparedCheatCodes[preparedCheats++] = cpy.c_str(); + } + break; + case OPT_AUTOFIRE: + // --autofire + autoFireMaxCount = fromDec(optarg); + if (autoFireMaxCount < 1) + autoFireMaxCount = 1; + break; + case 'b': + useBios = true; + if (optarg == NULL) { + log("Missing BIOS file name\n"); + break; + } + biosFileNameGBA = xstrdup(optarg); + break; + case 'c': + { + if (optarg == NULL) { + log("Missing config file name\n"); + break; + } + FILE *f = fopen(optarg, "r"); + if (f == NULL) { + log("File not found %s\n", optarg); + break; + } + preferences = NULL; + OpenPreferences(optarg); + fclose(f); + } + break; + case 'd': + debugger = true; + break; + case 'h': + optPrintUsage = 1; + break; + case 'i': + if (optarg == NULL) { + log("Missing patch name\n"); + break; + } + if (patchNum >= PATCH_MAX_NUM) { + log("Too many patches given at %s (max is %d). Ignoring.\n", optarg, PATCH_MAX_NUM); + } + else { + patchNames[patchNum] = (char *)malloc(1 + strlen(optarg)); + strcpy(patchNames[patchNum], optarg); + patchNum++; + } + break; + case 'G': + dbgMain = remoteStubMain; + dbgSignal = remoteStubSignal; + dbgOutput = remoteOutput; + debugger = true; + if (optarg) { + char *s = optarg; + if (strncmp(s, "tcp:", 4) == 0) { + s += 4; + int port = atoi(s); + remoteSetProtocol(0); + remoteSetPort(port); + } + else if (strcmp(s, "tcp") == 0) { + remoteSetProtocol(0); + } + else if (strcmp(s, "pipe") == 0) { + remoteSetProtocol(1); + } + else { + log("Unknown protocol %s\n", s); + break; + } + } + else { + remoteSetProtocol(0); + } + break; + case 'N': + parseDebug = false; + break; + case 'F': + fullScreen = 1; + mouseCounter = 120; + break; + case 'f': + if (optarg) { + filter = (Filter)atoi(optarg); + } + else { + filter = kStretch2x; + } + break; + case 'T': + if (optarg) + throttle = atoi(optarg); + break; + case 'I': + if (optarg) { + ifbType = (IFBFilter)atoi(optarg); + } + else { + ifbType = kIFBNone; + } + break; + case 'p': +#ifdef PROFILING + if (optarg) { + cpuEnableProfiling(atoi(optarg)); + } + else + cpuEnableProfiling(100); +#endif + break; + case 'S': + optFlashSize = atoi(optarg); + if (optFlashSize < 0 || optFlashSize > 1) + optFlashSize = 0; + break; + case 's': + if (optarg) { + int a = atoi(optarg); + if (a >= 0 && a <= 9) { + gbFrameSkip = a; + frameSkip = a; + } + } + else { + frameSkip = 2; + gbFrameSkip = 0; + } + break; + case 't': + if (optarg) { + int a = atoi(optarg); + if (a < 0 || a > 5) + a = 0; + cpuSaveType = a; + } + break; + case 'v': + if (optarg) { + systemVerbose = atoi(optarg); + } + else + systemVerbose = 0; + break; + case '?': + optPrintUsage = 1; + break; + case 'O': + if (optarg) { + openGL = atoi(optarg); + if (openGL < 0 || openGL > 2) + openGL = 1; + } + else + openGL = 0; + break; + + case OPT_CAPTURE_FORMAT: + // --capture-format + if (optarg) { + captureFormat = atoi(optarg); + } + break; + + case OPT_SHOW_SPEED_TRANSPARENT: + // --show-speed-transparent + if (optarg) { + showSpeedTransparent = atoi(optarg); + } + break; + + case OPT_AUTO_FRAME_SKIP: + // --auto-frame-skip + if (optarg) { + autoFrameSkip = atoi(optarg); + } + break; + + case OPT_AGB_PRINT: + // --agb-print + if (optarg) { + agbPrint = atoi(optarg); + } + break; + + case OPT_RTC_ENABLED: + // --rtc-enabled + if (optarg) { + rtcEnabled = atoi(optarg); + } + break; + + case OPT_VIDEO_OPTION: + // --video-option + if (optarg) { + videoOption = atoi(optarg); + } + break; + + case OPT_LANGUAGE_OPTION: + // --language-option + if (optarg) { + languageOption = atoi(optarg); + } + break; + + case OPT_GB_FRAME_SKIP: + // --gb-frame-skip + if (optarg) { + gbFrameSkip = atoi(optarg); + } + break; + + case OPT_FS_ADAPTER: + // --fs-adapter + if (optarg) { + fsAdapter = atoi(optarg); + } + break; + + case OPT_FS_WIDTH: + // --fs-width + if (optarg) { + fsWidth = atoi(optarg); + } + break; + + case OPT_FS_HEIGHT: + // --fs-height + if (optarg) { + fsHeight = atoi(optarg); + } + break; + + case OPT_FS_COLOR_DEPTH: + // --fs-color-depth + if (optarg) { + fsColorDepth = atoi(optarg); + } + break; + + case OPT_FS_FREQUENCY: + // --fs-frequency + if (optarg) { + fsFrequency = atoi(optarg); + } + break; + + case OPT_WINDOW_POSITION_X: + // --window-position-x + if (optarg) { + windowPositionX = atoi(optarg); + } + break; + + case OPT_WINDOW_POSITION_Y: + // --window-position-y + if (optarg) { + windowPositionY = atoi(optarg); + } + break; + + case OPT_SOUND_FILTERING: + // --sound-filtering + if (optarg) { + soundFiltering = atoi(optarg); + } + break; + + case OPT_GL_FILTER: + // --gl-filter + if (optarg) { + glFilter = atoi(optarg); + } + break; + + case OPT_SHOW_SPEED: + // --show-speed + if (optarg) { + showSpeed = atoi(optarg); + } + break; + + case OPT_IFB_TYPE: + // --ifb-type + if (optarg) { + ifbType = atoi(optarg); + } + break; + + case OPT_GB_EMULATOR_TYPE: + // --gb-emulator-type + if (optarg) { + gbEmulatorType = atoi(optarg); + } + break; + + case OPT_THREAD_PRIORITY: + // --thread-priority + if (optarg) { + threadPriority = atoi(optarg); + } + break; + + case OPT_GB_PALETTE_OPTION: + // --gb-palette-option + if (optarg) { + gbPaletteOption = atoi(optarg); + } + break; + + case OPT_REWIND_TIMER: + // --rewind-timer + if (optarg) { + rewindTimer = atoi(optarg); + } + break; + + case OPT_JOYPAD_DEFAULT: + // --joypad-default + if (optarg) { + joypadDefault = atoi(optarg); + } + break; + + case OPT_MAX_SCALE: + // --max-scale + if (optarg) { + maxScale = atoi(optarg); + } + break; + + case OPT_LINK_TIMEOUT: + // --link-timeout + if (optarg) { + linkTimeout = atoi(optarg); + } + break; + + case OPT_LINK_MODE: + // --link-mode + if (optarg) { + linkMode = atoi(optarg); + } + break; + + case OPT_LINK_AUTO: + // --link-auto + if (optarg) { + linkAuto = atoi(optarg); + } + break; + + case OPT_LINK_HACKS: + // --link-hacks + if (optarg) { + linkHacks = atoi(optarg); + } + break; + + case OPT_LINK_NUM_PLAYERS: + // --link-num-players + if (optarg) { + linkNumPlayers = atoi(optarg); + } + break; + + case OPT_GDB_PORT: + // --gdb-port + if (optarg) { + gdbPort = atoi(optarg); + } + break; + + case OPT_BIOS_FILE_NAME_GB: + // --bios-file-name-gb + biosFileNameGB = optarg; + break; + + case OPT_BIOS_FILE_NAME_GBA: + // --bios-file-name-gba + biosFileNameGBA = optarg; + break; + + case OPT_BIOS_FILE_NAME_GBC: + // --bios-file-name-gbc + biosFileNameGBC = optarg; + break; + + case OPT_AVI_RECORD_DIR: + // --avi-record-dir + aviRecordDir = optarg; + break; + + case OPT_MOVIE_RECORD_DIR: + // --movie-record-dir + movieRecordDir = optarg; + break; + + case OPT_SOUND_RECORD_DIR: + // --sound-record-dir + soundRecordDir = optarg; + break; + + case OPT_SCREEN_SHOT_DIR: + // --screen-shot-dir + screenShotDir = optarg; + break; + + case OPT_SAVE_DIR: + // --save-dir + saveDir = optarg; + break; + + case OPT_BATTERY_DIR: + // --battery-dir + batteryDir = optarg; + break; + + case OPT_ROM_DIR_GBC: + // --rom-dir-gbc + romDirGBC = optarg; + break; + + case OPT_ROM_DIR_GB: + // --rom-dir-gb + romDirGB = optarg; + break; + + case OPT_ROM_DIR_GBA: + // --rom-dir-gba + romDirGBA = optarg; + break; + + case OPT_LINK_HOST_ADDR: + // --link-host-addr + linkHostAddr = optarg; + break; + + case OPT_CPU_SAVE_TYPE: + // --cpu-save-type + if (optarg) { + cpuSaveType = atoi(optarg); + } + break; + + case OPT_OPT_FLASH_SIZE: + // --opt-flash-size + if (optarg) { + optFlashSize = atoi(optarg); + } + break; + + case OPT_WINDOW_HEIGHT: + // --window-height + if (optarg) { + windowHeight = atoi(optarg); + } + break; + + case OPT_WINDOW_WIDTH: + // --window-width + if (optarg) { + windowWidth = atoi(optarg); + } + break; + + case OPT_DOTCODE_FILE_NAME_LOAD: + // --dotcode-file-name-load + loadDotCodeFile = optarg; + break; + + case OPT_DOTCODE_FILE_NAME_SAVE: + // --dotcode-file-name-save + saveDotCodeFile = optarg; + break; + case OPT_SPEEDUP_THROTTLE: + if (optarg) + speedup_throttle = atoi(optarg); + break; + case OPT_SPEEDUP_FRAME_SKIP: + if (optarg) + speedup_frame_skip = atoi(optarg); + break; + } + } + return op; +} + diff --git a/src/common/ConfigManager.h b/src/common/ConfigManager.h index 7983fe87..0ad42024 100644 --- a/src/common/ConfigManager.h +++ b/src/common/ConfigManager.h @@ -1,183 +1,183 @@ -#ifndef _CONFIGMANAGER_H -#define _CONFIGMANAGER_H - -#pragma once -#include "../sdl/filters.h" -#include - -#ifndef __GNUC__ -#define HAVE_DECL_GETOPT 0 -#define __STDC__ 1 -#ifndef __LIBRETRO__ -#include "getopt.h" -#endif -#else // ! __GNUC__ -#define HAVE_DECL_GETOPT 1 -#ifndef __LIBRETRO__ -#include -#endif -#endif // ! __GNUC__ - -#define MAX_CHEATS 16384 - -extern bool cpuIsMultiBoot; -extern bool mirroringEnable; -extern bool parseDebug; -extern bool speedHack; -extern bool speedup; -extern char *rewindMemory; -extern const char *aviRecordDir; -extern const char *biosFileNameGB; -extern const char *biosFileNameGBA; -extern const char *biosFileNameGBC; -extern const char *loadDotCodeFile; -extern const char *saveDotCodeFile; -extern const char *linkHostAddr; -extern const char *movieRecordDir; -extern const char *romDirGB; -extern const char *romDirGBA; -extern const char *romDirGBC; -extern const char *soundRecordDir; -extern int *rewindSerials; -extern int active; -extern int agbPrint; -extern int autoFire; -extern int autoFireMaxCount; -extern int autoFireToggle; -extern int autoFrameSkip; -extern int autoLoadMostRecent; -extern int autoPatch; -extern int autoSaveLoadCheatList; -extern int aviRecording; -extern int captureFormat; -extern int cheatsEnabled; -extern int cpuDisableSfx; -extern int cpuSaveType; -extern int dinputKeyFocus; -extern int disableMMX; -extern int disableStatusMessages; -extern int dsoundDisableHardwareAcceleration; -extern int filterHeight; -extern int filterMagnification; -extern int filterMT; // enable multi-threading for pixel filters -extern int filter; -extern int filterWidth; -extern int frameSkip; -extern int frameskipadjust; -extern int fsAdapter; -extern int fsColorDepth; -extern int fsForceChange; -extern int fsFrequency; -extern int fsHeight; -extern int fsWidth; -extern int fullScreen; -extern int fullScreenStretch; -extern int gdbBreakOnLoad; -extern int gdbPort; -extern int glFilter; -extern int ifbType; -extern int joypadDefault; -extern int languageOption; -extern int layerEnable; -extern int layerSettings; -extern int linkAuto; -extern int linkHacks; -extern int linkMode; -extern int linkNumPlayers; -extern int linkTimeout; -extern int maxScale; -extern int movieFrame; -extern int moviePlayFrame; -extern int moviePlaying; -extern int movieRecording; -extern int openGL; -extern int autoPatch; -extern int optFlashSize; -extern int optPrintUsage; -extern int paused; -extern int pauseWhenInactive; -extern int recentFreeze; -extern int renderedFrames; -extern int rewindCount; -extern int rewindCounter; -extern int rewindPos; -extern int rewindSaveNeeded; -extern int rewindTimer; -extern int rewindTopPos; -// extern int romSize; -extern int rtcEnabled; -extern int saveType; -extern int screenMessage; -extern int sensorX; -extern int sensorY; -extern int showRenderedFrames; -extern int showSpeed; -extern int showSpeedTransparent; -extern int sizeX; -extern int sizeY; -extern int skipBios; -extern int skipSaveGameBattery; -extern int skipSaveGameCheats; -extern int soundRecording; -extern int speedupToggle; -extern int sunBars; -extern int surfaceSizeX; -extern int surfaceSizeY; -extern int threadPriority; -extern int tripleBuffering; -extern int useBios; -extern int useBiosFileGB; -extern int useBiosFileGBA; -extern int useBiosFileGBC; -extern int videoOption; -extern int vsync; -extern int wasPaused; -extern uint32_t windowHeight; -extern int windowPositionX; -extern int windowPositionY; -extern uint32_t windowWidth; -extern int winFlashSize; -extern int winGbBorderOn; -extern int winGbPrinterEnabled; -extern int winPauseNextFrame; -extern uint32_t autoFrameSkipLastTime; -extern uint32_t movieLastJoypad; -extern uint32_t movieNextJoypad; -extern uint32_t throttle; -extern uint32_t speedup_throttle; -extern uint32_t speedup_frame_skip; - -extern int preparedCheats; -extern const char *preparedCheatCodes[MAX_CHEATS]; - -// allow up to 100 IPS/UPS/PPF patches given on commandline -#define PATCH_MAX_NUM 100 -extern int patchNum; -extern char *patchNames[PATCH_MAX_NUM]; // and so on - -extern int mouseCounter; - -extern FilterFunc filterFunction; -extern IFBFilterFunc ifbFunction; - -extern char *homeDir; -extern const char *screenShotDir; -extern const char *saveDir; -extern const char *batteryDir; - -// Directory within homedir to use for default save location. -#define DOT_DIR "visualboyadvance-m" - -void SetHome(char *_arg0); -void SaveConfigFile(); -void CloseConfig(); -uint32_t ReadPrefHex(const char *pref_key, int default_value); -uint32_t ReadPrefHex(const char *pref_key); -uint32_t ReadPref(const char *pref_key, int default_value); -uint32_t ReadPref(const char *pref_key); -const char *ReadPrefString(const char *pref_key, const char *default_value); -const char *ReadPrefString(const char *pref_key); -void LoadConfigFile(int argc, char **argv); -void LoadConfig(); -int ReadOpts(int argc, char **argv); -#endif +#ifndef _CONFIGMANAGER_H +#define _CONFIGMANAGER_H + +#pragma once +#include "../sdl/filters.h" +#include + +#ifndef __GNUC__ +#define HAVE_DECL_GETOPT 0 +#define __STDC__ 1 +#ifndef __LIBRETRO__ +#include "getopt.h" +#endif +#else // ! __GNUC__ +#define HAVE_DECL_GETOPT 1 +#ifndef __LIBRETRO__ +#include +#endif +#endif // ! __GNUC__ + +#define MAX_CHEATS 16384 + +extern bool cpuIsMultiBoot; +extern bool mirroringEnable; +extern bool parseDebug; +extern bool speedHack; +extern bool speedup; +extern char *rewindMemory; +extern const char *aviRecordDir; +extern const char *biosFileNameGB; +extern const char *biosFileNameGBA; +extern const char *biosFileNameGBC; +extern const char *loadDotCodeFile; +extern const char *saveDotCodeFile; +extern const char *linkHostAddr; +extern const char *movieRecordDir; +extern const char *romDirGB; +extern const char *romDirGBA; +extern const char *romDirGBC; +extern const char *soundRecordDir; +extern int *rewindSerials; +extern int active; +extern int agbPrint; +extern int autoFire; +extern int autoFireMaxCount; +extern int autoFireToggle; +extern int autoFrameSkip; +extern int autoLoadMostRecent; +extern int autoPatch; +extern int autoSaveLoadCheatList; +extern int aviRecording; +extern int captureFormat; +extern int cheatsEnabled; +extern int cpuDisableSfx; +extern int cpuSaveType; +extern int dinputKeyFocus; +extern int disableMMX; +extern int disableStatusMessages; +extern int dsoundDisableHardwareAcceleration; +extern int filterHeight; +extern int filterMagnification; +extern int filterMT; // enable multi-threading for pixel filters +extern int filter; +extern int filterWidth; +extern int frameSkip; +extern int frameskipadjust; +extern int fsAdapter; +extern int fsColorDepth; +extern int fsForceChange; +extern int fsFrequency; +extern int fsHeight; +extern int fsWidth; +extern int fullScreen; +extern int fullScreenStretch; +extern int gdbBreakOnLoad; +extern int gdbPort; +extern int glFilter; +extern int ifbType; +extern int joypadDefault; +extern int languageOption; +extern int layerEnable; +extern int layerSettings; +extern int linkAuto; +extern int linkHacks; +extern int linkMode; +extern int linkNumPlayers; +extern int linkTimeout; +extern int maxScale; +extern int movieFrame; +extern int moviePlayFrame; +extern int moviePlaying; +extern int movieRecording; +extern int openGL; +extern int autoPatch; +extern int optFlashSize; +extern int optPrintUsage; +extern int paused; +extern int pauseWhenInactive; +extern int recentFreeze; +extern int renderedFrames; +extern int rewindCount; +extern int rewindCounter; +extern int rewindPos; +extern int rewindSaveNeeded; +extern int rewindTimer; +extern int rewindTopPos; +// extern int romSize; +extern int rtcEnabled; +extern int saveType; +extern int screenMessage; +extern int sensorX; +extern int sensorY; +extern int showRenderedFrames; +extern int showSpeed; +extern int showSpeedTransparent; +extern int sizeX; +extern int sizeY; +extern int skipBios; +extern int skipSaveGameBattery; +extern int skipSaveGameCheats; +extern int soundRecording; +extern int speedupToggle; +extern int sunBars; +extern int surfaceSizeX; +extern int surfaceSizeY; +extern int threadPriority; +extern int tripleBuffering; +extern int useBios; +extern int useBiosFileGB; +extern int useBiosFileGBA; +extern int useBiosFileGBC; +extern int videoOption; +extern int vsync; +extern int wasPaused; +extern uint32_t windowHeight; +extern int windowPositionX; +extern int windowPositionY; +extern uint32_t windowWidth; +extern int winFlashSize; +extern int winGbBorderOn; +extern int winGbPrinterEnabled; +extern int winPauseNextFrame; +extern uint32_t autoFrameSkipLastTime; +extern uint32_t movieLastJoypad; +extern uint32_t movieNextJoypad; +extern uint32_t throttle; +extern uint32_t speedup_throttle; +extern uint32_t speedup_frame_skip; + +extern int preparedCheats; +extern const char *preparedCheatCodes[MAX_CHEATS]; + +// allow up to 100 IPS/UPS/PPF patches given on commandline +#define PATCH_MAX_NUM 100 +extern int patchNum; +extern char *patchNames[PATCH_MAX_NUM]; // and so on + +extern int mouseCounter; + +extern FilterFunc filterFunction; +extern IFBFilterFunc ifbFunction; + +extern char *homeDir; +extern const char *screenShotDir; +extern const char *saveDir; +extern const char *batteryDir; + +// Directory within homedir to use for default save location. +#define DOT_DIR "visualboyadvance-m" + +void SetHome(char *_arg0); +void SaveConfigFile(); +void CloseConfig(); +uint32_t ReadPrefHex(const char *pref_key, int default_value); +uint32_t ReadPrefHex(const char *pref_key); +uint32_t ReadPref(const char *pref_key, int default_value); +uint32_t ReadPref(const char *pref_key); +const char *ReadPrefString(const char *pref_key, const char *default_value); +const char *ReadPrefString(const char *pref_key); +void LoadConfigFile(int argc, char **argv); +void LoadConfig(); +int ReadOpts(int argc, char **argv); +#endif diff --git a/src/common/SoundDriver.h b/src/common/SoundDriver.h index afceef3e..c6d405bf 100644 --- a/src/common/SoundDriver.h +++ b/src/common/SoundDriver.h @@ -58,7 +58,7 @@ class SoundDriver */ virtual void write(uint16_t *finalWave, int length) = 0; - virtual void setThrottle(unsigned short throttle){}; + virtual void setThrottle(unsigned short throttle) = 0; }; #endif // __VBA_SOUND_DRIVER_H__ diff --git a/src/common/SoundSDL.cpp b/src/common/SoundSDL.cpp index 2ae9324e..2ad7218e 100644 --- a/src/common/SoundSDL.cpp +++ b/src/common/SoundSDL.cpp @@ -137,7 +137,7 @@ bool SoundSDL::init(long sampleRate) { sound_device = SDL_OpenAudioDevice(NULL, 0, &audio, &audio_spec, SDL_AUDIO_ALLOW_ANY_CHANGE); - if(sound_device < 0) { + if(sound_device == 0) { std::cerr << "Failed to open audio: " << SDL_GetError() << std::endl; return false; } diff --git a/src/common/SoundSDL.h b/src/common/SoundSDL.h index 2d2d1f25..d6f7ec0a 100644 --- a/src/common/SoundSDL.h +++ b/src/common/SoundSDL.h @@ -45,7 +45,7 @@ protected: private: RingBuffer samples_buf; - SDL_AudioDeviceID sound_device = -1; + SDL_AudioDeviceID sound_device = 0; SDL_mutex* mutex; SDL_sem* data_available; diff --git a/src/common/iniparser.c b/src/common/iniparser.c index 5ffe7b5e..2d2e1416 100644 --- a/src/common/iniparser.c +++ b/src/common/iniparser.c @@ -643,7 +643,7 @@ dictionary *iniparser_load(const char *ininame) char line[ASCIILINESZ + 1]; char section[ASCIILINESZ + 1]; char key[ASCIILINESZ + 1]; - char tmp[ASCIILINESZ + 1]; + char tmp[2 * ASCIILINESZ + 3]; char val[ASCIILINESZ + 1]; int last = 0; diff --git a/src/filters/interframe.cpp b/src/filters/interframe.cpp index c7e9d8ed..f255d748 100644 --- a/src/filters/interframe.cpp +++ b/src/filters/interframe.cpp @@ -20,7 +20,7 @@ static uint8_t *frm3 = NULL; extern uint32_t qRGB_COLOR_MASK[2]; -static void Init() +void InterframeFilterInit() { frm1 = (uint8_t *)calloc(322*242,4); // 1 frame ago @@ -163,8 +163,9 @@ static void SmartIB_MMX(uint8_t *srcPtr, uint32_t srcPitch, int width, int start void SmartIB(uint8_t *srcPtr, uint32_t srcPitch, int width, int starty, int height) { + (void)width; // unused param if(frm1 == NULL) { - Init(); + InterframeFilterInit(); } #ifdef MMX if(cpu_mmx) { @@ -329,8 +330,9 @@ static void SmartIB32_MMX(uint8_t *srcPtr, uint32_t srcPitch, int width, int sta void SmartIB32(uint8_t *srcPtr, uint32_t srcPitch, int width, int starty, int height) { + (void)width; // unused param if(frm1 == NULL) { - Init(); + InterframeFilterInit(); } #ifdef MMX if(cpu_mmx) { @@ -445,8 +447,9 @@ static void MotionBlurIB_MMX(uint8_t *srcPtr, uint32_t srcPitch, int width, int void MotionBlurIB(uint8_t *srcPtr, uint32_t srcPitch, int width, int starty, int height) { + (void)width; // unused param if(frm1 == NULL) { - Init(); + InterframeFilterInit(); } #ifdef MMX @@ -550,8 +553,9 @@ static void MotionBlurIB32_MMX(uint8_t *srcPtr, uint32_t srcPitch, int width, in void MotionBlurIB32(uint8_t *srcPtr, uint32_t srcPitch, int width, int starty, int height) { + (void)width; // unused param if(frm1 == NULL) { - Init(); + InterframeFilterInit(); } #ifdef MMX @@ -569,7 +573,7 @@ void MotionBlurIB32(uint8_t *srcPtr, uint32_t srcPitch, int width, int starty, i int sPitch = srcPitch >> 2; int pos = 0; - for (int j = 0; j < height; j++) + for (int j = 0; j < height; j++) for (int i = 0; i < sPitch; i++) { uint32_t color = src0[pos]; src0[pos] = (((color & colorMask) >> 1) + diff --git a/src/filters/interframe.hpp b/src/filters/interframe.hpp index 66c2d2f4..6a482866 100644 --- a/src/filters/interframe.hpp +++ b/src/filters/interframe.hpp @@ -5,7 +5,7 @@ extern int RGB_LOW_BITS_MASK; -static void Init(); +void InterframeFilterInit(); // call ifc to ignore previous frame / when starting new void InterframeCleanup(); diff --git a/src/filters/xBRZ/config.h b/src/filters/xBRZ/config.h index 8159e51b..07c5b69b 100644 --- a/src/filters/xBRZ/config.h +++ b/src/filters/xBRZ/config.h @@ -1,38 +1,38 @@ -// **************************************************************************** -// * This file is part of the HqMAME project. It is distributed under * -// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * -// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * -// * * -// * Additionally and as a special exception, the author gives permission * -// * to link the code of this program with the MAME library (or with modified * -// * versions of MAME that use the same license as MAME), and distribute * -// * linked combinations including the two. You must obey the GNU General * -// * Public License in all respects for all of the code used other than MAME. * -// * If you modify this file, you may extend this exception to your version * -// * of the file, but you are not obligated to do so. If you do not wish to * -// * do so, delete this exception statement from your version. * -// **************************************************************************** - -#ifndef XBRZ_CONFIG_HEADER_284578425345 -#define XBRZ_CONFIG_HEADER_284578425345 - -// do NOT include any headers here! used by xBRZ_dll!!! - -namespace xbrz -{ -struct ScalerCfg { - ScalerCfg() - : luminanceWeight(1), equalColorTolerance(30), dominantDirectionThreshold(3.6), - steepDirectionThreshold(2.2), newTestAttribute(0) - { - } - - double luminanceWeight; - double equalColorTolerance; - double dominantDirectionThreshold; - double steepDirectionThreshold; - double newTestAttribute; // unused; test new parameters -}; -} - +// **************************************************************************** +// * This file is part of the HqMAME project. It is distributed under * +// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * +// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * +// * * +// * Additionally and as a special exception, the author gives permission * +// * to link the code of this program with the MAME library (or with modified * +// * versions of MAME that use the same license as MAME), and distribute * +// * linked combinations including the two. You must obey the GNU General * +// * Public License in all respects for all of the code used other than MAME. * +// * If you modify this file, you may extend this exception to your version * +// * of the file, but you are not obligated to do so. If you do not wish to * +// * do so, delete this exception statement from your version. * +// **************************************************************************** + +#ifndef XBRZ_CONFIG_HEADER_284578425345 +#define XBRZ_CONFIG_HEADER_284578425345 + +// do NOT include any headers here! used by xBRZ_dll!!! + +namespace xbrz +{ +struct ScalerCfg { + ScalerCfg() + : luminanceWeight(1), equalColorTolerance(30), dominantDirectionThreshold(3.6), + steepDirectionThreshold(2.2), newTestAttribute(0) + { + } + + double luminanceWeight; + double equalColorTolerance; + double dominantDirectionThreshold; + double steepDirectionThreshold; + double newTestAttribute; // unused; test new parameters +}; +} + #endif \ No newline at end of file diff --git a/src/filters/xBRZ/xbrz.cpp b/src/filters/xBRZ/xbrz.cpp index 7f15a3e0..7e73330a 100644 --- a/src/filters/xBRZ/xbrz.cpp +++ b/src/filters/xBRZ/xbrz.cpp @@ -1,1225 +1,1227 @@ -// **************************************************************************** -// * This file is part of the HqMAME project. It is distributed under * -// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * -// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * -// * * -// * Additionally and as a special exception, the author gives permission * -// * to link the code of this program with the MAME library (or with modified * -// * versions of MAME that use the same license as MAME), and distribute * -// * linked combinations including the two. You must obey the GNU General * -// * Public License in all respects for all of the code used other than MAME. * -// * If you modify this file, you may extend this exception to your version * -// * of the file, but you are not obligated to do so. If you do not wish to * -// * do so, delete this exception statement from your version. * -// **************************************************************************** - -#include "xbrz.h" -#include -#include // abs, pow, sqrt -#include -#include - -namespace -{ -#ifdef _MSC_VER - #define FORCE_INLINE __forceinline -#elif defined __GNUC__ - #define FORCE_INLINE __attribute__((always_inline)) inline -#else - #define FORCE_INLINE inline -#endif - - -template inline -unsigned char getByte(uint32_t val) { return static_cast((val >> (8 * N)) & 0xff); } - -inline unsigned char getAlpha(uint32_t pix) { return getByte<3>(pix); } -inline unsigned char getRed (uint32_t pix) { return getByte<2>(pix); } -inline unsigned char getGreen(uint32_t pix) { return getByte<1>(pix); } -inline unsigned char getBlue (uint32_t pix) { return getByte<0>(pix); } - -inline uint32_t makePixel( unsigned char r, unsigned char g, unsigned char b) { return (r << 16) | (g << 8) | b; } -inline uint32_t makePixel(unsigned char a, unsigned char r, unsigned char g, unsigned char b) { return (a << 24) | (r << 16) | (g << 8) | b; } - - -template -FORCE_INLINE -unsigned char calcColor(unsigned char colFront, unsigned char colBack) -{ - return (colFront * M + colBack * (N - M)) / N; -} - -template inline -uint32_t gradientRGB(uint32_t pixFront, uint32_t pixBack) //blend front color with opacity M / N over opaque background: http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending -{ - //~ static_assert(0 < M && M < N && N <= 1000, ""); - - return makePixel(calcColor(getRed (pixFront), getRed (pixBack)), - calcColor(getGreen(pixFront), getGreen(pixBack)), - calcColor(getBlue (pixFront), getBlue (pixBack))); -} - -FORCE_INLINE -unsigned char calcColor(unsigned char colFront, unsigned char colBack, const unsigned int weightFront, const unsigned int weightBack, const unsigned int weightSum) -{ - return static_cast((colFront * weightFront + colBack * weightBack) / weightSum); -} - -template inline -uint32_t gradientARGB(uint32_t pixFront, uint32_t pixBack) //find intermediate color between two colors with alpha channels (=> NO alpha blending!!!) -{ - //~ static_assert(0 < M && M < N && N <= 1000, ""); - - const unsigned int weightFront = getAlpha(pixFront) * M; - const unsigned int weightBack = getAlpha(pixBack) * (N - M); - const unsigned int weightSum = weightFront + weightBack; - if (weightSum == 0) - return 0; - - return makePixel(static_cast(weightSum / N), - calcColor(getRed (pixFront), getRed (pixBack), weightFront, weightBack, weightSum), - calcColor(getGreen(pixFront), getGreen(pixBack), weightFront, weightBack, weightSum), - calcColor(getBlue (pixFront), getBlue (pixBack), weightFront, weightBack, weightSum)); -} - - -//inline -//double fastSqrt(double n) -//{ -// __asm //speeds up xBRZ by about 9% compared to std::sqrt which internally uses the same assembler instructions but adds some "fluff" -// { -// fld n -// fsqrt -// } -//} -// - - -uint32_t* byteAdvance( uint32_t* ptr, int bytes) { return reinterpret_cast< uint32_t*>(reinterpret_cast< char*>(ptr) + bytes); } -const uint32_t* byteAdvance(const uint32_t* ptr, int bytes) { return reinterpret_cast(reinterpret_cast(ptr) + bytes); } - - -//fill block with the given color -inline -void fillBlock(uint32_t* trg, int pitch, uint32_t col, int blockWidth, int blockHeight) -{ - //for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch)) - // std::fill(trg, trg + blockWidth, col); - - for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch)) - for (int x = 0; x < blockWidth; ++x) - trg[x] = col; -} - -inline -void fillBlock(uint32_t* trg, int pitch, uint32_t col, int n) { fillBlock(trg, pitch, col, n, n); } - - -enum RotationDegree //clock-wise -{ - ROT_0, - ROT_90, - ROT_180, - ROT_270 -}; - -//calculate input matrix coordinates after rotation at compile time -template -struct MatrixRotation; - -template -struct MatrixRotation -{ - static const size_t I_old = I; - static const size_t J_old = J; -}; - -template //(i, j) = (row, col) indices, N = size of (square) matrix -struct MatrixRotation -{ - static const size_t I_old = N - 1 - MatrixRotation(rotDeg - 1), I, J, N>::J_old; //old coordinates before rotation! - static const size_t J_old = MatrixRotation(rotDeg - 1), I, J, N>::I_old; // -}; - - -template -class OutputMatrix -{ -public: - OutputMatrix(uint32_t* out, int outWidth) : //access matrix area, top-left at position "out" for image with given width - out_(out), - outWidth_(outWidth) {} - - template - uint32_t& ref() const - { - static const size_t I_old = MatrixRotation::I_old; - static const size_t J_old = MatrixRotation::J_old; - return *(out_ + J_old + I_old * outWidth_); - } - -private: - uint32_t* out_; - const int outWidth_; -}; - - -template inline -T square(T value) { return value * value; } - - - -inline -double distRGB(uint32_t pix1, uint32_t pix2) -{ - const double r_diff = static_cast(getRed (pix1)) - getRed (pix2); - const double g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); - const double b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); - - //euklidean RGB distance - return std::sqrt(square(r_diff) + square(g_diff) + square(b_diff)); -} - - -inline -double distYCbCr(uint32_t pix1, uint32_t pix2, double lumaWeight) -{ - //http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion - //YCbCr conversion is a matrix multiplication => take advantage of linearity by subtracting first! - const int r_diff = static_cast(getRed (pix1)) - getRed (pix2); //we may delay division by 255 to after matrix multiplication - const int g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); // - const int b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); //substraction for int is noticeable faster than for double! - - //const double k_b = 0.0722; //ITU-R BT.709 conversion - //const double k_r = 0.2126; // - const double k_b = 0.0593; //ITU-R BT.2020 conversion - const double k_r = 0.2627; // - const double k_g = 1 - k_b - k_r; - - const double scale_b = 0.5 / (1 - k_b); - const double scale_r = 0.5 / (1 - k_r); - - const double y = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr! - const double c_b = scale_b * (b_diff - y); - const double c_r = scale_r * (r_diff - y); - - //we skip division by 255 to have similar range like other distance functions - return std::sqrt(square(lumaWeight * y) + square(c_b) + square(c_r)); -} - - -struct DistYCbCrBuffer //30% perf boost compared to distYCbCr()! -{ -public: - DistYCbCrBuffer() : buffer(256 * 256 * 256) - { - for (uint32_t i = 0; i < 256 * 256 * 256; ++i) //startup time: 114 ms on Intel Core i5 (four cores) - { - const int r_diff = getByte<2>(i) * 2 - 255; - const int g_diff = getByte<1>(i) * 2 - 255; - const int b_diff = getByte<0>(i) * 2 - 255; - - const double k_b = 0.0593; //ITU-R BT.2020 conversion - const double k_r = 0.2627; // - const double k_g = 1 - k_b - k_r; - - const double scale_b = 0.5 / (1 - k_b); - const double scale_r = 0.5 / (1 - k_r); - - const double y = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr! - const double c_b = scale_b * (b_diff - y); - const double c_r = scale_r * (r_diff - y); - - buffer[i] = static_cast(std::sqrt(square(y) + square(c_b) + square(c_r))); - } - } - - double dist(uint32_t pix1, uint32_t pix2) const - { - //if (pix1 == pix2) -> 8% perf degradation! - // return 0; - //if (pix1 > pix2) - // std::swap(pix1, pix2); -> 30% perf degradation!!! - - const int r_diff = static_cast(getRed (pix1)) - getRed (pix2); - const int g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); - const int b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); - - return buffer[(((r_diff + 255) / 2) << 16) | //slightly reduce precision (division by 2) to squeeze value into single byte - (((g_diff + 255) / 2) << 8) | - (( b_diff + 255) / 2)]; - } - -private: - std::vector buffer; //consumes 64 MB memory; using double is 2% faster, but takes 128 MB -} distYCbCrBuffer; - - -enum BlendType -{ - BLEND_NONE = 0, - BLEND_NORMAL, //a normal indication to blend - BLEND_DOMINANT, //a strong indication to blend - //attention: BlendType must fit into the value range of 2 bit!!! -}; - -struct BlendResult -{ - BlendType - /**/blend_f, blend_g, - /**/blend_j, blend_k; -}; - - -struct Kernel_4x4 //kernel for preprocessing step -{ - uint32_t - /**/a, b, c, d, - /**/e, f, g, h, - /**/i, j, k, l, - /**/m, n, o, p; -}; - -template -FORCE_INLINE -double dist(uint32_t pix1, uint32_t pix2, const xbrz::ScalerCfg& cfg) -{ - return ColorDistance::dist(pix1, pix2, cfg.luminanceWeight); -} - -template -FORCE_INLINE -bool eq(uint32_t pix1, uint32_t pix2, const xbrz::ScalerCfg& cfg) -{ - return ColorDistance::dist(pix1, pix2, cfg.luminanceWeight) < cfg.equalColorTolerance; -} - -/* -input kernel area naming convention: ------------------ -| A | B | C | D | -----|---|---|---| -| E | F | G | H | //evaluate the four corners between F, G, J, K -----|---|---|---| //input pixel is at position F -| I | J | K | L | -----|---|---|---| -| M | N | O | P | ------------------ -*/ -template -FORCE_INLINE //detect blend direction -BlendResult preProcessCorners(const Kernel_4x4& ker, const xbrz::ScalerCfg& cfg) //result: F, G, J, K corners of "GradientType" -{ - BlendResult result = {}; - - if ((ker.f == ker.g && - ker.j == ker.k) || - (ker.f == ker.j && - ker.g == ker.k)) - return result; - - const int weight = 4; - double jg = dist(ker.i, ker.f, cfg) + dist(ker.f, ker.c, cfg) + dist(ker.n, ker.k, cfg) + dist(ker.k, ker.h, cfg) + weight * dist(ker.j, ker.g, cfg); - double fk = dist(ker.e, ker.j, cfg) + dist(ker.j, ker.o, cfg) + dist(ker.b, ker.g, cfg) + dist(ker.g, ker.l, cfg) + weight * dist(ker.f, ker.k, cfg); - - if (jg < fk) //test sample: 70% of values max(jg, fk) / min(jg, fk) are between 1.1 and 3.7 with median being 1.8 - { - const bool dominantGradient = cfg.dominantDirectionThreshold * jg < fk; - if (ker.f != ker.g && ker.f != ker.j) - result.blend_f = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; - - if (ker.k != ker.j && ker.k != ker.g) - result.blend_k = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; - } - else if (fk < jg) - { - const bool dominantGradient = cfg.dominantDirectionThreshold * fk < jg; - if (ker.j != ker.f && ker.j != ker.k) - result.blend_j = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; - - if (ker.g != ker.f && ker.g != ker.k) - result.blend_g = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; - } - return result; -} - -struct Kernel_3x3 -{ - uint32_t - /**/a, b, c, - /**/d, e, f, - /**/g, h, i; -}; - -#define DEF_GETTER(x) template uint32_t inline get_##x(const Kernel_3x3& ker) { return ker.x; } -//we cannot and NEED NOT write "ker.##x" since ## concatenates preprocessor tokens but "." is not a token -DEF_GETTER(a) DEF_GETTER(b) DEF_GETTER(c) -DEF_GETTER(d) DEF_GETTER(e) DEF_GETTER(f) -DEF_GETTER(g) DEF_GETTER(h) DEF_GETTER(i) -#undef DEF_GETTER - -#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } -DEF_GETTER(a, g) DEF_GETTER(b, d) DEF_GETTER(c, a) -DEF_GETTER(d, h) DEF_GETTER(e, e) DEF_GETTER(f, b) -DEF_GETTER(g, i) DEF_GETTER(h, f) DEF_GETTER(i, c) -#undef DEF_GETTER - -#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } -DEF_GETTER(a, i) DEF_GETTER(b, h) DEF_GETTER(c, g) -DEF_GETTER(d, f) DEF_GETTER(e, e) DEF_GETTER(f, d) -DEF_GETTER(g, c) DEF_GETTER(h, b) DEF_GETTER(i, a) -#undef DEF_GETTER - -#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } -DEF_GETTER(a, c) DEF_GETTER(b, f) DEF_GETTER(c, i) -DEF_GETTER(d, b) DEF_GETTER(e, e) DEF_GETTER(f, h) -DEF_GETTER(g, a) DEF_GETTER(h, d) DEF_GETTER(i, g) -#undef DEF_GETTER - - -//compress four blend types into a single byte -inline BlendType getTopL (unsigned char b) { return static_cast(0x3 & b); } -inline BlendType getTopR (unsigned char b) { return static_cast(0x3 & (b >> 2)); } -inline BlendType getBottomR(unsigned char b) { return static_cast(0x3 & (b >> 4)); } -inline BlendType getBottomL(unsigned char b) { return static_cast(0x3 & (b >> 6)); } - -inline void setTopL (unsigned char& b, BlendType bt) { b |= bt; } //buffer is assumed to be initialized before preprocessing! -inline void setTopR (unsigned char& b, BlendType bt) { b |= (bt << 2); } -inline void setBottomR(unsigned char& b, BlendType bt) { b |= (bt << 4); } -inline void setBottomL(unsigned char& b, BlendType bt) { b |= (bt << 6); } - -inline bool blendingNeeded(unsigned char b) { return b != 0; } - -template inline -unsigned char rotateBlendInfo(unsigned char b) { return b; } -template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 2) | (b >> 6)) & 0xff; } -template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 4) | (b >> 4)) & 0xff; } -template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 6) | (b >> 2)) & 0xff; } - - -#ifndef NDEBUG -#ifdef _MSC_VER - int debugPixelX = -1; - int debugPixelY = 12; - __declspec(thread) bool breakIntoDebugger = false; -#endif -#endif - - -/* -input kernel area naming convention: -------------- -| A | B | C | -----|---|---| -| D | E | F | //input pixel is at position E -----|---|---| -| G | H | I | -------------- -*/ -template -FORCE_INLINE //perf: quite worth it! -void blendPixel(const Kernel_3x3& ker, - uint32_t* target, int trgWidth, - unsigned char blendInfo, //result of preprocessing all four corners of pixel "e" - const xbrz::ScalerCfg& cfg) -{ -#define a get_a(ker) -#define b get_b(ker) -#define c get_c(ker) -#define d get_d(ker) -#define e get_e(ker) -#define f get_f(ker) -#define g get_g(ker) -#define h get_h(ker) -#define i get_i(ker) - -#ifndef NDEBUG -#ifdef _MSC_VER - if (breakIntoDebugger) - __debugbreak(); //__asm int 3; -#endif -#endif - - const unsigned char blend = rotateBlendInfo(blendInfo); - - if (getBottomR(blend) >= BLEND_NORMAL) - { - bool doLineBlend = (getBottomR(blend) >= BLEND_DOMINANT) || !( - //make sure there is no second blending in an adjacent rotation for this pixel: handles insular pixels, mario eyes - (getTopR(blend) != BLEND_NONE && !eq(e, g, cfg)) || //but support double-blending for 90° corners - (getBottomL(blend) != BLEND_NONE && !eq(e, c, cfg)) || - //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes") - (!eq(e, i, cfg) && eq(g, h, cfg) && eq(h , i, cfg) && eq(i, f, cfg) && eq(f, c, cfg)) - ); - - const uint32_t px = dist(e, f, cfg) <= dist(e, h, cfg) ? f : h; //choose most similar color - - OutputMatrix out(target, trgWidth); - - if (doLineBlend) - { - const double fg = dist(f, g, cfg); //test sample: 70% of values max(fg, hc) / min(fg, hc) are between 1.1 and 3.7 with median being 1.9 - const double hc = dist(h, c, cfg); // - - const bool haveShallowLine = cfg.steepDirectionThreshold * fg <= hc && e != g && d != g; - const bool haveSteepLine = cfg.steepDirectionThreshold * hc <= fg && e != c && b != c; - - if (haveShallowLine) - { - if (haveSteepLine) - Scaler::blendLineSteepAndShallow(px, out); - else - Scaler::blendLineShallow(px, out); - } - else - { - if (haveSteepLine) - Scaler::blendLineSteep(px, out); - else - Scaler::blendLineDiagonal(px,out); - } - } - else - Scaler::blendCorner(px, out); - } - -#undef a -#undef b -#undef c -#undef d -#undef e -#undef f -#undef g -#undef h -#undef i -} - - -template //scaler policy: see "Scaler2x" reference implementation -void scaleImage(const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, uint32_t* trg, int trgWidth, const xbrz::ScalerCfg& cfg, int yFirst, int yLast) -{ - yFirst = std::max(yFirst, 0); - yLast = std::min(yLast, srcHeight); - if (yFirst >= yLast || srcWidth <= 0) - return; - - //"use" space at the end of the image as temporary buffer for "on the fly preprocessing": we even could use larger area of - //"sizeof(uint32_t) * srcWidth * (yLast - yFirst)" bytes without risk of accidental overwriting before accessing - const int bufferSize = srcWidth; - unsigned char* preProcBuffer = reinterpret_cast(trg + yLast * Scaler::scale * trgWidth) - bufferSize; - std::fill(preProcBuffer, preProcBuffer + bufferSize, 0); - //~ static_assert(BLEND_NONE == 0, ""); - - //initialize preprocessing buffer for first row of current stripe: detect upper left and right corner blending - //this cannot be optimized for adjacent processing stripes; we must not allow for a memory race condition! - if (yFirst > 0) - { - const int y = yFirst - 1; - - const uint32_t* s_m1 = src + srcPitch * std::max(y - 1, 0); - const uint32_t* s_0 = src + srcPitch * y; //center line - const uint32_t* s_p1 = src + srcPitch * std::min(y + 1, srcHeight - 1); - const uint32_t* s_p2 = src + srcPitch * std::min(y + 2, srcHeight - 1); - - for (int x = 0; x < srcWidth; ++x) - { - const int x_m1 = std::max(x - 1, 0); - const int x_p1 = std::min(x + 1, srcWidth - 1); - const int x_p2 = std::min(x + 2, srcWidth - 1); - - Kernel_4x4 ker = {}; //perf: initialization is negligible - ker.a = s_m1[x_m1]; //read sequentially from memory as far as possible - ker.b = s_m1[x]; - ker.c = s_m1[x_p1]; - ker.d = s_m1[x_p2]; - - ker.e = s_0[x_m1]; - ker.f = s_0[x]; - ker.g = s_0[x_p1]; - ker.h = s_0[x_p2]; - - ker.i = s_p1[x_m1]; - ker.j = s_p1[x]; - ker.k = s_p1[x_p1]; - ker.l = s_p1[x_p2]; - - ker.m = s_p2[x_m1]; - ker.n = s_p2[x]; - ker.o = s_p2[x_p1]; - ker.p = s_p2[x_p2]; - - const BlendResult res = preProcessCorners(ker, cfg); - /* - preprocessing blend result: - --------- - | F | G | //evalute corner between F, G, J, K - ----|---| //input pixel is at position F - | J | K | - --------- - */ - setTopR(preProcBuffer[x], res.blend_j); - - if (x + 1 < bufferSize) - setTopL(preProcBuffer[x + 1], res.blend_k); - } - } - //------------------------------------------------------------------------------------ - - for (int y = yFirst; y < yLast; ++y) - { - uint32_t* out = trg + Scaler::scale * y * trgWidth; //consider MT "striped" access - - const uint32_t* s_m1 = src + srcPitch * std::max(y - 1, 0); - const uint32_t* s_0 = src + srcPitch * y; //center line - const uint32_t* s_p1 = src + srcPitch * std::min(y + 1, srcHeight - 1); - const uint32_t* s_p2 = src + srcPitch * std::min(y + 2, srcHeight - 1); - - unsigned char blend_xy1 = 0; //corner blending for current (x, y + 1) position - - for (int x = 0; x < srcWidth; ++x, out += Scaler::scale) - { -#ifndef NDEBUG -#ifdef _MSC_VER - breakIntoDebugger = debugPixelX == x && debugPixelY == y; -#endif -#endif - //all those bounds checks have only insignificant impact on performance! - const int x_m1 = std::max(x - 1, 0); //perf: prefer array indexing to additional pointers! - const int x_p1 = std::min(x + 1, srcWidth - 1); - const int x_p2 = std::min(x + 2, srcWidth - 1); - - Kernel_4x4 ker4 = {}; //perf: initialization is negligible - - ker4.a = s_m1[x_m1]; //read sequentially from memory as far as possible - ker4.b = s_m1[x]; - ker4.c = s_m1[x_p1]; - ker4.d = s_m1[x_p2]; - - ker4.e = s_0[x_m1]; - ker4.f = s_0[x]; - ker4.g = s_0[x_p1]; - ker4.h = s_0[x_p2]; - - ker4.i = s_p1[x_m1]; - ker4.j = s_p1[x]; - ker4.k = s_p1[x_p1]; - ker4.l = s_p1[x_p2]; - - ker4.m = s_p2[x_m1]; - ker4.n = s_p2[x]; - ker4.o = s_p2[x_p1]; - ker4.p = s_p2[x_p2]; - - //evaluate the four corners on bottom-right of current pixel - unsigned char blend_xy = 0; //for current (x, y) position - { - const BlendResult res = preProcessCorners(ker4, cfg); - /* - preprocessing blend result: - --------- - | F | G | //evalute corner between F, G, J, K - ----|---| //current input pixel is at position F - | J | K | - --------- - */ - blend_xy = preProcBuffer[x]; - setBottomR(blend_xy, res.blend_f); //all four corners of (x, y) have been determined at this point due to processing sequence! - - setTopR(blend_xy1, res.blend_j); //set 2nd known corner for (x, y + 1) - preProcBuffer[x] = blend_xy1; //store on current buffer position for use on next row - - blend_xy1 = 0; - setTopL(blend_xy1, res.blend_k); //set 1st known corner for (x + 1, y + 1) and buffer for use on next column - - if (x + 1 < bufferSize) //set 3rd known corner for (x + 1, y) - setBottomL(preProcBuffer[x + 1], res.blend_g); - } - - //fill block of size scale * scale with the given color - fillBlock(out, trgWidth * sizeof(uint32_t), ker4.f, Scaler::scale); //place *after* preprocessing step, to not overwrite the results while processing the the last pixel! - - //blend four corners of current pixel - if (blendingNeeded(blend_xy)) //good 5% perf-improvement - { - Kernel_3x3 ker3 = {}; //perf: initialization is negligible - - ker3.a = ker4.a; - ker3.b = ker4.b; - ker3.c = ker4.c; - - ker3.d = ker4.e; - ker3.e = ker4.f; - ker3.f = ker4.g; - - ker3.g = ker4.i; - ker3.h = ker4.j; - ker3.i = ker4.k; - - blendPixel(ker3, out, trgWidth, blend_xy, cfg); - blendPixel(ker3, out, trgWidth, blend_xy, cfg); - blendPixel(ker3, out, trgWidth, blend_xy, cfg); - blendPixel(ker3, out, trgWidth, blend_xy, cfg); - } - } - } -} - -//------------------------------------------------------------------------------------ - -template -struct Scaler2x : public ColorGradient -{ - static const int scale = 2; - - template //bring template function into scope for GCC - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } - - - template - static void blendLineShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - } - - template - static void blendLineSteep(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - } - - template - static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<1, 0>(), col); - alphaGrad<1, 4>(out.template ref<0, 1>(), col); - alphaGrad<5, 6>(out.template ref<1, 1>(), col); //[!] fixes 7/8 used in xBR - } - - template - static void blendLineDiagonal(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 2>(out.template ref<1, 1>(), col); - } - - template - static void blendCorner(uint32_t col, OutputMatrix& out) - { - //model a round corner - alphaGrad<21, 100>(out.template ref<1, 1>(), col); //exact: 1 - pi/4 = 0.2146018366 - } -}; - - -template -struct Scaler3x : public ColorGradient -{ - static const int scale = 3; - - template //bring template function into scope for GCC - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } - - - template - static void blendLineShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - - alphaGrad<3, 4>(out.template ref(), col); - out.template ref() = col; - } - - template - static void blendLineSteep(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - out.template ref<2, scale - 1>() = col; - } - - template - static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<2, 0>(), col); - alphaGrad<1, 4>(out.template ref<0, 2>(), col); - alphaGrad<3, 4>(out.template ref<2, 1>(), col); - alphaGrad<3, 4>(out.template ref<1, 2>(), col); - out.template ref<2, 2>() = col; - } - - template - static void blendLineDiagonal(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 8>(out.template ref<1, 2>(), col); //conflict with other rotations for this odd scale - alphaGrad<1, 8>(out.template ref<2, 1>(), col); - alphaGrad<7, 8>(out.template ref<2, 2>(), col); // - } - - template - static void blendCorner(uint32_t col, OutputMatrix& out) - { - //model a round corner - alphaGrad<45, 100>(out.template ref<2, 2>(), col); //exact: 0.4545939598 - //alphaGrad<7, 256>(out.template ref<2, 1>(), col); //0.02826017254 -> negligible + avoid conflicts with other rotations for this odd scale - //alphaGrad<7, 256>(out.template ref<1, 2>(), col); //0.02826017254 - } -}; - - -template -struct Scaler4x : public ColorGradient -{ - static const int scale = 4; - - template //bring template function into scope for GCC - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } - - - template - static void blendLineShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - - alphaGrad<3, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendLineSteep(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); - - out.template ref<2, scale - 1>() = col; - out.template ref<3, scale - 1>() = col; - } - - template - static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<3, 4>(out.template ref<3, 1>(), col); - alphaGrad<3, 4>(out.template ref<1, 3>(), col); - alphaGrad<1, 4>(out.template ref<3, 0>(), col); - alphaGrad<1, 4>(out.template ref<0, 3>(), col); - - alphaGrad<1, 3>(out.template ref<2, 2>(), col); //[!] fixes 1/4 used in xBR - - out.template ref<3, 3>() = col; - out.template ref<3, 2>() = col; - out.template ref<2, 3>() = col; - } - - template - static void blendLineDiagonal(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 2>(out.template ref(), col); - alphaGrad<1, 2>(out.template ref(), col); - out.template ref() = col; - } - - template - static void blendCorner(uint32_t col, OutputMatrix& out) - { - //model a round corner - alphaGrad<68, 100>(out.template ref<3, 3>(), col); //exact: 0.6848532563 - alphaGrad< 9, 100>(out.template ref<3, 2>(), col); //0.08677704501 - alphaGrad< 9, 100>(out.template ref<2, 3>(), col); //0.08677704501 - } -}; - - -template -struct Scaler5x : public ColorGradient -{ - static const int scale = 5; - - template //bring template function into scope for GCC - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } - - - template - static void blendLineShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - - alphaGrad<3, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - - out.template ref() = col; - out.template ref() = col; - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendLineSteep(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - alphaGrad<1, 4>(out.template ref<4, scale - 3>(), col); - - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); - - out.template ref<2, scale - 1>() = col; - out.template ref<3, scale - 1>() = col; - out.template ref<4, scale - 1>() = col; - out.template ref<4, scale - 2>() = col; - } - - template - static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - - alphaGrad<2, 3>(out.template ref<3, 3>(), col); - - out.template ref<2, scale - 1>() = col; - out.template ref<3, scale - 1>() = col; - out.template ref<4, scale - 1>() = col; - - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendLineDiagonal(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 8>(out.template ref(), col); //conflict with other rotations for this odd scale - alphaGrad<1, 8>(out.template ref(), col); - alphaGrad<1, 8>(out.template ref(), col); // - - alphaGrad<7, 8>(out.template ref<4, 3>(), col); - alphaGrad<7, 8>(out.template ref<3, 4>(), col); - - out.template ref<4, 4>() = col; - } - - template - static void blendCorner(uint32_t col, OutputMatrix& out) - { - //model a round corner - alphaGrad<86, 100>(out.template ref<4, 4>(), col); //exact: 0.8631434088 - alphaGrad<23, 100>(out.template ref<4, 3>(), col); //0.2306749731 - alphaGrad<23, 100>(out.template ref<3, 4>(), col); //0.2306749731 - //alphaGrad<1, 64>(out.template ref<4, 2>(), col); //0.01676812367 -> negligible + avoid conflicts with other rotations for this odd scale - //alphaGrad<1, 64>(out.template ref<2, 4>(), col); //0.01676812367 - } -}; - - -template -struct Scaler6x : public ColorGradient -{ - static const int scale = 6; - - template //bring template function into scope for GCC - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } - - - template - static void blendLineShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - - alphaGrad<3, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - - out.template ref() = col; - out.template ref() = col; - out.template ref() = col; - out.template ref() = col; - - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendLineSteep(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - alphaGrad<1, 4>(out.template ref<4, scale - 3>(), col); - - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); - alphaGrad<3, 4>(out.template ref<5, scale - 3>(), col); - - out.template ref<2, scale - 1>() = col; - out.template ref<3, scale - 1>() = col; - out.template ref<4, scale - 1>() = col; - out.template ref<5, scale - 1>() = col; - - out.template ref<4, scale - 2>() = col; - out.template ref<5, scale - 2>() = col; - } - - template - static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); - alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); - alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); - alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); - - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<1, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - alphaGrad<3, 4>(out.template ref(), col); - - out.template ref<2, scale - 1>() = col; - out.template ref<3, scale - 1>() = col; - out.template ref<4, scale - 1>() = col; - out.template ref<5, scale - 1>() = col; - - out.template ref<4, scale - 2>() = col; - out.template ref<5, scale - 2>() = col; - - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendLineDiagonal(uint32_t col, OutputMatrix& out) - { - alphaGrad<1, 2>(out.template ref(), col); - alphaGrad<1, 2>(out.template ref(), col); - alphaGrad<1, 2>(out.template ref(), col); - - out.template ref() = col; - out.template ref() = col; - out.template ref() = col; - } - - template - static void blendCorner(uint32_t col, OutputMatrix& out) - { - //model a round corner - alphaGrad<97, 100>(out.template ref<5, 5>(), col); //exact: 0.9711013910 - alphaGrad<42, 100>(out.template ref<4, 5>(), col); //0.4236372243 - alphaGrad<42, 100>(out.template ref<5, 4>(), col); //0.4236372243 - alphaGrad< 6, 100>(out.template ref<5, 3>(), col); //0.05652034508 - alphaGrad< 6, 100>(out.template ref<3, 5>(), col); //0.05652034508 - } -}; - -//------------------------------------------------------------------------------------ - -struct ColorDistanceRGB -{ - static double dist(uint32_t pix1, uint32_t pix2, double luminanceWeight) - { - return distYCbCrBuffer.dist(pix1, pix2); - - //if (pix1 == pix2) //about 4% perf boost - // return 0; - //return distYCbCr(pix1, pix2, luminanceWeight); - } -}; - -struct ColorDistanceARGB -{ - static double dist(uint32_t pix1, uint32_t pix2, double luminanceWeight) - { - const double a1 = getAlpha(pix1) / 255.0 ; - const double a2 = getAlpha(pix2) / 255.0 ; - /* - Requirements for a color distance handling alpha channel: with a1, a2 in [0, 1] - - 1. if a1 = a2, distance should be: a1 * distYCbCr() - 2. if a1 = 0, distance should be: a2 * distYCbCr(black, white) = a2 * 255 - 3. if a1 = 1, ??? maybe: 255 * (1 - a2) + a2 * distYCbCr() - */ - - //return std::min(a1, a2) * distYCbCrBuffer.dist(pix1, pix2) + 255 * abs(a1 - a2); - //=> following code is 15% faster: - const double d = distYCbCrBuffer.dist(pix1, pix2); - if (a1 < a2) - return a1 * d + 255 * (a2 - a1); - else - return a2 * d + 255 * (a1 - a2); - - //alternative? return std::sqrt(a1 * a2 * square(distYCbCrBuffer.dist(pix1, pix2)) + square(255 * (a1 - a2))); - } -}; - - -struct ColorGradientRGB -{ - template - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) - { - pixBack = gradientRGB(pixFront, pixBack); - } -}; - -struct ColorGradientARGB -{ - template - static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) - { - pixBack = gradientARGB(pixFront, pixBack); - } -}; -} - - -void xbrz::scale(size_t factor, const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, uint32_t* trg, int trgPitch, ColorFormat colFmt, const xbrz::ScalerCfg& cfg, int yFirst, int yLast) -{ - if (srcPitch % static_cast(sizeof(uint32_t)) != 0 || - trgPitch % static_cast(sizeof(uint32_t)) != 0 || - srcPitch < srcWidth * static_cast(sizeof(uint32_t)) || - trgPitch < srcWidth * static_cast(factor) * static_cast(sizeof(uint32_t))) - { - assert(false); - return; - } - - int trgWidth = trgPitch / static_cast(sizeof(uint32_t)); - int srcPPitch = srcPitch / static_cast(sizeof(uint32_t)); - - switch (colFmt) - { - case ARGB: - switch (factor) - { - case 2: - return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 3: - return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 4: - return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 5: - return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 6: - return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - } - break; - - case RGB: - switch (factor) - { - case 2: - return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 3: - return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 4: - return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 5: - return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - case 6: - return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); - } - break; - } - assert(false); -} - - -bool xbrz::equalColorTest(uint32_t col1, uint32_t col2, ColorFormat colFmt, double luminanceWeight, double equalColorTolerance) -{ - switch (colFmt) - { - case ARGB: - return ColorDistanceARGB::dist(col1, col2, luminanceWeight) < equalColorTolerance; - - case RGB: - return ColorDistanceRGB::dist(col1, col2, luminanceWeight) < equalColorTolerance; - } - assert(false); - return false; -} - - -void xbrz::nearestNeighborScale(const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, - uint32_t* trg, int trgWidth, int trgHeight, int trgPitch, - SliceType st, int yFirst, int yLast) -{ - if (srcPitch < srcWidth * static_cast(sizeof(uint32_t)) || - trgPitch < trgWidth * static_cast(sizeof(uint32_t))) - { - assert(false); - return; - } - - switch (st) - { - case NN_SCALE_SLICE_SOURCE: - //nearest-neighbor (going over source image - fast for upscaling, since source is read only once - yFirst = std::max(yFirst, 0); - yLast = std::min(yLast, srcHeight); - if (yFirst >= yLast || trgWidth <= 0 || trgHeight <= 0) return; - - for (int y = yFirst; y < yLast; ++y) - { - //mathematically: ySrc = floor(srcHeight * yTrg / trgHeight) - // => search for integers in: [ySrc, ySrc + 1) * trgHeight / srcHeight - - //keep within for loop to support MT input slices! - const int yTrg_first = ( y * trgHeight + srcHeight - 1) / srcHeight; //=ceil(y * trgHeight / srcHeight) - const int yTrg_last = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; //=ceil(((y + 1) * trgHeight) / srcHeight) - const int blockHeight = yTrg_last - yTrg_first; - - if (blockHeight > 0) - { - const uint32_t* srcLine = byteAdvance(src, y * srcPitch); - uint32_t* trgLine = byteAdvance(trg, yTrg_first * trgPitch); - int xTrg_first = 0; - - for (int x = 0; x < srcWidth; ++x) - { - int xTrg_last = ((x + 1) * trgWidth + srcWidth - 1) / srcWidth; - const int blockWidth = xTrg_last - xTrg_first; - if (blockWidth > 0) - { - xTrg_first = xTrg_last; - fillBlock(trgLine, trgPitch, srcLine[x], blockWidth, blockHeight); - trgLine += blockWidth; - } - } - } - } - break; - - case NN_SCALE_SLICE_TARGET: - //nearest-neighbor (going over target image - slow for upscaling, since source is read multiple times missing out on cache! Fast for similar image sizes!) - yFirst = std::max(yFirst, 0); - yLast = std::min(yLast, trgHeight); - if (yFirst >= yLast || srcHeight <= 0 || srcWidth <= 0) return; - - for (int y = yFirst; y < yLast; ++y) - { - uint32_t* trgLine = byteAdvance(trg, y * trgPitch); - const int ySrc = srcHeight * y / trgHeight; - const uint32_t* srcLine = byteAdvance(src, ySrc * srcPitch); - for (int x = 0; x < trgWidth; ++x) - { - const int xSrc = srcWidth * x / trgWidth; - trgLine[x] = srcLine[xSrc]; - } - } - break; - } -} +// **************************************************************************** +// * This file is part of the HqMAME project. It is distributed under * +// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * +// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * +// * * +// * Additionally and as a special exception, the author gives permission * +// * to link the code of this program with the MAME library (or with modified * +// * versions of MAME that use the same license as MAME), and distribute * +// * linked combinations including the two. You must obey the GNU General * +// * Public License in all respects for all of the code used other than MAME. * +// * If you modify this file, you may extend this exception to your version * +// * of the file, but you are not obligated to do so. If you do not wish to * +// * do so, delete this exception statement from your version. * +// **************************************************************************** + +#include "xbrz.h" +#include +#include // abs, pow, sqrt +#include +#include + +namespace +{ +#ifdef _MSC_VER + #define FORCE_INLINE __forceinline +#elif defined __GNUC__ + #define FORCE_INLINE __attribute__((always_inline)) inline +#else + #define FORCE_INLINE inline +#endif + + +template inline +unsigned char getByte(uint32_t val) { return static_cast((val >> (8 * N)) & 0xff); } + +inline unsigned char getAlpha(uint32_t pix) { return getByte<3>(pix); } +inline unsigned char getRed (uint32_t pix) { return getByte<2>(pix); } +inline unsigned char getGreen(uint32_t pix) { return getByte<1>(pix); } +inline unsigned char getBlue (uint32_t pix) { return getByte<0>(pix); } + +inline uint32_t makePixel( unsigned char r, unsigned char g, unsigned char b) { return (r << 16) | (g << 8) | b; } +inline uint32_t makePixel(unsigned char a, unsigned char r, unsigned char g, unsigned char b) { return (a << 24) | (r << 16) | (g << 8) | b; } + + +template +FORCE_INLINE +unsigned char calcColor(unsigned char colFront, unsigned char colBack) +{ + return (colFront * M + colBack * (N - M)) / N; +} + +template inline +uint32_t gradientRGB(uint32_t pixFront, uint32_t pixBack) //blend front color with opacity M / N over opaque background: http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending +{ + //~ static_assert(0 < M && M < N && N <= 1000, ""); + + return makePixel(calcColor(getRed (pixFront), getRed (pixBack)), + calcColor(getGreen(pixFront), getGreen(pixBack)), + calcColor(getBlue (pixFront), getBlue (pixBack))); +} + +FORCE_INLINE +unsigned char calcColor(unsigned char colFront, unsigned char colBack, const unsigned int weightFront, const unsigned int weightBack, const unsigned int weightSum) +{ + return static_cast((colFront * weightFront + colBack * weightBack) / weightSum); +} + +template inline +uint32_t gradientARGB(uint32_t pixFront, uint32_t pixBack) //find intermediate color between two colors with alpha channels (=> NO alpha blending!!!) +{ + //~ static_assert(0 < M && M < N && N <= 1000, ""); + + const unsigned int weightFront = getAlpha(pixFront) * M; + const unsigned int weightBack = getAlpha(pixBack) * (N - M); + const unsigned int weightSum = weightFront + weightBack; + if (weightSum == 0) + return 0; + + return makePixel(static_cast(weightSum / N), + calcColor(getRed (pixFront), getRed (pixBack), weightFront, weightBack, weightSum), + calcColor(getGreen(pixFront), getGreen(pixBack), weightFront, weightBack, weightSum), + calcColor(getBlue (pixFront), getBlue (pixBack), weightFront, weightBack, weightSum)); +} + + +//inline +//double fastSqrt(double n) +//{ +// __asm //speeds up xBRZ by about 9% compared to std::sqrt which internally uses the same assembler instructions but adds some "fluff" +// { +// fld n +// fsqrt +// } +//} +// + + +uint32_t* byteAdvance( uint32_t* ptr, int bytes) { return reinterpret_cast< uint32_t*>(reinterpret_cast< char*>(ptr) + bytes); } +const uint32_t* byteAdvance(const uint32_t* ptr, int bytes) { return reinterpret_cast(reinterpret_cast(ptr) + bytes); } + + +//fill block with the given color +inline +void fillBlock(uint32_t* trg, int pitch, uint32_t col, int blockWidth, int blockHeight) +{ + //for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch)) + // std::fill(trg, trg + blockWidth, col); + + for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch)) + for (int x = 0; x < blockWidth; ++x) + trg[x] = col; +} + +inline +void fillBlock(uint32_t* trg, int pitch, uint32_t col, int n) { fillBlock(trg, pitch, col, n, n); } + + +enum RotationDegree //clock-wise +{ + ROT_0, + ROT_90, + ROT_180, + ROT_270 +}; + +//calculate input matrix coordinates after rotation at compile time +template +struct MatrixRotation; + +template +struct MatrixRotation +{ + static const size_t I_old = I; + static const size_t J_old = J; +}; + +template //(i, j) = (row, col) indices, N = size of (square) matrix +struct MatrixRotation +{ + static const size_t I_old = N - 1 - MatrixRotation(rotDeg - 1), I, J, N>::J_old; //old coordinates before rotation! + static const size_t J_old = MatrixRotation(rotDeg - 1), I, J, N>::I_old; // +}; + + +template +class OutputMatrix +{ +public: + OutputMatrix(uint32_t* out, int outWidth) : //access matrix area, top-left at position "out" for image with given width + out_(out), + outWidth_(outWidth) {} + + template + uint32_t& ref() const + { + static const size_t I_old = MatrixRotation::I_old; + static const size_t J_old = MatrixRotation::J_old; + return *(out_ + J_old + I_old * outWidth_); + } + +private: + uint32_t* out_; + const int outWidth_; +}; + + +template inline +T square(T value) { return value * value; } + + + +inline +double distRGB(uint32_t pix1, uint32_t pix2) +{ + const double r_diff = static_cast(getRed (pix1)) - getRed (pix2); + const double g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); + const double b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); + + //euklidean RGB distance + return std::sqrt(square(r_diff) + square(g_diff) + square(b_diff)); +} + + +inline +double distYCbCr(uint32_t pix1, uint32_t pix2, double lumaWeight) +{ + //http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion + //YCbCr conversion is a matrix multiplication => take advantage of linearity by subtracting first! + const int r_diff = static_cast(getRed (pix1)) - getRed (pix2); //we may delay division by 255 to after matrix multiplication + const int g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); // + const int b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); //substraction for int is noticeable faster than for double! + + //const double k_b = 0.0722; //ITU-R BT.709 conversion + //const double k_r = 0.2126; // + const double k_b = 0.0593; //ITU-R BT.2020 conversion + const double k_r = 0.2627; // + const double k_g = 1 - k_b - k_r; + + const double scale_b = 0.5 / (1 - k_b); + const double scale_r = 0.5 / (1 - k_r); + + const double y = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr! + const double c_b = scale_b * (b_diff - y); + const double c_r = scale_r * (r_diff - y); + + //we skip division by 255 to have similar range like other distance functions + return std::sqrt(square(lumaWeight * y) + square(c_b) + square(c_r)); +} + + +struct DistYCbCrBuffer //30% perf boost compared to distYCbCr()! +{ +public: + DistYCbCrBuffer() : buffer(256 * 256 * 256) + { + for (uint32_t i = 0; i < 256 * 256 * 256; ++i) //startup time: 114 ms on Intel Core i5 (four cores) + { + const int r_diff = getByte<2>(i) * 2 - 255; + const int g_diff = getByte<1>(i) * 2 - 255; + const int b_diff = getByte<0>(i) * 2 - 255; + + const double k_b = 0.0593; //ITU-R BT.2020 conversion + const double k_r = 0.2627; // + const double k_g = 1 - k_b - k_r; + + const double scale_b = 0.5 / (1 - k_b); + const double scale_r = 0.5 / (1 - k_r); + + const double y = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr! + const double c_b = scale_b * (b_diff - y); + const double c_r = scale_r * (r_diff - y); + + buffer[i] = static_cast(std::sqrt(square(y) + square(c_b) + square(c_r))); + } + } + + double dist(uint32_t pix1, uint32_t pix2) const + { + //if (pix1 == pix2) -> 8% perf degradation! + // return 0; + //if (pix1 > pix2) + // std::swap(pix1, pix2); -> 30% perf degradation!!! + + const int r_diff = static_cast(getRed (pix1)) - getRed (pix2); + const int g_diff = static_cast(getGreen(pix1)) - getGreen(pix2); + const int b_diff = static_cast(getBlue (pix1)) - getBlue (pix2); + + return buffer[(((r_diff + 255) / 2) << 16) | //slightly reduce precision (division by 2) to squeeze value into single byte + (((g_diff + 255) / 2) << 8) | + (( b_diff + 255) / 2)]; + } + +private: + std::vector buffer; //consumes 64 MB memory; using double is 2% faster, but takes 128 MB +} distYCbCrBuffer; + + +enum BlendType +{ + BLEND_NONE = 0, + BLEND_NORMAL, //a normal indication to blend + BLEND_DOMINANT, //a strong indication to blend + //attention: BlendType must fit into the value range of 2 bit!!! +}; + +struct BlendResult +{ + BlendType + /**/blend_f, blend_g, + /**/blend_j, blend_k; +}; + + +struct Kernel_4x4 //kernel for preprocessing step +{ + uint32_t + /**/a, b, c, d, + /**/e, f, g, h, + /**/i, j, k, l, + /**/m, n, o, p; +}; + +template +FORCE_INLINE +double dist(uint32_t pix1, uint32_t pix2, const xbrz::ScalerCfg& cfg) +{ + return ColorDistance::dist(pix1, pix2, cfg.luminanceWeight); +} + +template +FORCE_INLINE +bool eq(uint32_t pix1, uint32_t pix2, const xbrz::ScalerCfg& cfg) +{ + return ColorDistance::dist(pix1, pix2, cfg.luminanceWeight) < cfg.equalColorTolerance; +} + +/* +input kernel area naming convention: +----------------- +| A | B | C | D | +----|---|---|---| +| E | F | G | H | //evaluate the four corners between F, G, J, K +----|---|---|---| //input pixel is at position F +| I | J | K | L | +----|---|---|---| +| M | N | O | P | +----------------- +*/ +template +FORCE_INLINE //detect blend direction +BlendResult preProcessCorners(const Kernel_4x4& ker, const xbrz::ScalerCfg& cfg) //result: F, G, J, K corners of "GradientType" +{ + BlendResult result = {}; + + if ((ker.f == ker.g && + ker.j == ker.k) || + (ker.f == ker.j && + ker.g == ker.k)) + return result; + + const int weight = 4; + double jg = dist(ker.i, ker.f, cfg) + dist(ker.f, ker.c, cfg) + dist(ker.n, ker.k, cfg) + dist(ker.k, ker.h, cfg) + weight * dist(ker.j, ker.g, cfg); + double fk = dist(ker.e, ker.j, cfg) + dist(ker.j, ker.o, cfg) + dist(ker.b, ker.g, cfg) + dist(ker.g, ker.l, cfg) + weight * dist(ker.f, ker.k, cfg); + + if (jg < fk) //test sample: 70% of values max(jg, fk) / min(jg, fk) are between 1.1 and 3.7 with median being 1.8 + { + const bool dominantGradient = cfg.dominantDirectionThreshold * jg < fk; + if (ker.f != ker.g && ker.f != ker.j) + result.blend_f = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; + + if (ker.k != ker.j && ker.k != ker.g) + result.blend_k = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; + } + else if (fk < jg) + { + const bool dominantGradient = cfg.dominantDirectionThreshold * fk < jg; + if (ker.j != ker.f && ker.j != ker.k) + result.blend_j = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; + + if (ker.g != ker.f && ker.g != ker.k) + result.blend_g = dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL; + } + return result; +} + +struct Kernel_3x3 +{ + uint32_t + /**/a, b, c, + /**/d, e, f, + /**/g, h, i; +}; + +#define DEF_GETTER(x) template uint32_t inline get_##x(const Kernel_3x3& ker) { return ker.x; } +//we cannot and NEED NOT write "ker.##x" since ## concatenates preprocessor tokens but "." is not a token +DEF_GETTER(a) DEF_GETTER(b) DEF_GETTER(c) +DEF_GETTER(d) DEF_GETTER(e) DEF_GETTER(f) +DEF_GETTER(g) DEF_GETTER(h) DEF_GETTER(i) +#undef DEF_GETTER + +#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } +DEF_GETTER(a, g) DEF_GETTER(b, d) DEF_GETTER(c, a) +DEF_GETTER(d, h) DEF_GETTER(e, e) DEF_GETTER(f, b) +DEF_GETTER(g, i) DEF_GETTER(h, f) DEF_GETTER(i, c) +#undef DEF_GETTER + +#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } +DEF_GETTER(a, i) DEF_GETTER(b, h) DEF_GETTER(c, g) +DEF_GETTER(d, f) DEF_GETTER(e, e) DEF_GETTER(f, d) +DEF_GETTER(g, c) DEF_GETTER(h, b) DEF_GETTER(i, a) +#undef DEF_GETTER + +#define DEF_GETTER(x, y) template <> inline uint32_t get_##x(const Kernel_3x3& ker) { return ker.y; } +DEF_GETTER(a, c) DEF_GETTER(b, f) DEF_GETTER(c, i) +DEF_GETTER(d, b) DEF_GETTER(e, e) DEF_GETTER(f, h) +DEF_GETTER(g, a) DEF_GETTER(h, d) DEF_GETTER(i, g) +#undef DEF_GETTER + + +//compress four blend types into a single byte +inline BlendType getTopL (unsigned char b) { return static_cast(0x3 & b); } +inline BlendType getTopR (unsigned char b) { return static_cast(0x3 & (b >> 2)); } +inline BlendType getBottomR(unsigned char b) { return static_cast(0x3 & (b >> 4)); } +inline BlendType getBottomL(unsigned char b) { return static_cast(0x3 & (b >> 6)); } + +inline void setTopL (unsigned char& b, BlendType bt) { b |= bt; } //buffer is assumed to be initialized before preprocessing! +inline void setTopR (unsigned char& b, BlendType bt) { b |= (bt << 2); } +inline void setBottomR(unsigned char& b, BlendType bt) { b |= (bt << 4); } +inline void setBottomL(unsigned char& b, BlendType bt) { b |= (bt << 6); } + +inline bool blendingNeeded(unsigned char b) { return b != 0; } + +template inline +unsigned char rotateBlendInfo(unsigned char b) { return b; } +template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 2) | (b >> 6)) & 0xff; } +template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 4) | (b >> 4)) & 0xff; } +template <> inline unsigned char rotateBlendInfo(unsigned char b) { return ((b << 6) | (b >> 2)) & 0xff; } + + +#ifndef NDEBUG +#ifdef _MSC_VER + int debugPixelX = -1; + int debugPixelY = 12; + __declspec(thread) bool breakIntoDebugger = false; +#endif +#endif + + +/* +input kernel area naming convention: +------------- +| A | B | C | +----|---|---| +| D | E | F | //input pixel is at position E +----|---|---| +| G | H | I | +------------- +*/ +template +FORCE_INLINE //perf: quite worth it! +void blendPixel(const Kernel_3x3& ker, + uint32_t* target, int trgWidth, + unsigned char blendInfo, //result of preprocessing all four corners of pixel "e" + const xbrz::ScalerCfg& cfg) +{ +#define a get_a(ker) +#define b get_b(ker) +#define c get_c(ker) +#define d get_d(ker) +#define e get_e(ker) +#define f get_f(ker) +#define g get_g(ker) +#define h get_h(ker) +#define i get_i(ker) + +#ifndef NDEBUG +#ifdef _MSC_VER + if (breakIntoDebugger) + __debugbreak(); //__asm int 3; +#endif +#endif + + const unsigned char blend = rotateBlendInfo(blendInfo); + + if (getBottomR(blend) >= BLEND_NORMAL) + { + bool doLineBlend = (getBottomR(blend) >= BLEND_DOMINANT) || !( + //make sure there is no second blending in an adjacent rotation for this pixel: handles insular pixels, mario eyes + (getTopR(blend) != BLEND_NONE && !eq(e, g, cfg)) || //but support double-blending for 90° corners + (getBottomL(blend) != BLEND_NONE && !eq(e, c, cfg)) || + //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes") + (!eq(e, i, cfg) && eq(g, h, cfg) && eq(h , i, cfg) && eq(i, f, cfg) && eq(f, c, cfg)) + ); + + const uint32_t px = dist(e, f, cfg) <= dist(e, h, cfg) ? f : h; //choose most similar color + + OutputMatrix out(target, trgWidth); + + if (doLineBlend) + { + const double fg = dist(f, g, cfg); //test sample: 70% of values max(fg, hc) / min(fg, hc) are between 1.1 and 3.7 with median being 1.9 + const double hc = dist(h, c, cfg); // + + const bool haveShallowLine = cfg.steepDirectionThreshold * fg <= hc && e != g && d != g; + const bool haveSteepLine = cfg.steepDirectionThreshold * hc <= fg && e != c && b != c; + + if (haveShallowLine) + { + if (haveSteepLine) + Scaler::blendLineSteepAndShallow(px, out); + else + Scaler::blendLineShallow(px, out); + } + else + { + if (haveSteepLine) + Scaler::blendLineSteep(px, out); + else + Scaler::blendLineDiagonal(px,out); + } + } + else + Scaler::blendCorner(px, out); + } + +#undef a +#undef b +#undef c +#undef d +#undef e +#undef f +#undef g +#undef h +#undef i +} + + +template //scaler policy: see "Scaler2x" reference implementation +void scaleImage(const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, uint32_t* trg, int trgWidth, const xbrz::ScalerCfg& cfg, int yFirst, int yLast) +{ + yFirst = std::max(yFirst, 0); + yLast = std::min(yLast, srcHeight); + if (yFirst >= yLast || srcWidth <= 0) + return; + + //"use" space at the end of the image as temporary buffer for "on the fly preprocessing": we even could use larger area of + //"sizeof(uint32_t) * srcWidth * (yLast - yFirst)" bytes without risk of accidental overwriting before accessing + const int bufferSize = srcWidth; + unsigned char* preProcBuffer = reinterpret_cast(trg + yLast * Scaler::scale * trgWidth) - bufferSize; + std::fill(preProcBuffer, preProcBuffer + bufferSize, 0); + //~ static_assert(BLEND_NONE == 0, ""); + + //initialize preprocessing buffer for first row of current stripe: detect upper left and right corner blending + //this cannot be optimized for adjacent processing stripes; we must not allow for a memory race condition! + if (yFirst > 0) + { + const int y = yFirst - 1; + + const uint32_t* s_m1 = src + srcPitch * std::max(y - 1, 0); + const uint32_t* s_0 = src + srcPitch * y; //center line + const uint32_t* s_p1 = src + srcPitch * std::min(y + 1, srcHeight - 1); + const uint32_t* s_p2 = src + srcPitch * std::min(y + 2, srcHeight - 1); + + for (int x = 0; x < srcWidth; ++x) + { + const int x_m1 = std::max(x - 1, 0); + const int x_p1 = std::min(x + 1, srcWidth - 1); + const int x_p2 = std::min(x + 2, srcWidth - 1); + + Kernel_4x4 ker = {}; //perf: initialization is negligible + ker.a = s_m1[x_m1]; //read sequentially from memory as far as possible + ker.b = s_m1[x]; + ker.c = s_m1[x_p1]; + ker.d = s_m1[x_p2]; + + ker.e = s_0[x_m1]; + ker.f = s_0[x]; + ker.g = s_0[x_p1]; + ker.h = s_0[x_p2]; + + ker.i = s_p1[x_m1]; + ker.j = s_p1[x]; + ker.k = s_p1[x_p1]; + ker.l = s_p1[x_p2]; + + ker.m = s_p2[x_m1]; + ker.n = s_p2[x]; + ker.o = s_p2[x_p1]; + ker.p = s_p2[x_p2]; + + const BlendResult res = preProcessCorners(ker, cfg); + /* + preprocessing blend result: + --------- + | F | G | //evalute corner between F, G, J, K + ----|---| //input pixel is at position F + | J | K | + --------- + */ + setTopR(preProcBuffer[x], res.blend_j); + + if (x + 1 < bufferSize) + setTopL(preProcBuffer[x + 1], res.blend_k); + } + } + //------------------------------------------------------------------------------------ + + for (int y = yFirst; y < yLast; ++y) + { + uint32_t* out = trg + Scaler::scale * y * trgWidth; //consider MT "striped" access + + const uint32_t* s_m1 = src + srcPitch * std::max(y - 1, 0); + const uint32_t* s_0 = src + srcPitch * y; //center line + const uint32_t* s_p1 = src + srcPitch * std::min(y + 1, srcHeight - 1); + const uint32_t* s_p2 = src + srcPitch * std::min(y + 2, srcHeight - 1); + + unsigned char blend_xy1 = 0; //corner blending for current (x, y + 1) position + + for (int x = 0; x < srcWidth; ++x, out += Scaler::scale) + { +#ifndef NDEBUG +#ifdef _MSC_VER + breakIntoDebugger = debugPixelX == x && debugPixelY == y; +#endif +#endif + //all those bounds checks have only insignificant impact on performance! + const int x_m1 = std::max(x - 1, 0); //perf: prefer array indexing to additional pointers! + const int x_p1 = std::min(x + 1, srcWidth - 1); + const int x_p2 = std::min(x + 2, srcWidth - 1); + + Kernel_4x4 ker4 = {}; //perf: initialization is negligible + + ker4.a = s_m1[x_m1]; //read sequentially from memory as far as possible + ker4.b = s_m1[x]; + ker4.c = s_m1[x_p1]; + ker4.d = s_m1[x_p2]; + + ker4.e = s_0[x_m1]; + ker4.f = s_0[x]; + ker4.g = s_0[x_p1]; + ker4.h = s_0[x_p2]; + + ker4.i = s_p1[x_m1]; + ker4.j = s_p1[x]; + ker4.k = s_p1[x_p1]; + ker4.l = s_p1[x_p2]; + + ker4.m = s_p2[x_m1]; + ker4.n = s_p2[x]; + ker4.o = s_p2[x_p1]; + ker4.p = s_p2[x_p2]; + + //evaluate the four corners on bottom-right of current pixel + unsigned char blend_xy = 0; //for current (x, y) position + { + const BlendResult res = preProcessCorners(ker4, cfg); + /* + preprocessing blend result: + --------- + | F | G | //evalute corner between F, G, J, K + ----|---| //current input pixel is at position F + | J | K | + --------- + */ + blend_xy = preProcBuffer[x]; + setBottomR(blend_xy, res.blend_f); //all four corners of (x, y) have been determined at this point due to processing sequence! + + setTopR(blend_xy1, res.blend_j); //set 2nd known corner for (x, y + 1) + preProcBuffer[x] = blend_xy1; //store on current buffer position for use on next row + + blend_xy1 = 0; + setTopL(blend_xy1, res.blend_k); //set 1st known corner for (x + 1, y + 1) and buffer for use on next column + + if (x + 1 < bufferSize) //set 3rd known corner for (x + 1, y) + setBottomL(preProcBuffer[x + 1], res.blend_g); + } + + //fill block of size scale * scale with the given color + fillBlock(out, trgWidth * sizeof(uint32_t), ker4.f, Scaler::scale); //place *after* preprocessing step, to not overwrite the results while processing the the last pixel! + + //blend four corners of current pixel + if (blendingNeeded(blend_xy)) //good 5% perf-improvement + { + Kernel_3x3 ker3 = {}; //perf: initialization is negligible + + ker3.a = ker4.a; + ker3.b = ker4.b; + ker3.c = ker4.c; + + ker3.d = ker4.e; + ker3.e = ker4.f; + ker3.f = ker4.g; + + ker3.g = ker4.i; + ker3.h = ker4.j; + ker3.i = ker4.k; + + blendPixel(ker3, out, trgWidth, blend_xy, cfg); + blendPixel(ker3, out, trgWidth, blend_xy, cfg); + blendPixel(ker3, out, trgWidth, blend_xy, cfg); + blendPixel(ker3, out, trgWidth, blend_xy, cfg); + } + } + } +} + +//------------------------------------------------------------------------------------ + +template +struct Scaler2x : public ColorGradient +{ + static const int scale = 2; + + template //bring template function into scope for GCC + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } + + + template + static void blendLineShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + } + + template + static void blendLineSteep(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + } + + template + static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<1, 0>(), col); + alphaGrad<1, 4>(out.template ref<0, 1>(), col); + alphaGrad<5, 6>(out.template ref<1, 1>(), col); //[!] fixes 7/8 used in xBR + } + + template + static void blendLineDiagonal(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 2>(out.template ref<1, 1>(), col); + } + + template + static void blendCorner(uint32_t col, OutputMatrix& out) + { + //model a round corner + alphaGrad<21, 100>(out.template ref<1, 1>(), col); //exact: 1 - pi/4 = 0.2146018366 + } +}; + + +template +struct Scaler3x : public ColorGradient +{ + static const int scale = 3; + + template //bring template function into scope for GCC + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } + + + template + static void blendLineShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + + alphaGrad<3, 4>(out.template ref(), col); + out.template ref() = col; + } + + template + static void blendLineSteep(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + out.template ref<2, scale - 1>() = col; + } + + template + static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<2, 0>(), col); + alphaGrad<1, 4>(out.template ref<0, 2>(), col); + alphaGrad<3, 4>(out.template ref<2, 1>(), col); + alphaGrad<3, 4>(out.template ref<1, 2>(), col); + out.template ref<2, 2>() = col; + } + + template + static void blendLineDiagonal(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 8>(out.template ref<1, 2>(), col); //conflict with other rotations for this odd scale + alphaGrad<1, 8>(out.template ref<2, 1>(), col); + alphaGrad<7, 8>(out.template ref<2, 2>(), col); // + } + + template + static void blendCorner(uint32_t col, OutputMatrix& out) + { + //model a round corner + alphaGrad<45, 100>(out.template ref<2, 2>(), col); //exact: 0.4545939598 + //alphaGrad<7, 256>(out.template ref<2, 1>(), col); //0.02826017254 -> negligible + avoid conflicts with other rotations for this odd scale + //alphaGrad<7, 256>(out.template ref<1, 2>(), col); //0.02826017254 + } +}; + + +template +struct Scaler4x : public ColorGradient +{ + static const int scale = 4; + + template //bring template function into scope for GCC + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } + + + template + static void blendLineShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + + alphaGrad<3, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendLineSteep(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); + + out.template ref<2, scale - 1>() = col; + out.template ref<3, scale - 1>() = col; + } + + template + static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<3, 4>(out.template ref<3, 1>(), col); + alphaGrad<3, 4>(out.template ref<1, 3>(), col); + alphaGrad<1, 4>(out.template ref<3, 0>(), col); + alphaGrad<1, 4>(out.template ref<0, 3>(), col); + + alphaGrad<1, 3>(out.template ref<2, 2>(), col); //[!] fixes 1/4 used in xBR + + out.template ref<3, 3>() = col; + out.template ref<3, 2>() = col; + out.template ref<2, 3>() = col; + } + + template + static void blendLineDiagonal(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 2>(out.template ref(), col); + alphaGrad<1, 2>(out.template ref(), col); + out.template ref() = col; + } + + template + static void blendCorner(uint32_t col, OutputMatrix& out) + { + //model a round corner + alphaGrad<68, 100>(out.template ref<3, 3>(), col); //exact: 0.6848532563 + alphaGrad< 9, 100>(out.template ref<3, 2>(), col); //0.08677704501 + alphaGrad< 9, 100>(out.template ref<2, 3>(), col); //0.08677704501 + } +}; + + +template +struct Scaler5x : public ColorGradient +{ + static const int scale = 5; + + template //bring template function into scope for GCC + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } + + + template + static void blendLineShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + + alphaGrad<3, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + + out.template ref() = col; + out.template ref() = col; + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendLineSteep(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + alphaGrad<1, 4>(out.template ref<4, scale - 3>(), col); + + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); + + out.template ref<2, scale - 1>() = col; + out.template ref<3, scale - 1>() = col; + out.template ref<4, scale - 1>() = col; + out.template ref<4, scale - 2>() = col; + } + + template + static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + + alphaGrad<2, 3>(out.template ref<3, 3>(), col); + + out.template ref<2, scale - 1>() = col; + out.template ref<3, scale - 1>() = col; + out.template ref<4, scale - 1>() = col; + + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendLineDiagonal(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 8>(out.template ref(), col); //conflict with other rotations for this odd scale + alphaGrad<1, 8>(out.template ref(), col); + alphaGrad<1, 8>(out.template ref(), col); // + + alphaGrad<7, 8>(out.template ref<4, 3>(), col); + alphaGrad<7, 8>(out.template ref<3, 4>(), col); + + out.template ref<4, 4>() = col; + } + + template + static void blendCorner(uint32_t col, OutputMatrix& out) + { + //model a round corner + alphaGrad<86, 100>(out.template ref<4, 4>(), col); //exact: 0.8631434088 + alphaGrad<23, 100>(out.template ref<4, 3>(), col); //0.2306749731 + alphaGrad<23, 100>(out.template ref<3, 4>(), col); //0.2306749731 + //alphaGrad<1, 64>(out.template ref<4, 2>(), col); //0.01676812367 -> negligible + avoid conflicts with other rotations for this odd scale + //alphaGrad<1, 64>(out.template ref<2, 4>(), col); //0.01676812367 + } +}; + + +template +struct Scaler6x : public ColorGradient +{ + static const int scale = 6; + + template //bring template function into scope for GCC + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) { ColorGradient::template alphaGrad(pixBack, pixFront); } + + + template + static void blendLineShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + + alphaGrad<3, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + + out.template ref() = col; + out.template ref() = col; + out.template ref() = col; + out.template ref() = col; + + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendLineSteep(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + alphaGrad<1, 4>(out.template ref<4, scale - 3>(), col); + + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); + alphaGrad<3, 4>(out.template ref<5, scale - 3>(), col); + + out.template ref<2, scale - 1>() = col; + out.template ref<3, scale - 1>() = col; + out.template ref<4, scale - 1>() = col; + out.template ref<5, scale - 1>() = col; + + out.template ref<4, scale - 2>() = col; + out.template ref<5, scale - 2>() = col; + } + + template + static void blendLineSteepAndShallow(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 4>(out.template ref<0, scale - 1>(), col); + alphaGrad<1, 4>(out.template ref<2, scale - 2>(), col); + alphaGrad<3, 4>(out.template ref<1, scale - 1>(), col); + alphaGrad<3, 4>(out.template ref<3, scale - 2>(), col); + + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<1, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + alphaGrad<3, 4>(out.template ref(), col); + + out.template ref<2, scale - 1>() = col; + out.template ref<3, scale - 1>() = col; + out.template ref<4, scale - 1>() = col; + out.template ref<5, scale - 1>() = col; + + out.template ref<4, scale - 2>() = col; + out.template ref<5, scale - 2>() = col; + + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendLineDiagonal(uint32_t col, OutputMatrix& out) + { + alphaGrad<1, 2>(out.template ref(), col); + alphaGrad<1, 2>(out.template ref(), col); + alphaGrad<1, 2>(out.template ref(), col); + + out.template ref() = col; + out.template ref() = col; + out.template ref() = col; + } + + template + static void blendCorner(uint32_t col, OutputMatrix& out) + { + //model a round corner + alphaGrad<97, 100>(out.template ref<5, 5>(), col); //exact: 0.9711013910 + alphaGrad<42, 100>(out.template ref<4, 5>(), col); //0.4236372243 + alphaGrad<42, 100>(out.template ref<5, 4>(), col); //0.4236372243 + alphaGrad< 6, 100>(out.template ref<5, 3>(), col); //0.05652034508 + alphaGrad< 6, 100>(out.template ref<3, 5>(), col); //0.05652034508 + } +}; + +//------------------------------------------------------------------------------------ + +struct ColorDistanceRGB +{ + static double dist(uint32_t pix1, uint32_t pix2, double luminanceWeight) + { + (void)luminanceWeight; // unused param + return distYCbCrBuffer.dist(pix1, pix2); + + //if (pix1 == pix2) //about 4% perf boost + // return 0; + //return distYCbCr(pix1, pix2, luminanceWeight); + } +}; + +struct ColorDistanceARGB +{ + static double dist(uint32_t pix1, uint32_t pix2, double luminanceWeight) + { + (void)luminanceWeight; // unused param + const double a1 = getAlpha(pix1) / 255.0 ; + const double a2 = getAlpha(pix2) / 255.0 ; + /* + Requirements for a color distance handling alpha channel: with a1, a2 in [0, 1] + + 1. if a1 = a2, distance should be: a1 * distYCbCr() + 2. if a1 = 0, distance should be: a2 * distYCbCr(black, white) = a2 * 255 + 3. if a1 = 1, ??? maybe: 255 * (1 - a2) + a2 * distYCbCr() + */ + + //return std::min(a1, a2) * distYCbCrBuffer.dist(pix1, pix2) + 255 * abs(a1 - a2); + //=> following code is 15% faster: + const double d = distYCbCrBuffer.dist(pix1, pix2); + if (a1 < a2) + return a1 * d + 255 * (a2 - a1); + else + return a2 * d + 255 * (a1 - a2); + + //alternative? return std::sqrt(a1 * a2 * square(distYCbCrBuffer.dist(pix1, pix2)) + square(255 * (a1 - a2))); + } +}; + + +struct ColorGradientRGB +{ + template + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) + { + pixBack = gradientRGB(pixFront, pixBack); + } +}; + +struct ColorGradientARGB +{ + template + static void alphaGrad(uint32_t& pixBack, uint32_t pixFront) + { + pixBack = gradientARGB(pixFront, pixBack); + } +}; +} + + +void xbrz::scale(size_t factor, const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, uint32_t* trg, int trgPitch, ColorFormat colFmt, const xbrz::ScalerCfg& cfg, int yFirst, int yLast) +{ + if (srcPitch % static_cast(sizeof(uint32_t)) != 0 || + trgPitch % static_cast(sizeof(uint32_t)) != 0 || + srcPitch < srcWidth * static_cast(sizeof(uint32_t)) || + trgPitch < srcWidth * static_cast(factor) * static_cast(sizeof(uint32_t))) + { + assert(false); + return; + } + + int trgWidth = trgPitch / static_cast(sizeof(uint32_t)); + int srcPPitch = srcPitch / static_cast(sizeof(uint32_t)); + + switch (colFmt) + { + case ARGB: + switch (factor) + { + case 2: + return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 3: + return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 4: + return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 5: + return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 6: + return scaleImage, ColorDistanceARGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + } + break; + + case RGB: + switch (factor) + { + case 2: + return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 3: + return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 4: + return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 5: + return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + case 6: + return scaleImage, ColorDistanceRGB>(src, srcWidth, srcHeight, srcPPitch, trg, trgWidth, cfg, yFirst, yLast); + } + break; + } + assert(false); +} + + +bool xbrz::equalColorTest(uint32_t col1, uint32_t col2, ColorFormat colFmt, double luminanceWeight, double equalColorTolerance) +{ + switch (colFmt) + { + case ARGB: + return ColorDistanceARGB::dist(col1, col2, luminanceWeight) < equalColorTolerance; + + case RGB: + return ColorDistanceRGB::dist(col1, col2, luminanceWeight) < equalColorTolerance; + } + assert(false); + return false; +} + + +void xbrz::nearestNeighborScale(const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, + uint32_t* trg, int trgWidth, int trgHeight, int trgPitch, + SliceType st, int yFirst, int yLast) +{ + if (srcPitch < srcWidth * static_cast(sizeof(uint32_t)) || + trgPitch < trgWidth * static_cast(sizeof(uint32_t))) + { + assert(false); + return; + } + + switch (st) + { + case NN_SCALE_SLICE_SOURCE: + //nearest-neighbor (going over source image - fast for upscaling, since source is read only once + yFirst = std::max(yFirst, 0); + yLast = std::min(yLast, srcHeight); + if (yFirst >= yLast || trgWidth <= 0 || trgHeight <= 0) return; + + for (int y = yFirst; y < yLast; ++y) + { + //mathematically: ySrc = floor(srcHeight * yTrg / trgHeight) + // => search for integers in: [ySrc, ySrc + 1) * trgHeight / srcHeight + + //keep within for loop to support MT input slices! + const int yTrg_first = ( y * trgHeight + srcHeight - 1) / srcHeight; //=ceil(y * trgHeight / srcHeight) + const int yTrg_last = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; //=ceil(((y + 1) * trgHeight) / srcHeight) + const int blockHeight = yTrg_last - yTrg_first; + + if (blockHeight > 0) + { + const uint32_t* srcLine = byteAdvance(src, y * srcPitch); + uint32_t* trgLine = byteAdvance(trg, yTrg_first * trgPitch); + int xTrg_first = 0; + + for (int x = 0; x < srcWidth; ++x) + { + int xTrg_last = ((x + 1) * trgWidth + srcWidth - 1) / srcWidth; + const int blockWidth = xTrg_last - xTrg_first; + if (blockWidth > 0) + { + xTrg_first = xTrg_last; + fillBlock(trgLine, trgPitch, srcLine[x], blockWidth, blockHeight); + trgLine += blockWidth; + } + } + } + } + break; + + case NN_SCALE_SLICE_TARGET: + //nearest-neighbor (going over target image - slow for upscaling, since source is read multiple times missing out on cache! Fast for similar image sizes!) + yFirst = std::max(yFirst, 0); + yLast = std::min(yLast, trgHeight); + if (yFirst >= yLast || srcHeight <= 0 || srcWidth <= 0) return; + + for (int y = yFirst; y < yLast; ++y) + { + uint32_t* trgLine = byteAdvance(trg, y * trgPitch); + const int ySrc = srcHeight * y / trgHeight; + const uint32_t* srcLine = byteAdvance(src, ySrc * srcPitch); + for (int x = 0; x < trgWidth; ++x) + { + const int xSrc = srcWidth * x / trgWidth; + trgLine[x] = srcLine[xSrc]; + } + } + break; + } +} diff --git a/src/filters/xBRZ/xbrz.h b/src/filters/xBRZ/xbrz.h index 7bc9590b..42c7a315 100644 --- a/src/filters/xBRZ/xbrz.h +++ b/src/filters/xBRZ/xbrz.h @@ -1,102 +1,102 @@ -// **************************************************************************** -// * This file is part of the HqMAME project. It is distributed under * -// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * -// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * -// * * -// * Additionally and as a special exception, the author gives permission * -// * to link the code of this program with the MAME library (or with modified * -// * versions of MAME that use the same license as MAME), and distribute * -// * linked combinations including the two. You must obey the GNU General * -// * Public License in all respects for all of the code used other than MAME. * -// * If you modify this file, you may extend this exception to your version * -// * of the file, but you are not obligated to do so. If you do not wish to * -// * do so, delete this exception statement from your version. * -// **************************************************************************** - -#ifndef XBRZ_HEADER_3847894708239054 -#define XBRZ_HEADER_3847894708239054 - -#include "config.h" -#include //size_t -#include -#include //uint32_t - -namespace xbrz -{ -/* -------------------------------------------------------------------------- -| xBRZ: "Scale by rules" - high quality image upscaling filter by Zenju | -------------------------------------------------------------------------- -using a modified approach of xBR: -http://board.byuu.org/viewtopic.php?f=10&t=2248 -- new rule set preserving small image features -- highly optimized for performance -- support alpha channel -- support multithreading -- support 64-bit architectures -- support processing image slices -- support scaling up to 6xBRZ -*/ - -enum ColorFormat // from high bits -> low bits, 8 bit per channel -{ RGB, // 8 bit for each red, green, blue, upper 8 bits unused - ARGB, // including alpha channel, BGRA byte order on little-endian machines -}; - -/* --> map source (srcWidth * srcHeight) to target (scale * width x scale * height) image, optionally -processing a half-open slice of rows [yFirst, yLast) only --> support for source/target pitch in bytes! --> if your emulator changes only a few image slices during each cycle (e.g. DOSBox) then there's no -need to run xBRZ on the complete image: - Just make sure you enlarge the source image slice by 2 rows on top and 2 on bottom (this is the -additional range the xBRZ algorithm is using during analysis) - Caveat: If there are multiple changed slices, make sure they do not overlap after adding these -additional rows in order to avoid a memory race condition - in the target image data if you are using multiple threads for processing each enlarged slice! - -THREAD-SAFETY: - parts of the same image may be scaled by multiple threads as long as the [yFirst, -yLast) ranges do not overlap! - - there is a minor inefficiency for the first row of a slice, so avoid processing -single rows only; suggestion: process 8-16 rows at least -*/ -void scale(size_t factor, // valid range: 2 - 6 - const uint32_t *src, int srcWidth, int srcHeight, int srcPitch, uint32_t *trg, - int trgPitch, ColorFormat colFmt, const ScalerCfg &cfg = ScalerCfg(), int yFirst = 0, - int yLast = std::numeric_limits::max()); // slice of source image - -void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, uint32_t *trg, - int trgWidth, int trgHeight); - -enum SliceType { - NN_SCALE_SLICE_SOURCE, - NN_SCALE_SLICE_TARGET, -}; -void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, - int srcPitch, // pitch in bytes! - uint32_t *trg, int trgWidth, int trgHeight, int trgPitch, SliceType st, - int yFirst, int yLast); - -// parameter tuning -bool equalColorTest(uint32_t col1, uint32_t col2, ColorFormat colFmt, double luminanceWeight, - double equalColorTolerance); - -//########################### implementation ########################### -inline void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, uint32_t *trg, - int trgWidth, int trgHeight) -{ - nearestNeighborScale(src, - srcWidth, - srcHeight, - srcWidth * sizeof(uint32_t), - trg, - trgWidth, - trgHeight, - trgWidth * sizeof(uint32_t), - NN_SCALE_SLICE_TARGET, - 0, - trgHeight); -} -} - -#endif +// **************************************************************************** +// * This file is part of the HqMAME project. It is distributed under * +// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 * +// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved * +// * * +// * Additionally and as a special exception, the author gives permission * +// * to link the code of this program with the MAME library (or with modified * +// * versions of MAME that use the same license as MAME), and distribute * +// * linked combinations including the two. You must obey the GNU General * +// * Public License in all respects for all of the code used other than MAME. * +// * If you modify this file, you may extend this exception to your version * +// * of the file, but you are not obligated to do so. If you do not wish to * +// * do so, delete this exception statement from your version. * +// **************************************************************************** + +#ifndef XBRZ_HEADER_3847894708239054 +#define XBRZ_HEADER_3847894708239054 + +#include "config.h" +#include //size_t +#include +#include //uint32_t + +namespace xbrz +{ +/* +------------------------------------------------------------------------- +| xBRZ: "Scale by rules" - high quality image upscaling filter by Zenju | +------------------------------------------------------------------------- +using a modified approach of xBR: +http://board.byuu.org/viewtopic.php?f=10&t=2248 +- new rule set preserving small image features +- highly optimized for performance +- support alpha channel +- support multithreading +- support 64-bit architectures +- support processing image slices +- support scaling up to 6xBRZ +*/ + +enum ColorFormat // from high bits -> low bits, 8 bit per channel +{ RGB, // 8 bit for each red, green, blue, upper 8 bits unused + ARGB, // including alpha channel, BGRA byte order on little-endian machines +}; + +/* +-> map source (srcWidth * srcHeight) to target (scale * width x scale * height) image, optionally +processing a half-open slice of rows [yFirst, yLast) only +-> support for source/target pitch in bytes! +-> if your emulator changes only a few image slices during each cycle (e.g. DOSBox) then there's no +need to run xBRZ on the complete image: + Just make sure you enlarge the source image slice by 2 rows on top and 2 on bottom (this is the +additional range the xBRZ algorithm is using during analysis) + Caveat: If there are multiple changed slices, make sure they do not overlap after adding these +additional rows in order to avoid a memory race condition + in the target image data if you are using multiple threads for processing each enlarged slice! + +THREAD-SAFETY: - parts of the same image may be scaled by multiple threads as long as the [yFirst, +yLast) ranges do not overlap! + - there is a minor inefficiency for the first row of a slice, so avoid processing +single rows only; suggestion: process 8-16 rows at least +*/ +void scale(size_t factor, // valid range: 2 - 6 + const uint32_t *src, int srcWidth, int srcHeight, int srcPitch, uint32_t *trg, + int trgPitch, ColorFormat colFmt, const ScalerCfg &cfg = ScalerCfg(), int yFirst = 0, + int yLast = std::numeric_limits::max()); // slice of source image + +void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, uint32_t *trg, + int trgWidth, int trgHeight); + +enum SliceType { + NN_SCALE_SLICE_SOURCE, + NN_SCALE_SLICE_TARGET, +}; +void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, + int srcPitch, // pitch in bytes! + uint32_t *trg, int trgWidth, int trgHeight, int trgPitch, SliceType st, + int yFirst, int yLast); + +// parameter tuning +bool equalColorTest(uint32_t col1, uint32_t col2, ColorFormat colFmt, double luminanceWeight, + double equalColorTolerance); + +//########################### implementation ########################### +inline void nearestNeighborScale(const uint32_t *src, int srcWidth, int srcHeight, uint32_t *trg, + int trgWidth, int trgHeight) +{ + nearestNeighborScale(src, + srcWidth, + srcHeight, + srcWidth * sizeof(uint32_t), + trg, + trgWidth, + trgHeight, + trgWidth * sizeof(uint32_t), + NN_SCALE_SLICE_TARGET, + 0, + trgHeight); +} +} + +#endif diff --git a/src/gb/GB.cpp b/src/gb/GB.cpp index 382aa964..9fa86326 100644 --- a/src/gb/GB.cpp +++ b/src/gb/GB.cpp @@ -2189,7 +2189,7 @@ static void gbSelectColorizationPalette() } // Check if the checksum is in the list. - int idx; + size_t idx; for (idx = 0; idx < sizeof(gbColorizationChecksums); idx++) { if (gbColorizationChecksums[idx] == checksum) { break; @@ -2201,7 +2201,7 @@ static void gbSelectColorizationPalette() // Indexes above 0x40 have to be disambiguated. if (idx > 0x40) { // No idea how that works. But it works. - for (int i = idx - 0x41, j = 0; i < sizeof(gbColorizationDisambigChars); i += 14, j += 14) { + for (size_t i = idx - 0x41, j = 0; i < sizeof(gbColorizationDisambigChars); i += 14, j += 14) { if (gbRom[0x0137] == gbColorizationDisambigChars[i]) { infoIdx = idx + j; break; @@ -3430,7 +3430,7 @@ bool gbReadGSASnapshot(const char* fileName) fseek(file, 0x4, SEEK_SET); char buffer[16]; char buffer2[16]; - fread(buffer, 1, 15, file); + FREAD_UNCHECKED(buffer, 1, 15, file); buffer[15] = 0; memcpy(buffer2, &gbRom[0x134], 15); buffer2[15] = 0; @@ -3443,8 +3443,6 @@ bool gbReadGSASnapshot(const char* fileName) return false; } fseek(file, 0x13, SEEK_SET); - size_t read = 0; - int toRead = 0; switch (gbRomType) { case 0x03: case 0x0f: @@ -3453,13 +3451,11 @@ bool gbReadGSASnapshot(const char* fileName) case 0x1b: case 0x1e: case 0xff: - read = fread(gbRam, 1, (gbRamSizeMask + 1), file); - toRead = (gbRamSizeMask + 1); + FREAD_UNCHECKED(gbRam, 1, (gbRamSizeMask + 1), file); break; case 0x06: case 0x22: - read = fread(&gbMemory[0xa000], 1, 256, file); - toRead = 256; + FREAD_UNCHECKED(&gbMemory[0xa000], 1, 256, file); break; default: systemMessage(MSG_UNSUPPORTED_SNAPSHOT_FILE, diff --git a/src/gb/gbCheats.cpp b/src/gb/gbCheats.cpp index 90947906..e75039af 100644 --- a/src/gb/gbCheats.cpp +++ b/src/gb/gbCheats.cpp @@ -416,10 +416,10 @@ bool gbCheatReadGSCodeFile(const char* fileName) char code[9]; int i; for (i = 0; i < count; i++) { - fread(&dummy, 1, 2, file); - fread(desc, 1, 12, file); + FREAD_UNCHECKED(&dummy, 1, 2, file); + FREAD_UNCHECKED(desc, 1, 12, file); desc[12] = 0; - fread(code, 1, 8, file); + FREAD_UNCHECKED(code, 1, 8, file); code[8] = 0; gbAddGsCheat(code, desc); } diff --git a/src/gb/gbMemory.cpp b/src/gb/gbMemory.cpp index 85cd45ed..98cda0be 100644 --- a/src/gb/gbMemory.cpp +++ b/src/gb/gbMemory.cpp @@ -991,8 +991,17 @@ mapperHuC3 gbDataHuC3 = { 1, // ROM bank 0, // RAM bank 0, // RAM address + 0, // Address 0, // RAM flag - 0 // RAM read value + 0, // RAM read value + 0, // Register 1 + 0, // Register 2 + 0, // Register 3 + 0, // Register 4 + 0, // Register 5 + 0, // Register 6 + 0, // Register 7 + 0 // Register 8 }; // HuC3 ROM write registers diff --git a/src/gb/gbSGB.cpp b/src/gb/gbSGB.cpp index c2155a31..3f2152ae 100644 --- a/src/gb/gbSGB.cpp +++ b/src/gb/gbSGB.cpp @@ -67,7 +67,7 @@ void gbSgbReset() gbSgbNextController = 0x0f; gbSgbReadingController = 0; - memset(gbSgbSCPPalette, 0, 512 * 4); + memset(gbSgbSCPPalette, 0, 512 * 4 * sizeof(uint16_t)); memset(gbSgbATF, 0, 20 * 18); memset(gbSgbATFList, 0, 45 * 20 * 18); memset(gbSgbPacket, 0, 16 * 7); diff --git a/src/gba/BreakpointStructures.cpp b/src/gba/BreakpointStructures.cpp index e1a78d68..35ae0920 100644 --- a/src/gba/BreakpointStructures.cpp +++ b/src/gba/BreakpointStructures.cpp @@ -1,14 +1,14 @@ -/*New code made for the new breakpoint system. - -Each breakpoint is now marked by a halfword in an array on map, -breakpoint array. Each bit means one different type of breakpoint. -Bit Value -0 - write -1 - read -2 - ARM -3 - THUMB -4 - Always on Write -5 - Always on Read +/*New code made for the new breakpoint system. + +Each breakpoint is now marked by a halfword in an array on map, +breakpoint array. Each bit means one different type of breakpoint. +Bit Value +0 - write +1 - read +2 - ARM +3 - THUMB +4 - Always on Write +5 - Always on Read 6 - Always on ARM 7 - Always on THUMB @@ -16,43 +16,43 @@ Each flag is independent, and can be used as such, as well as together. You can define a break on access (0xf), break on IO (0x3), break on execution(0xc) or any other combination you need. 0xf0 will always break on any passage through the address - -This structure is accompanied by two other structures for the accesses. -One of them is the Conditional structure. It's available for all types. - -The breaking address header is placed at ConditionalBreak. The type_flags -indicate the type of break, in the format indicated above. -Then, it links to the several conditions needed for the break to take place. - -Those conditions are then sequentially executed, and if all are true, the -break takes place. -They are composed of an address to test, a value to test against, the value's -type, the flag conditons to test and a link to the next condition to test if -that was true. Address and value are stored as Evaluatable expressions, -according to the already defined eval from expr.c -However, be reminded that sometimes registers and memory positions may contain -values that are not addresses at some times. If such is the case, the program -will show garbage results or crash. - -The flags are bit-based -Bit Value -0 - equal -1 - greater -2 - lesser -3 - force Signed comparison - -Bit Value -0,1 - addr is: 00 - byte, 01 - halfword, 10 - word, 11 - undefined, assume word -2 - addr_is_signed -3 - addr_is_array of values (not implemented yet) -4,5 - 00 is byte, 01 is halfword, 10 is word, 11 undefined -6 - val_is_signed -7 - val_is_array (also not implemented) -Usage: -Instructions that accept this kind of implementation will follow this pattern -if [<;>OR<||>OR<&&> [repeat] -if indicates that the following there is a condition. no If counts as always break - is the first value expression, that unlike what the name implies, may be + +This structure is accompanied by two other structures for the accesses. +One of them is the Conditional structure. It's available for all types. + +The breaking address header is placed at ConditionalBreak. The type_flags +indicate the type of break, in the format indicated above. +Then, it links to the several conditions needed for the break to take place. + +Those conditions are then sequentially executed, and if all are true, the +break takes place. +They are composed of an address to test, a value to test against, the value's +type, the flag conditons to test and a link to the next condition to test if +that was true. Address and value are stored as Evaluatable expressions, +according to the already defined eval from expr.c +However, be reminded that sometimes registers and memory positions may contain +values that are not addresses at some times. If such is the case, the program +will show garbage results or crash. + +The flags are bit-based +Bit Value +0 - equal +1 - greater +2 - lesser +3 - force Signed comparison + +Bit Value +0,1 - addr is: 00 - byte, 01 - halfword, 10 - word, 11 - undefined, assume word +2 - addr_is_signed +3 - addr_is_array of values (not implemented yet) +4,5 - 00 is byte, 01 is halfword, 10 is word, 11 undefined +6 - val_is_signed +7 - val_is_array (also not implemented) +Usage: +Instructions that accept this kind of implementation will follow this pattern +if [<;>OR<||>OR<&&> [repeat] +if indicates that the following there is a condition. no If counts as always break + is the first value expression, that unlike what the name implies, may be anything. is one of the comparation Operands. Full list bellow is the value to compare to. @@ -60,823 +60,826 @@ Following can be a ||(or), that adds a second, independent break condition, or a &&(and), that specifies that the next condition is a conjoined requisite to the break. EX: [0x03005000] == 0x77777777 && 0x50 == [0x03005000] Would be impossible, but tested anyway, and make it never break due to this condition. - [0x03005000] == 0x77777777 || 0x50 == [0x03005000] - Would make it break when the contents of 0x03005000 were either 0x77777777 or 0x50 - -Ex: to implement stop only when r2 is 0xf, use - if r2 == 0xf - to implement stop when PC is above 0x08005000 and 0x03005000 is signed halfword 0x2500 - if pc > 0x08005000 && 0x03005000 == +0x2500 -*/ - -/* -Full Operands lists -Op1, op2, ...,opN --> Meaning - -== , =, eq --> equal - -<, lt --> lesser than - -<=, le --> less or equal to - -> gt --> greater than - ->=, ge --> greater or equal to - -!=, <>, ne --> not equal to - - -valid content types -b, byte, uint8_t --> byte -sb, sbyte, int8_t --> signed byte -h,hw, halfword, uint16_t, ushort --> halfword -sh, shw, shalfword, int16_t short --> signed halfword -w, word, uint2_t --> word -sw, sword, int32_t, int --> signed word -*/ - -#include -#include -#include -#include - -#include "BreakpointStructures.h" -#include "remote.h" - -#if (defined __WIN32__ || defined _WIN32) -#define strdup _strdup -#endif - -extern bool dexp_eval(char*, uint32_t*); - -//struct intToString{ -// int value; -// char mapping[20]; -//}; - -struct ConditionalBreak* conditionals[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; - -//struct intToString breakFlagMapping[] = { -// {0x80,"Thumb"}, -// {0x40,"ARM"}, -// {0x20,"Read"}, -// {0x10,"Write"}, -// {0x8,"Thumb"}, -// {0x4,"ARM"}, -// {0x2,"Read"}, -// {0x1,"Write"}, -// {0x0,"None"} -//}; -/* -struct intToString compareFlagMapping[] = { - {0x7,"Always"}, - {0x6,"!="}, - {0x5,"<="}, - {0x4,"<"}, - {0x3,">="}, - {0x2,">"}, - {0x1,"=="}, - {0x0,"Never"} -};*/ - -//char* typeMapping[] = {"'uint8_t","'uint16_t","'uint32_t","'uint32_t","'int8_t","'int16_t","'int32_t","'int32_t"}; -// -//char* compareFlagMapping[] = {"Never","==",">",">=","<","<=","!=","<=>"}; - -//Constructors -//case '*': flag = 0xf; break; -//case 't': flag = 0x8; break; // thumb -//case 'a': flag = 0x4; break; // arm -//case 'x': flag = 0xC; break; -//case 'r': flag = 0x2; break; // mem read -//case 'w': flag = 0x1; break; // mem write -//case 'i': flag = 0x3; break; -struct ConditionalBreak* addConditionalBreak(uint32_t address, uint8_t flag) -{ - uint8_t condIndex = address >> 24; - struct ConditionalBreak* cond = NULL; - BreakSet((&map[condIndex])->breakPoints, address & (&map[condIndex])->mask, ((flag & 0xf) | (flag >> 4))); - if (flag & 0xf0) { - struct ConditionalBreak* base = conditionals[condIndex]; - struct ConditionalBreak* prev = conditionals[condIndex]; - if (conditionals[condIndex]) { - while ((base) && (address >= base->break_address)) { - if (base->break_address == address) { - if (base->type_flags & 0xf0) { - base->type_flags |= (flag & 0xf0); - flag &= 0xf; - cond = base; - goto addCB_nextHandle; - } else { - goto condCreateForFlagAlways; - } - } else { - prev = base; - base = base->next; - } - } - } - condCreateForFlagAlways: - cond = (struct ConditionalBreak*)malloc(sizeof(struct ConditionalBreak)); - cond->break_address = address; - cond->type_flags = flag & 0xf0; - cond->next = base; - cond->firstCond = NULL; - if (prev == conditionals[condIndex]) - conditionals[condIndex] = cond; - else - prev->next = cond; - } - flag &= 0xf; - -addCB_nextHandle: - if (flag == 0) - return cond; - - cond = (struct ConditionalBreak*)malloc(sizeof(struct ConditionalBreak)); - cond->break_address = address; - cond->type_flags = flag; - cond->next = NULL; - cond->firstCond = NULL; - if (conditionals[condIndex] == NULL) { - conditionals[condIndex] = cond; - return cond; - } else { - struct ConditionalBreak *curr, *prev; - curr = conditionals[condIndex]; - prev = conditionals[condIndex]; - while (curr) { - if (curr->break_address > address) { - if (prev == curr) { - conditionals[condIndex] = cond; - } else { - prev->next = cond; - } - cond->next = curr; - return cond; - } - prev = curr; - curr = prev->next; - } - prev->next = cond; - return cond; - } -} - -void addCondition(struct ConditionalBreak* base, struct ConditionalBreakNode* toAdd) -{ - if (base->firstCond) { - struct ConditionalBreakNode *curr, *prev; - curr = base->firstCond; - prev = base->firstCond; - while (curr) { - prev = curr; - curr = curr->next; - } - prev->next = toAdd; - } else { - base->firstCond = toAdd; - } -} - -//destructors -void freeConditionalBreak(struct ConditionalBreak* toFree) -{ - struct ConditionalBreakNode* freeMe; - while (toFree->firstCond) { - freeMe = toFree->firstCond; - toFree->firstCond = toFree->firstCond->next; - free(freeMe); - } - free(toFree); -} - -void freeConditionalNode(struct ConditionalBreakNode* toDel) -{ - if (toDel->next) - freeConditionalNode(toDel->next); - if (toDel->address) - free(toDel->address); - if (toDel->value) - free(toDel->value); - free(toDel); -} - -void freeAllConditionals() -{ - for (int i = 0; i < 16; i++) { - while (conditionals[i]) { - struct ConditionalBreak* tmp = conditionals[i]; - conditionals[i] = conditionals[i]->next; - freeConditionalBreak(tmp); - } - } -} - -int removeConditionalBreak(struct ConditionalBreak* toDelete) -{ - if (toDelete) { - uint8_t condIndex = toDelete->break_address >> 24; - struct ConditionalBreak* base = conditionals[condIndex]; - struct ConditionalBreak* prev = conditionals[condIndex]; - while (base) { - if (base == toDelete) { - if (base == prev) { - conditionals[condIndex] = base->next; - } else { - prev->next = base->next; - } - freeConditionalBreak(toDelete); - return 0; - } - prev = base; - base = base->next; - } - return -1; //failed to remove - } - return -2; //delete failed because container was not there -} - -/* -int removeConditionalBreak(uint32_t address, uint8_t num, uint8_t flag){ - uint8_t condIndex = address>>24; - struct ConditionalBreak* base = conditionals[condIndex]; - struct ConditionalBreak* prev = conditionals[condIndex]; - uint8_t counter = 0; - while(base){ - if(base->break_address > address) - return -2; //failed to remove - if(base->break_address == address){ - counter++; - } - if(counter == num){ - base->type_flags &= ~flag; - if(base->type_flags == 0){ - if(prev == base){ - conditionals[condIndex] = base->next; - }else{ - prev->next = base->next; - } - freeConditionalBreak(base); - return 0; - } - return 1; - } - prev = base; - base = base->next; - } - return -2; -} - -bool removeCondition(struct ConditionalBreak* base, struct ConditionalBreakNode* toDel){ - if(base->firstCond){ - if(toDel == base->firstCond){ - base->firstCond = toDel->next; - freeConditionalNode(toDel); - return true; - } - struct ConditionalBreakNode* curr, *prev; - curr = base->firstCond; - prev = base->firstCond; - while(curr){ - if(curr == toDel){ - prev->next = curr->next; - freeConditionalNode(toDel); - return true; - } - prev = curr; - curr = curr->next; - } - } - freeConditionalNode(toDel); - return false; -} - -bool removeCondition(uint32_t address, uint8_t flags, uint8_t num){ - struct ConditionalBreak* base = conditionals[address>>24]; - while(base && base->break_address < address){ - base = base->next; - } - if(base && base->break_address == address){ - struct ConditionalBreakNode* curr = base->firstCond; - for(int i = 0; i < num; i++){ - if(!curr && ((!base) || (!base->next))){ - return false; - }if(!curr){ - while(!curr){ - base = base->next; - if(base->break_address > address) - return false; - - curr = base->firstCond; - } - } - } - } -}*/ - -/* -int removeAllConditions(uint32_t address, uint8_t flags){ - struct ConditionalBreak* base = conditionals[address>>24]; - while(base && base->break_address < address){ - base = base->next; - } - struct ConditionalBreak* curr = base; - while(base && base->break_address == address){ - base->type_flags &= ~flags; - if(!base->type_flags){ - curr = base; - base = base->next; - removeCondition(base); - } - } - return true; -}*/ - -void recountFlagsForAddress(uint32_t address) -{ - struct ConditionalBreak* base = conditionals[address >> 24]; - uint8_t flags = 0; - while (base) { - if (base->break_address < address) { - base = base->next; - } else { - if (base->break_address == address) { - flags |= base->type_flags; - } else { - BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, 0xff); - BreakSet((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags >> 4) | (flags & 0x8))); - return; - } - base = base->next; - } - } - BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, 0xff); - BreakSet((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags >> 4) | (flags & 0x8))); -} - -//Removers -int removeConditionalBreakNo(uint32_t addrNo, uint8_t number) -{ - if (conditionals[addrNo >> 24]) { - struct ConditionalBreak* base = conditionals[addrNo >> 24]; - struct ConditionalBreak* curr = conditionals[addrNo >> 24]; - while (curr->break_address < addrNo) { - base = curr; - curr = curr->next; - } - if (curr->break_address == addrNo) { - if (number == 1) { - if (base == curr) { - conditionals[addrNo >> 24] = curr->next; - freeConditionalBreak(curr); - } else { - base->next = curr->next; - freeConditionalBreak(curr); - } - recountFlagsForAddress(addrNo); - return 0; - } else { - int count = 1; - while (curr && (curr->break_address == addrNo)) { - if (count == number) { - base->next = curr->next; - freeConditionalBreak(curr); - recountFlagsForAddress(addrNo); - return 1; - } - count++; - base = curr; - curr = curr->next; - } - return -1; - } - } - } - return -2; -} - -int removeFlagFromConditionalBreakNo(uint32_t addrNo, uint8_t number, uint8_t flag) -{ - if (conditionals[addrNo >> 24]) { - struct ConditionalBreak* base = conditionals[addrNo >> 24]; - struct ConditionalBreak* curr = conditionals[addrNo >> 24]; - while (curr->break_address < addrNo) { - base = curr; - curr = curr->next; - } - if (curr->break_address == addrNo) { - if (number == 1) { - curr->type_flags &= ~flag; - if (curr->type_flags == 0) { - if (base == curr) { - conditionals[addrNo >> 24] = curr->next; - freeConditionalBreak(curr); - } else { - base->next = curr->next; - freeConditionalBreak(curr); - } - } - recountFlagsForAddress(addrNo); - return 0; - } else { - int count = 1; - while (curr && (curr->break_address == addrNo)) { - if (count == number) { - curr->type_flags &= ~flag; - if (!curr->type_flags) { - base->next = curr->next; - freeConditionalBreak(curr); - recountFlagsForAddress(addrNo); - return 1; - } - recountFlagsForAddress(addrNo); - return 0; - } - count++; - base = curr; - curr = curr->next; - } - return -1; - } - } - } - return -2; -} - -int removeConditionalWithAddress(uint32_t address) -{ - uint8_t addrNo = address >> 24; - if (conditionals[addrNo] != NULL) { - struct ConditionalBreak* base = conditionals[addrNo]; - struct ConditionalBreak* curr = conditionals[addrNo]; - uint8_t count = 0; - uint8_t flags = 0; - while (curr && address >= curr->break_address) { - if (curr->break_address == address) { - base->next = curr->next; - flags |= curr->type_flags; - freeConditionalBreak(curr); - curr = base->next; - count++; - } else { - base = curr; - curr = curr->next; - } - } - BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags & 0xf) | (flags >> 4))); - return count; - } - return -2; -} - -int removeConditionalWithFlag(uint8_t flag, bool orMode) -{ - for (uint8_t addrNo = 0; addrNo < 16; addrNo++) { - if (conditionals[addrNo] != NULL) { - struct ConditionalBreak* base = conditionals[addrNo]; - struct ConditionalBreak* curr = conditionals[addrNo]; - uint8_t count = 0; - while (curr) { - if (((curr->type_flags & flag) == curr->type_flags) || (orMode && (curr->type_flags & flag))) { - curr->type_flags &= ~flag; - BreakClear((&map[addrNo])->breakPoints, curr->break_address & (&map[addrNo])->mask, ((flag & 0xf) | (flag >> 4))); - if (curr->type_flags == 0) { - if (base == conditionals[addrNo]) { - conditionals[addrNo] = curr->next; - base = curr->next; - curr = base; - } else { - base->next = curr->next; - freeConditionalBreak(curr); - curr = base->next; - } - count++; - } else { - base = curr; - curr = curr->next; - } - } else { - base = curr; - curr = curr->next; - } - } - return count; - } - } - return -2; -} - -int removeConditionalWithAddressAndFlag(uint32_t address, uint8_t flag, bool orMode) -{ - uint8_t addrNo = address >> 24; - if (conditionals[addrNo] != NULL) { - struct ConditionalBreak* base = conditionals[addrNo]; - struct ConditionalBreak* curr = conditionals[addrNo]; - uint8_t count = 0; - while (curr && address >= curr->break_address) { - if ((curr->break_address == address) && (((curr->type_flags & flag) == curr->type_flags) || (orMode && (curr->type_flags & flag)))) { - curr->type_flags &= ~flag; - BreakClear((&map[address >> 24])->breakPoints, curr->break_address & (&map[address >> 24])->mask, ((flag & 0xf) | (flag >> 4))); - if (curr->type_flags == 0) { - if (curr == conditionals[addrNo]) { - conditionals[addrNo] = curr->next; - freeConditionalBreak(curr); - curr = conditionals[addrNo]; - } else { - base->next = curr->next; - freeConditionalBreak(curr); - curr = base->next; - } - count++; - } else { - base = curr; - curr = curr->next; - } - } else { - base = curr; - curr = curr->next; - } - } - return count; - } - return -2; -} - -//true creating code for a given expression. -//It assumes an if was found, and that all up to the if was removed. -//receives an array of chars following the pattern: -//{',,,',,, (repeats) -//next = 0; - now->exp_type_flags = 0; - if (exp[i][0] == '\'') { - now->exp_type_flags |= parseExpressionType(&exp[i][1]); - i++; - if (i >= n) - goto fail; - } else { - now->exp_type_flags |= 6; //assume signed word - } - now->address = strdup(exp[i]); - i++; - if (i >= n) - goto fail; - char* operandName = exp[i]; - now->cond_flags = parseConditionOperand(exp[i]); - i++; - if (i >= n) - goto fail; - - if (exp[i][0] == '\'') { - now->exp_type_flags |= (parseExpressionType(&exp[i][1]) << 4); - i++; - if (i >= n) - goto fail; - } else { - now->exp_type_flags |= 0x60; //assume signed word - } - now->value = strdup(exp[i]); - i++; - uint32_t val; - if (!dexp_eval(now->value, &val) || !dexp_eval(now->address, &val)) { - printf("Invalid expression.\n"); - if (workBreak) - removeConditionalBreak(workBreak); - return; - } - if (i < n) { - if (strcmp(exp[i], "&&") == 0) { - now = (struct ConditionalBreakNode*)malloc(sizeof(struct ConditionalBreakNode)); - toAdd->next = now; - } else if (strcmp(exp[i], "||") == 0) { - addCondition(workBreak, toAdd); - printf("Added break on address %08x, with condition:\n%s %s %s\n", address, now->address, operandName, now->value); - workBreak = addConditionalBreak(address, flags); - now = (struct ConditionalBreakNode*)malloc(sizeof(struct ConditionalBreakNode)); - toAdd = now; - } - } else { - addCondition(workBreak, toAdd); - printf("Added break on address %08x, ending with condition: \n%s %s %s\n", address, now->address, operandName, now->value); - return; - } - } - return; - -fail: - printf("Not enough material (expressions) to work with."); - removeConditionalBreak(workBreak); - return; -} - -//aux -uint8_t parseExpressionType(char* given_type) -{ - uint8_t flags = 0; - //for such a small string, pays off to convert first - char* type = strdup(given_type); - for (int i = 0; type[i] != '\0'; i++) { - type[i] = toupper(type[i]); - } - if ((type[0] == 'S') || type[0] == 'U') { - flags |= (4 - ((type[0] - 'S') << 1)); - type++; - if (type[0] == 'H') { - type[0] = '1'; - type[1] = '6'; - type[2] = '\0'; - } else if (type[0] == 'W') { - type[0] = '3'; - type[1] = '2'; - type[2] = '\0'; - } else if (type[0] == 'B') { - type[0] = '8'; - type[1] = '\0'; - } - int size; - sscanf(type, "%d", &size); - size = (size >> 3) - 1; - flags |= (size >= 2 ? 2 : ((uint8_t)size)); - free(type); - return flags; - } - if (strcmp(type, "INT") == 0) { - flags = 6; - } - if (type[0] == 'H') { - flags = 1; - } else if (type[0] == 'W') { - flags = 2; - } else if (type[0] == 'B') { - flags = 0; - } else { - flags = 6; - } - free(type); - return flags; -} - -uint8_t parseConditionOperand(char* type) -{ - uint8_t flag = 0; - if (toupper(type[0]) == 'S') { - flag = 8; - type++; - } - switch (type[0]) { - case '!': - if (type[1] == '=' || type[1] == '\0') - return flag | 0x6; - break; - case '=': - if (type[1] == '=' || type[1] == '\0') - return flag | 0x1; - break; - case '<': - if (type[1] == '>') - return flag | 0x6; - if (type[1] == '=') - return flag | 0x5; - if (type[1] == '\0') - return flag | 0x4; - break; - case '>': - if (type[1] == '<') - return flag | 0x6; - if (type[1] == '=') - return flag | 0x3; - if (type[1] == '\0') - return flag | 0x2; - break; - default:; - } - switch (tolower(type[0])) { - case 'l': - if (tolower(type[1]) == 'e') - return flag | 0x5; - if (tolower(type[1]) == 't') - return flag | 0x4; - break; - case 'g': - if (tolower(type[1]) == 'e') - return flag | 0x3; - if (tolower(type[1]) == 't') - return flag | 0x2; - - case 'e': - if (tolower(type[1]) == 'q') - return flag | 0x1; - if (type[1] == '\0') - return flag | 0x1; - case 'n': - if (tolower(type[1]) == 'e') - return flag | 0x6; - default:; - } - return flag; -} - -uint32_t calculateFinalValue(char* expToEval, uint8_t type_of_flags) -{ - uint32_t val; - if (!dexp_eval(expToEval, &val)) { - printf("Invalid expression.\n"); - return 0; - } - if (type_of_flags & 0x4) { - switch (type_of_flags & 0x3) { - case 0: - return (int8_t)(val & 0xff); - case 1: - return (int16_t)(val & 0xffff); - default: - return (int)val; - } - } else { - switch (type_of_flags & 0x3) { - case 0: - return (uint8_t)(val & 0xff); - case 1: - return (uint16_t)(val & 0xffff); - default: - return val; - } - } -} - -//check for execution -bool isCorrectBreak(struct ConditionalBreak* toTest, uint8_t accessType) -{ - - return (toTest->type_flags & accessType); -} - -bool doBreak(struct ConditionalBreak* toTest) -{ - struct ConditionalBreakNode* toExamine = toTest->firstCond; - - bool globalVeredict = true; - bool veredict = false; - while (toExamine && globalVeredict) { - uint32_t address = calculateFinalValue(toExamine->address, toExamine->exp_type_flags & 0xf); - uint32_t value = calculateFinalValue(toExamine->value, toExamine->exp_type_flags >> 4); - if ((toExamine->cond_flags & 0x7) != 0) { - veredict = veredict || ((toExamine->cond_flags & 1) ? (address == value) : false); - veredict = veredict || ((toExamine->cond_flags & 4) ? ((toExamine->cond_flags & 8) ? ((int)address < (int)value) : (address < value)) : false); - veredict = veredict || ((toExamine->cond_flags & 2) ? ((toExamine->cond_flags & 8) ? ((int)address > (int)value) : (address > value)) : false); - } - toExamine = toExamine->next; - globalVeredict = veredict && globalVeredict; - } - return globalVeredict; -} - -bool doesBreak(uint32_t address, uint8_t allowedFlags) -{ - uint8_t addrNo = address >> 24; - if (conditionals[addrNo]) { - struct ConditionalBreak* base = conditionals[addrNo]; - while (base && base->break_address < address) { - base = base->next; - } - while (base && base->break_address == address) { - if (base->type_flags & allowedFlags & 0xf0) { - return true; - } - if (isCorrectBreak(base, allowedFlags) && doBreak(base)) { - return true; - } - base = base->next; - } - } - return false; -} - -/* -//Test main -int main (int argc, char** args){ - char* argv[] = {"r7","s==","0", "||","'byte","0x25","ge","'hword","0x0001"}; - parseAndCreateConditionalBreaks(0x0203fd00, 0x1f, argv, 9); - parseAndCreateConditionalBreaks(0x0203fd00, 0x10, argv, 9); - parseAndCreateConditionalBreaks(0x0203fd00, 0x40, argv, 9); - parseAndCreateConditionalBreaks(0x0203fd04, 0x04, argv, 9); - printAllFlagConditionals(0xff, true); - removeFlagFromConditionalBreakNo(0x0203fd00, 0x3,0xff); - printf("after\n"); - printAllFlagConditionals(0xff, true); - - getchar(); -} -*/ + [0x03005000] == 0x77777777 || 0x50 == [0x03005000] + Would make it break when the contents of 0x03005000 were either 0x77777777 or 0x50 + +Ex: to implement stop only when r2 is 0xf, use + if r2 == 0xf + to implement stop when PC is above 0x08005000 and 0x03005000 is signed halfword 0x2500 + if pc > 0x08005000 && 0x03005000 == +0x2500 +*/ + +/* +Full Operands lists +Op1, op2, ...,opN --> Meaning + +== , =, eq --> equal + +<, lt --> lesser than + +<=, le --> less or equal to + +> gt --> greater than + +>=, ge --> greater or equal to + +!=, <>, ne --> not equal to + + +valid content types +b, byte, uint8_t --> byte +sb, sbyte, int8_t --> signed byte +h,hw, halfword, uint16_t, ushort --> halfword +sh, shw, shalfword, int16_t short --> signed halfword +w, word, uint2_t --> word +sw, sword, int32_t, int --> signed word +*/ + +#include +#include +#include +#include + +#include "BreakpointStructures.h" +#include "remote.h" + +#if (defined __WIN32__ || defined _WIN32) +#define strdup _strdup +#endif + +extern bool dexp_eval(char*, uint32_t*); + +//struct intToString{ +// int value; +// char mapping[20]; +//}; + +struct ConditionalBreak* conditionals[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + +//struct intToString breakFlagMapping[] = { +// {0x80,"Thumb"}, +// {0x40,"ARM"}, +// {0x20,"Read"}, +// {0x10,"Write"}, +// {0x8,"Thumb"}, +// {0x4,"ARM"}, +// {0x2,"Read"}, +// {0x1,"Write"}, +// {0x0,"None"} +//}; +/* +struct intToString compareFlagMapping[] = { + {0x7,"Always"}, + {0x6,"!="}, + {0x5,"<="}, + {0x4,"<"}, + {0x3,">="}, + {0x2,">"}, + {0x1,"=="}, + {0x0,"Never"} +};*/ + +//char* typeMapping[] = {"'uint8_t","'uint16_t","'uint32_t","'uint32_t","'int8_t","'int16_t","'int32_t","'int32_t"}; +// +//char* compareFlagMapping[] = {"Never","==",">",">=","<","<=","!=","<=>"}; + +//Constructors +//case '*': flag = 0xf; break; +//case 't': flag = 0x8; break; // thumb +//case 'a': flag = 0x4; break; // arm +//case 'x': flag = 0xC; break; +//case 'r': flag = 0x2; break; // mem read +//case 'w': flag = 0x1; break; // mem write +//case 'i': flag = 0x3; break; +struct ConditionalBreak* addConditionalBreak(uint32_t address, uint8_t flag) +{ + uint8_t condIndex = address >> 24; + struct ConditionalBreak* cond = NULL; + BreakSet((&map[condIndex])->breakPoints, address & (&map[condIndex])->mask, ((flag & 0xf) | (flag >> 4))); + if (flag & 0xf0) { + struct ConditionalBreak* base = conditionals[condIndex]; + struct ConditionalBreak* prev = conditionals[condIndex]; + if (conditionals[condIndex]) { + while ((base) && (address >= base->break_address)) { + if (base->break_address == address) { + if (base->type_flags & 0xf0) { + base->type_flags |= (flag & 0xf0); + flag &= 0xf; + cond = base; + goto addCB_nextHandle; + } else { + goto condCreateForFlagAlways; + } + } else { + prev = base; + base = base->next; + } + } + } + condCreateForFlagAlways: + cond = (struct ConditionalBreak*)malloc(sizeof(struct ConditionalBreak)); + cond->break_address = address; + cond->type_flags = flag & 0xf0; + cond->next = base; + cond->firstCond = NULL; + if (prev == conditionals[condIndex]) + conditionals[condIndex] = cond; + else + prev->next = cond; + } + flag &= 0xf; + +addCB_nextHandle: + if (flag == 0) + return cond; + + cond = (struct ConditionalBreak*)malloc(sizeof(struct ConditionalBreak)); + cond->break_address = address; + cond->type_flags = flag; + cond->next = NULL; + cond->firstCond = NULL; + if (conditionals[condIndex] == NULL) { + conditionals[condIndex] = cond; + return cond; + } else { + struct ConditionalBreak *curr, *prev; + curr = conditionals[condIndex]; + prev = conditionals[condIndex]; + while (curr) { + if (curr->break_address > address) { + if (prev == curr) { + conditionals[condIndex] = cond; + } else { + prev->next = cond; + } + cond->next = curr; + return cond; + } + prev = curr; + curr = prev->next; + } + prev->next = cond; + return cond; + } +} + +void addCondition(struct ConditionalBreak* base, struct ConditionalBreakNode* toAdd) +{ + if (base->firstCond) { + struct ConditionalBreakNode *curr, *prev; + curr = base->firstCond; + prev = base->firstCond; + while (curr) { + prev = curr; + curr = curr->next; + } + prev->next = toAdd; + } else { + base->firstCond = toAdd; + } +} + +//destructors +void freeConditionalBreak(struct ConditionalBreak* toFree) +{ + struct ConditionalBreakNode* freeMe; + while (toFree->firstCond) { + freeMe = toFree->firstCond; + toFree->firstCond = toFree->firstCond->next; + free(freeMe); + } + free(toFree); +} + +void freeConditionalNode(struct ConditionalBreakNode* toDel) +{ + if (toDel->next) + freeConditionalNode(toDel->next); + if (toDel->address) + free(toDel->address); + if (toDel->value) + free(toDel->value); + free(toDel); +} + +void freeAllConditionals() +{ + for (int i = 0; i < 16; i++) { + while (conditionals[i]) { + struct ConditionalBreak* tmp = conditionals[i]; + conditionals[i] = conditionals[i]->next; + freeConditionalBreak(tmp); + } + } +} + +int removeConditionalBreak(struct ConditionalBreak* toDelete) +{ + if (toDelete) { + uint8_t condIndex = toDelete->break_address >> 24; + struct ConditionalBreak* base = conditionals[condIndex]; + struct ConditionalBreak* prev = conditionals[condIndex]; + while (base) { + if (base == toDelete) { + if (base == prev) { + conditionals[condIndex] = base->next; + } else { + prev->next = base->next; + } + freeConditionalBreak(toDelete); + return 0; + } + prev = base; + base = base->next; + } + return -1; //failed to remove + } + return -2; //delete failed because container was not there +} + +/* +int removeConditionalBreak(uint32_t address, uint8_t num, uint8_t flag){ + uint8_t condIndex = address>>24; + struct ConditionalBreak* base = conditionals[condIndex]; + struct ConditionalBreak* prev = conditionals[condIndex]; + uint8_t counter = 0; + while(base){ + if(base->break_address > address) + return -2; //failed to remove + if(base->break_address == address){ + counter++; + } + if(counter == num){ + base->type_flags &= ~flag; + if(base->type_flags == 0){ + if(prev == base){ + conditionals[condIndex] = base->next; + }else{ + prev->next = base->next; + } + freeConditionalBreak(base); + return 0; + } + return 1; + } + prev = base; + base = base->next; + } + return -2; +} + +bool removeCondition(struct ConditionalBreak* base, struct ConditionalBreakNode* toDel){ + if(base->firstCond){ + if(toDel == base->firstCond){ + base->firstCond = toDel->next; + freeConditionalNode(toDel); + return true; + } + struct ConditionalBreakNode* curr, *prev; + curr = base->firstCond; + prev = base->firstCond; + while(curr){ + if(curr == toDel){ + prev->next = curr->next; + freeConditionalNode(toDel); + return true; + } + prev = curr; + curr = curr->next; + } + } + freeConditionalNode(toDel); + return false; +} + +bool removeCondition(uint32_t address, uint8_t flags, uint8_t num){ + struct ConditionalBreak* base = conditionals[address>>24]; + while(base && base->break_address < address){ + base = base->next; + } + if(base && base->break_address == address){ + struct ConditionalBreakNode* curr = base->firstCond; + for(int i = 0; i < num; i++){ + if(!curr && ((!base) || (!base->next))){ + return false; + }if(!curr){ + while(!curr){ + base = base->next; + if(base->break_address > address) + return false; + + curr = base->firstCond; + } + } + } + } +}*/ + +/* +int removeAllConditions(uint32_t address, uint8_t flags){ + struct ConditionalBreak* base = conditionals[address>>24]; + while(base && base->break_address < address){ + base = base->next; + } + struct ConditionalBreak* curr = base; + while(base && base->break_address == address){ + base->type_flags &= ~flags; + if(!base->type_flags){ + curr = base; + base = base->next; + removeCondition(base); + } + } + return true; +}*/ + +void recountFlagsForAddress(uint32_t address) +{ + struct ConditionalBreak* base = conditionals[address >> 24]; + uint8_t flags = 0; + while (base) { + if (base->break_address < address) { + base = base->next; + } else { + if (base->break_address == address) { + flags |= base->type_flags; + } else { + BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, 0xff); + BreakSet((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags >> 4) | (flags & 0x8))); + return; + } + base = base->next; + } + } + BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, 0xff); + BreakSet((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags >> 4) | (flags & 0x8))); +} + +//Removers +int removeConditionalBreakNo(uint32_t addrNo, uint8_t number) +{ + if (conditionals[addrNo >> 24]) { + struct ConditionalBreak* base = conditionals[addrNo >> 24]; + struct ConditionalBreak* curr = conditionals[addrNo >> 24]; + while (curr->break_address < addrNo) { + base = curr; + curr = curr->next; + } + if (curr->break_address == addrNo) { + if (number == 1) { + if (base == curr) { + conditionals[addrNo >> 24] = curr->next; + freeConditionalBreak(curr); + } else { + base->next = curr->next; + freeConditionalBreak(curr); + } + recountFlagsForAddress(addrNo); + return 0; + } else { + int count = 1; + while (curr && (curr->break_address == addrNo)) { + if (count == number) { + base->next = curr->next; + freeConditionalBreak(curr); + recountFlagsForAddress(addrNo); + return 1; + } + count++; + base = curr; + curr = curr->next; + } + return -1; + } + } + } + return -2; +} + +int removeFlagFromConditionalBreakNo(uint32_t addrNo, uint8_t number, uint8_t flag) +{ + if (conditionals[addrNo >> 24]) { + struct ConditionalBreak* base = conditionals[addrNo >> 24]; + struct ConditionalBreak* curr = conditionals[addrNo >> 24]; + while (curr->break_address < addrNo) { + base = curr; + curr = curr->next; + } + if (curr->break_address == addrNo) { + if (number == 1) { + curr->type_flags &= ~flag; + if (curr->type_flags == 0) { + if (base == curr) { + conditionals[addrNo >> 24] = curr->next; + freeConditionalBreak(curr); + } else { + base->next = curr->next; + freeConditionalBreak(curr); + } + } + recountFlagsForAddress(addrNo); + return 0; + } else { + int count = 1; + while (curr && (curr->break_address == addrNo)) { + if (count == number) { + curr->type_flags &= ~flag; + if (!curr->type_flags) { + base->next = curr->next; + freeConditionalBreak(curr); + recountFlagsForAddress(addrNo); + return 1; + } + recountFlagsForAddress(addrNo); + return 0; + } + count++; + base = curr; + curr = curr->next; + } + return -1; + } + } + } + return -2; +} + +int removeConditionalWithAddress(uint32_t address) +{ + uint8_t addrNo = address >> 24; + if (conditionals[addrNo] != NULL) { + struct ConditionalBreak* base = conditionals[addrNo]; + struct ConditionalBreak* curr = conditionals[addrNo]; + uint8_t count = 0; + uint8_t flags = 0; + while (curr && address >= curr->break_address) { + if (curr->break_address == address) { + base->next = curr->next; + flags |= curr->type_flags; + freeConditionalBreak(curr); + curr = base->next; + count++; + } else { + base = curr; + curr = curr->next; + } + } + BreakClear((&map[address >> 24])->breakPoints, address & (&map[address >> 24])->mask, ((flags & 0xf) | (flags >> 4))); + return count; + } + return -2; +} + +int removeConditionalWithFlag(uint8_t flag, bool orMode) +{ + for (uint8_t addrNo = 0; addrNo < 16; addrNo++) { + if (conditionals[addrNo] != NULL) { + struct ConditionalBreak* base = conditionals[addrNo]; + struct ConditionalBreak* curr = conditionals[addrNo]; + uint8_t count = 0; + while (curr) { + if (((curr->type_flags & flag) == curr->type_flags) || (orMode && (curr->type_flags & flag))) { + curr->type_flags &= ~flag; + BreakClear((&map[addrNo])->breakPoints, curr->break_address & (&map[addrNo])->mask, ((flag & 0xf) | (flag >> 4))); + if (curr->type_flags == 0) { + if (base == conditionals[addrNo]) { + conditionals[addrNo] = curr->next; + base = curr->next; + curr = base; + } else { + base->next = curr->next; + freeConditionalBreak(curr); + curr = base->next; + } + count++; + } else { + base = curr; + curr = curr->next; + } + } else { + base = curr; + curr = curr->next; + } + } + return count; + } + } + return -2; +} + +int removeConditionalWithAddressAndFlag(uint32_t address, uint8_t flag, bool orMode) +{ + uint8_t addrNo = address >> 24; + if (conditionals[addrNo] != NULL) { + struct ConditionalBreak* base = conditionals[addrNo]; + struct ConditionalBreak* curr = conditionals[addrNo]; + uint8_t count = 0; + while (curr && address >= curr->break_address) { + if ((curr->break_address == address) && (((curr->type_flags & flag) == curr->type_flags) || (orMode && (curr->type_flags & flag)))) { + curr->type_flags &= ~flag; + BreakClear((&map[address >> 24])->breakPoints, curr->break_address & (&map[address >> 24])->mask, ((flag & 0xf) | (flag >> 4))); + if (curr->type_flags == 0) { + if (curr == conditionals[addrNo]) { + conditionals[addrNo] = curr->next; + freeConditionalBreak(curr); + curr = conditionals[addrNo]; + } else { + base->next = curr->next; + freeConditionalBreak(curr); + curr = base->next; + } + count++; + } else { + base = curr; + curr = curr->next; + } + } else { + base = curr; + curr = curr->next; + } + } + return count; + } + return -2; +} + +//true creating code for a given expression. +//It assumes an if was found, and that all up to the if was removed. +//receives an array of chars following the pattern: +//{',,,',,, (repeats) +//next = 0; + now->exp_type_flags = 0; + if (exp[i][0] == '\'') { + now->exp_type_flags |= parseExpressionType(&exp[i][1]); + i++; + if (i >= n) + goto fail; + } else { + now->exp_type_flags |= 6; //assume signed word + } + now->address = strdup(exp[i]); + i++; + if (i >= n) + goto fail; + char* operandName = exp[i]; + now->cond_flags = parseConditionOperand(exp[i]); + i++; + if (i >= n) + goto fail; + + if (exp[i][0] == '\'') { + now->exp_type_flags |= (parseExpressionType(&exp[i][1]) << 4); + i++; + if (i >= n) + goto fail; + } else { + now->exp_type_flags |= 0x60; //assume signed word + } + now->value = strdup(exp[i]); + i++; + uint32_t val; + if (!dexp_eval(now->value, &val) || !dexp_eval(now->address, &val)) { + printf("Invalid expression.\n"); + if (workBreak) + removeConditionalBreak(workBreak); + return; + } + if (i < n) { + if (strcmp(exp[i], "&&") == 0) { + now = (struct ConditionalBreakNode*)malloc(sizeof(struct ConditionalBreakNode)); + toAdd->next = now; + } else if (strcmp(exp[i], "||") == 0) { + addCondition(workBreak, toAdd); + printf("Added break on address %08x, with condition:\n%s %s %s\n", address, now->address, operandName, now->value); + workBreak = addConditionalBreak(address, flags); + now = (struct ConditionalBreakNode*)malloc(sizeof(struct ConditionalBreakNode)); + toAdd = now; + } + } else { + addCondition(workBreak, toAdd); + printf("Added break on address %08x, ending with condition: \n%s %s %s\n", address, now->address, operandName, now->value); + return; + } + } + return; + +fail: + printf("Not enough material (expressions) to work with."); + removeConditionalBreak(workBreak); + return; +} + +//aux +uint8_t parseExpressionType(char* given_type) +{ + uint8_t flags = 0; + //for such a small string, pays off to convert first + char* type = strdup(given_type); + for (int i = 0; type[i] != '\0'; i++) { + type[i] = toupper(type[i]); + } + if ((type[0] == 'S') || type[0] == 'U') { + flags |= (4 - ((type[0] - 'S') << 1)); + type++; + if (type[0] == 'H') { + type[0] = '1'; + type[1] = '6'; + type[2] = '\0'; + } else if (type[0] == 'W') { + type[0] = '3'; + type[1] = '2'; + type[2] = '\0'; + } else if (type[0] == 'B') { + type[0] = '8'; + type[1] = '\0'; + } + int size; + sscanf(type, "%d", &size); + size = (size >> 3) - 1; + flags |= (size >= 2 ? 2 : ((uint8_t)size)); + free(type); + return flags; + } + if (strcmp(type, "INT") == 0) { + flags = 6; + } + if (type[0] == 'H') { + flags = 1; + } else if (type[0] == 'W') { + flags = 2; + } else if (type[0] == 'B') { + flags = 0; + } else { + flags = 6; + } + free(type); + return flags; +} + +uint8_t parseConditionOperand(char* type) +{ + uint8_t flag = 0; + if (toupper(type[0]) == 'S') { + flag = 8; + type++; + } + switch (type[0]) { + case '!': + if (type[1] == '=' || type[1] == '\0') + return flag | 0x6; + break; + case '=': + if (type[1] == '=' || type[1] == '\0') + return flag | 0x1; + break; + case '<': + if (type[1] == '>') + return flag | 0x6; + if (type[1] == '=') + return flag | 0x5; + if (type[1] == '\0') + return flag | 0x4; + break; + case '>': + if (type[1] == '<') + return flag | 0x6; + if (type[1] == '=') + return flag | 0x3; + if (type[1] == '\0') + return flag | 0x2; + break; + default:; + } + switch (tolower(type[0])) { + case 'l': + if (tolower(type[1]) == 'e') + return flag | 0x5; + if (tolower(type[1]) == 't') + return flag | 0x4; + break; + case 'g': + if (tolower(type[1]) == 'e') + return flag | 0x3; + if (tolower(type[1]) == 't') + return flag | 0x2; + break; + + case 'e': + if (tolower(type[1]) == 'q') + return flag | 0x1; + if (type[1] == '\0') + return flag | 0x1; + break; + case 'n': + if (tolower(type[1]) == 'e') + return flag | 0x6; + default: + break; + } + return flag; +} + +uint32_t calculateFinalValue(char* expToEval, uint8_t type_of_flags) +{ + uint32_t val; + if (!dexp_eval(expToEval, &val)) { + printf("Invalid expression.\n"); + return 0; + } + if (type_of_flags & 0x4) { + switch (type_of_flags & 0x3) { + case 0: + return (int8_t)(val & 0xff); + case 1: + return (int16_t)(val & 0xffff); + default: + return (int)val; + } + } else { + switch (type_of_flags & 0x3) { + case 0: + return (uint8_t)(val & 0xff); + case 1: + return (uint16_t)(val & 0xffff); + default: + return val; + } + } +} + +//check for execution +bool isCorrectBreak(struct ConditionalBreak* toTest, uint8_t accessType) +{ + + return (toTest->type_flags & accessType); +} + +bool doBreak(struct ConditionalBreak* toTest) +{ + struct ConditionalBreakNode* toExamine = toTest->firstCond; + + bool globalVeredict = true; + bool veredict = false; + while (toExamine && globalVeredict) { + uint32_t address = calculateFinalValue(toExamine->address, toExamine->exp_type_flags & 0xf); + uint32_t value = calculateFinalValue(toExamine->value, toExamine->exp_type_flags >> 4); + if ((toExamine->cond_flags & 0x7) != 0) { + veredict = veredict || ((toExamine->cond_flags & 1) ? (address == value) : false); + veredict = veredict || ((toExamine->cond_flags & 4) ? ((toExamine->cond_flags & 8) ? ((int)address < (int)value) : (address < value)) : false); + veredict = veredict || ((toExamine->cond_flags & 2) ? ((toExamine->cond_flags & 8) ? ((int)address > (int)value) : (address > value)) : false); + } + toExamine = toExamine->next; + globalVeredict = veredict && globalVeredict; + } + return globalVeredict; +} + +bool doesBreak(uint32_t address, uint8_t allowedFlags) +{ + uint8_t addrNo = address >> 24; + if (conditionals[addrNo]) { + struct ConditionalBreak* base = conditionals[addrNo]; + while (base && base->break_address < address) { + base = base->next; + } + while (base && base->break_address == address) { + if (base->type_flags & allowedFlags & 0xf0) { + return true; + } + if (isCorrectBreak(base, allowedFlags) && doBreak(base)) { + return true; + } + base = base->next; + } + } + return false; +} + +/* +//Test main +int main (int argc, char** args){ + char* argv[] = {"r7","s==","0", "||","'byte","0x25","ge","'hword","0x0001"}; + parseAndCreateConditionalBreaks(0x0203fd00, 0x1f, argv, 9); + parseAndCreateConditionalBreaks(0x0203fd00, 0x10, argv, 9); + parseAndCreateConditionalBreaks(0x0203fd00, 0x40, argv, 9); + parseAndCreateConditionalBreaks(0x0203fd04, 0x04, argv, 9); + printAllFlagConditionals(0xff, true); + removeFlagFromConditionalBreakNo(0x0203fd00, 0x3,0xff); + printf("after\n"); + printAllFlagConditionals(0xff, true); + + getchar(); +} +*/ diff --git a/src/gba/Cheats.cpp b/src/gba/Cheats.cpp index bf0c2202..0c59678c 100644 --- a/src/gba/Cheats.cpp +++ b/src/gba/Cheats.cpp @@ -2055,15 +2055,15 @@ bool cheatsImportGSACodeFile(const char* name, int game, bool v3) found = true; break; } - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); fseek(f, len, SEEK_CUR); int codes = 0; - fread(&codes, 1, 4, f); + FREAD_UNCHECKED(&codes, 1, 4, f); while (codes > 0) { - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); fseek(f, len, SEEK_CUR); fseek(f, 8, SEEK_CUR); - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); fseek(f, len * 12, SEEK_CUR); codes--; } @@ -2073,26 +2073,26 @@ bool cheatsImportGSACodeFile(const char* name, int game, bool v3) if (found) { char desc[256]; char code[17]; - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); fseek(f, len, SEEK_CUR); int codes = 0; - fread(&codes, 1, 4, f); + FREAD_UNCHECKED(&codes, 1, 4, f); while (codes > 0) { - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); if (len > 255) goto evil_gsa_code_file; //XXX: this functione needs a rewrite in general, so for the short this is better than nothing - fread(desc, 1, len, f); + FREAD_UNCHECKED(desc, 1, len, f); desc[len] = 0; desc[31] = 0; - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); fseek(f, len, SEEK_CUR); fseek(f, 4, SEEK_CUR); - fread(&len, 1, 4, f); + FREAD_UNCHECKED(&len, 1, 4, f); while (len) { fseek(f, 4, SEEK_CUR); - fread(code, 1, 8, f); + FREAD_UNCHECKED(code, 1, 8, f); fseek(f, 4, SEEK_CUR); - fread(&code[8], 1, 8, f); + FREAD_UNCHECKED(&code[8], 1, 8, f); code[16] = 0; cheatsAddGSACode(code, desc, v3); len -= 2; @@ -2734,16 +2734,16 @@ bool cheatsLoadCheatList(const char* file) } } else if (type == 0) { for (int i = 0; i < count; i++) { - fread(&cheatsList[i].code, 1, sizeof(int), f); - fread(&cheatsList[i].size, 1, sizeof(int), f); - fread(&cheatsList[i].status, 1, sizeof(int), f); - fread(&cheatsList[i].enabled, 1, sizeof(int), f); + FREAD_UNCHECKED(&cheatsList[i].code, 1, sizeof(int), f); + FREAD_UNCHECKED(&cheatsList[i].size, 1, sizeof(int), f); + FREAD_UNCHECKED(&cheatsList[i].status, 1, sizeof(int), f); + FREAD_UNCHECKED(&cheatsList[i].enabled, 1, sizeof(int), f); cheatsList[i].enabled = cheatsList[i].enabled ? true : false; - fread(&cheatsList[i].address, 1, sizeof(uint32_t), f); + FREAD_UNCHECKED(&cheatsList[i].address, 1, sizeof(uint32_t), f); cheatsList[i].rawaddress = cheatsList[i].address; - fread(&cheatsList[i].value, 1, sizeof(uint32_t), f); - fread(&cheatsList[i].oldValue, 1, sizeof(uint32_t), f); - fread(&cheatsList[i].codestring, 1, 20 * sizeof(char), f); + FREAD_UNCHECKED(&cheatsList[i].value, 1, sizeof(uint32_t), f); + FREAD_UNCHECKED(&cheatsList[i].oldValue, 1, sizeof(uint32_t), f); + FREAD_UNCHECKED(&cheatsList[i].codestring, 1, 20 * sizeof(char), f); if (fread(&cheatsList[i].desc, 1, 32 * sizeof(char), f) != 32 * sizeof(char)) { fclose(f); return false; diff --git a/src/gba/GBA.cpp b/src/gba/GBA.cpp index eb90a2aa..c0cc468b 100644 --- a/src/gba/GBA.cpp +++ b/src/gba/GBA.cpp @@ -1007,21 +1007,21 @@ bool CPUReadGSASnapshot(const char* fileName) // long size = ftell(file); fseek(file, 0x0, SEEK_SET); - fread(&i, 1, 4, file); + FREAD_UNCHECKED(&i, 1, 4, file); fseek(file, i, SEEK_CUR); // Skip SharkPortSave fseek(file, 4, SEEK_CUR); // skip some sort of flag - fread(&i, 1, 4, file); // name length + FREAD_UNCHECKED(&i, 1, 4, file); // name length fseek(file, i, SEEK_CUR); // skip name - fread(&i, 1, 4, file); // desc length + FREAD_UNCHECKED(&i, 1, 4, file); // desc length fseek(file, i, SEEK_CUR); // skip desc - fread(&i, 1, 4, file); // notes length + FREAD_UNCHECKED(&i, 1, 4, file); // notes length fseek(file, i, SEEK_CUR); // skip notes int saveSize; - fread(&saveSize, 1, 4, file); // read length + FREAD_UNCHECKED(&saveSize, 1, 4, file); // read length saveSize -= 0x1c; // remove header size char buffer[17]; char buffer2[17]; - fread(buffer, 1, 16, file); + FREAD_UNCHECKED(buffer, 1, 16, file); buffer[16] = 0; for (i = 0; i < 16; i++) if (buffer[i] < 32) @@ -1074,7 +1074,7 @@ bool CPUReadGSASPSnapshot(const char* fileName) // read save name fseek(file, namepos, SEEK_SET); - fread(savename, 1, namesz, file); + FREAD_UNCHECKED(savename, 1, namesz, file); savename[namesz] = 0; memcpy(romname, &rom[0xa0], namesz); @@ -1091,7 +1091,7 @@ bool CPUReadGSASPSnapshot(const char* fileName) // read footer tag fseek(file, footerpos, SEEK_SET); - fread(footer, 1, footersz, file); + FREAD_UNCHECKED(footer, 1, footersz, file); footer[footersz] = 0; if (memcmp(footer, gsvfooter, footersz)) { @@ -1106,7 +1106,7 @@ bool CPUReadGSASPSnapshot(const char* fileName) } // Read up to 128k save - fread(flashSaveMemory, 1, FLASH_128K_SZ, file); + FREAD_UNCHECKED(flashSaveMemory, 1, FLASH_128K_SZ, file); fclose(file); CPUReset(); diff --git a/src/gba/GBA.h b/src/gba/GBA.h index b45fed9f..8649b2e5 100644 --- a/src/gba/GBA.h +++ b/src/gba/GBA.h @@ -3,6 +3,7 @@ #include "../common/Types.h" #include "../System.h" +#include "../Util.h" const uint64_t TICKS_PER_SECOND = 16777216; diff --git a/src/gba/GBALink.cpp b/src/gba/GBALink.cpp index 560e6927..ba7c2691 100644 --- a/src/gba/GBALink.cpp +++ b/src/gba/GBALink.cpp @@ -609,6 +609,7 @@ void EnableSpeedHacks(bool enable) void BootLink(int m_type, const char* hostAddr, int timeout, bool m_hacks, int m_numplayers) { + (void)m_numplayers; // unused param if (linkDriver) { // Connection has already been established return; @@ -888,7 +889,7 @@ bool CableServer::RecvGB(void) if (counter == 1) return false; - int numbytes; + int numbytes = 0; if (lanlink.type == 0) { // TCP fdset.clear(); @@ -1230,6 +1231,7 @@ void StartCableSocket(uint16_t value) static void UpdateCableSocket(int ticks) { + (void)ticks; // unused param if (linkid && transfer_direction == SENDING && lc.transferring && linktime >= transfer_start_time_from_master) { cable_data[linkid] = READ16LE(&ioMem[COMM_SIODATA8]); @@ -2199,7 +2201,8 @@ static void StartRFUSocket(uint16_t value) case 0x24: // send [non-important] data (used by server often) rfu_data.rfu_linktime[linkid] = linktime; //save the ticks before reseted to zero - if (rfu_cansend && rfu_qsend2 >= 0) { + // rfu_qsend2 >= 0 due to being `uint8_t` + if (rfu_cansend) { if (rfu_ishost) { for (int j = 0; j < rfu_data.numgbas; j++) if (j != linkid) { @@ -2560,7 +2563,7 @@ uint16_t gbLinkUpdate(uint8_t b, int gbSerialOn) //used on external clock rfu_enabled = false; if (gbSerialOn) { - if (gba_link_enabled) + if (gba_link_enabled) { //Single Computer if (GetLinkMode() == LINK_GAMEBOY_IPC) { #if (defined __WIN32__ || defined _WIN32) @@ -2595,7 +2598,7 @@ uint16_t gbLinkUpdate(uint8_t b, int gbSerialOn) //used on external clock } } } - + } if (dat == 0xff /*||dat==0x00||b==0x00*/) //dat==0xff||dat==0x00 LinkFirstTime = true; } diff --git a/src/gba/GBASockClient.cpp b/src/gba/GBASockClient.cpp index 57c4ecb2..56163213 100644 --- a/src/gba/GBASockClient.cpp +++ b/src/gba/GBASockClient.cpp @@ -59,6 +59,7 @@ char GBASockClient::ReceiveCmd(char* data_in, bool block) void GBASockClient::ReceiveClock(bool block) { + (void)block; // unused param if (IsDisconnected()) return; diff --git a/src/gba/GBAinline.h b/src/gba/GBAinline.h index 6cca2173..0fc9d869 100644 --- a/src/gba/GBAinline.h +++ b/src/gba/GBAinline.h @@ -56,7 +56,7 @@ static inline uint32_t CPUReadMemory(uint32_t address) } } #endif - uint32_t value; + uint32_t value = 0; uint32_t oldAddress = address; if (address & 3) { diff --git a/src/gba/debugger-expr-yacc.cpp b/src/gba/debugger-expr-yacc.cpp index 1e33a505..3f57b14e 100644 --- a/src/gba/debugger-expr-yacc.cpp +++ b/src/gba/debugger-expr-yacc.cpp @@ -1,1753 +1,1753 @@ -/* A Bison parser, made by GNU Bison 2.3. */ - -/* Skeleton implementation for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.3" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - -#define yyparse dexp_parse -#define yylex dexp_lex -#define yyerror dexp_error -#define yylval dexp_lval -#define yychar dexp_char -#define yydebug dexp_debug -#define yynerrs dexp_nerrs - -/* Tokens. */ -#ifndef YYTOKENTYPE -#define YYTOKENTYPE -/* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ -enum yytokentype { - TOK_PLUS = 258, - TOK_MINUS = 259, - TOK_DIVIDE = 260, - TOK_MULTIPLY = 261, - TOK_LSHIFT = 262, - TOK_RSHIFT = 263, - TOK_LPAREN = 264, - TOK_RPAREN = 265, - TOK_OR = 266, - TOK_AND = 267, - TOK_XOR = 268, - TOK_NEGATE = 269, - TOK_BBRACKET = 270, - TOK_HBRACKET = 271, - TOK_WBRACKET = 272, - TOK_LBRACKET = 273, - TOK_RBRACKET = 274, - TOK_REGISTER = 275, - TOK_NUMBER = 276, - TOK_ID = 277 -}; -#endif -/* Tokens. */ -#define TOK_PLUS 258 -#define TOK_MINUS 259 -#define TOK_DIVIDE 260 -#define TOK_MULTIPLY 261 -#define TOK_LSHIFT 262 -#define TOK_RSHIFT 263 -#define TOK_LPAREN 264 -#define TOK_RPAREN 265 -#define TOK_OR 266 -#define TOK_AND 267 -#define TOK_XOR 268 -#define TOK_NEGATE 269 -#define TOK_BBRACKET 270 -#define TOK_HBRACKET 271 -#define TOK_WBRACKET 272 -#define TOK_LBRACKET 273 -#define TOK_RBRACKET 274 -#define TOK_REGISTER 275 -#define TOK_NUMBER 276 -#define TOK_ID 277 - -/* Copy the first part of user declarations. */ -#line 1 "src/sdl/debugger-expr.y" - -#include - -#include "../System.h" -#include "../common/Port.h" -#include "GBA.h" - -#include -#include -#include - -unsigned int dexp_result = 0; -extern int dexp_error(char*); -extern int dexp_lex(); -extern char* dexp_text; - -std::map dexp_vars; - -#define readWord(addr) \ - READ32LE((&map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask])) - -#define readHalfWord(addr) \ - READ16LE((&map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask])) - -#define readByte(addr) \ - map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask] - -/* Enabling traces. */ -#ifndef YYDEBUG -#define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -#undef YYERROR_VERBOSE -#define YYERROR_VERBOSE 1 -#else -#define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -#define YYTOKEN_TABLE 0 -#endif - -#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 44 "src/sdl/debugger-expr.y" -{ - unsigned int number; - char* string; -} -/* Line 187 of yacc.c. */ -#line 175 "src/sdl/debugger-expr-yacc.cpp" -YYSTYPE; -#define yystype YYSTYPE /* obsolescent; will be withdrawn */ -#define YYSTYPE_IS_DECLARED 1 -#define YYSTYPE_IS_TRIVIAL 1 -#endif - -/* Copy the second part of user declarations. */ - -/* Line 216 of yacc.c. */ -#line 188 "src/sdl/debugger-expr-yacc.cpp" - -#ifdef short -#undef short -#endif - -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; -#endif - -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -typedef signed char yytype_int8; -#else -typedef short int yytype_int8; -#endif - -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; -#else -typedef unsigned short int yytype_uint16; -#endif - -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; -#else -typedef short int yytype_int16; -#endif - -#ifndef YYSIZE_T -#ifdef __SIZE_TYPE__ -#define YYSIZE_T __SIZE_TYPE__ -#elif defined size_t -#define YYSIZE_T size_t -#elif !defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -#include /* INFRINGES ON USER NAME SPACE */ -#define YYSIZE_T size_t -#else -#define YYSIZE_T unsigned int -#endif -#endif - -#define YYSIZE_MAXIMUM ((YYSIZE_T)-1) - -#ifndef YY_ -#if YYENABLE_NLS -#if ENABLE_NLS -#include /* INFRINGES ON USER NAME SPACE */ -#define YY_(msgid) dgettext("bison-runtime", msgid) -#endif -#endif -#ifndef YY_ -#define YY_(msgid) msgid -#endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if !defined lint || defined __GNUC__ -#define YYUSE(e) ((void)(e)) -#else -#define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -#define YYID(n) (n) -#else -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static int -YYID(int i) -#else -static int - YYID(i) int i; -#endif -{ - return i; -} -#endif - -#if !defined yyoverflow || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -#ifdef YYSTACK_USE_ALLOCA -#if YYSTACK_USE_ALLOCA -#ifdef __GNUC__ -#define YYSTACK_ALLOC __builtin_alloca -#elif defined __BUILTIN_VA_ARG_INCR -#include /* INFRINGES ON USER NAME SPACE */ -#elif defined _AIX -#define YYSTACK_ALLOC __alloca -#elif defined _MSC_VER -#include /* INFRINGES ON USER NAME SPACE */ -#define alloca _alloca -#else -#define YYSTACK_ALLOC alloca -#if !defined _ALLOCA_H && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -#include /* INFRINGES ON USER NAME SPACE */ -#ifndef _STDLIB_H -#define _STDLIB_H 1 -#endif -#endif -#endif -#endif -#endif - -#ifdef YYSTACK_ALLOC -/* Pacify GCC's `empty if-body' warning. */ -#define YYSTACK_FREE(Ptr) \ - do { /* empty */ \ - ; \ - } while (YYID(0)) -#ifndef YYSTACK_ALLOC_MAXIMUM -/* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -#define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -#endif -#else -#define YYSTACK_ALLOC YYMALLOC -#define YYSTACK_FREE YYFREE -#ifndef YYSTACK_ALLOC_MAXIMUM -#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -#endif -#if (defined __cplusplus && !defined _STDLIB_H \ - && !((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -#include /* INFRINGES ON USER NAME SPACE */ -#ifndef _STDLIB_H -#define _STDLIB_H 1 -#endif -#endif -#ifndef YYMALLOC -#define YYMALLOC malloc -#if !defined malloc && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void* malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -#endif -#endif -#ifndef YYFREE -#define YYFREE free -#if !defined free && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void free(void*); /* INFRINGES ON USER NAME SPACE */ -#endif -#endif -#endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - -#if (!defined yyoverflow \ - && (!defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc { - yytype_int16 yyss; - YYSTYPE yyvs; -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -#define YYSTACK_GAP_MAXIMUM (sizeof(union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -#define YYSTACK_BYTES(N) \ - ((N) * (sizeof(yytype_int16) + sizeof(YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -#ifndef YYCOPY -#if defined __GNUC__ && 1 < __GNUC__ -#define YYCOPY(To, From, Count) \ - __builtin_memcpy(To, From, (Count) * sizeof(*(From))) -#else -#define YYCOPY(To, From, Count) \ - do { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } while (YYID(0)) -#endif -#endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -#define YYSTACK_RELOCATE(Stack) \ - do { \ - YYSIZE_T yynewbytes; \ - YYCOPY(&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof(*yyptr); \ - } while (YYID(0)) - -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 20 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 135 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 23 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 3 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 21 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 44 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 277 - -#define YYTRANSLATE(YYX) \ - ((unsigned int)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const yytype_uint8 yytranslate[] = { - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22 -}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const yytype_uint8 yyprhs[] = { - 0, 0, 3, 5, 7, 9, 13, 17, 20, 23, - 27, 31, 35, 39, 43, 47, 51, 55, 57, 61, - 65, 69 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int8 yyrhs[] = { - 24, 0, -1, 25, -1, 21, -1, 22, -1, 25, - 3, 25, -1, 25, 4, 25, -1, 4, 25, -1, - 14, 25, -1, 25, 5, 25, -1, 25, 6, 25, - -1, 25, 7, 25, -1, 25, 8, 25, -1, 9, - 25, 10, -1, 25, 12, 25, -1, 25, 11, 25, - -1, 25, 13, 25, -1, 20, -1, 15, 25, 19, - -1, 16, 25, 19, -1, 17, 25, 19, -1, 18, - 25, 19, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const yytype_uint8 yyrline[] = { - 0, 56, 56, 59, 60, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84 -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char* const yytname[] = { - "$end", "error", "$undefined", "TOK_PLUS", "TOK_MINUS", "TOK_DIVIDE", - "TOK_MULTIPLY", "TOK_LSHIFT", "TOK_RSHIFT", "TOK_LPAREN", "TOK_RPAREN", - "TOK_OR", "TOK_AND", "TOK_XOR", "TOK_NEGATE", "TOK_BBRACKET", - "TOK_HBRACKET", "TOK_WBRACKET", "TOK_LBRACKET", "TOK_RBRACKET", - "TOK_REGISTER", "TOK_NUMBER", "TOK_ID", "$accept", "final", "exp", 0 -}; -#endif - -#ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const yytype_uint16 yytoknum[] = { - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277 -}; -#endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = { - 0, 23, 24, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 25 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = { - 0, 2, 1, 1, 1, 3, 3, 2, 2, 3, - 3, 3, 3, 3, 3, 3, 3, 1, 3, 3, - 3, 3 -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const yytype_uint8 yydefact[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 17, 3, - 4, 0, 2, 7, 0, 8, 0, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 13, 18, 19, 20, 21, 5, 6, 9, 10, 11, - 12, 15, 14, 16 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int8 yydefgoto[] = { - -1, 11, 12 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -2 -static const yytype_int8 yypact[] = { - 25, 25, 25, 25, 25, 25, 25, 25, -2, -2, - -2, 13, 113, 122, 4, 122, 45, 62, 79, 96, - -2, 25, 25, 25, 25, 25, 25, 25, 25, 25, - -2, -2, -2, -2, -2, 122, 122, 24, 24, 48, - 48, 6, 17, -2 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int8 yypgoto[] = { - -2, -2, -1 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -1 -static const yytype_uint8 yytable[] = { - 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, - 24, 25, 26, 20, 30, 27, 28, 29, 28, 29, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 1, - 29, 25, 26, 0, 2, 27, 28, 29, 0, 3, - 4, 5, 6, 7, 0, 8, 9, 10, 21, 22, - 23, 24, 25, 26, 0, 0, 27, 28, 29, 27, - 28, 29, 0, 0, 31, 21, 22, 23, 24, 25, - 26, 0, 0, 27, 28, 29, 0, 0, 0, 0, - 0, 32, 21, 22, 23, 24, 25, 26, 0, 0, - 27, 28, 29, 0, 0, 0, 0, 0, 33, 21, - 22, 23, 24, 25, 26, 0, 0, 27, 28, 29, - 0, 0, 0, 0, 0, 34, 21, 22, 23, 24, - 25, 26, 0, 0, 27, 28, 29, 23, 24, 25, - 26, 0, 0, 27, 28, 29 -}; - -static const yytype_int8 yycheck[] = { - 1, 2, 3, 4, 5, 6, 7, 3, 4, 5, - 6, 7, 8, 0, 10, 11, 12, 13, 12, 13, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 4, - 13, 7, 8, -1, 9, 11, 12, 13, -1, 14, - 15, 16, 17, 18, -1, 20, 21, 22, 3, 4, - 5, 6, 7, 8, -1, -1, 11, 12, 13, 11, - 12, 13, -1, -1, 19, 3, 4, 5, 6, 7, - 8, -1, -1, 11, 12, 13, -1, -1, -1, -1, - -1, 19, 3, 4, 5, 6, 7, 8, -1, -1, - 11, 12, 13, -1, -1, -1, -1, -1, 19, 3, - 4, 5, 6, 7, 8, -1, -1, 11, 12, 13, - -1, -1, -1, -1, -1, 19, 3, 4, 5, 6, - 7, 8, -1, -1, 11, 12, 13, 5, 6, 7, - 8, -1, -1, 11, 12, 13 -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = { - 0, 4, 9, 14, 15, 16, 17, 18, 20, 21, - 22, 24, 25, 25, 25, 25, 25, 25, 25, 25, - 0, 3, 4, 5, 6, 7, 8, 11, 12, 13, - 10, 19, 19, 19, 19, 25, 25, 25, 25, 25, - 25, 25, 25, 25 -}; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto yyerrlab - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ - \ -do if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE(yychar); \ - YYPOPSTACK(1); \ - goto yybackup; \ - } \ - else \ - { \ - yyerror(YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ - \ -while(YYID(0)) - -#define YYTERROR 1 -#define YYERRCODE 256 - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -#define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID(N)) { \ - (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC(Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC(Rhs, N).last_column; \ - } else { \ - (Current).first_line = (Current).last_line = YYRHSLOC(Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = YYRHSLOC(Rhs, 0).last_column; \ - } \ - while (YYID(0)) -#endif - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -#if YYLTYPE_IS_TRIVIAL -#define YY_LOCATION_PRINT(File, Loc) \ - fprintf(File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -#else -#define YY_LOCATION_PRINT(File, Loc) ((void)0) -#endif -#endif - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -#define YYLEX yylex(YYLEX_PARAM) -#else -#define YYLEX yylex() -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -#ifndef YYFPRINTF -#include /* INFRINGES ON USER NAME SPACE */ -#define YYFPRINTF fprintf -#endif - -#define YYDPRINTF(Args) \ - \ -do \ - { \ - if (yydebug) \ - YYFPRINTF Args; \ - \ -} \ - while (YYID(0)) - -#define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ - \ -do \ - { \ - if (yydebug) { \ - YYFPRINTF(stderr, "%s ", Title); \ - yy_symbol_print(stderr, \ - Type, Value); \ - YYFPRINTF(stderr, "\n"); \ - } \ - \ -} \ - while (YYID(0)) - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_value_print(FILE* yyoutput, int yytype, YYSTYPE const* const yyvaluep) -#else -static void - yy_symbol_value_print(yyoutput, yytype, yyvaluep) - FILE* yyoutput; -int yytype; -YYSTYPE const* const yyvaluep; -#endif -{ - if (!yyvaluep) - return; -#ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT(yyoutput, yytoknum[yytype], *yyvaluep); -#else - YYUSE(yyoutput); -#endif - switch (yytype) { - default: - break; - } -} - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_print(FILE* yyoutput, int yytype, YYSTYPE const* const yyvaluep) -#else -static void - yy_symbol_print(yyoutput, yytype, yyvaluep) - FILE* yyoutput; -int yytype; -YYSTYPE const* const yyvaluep; -#endif -{ - if (yytype < YYNTOKENS) - YYFPRINTF(yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF(yyoutput, "nterm %s (", yytname[yytype]); - - yy_symbol_value_print(yyoutput, yytype, yyvaluep); - YYFPRINTF(yyoutput, ")"); -} - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_stack_print(yytype_int16* bottom, yytype_int16* top) -#else -static void - yy_stack_print(bottom, top) - yytype_int16* bottom; -yytype_int16* top; -#endif -{ - YYFPRINTF(stderr, "Stack now"); - for (; bottom <= top; ++bottom) - YYFPRINTF(stderr, " %d", *bottom); - YYFPRINTF(stderr, "\n"); -} - -#define YY_STACK_PRINT(Bottom, Top) \ - \ -do \ - { \ - if (yydebug) \ - yy_stack_print((Bottom), (Top)); \ - \ -} \ - while (YYID(0)) - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_reduce_print(YYSTYPE* yyvsp, int yyrule) -#else -static void - yy_reduce_print(yyvsp, yyrule) - YYSTYPE* yyvsp; -int yyrule; -#endif -{ - int yynrhs = yyr2[yyrule]; - int yyi; - unsigned long int yylno = yyrline[yyrule]; - YYFPRINTF(stderr, "Reducing stack by rule %d (line %lu):\n", - yyrule - 1, yylno); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) { - fprintf(stderr, " $%d = ", yyi + 1); - yy_symbol_print(stderr, yyrhs[yyprhs[yyrule] + yyi], - &(yyvsp[(yyi + 1) - (yynrhs)])); - fprintf(stderr, "\n"); - } -} - -#define YY_REDUCE_PRINT(Rule) \ - \ -do \ - { \ - if (yydebug) \ - yy_reduce_print(yyvsp, Rule); \ - \ -} \ - while (YYID(0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -#define YYDPRINTF(Args) -#define YY_SYMBOL_PRINT(Title, Type, Value, Location) -#define YY_STACK_PRINT(Bottom, Top) -#define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -#define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -#define YYMAXDEPTH 10000 -#endif - -#if YYERROR_VERBOSE - -#ifndef yystrlen -#if defined __GLIBC__ && defined _STRING_H -#define yystrlen strlen -#else -/* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static YYSIZE_T -yystrlen(const char* yystr) -#else -static YYSIZE_T - yystrlen(yystr) - const char* yystr; -#endif -{ - YYSIZE_T yylen; - for (yylen = 0; yystr[yylen]; yylen++) - continue; - return yylen; -} -#endif -#endif - -#ifndef yystpcpy -#if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -#define yystpcpy stpcpy -#else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static char* -yystpcpy(char* yydest, const char* yysrc) -#else -static char* - yystpcpy(yydest, yysrc) char* yydest; -const char* yysrc; -#endif -{ - char* yyd = yydest; - const char* yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -#endif -#endif - -#ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T -yytnamerr(char* yyres, const char* yystr) -{ - if (*yystr == '"') { - YYSIZE_T yyn = 0; - char const* yyp = yystr; - - for (;;) - switch (*++yyp) { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes:; - } - - if (!yyres) - return yystrlen(yystr); - - return yystpcpy(yyres, yystr) - yyres; -} -#endif - -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error(char* yyresult, int yystate, int yychar) -{ - int yyn = yypact[yystate]; - - if (!(YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else { - int yytype = YYTRANSLATE(yychar); - YYSIZE_T yysize0 = yytnamerr(0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const* yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -#if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -#endif - char* yyfmt; - char const* yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const* yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy(yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr(0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy(yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen(yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char* yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { - yyp += yytnamerr(yyp, yyarg[yyi++]); - yyf += 2; - } else { - yyp++; - yyf++; - } - } - } - return yysize; - } -} -#endif /* YYERROR_VERBOSE */ - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yydestruct(const char* yymsg, int yytype, YYSTYPE* yyvaluep) -#else -static void - yydestruct(yymsg, yytype, yyvaluep) - const char* yymsg; -int yytype; -YYSTYPE* yyvaluep; -#endif -{ - YYUSE(yyvaluep); - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) { - - default: - break; - } -} - -/* Prevent warnings from -Wmissing-prototypes. */ - -#ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int yyparse(void* YYPARSE_PARAM); -#else -int yyparse(); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus -int yyparse(void); -#else -int yyparse(); -#endif -#endif /* ! YYPARSE_PARAM */ - -/* The look-ahead symbol. */ -int yychar; - -/* The semantic value of the look-ahead symbol. */ -YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs; - -/*----------. -| yyparse. | -`----------*/ - -#ifdef YYPARSE_PARAM -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int yyparse(void* YYPARSE_PARAM) -#else -int - yyparse(YYPARSE_PARAM) void* YYPARSE_PARAM; -#endif -#else /* ! YYPARSE_PARAM */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int yyparse(void) -#else -int yyparse() - -#endif -#endif -{ - - int yystate; - int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; -#if YYERROR_VERBOSE - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char* yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; -#endif - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16* yyss = yyssa; - yytype_int16* yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE* yyvs = yyvsa; - YYSTYPE* yyvsp; - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) - - YYSIZE_T yystacksize = YYINITDEPTH; - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - - /* The number of symbols on the RHS of the reduced rule. - Keep to zero when no symbol should be popped. */ - int yylen = 0; - - YYDPRINTF((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - - yyssp = yyss; - yyvsp = yyvs; - - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ -yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. So pushing a state here evens the stacks. */ - yyssp++; - -yysetstate: - *yyssp = yystate; - - if (yyss + yystacksize - 1 <= yyssp) { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE* yyvs1 = yyvs; - yytype_int16* yyss1 = yyss; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow(YY_("memory exhausted"), - &yyss1, yysize * sizeof(*yyssp), - &yyvs1, yysize * sizeof(*yyvsp), - - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -#ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -#else - /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; - yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; - - { - yytype_int16* yyss1 = yyss; - union yyalloc* yyptr = (union yyalloc*)YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize)); - if (!yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE(yyss); - YYSTACK_RELOCATE(yyvs); - -#undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE(yyss1); - } -#endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - - YYDPRINTF((stderr, "Stack size increased to %lu\n", - (unsigned long int)yystacksize)); - - if (yyss + yystacksize - 1 <= yyssp) - YYABORT; - } - - YYDPRINTF((stderr, "Entering state %d\n", yystate)); - - goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - - /* Do appropriate processing given the current state. Read a - look-ahead token if we need one and don't already have one. */ - - /* First try to decide what to do without reference to look-ahead token. */ - yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) - goto yydefault; - - /* Not known => get a look-ahead token if don't already have one. */ - - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ - if (yychar == YYEMPTY) { - YYDPRINTF((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - if (yychar <= YYEOF) { - yychar = yytoken = YYEOF; - YYDPRINTF((stderr, "Now at end of input.\n")); - } else { - yytoken = YYTRANSLATE(yychar); - YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc); - } - - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - if (yyn == YYFINAL) - YYACCEPT; - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - /* Shift the look-ahead token. */ - YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; - - yystate = yyn; - *++yyvsp = yylval; - - goto yynewstate; - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1 - yylen]; - - YY_REDUCE_PRINT(yyn); - switch (yyn) { - case 2: -#line 56 "src/sdl/debugger-expr.y" - { - dexp_result = (yyvsp[(1) - (1)].number); - } break; - - case 3: -#line 59 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (1)].number); - } break; - - case 4: -#line 60 "src/sdl/debugger-expr.y" - { - std::string v((yyvsp[(1) - (1)].string)); - if (dexp_vars.count(v) == 0) { - printf("Variable %s not defined.\n", (yyvsp[(1) - (1)].string)); - YYABORT; - } - (yyval.number) = dexp_vars[v]; - } break; - - case 5: -#line 68 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number); - } break; - - case 6: -#line 69 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) - (yyvsp[(3) - (3)].number); - } break; - - case 7: -#line 70 "src/sdl/debugger-expr.y" - { - (yyval.number) = -(yyvsp[(2) - (2)].number); - } break; - - case 8: -#line 71 "src/sdl/debugger-expr.y" - { - (yyval.number) = ~(yyvsp[(2) - (2)].number); - } break; - - case 9: -#line 72 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) / (yyvsp[(3) - (3)].number); - } break; - - case 10: -#line 73 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) * (yyvsp[(3) - (3)].number); - } break; - - case 11: -#line 74 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) << (yyvsp[(3) - (3)].number); - } break; - - case 12: -#line 75 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) >> (yyvsp[(3) - (3)].number); - } break; - - case 13: -#line 76 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(2) - (3)].number); - } break; - - case 14: -#line 77 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) & (yyvsp[(3) - (3)].number); - } break; - - case 15: -#line 78 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) | (yyvsp[(3) - (3)].number); - } break; - - case 16: -#line 79 "src/sdl/debugger-expr.y" - { - (yyval.number) = (yyvsp[(1) - (3)].number) ^ (yyvsp[(3) - (3)].number); - } break; - - case 17: -#line 80 "src/sdl/debugger-expr.y" - { - (yyval.number) = reg[(yyvsp[(1) - (1)].number)].I; - } break; - - case 18: -#line 81 "src/sdl/debugger-expr.y" - { - (yyval.number) = readByte((yyvsp[(2) - (3)].number)); - } break; - - case 19: -#line 82 "src/sdl/debugger-expr.y" - { - (yyval.number) = readHalfWord((yyvsp[(2) - (3)].number)); - } break; - - case 20: -#line 83 "src/sdl/debugger-expr.y" - { - (yyval.number) = readWord((yyvsp[(2) - (3)].number)); - } break; - - case 21: -#line 84 "src/sdl/debugger-expr.y" - { - (yyval.number) = readWord((yyvsp[(2) - (3)].number)); - } break; - -/* Line 1267 of yacc.c. */ -#line 1534 "src/sdl/debugger-expr-yacc.cpp" - default: - break; - } - YY_SYMBOL_PRINT("-> $$ =", yyr1[yyn], &yyval, &yyloc); - - YYPOPSTACK(yylen); - yylen = 0; - YY_STACK_PRINT(yyss, yyssp); - - *++yyvsp = yyval; - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; - - goto yynewstate; - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) { - ++yynerrs; -#if !YYERROR_VERBOSE - yyerror(YY_("syntax error")); -#else - { - YYSIZE_T yysize = yysyntax_error(0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) { - YYSIZE_T yyalloc = 2 * yysize; - if (!(yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE(yymsg); - yymsg = (char*)YYSTACK_ALLOC(yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) { - (void)yysyntax_error(yymsg, yystate, yychar); - yyerror(yymsg); - } else { - yyerror(YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } -#endif - } - - if (yyerrstatus == 3) { - /* If just tried and failed to reuse look-ahead token after an - error, discard it. */ - - if (yychar <= YYEOF) { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } else { - yydestruct("Error: discarding", - yytoken, &yylval); - yychar = YYEMPTY; - } - } - - /* Else will try to reuse look-ahead token after shifting the error - token. */ - goto yyerrlab1; - -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; - - /* Do not reclaim the symbols of the rule which action triggered - this YYERROR. */ - YYPOPSTACK(yylen); - yylen = 0; - YY_STACK_PRINT(yyss, yyssp); - yystate = *yyssp; - goto yyerrlab1; - -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ - - for (;;) { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; - - yydestruct("Error: popping", - yystos[yystate], yyvsp); - YYPOPSTACK(1); - yystate = *yyssp; - YY_STACK_PRINT(yyss, yyssp); - } - - if (yyn == YYFINAL) - YYACCEPT; - - *++yyvsp = yylval; - - /* Shift the error token. */ - YY_SYMBOL_PRINT("Shifting", yystos[yyn], yyvsp, yylsp); - - yystate = yyn; - goto yynewstate; - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ -yyexhaustedlab: - yyerror(YY_("memory exhausted")); - yyresult = 2; -/* Fall through. */ -#endif - -yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) - yydestruct("Cleanup: discarding lookahead", - yytoken, &yylval); - /* Do not reclaim the symbols of the rule which action triggered - this YYABORT or YYACCEPT. */ - YYPOPSTACK(yylen); - YY_STACK_PRINT(yyss, yyssp); - while (yyssp != yyss) { - yydestruct("Cleanup: popping", - yystos[*yyssp], yyvsp); - YYPOPSTACK(1); - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE(yyss); -#endif -#if YYERROR_VERBOSE - if (yymsg != yymsgbuf) - YYSTACK_FREE(yymsg); -#endif - /* Make sure YYID is used. */ - return YYID(yyresult); -} - -#line 86 "src/sdl/debugger-expr.y" - -bool dexp_eval(char* expr, uint32_t* result) -{ - extern void dexp_flush(); - extern char* dexprString; - extern int dexprCol; - - dexp_flush(); - - dexprString = expr; - dexprCol = 0; - - if (!dexp_parse()) { - *result = dexp_result; - return true; - } else { - return false; - } -} - -int dexp_error(char* s) -{ - return 0; -} - -void dexp_setVar(char* name, uint32_t value) -{ - std::string a(name); - dexp_vars[a] = value; -} - -void dexp_listVars() -{ - std::map::iterator iter; - - for (iter = dexp_vars.begin(); iter != dexp_vars.end(); iter++) { - printf("%s = %08X\n", iter->first.c_str(), iter->second); - } -} - -void dexp_saveVars(char* file) -{ - std::map::iterator iter; - - FILE* f = fopen(file, "w"); - if (!f) { - printf("Could not open file %s\n", file); - return; - } - - for (iter = dexp_vars.begin(); iter != dexp_vars.end(); iter++) { - fprintf(f, "%s = %08X\n", iter->first.c_str(), iter->second); - } - fclose(f); -} - -void dexp_loadVars(char* file) -{ - std::map::iterator iter; - char buffer[500]; - char name[500]; - uint32_t val; - - FILE* f = fopen(file, "r"); - if (!f) { - printf("Could not open file %s\n", file); - return; - } - - while (fgets(buffer, 500, f) != NULL) { - if (sscanf(buffer, "%s = %x", name, &val) == 2) { - dexp_setVar(name, val); - } - } -} +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton implementation for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.3" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +#define yyparse dexp_parse +#define yylex dexp_lex +#define yyerror dexp_error +#define yylval dexp_lval +#define yychar dexp_char +#define yydebug dexp_debug +#define yynerrs dexp_nerrs + +/* Tokens. */ +#ifndef YYTOKENTYPE +#define YYTOKENTYPE +/* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ +enum yytokentype { + TOK_PLUS = 258, + TOK_MINUS = 259, + TOK_DIVIDE = 260, + TOK_MULTIPLY = 261, + TOK_LSHIFT = 262, + TOK_RSHIFT = 263, + TOK_LPAREN = 264, + TOK_RPAREN = 265, + TOK_OR = 266, + TOK_AND = 267, + TOK_XOR = 268, + TOK_NEGATE = 269, + TOK_BBRACKET = 270, + TOK_HBRACKET = 271, + TOK_WBRACKET = 272, + TOK_LBRACKET = 273, + TOK_RBRACKET = 274, + TOK_REGISTER = 275, + TOK_NUMBER = 276, + TOK_ID = 277 +}; +#endif +/* Tokens. */ +#define TOK_PLUS 258 +#define TOK_MINUS 259 +#define TOK_DIVIDE 260 +#define TOK_MULTIPLY 261 +#define TOK_LSHIFT 262 +#define TOK_RSHIFT 263 +#define TOK_LPAREN 264 +#define TOK_RPAREN 265 +#define TOK_OR 266 +#define TOK_AND 267 +#define TOK_XOR 268 +#define TOK_NEGATE 269 +#define TOK_BBRACKET 270 +#define TOK_HBRACKET 271 +#define TOK_WBRACKET 272 +#define TOK_LBRACKET 273 +#define TOK_RBRACKET 274 +#define TOK_REGISTER 275 +#define TOK_NUMBER 276 +#define TOK_ID 277 + +/* Copy the first part of user declarations. */ +#line 1 "src/sdl/debugger-expr.y" + +#include + +#include "../System.h" +#include "../common/Port.h" +#include "GBA.h" + +#include +#include +#include + +unsigned int dexp_result = 0; +extern int dexp_error(char*); +extern int dexp_lex(); +extern char* dexp_text; + +std::map dexp_vars; + +#define readWord(addr) \ + READ32LE((&map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask])) + +#define readHalfWord(addr) \ + READ16LE((&map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask])) + +#define readByte(addr) \ + map[(addr) >> 24].address[(addr)&map[(addr) >> 24].mask] + +/* Enabling traces. */ +#ifndef YYDEBUG +#define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +#undef YYERROR_VERBOSE +#define YYERROR_VERBOSE 1 +#else +#define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +#define YYTOKEN_TABLE 0 +#endif + +#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 44 "src/sdl/debugger-expr.y" +{ + unsigned int number; + char* string; +} +/* Line 187 of yacc.c. */ +#line 175 "src/sdl/debugger-expr-yacc.cpp" +YYSTYPE; +#define yystype YYSTYPE /* obsolescent; will be withdrawn */ +#define YYSTYPE_IS_DECLARED 1 +#define YYSTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + +/* Line 216 of yacc.c. */ +#line 188 "src/sdl/debugger-expr-yacc.cpp" + +#ifdef short +#undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +#ifdef __SIZE_TYPE__ +#define YYSIZE_T __SIZE_TYPE__ +#elif defined size_t +#define YYSIZE_T size_t +#elif !defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +#include /* INFRINGES ON USER NAME SPACE */ +#define YYSIZE_T size_t +#else +#define YYSIZE_T unsigned int +#endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T)-1) + +#ifndef YY_ +#if YYENABLE_NLS +#if ENABLE_NLS +#include /* INFRINGES ON USER NAME SPACE */ +#define YY_(msgid) dgettext("bison-runtime", msgid) +#endif +#endif +#ifndef YY_ +#define YY_(msgid) msgid +#endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if !defined lint || defined __GNUC__ +#define YYUSE(e) ((void)(e)) +#else +#define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +#define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID(int i) +#else +static int + YYID(i) int i; +#endif +{ + return i; +} +#endif + +#if !defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +#ifdef YYSTACK_USE_ALLOCA +#if YYSTACK_USE_ALLOCA +#ifdef __GNUC__ +#define YYSTACK_ALLOC __builtin_alloca +#elif defined __BUILTIN_VA_ARG_INCR +#include /* INFRINGES ON USER NAME SPACE */ +#elif defined _AIX +#define YYSTACK_ALLOC __alloca +#elif defined _MSC_VER +#include /* INFRINGES ON USER NAME SPACE */ +#define alloca _alloca +#else +#define YYSTACK_ALLOC alloca +#if !defined _ALLOCA_H && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +#include /* INFRINGES ON USER NAME SPACE */ +#ifndef _STDLIB_H +#define _STDLIB_H 1 +#endif +#endif +#endif +#endif +#endif + +#ifdef YYSTACK_ALLOC +/* Pacify GCC's `empty if-body' warning. */ +#define YYSTACK_FREE(Ptr) \ + do { /* empty */ \ + ; \ + } while (YYID(0)) +#ifndef YYSTACK_ALLOC_MAXIMUM +/* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +#define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +#endif +#else +#define YYSTACK_ALLOC YYMALLOC +#define YYSTACK_FREE YYFREE +#ifndef YYSTACK_ALLOC_MAXIMUM +#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +#endif +#if (defined __cplusplus && !defined _STDLIB_H \ + && !((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +#include /* INFRINGES ON USER NAME SPACE */ +#ifndef _STDLIB_H +#define _STDLIB_H 1 +#endif +#endif +#ifndef YYMALLOC +#define YYMALLOC malloc +#if !defined malloc && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void* malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +#endif +#endif +#ifndef YYFREE +#define YYFREE free +#if !defined free && !defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free(void*); /* INFRINGES ON USER NAME SPACE */ +#endif +#endif +#endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + +#if (!defined yyoverflow \ + && (!defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc { + yytype_int16 yyss; + YYSTYPE yyvs; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +#define YYSTACK_GAP_MAXIMUM (sizeof(union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +#define YYSTACK_BYTES(N) \ + ((N) * (sizeof(yytype_int16) + sizeof(YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +#ifndef YYCOPY +#if defined __GNUC__ && 1 < __GNUC__ +#define YYCOPY(To, From, Count) \ + __builtin_memcpy(To, From, (Count) * sizeof(*(From))) +#else +#define YYCOPY(To, From, Count) \ + do { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } while (YYID(0)) +#endif +#endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +#define YYSTACK_RELOCATE(Stack) \ + do { \ + YYSIZE_T yynewbytes; \ + YYCOPY(&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof(*yyptr); \ + } while (YYID(0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 20 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 135 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 23 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 3 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 21 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 44 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 277 + +#define YYTRANSLATE(YYX) \ + ((unsigned int)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = { + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint8 yyprhs[] = { + 0, 0, 3, 5, 7, 9, 13, 17, 20, 23, + 27, 31, 35, 39, 43, 47, 51, 55, 57, 61, + 65, 69 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int8 yyrhs[] = { + 24, 0, -1, 25, -1, 21, -1, 22, -1, 25, + 3, 25, -1, 25, 4, 25, -1, 4, 25, -1, + 14, 25, -1, 25, 5, 25, -1, 25, 6, 25, + -1, 25, 7, 25, -1, 25, 8, 25, -1, 9, + 25, 10, -1, 25, 12, 25, -1, 25, 11, 25, + -1, 25, 13, 25, -1, 20, -1, 15, 25, 19, + -1, 16, 25, 19, -1, 17, 25, 19, -1, 18, + 25, 19, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint8 yyrline[] = { + 0, 56, 56, 59, 60, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char* const yytname[] = { + "$end", "error", "$undefined", "TOK_PLUS", "TOK_MINUS", "TOK_DIVIDE", + "TOK_MULTIPLY", "TOK_LSHIFT", "TOK_RSHIFT", "TOK_LPAREN", "TOK_RPAREN", + "TOK_OR", "TOK_AND", "TOK_XOR", "TOK_NEGATE", "TOK_BBRACKET", + "TOK_HBRACKET", "TOK_WBRACKET", "TOK_LBRACKET", "TOK_RBRACKET", + "TOK_REGISTER", "TOK_NUMBER", "TOK_ID", "$accept", "final", "exp", 0 +}; +#endif + +#ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = { + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277 +}; +#endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = { + 0, 23, 24, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = { + 0, 2, 1, 1, 1, 3, 3, 2, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 1, 3, 3, + 3, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 17, 3, + 4, 0, 2, 7, 0, 8, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 18, 19, 20, 21, 5, 6, 9, 10, 11, + 12, 15, 14, 16 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = { + -1, 11, 12 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -2 +static const yytype_int8 yypact[] = { + 25, 25, 25, 25, 25, 25, 25, 25, -2, -2, + -2, 13, 113, 122, 4, 122, 45, 62, 79, 96, + -2, 25, 25, 25, 25, 25, 25, 25, 25, 25, + -2, -2, -2, -2, -2, 122, 122, 24, 24, 48, + 48, 6, 17, -2 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = { + -2, -2, -1 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const yytype_uint8 yytable[] = { + 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, + 24, 25, 26, 20, 30, 27, 28, 29, 28, 29, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 1, + 29, 25, 26, 0, 2, 27, 28, 29, 0, 3, + 4, 5, 6, 7, 0, 8, 9, 10, 21, 22, + 23, 24, 25, 26, 0, 0, 27, 28, 29, 27, + 28, 29, 0, 0, 31, 21, 22, 23, 24, 25, + 26, 0, 0, 27, 28, 29, 0, 0, 0, 0, + 0, 32, 21, 22, 23, 24, 25, 26, 0, 0, + 27, 28, 29, 0, 0, 0, 0, 0, 33, 21, + 22, 23, 24, 25, 26, 0, 0, 27, 28, 29, + 0, 0, 0, 0, 0, 34, 21, 22, 23, 24, + 25, 26, 0, 0, 27, 28, 29, 23, 24, 25, + 26, 0, 0, 27, 28, 29 +}; + +static const yytype_int8 yycheck[] = { + 1, 2, 3, 4, 5, 6, 7, 3, 4, 5, + 6, 7, 8, 0, 10, 11, 12, 13, 12, 13, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 4, + 13, 7, 8, -1, 9, 11, 12, 13, -1, 14, + 15, 16, 17, 18, -1, 20, 21, 22, 3, 4, + 5, 6, 7, 8, -1, -1, 11, 12, 13, 11, + 12, 13, -1, -1, 19, 3, 4, 5, 6, 7, + 8, -1, -1, 11, 12, 13, -1, -1, -1, -1, + -1, 19, 3, 4, 5, 6, 7, 8, -1, -1, + 11, 12, 13, -1, -1, -1, -1, -1, 19, 3, + 4, 5, 6, 7, 8, -1, -1, 11, 12, 13, + -1, -1, -1, -1, -1, 19, 3, 4, 5, 6, + 7, 8, -1, -1, 11, 12, 13, 5, 6, 7, + 8, -1, -1, 11, 12, 13 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = { + 0, 4, 9, 14, 15, 16, 17, 18, 20, 21, + 22, 24, 25, 25, 25, 25, 25, 25, 25, 25, + 0, 3, 4, 5, 6, 7, 8, 11, 12, 13, + 10, 19, 19, 19, 19, 25, 25, 25, 25, 25, + 25, 25, 25, 25 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + \ +do if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE(yychar); \ + YYPOPSTACK(1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror(YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + \ +while(YYID(0)) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +#define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID(N)) { \ + (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC(Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC(Rhs, N).last_column; \ + } else { \ + (Current).first_line = (Current).last_line = YYRHSLOC(Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = YYRHSLOC(Rhs, 0).last_column; \ + } \ + while (YYID(0)) +#endif + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +#if YYLTYPE_IS_TRIVIAL +#define YY_LOCATION_PRINT(File, Loc) \ + fprintf(File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +#else +#define YY_LOCATION_PRINT(File, Loc) ((void)0) +#endif +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +#define YYLEX yylex(YYLEX_PARAM) +#else +#define YYLEX yylex() +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +#ifndef YYFPRINTF +#include /* INFRINGES ON USER NAME SPACE */ +#define YYFPRINTF fprintf +#endif + +#define YYDPRINTF(Args) \ + \ +do \ + { \ + if (yydebug) \ + YYFPRINTF Args; \ + \ +} \ + while (YYID(0)) + +#define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ + \ +do \ + { \ + if (yydebug) { \ + YYFPRINTF(stderr, "%s ", Title); \ + yy_symbol_print(stderr, \ + Type, Value); \ + YYFPRINTF(stderr, "\n"); \ + } \ + \ +} \ + while (YYID(0)) + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print(FILE* yyoutput, int yytype, YYSTYPE const* const yyvaluep) +#else +static void + yy_symbol_value_print(yyoutput, yytype, yyvaluep) + FILE* yyoutput; +int yytype; +YYSTYPE const* const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +#ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT(yyoutput, yytoknum[yytype], *yyvaluep); +#else + YYUSE(yyoutput); +#endif + switch (yytype) { + default: + break; + } +} + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print(FILE* yyoutput, int yytype, YYSTYPE const* const yyvaluep) +#else +static void + yy_symbol_print(yyoutput, yytype, yyvaluep) + FILE* yyoutput; +int yytype; +YYSTYPE const* const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF(yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF(yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print(yyoutput, yytype, yyvaluep); + YYFPRINTF(yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print(yytype_int16* bottom, yytype_int16* top) +#else +static void + yy_stack_print(bottom, top) + yytype_int16* bottom; +yytype_int16* top; +#endif +{ + YYFPRINTF(stderr, "Stack now"); + for (; bottom <= top; ++bottom) + YYFPRINTF(stderr, " %d", *bottom); + YYFPRINTF(stderr, "\n"); +} + +#define YY_STACK_PRINT(Bottom, Top) \ + \ +do \ + { \ + if (yydebug) \ + yy_stack_print((Bottom), (Top)); \ + \ +} \ + while (YYID(0)) + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print(YYSTYPE* yyvsp, int yyrule) +#else +static void + yy_reduce_print(yyvsp, yyrule) + YYSTYPE* yyvsp; +int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF(stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) { + fprintf(stderr, " $%d = ", yyi + 1); + yy_symbol_print(stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)])); + fprintf(stderr, "\n"); + } +} + +#define YY_REDUCE_PRINT(Rule) \ + \ +do \ + { \ + if (yydebug) \ + yy_reduce_print(yyvsp, Rule); \ + \ +} \ + while (YYID(0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +#define YYDPRINTF(Args) +#define YY_SYMBOL_PRINT(Title, Type, Value, Location) +#define YY_STACK_PRINT(Bottom, Top) +#define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +#if YYERROR_VERBOSE + +#ifndef yystrlen +#if defined __GLIBC__ && defined _STRING_H +#define yystrlen strlen +#else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen(const char* yystr) +#else +static YYSIZE_T + yystrlen(yystr) + const char* yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +#endif +#endif + +#ifndef yystpcpy +#if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +#define yystpcpy stpcpy +#else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char* +yystpcpy(char* yydest, const char* yysrc) +#else +static char* + yystpcpy(yydest, yysrc) char* yydest; +const char* yysrc; +#endif +{ + char* yyd = yydest; + const char* yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +#endif +#endif + +#ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr(char* yyres, const char* yystr) +{ + if (*yystr == '"') { + YYSIZE_T yyn = 0; + char const* yyp = yystr; + + for (;;) + switch (*++yyp) { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes:; + } + + if (!yyres) + return yystrlen(yystr); + + return yystpcpy(yyres, yystr) - yyres; +} +#endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error(char* yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (!(YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else { + int yytype = YYTRANSLATE(yychar); + YYSIZE_T yysize0 = yytnamerr(0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const* yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +#if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +#endif + char* yyfmt; + char const* yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const* yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy(yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr(0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy(yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen(yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char* yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) { + yyp += yytnamerr(yyp, yyarg[yyi++]); + yyf += 2; + } else { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct(const char* yymsg, int yytype, YYSTYPE* yyvaluep) +#else +static void + yydestruct(yymsg, yytype, yyvaluep) + const char* yymsg; +int yytype; +YYSTYPE* yyvaluep; +#endif +{ + YYUSE(yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) { + + default: + break; + } +} + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse(void* YYPARSE_PARAM); +#else +int yyparse(); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse(void); +#else +int yyparse(); +#endif +#endif /* ! YYPARSE_PARAM */ + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int yyparse(void* YYPARSE_PARAM) +#else +int + yyparse(YYPARSE_PARAM) void* YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int yyparse(void) +#else +int yyparse() + +#endif +#endif +{ + + int yystate; + int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char* yymsg = (char *)yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16* yyss = yyssa; + yytype_int16* yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE* yyvs = yyvsa; + YYSTYPE* yyvsp; + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + +yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE* yyvs1 = yyvs; + yytype_int16* yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow(YY_("memory exhausted"), + &yyss1, yysize * sizeof(*yyssp), + &yyvs1, yysize * sizeof(*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +#ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +#else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16* yyss1 = yyss; + union yyalloc* yyptr = (union yyalloc*)YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize)); + if (!yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE(yyss); + YYSTACK_RELOCATE(yyvs); + +#undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE(yyss1); + } +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YYDPRINTF((stderr, "Stack size increased to %lu\n", + (unsigned long int)yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + look-ahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to look-ahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) { + YYDPRINTF((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) { + yychar = yytoken = YYEOF; + YYDPRINTF((stderr, "Now at end of input.\n")); + } else { + yytoken = YYTRANSLATE(yychar); + YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1 - yylen]; + + YY_REDUCE_PRINT(yyn); + switch (yyn) { + case 2: +#line 56 "src/sdl/debugger-expr.y" + { + dexp_result = (yyvsp[(1) - (1)].number); + } break; + + case 3: +#line 59 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (1)].number); + } break; + + case 4: +#line 60 "src/sdl/debugger-expr.y" + { + std::string v((yyvsp[(1) - (1)].string)); + if (dexp_vars.count(v) == 0) { + printf("Variable %s not defined.\n", (yyvsp[(1) - (1)].string)); + YYABORT; + } + (yyval.number) = dexp_vars[v]; + } break; + + case 5: +#line 68 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number); + } break; + + case 6: +#line 69 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) - (yyvsp[(3) - (3)].number); + } break; + + case 7: +#line 70 "src/sdl/debugger-expr.y" + { + (yyval.number) = -(yyvsp[(2) - (2)].number); + } break; + + case 8: +#line 71 "src/sdl/debugger-expr.y" + { + (yyval.number) = ~(yyvsp[(2) - (2)].number); + } break; + + case 9: +#line 72 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) / (yyvsp[(3) - (3)].number); + } break; + + case 10: +#line 73 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) * (yyvsp[(3) - (3)].number); + } break; + + case 11: +#line 74 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) << (yyvsp[(3) - (3)].number); + } break; + + case 12: +#line 75 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) >> (yyvsp[(3) - (3)].number); + } break; + + case 13: +#line 76 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(2) - (3)].number); + } break; + + case 14: +#line 77 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) & (yyvsp[(3) - (3)].number); + } break; + + case 15: +#line 78 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) | (yyvsp[(3) - (3)].number); + } break; + + case 16: +#line 79 "src/sdl/debugger-expr.y" + { + (yyval.number) = (yyvsp[(1) - (3)].number) ^ (yyvsp[(3) - (3)].number); + } break; + + case 17: +#line 80 "src/sdl/debugger-expr.y" + { + (yyval.number) = reg[(yyvsp[(1) - (1)].number)].I; + } break; + + case 18: +#line 81 "src/sdl/debugger-expr.y" + { + (yyval.number) = readByte((yyvsp[(2) - (3)].number)); + } break; + + case 19: +#line 82 "src/sdl/debugger-expr.y" + { + (yyval.number) = readHalfWord((yyvsp[(2) - (3)].number)); + } break; + + case 20: +#line 83 "src/sdl/debugger-expr.y" + { + (yyval.number) = readWord((yyvsp[(2) - (3)].number)); + } break; + + case 21: +#line 84 "src/sdl/debugger-expr.y" + { + (yyval.number) = readWord((yyvsp[(2) - (3)].number)); + } break; + +/* Line 1267 of yacc.c. */ +#line 1534 "src/sdl/debugger-expr-yacc.cpp" + default: + break; + } + YY_SYMBOL_PRINT("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK(yylen); + yylen = 0; + YY_STACK_PRINT(yyss, yyssp); + + *++yyvsp = yyval; + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) { + ++yynerrs; +#if !YYERROR_VERBOSE + yyerror((char *)YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error(0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) { + YYSIZE_T yyalloc = 2 * yysize; + if (!(yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE(yymsg); + yymsg = (char*)YYSTACK_ALLOC(yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) { + (void)yysyntax_error(yymsg, yystate, yychar); + yyerror(yymsg); + } else { + yyerror((char *)YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif + } + + if (yyerrstatus == 3) { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } else { + yydestruct("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK(yylen); + yylen = 0; + YY_STACK_PRINT(yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + yydestruct("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK(1); + yystate = *yyssp; + YY_STACK_PRINT(yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + /* Shift the error token. */ + YY_SYMBOL_PRINT("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror((char *)YY_("memory exhausted")); + yyresult = 2; +/* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEOF && yychar != YYEMPTY) + yydestruct("Cleanup: discarding lookahead", + yytoken, &yylval); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK(yylen); + YY_STACK_PRINT(yyss, yyssp); + while (yyssp != yyss) { + yydestruct("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK(1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE(yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE(yymsg); +#endif + /* Make sure YYID is used. */ + return YYID(yyresult); +} + +#line 86 "src/sdl/debugger-expr.y" + +bool dexp_eval(char* expr, uint32_t* result) +{ + extern void dexp_flush(); + extern char* dexprString; + extern int dexprCol; + + dexp_flush(); + + dexprString = expr; + dexprCol = 0; + + if (!dexp_parse()) { + *result = dexp_result; + return true; + } else { + return false; + } +} + +int dexp_error(char* s) +{ + return 0; +} + +void dexp_setVar(char* name, uint32_t value) +{ + std::string a(name); + dexp_vars[a] = value; +} + +void dexp_listVars() +{ + std::map::iterator iter; + + for (iter = dexp_vars.begin(); iter != dexp_vars.end(); iter++) { + printf("%s = %08X\n", iter->first.c_str(), iter->second); + } +} + +void dexp_saveVars(char* file) +{ + std::map::iterator iter; + + FILE* f = fopen(file, "w"); + if (!f) { + printf("Could not open file %s\n", file); + return; + } + + for (iter = dexp_vars.begin(); iter != dexp_vars.end(); iter++) { + fprintf(f, "%s = %08X\n", iter->first.c_str(), iter->second); + } + fclose(f); +} + +void dexp_loadVars(char* file) +{ + std::map::iterator iter; + char buffer[500]; + char name[500]; + uint32_t val; + + FILE* f = fopen(file, "r"); + if (!f) { + printf("Could not open file %s\n", file); + return; + } + + while (fgets(buffer, 500, f) != NULL) { + if (sscanf(buffer, "%s = %x", name, &val) == 2) { + dexp_setVar(name, val); + } + } +} diff --git a/src/gba/ereader.cpp b/src/gba/ereader.cpp index e7e35e1e..4f1ad7b2 100644 --- a/src/gba/ereader.cpp +++ b/src/gba/ereader.cpp @@ -1,584 +1,585 @@ -#include -#include -#include -#include - -#include "GBA.h" -#include "GBAinline.h" -#include "Globals.h" -#include "ereader.h" - -char US_Ereader[19] = "CARDE READERPSAE01"; -char JAP_Ereader[19] = "CARDE READERPEAJ01"; -char JAP_Ereader_plus[19] = "CARDEREADER+PSAJ01"; -char rom_info[19]; - -char Signature[0x29] = "E-Reader Dotcode -Created- by CaitSith2"; - -unsigned char ShortDotCodeHeader[0x30] = { - 0x00, 0x30, 0x01, 0x01, - 0x00, 0x01, 0x05, 0x10, - 0x00, 0x00, 0x10, 0x12, //Constant data - - 0x00, 0x00, //Header First 2 bytes - - 0x02, 0x00, //Constant data - - 0x00, 0x00, //Header Second 2 bytes - - 0x10, 0x47, 0xEF, //Global Checksum 1 - - 0x19, 0x00, 0x00, 0x00, 0x08, 0x4E, 0x49, - 0x4E, 0x54, 0x45, 0x4E, 0x44, 0x4F, 0x00, 0x22, - 0x00, 0x09, //Constant data - - 0x00, 0x00, //Header, last 8 bytes - 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, - 0x00, //Header Checksum - 0x57 //Global Checksum 2 -}; - -unsigned char LongDotCodeHeader[0x30] = { - 0x00, 0x30, 0x01, 0x02, - 0x00, 0x01, 0x08, 0x10, - 0x00, 0x00, 0x10, 0x12, //Constant Data - - 0x00, 0x00, //Header, first 2 bytes - - 0x01, 0x00, //Constant data - - 0x00, 0x00, //Header, second 2 bytes - 0x10, 0x9A, 0x99, //Global Checksum 1 - - 0x19, 0x00, 0x00, 0x00, 0x08, 0x4E, 0x49, - 0x4E, 0x54, 0x45, 0x4E, 0x44, 0x4F, 0x00, 0x22, - 0x00, 0x09, //Constant data - - 0x00, 0x00, //Header, last 8 bytes - 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, - 0x00, //Header Checksum - 0x57 //Global Checksum 2 -}; - -unsigned char shortheader[0x18] = { - 0x00, 0x02, 0x00, 0x01, 0x40, 0x10, 0x00, 0x1C, - 0x10, 0x6F, 0x40, 0xDA, 0x39, 0x25, 0x8E, 0xE0, - 0x7B, 0xB5, 0x98, 0xB6, 0x5B, 0xCF, 0x7F, 0x72 -}; -unsigned char longheader[0x18] = { - 0x00, 0x03, 0x00, 0x19, 0x40, 0x10, 0x00, 0x2C, - 0x0E, 0x88, 0xED, 0x82, 0x50, 0x67, 0xFB, 0xD1, - 0x43, 0xEE, 0x03, 0xC6, 0xC6, 0x2B, 0x2C, 0x93 -}; - -unsigned char dotcodeheader[0x48]; -unsigned char dotcodedata[0xB38]; -unsigned char dotcodetemp[0xB00]; -int dotcodepointer; -int dotcodeinterleave; -int decodestate; - -uint32_t GFpow; - -unsigned char* DotCodeData; -char filebuffer[2048]; - -int dotcodesize; - -#if (defined __WIN32__ || defined _WIN32) -#define strcasecmp _stricmp -#endif - -int CheckEReaderRegion(void) //US = 1, JAP = 2, JAP+ = 3 -{ - int i; - for (i = 0; i < 18; i++) - rom_info[i] = rom[0xA0 + i]; - rom_info[i] = 0; - - if (!strcasecmp(rom_info, US_Ereader)) - return 1; - if (!strcasecmp(rom_info, JAP_Ereader)) - return 2; - if (!strcasecmp(rom_info, JAP_Ereader_plus)) - return 3; - - return 0; -} - -int LoadDotCodeData(int size, uint32_t* DCdata, unsigned long MEM1, unsigned long MEM2, int loadraw) -{ - uint32_t temp1; - int i, j; - - unsigned char scanmap[28]; - int scantotal = 0; - - for (i = 0; i < 28; i++) - scanmap[i] = 0; - - unsigned char longdotcodescan[28] = { - 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, - 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, - 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, - 0xF1, 0xF2, 0xB1, 0xB1 - }; - - temp1 = CPUReadMemory(MEM1 - 4); - for (i = 0; i < 0x60; i += 4) - CPUWriteMemory((MEM2 - 8) + i, 0); - for (i = 0; i < 0x1860; i += 4) - CPUWriteMemory(temp1 + i, 0); - if (DCdata != NULL) { - if (size == 0xB60) { - for (i = 0; i < 28; i++) { - for (j = 0, scantotal = 0; j < 0x68; j += 4) { - scantotal += DCdata[((i * 0x68) + j) >> 2]; - } - if (scantotal) - scanmap[i] = longdotcodescan[i]; - } - for (i = 0; i < size; i += 4) { - CPUWriteMemory(temp1 + i + 0x9C0, DCdata[i >> 2]); - } - } else if (size == 0x750) { - for (i = 0; i < 18; i++) { - if ((DCdata[0] == 0x02011394) && (DCdata[1] == 0x0203E110) && (i == 0)) - continue; - for (j = 0, scantotal = 0; j < 0x68; j += 4) { - scantotal += DCdata[((i * 0x68) + j) >> 2]; - } - if (scantotal) - scanmap[i] = longdotcodescan[i]; - } - for (i = 0; i < size; i += 4) { - CPUWriteMemory(temp1 + i, DCdata[i >> 2]); - } - } - } - CPUWriteMemory(MEM2 - 8, 0x1860); - CPUWriteMemory(MEM2 - 4, temp1); - - if (size == 0xB60) { - if (loadraw) { - for (i = 0; i < 28; i++) - CPUWriteByte(MEM2 + 0x18 + i, scanmap[i]); - } else { - CPUWriteMemory(MEM2 + 0x18, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 4, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 8, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 12, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 16, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 20, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 0x18 + 24, 0xB1B1F2F1); - } - CPUWriteMemory(MEM2 + 0x40, 0x19); - CPUWriteMemory(MEM2 + 0x44, 0x34); - } else if (size == 0x750) { - if (loadraw) { - for (i = 0; i < 18; i++) - CPUWriteByte(MEM2 + i, scanmap[i]); - } else { - CPUWriteMemory(MEM2, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 4, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 8, 0xF1F1F1F1); - CPUWriteMemory(MEM2 + 12, 0xF2F1F1F1); - CPUWriteMemory(MEM2 + 16, 0xB1B1); - } - CPUWriteMemory(MEM2 + 0x40, 0x01); - CPUWriteMemory(MEM2 + 0x44, 0x12); - } - CPUWriteMemory(MEM2 + 0x48, 0x3C); - CPUWriteMemory(MEM2 + 0x4C, MEM2); - - return 0; -} - -void EReaderWriteMemory(uint32_t address, uint32_t value) -{ - switch (address >> 24) { - case 2: - WRITE32LE(((uint32_t*)&workRAM[address & 0x3FFFF]), value); - break; - case 3: - WRITE32LE(((uint32_t*)&internalRAM[address & 0x7FFF]), value); - break; - default: - WRITE32LE(((uint32_t*)&rom[address & 0x1FFFFFF]), value); - //rom[address & 0x1FFFFFF] = data; - break; - } -} - -void BIOS_EReader_ScanCard(int swi_num) -{ - - int i, j, k; - int dotcodetype; - - int global1, global2; - - FILE* f; - - //Open dotcode bin/raw - - if (swi_num == 0xE0) { - dotcodepointer = 0; - dotcodeinterleave = 0; - decodestate = 0; - - const char* loadDotCodeFile = GetLoadDotCodeFile(); - - if (loadDotCodeFile == 0) { - reg[0].I = 0x301; - return; - } - f = fopen(loadDotCodeFile, "rb"); - //f=fopen(filebuffer,"rb"); - //f=fopen("dotcode4.raw","rb"); - if (f == NULL) { - reg[0].I = 0x303; - return; - } - fseek(f, 0, SEEK_END); - i = ftell(f); - fseek(f, 0, SEEK_SET); - if ((i == 0xB60) || (i == 0x750)) { - dotcodetype = 0; - } else if ((i == 0x81C) || (i == 0x51C)) { - dotcodetype = 1; - } else { - fclose(f); - reg[0].I = 0x303; - return; - } - DotCodeData = (unsigned char*)malloc(i); - if (DotCodeData == NULL) { - reg[0].I = 0x303; - return; - } - fread(DotCodeData, 1, i, f); - fclose(f); - - if (dotcodetype == 0) { - - switch (CheckEReaderRegion()) { - case 1: //US - LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x2032D14, 0x2028B28, 1); - EReaderWriteMemory(0x80091BA, 0x46C0DFE2); - break; - case 2: - LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x2006EC4, 0x2002478, 1); - EReaderWriteMemory(0x8008B12, 0x46C0DFE2); - break; - case 3: - LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x202F8A4, 0x2031034, 1); - EReaderWriteMemory(0x800922E, 0x46C0DFE2); - break; - } - reg[0].I = 0; - free(DotCodeData); - } else { - //dotcodesize = i; - if (i == 0x81C) - dotcodesize = 0xB60; - else - dotcodesize = 0x750; - - switch (CheckEReaderRegion()) { - case 1: //US - LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x2032D14, 0x2028B28, 0); - EReaderWriteMemory(0x80091BA, 0x46C0DFE1); - break; - case 2: - LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x2006EC4, 0x2002478, 0); - EReaderWriteMemory(0x8008B12, 0x46C0DFE1); - break; - case 3: - LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x202F8A4, 0x2031034, 0); - EReaderWriteMemory(0x800922E, 0x46C0DFE1); - break; - } - reg[0].I = 0; - dotcodesize = i; - } - } else if (swi_num == 0xE1) { - - switch (CheckEReaderRegion()) { - case 1: //US - EReaderWriteMemory(0x80091BA, 0xF8A5F03B); - EReaderWriteMemory(0x3002F7C, 0xEFE40000); //Beginning of Reed-Solomon decoder - EReaderWriteMemory(0x3003144, 0xCA00002F); //Fix required to Correct 16 "Erasures" - EReaderWriteMemory(0x300338C, 0xEFE50000); //End of Reed-Solomon decoder - GFpow = 0x3000A6C; - break; - case 2: - EReaderWriteMemory(0x8008B12, 0xFB0BF035); - EReaderWriteMemory(0x3002F88, 0xEFE40000); - EReaderWriteMemory(0x3003150, 0xCA00002F); - EReaderWriteMemory(0x3003398, 0xEFE50000); - GFpow = 0x3000A78; - break; - case 3: - EReaderWriteMemory(0x800922E, 0xF94BF04B); - EReaderWriteMemory(0x3002F7C, 0xEFE40000); - EReaderWriteMemory(0x3003144, 0xCA00002F); - EReaderWriteMemory(0x300338C, 0xEFE50000); - GFpow = 0x3000A6C; - break; - } - - armNextPC -= 2; - reg[15].I -= 2; - if (armState) - ARM_PREFETCH - else - THUMB_PREFETCH - - for (i = 0, j = 0; i < 12; i++) - j ^= DotCodeData[i]; - if (dotcodesize == 0x81C) { - LongDotCodeHeader[0x2E] = j; - LongDotCodeHeader[0x0D] = DotCodeData[0]; - LongDotCodeHeader[0x0C] = DotCodeData[1]; - LongDotCodeHeader[0x11] = DotCodeData[2]; - LongDotCodeHeader[0x10] = DotCodeData[3]; - - LongDotCodeHeader[0x26] = DotCodeData[4]; - LongDotCodeHeader[0x27] = DotCodeData[5]; - LongDotCodeHeader[0x28] = DotCodeData[6]; - LongDotCodeHeader[0x29] = DotCodeData[7]; - LongDotCodeHeader[0x2A] = DotCodeData[8]; - LongDotCodeHeader[0x2B] = DotCodeData[9]; - LongDotCodeHeader[0x2C] = DotCodeData[10]; - LongDotCodeHeader[0x2D] = DotCodeData[11]; - - LongDotCodeHeader[0x12] = 0x10; //calculate Global Checksum 1 - LongDotCodeHeader[0x02] = 1; //Do not calculate Global Checksum 2 - - for (i = 0x0C, j = 0; i < 0x81C; i++) { - if (i & 1) - j += DotCodeData[i]; - else - j += (DotCodeData[i] << 8); - } - j &= 0xFFFF; - j ^= 0xFFFF; - LongDotCodeHeader[0x13] = (j & 0xFF00) >> 8; - LongDotCodeHeader[0x14] = (j & 0x00FF); - - for (i = 0, j = 0; i < 0x2F; i++) - j += LongDotCodeHeader[i]; - j &= 0xFF; - for (i = 1, global2 = 0; i < 0x2C; i++) { - for (k = 0, global1 = 0; k < 0x30; k++) { - global1 ^= DotCodeData[((i - 1) * 0x30) + k + 0x0C]; - } - global2 += global1; - } - global2 += j; - global2 &= 0xFF; - global2 ^= 0xFF; - LongDotCodeHeader[0x2F] = global2; - - } else { - ShortDotCodeHeader[0x2E] = j; - ShortDotCodeHeader[0x0D] = DotCodeData[0]; - ShortDotCodeHeader[0x0C] = DotCodeData[1]; - ShortDotCodeHeader[0x11] = DotCodeData[2]; - ShortDotCodeHeader[0x10] = DotCodeData[3]; - - ShortDotCodeHeader[0x26] = DotCodeData[4]; - ShortDotCodeHeader[0x27] = DotCodeData[5]; - ShortDotCodeHeader[0x28] = DotCodeData[6]; - ShortDotCodeHeader[0x29] = DotCodeData[7]; - ShortDotCodeHeader[0x2A] = DotCodeData[8]; - ShortDotCodeHeader[0x2B] = DotCodeData[9]; - ShortDotCodeHeader[0x2C] = DotCodeData[10]; - ShortDotCodeHeader[0x2D] = DotCodeData[11]; - - ShortDotCodeHeader[0x12] = 0x10; //calculate Global Checksum 1 - ShortDotCodeHeader[0x02] = 1; //Do not calculate Global Checksum 2 - - for (i = 0x0C, j = 0; i < 0x51C; i++) { - if (i & 1) - j += DotCodeData[i]; - else - j += (DotCodeData[i] << 8); - } - j &= 0xFFFF; - j ^= 0xFFFF; - ShortDotCodeHeader[0x13] = (j & 0xFF00) >> 8; - ShortDotCodeHeader[0x14] = (j & 0x00FF); - - for (i = 0, j = 0; i < 0x2F; i++) - j += ShortDotCodeHeader[i]; - j &= 0xFF; - for (i = 1, global2 = 0; i < 0x1C; i++) { - for (k = 0, global1 = 0; k < 0x30; k++) { - global1 ^= DotCodeData[((i - 1) * 0x30) + k + 0x0C]; - } - global2 += global1; - } - global2 += j; - global2 &= 0xFF; - global2 ^= 0xFF; - ShortDotCodeHeader[0x2F] = global2; - } - - } else if (swi_num == 0xE2) //Header - { - switch (CheckEReaderRegion()) { - case 1: //US - EReaderWriteMemory(0x80091BA, 0xF8A5F03B); - EReaderWriteMemory(0x300338C, 0xEFE30000); - GFpow = 0x3000A6C; - break; - case 2: - EReaderWriteMemory(0x8008B12, 0xFB0BF035); - EReaderWriteMemory(0x3003398, 0xEFE30000); - GFpow = 0x3000A78; - break; - case 3: - EReaderWriteMemory(0x800922E, 0xF94BF04B); - EReaderWriteMemory(0x300338C, 0xEFE30000); - GFpow = 0x3000A6C; - break; - } - armNextPC -= 2; - reg[15].I -= 2; - if (armState) - ARM_PREFETCH - else - THUMB_PREFETCH - } else if ((swi_num == 0xE3) || (swi_num == 0xE5)) //Dotcode data - { - if ((reg[0].I >= 0) && (reg[0].I <= 0x10)) { - if (decodestate == 0) { - for (i = 0x17; i >= 0; i--) { - if ((0x17 - i) < 8) - j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)); - else - j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)) ^ 0xFF; - - dotcodeheader[(0x17 - i)] = j; - dotcodeheader[(0x17 - i) + 0x18] = j; - dotcodeheader[(0x17 - i) + 0x30] = j; - } - for (i = 0; i < 28; i++) - for (j = 0; j < 2; j++) - dotcodedata[(i * 0x68) + j] = dotcodeheader[(i * 2) + j]; - dotcodeinterleave = dotcodeheader[7]; - decodestate = 1; - } else { - for (i = 0x3F; i >= 0; i--) { - if ((0x3F - i) < 0x30) - j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)); - else - j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)) ^ 0xFF; - dotcodetemp[((0x3F - i) * dotcodeinterleave) + dotcodepointer] = j; - } - dotcodepointer++; - - if (dotcodepointer == dotcodeinterleave) { - switch (dotcodeinterleave) { - case 0x1C: - j = 0x724; - k = 0x750 - j; - break; - case 0x2C: - j = 0xB38; - k = 0xB60 - j; - break; - } - dotcodepointer = 0; - for (i = 2; i < j; i++) { - if ((i % 0x68) == 0) - i += 2; - dotcodedata[i] = dotcodetemp[dotcodepointer++]; - } - if (swi_num == 0xE3) { - const char* loadDotCodeFile = GetLoadDotCodeFile(); - f = fopen(loadDotCodeFile, "rb+"); - if (f != NULL) { - fwrite(dotcodedata, 1, j, f); - fclose(f); - } - } else { - const char* saveDotCodeFile = GetSaveDotCodeFile(); - if (saveDotCodeFile) { - f = fopen(saveDotCodeFile, "wb"); - if (f != NULL) { - fwrite(dotcodedata, 1, j, f); - fwrite(Signature, 1, 0x28, f); - if (j == 0x724) { - fputc(0x65, f); - fputc(0x02, f); - fputc(0x71, f); - fputc(0x10, f); - } - fclose(f); - } - } - free(DotCodeData); - } - } - } - } - - int base = 14; - armState = reg[base].I & 1 ? false : true; - if (armState) { - reg[15].I = reg[base].I & 0xFFFFFFFC; - armNextPC = reg[15].I; - reg[15].I += 4; - ARM_PREFETCH - } else { - reg[15].I = reg[base].I & 0xFFFFFFFE; - armNextPC = reg[15].I; - reg[15].I += 2; - THUMB_PREFETCH - } - } else if (swi_num == 0xE4) { - reg[12].I = reg[13].I; - if (decodestate == 0) { - for (i = 0; i < 0x18; i++) { - if (dotcodesize == 0x81C) - j = longheader[i]; - else - j = shortheader[i]; - - if (i < 8) - j = CPUReadByte(GFpow + 0x100 + j); - else - j = CPUReadByte(GFpow + 0x100 + (j ^ 0xFF)); - - CPUWriteByte(GFpow + 0x200 + (0x17 - i), j); - } - } else { - if (dotcodepointer == 0) { - for (i = 0; i < 0x30; i++) { - if (dotcodesize == 0x81C) - j = LongDotCodeHeader[i]; - else - j = ShortDotCodeHeader[i]; - - j = CPUReadByte(GFpow + 0x100 + j); - CPUWriteByte(GFpow + 0x200 + (0x3F - i), j); - } - - } else { - for (i = 0; i < 0x30; i++) { - - j = DotCodeData[((dotcodepointer - 1) * 0x30) + 0x0C + i]; - j = CPUReadByte(GFpow + 0x100 + j); - CPUWriteByte(GFpow + 0x200 + (0x3F - i), j); - } - } - for (i = 0; i < 16; i++) - CPUWriteByte(GFpow + 0x258 + i, 1); //16 Erasures on the parity bytes, to have them calculated. - } - } -} +#include +#include +#include +#include + +#include "GBA.h" +#include "GBAinline.h" +#include "Globals.h" +#include "ereader.h" + +char US_Ereader[19] = "CARDE READERPSAE01"; +char JAP_Ereader[19] = "CARDE READERPEAJ01"; +char JAP_Ereader_plus[19] = "CARDEREADER+PSAJ01"; +char rom_info[19]; + +char Signature[0x29] = "E-Reader Dotcode -Created- by CaitSith2"; + +unsigned char ShortDotCodeHeader[0x30] = { + 0x00, 0x30, 0x01, 0x01, + 0x00, 0x01, 0x05, 0x10, + 0x00, 0x00, 0x10, 0x12, //Constant data + + 0x00, 0x00, //Header First 2 bytes + + 0x02, 0x00, //Constant data + + 0x00, 0x00, //Header Second 2 bytes + + 0x10, 0x47, 0xEF, //Global Checksum 1 + + 0x19, 0x00, 0x00, 0x00, 0x08, 0x4E, 0x49, + 0x4E, 0x54, 0x45, 0x4E, 0x44, 0x4F, 0x00, 0x22, + 0x00, 0x09, //Constant data + + 0x00, 0x00, //Header, last 8 bytes + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, + 0x00, //Header Checksum + 0x57 //Global Checksum 2 +}; + +unsigned char LongDotCodeHeader[0x30] = { + 0x00, 0x30, 0x01, 0x02, + 0x00, 0x01, 0x08, 0x10, + 0x00, 0x00, 0x10, 0x12, //Constant Data + + 0x00, 0x00, //Header, first 2 bytes + + 0x01, 0x00, //Constant data + + 0x00, 0x00, //Header, second 2 bytes + 0x10, 0x9A, 0x99, //Global Checksum 1 + + 0x19, 0x00, 0x00, 0x00, 0x08, 0x4E, 0x49, + 0x4E, 0x54, 0x45, 0x4E, 0x44, 0x4F, 0x00, 0x22, + 0x00, 0x09, //Constant data + + 0x00, 0x00, //Header, last 8 bytes + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, + 0x00, //Header Checksum + 0x57 //Global Checksum 2 +}; + +unsigned char shortheader[0x18] = { + 0x00, 0x02, 0x00, 0x01, 0x40, 0x10, 0x00, 0x1C, + 0x10, 0x6F, 0x40, 0xDA, 0x39, 0x25, 0x8E, 0xE0, + 0x7B, 0xB5, 0x98, 0xB6, 0x5B, 0xCF, 0x7F, 0x72 +}; +unsigned char longheader[0x18] = { + 0x00, 0x03, 0x00, 0x19, 0x40, 0x10, 0x00, 0x2C, + 0x0E, 0x88, 0xED, 0x82, 0x50, 0x67, 0xFB, 0xD1, + 0x43, 0xEE, 0x03, 0xC6, 0xC6, 0x2B, 0x2C, 0x93 +}; + +unsigned char dotcodeheader[0x48]; +unsigned char dotcodedata[0xB38]; +unsigned char dotcodetemp[0xB00]; +int dotcodepointer; +int dotcodeinterleave; +int decodestate; + +uint32_t GFpow; + +unsigned char* DotCodeData; +char filebuffer[2048]; + +int dotcodesize; + +#if (defined __WIN32__ || defined _WIN32) +#define strcasecmp _stricmp +#endif + +int CheckEReaderRegion(void) //US = 1, JAP = 2, JAP+ = 3 +{ + int i; + for (i = 0; i < 18; i++) + rom_info[i] = rom[0xA0 + i]; + rom_info[i] = 0; + + if (!strcasecmp(rom_info, US_Ereader)) + return 1; + if (!strcasecmp(rom_info, JAP_Ereader)) + return 2; + if (!strcasecmp(rom_info, JAP_Ereader_plus)) + return 3; + + return 0; +} + +int LoadDotCodeData(int size, uint32_t* DCdata, unsigned long MEM1, unsigned long MEM2, int loadraw) +{ + uint32_t temp1; + int i, j; + + unsigned char scanmap[28]; + int scantotal = 0; + + for (i = 0; i < 28; i++) + scanmap[i] = 0; + + unsigned char longdotcodescan[28] = { + 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, + 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, + 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, + 0xF1, 0xF2, 0xB1, 0xB1 + }; + + temp1 = CPUReadMemory(MEM1 - 4); + for (i = 0; i < 0x60; i += 4) + CPUWriteMemory((MEM2 - 8) + i, 0); + for (i = 0; i < 0x1860; i += 4) + CPUWriteMemory(temp1 + i, 0); + if (DCdata != NULL) { + if (size == 0xB60) { + for (i = 0; i < 28; i++) { + for (j = 0, scantotal = 0; j < 0x68; j += 4) { + scantotal += DCdata[((i * 0x68) + j) >> 2]; + } + if (scantotal) + scanmap[i] = longdotcodescan[i]; + } + for (i = 0; i < size; i += 4) { + CPUWriteMemory(temp1 + i + 0x9C0, DCdata[i >> 2]); + } + } else if (size == 0x750) { + for (i = 0; i < 18; i++) { + if ((DCdata[0] == 0x02011394) && (DCdata[1] == 0x0203E110) && (i == 0)) + continue; + for (j = 0, scantotal = 0; j < 0x68; j += 4) { + scantotal += DCdata[((i * 0x68) + j) >> 2]; + } + if (scantotal) + scanmap[i] = longdotcodescan[i]; + } + for (i = 0; i < size; i += 4) { + CPUWriteMemory(temp1 + i, DCdata[i >> 2]); + } + } + } + CPUWriteMemory(MEM2 - 8, 0x1860); + CPUWriteMemory(MEM2 - 4, temp1); + + if (size == 0xB60) { + if (loadraw) { + for (i = 0; i < 28; i++) + CPUWriteByte(MEM2 + 0x18 + i, scanmap[i]); + } else { + CPUWriteMemory(MEM2 + 0x18, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 4, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 8, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 12, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 16, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 20, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 0x18 + 24, 0xB1B1F2F1); + } + CPUWriteMemory(MEM2 + 0x40, 0x19); + CPUWriteMemory(MEM2 + 0x44, 0x34); + } else if (size == 0x750) { + if (loadraw) { + for (i = 0; i < 18; i++) + CPUWriteByte(MEM2 + i, scanmap[i]); + } else { + CPUWriteMemory(MEM2, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 4, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 8, 0xF1F1F1F1); + CPUWriteMemory(MEM2 + 12, 0xF2F1F1F1); + CPUWriteMemory(MEM2 + 16, 0xB1B1); + } + CPUWriteMemory(MEM2 + 0x40, 0x01); + CPUWriteMemory(MEM2 + 0x44, 0x12); + } + CPUWriteMemory(MEM2 + 0x48, 0x3C); + CPUWriteMemory(MEM2 + 0x4C, MEM2); + + return 0; +} + +void EReaderWriteMemory(uint32_t address, uint32_t value) +{ + switch (address >> 24) { + case 2: + WRITE32LE(((uint32_t*)&workRAM[address & 0x3FFFF]), value); + break; + case 3: + WRITE32LE(((uint32_t*)&internalRAM[address & 0x7FFF]), value); + break; + default: + WRITE32LE(((uint32_t*)&rom[address & 0x1FFFFFF]), value); + //rom[address & 0x1FFFFFF] = data; + break; + } +} + +void BIOS_EReader_ScanCard(int swi_num) +{ + + int i, j, k; + int dotcodetype; + + int global1, global2; + + FILE* f; + + i = j = k = 0; + //Open dotcode bin/raw + + if (swi_num == 0xE0) { + dotcodepointer = 0; + dotcodeinterleave = 0; + decodestate = 0; + + const char* loadDotCodeFile = GetLoadDotCodeFile(); + + if (loadDotCodeFile == 0) { + reg[0].I = 0x301; + return; + } + f = fopen(loadDotCodeFile, "rb"); + //f=fopen(filebuffer,"rb"); + //f=fopen("dotcode4.raw","rb"); + if (f == NULL) { + reg[0].I = 0x303; + return; + } + fseek(f, 0, SEEK_END); + i = ftell(f); + fseek(f, 0, SEEK_SET); + if ((i == 0xB60) || (i == 0x750)) { + dotcodetype = 0; + } else if ((i == 0x81C) || (i == 0x51C)) { + dotcodetype = 1; + } else { + fclose(f); + reg[0].I = 0x303; + return; + } + DotCodeData = (unsigned char*)malloc(i); + if (DotCodeData == NULL) { + reg[0].I = 0x303; + return; + } + FREAD_UNCHECKED(DotCodeData, 1, i, f); + fclose(f); + + if (dotcodetype == 0) { + + switch (CheckEReaderRegion()) { + case 1: //US + LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x2032D14, 0x2028B28, 1); + EReaderWriteMemory(0x80091BA, 0x46C0DFE2); + break; + case 2: + LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x2006EC4, 0x2002478, 1); + EReaderWriteMemory(0x8008B12, 0x46C0DFE2); + break; + case 3: + LoadDotCodeData(i, (uint32_t*)DotCodeData, 0x202F8A4, 0x2031034, 1); + EReaderWriteMemory(0x800922E, 0x46C0DFE2); + break; + } + reg[0].I = 0; + free(DotCodeData); + } else { + //dotcodesize = i; + if (i == 0x81C) + dotcodesize = 0xB60; + else + dotcodesize = 0x750; + + switch (CheckEReaderRegion()) { + case 1: //US + LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x2032D14, 0x2028B28, 0); + EReaderWriteMemory(0x80091BA, 0x46C0DFE1); + break; + case 2: + LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x2006EC4, 0x2002478, 0); + EReaderWriteMemory(0x8008B12, 0x46C0DFE1); + break; + case 3: + LoadDotCodeData(dotcodesize, (uint32_t*)NULL, 0x202F8A4, 0x2031034, 0); + EReaderWriteMemory(0x800922E, 0x46C0DFE1); + break; + } + reg[0].I = 0; + dotcodesize = i; + } + } else if (swi_num == 0xE1) { + + switch (CheckEReaderRegion()) { + case 1: //US + EReaderWriteMemory(0x80091BA, 0xF8A5F03B); + EReaderWriteMemory(0x3002F7C, 0xEFE40000); //Beginning of Reed-Solomon decoder + EReaderWriteMemory(0x3003144, 0xCA00002F); //Fix required to Correct 16 "Erasures" + EReaderWriteMemory(0x300338C, 0xEFE50000); //End of Reed-Solomon decoder + GFpow = 0x3000A6C; + break; + case 2: + EReaderWriteMemory(0x8008B12, 0xFB0BF035); + EReaderWriteMemory(0x3002F88, 0xEFE40000); + EReaderWriteMemory(0x3003150, 0xCA00002F); + EReaderWriteMemory(0x3003398, 0xEFE50000); + GFpow = 0x3000A78; + break; + case 3: + EReaderWriteMemory(0x800922E, 0xF94BF04B); + EReaderWriteMemory(0x3002F7C, 0xEFE40000); + EReaderWriteMemory(0x3003144, 0xCA00002F); + EReaderWriteMemory(0x300338C, 0xEFE50000); + GFpow = 0x3000A6C; + break; + } + + armNextPC -= 2; + reg[15].I -= 2; + if (armState) + ARM_PREFETCH + else + THUMB_PREFETCH + + for (i = 0, j = 0; i < 12; i++) + j ^= DotCodeData[i]; + if (dotcodesize == 0x81C) { + LongDotCodeHeader[0x2E] = j; + LongDotCodeHeader[0x0D] = DotCodeData[0]; + LongDotCodeHeader[0x0C] = DotCodeData[1]; + LongDotCodeHeader[0x11] = DotCodeData[2]; + LongDotCodeHeader[0x10] = DotCodeData[3]; + + LongDotCodeHeader[0x26] = DotCodeData[4]; + LongDotCodeHeader[0x27] = DotCodeData[5]; + LongDotCodeHeader[0x28] = DotCodeData[6]; + LongDotCodeHeader[0x29] = DotCodeData[7]; + LongDotCodeHeader[0x2A] = DotCodeData[8]; + LongDotCodeHeader[0x2B] = DotCodeData[9]; + LongDotCodeHeader[0x2C] = DotCodeData[10]; + LongDotCodeHeader[0x2D] = DotCodeData[11]; + + LongDotCodeHeader[0x12] = 0x10; //calculate Global Checksum 1 + LongDotCodeHeader[0x02] = 1; //Do not calculate Global Checksum 2 + + for (i = 0x0C, j = 0; i < 0x81C; i++) { + if (i & 1) + j += DotCodeData[i]; + else + j += (DotCodeData[i] << 8); + } + j &= 0xFFFF; + j ^= 0xFFFF; + LongDotCodeHeader[0x13] = (j & 0xFF00) >> 8; + LongDotCodeHeader[0x14] = (j & 0x00FF); + + for (i = 0, j = 0; i < 0x2F; i++) + j += LongDotCodeHeader[i]; + j &= 0xFF; + for (i = 1, global2 = 0; i < 0x2C; i++) { + for (k = 0, global1 = 0; k < 0x30; k++) { + global1 ^= DotCodeData[((i - 1) * 0x30) + k + 0x0C]; + } + global2 += global1; + } + global2 += j; + global2 &= 0xFF; + global2 ^= 0xFF; + LongDotCodeHeader[0x2F] = global2; + + } else { + ShortDotCodeHeader[0x2E] = j; + ShortDotCodeHeader[0x0D] = DotCodeData[0]; + ShortDotCodeHeader[0x0C] = DotCodeData[1]; + ShortDotCodeHeader[0x11] = DotCodeData[2]; + ShortDotCodeHeader[0x10] = DotCodeData[3]; + + ShortDotCodeHeader[0x26] = DotCodeData[4]; + ShortDotCodeHeader[0x27] = DotCodeData[5]; + ShortDotCodeHeader[0x28] = DotCodeData[6]; + ShortDotCodeHeader[0x29] = DotCodeData[7]; + ShortDotCodeHeader[0x2A] = DotCodeData[8]; + ShortDotCodeHeader[0x2B] = DotCodeData[9]; + ShortDotCodeHeader[0x2C] = DotCodeData[10]; + ShortDotCodeHeader[0x2D] = DotCodeData[11]; + + ShortDotCodeHeader[0x12] = 0x10; //calculate Global Checksum 1 + ShortDotCodeHeader[0x02] = 1; //Do not calculate Global Checksum 2 + + for (i = 0x0C, j = 0; i < 0x51C; i++) { + if (i & 1) + j += DotCodeData[i]; + else + j += (DotCodeData[i] << 8); + } + j &= 0xFFFF; + j ^= 0xFFFF; + ShortDotCodeHeader[0x13] = (j & 0xFF00) >> 8; + ShortDotCodeHeader[0x14] = (j & 0x00FF); + + for (i = 0, j = 0; i < 0x2F; i++) + j += ShortDotCodeHeader[i]; + j &= 0xFF; + for (i = 1, global2 = 0; i < 0x1C; i++) { + for (k = 0, global1 = 0; k < 0x30; k++) { + global1 ^= DotCodeData[((i - 1) * 0x30) + k + 0x0C]; + } + global2 += global1; + } + global2 += j; + global2 &= 0xFF; + global2 ^= 0xFF; + ShortDotCodeHeader[0x2F] = global2; + } + + } else if (swi_num == 0xE2) //Header + { + switch (CheckEReaderRegion()) { + case 1: //US + EReaderWriteMemory(0x80091BA, 0xF8A5F03B); + EReaderWriteMemory(0x300338C, 0xEFE30000); + GFpow = 0x3000A6C; + break; + case 2: + EReaderWriteMemory(0x8008B12, 0xFB0BF035); + EReaderWriteMemory(0x3003398, 0xEFE30000); + GFpow = 0x3000A78; + break; + case 3: + EReaderWriteMemory(0x800922E, 0xF94BF04B); + EReaderWriteMemory(0x300338C, 0xEFE30000); + GFpow = 0x3000A6C; + break; + } + armNextPC -= 2; + reg[15].I -= 2; + if (armState) + ARM_PREFETCH + else + THUMB_PREFETCH + } else if ((swi_num == 0xE3) || (swi_num == 0xE5)) //Dotcode data + { + if ((reg[0].I >= 0) && (reg[0].I <= 0x10)) { + if (decodestate == 0) { + for (i = 0x17; i >= 0; i--) { + if ((0x17 - i) < 8) + j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)); + else + j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)) ^ 0xFF; + + dotcodeheader[(0x17 - i)] = j; + dotcodeheader[(0x17 - i) + 0x18] = j; + dotcodeheader[(0x17 - i) + 0x30] = j; + } + for (i = 0; i < 28; i++) + for (j = 0; j < 2; j++) + dotcodedata[(i * 0x68) + j] = dotcodeheader[(i * 2) + j]; + dotcodeinterleave = dotcodeheader[7]; + decodestate = 1; + } else { + for (i = 0x3F; i >= 0; i--) { + if ((0x3F - i) < 0x30) + j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)); + else + j = CPUReadByte(GFpow + CPUReadByte(GFpow + 0x200 + i)) ^ 0xFF; + dotcodetemp[((0x3F - i) * dotcodeinterleave) + dotcodepointer] = j; + } + dotcodepointer++; + + if (dotcodepointer == dotcodeinterleave) { + switch (dotcodeinterleave) { + case 0x1C: + j = 0x724; + k = 0x750 - j; + break; + case 0x2C: + j = 0xB38; + k = 0xB60 - j; + break; + } + dotcodepointer = 0; + for (i = 2; i < j; i++) { + if ((i % 0x68) == 0) + i += 2; + dotcodedata[i] = dotcodetemp[dotcodepointer++]; + } + if (swi_num == 0xE3) { + const char* loadDotCodeFile = GetLoadDotCodeFile(); + f = fopen(loadDotCodeFile, "rb+"); + if (f != NULL) { + fwrite(dotcodedata, 1, j, f); + fclose(f); + } + } else { + const char* saveDotCodeFile = GetSaveDotCodeFile(); + if (saveDotCodeFile) { + f = fopen(saveDotCodeFile, "wb"); + if (f != NULL) { + fwrite(dotcodedata, 1, j, f); + fwrite(Signature, 1, 0x28, f); + if (j == 0x724) { + fputc(0x65, f); + fputc(0x02, f); + fputc(0x71, f); + fputc(0x10, f); + } + fclose(f); + } + } + free(DotCodeData); + } + } + } + } + + int base = 14; + armState = reg[base].I & 1 ? false : true; + if (armState) { + reg[15].I = reg[base].I & 0xFFFFFFFC; + armNextPC = reg[15].I; + reg[15].I += 4; + ARM_PREFETCH + } else { + reg[15].I = reg[base].I & 0xFFFFFFFE; + armNextPC = reg[15].I; + reg[15].I += 2; + THUMB_PREFETCH + } + } else if (swi_num == 0xE4) { + reg[12].I = reg[13].I; + if (decodestate == 0) { + for (i = 0; i < 0x18; i++) { + if (dotcodesize == 0x81C) + j = longheader[i]; + else + j = shortheader[i]; + + if (i < 8) + j = CPUReadByte(GFpow + 0x100 + j); + else + j = CPUReadByte(GFpow + 0x100 + (j ^ 0xFF)); + + CPUWriteByte(GFpow + 0x200 + (0x17 - i), j); + } + } else { + if (dotcodepointer == 0) { + for (i = 0; i < 0x30; i++) { + if (dotcodesize == 0x81C) + j = LongDotCodeHeader[i]; + else + j = ShortDotCodeHeader[i]; + + j = CPUReadByte(GFpow + 0x100 + j); + CPUWriteByte(GFpow + 0x200 + (0x3F - i), j); + } + + } else { + for (i = 0; i < 0x30; i++) { + + j = DotCodeData[((dotcodepointer - 1) * 0x30) + 0x0C + i]; + j = CPUReadByte(GFpow + 0x100 + j); + CPUWriteByte(GFpow + 0x200 + (0x3F - i), j); + } + } + for (i = 0; i < 16; i++) + CPUWriteByte(GFpow + 0x258 + i, 1); //16 Erasures on the parity bytes, to have them calculated. + } + } +} diff --git a/src/gba/ereader.h b/src/gba/ereader.h index 72d8209b..2fa3b8e0 100644 --- a/src/gba/ereader.h +++ b/src/gba/ereader.h @@ -1,9 +1,9 @@ -extern unsigned char* DotCodeData; -extern char filebuffer[]; - -int OpenDotCodeFile(void); -int CheckEReaderRegion(void); -int LoadDotCodeData(int size, uint32_t* DCdata, unsigned long MEM1, unsigned long MEM2); -void EReaderWriteMemory(uint32_t address, uint32_t value); - -void BIOS_EReader_ScanCard(int swi_num); +extern unsigned char* DotCodeData; +extern char filebuffer[]; + +int OpenDotCodeFile(void); +int CheckEReaderRegion(void); +int LoadDotCodeData(int size, uint32_t* DCdata, unsigned long MEM1, unsigned long MEM2); +void EReaderWriteMemory(uint32_t address, uint32_t value); + +void BIOS_EReader_ScanCard(int swi_num); diff --git a/src/gba/remote.cpp b/src/gba/remote.cpp index 3ef18bf9..3478f091 100644 --- a/src/gba/remote.cpp +++ b/src/gba/remote.cpp @@ -349,6 +349,7 @@ void debuggerDontBreak(int n, char** args) void debuggerDontBreakClear(int n, char** args) { + (void)args; // unused params if (n == 1) { debuggerNumOfDontBreak = 0; { @@ -782,7 +783,7 @@ unsigned int AddressToGBA(uint8_t* mem) void debuggerDoSearch() { - int count = 0; + unsigned int count = 0; while (true) { unsigned int final = SearchStart + SearchLength - 1; @@ -1882,6 +1883,8 @@ void debuggerSymbols(int argc, char** argv) void debuggerWhere(int n, char** args) { + (void)n; // unused params + (void)args; // unused params void elfPrintCallChain(uint32_t); elfPrintCallChain(armNextPC); } @@ -1958,6 +1961,7 @@ void debuggerVar(int n, char** args) bool debuggerBreakOnExecution(uint32_t address, uint8_t state) { + (void)state; // unused params if (dontBreakNow) return false; if (debuggerInDB(address)) @@ -1975,6 +1979,7 @@ bool debuggerBreakOnExecution(uint32_t address, uint8_t state) bool debuggerBreakOnRead(uint32_t address, int size) { + (void)size; // unused params if (dontBreakNow) return false; if (debuggerInDB(armState ? reg[15].I - 4 : reg[15].I - 2)) @@ -1996,6 +2001,8 @@ bool debuggerBreakOnRead(uint32_t address, int size) bool debuggerBreakOnWrite(uint32_t address, uint32_t value, int size) { + (void)value; // unused params + (void)size; // unused params if (dontBreakNow) return false; if (debuggerInDB(armState ? reg[15].I - 4 : reg[15].I - 2)) @@ -2019,6 +2026,8 @@ bool debuggerBreakOnWrite(uint32_t address, uint32_t value, int size) void debuggerBreakOnWrite(uint32_t address, uint32_t oldvalue, uint32_t value, int size, int t) { + (void)oldvalue; // unused params + (void)t; // unused params debuggerBreakOnWrite(address, value, size); //uint32_t lastValue; //dexp_eval("old_value", &lastValue); @@ -2677,6 +2686,8 @@ void deleteBreak(uint32_t address, uint8_t flags, char** expression, int howToDe } void clearBreaks(uint32_t address, uint8_t flags, char** expression, int howToClear) { + (void)address; // unused params + (void)expression; // unused params if (howToClear == 2) { removeConditionalWithFlag(flags, true); removeConditionalWithFlag(flags << 4, true); @@ -2692,6 +2703,7 @@ void clearBreaks(uint32_t address, uint8_t flags, char** expression, int howToCl void listBreaks(uint32_t address, uint8_t flags, char** expression, int howToList) { + (void)expression; // unused params flags |= (flags << 4); if (howToList) { printAllFlagConditionalsWithAddress(address, flags, true); @@ -2896,8 +2908,7 @@ void executeBreakCommands(int n, char** cmd) operation(address, flag, cmd + 1, n - 1); return; } - -brkcmd_special_register: +//brkcmd_special_register: switch (command[4]) { case 'l': debuggerBreakRegisterList((n > 0) && (tolower(cmd[0][0]) == 'v')); @@ -3786,7 +3797,7 @@ void remoteSetBreakPoint(char* p) void remoteClearBreakPoint(char* p) { - int result; + int result = 0; uint32_t address; int count; sscanf(p, ",%x,%x#", &address, &count); @@ -3975,6 +3986,7 @@ void remoteReadRegister(char* p) void remoteReadRegisters(char* p) { + (void)p; // unused params char buffer[1024]; char* s = buffer; @@ -4233,6 +4245,7 @@ void remoteStubMain() void remoteStubSignal(int sig, int number) { + (void)number; // unused params remoteSignal = sig; remoteResumed = false; remoteSendStatus(); diff --git a/src/gba/remote.h b/src/gba/remote.h index b42084f0..d71ed02f 100644 --- a/src/gba/remote.h +++ b/src/gba/remote.h @@ -1,79 +1,79 @@ -#ifndef REMOTE_H -#define REMOTE_H - -#include "GBA.h" - -#define BitSet(array, bit) ((uint8_t*)(array))[(bit) >> 3] |= (1 << ((bit)&7)) - -#define BitClear(array, bit) ((uint8_t*)(array))[(bit) >> 3] &= ~(1 << ((bit)&7)) - -#define BitGet(array, bit) ((uint8_t)((array)[(bit) >> 3]) & (uint8_t)(1 << ((bit)&7))) - -#define BreakSet(array, addr, flag) \ - ((uint8_t*)(array))[(addr) >> 1] |= ((addr & 1) ? (flag << 4) : (flag & 0xf)) - -#define BreakClear(array, addr, flag) \ - ((uint8_t*)(array))[(addr) >> 1] &= ~((addr & 1) ? (flag << 4) : (flag & 0xf)) - -// check -#define BreakThumbCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x80 : 0x8) - -#define BreakARMCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x40 : 0x4) - -#define BreakReadCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x20 : 0x2) - -#define BreakWriteCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x10 : 0x1) - -#define BreakCheck(array, addr, flag) \ - ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? (flag << 4) : (flag & 0xf)) - -extern bool debugger; - -extern bool dexp_eval(char*, uint32_t*); -extern void dexp_setVar(char*, uint32_t); -extern void dexp_listVars(); -extern void dexp_saveVars(char*); -extern void dexp_loadVars(char*); - -void debuggerOutput(const char* s, uint32_t addr); - -bool debuggerBreakOnExecution(uint32_t address, uint8_t state); -bool debuggerBreakOnWrite(uint32_t address, uint32_t value, int size); -void debuggerBreakOnWrite(uint32_t address, uint32_t oldvalue, uint32_t value, int size, int t); -bool debuggerBreakOnRead(uint32_t address, int size); - -struct regBreak { - // uint8_t regNum; /No longer needed - // bit 0 = equal - // bit 1 = greater - // bit 2 = smaller - // bit 3 = signed - uint8_t flags; - uint32_t intVal; - struct regBreak* next; -}; -extern uint8_t lowRegBreakCounter[4]; //(r0-r3) -extern uint8_t medRegBreakCounter[4]; //(r4-r7) -extern uint8_t highRegBreakCounter[4]; //(r8-r11) -extern uint8_t statusRegBreakCounter[4]; //(r12-r15) - -extern bool enableRegBreak; -extern regBreak* breakRegList[16]; -extern void breakReg_check(int i); - -struct regBreak* getFromBreakRegList(uint8_t regnum, int location); - -void clearBreakRegList(); -void clearParticularRegListBreaks(int reg); -void deleteFromBreakRegList(uint8_t regnum, int location); - -void addBreakRegToList(uint8_t regnum, uint8_t flags, uint32_t value); -void printBreakRegList(bool verbose); - -void remoteStubMain(); -void remoteStubSignal(int sig, int number); -void remoteOutput(const char* s, uint32_t addr); -void remoteSetProtocol(int p); -void remoteSetPort(int port); - -#endif // REMOTE_H +#ifndef REMOTE_H +#define REMOTE_H + +#include "GBA.h" + +#define BitSet(array, bit) ((uint8_t*)(array))[(bit) >> 3] |= (1 << ((bit)&7)) + +#define BitClear(array, bit) ((uint8_t*)(array))[(bit) >> 3] &= ~(1 << ((bit)&7)) + +#define BitGet(array, bit) ((uint8_t)((array)[(bit) >> 3]) & (uint8_t)(1 << ((bit)&7))) + +#define BreakSet(array, addr, flag) \ + ((uint8_t*)(array))[(addr) >> 1] |= ((addr & 1) ? (flag << 4) : (flag & 0xf)) + +#define BreakClear(array, addr, flag) \ + ((uint8_t*)(array))[(addr) >> 1] &= ~((addr & 1) ? (flag << 4) : (flag & 0xf)) + +// check +#define BreakThumbCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x80 : 0x8) + +#define BreakARMCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x40 : 0x4) + +#define BreakReadCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x20 : 0x2) + +#define BreakWriteCheck(array, addr) ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? 0x10 : 0x1) + +#define BreakCheck(array, addr, flag) \ + ((uint8_t*)(array))[(addr) >> 1] & ((addr & 1) ? (flag << 4) : (flag & 0xf)) + +extern bool debugger; + +extern bool dexp_eval(char*, uint32_t*); +extern void dexp_setVar(char*, uint32_t); +extern void dexp_listVars(); +extern void dexp_saveVars(char*); +extern void dexp_loadVars(char*); + +void debuggerOutput(const char* s, uint32_t addr); + +bool debuggerBreakOnExecution(uint32_t address, uint8_t state); +bool debuggerBreakOnWrite(uint32_t address, uint32_t value, int size); +void debuggerBreakOnWrite(uint32_t address, uint32_t oldvalue, uint32_t value, int size, int t); +bool debuggerBreakOnRead(uint32_t address, int size); + +struct regBreak { + // uint8_t regNum; /No longer needed + // bit 0 = equal + // bit 1 = greater + // bit 2 = smaller + // bit 3 = signed + uint8_t flags; + uint32_t intVal; + struct regBreak* next; +}; +extern uint8_t lowRegBreakCounter[4]; //(r0-r3) +extern uint8_t medRegBreakCounter[4]; //(r4-r7) +extern uint8_t highRegBreakCounter[4]; //(r8-r11) +extern uint8_t statusRegBreakCounter[4]; //(r12-r15) + +extern bool enableRegBreak; +extern regBreak* breakRegList[16]; +extern void breakReg_check(int i); + +struct regBreak* getFromBreakRegList(uint8_t regnum, int location); + +void clearBreakRegList(); +void clearParticularRegListBreaks(int reg); +void deleteFromBreakRegList(uint8_t regnum, int location); + +void addBreakRegToList(uint8_t regnum, uint8_t flags, uint32_t value); +void printBreakRegList(bool verbose); + +void remoteStubMain(); +void remoteStubSignal(int sig, int number); +void remoteOutput(const char* s, uint32_t addr); +void remoteSetProtocol(int p); +void remoteSetPort(int port); + +#endif // REMOTE_H diff --git a/src/libretro/SoundRetro.cpp b/src/libretro/SoundRetro.cpp index a71a4b47..f4093fbb 100644 --- a/src/libretro/SoundRetro.cpp +++ b/src/libretro/SoundRetro.cpp @@ -33,6 +33,7 @@ void SoundRetro::write(uint16_t* finalWave, int length) bool SoundRetro::init(long sampleRate) { + (void)sampleRate; // unused param return true; } @@ -51,3 +52,8 @@ void SoundRetro::resume() void SoundRetro::reset() { } + +void SoundRetro::setThrottle(unsigned short throttle) +{ + (void)throttle; // unused param +} diff --git a/src/libretro/SoundRetro.h b/src/libretro/SoundRetro.h index 53236ed3..43ef5403 100644 --- a/src/libretro/SoundRetro.h +++ b/src/libretro/SoundRetro.h @@ -30,6 +30,7 @@ public: virtual void reset(); virtual void resume(); virtual void write(uint16_t* finalWave, int length); + virtual void setThrottle(unsigned short throttle); }; #endif // __VBA_SOUND_RETRO_H__ diff --git a/src/libretro/UtilRetro.cpp b/src/libretro/UtilRetro.cpp index 00bbc560..2c1afdea 100644 --- a/src/libretro/UtilRetro.cpp +++ b/src/libretro/UtilRetro.cpp @@ -192,7 +192,7 @@ uint8_t *utilLoad(const char *file, bool (*accept)(const char *), uint8_t *data, } } - fread(image, 1, size, fp); // read into buffer + FREAD_UNCHECKED(image, 1, size, fp); // read into buffer fclose(fp); return image; } diff --git a/src/sdl/SDL.cpp b/src/sdl/SDL.cpp index 9697ae44..86d86201 100644 --- a/src/sdl/SDL.cpp +++ b/src/sdl/SDL.cpp @@ -492,7 +492,8 @@ static void sdlOpenGLVideoResize() void sdlOpenGLInit(int w, int h) { - + (void)w; // unused params + (void)h; // unused params #if 0 float screenAspect = (float) sizeX / sizeY, windowAspect = (float) w / h; @@ -2058,6 +2059,7 @@ int main(int argc, char** argv) void systemMessage(int num, const char* msg, ...) { + (void)num; // unused params va_list valist; va_start(valist, msg); @@ -2290,6 +2292,12 @@ uint32_t systemGetClock() void systemGbPrint(uint8_t* data, int len, int pages, int feed, int palette, int contrast) { + (void)data; // unused params + (void)len; // unused params + (void)pages; // unused params + (void)feed; // unused params + (void)palette; // unused params + (void)contrast; // unused params } /* xKiv: added timestamp */ @@ -2412,6 +2420,8 @@ void systemOnSoundShutdown() void systemOnWriteDataToSoundBuffer(const uint16_t* finalWave, int length) { + (void)finalWave; // unused params + (void)length; // unused params } void log(const char* defaultMsg, ...) diff --git a/src/sdl/expr.cpp b/src/sdl/expr.cpp index 4a489581..0b8cc978 100644 --- a/src/sdl/expr.cpp +++ b/src/sdl/expr.cpp @@ -1530,6 +1530,7 @@ yyreturn: int yyerror(const char* s) { + (void)s; // unused params return 0; } diff --git a/src/sdl/exprNode.cpp b/src/sdl/exprNode.cpp index d1bee523..b78c9578 100644 --- a/src/sdl/exprNode.cpp +++ b/src/sdl/exprNode.cpp @@ -97,6 +97,9 @@ Node* exprNodeNumber() bool exprNodeNumberResolve(Node* n, Function* f, CompileUnit* u) { + (void)n; // unused params + (void)f; // unused params + (void)u; // unused params return true; } diff --git a/src/sdl/filters.cpp b/src/sdl/filters.cpp index f3d02499..6489bbe4 100644 --- a/src/sdl/filters.cpp +++ b/src/sdl/filters.cpp @@ -605,6 +605,7 @@ void (*sdlStretcher24[4])(uint8_t*, uint8_t*, int) = { bool sdlStretchInit(int colorDepth, int sizeMultiplier, int srcWidth) { + (void)srcWidth; // unused params #ifndef C_CORE sdlMakeStretcher(srcWidth, sizeMultiplier); #else diff --git a/src/wx/cmdevents.cpp b/src/wx/cmdevents.cpp index fa75dd98..5923b3bf 100644 --- a/src/wx/cmdevents.cpp +++ b/src/wx/cmdevents.cpp @@ -50,7 +50,7 @@ void MainFrame::GetMenuOptionBool(const char* menuName, bool& field) field = !field; int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -65,7 +65,7 @@ void MainFrame::GetMenuOptionInt(const char* menuName, int& field, int mask) bool is_checked = ((field) & (mask)) != (value); int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -80,7 +80,7 @@ void MainFrame::SetMenuOption(const char* menuName, int value) { int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -506,6 +506,7 @@ static bool maker_lt(const rom_maker& r1, const rom_maker& r2) void SetDialogLabel(wxDialog* dlg, const wxString& id, wxString ts, size_t l) { + (void)l; // unused params ts.Replace(wxT("&"), wxT("&&"), true); (dynamic_cast((*dlg).FindWindow(wxXmlResource::GetXRCID(id))))->SetLabel(ts); } @@ -548,7 +549,7 @@ EVT_HANDLER_MASK(RomInformation, "ROM information...", CMDEN_GB | CMDEN_GBA) s.Printf(wxT("%02x"), gbRom[0x14b]); setlab("MakerCode"); - const rom_maker m = { s }, *rm; + const rom_maker m = { s, wxString() }, *rm; rm = std::lower_bound(&makers[0], &makers[num_makers], m, maker_lt); if (rm < &makers[num_makers] && !wxStrcmp(m.code, rm->code)) @@ -776,7 +777,7 @@ EVT_HANDLER_MASK(RomInformation, "ROM information...", CMDEN_GB | CMDEN_GBA) SetDialogLabel(dlg, wxT("CRC32"), rom_crc32, 8); setlabs("GameCode", rom[0xac], 4); setlabs("MakerCode", rom[0xb0], 2); - const rom_maker m = { s }, *rm; + const rom_maker m = { s, wxString() }, *rm; rm = std::lower_bound(&makers[0], &makers[num_makers], m, maker_lt); if (rm < &makers[num_makers] && !wxStrcmp(m.code, rm->code)) @@ -804,6 +805,9 @@ EVT_HANDLER_MASK(RomInformation, "ROM information...", CMDEN_GB | CMDEN_GBA) dlg->Fit(); ShowModal(dlg); } break; + + default: + break; } } @@ -971,7 +975,7 @@ EVT_HANDLER_MASK(ImportGamesharkCodeFile, "Import GameShark code file...", CMDEN game = lst->GetSelection(); - if (game == wxNOT_FOUND) + if ((int)game == wxNOT_FOUND) game = 0; } @@ -1606,7 +1610,7 @@ EVT_HANDLER_MASK(Rewind, "Rewind", CMDEN_REWIND) // if within 5 seconds of last one, and > 1 state, delete last state & move back // FIXME: 5 should actually be user-configurable // maybe instead of 5, 10% of rewind_interval - if (panel->num_rewind_states > 1 && (gopts.rewind_interval <= 5 || panel->rewind_time / 6 > gopts.rewind_interval - 5)) { + if (panel->num_rewind_states > 1 && (gopts.rewind_interval <= 5 || (int)panel->rewind_time / 6 > gopts.rewind_interval - 5)) { --panel->num_rewind_states; panel->next_rewind_state = rew_st; @@ -1713,7 +1717,7 @@ EVT_HANDLER_MASK(VideoLayersReset, "Show all video layers", CMDEN_GB | CMDEN_GBA #define set_vl(s) \ do { \ int id = XRCID(s); \ - for (int i = 0; i < checkable_mi.size(); i++) \ + for (size_t i = 0; i < checkable_mi.size(); i++) \ if (checkable_mi[i].cmd == id) { \ checkable_mi[i].mi->Check(true); \ break; \ @@ -2291,7 +2295,7 @@ EVT_HANDLER_MASK(ChangeFilter, "Change Pixel Filter", CMDEN_NREC_ANY) { int filt = gopts.filter; - if (filt == FF_PLUGIN || ++gopts.filter == FF_PLUGIN && gopts.filter_plugin.empty()) { + if ((filt == FF_PLUGIN || ++gopts.filter == FF_PLUGIN) && gopts.filter_plugin.empty()) { gopts.filter = 0; } diff --git a/src/wx/copy-events.cmake b/src/wx/copy-events.cmake index 06b30de7..252a5b88 100644 --- a/src/wx/copy-events.cmake +++ b/src/wx/copy-events.cmake @@ -18,7 +18,7 @@ SET(EVLINES ) FOREACH(EV ${MW}) # stripping the wxID_ makes it look better, but it's still all-caps STRING(REGEX REPLACE "^[^\"]*\\((wxID_|)([^,]*),[^\"]*(\"[^\"]*\")[^,)]*(,[^)]*|).*" - " {wxT(\"\\2\"), wxTRANSLATE(\\3), XRCID(\"\\1\\2\")\\4 }" + " new_cmditem(wxT(\"\\2\"), wxTRANSLATE(\\3), XRCID(\"\\1\\2\")\\4 )" EV "${EV}") STRING(REGEX REPLACE "XRCID\\(\"(wxID_[^\"]*)\"\\)" "\\1" EV ${EV}) LIST(APPEND EVLINES "${EV},\n") diff --git a/src/wx/faudio.cpp b/src/wx/faudio.cpp index 3c9cc462..f54e8397 100644 --- a/src/wx/faudio.cpp +++ b/src/wx/faudio.cpp @@ -69,7 +69,7 @@ bool GetFADevices(wxArrayString& names, wxArrayString& ids) } GetFADevices(fa, &names, &ids, NULL); - //fa->Release(); + //fa->Release(); FAudio_Release(fa); return true; } @@ -371,7 +371,7 @@ bool FAudio_Output::init(long sampleRate) wfx.nBlockAlign = wfx.nChannels * (wfx.wBitsPerSample / 8); wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign; // create sound receiver - hr = FAudio_CreateMasteringVoice( + hr = FAudio_CreateMasteringVoice( faud, &mVoice, FAUDIO_DEFAULT_CHANNELS, @@ -386,9 +386,9 @@ bool FAudio_Output::init(long sampleRate) return false; } - // create sound emitter + // create sound emitter //This should be FAudio_CreateSourceVoice() - //hr = faud->CreateSourceVoice(&sVoice, &wfx, 0, 4.0f, ¬ify); + //hr = faud->CreateSourceVoice(&sVoice, &wfx, 0, 4.0f, ¬ify); hr = FAudio_CreateSourceVoice(faud, &sVoice, (const FAudioWaveFormatEx*)&wfx, 0, 4.0f, ¬ify, NULL, NULL); if (hr != S_OK) { @@ -516,7 +516,7 @@ bool FAudio_Output::init(long sampleRate) } void FAudio_Output::write(uint16_t* finalWave, int length) -{ +{ UINT32 flags = 0; if (!initialized || failed) return; diff --git a/src/wx/gfxviewers.cpp b/src/wx/gfxviewers.cpp index a90280be..1a6284f9 100644 --- a/src/wx/gfxviewers.cpp +++ b/src/wx/gfxviewers.cpp @@ -229,7 +229,7 @@ public: s.Printf(wxT("0x%08X"), address); addr->SetLabel(s); - if (!mode || (mode < 3 || mode > 5) && bg < 2) { + if ((!mode || (mode < 3 || mode > 5)) && bg < 2) { uint16_t value = *((uint16_t*)&vram[address - 0x6000000]); s.Printf(wxT("%d"), value & 1023); tile->SetLabel(s); @@ -738,6 +738,10 @@ void MainFrame::MapViewer() case IMAGE_GB: LoadXRCViewer(GBMap); break; + + case IMAGE_UNKNOWN: + // do nothing + break; } } @@ -1113,6 +1117,10 @@ void MainFrame::OAMViewer() case IMAGE_GB: LoadXRCViewer(GBOAM); break; + + case IMAGE_UNKNOWN: + // do nothing + break; } } @@ -1233,11 +1241,13 @@ public: } void SelBG(wxMouseEvent& ev) { + (void)ev; // unused params spv->SetSel(-1, -1, false); ShowSel(); } void SelSprite(wxMouseEvent& ev) { + (void)ev; // unused params bpv->SetSel(-1, -1, false); ShowSel(); } @@ -1273,14 +1283,17 @@ public: } void SaveBG(wxCommandEvent& ev) { + (void)ev; // unused params savepal(this, colbmp, 16 * 16, wxT("bg")); } void SaveOBJ(wxCommandEvent& ev) { + (void)ev; // unused params savepal(this, colbmp + 16 * 16 * 3, 16 * 16, wxT("obj")); } void ChangeBackdrop(wxCommandEvent& ev) { + (void)ev; // unused params // FIXME: this should really be a preference // should also have some way of indicating selection // perhaps replace w/ checkbox + colorpickerctrl @@ -1294,7 +1307,7 @@ public: *cd = dlg.GetColourData(); wxColour c = cd->GetColour(); //Binary or the upper 5 bits of each color choice - customBackdropColor = (c.Red() >> 3) || ((c.Green() >> 3) << 5) || ((c.Blue() >> 3) << 10); + customBackdropColor = ((c.Red() >> 3) != 0) || (((c.Green() >> 3) << 5) != 0) || (((c.Blue() >> 3) << 10) != 0); } else // kind of an unintuitive way to turn it off... customBackdropColor = -1; @@ -1347,11 +1360,13 @@ public: } void SelBG(wxMouseEvent& ev) { + (void)ev; // unused params spv->SetSel(-1, -1, false); ShowSel(); } void SelSprite(wxMouseEvent& ev) { + (void)ev; // unused params bpv->SetSel(-1, -1, false); ShowSel(); } @@ -1386,10 +1401,12 @@ public: } void SaveBG(wxCommandEvent& ev) { + (void)ev; // unused params savepal(this, colbmp, 4 * 8, wxT("bg")); } void SaveOBJ(wxCommandEvent& ev) { + (void)ev; // unused params savepal(this, colbmp + 4 * 8 * 3, 4 * 8, wxT("obj")); } @@ -1419,6 +1436,10 @@ void MainFrame::PaletteViewer() case IMAGE_GB: LoadXRCViewer(GBPalette); break; + + case IMAGE_UNKNOWN: + // do nothing + break; } } @@ -1687,5 +1708,9 @@ void MainFrame::TileViewer() case IMAGE_GB: LoadXRCViewer(GBTile); break; + + case IMAGE_UNKNOWN: + // do nothing + break; } } diff --git a/src/wx/guiinit.cpp b/src/wx/guiinit.cpp index 6018ddc8..02ac5213 100644 --- a/src/wx/guiinit.cpp +++ b/src/wx/guiinit.cpp @@ -72,10 +72,12 @@ public: wxButton* okb; void ServerOKButton(wxCommandEvent& ev) { + (void)ev; // unused params okb->SetLabel(_("Start!")); } void ClientOKButton(wxCommandEvent& ev) { + (void)ev; // unused params okb->SetLabel(_("Connect")); } // attached to OK, so skip when OK @@ -305,7 +307,7 @@ public: } break; case wxID_REMOVE: { - bool asked = false, restore; + bool asked = false, restore = false; for (int i = list->GetItemCount() - 1; i >= 0; i--) if (list->GetItemState(i, wxLIST_STATE_SELECTED)) { @@ -704,10 +706,14 @@ public: CheatListFill(const CheatListFill& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new CheatListFill(*this); } bool TransferFromWindow() { return true; } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { CheatList_t& clh = cheat_list_handler; @@ -885,6 +891,7 @@ public: void UpdateVals(wxCommandEvent& ev) { + (void)ev; // unused params if (cheatSearchData.count) { cheatSearchUpdateValues(&cheatSearchData); @@ -897,6 +904,7 @@ public: void ResetSearch(wxCommandEvent& ev) { + (void)ev; // unused params if (!cheatSearchData.count) { CheatSearchBlock* block = cheatSearchData.blocks; @@ -988,6 +996,7 @@ public: void AddCheatB(wxCommandEvent& ev) { + (void)ev; // unused params int idx = list->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); if (idx >= 0) @@ -1194,6 +1203,7 @@ public: void UpdateView(wxCommandEvent& ev) { + (void)ev; // unused params dlg->TransferDataFromWindow(); if (ofmt != fmt && !val_s.empty()) { @@ -1282,10 +1292,14 @@ public: CheatFindFill(const CheatFindFill& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new CheatFindFill(*this); } bool TransferFromWindow() { return true; } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { CheatFind_t& cfh = cheat_find_handler; @@ -1313,7 +1327,7 @@ wxString CheatListCtrl::OnGetItemText(long item, long column) const off = (item & ((1 << (cap_size - size)) - 1)) << size; item >>= cap_size - size; } else if (cap_size < size) { - for (int i = 0; i < addrs.size(); i++) { + for (size_t i = 0; i < addrs.size(); i++) { if (!(addrs[i] & ((1 << size) - 1)) && !item--) { item = i; break; @@ -1418,6 +1432,7 @@ public: } void ColorReset(wxCommandEvent& ev) { + (void)ev; // unused params const uint16_t* color = &systemGbPalette[pno * 8]; for (int i = 0; i < 8; i++, color++) @@ -1428,6 +1443,7 @@ public: void ColorButton(wxCommandEvent& ev) { + (void)ev; // unused params c->SetSelection(0); } } GBColorConfigHandler[3]; @@ -1442,10 +1458,14 @@ public: GBACtrlEnabler(const GBACtrlEnabler& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new GBACtrlEnabler(*this); } bool TransferFromWindow() { return true; } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { GetWindow()->Enable(wxGetApp().frame->GetPanel()->game_type() == IMAGE_GBA); @@ -1464,6 +1484,7 @@ public: } void Detect(wxCommandEvent& ev) { + (void)ev; // unused params uint32_t sz = wxGetApp().frame->GetPanel()->game_size(); utilGBAFindSave(sz); type->SetSelection(saveType); @@ -1489,6 +1510,7 @@ public: void FullVol(wxCommandEvent& ev) { + (void)ev; // unused params vol->SetValue(100); } void AdjustFrames(int count) @@ -1499,6 +1521,7 @@ public: } void AdjustFramesEv(wxCommandEvent& ev) { + (void)ev; // unused params AdjustFrames(bufs->GetValue()); } @@ -1548,7 +1571,7 @@ public: dev->SetSelection(0); - for (int i = 0; i < names.size(); i++) { + for (size_t i = 0; i < names.size(); i++) { dev->Append(names[i]); if (api == gopts.audio_api && gopts.audio_dev == dev_ids[i]) @@ -1586,9 +1609,13 @@ public: SoundConfigLoad(const SoundConfigLoad& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new SoundConfigLoad(*this); } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { SoundConfig_t& sch = sound_config_handler; @@ -1649,9 +1676,13 @@ public: ScreenModeList(const ScreenModeList& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new ScreenModeList(*this); } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { wxChoice* c = wxStaticCast(GetWindow(), wxChoice); @@ -1665,7 +1696,7 @@ public: vm = d.GetModes(); wxString s; - for (int i = 0; i < vm.size(); i++) { + for (size_t i = 0; i < vm.size(); i++) { s.Printf(_("%d x %d - %dbpp @ %dHz"), vm[i].w, vm[i].h, vm[i].bpp, vm[i].refresh); c->Append(s); @@ -1723,10 +1754,14 @@ public: PluginEnabler(const PluginEnabler& e) : wxValidator() { + (void)e; // unused params } wxObject* Clone() const { return new PluginEnabler(*this); } bool TransferFromWindow() { return true; } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { GetWindow()->Enable(gopts.filter == FF_PLUGIN); @@ -1751,22 +1786,25 @@ class PluginListFiller : public PluginEnabler { public: PluginListFiller(wxDialog* parent, wxControl* lab, wxChoice* ch) : PluginEnabler() + , dlg(parent) , txt(lab) - , dlg(parent) - , plugins() , filtch(ch) + , plugins() { } PluginListFiller(const PluginListFiller& e) : PluginEnabler() + , dlg(e.dlg) , txt(e.txt) - , dlg(e.dlg) - , plugins(e.plugins) , filtch(e.filtch) + , plugins(e.plugins) { } wxObject* Clone() const { return new PluginListFiller(*this); } - bool Validate(wxWindow* p) { return true; } + bool Validate(wxWindow* p) { + (void)p; // unused params + return true; + } bool TransferToWindow() { PluginEnabler::TransferToWindow(); @@ -1777,10 +1815,10 @@ public: const wxString plpath = wxGetApp().GetPluginsDir(); wxDir::GetAllFiles(plpath, &plugins, wxT("*.rpi"), wxDIR_FILES | wxDIR_DIRS); - for (int i = 0; i < plugins.size(); i++) { + for (size_t i = 0; i < plugins.size(); i++) { wxDynamicLibrary dl(plugins[i], wxDL_VERBATIM | wxDL_NOW); RENDPLUG_GetInfo GetInfo; - const RENDER_PLUGIN_INFO* rpi; + const RENDER_PLUGIN_INFO* rpi = NULL; if (dl.IsLoaded() && (GetInfo = (RENDPLUG_GetInfo)dl.GetSymbol(wxT("RenderPluginGetInfo"))) && // note that in actual kega fusion plugins, rpi->Output is @@ -1802,8 +1840,10 @@ public: if (plugins[i] == gopts.filter_plugin) ch->SetSelection(i + 1); - } else + } + else { plugins.RemoveAt(i--); + } } if (ch->GetCount() == 1) { @@ -1993,7 +2033,7 @@ public: asb->Enable(!key->GetValue().empty()); int cmd = id->val; - for (int i = 0; i < accels.size(); i++) + for (size_t i = 0; i < accels.size(); i++) if (accels[i].GetCommand() == cmdtab[cmd].cmd_id) lb->Append(wxKeyTextCtrl::ToString(accels[i].GetFlags(), accels[i].GetKeyCode())); @@ -2002,12 +2042,14 @@ public: // after selecting a key in key list, enable Remove button void KeySel(wxCommandEvent& ev) { + (void)ev; // unused params remb->Enable(lb->GetSelection() != wxNOT_FOUND); } // remove selected binding void Remove(wxCommandEvent& ev) { + (void)ev; // unused params int lsel = lb->GetSelection(); if (lsel == wxNOT_FOUND) @@ -2038,7 +2080,7 @@ public: // if it's a system accel, disable by assigning to NOOP wxAcceleratorEntry_v& sys_accels = wxGetApp().frame->sys_accels; - for (int i = 0; i < sys_accels.size(); i++) + for (size_t i = 0; i < sys_accels.size(); i++) if (sys_accels[i].GetFlags() == selmod && sys_accels[i].GetKeyCode() == selkey) { wxAcceleratorEntry ne(selmod, selkey, XRCID("NOOP")); user_accels.push_back(ne); @@ -2056,6 +2098,7 @@ public: // wipe out all user bindings void ResetAll(wxCommandEvent& ev) { + (void)ev; // unused params if (user_accels.empty() || wxMessageBox(_("This will clear all user-defined accelerators. Are you sure?"), _("Confirm"), wxYES_NO) != wxYES) return; @@ -2071,6 +2114,7 @@ public: // remove old key binding, add new key binding, and update GUI void Assign(wxCommandEvent& ev) { + (void)ev; // unused params wxTreeItemId csel = tc->GetSelection(); wxString accel = key->GetValue(); @@ -2082,7 +2126,7 @@ public: if (!wxKeyTextCtrl::FromString(accel, acmod, ackey)) return; // this should never happen - for (int i = 0; i < lb->GetCount(); i++) + for (unsigned int i = 0; i < lb->GetCount(); i++) if (lb->GetString(i) == accel) return; // ignore attempts to add twice @@ -2111,6 +2155,7 @@ public: // update curas and maybe enable asb void CheckKey(wxCommandEvent& ev) { + (void)ev; // unused params wxString nkey = key->GetValue(); if (nkey.empty()) { @@ -2131,7 +2176,7 @@ public: asb->Enable(tc->GetSelection().IsOk()); int cmd = -1; - for (int i = 0; i < accels.size(); i++) + for (size_t i = 0; i < accels.size(); i++) if (accels[i].GetFlags() == acmod && accels[i].GetKeyCode() == ackey) { int cmdid = accels[i].GetCommand(); @@ -2218,6 +2263,7 @@ public: // set thrsel from thr void SetThrottleSel(wxSpinEvent& evt) { + (void)evt; // unused params DoSetThrottleSel(thr->GetValue()); } @@ -2232,6 +2278,7 @@ public: // set thr from thrsel void SetThrottle(wxCommandEvent& evt) { + (void)evt; // unused params uint32_t val = thrsel->GetSelection() * 25; if (val <= 600) @@ -2271,6 +2318,7 @@ public: // set speedup_throttle_sel from speedup_throttle void SetSpeedupThrottleSel(wxSpinEvent& evt) { + (void)evt; // unused params DoSetSpeedupThrottleSel(speedup_throttle_spin->GetValue()); } @@ -2289,6 +2337,7 @@ public: // set speedup_throttle from speedup_throttle_sel void SetSpeedupThrottle(wxCommandEvent& evt) { + (void)evt; // unused params uint32_t val = speedup_throttle_sel->GetSelection() * 25; if (val > 0 && val <= 600) { @@ -2311,6 +2360,7 @@ public: // set speedup_frame_skip_sel from speedup_frame_skip void SpeedupFrameSkipCtrl_t::SetSpeedupFrameSkipSel(wxSpinEvent& evt) { + (void)evt; // unused params DoSetSpeedupFrameSkipSel(speedup_frame_skip_spin->GetValue()); } @@ -2329,6 +2379,7 @@ void SpeedupFrameSkipCtrl_t::DoSetSpeedupFrameSkipSel(uint32_t val) // set speedup_frame_skip from speedup_frame_skip_sel void SpeedupFrameSkipCtrl_t::SetSpeedupFrameSkip(wxCommandEvent& evt) { + (void)evt; // unused params uint32_t val = speedup_frame_skip_sel->GetSelection(); if (val > 0 && val <= 30) { @@ -2450,7 +2501,7 @@ wxAcceleratorEntry_v MainFrame::get_accels(wxAcceleratorEntry_v user_accels) // then user overrides // silently keep only last defined binding // same horribly inefficent O(n*m) search for duplicates as above.. - for (int i = 0; i < user_accels.size(); i++) { + for (size_t i = 0; i < user_accels.size(); i++) { const wxAcceleratorEntry& ae = user_accels[i]; for (wxAcceleratorEntry_v::iterator e = accels.begin(); e < accels.end(); ++e) @@ -2476,7 +2527,7 @@ void MainFrame::set_global_accels() // the menus will be added now // first, zero out menu item on all accels - for (int i = 0; i < accels.size(); i++) + for (size_t i = 0; i < accels.size(); i++) accels[i].Set(accels[i].GetFlags(), accels[i].GetKeyCode(), accels[i].GetCommand()); @@ -2494,7 +2545,7 @@ void MainFrame::set_global_accels() int cmd = cmdtab[i].cmd_id; int last_accel = -1; - for (int j = 0; j < accels.size(); j++) + for (size_t j = 0; j < accels.size(); j++) if (cmd == accels[j].GetCommand()) last_accel = j; @@ -2511,14 +2562,14 @@ void MainFrame::set_global_accels() // Finally, install a global accelerator table for any non-menu accels int len = 0; - for (int i = 0; i < accels.size(); i++) + for (size_t i = 0; i < accels.size(); i++) if (!accels[i].GetMenuItem()) len++; if (len) { wxAcceleratorEntry tab[1000]; - for (int i = 0, j = 0; i < accels.size(); i++) + for (size_t i = 0, j = 0; i < accels.size(); i++) if (!accels[i].GetMenuItem()) tab[j++] = accels[i]; @@ -2533,7 +2584,7 @@ void MainFrame::set_global_accels() for (int i = 0; i < 10; i++) recent_accel[i] = wxAcceleratorEntry(); - for (int i = 0; i < accels.size(); i++) + for (size_t i = 0; i < accels.size(); i++) if (accels[i].GetCommand() >= wxID_FILE1 && accels[i].GetCommand() <= wxID_FILE10) recent_accel[accels[i].GetCommand() - wxID_FILE1] = accels[i]; @@ -2544,7 +2595,7 @@ void MainFrame::MenuOptionBool(const char* menuName, bool& field) { int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -2559,7 +2610,7 @@ void MainFrame::MenuOptionIntMask(const char* menuName, int& field, int mask) int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); int value = mask; - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -2575,7 +2626,7 @@ void MainFrame::MenuOptionIntRadioValue(const char* menuName, int& field, int va { int id = wxXmlResource::GetXRCID(wxString(menuName, wxConvUTF8)); - for (int i = 0; i < checkable_mi.size(); i++) { + for (size_t i = 0; i < checkable_mi.size(); i++) { if (checkable_mi[i].cmd != id) continue; @@ -2793,7 +2844,7 @@ bool MainFrame::BindControls() // store checkable items if (mi->IsCheckable()) { - checkable_mi_t cmi = { cmdtab[i].cmd_id, mi }; + checkable_mi_t cmi = { cmdtab[i].cmd_id, mi, NULL, NULL, 0, 0 }; checkable_mi.push_back(cmi); for (int j = 0; j < num_opts; j++) { @@ -2876,7 +2927,7 @@ bool MainFrame::BindControls() MenuOptionIntRadioValue("LinkType4Gameboy", gopts.gba_link_type, 4); } - for (int i = 0; i < checkable_mi.size(); i++) + for (size_t i = 0; i < checkable_mi.size(); i++) if (!checkable_mi[i].boolopt && !checkable_mi[i].intopt) { wxLogError(_("Invalid menu item %s; removing"), checkable_mi[i].mi->GetItemLabelText().c_str()); @@ -3313,6 +3364,7 @@ bool MainFrame::BindControls() } #define getcbbe(n, o) getbe(n, o, cb, wxCheckBox, CB) wxBoolIntEnValidator* bienval; + (void)bienval; // not used yet #define getbie(n, o, v, cv, t, wt) \ do { \ cv = SafeXRCCTRL(d, n); \ @@ -3655,7 +3707,7 @@ bool MainFrame::BindControls() if (menubar) { wxTreeItemId mid = tc->AppendItem(rid, _("Menu commands")); - for (int i = 0; i < menubar->GetMenuCount(); i++) { + for (size_t i = 0; i < menubar->GetMenuCount(); i++) { #if wxCHECK_VERSION(2, 8, 8) wxTreeItemId id = tc->AppendItem(mid, menubar->GetMenuLabelText(i)); #else diff --git a/src/wx/openal.cpp b/src/wx/openal.cpp index 7f4245ad..3c88fa02 100644 --- a/src/wx/openal.cpp +++ b/src/wx/openal.cpp @@ -27,7 +27,8 @@ #ifdef winlog #undef winlog #endif -#define winlog // +// https://stackoverflow.com/a/1306690/262458 +#define winlog(x,...) do {} while(0) #define debugState() // #endif @@ -133,6 +134,7 @@ void OpenAL::debugState() break; } + alGetSourcei(source, AL_BUFFERS_QUEUED, &value); ASSERT_SUCCESS; winlog(" Buffers in queue: %i\n", value); @@ -252,6 +254,7 @@ void OpenAL::reset() void OpenAL::write(uint16_t* finalWave, int length) { + (void)length; // unused param if (!initialized) return; diff --git a/src/wx/opts.cpp b/src/wx/opts.cpp index f1df598a..c6df2b73 100644 --- a/src/wx/opts.cpp +++ b/src/wx/opts.cpp @@ -13,31 +13,30 @@ -p/--profile=hz */ +#define WJKB newWxJoyKeyBinding + /* not sure how well other compilers support field-init syntax */ #define STROPT(c, n, d, v) \ - { \ - wxT(c), (n), d, &v \ - } -#define INTOPT(c, n, d, v, min, max) \ - { \ - wxT(c), (n), d, NULL, &v, wxT(""), min, max \ - } -#define DOUBLEOPT(c, n, d, v, min, max) \ - { \ - wxT(c), (n), d, NULL, NULL, wxT(""), min, max, NULL, &v \ - } -#define UINTOPT(c, n, d, v, min, max) \ - { \ - wxT(c), (n), d, NULL, NULL, wxT(""), min, max, NULL, NULL, &v \ - } -#define BOOLOPT(c, n, d, v) \ - { \ - wxT(c), (n), d, NULL, NULL, wxT(""), 0, 0, &v \ - } -#define ENUMOPT(c, n, d, v, e) \ - { \ - wxT(c), (n), d, NULL, &v, e \ - } + new_opt_desc(wxT(c), (n), d, &v) + +#define INTOPT(c, n, d, v, min, max) \ + new_opt_desc(wxT(c), (n), d, NULL, &v, wxT(""), min, max) + +#define DOUBLEOPT(c, n, d, v, min, max) \ + new_opt_desc(wxT(c), (n), d, NULL, NULL, wxT(""), min, max, NULL, &v) + +#define UINTOPT(c, n, d, v, min, max) \ + new_opt_desc(wxT(c), (n), d, NULL, NULL, wxT(""), min, max, NULL, NULL, &v) + +#define BOOLOPT(c, n, d, v) \ + new_opt_desc(wxT(c), (n), d, NULL, NULL, wxT(""), 0, 0, &v) + +#define ENUMOPT(c, n, d, v, e) \ + new_opt_desc(wxT(c), (n), d, NULL, &v, e) + +#define NOOPT(c, n, d) \ + new_opt_desc(c, (n), d) + opts_t gopts; @@ -137,21 +136,34 @@ const wxString joynames[NUM_KEYS] = { }; wxJoyKeyBinding defkeys[NUM_KEYS * 2] = { - { WXK_UP }, { 1, WXJB_AXIS_MINUS, 1 }, { WXK_DOWN }, { 1, WXJB_AXIS_PLUS, 1 }, - { WXK_LEFT }, { 0, WXJB_AXIS_MINUS, 1 }, { WXK_RIGHT }, { 0, WXJB_AXIS_PLUS, 1 }, - { wxT('X') }, { 0, WXJB_BUTTON, 1 }, { wxT('Z') }, { 1, WXJB_BUTTON, 1 }, - { wxT('A') }, { 2, WXJB_BUTTON, 1 }, { wxT('S') }, { 3, WXJB_BUTTON, 1 }, - { WXK_BACK }, { 4, WXJB_BUTTON, 1 }, { WXK_RETURN }, { 5, WXJB_BUTTON, 1 }, - { WXK_NUMPAD_UP }, { 0 }, { WXK_NUMPAD_DOWN }, { 0 }, - { WXK_NUMPAD_LEFT }, { 0 }, { WXK_NUMPAD_RIGHT }, { 0 }, - { WXK_NUMPAD_PAGEUP }, { 0 }, { WXK_NUMPAD_PAGEDOWN }, { 0 }, - { wxT('W') }, { 0 }, { wxT('Q') }, { 0 }, - { WXK_SPACE }, { 0 }, { 0 }, { 0 }, - { 0 }, { 0 } + WJKB(WXK_UP), WJKB(1, WXJB_AXIS_MINUS, 1), WJKB(WXK_DOWN), WJKB(1, WXJB_AXIS_PLUS, 1), + WJKB(WXK_LEFT), WJKB(0, WXJB_AXIS_MINUS, 1), WJKB(WXK_RIGHT), WJKB(0, WXJB_AXIS_PLUS, 1), + WJKB(wxT('X')), WJKB(0, WXJB_BUTTON, 1), WJKB(wxT('Z')), WJKB(1, WXJB_BUTTON, 1), + WJKB(wxT('A')), WJKB(2, WXJB_BUTTON, 1), WJKB(wxT('S')), WJKB(3, WXJB_BUTTON, 1), + WJKB(WXK_BACK), WJKB(4, WXJB_BUTTON, 1), WJKB(WXK_RETURN), WJKB(5, WXJB_BUTTON, 1), + WJKB(WXK_NUMPAD_UP), WJKB(0), WJKB(WXK_NUMPAD_DOWN), WJKB(0), + WJKB(WXK_NUMPAD_LEFT), WJKB(0), WJKB(WXK_NUMPAD_RIGHT), WJKB(0), + WJKB(WXK_NUMPAD_PAGEUP), WJKB(0), WJKB(WXK_NUMPAD_PAGEDOWN), WJKB(0), + WJKB(wxT('W')), WJKB(0), WJKB(wxT('Q')), WJKB(0), + WJKB(WXK_SPACE), WJKB(0), WJKB(0), WJKB(0), + WJKB(0), WJKB(0) }; wxAcceleratorEntry_v sys_accels; +// Initializer for struct opt_desc +opt_desc new_opt_desc(wxString opt, const char* cmd, wxString desc, + wxString* stropt, int* intopt, wxString enumvals, + double min, double max, bool* boolopt, + double* doubleopt, uint32_t* uintopt, wxString curstr, + int curint, double curdouble, uint32_t curuint) +{ + struct opt_desc new_opt = {opt, cmd, desc, stropt, intopt, enumvals, + min, max, boolopt, doubleopt, uintopt, + curstr, curint, curdouble, curuint}; + return new_opt; +} + // Note: this table must be sorted in option name order // Both for better user display and for (fast) searching by name opt_desc opts[] = { @@ -178,9 +190,9 @@ opt_desc opts[] = { /// GB STROPT("GB/BiosFile", "", wxTRANSLATE("BIOS file to use for GB, if enabled"), gopts.gb_bios), STROPT("GB/GBCBiosFile", "", wxTRANSLATE("BIOS file to use for GBC, if enabled"), gopts.gbc_bios), - { wxT("GB/Palette0"), "", wxTRANSLATE("The default palette, as 8 comma-separated 4-digit hex integers (rgb555).") }, - { wxT("GB/Palette1"), "", wxTRANSLATE("The first user palette, as 8 comma-separated 4-digit hex integers (rgb555).") }, - { wxT("GB/Palette2"), "", wxTRANSLATE("The second user palette, as 8 comma-separated 4-digit hex integers (rgb555).") }, + NOOPT(wxT("GB/Palette0"), "", wxTRANSLATE("The default palette, as 8 comma-separated 4-digit hex integers (rgb555).")), + NOOPT(wxT("GB/Palette1"), "", wxTRANSLATE("The first user palette, as 8 comma-separated 4-digit hex integers (rgb555).")), + NOOPT(wxT("GB/Palette2"), "", wxTRANSLATE("The second user palette, as 8 comma-separated 4-digit hex integers (rgb555).")), BOOLOPT("GB/PrintAutoPage", "PrintGather", wxTRANSLATE("Automatically gather a full page before printing"), gopts.print_auto_page), BOOLOPT("GB/PrintScreenCap", "PrintSnap", wxTRANSLATE("Automatically save printouts as screen captures with -print suffix"), gopts.print_screen_cap), STROPT("GB/ROMDir", "", wxTRANSLATE("Directory to look for ROM files"), gopts.gb_rom_dir), @@ -210,14 +222,14 @@ opt_desc opts[] = { INTOPT("General/StatusBar", "StatusBar", wxTRANSLATE("Enable status bar"), gopts.statusbar, 0, 1), /// Joypad - { wxT("Joypad/*/*"), "", wxTRANSLATE("The parameter Joypad//