/*
* stb_image - v2.23 - public domain image loader - http://nothings.org/stb
* no warranty implied; use at your own risk
*
* [heavily modified by justine tunney]
*
* JPEG baseline & progressive (12 bpc/arithmetic not supported, same
* as stock IJG lib) PNG 1/2/4/8/16-bit-per-channel
* GIF (*comp always reports as 4-channel)
* HDR (radiance rgbE format)
* 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
*
* ============================ 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 (ImageNet JPGs)
* Mikhail Morozov (1-bit BMP)
* Optimizations & bugfixes Anael Seghezzi (is-16-bit query)
* Fabian "ryg" Giesen
* 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
*/
/*
* 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.
*
* ===========================================================================
*
* 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).
*
* ===========================================================================
*
* 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_GIF
* STBI_NO_HDR
* STBI_NO_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
*
*/
/* stb_image_resize - v0.96 - public domain image resizing
* by Jorge L Rodriguez (@VinoBS) - 2014
* http://github.com/nothings/stb
*
* Written with emphasis on usability, portability, and efficiency. (No
* SIMD or threads, so it be easily outperformed by libs that use those.)
* Only scaling and translation is supported, no rotations or shears.
* Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation.
*
* QUICKSTART
* stbir_resize_uint8( input_pixels , in_w , in_h , 0,
* output_pixels, out_w, out_h, 0, num_channels)
* stbir_resize_float(...)
* stbir_resize_uint8_srgb( input_pixels , in_w , in_h , 0,
* output_pixels, out_w, out_h, 0,
* num_channels , alpha_chan , 0)
* stbir_resize_uint8_srgb_edgemode(
* input_pixels , in_w , in_h , 0,
* output_pixels, out_w, out_h, 0,
* num_channels , alpha_chan , 0, STBIR_EDGE_CLAMP)
* // WRAP/REFLECT/ZERO
*/
/*
* DOCUMENTATION
*
* SRGB & FLOATING POINT REPRESENTATION
* The sRGB functions presume IEEE floating point. If you do not have
* IEEE floating point, define STBIR_NON_IEEE_FLOAT. This will use
* a slower implementation.
*
* MEMORY ALLOCATION
* The resize functions here perform a single memory allocation using
* malloc. To control the memory allocation, before the #include that
* triggers the implementation, do:
*
* #define STBIR_MALLOC(size,context) ...
* #define STBIR_FREE(ptr,context) ...
*
* Each resize function makes exactly one call to malloc/free, so to use
* temp memory, store the temp memory in the context and return that.
*
* ASSERT
* Define STBIR_ASSERT(boolval) to override assert() and not use assert.h
*
* OPTIMIZATION
* Define STBIR_SATURATE_INT to compute clamp values in-range using
* integer operations instead of float operations. This may be faster
* on some platforms.
*
* DEFAULT FILTERS
* For functions which don't provide explicit control over what filters
* to use, you can change the compile-time defaults with
*
* #define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_something
* #define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_something
*
* See stbir_filter in the header-file section for the list of filters.
*
* NEW FILTERS
* A number of 1D filter kernels are used. For a list of
* supported filters see the stbir_filter enum. To add a new filter,
* write a filter function and add it to stbir__filter_info_table.
*
* PROGRESS
* For interactive use with slow resize operations, you can install
* a progress-report callback:
*
* #define STBIR_PROGRESS_REPORT(val) some_func(val)
*
* The parameter val is a float which goes from 0 to 1 as progress
* is made.
*
* For example:
*
* static void my_progress_report(float progress);
* #define STBIR_PROGRESS_REPORT(val) my_progress_report(val)
*
* #define STB_IMAGE_RESIZE_IMPLEMENTATION
*
* static void my_progress_report(float progress)
* {
* printf("Progress: %f%%\n", progress*100);
* }
*
* MAX CHANNELS
* If your image has more than 64 channels, define STBIR_MAX_CHANNELS
* to the max you'll have.
*
* ALPHA CHANNEL
* Most of the resizing functions provide the ability to control how
* the alpha channel of an image is processed. The important things
* to know about this:
*
* 1. The best mathematically-behaved version of alpha to use is
* called "premultiplied alpha", in which the other color channels
* have had the alpha value multiplied in. If you use premultiplied
* alpha, linear filtering (such as image resampling done by this
* library, or performed in texture units on GPUs) does the "right
* thing". While premultiplied alpha is standard in the movie CGI
* industry, it is still uncommon in the videogame/real-time world.
*
* If you linearly filter non-premultiplied alpha, strange effects
* occur. (For example, the 50/50 average of 99% transparent bright green
* and 1% transparent black produces 50% transparent dark green when
* non-premultiplied, whereas premultiplied it produces 50%
* transparent near-black. The former introduces green energy
* that doesn't exist in the source image.)
*
* 2. Artists should not edit premultiplied-alpha images; artists
* want non-premultiplied alpha images. Thus, art tools generally output
* non-premultiplied alpha images.
*
* 3. You will get best results in most cases by converting images
* to premultiplied alpha before processing them mathematically.
*
* 4. If you pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED, the
* resizer does not do anything special for the alpha channel;
* it is resampled identically to other channels. This produces
* the correct results for premultiplied-alpha images, but produces
* less-than-ideal results for non-premultiplied-alpha images.
*
* 5. If you do not pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED,
* then the resizer weights the contribution of input pixels
* based on their alpha values, or, equivalently, it multiplies
* the alpha value into the color channels, resamples, then divides
* by the resultant alpha value. Input pixels which have alpha=0 do
* not contribute at all to output pixels unless _all_ of the input
* pixels affecting that output pixel have alpha=0, in which case
* the result for that pixel is the same as it would be without
* STBIR_FLAG_ALPHA_PREMULTIPLIED. However, this is only true for
* input images in integer formats. For input images in float format,
* input pixels with alpha=0 have no effect, and output pixels
* which have alpha=0 will be 0 in all channels. (For float images,
* you can manually achieve the same result by adding a tiny epsilon
* value to the alpha channel of every image, and then subtracting
* or clamping it at the end.)
*
* 6. You can suppress the behavior described in #5 and make
* all-0-alpha pixels have 0 in all channels by #defining
* STBIR_NO_ALPHA_EPSILON.
*
* 7. You can separately control whether the alpha channel is
* interpreted as linear or affected by the colorspace. By default
* it is linear; you almost never want to apply the colorspace.
* (For example, graphics hardware does not apply sRGB conversion
* to the alpha channel.)
*
* CONTRIBUTORS
* Jorge L Rodriguez: Implementation
* Sean Barrett: API design, optimizations
* Aras Pranckevicius: bugfix
* Nathan Reed: warning fixes
*
* REVISIONS
* 0.96 (2019-03-04) fixed warnings
* 0.95 (2017-07-23) fixed warnings
* 0.94 (2017-03-18) fixed warnings
* 0.93 (2017-03-03) fixed bug with certain combinations of heights
* 0.92 (2017-01-02) fix integer overflow on large (>2GB) images
* 0.91 (2016-04-02) fix warnings; fix handling of subpixel regions
* 0.90 (2014-09-17) first released version
*
* LICENSE
* See end of file for license information.
*
* TODO
* Don't decode all of the image data when only processing a partial tile
* Don't use full-width decode buffers when only processing a partial tile
* When processing wide images, break processing into tiles so data fits in
* L1 cache Installable filters? Resize that respects alpha test coverage
* (Reference code: FloatImage::alphaTestCoverage and
* FloatImage::scaleAlphaToCoverage:
* https://code.google.com/p/nvidia-texture-tools/source/browse/trunk/src/nvimage/FloatImage.cpp
* )
*/
ea0b5d9d1c