From 58d5442dc557016464fea9f0f5736d17b23efb1c Mon Sep 17 00:00:00 2001
From: Seven Du <dujinfang@gmail.com>
Date: Wed, 6 Mar 2019 09:48:20 +0800
Subject: [PATCH] [core] add stb_image to read more supported picture formats

---
 images/cluecon.jpg              |  Bin 0 -> 50243 bytes
 images/cluecon.png              |  Bin 0 -> 115565 bytes
 libs/stb/stb_image.h            | 7547 +++++++++++++++++++++++++++++++
 src/include/switch_core_video.h |    3 +
 src/switch_core_video.c         |   48 +
 tests/unit/switch_core_video.c  |   21 +
 6 files changed, 7619 insertions(+)
 create mode 100644 images/cluecon.jpg
 create mode 100644 images/cluecon.png
 create mode 100644 libs/stb/stb_image.h

diff --git a/images/cluecon.jpg b/images/cluecon.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..a6e89751ea740a812fe188a25c30c870a9eb7056
GIT binary patch
literal 50243
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
EKOBqTyZ`_I

literal 0
HcmV?d00001

diff --git a/images/cluecon.png b/images/cluecon.png
new file mode 100644
index 0000000000000000000000000000000000000000..7b0c4ced2b6e9288ccc1a38f0af8080386bbd9b8
GIT binary patch
literal 115565
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

literal 0
HcmV?d00001

diff --git a/libs/stb/stb_image.h b/libs/stb/stb_image.h
new file mode 100644
index 0000000000..5405380c11
--- /dev/null
+++ b/libs/stb/stb_image.h
@@ -0,0 +1,7547 @@
+/* stb_image - v2.22 - 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.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      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
+    Carmelo J Fdez-Aguera
+
+ 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      JR Smith           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.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// 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
+// provide 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 supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. 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 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 <stdio.h>
+#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
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#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_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
+
+#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
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#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 <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#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 <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+#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 <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __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
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+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
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+// 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;
+      }
+   }
+}
+
+#ifndef STBI_NO_GIF
+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;
+   }
+}
+#endif
+
+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
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
+      return 0;
+
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
+      return 0;
+
+#if _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif 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 (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/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<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->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] = { NULL, NULL, NULL, NULL };
+
+      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]={0};
+   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(unsigned 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 (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               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 preceded 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; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__readval(s,packet->channel,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; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,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;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,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;
+   STBI_NOTUSED(req_comp);
+
+   // 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
+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+         return stbi__errpuc("too large", "GIF image is too large");
+      pcount = g->w * g->h;
+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->history = (stbi_uc *) stbi__malloc(pcount);
+      if (!g->out || !g->background || !g->history)
+         return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "transparent" 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 the color that was there the previous frame.
+      memset(g->out, 0x00, 4 * pcount);
+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+      memset(g->history, 0x00, pcount);        // 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;
+
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+               g->cur_y = g->max_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) 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));
+   STBI_NOTUSED(ri);
+
+   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);
+   } else if (g.out) {
+      // if there was an error and we allocated an image buffer, free it!
+      STBI_FREE(g.out);
+   }
+
+   // 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.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      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.
+------------------------------------------------------------------------------
+*/
diff --git a/src/include/switch_core_video.h b/src/include/switch_core_video.h
index 21e6b77414..23d1356b78 100644
--- a/src/include/switch_core_video.h
+++ b/src/include/switch_core_video.h
@@ -395,6 +395,9 @@ SWITCH_DECLARE(switch_status_t) switch_img_write_png(switch_image_t *img, char *
 SWITCH_DECLARE(switch_status_t) switch_png_open(switch_png_t **pngP, const char *file_name);
 SWITCH_DECLARE(void) switch_png_free(switch_png_t **pngP);
 SWITCH_DECLARE(switch_status_t) switch_img_data_url_png(switch_image_t *img, char **urlP);
+
+/*!\brief Read an image file to switch_image_t */
+SWITCH_DECLARE(switch_image_t *) switch_img_read_from_file(const char *file_name, switch_img_fmt_t img_fmt);
 																
 /*!\brief put a small img over a big IMG at position x,y, with alpha transparency
 *
diff --git a/src/switch_core_video.c b/src/switch_core_video.c
index 540edf0ae9..dcdbe67332 100644
--- a/src/switch_core_video.c
+++ b/src/switch_core_video.c
@@ -48,6 +48,9 @@
 #include <gd.h>
 #endif
 
+#define STB_IMAGE_IMPLEMENTATION
+#include "../libs/stb/stb_image.h"
+
 #ifdef SWITCH_HAVE_YUV
 static inline void switch_img_get_yuv_pixel(switch_image_t *img, switch_yuv_color_t *yuv, int x, int y);
 #endif
@@ -3100,6 +3103,51 @@ SWITCH_DECLARE(switch_status_t) switch_img_data_url_png(switch_image_t *img, cha
 
 #endif
 
+SWITCH_DECLARE(switch_image_t *) switch_img_read_from_file(const char* file_name, switch_img_fmt_t img_fmt)
+{
+	int width = 0, height = 0, channels = 8;
+	int comp = STBI_rgb;
+	unsigned char *data = NULL;
+
+	if (img_fmt == SWITCH_IMG_FMT_I420) {
+		comp = STBI_rgb;
+	} else if (img_fmt == SWITCH_IMG_FMT_ARGB) {
+		comp = STBI_rgb_alpha;
+	} else {
+		return NULL;
+	}
+
+	data = stbi_load(file_name, &width, &height, &channels, comp);
+	// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%dx%d channels=%d\n", width, height, channels);
+
+	if (data && width > 0 && height > 0) {
+		switch_image_t *img = switch_img_alloc(NULL, img_fmt, width, height, 1);
+		switch_assert(img);
+
+		if (img_fmt == SWITCH_IMG_FMT_I420) {
+			RAWToI420(data, width * 3,
+					img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
+					img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
+					img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
+					width, height);
+		} else if (img_fmt == SWITCH_IMG_FMT_ARGB) {
+#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
+			RGBAToARGB(data, width * 4, img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], width, height);
+#else
+			ABGRToARGB(data, width * 4, img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], width, height);
+#endif
+		}
+
+		stbi_image_free(data);
+
+		return img;
+	} else if (data) {
+		stbi_image_free(data);
+	}
+
+	return NULL;
+}
+
 SWITCH_DECLARE(switch_status_t) switch_img_letterbox(switch_image_t *img, switch_image_t **imgP, int width, int height, const char *color)
 {
 	int img_w = 0, img_h = 0;
diff --git a/tests/unit/switch_core_video.c b/tests/unit/switch_core_video.c
index 7d42eaae1f..cafa075337 100644
--- a/tests/unit/switch_core_video.c
+++ b/tests/unit/switch_core_video.c
@@ -199,6 +199,27 @@ FST_CORE_BEGIN("./conf")
 			switch_img_free(&timg_small);
 		}
 		FST_TEST_END()
+
+		FST_TEST_BEGIN(read_from_file)
+		{
+			switch_image_t *img;
+
+			img = switch_img_read_from_file("../../images/cluecon.png", SWITCH_IMG_FMT_I420);
+			fst_requires(img);
+			switch_img_write_png(img, "cluecon-rgb.png");
+			switch_img_free(&img);
+
+			img = switch_img_read_from_file("../../images/cluecon.png", SWITCH_IMG_FMT_ARGB);
+			fst_requires(img);
+			switch_img_write_png(img, "cluecon-argb.png");
+			switch_img_free(&img);
+
+			img = switch_img_read_from_file("../../images/cluecon.jpg", SWITCH_IMG_FMT_I420);
+			fst_requires(img);
+			switch_img_write_png(img, "cluecon-jpg.png");
+			switch_img_free(&img);
+		}
+		FST_TEST_END()
 	}
 	FST_SUITE_END()
 }