JuicyPixels-stbir (empty) → 0.1.0.0

raw patch · 6 files changed

+2958/−0 lines, 6 filesdep +JuicyPixelsdep +basedep +data-default-class

Dependencies added: JuicyPixels, base, data-default-class, vector

Files

• JuicyPixels-stbir.cabal +34/−0
• LICENSE +30/−0
• README.md +5/−0
• cbits/stb_image_resize.c +2/−0
• cbits/stb_image_resize.h +2627/−0
• src/Codec/Picture/STBIR.chs +260/−0

@@ -0,0 +1,34 @@+name:                 JuicyPixels-stbir+version:              0.1.0.0+homepage:             https://github.com/mtolly/JuicyPixels-stbir+license:              BSD3+license-file:         LICENSE+author:               Jorge L Rodriguez, Michael Tolly+maintainer:           miketolly@gmail.com+copyright:            Jorge L Rodriguez, Michael Tolly+category:             Graphics, Image+build-type:           Simple+extra-source-files:+  README.md+  cbits/stb_image_resize.h+cabal-version:        >= 1.10+synopsis:             Scale JuicyPixels images with stb_image_resize+description:+  Use the <https://github.com/nothings/stb stb> image resize C library+  to scale JuicyPixels images at high quality with a variety of options.++library+  hs-source-dirs:       src+  exposed-modules:      Codec.Picture.STBIR+  build-depends:        base >= 4.7 && < 5, JuicyPixels, vector, data-default-class+  build-tools:          c2hs+  default-language:     Haskell2010+  ghc-options:          -Wall+  c-sources:+    cbits/stb_image_resize.c+  include-dirs:+    cbits/++source-repository head+  type:     git+  location: https://github.com/mtolly/JuicyPixels-stbir

@@ -0,0 +1,30 @@+Copyright 2014 - 2017 Jorge L Rodriguez, Michael Tolly++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the name of Author name here nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

@@ -0,0 +1,5 @@+Use the [stb](https://github.com/nothings/stb) image resize C library+to scale JuicyPixels images at high quality with a variety of options.++This package bundles the C code (v0.95)+and provides a high-level Haskell interface.

@@ -0,0 +1,2 @@+#define STB_IMAGE_RESIZE_IMPLEMENTATION+#include "stb_image_resize.h"

@@ -0,0 +1,2627 @@+/* stb_image_resize - v0.95 - 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.++   COMPILING & LINKING+      In one C/C++ file that #includes this file, do this:+         #define STB_IMAGE_RESIZE_IMPLEMENTATION+      before the #include. That will create the implementation in that file.++   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++   FULL API+      See the "header file" section of the source for API documentation.++   ADDITIONAL 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+            #include "stb_image_resize.h"++            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.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 )+*/++#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE_H+#define STBIR_INCLUDE_STB_IMAGE_RESIZE_H++#ifdef _MSC_VER+typedef unsigned char  stbir_uint8;+typedef unsigned short stbir_uint16;+typedef unsigned int   stbir_uint32;+#else+#include <stdint.h>+typedef uint8_t  stbir_uint8;+typedef uint16_t stbir_uint16;+typedef uint32_t stbir_uint32;+#endif++#ifdef STB_IMAGE_RESIZE_STATIC+#define STBIRDEF static+#else+#ifdef __cplusplus+#define STBIRDEF extern "C"+#else+#define STBIRDEF extern+#endif+#endif+++//////////////////////////////////////////////////////////////////////////////+//+// Easy-to-use API:+//+//     * "input pixels" points to an array of image data with 'num_channels' channels (e.g. RGB=3, RGBA=4)+//     * input_w is input image width (x-axis), input_h is input image height (y-axis)+//     * stride is the offset between successive rows of image data in memory, in bytes. you can+//       specify 0 to mean packed continuously in memory+//     * alpha channel is treated identically to other channels.+//     * colorspace is linear or sRGB as specified by function name+//     * returned result is 1 for success or 0 in case of an error.+//       #define STBIR_ASSERT() to trigger an assert on parameter validation errors.+//     * Memory required grows approximately linearly with input and output size, but with+//       discontinuities at input_w == output_w and input_h == output_h.+//     * These functions use a "default" resampling filter defined at compile time. To change the filter,+//       you can change the compile-time defaults by #defining STBIR_DEFAULT_FILTER_UPSAMPLE+//       and STBIR_DEFAULT_FILTER_DOWNSAMPLE, or you can use the medium-complexity API.++STBIRDEF int stbir_resize_uint8(     const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels);++STBIRDEF int stbir_resize_float(     const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels);+++// The following functions interpret image data as gamma-corrected sRGB. +// Specify STBIR_ALPHA_CHANNEL_NONE if you have no alpha channel,+// or otherwise provide the index of the alpha channel. Flags value+// of 0 will probably do the right thing if you're not sure what+// the flags mean.++#define STBIR_ALPHA_CHANNEL_NONE       -1++// Set this flag if your texture has premultiplied alpha. Otherwise, stbir will+// use alpha-weighted resampling (effectively premultiplying, resampling,+// then unpremultiplying).+#define STBIR_FLAG_ALPHA_PREMULTIPLIED    (1 << 0)+// The specified alpha channel should be handled as gamma-corrected value even+// when doing sRGB operations.+#define STBIR_FLAG_ALPHA_USES_COLORSPACE  (1 << 1)++STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels, int alpha_channel, int flags);+++typedef enum+{+    STBIR_EDGE_CLAMP   = 1,+    STBIR_EDGE_REFLECT = 2,+    STBIR_EDGE_WRAP    = 3,+    STBIR_EDGE_ZERO    = 4,+} stbir_edge;++// This function adds the ability to specify how requests to sample off the edge of the image are handled.+STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                                    unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                              int num_channels, int alpha_channel, int flags,+                                              stbir_edge edge_wrap_mode);++//////////////////////////////////////////////////////////////////////////////+//+// Medium-complexity API+//+// This extends the easy-to-use API as follows:+//+//     * Alpha-channel can be processed separately+//       * If alpha_channel is not STBIR_ALPHA_CHANNEL_NONE+//         * Alpha channel will not be gamma corrected (unless flags&STBIR_FLAG_GAMMA_CORRECT)+//         * Filters will be weighted by alpha channel (unless flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)+//     * Filter can be selected explicitly+//     * uint16 image type+//     * sRGB colorspace available for all types+//     * context parameter for passing to STBIR_MALLOC++typedef enum+{+    STBIR_FILTER_DEFAULT      = 0,  // use same filter type that easy-to-use API chooses+    STBIR_FILTER_BOX          = 1,  // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios+    STBIR_FILTER_TRIANGLE     = 2,  // On upsampling, produces same results as bilinear texture filtering+    STBIR_FILTER_CUBICBSPLINE = 3,  // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque+    STBIR_FILTER_CATMULLROM   = 4,  // An interpolating cubic spline+    STBIR_FILTER_MITCHELL     = 5,  // Mitchell-Netrevalli filter with B=1/3, C=1/3+} stbir_filter;++typedef enum+{+    STBIR_COLORSPACE_LINEAR,+    STBIR_COLORSPACE_SRGB,++    STBIR_MAX_COLORSPACES,+} stbir_colorspace;++// The following functions are all identical except for the type of the image data++STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                               unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context);++STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels  , int input_w , int input_h , int input_stride_in_bytes,+                                               stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context);++STBIRDEF int stbir_resize_float_generic( const float *input_pixels         , int input_w , int input_h , int input_stride_in_bytes,+                                               float *output_pixels        , int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context);++++//////////////////////////////////////////////////////////////////////////////+//+// Full-complexity API+//+// This extends the medium API as follows:+//+//       * uint32 image type+//     * not typesafe+//     * separate filter types for each axis+//     * separate edge modes for each axis+//     * can specify scale explicitly for subpixel correctness+//     * can specify image source tile using texture coordinates++typedef enum+{+    STBIR_TYPE_UINT8 ,+    STBIR_TYPE_UINT16,+    STBIR_TYPE_UINT32,+    STBIR_TYPE_FLOAT ,++    STBIR_MAX_TYPES+} stbir_datatype;++STBIRDEF int stbir_resize(         const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context);++STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context,+                                   float x_scale, float y_scale,+                                   float x_offset, float y_offset);++STBIRDEF int stbir_resize_region(  const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context,+                                   float s0, float t0, float s1, float t1);+// (s0, t0) & (s1, t1) are the top-left and bottom right corner (uv addressing style: [0, 1]x[0, 1]) of a region of the input image to use.++//+//+////   end header file   /////////////////////////////////////////////////////+#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE_H++++++#ifdef STB_IMAGE_RESIZE_IMPLEMENTATION++#ifndef STBIR_ASSERT+#include <assert.h>+#define STBIR_ASSERT(x) assert(x)+#endif++// For memset+#include <string.h>++#include <math.h>++#ifndef STBIR_MALLOC+#include <stdlib.h>+// use comma operator to evaluate c, to avoid "unused parameter" warnings+#define STBIR_MALLOC(size,c) ((void)(c), malloc(size))+#define STBIR_FREE(ptr,c)    ((void)(c), free(ptr))+#endif++#ifndef _MSC_VER+#ifdef __cplusplus+#define stbir__inline inline+#else+#define stbir__inline+#endif+#else+#define stbir__inline __forceinline+#endif+++// should produce compiler error if size is wrong+typedef unsigned char stbir__validate_uint32[sizeof(stbir_uint32) == 4 ? 1 : -1];++#ifdef _MSC_VER+#define STBIR__NOTUSED(v)  (void)(v)+#else+#define STBIR__NOTUSED(v)  (void)sizeof(v)+#endif++#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))++#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE+#define STBIR_DEFAULT_FILTER_UPSAMPLE    STBIR_FILTER_CATMULLROM+#endif++#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE+#define STBIR_DEFAULT_FILTER_DOWNSAMPLE  STBIR_FILTER_MITCHELL+#endif++#ifndef STBIR_PROGRESS_REPORT+#define STBIR_PROGRESS_REPORT(float_0_to_1)+#endif++#ifndef STBIR_MAX_CHANNELS+#define STBIR_MAX_CHANNELS 64+#endif++#if STBIR_MAX_CHANNELS > 65536+#error "Too many channels; STBIR_MAX_CHANNELS must be no more than 65536."+// because we store the indices in 16-bit variables+#endif++// This value is added to alpha just before premultiplication to avoid+// zeroing out color values. It is equivalent to 2^-80. If you don't want+// that behavior (it may interfere if you have floating point images with+// very small alpha values) then you can define STBIR_NO_ALPHA_EPSILON to+// disable it.+#ifndef STBIR_ALPHA_EPSILON+#define STBIR_ALPHA_EPSILON ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))+#endif++++#ifdef _MSC_VER+#define STBIR__UNUSED_PARAM(v)  (void)(v)+#else+#define STBIR__UNUSED_PARAM(v)  (void)sizeof(v)+#endif++// must match stbir_datatype+static unsigned char stbir__type_size[] = {+    1, // STBIR_TYPE_UINT8+    2, // STBIR_TYPE_UINT16+    4, // STBIR_TYPE_UINT32+    4, // STBIR_TYPE_FLOAT+};++// Kernel function centered at 0+typedef float (stbir__kernel_fn)(float x, float scale);+typedef float (stbir__support_fn)(float scale);++typedef struct+{+    stbir__kernel_fn* kernel;+    stbir__support_fn* support;+} stbir__filter_info;++// When upsampling, the contributors are which source pixels contribute.+// When downsampling, the contributors are which destination pixels are contributed to.+typedef struct+{+    int n0; // First contributing pixel+    int n1; // Last contributing pixel+} stbir__contributors;++typedef struct+{+    const void* input_data;+    int input_w;+    int input_h;+    int input_stride_bytes;++    void* output_data;+    int output_w;+    int output_h;+    int output_stride_bytes;++    float s0, t0, s1, t1;++    float horizontal_shift; // Units: output pixels+    float vertical_shift;   // Units: output pixels+    float horizontal_scale;+    float vertical_scale;++    int channels;+    int alpha_channel;+    stbir_uint32 flags;+    stbir_datatype type;+    stbir_filter horizontal_filter;+    stbir_filter vertical_filter;+    stbir_edge edge_horizontal;+    stbir_edge edge_vertical;+    stbir_colorspace colorspace;++    stbir__contributors* horizontal_contributors;+    float* horizontal_coefficients;++    stbir__contributors* vertical_contributors;+    float* vertical_coefficients;++    int decode_buffer_pixels;+    float* decode_buffer;++    float* horizontal_buffer;++    // cache these because ceil/floor are inexplicably showing up in profile+    int horizontal_coefficient_width;+    int vertical_coefficient_width;+    int horizontal_filter_pixel_width;+    int vertical_filter_pixel_width;+    int horizontal_filter_pixel_margin;+    int vertical_filter_pixel_margin;+    int horizontal_num_contributors;+    int vertical_num_contributors;++    int ring_buffer_length_bytes;   // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter)+    int ring_buffer_num_entries;    // Total number of entries in the ring buffer.+    int ring_buffer_first_scanline;+    int ring_buffer_last_scanline;+    int ring_buffer_begin_index;    // first_scanline is at this index in the ring buffer+    float* ring_buffer;++    float* encode_buffer; // A temporary buffer to store floats so we don't lose precision while we do multiply-adds.++    int horizontal_contributors_size;+    int horizontal_coefficients_size;+    int vertical_contributors_size;+    int vertical_coefficients_size;+    int decode_buffer_size;+    int horizontal_buffer_size;+    int ring_buffer_size;+    int encode_buffer_size;+} stbir__info;+++static const float stbir__max_uint8_as_float  = 255.0f;+static const float stbir__max_uint16_as_float = 65535.0f;+static const double stbir__max_uint32_as_float = 4294967295.0;+++static stbir__inline int stbir__min(int a, int b)+{+    return a < b ? a : b;+}++static stbir__inline float stbir__saturate(float x)+{+    if (x < 0)+        return 0;++    if (x > 1)+        return 1;++    return x;+}++#ifdef STBIR_SATURATE_INT+static stbir__inline stbir_uint8 stbir__saturate8(int x)+{+    if ((unsigned int) x <= 255)+        return x;++    if (x < 0)+        return 0;++    return 255;+}++static stbir__inline stbir_uint16 stbir__saturate16(int x)+{+    if ((unsigned int) x <= 65535)+        return x;++    if (x < 0)+        return 0;++    return 65535;+}+#endif++static float stbir__srgb_uchar_to_linear_float[256] = {+    0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f,+    0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f,+    0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f,+    0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f,+    0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f,+    0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f,+    0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f,+    0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f,+    0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f,+    0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f,+    0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f,+    0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f,+    0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f,+    0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f,+    0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f,+    0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f,+    0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f,+    0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f,+    0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f,+    0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f,+    0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f,+    0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f,+    0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f,+    0.982251f, 0.991102f, 1.0f+};++static float stbir__srgb_to_linear(float f)+{+    if (f <= 0.04045f)+        return f / 12.92f;+    else+        return (float)pow((f + 0.055f) / 1.055f, 2.4f);+}++static float stbir__linear_to_srgb(float f)+{+    if (f <= 0.0031308f)+        return f * 12.92f;+    else+        return 1.055f * (float)pow(f, 1 / 2.4f) - 0.055f;+}++#ifndef STBIR_NON_IEEE_FLOAT+// From https://gist.github.com/rygorous/2203834++typedef union+{+    stbir_uint32 u;+    float f;+} stbir__FP32;++static const stbir_uint32 fp32_to_srgb8_tab4[104] = {+    0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,+    0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,+    0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,+    0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,+    0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,+    0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,+    0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,+    0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,+    0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,+    0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,+    0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,+    0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,+    0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,+};+ +static stbir_uint8 stbir__linear_to_srgb_uchar(float in)+{+    static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps+    static const stbir__FP32 minval = { (127-13) << 23 };+    stbir_uint32 tab,bias,scale,t;+    stbir__FP32 f;+ +    // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.+    // The tests are carefully written so that NaNs map to 0, same as in the reference+    // implementation.+    if (!(in > minval.f)) // written this way to catch NaNs+        in = minval.f;+    if (in > almostone.f)+        in = almostone.f;+ +    // Do the table lookup and unpack bias, scale+    f.f = in;+    tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];+    bias = (tab >> 16) << 9;+    scale = tab & 0xffff;+ +    // Grab next-highest mantissa bits and perform linear interpolation+    t = (f.u >> 12) & 0xff;+    return (unsigned char) ((bias + scale*t) >> 16);+}++#else+// sRGB transition values, scaled by 1<<28+static int stbir__srgb_offset_to_linear_scaled[256] =+{+            0,     40738,    122216,    203693,    285170,    366648,    448125,    529603,+       611080,    692557,    774035,    855852,    942009,   1033024,   1128971,   1229926,+      1335959,   1447142,   1563542,   1685229,   1812268,   1944725,   2082664,   2226148,+      2375238,   2529996,   2690481,   2856753,   3028870,   3206888,   3390865,   3580856,+      3776916,   3979100,   4187460,   4402049,   4622919,   4850123,   5083710,   5323731,+      5570236,   5823273,   6082892,   6349140,   6622065,   6901714,   7188133,   7481369,+      7781466,   8088471,   8402427,   8723380,   9051372,   9386448,   9728650,  10078021,+     10434603,  10798439,  11169569,  11548036,  11933879,  12327139,  12727857,  13136073,+     13551826,  13975156,  14406100,  14844697,  15290987,  15745007,  16206795,  16676389,+     17153826,  17639142,  18132374,  18633560,  19142734,  19659934,  20185196,  20718552,+     21260042,  21809696,  22367554,  22933648,  23508010,  24090680,  24681686,  25281066,+     25888850,  26505076,  27129772,  27762974,  28404716,  29055026,  29713942,  30381490,+     31057708,  31742624,  32436272,  33138682,  33849884,  34569912,  35298800,  36036568,+     36783260,  37538896,  38303512,  39077136,  39859796,  40651528,  41452360,  42262316,+     43081432,  43909732,  44747252,  45594016,  46450052,  47315392,  48190064,  49074096,+     49967516,  50870356,  51782636,  52704392,  53635648,  54576432,  55526772,  56486700,+     57456236,  58435408,  59424248,  60422780,  61431036,  62449032,  63476804,  64514376,+     65561776,  66619028,  67686160,  68763192,  69850160,  70947088,  72053992,  73170912,+     74297864,  75434880,  76581976,  77739184,  78906536,  80084040,  81271736,  82469648,+     83677792,  84896192,  86124888,  87363888,  88613232,  89872928,  91143016,  92423512,+     93714432,  95015816,  96327688,  97650056,  98982952, 100326408, 101680440, 103045072,+    104420320, 105806224, 107202800, 108610064, 110028048, 111456776, 112896264, 114346544,+    115807632, 117279552, 118762328, 120255976, 121760536, 123276016, 124802440, 126339832,+    127888216, 129447616, 131018048, 132599544, 134192112, 135795792, 137410592, 139036528,+    140673648, 142321952, 143981456, 145652208, 147334208, 149027488, 150732064, 152447968,+    154175200, 155913792, 157663776, 159425168, 161197984, 162982240, 164777968, 166585184,+    168403904, 170234160, 172075968, 173929344, 175794320, 177670896, 179559120, 181458992,+    183370528, 185293776, 187228736, 189175424, 191133888, 193104112, 195086128, 197079968,+    199085648, 201103184, 203132592, 205173888, 207227120, 209292272, 211369392, 213458480,+    215559568, 217672656, 219797792, 221934976, 224084240, 226245600, 228419056, 230604656,+    232802400, 235012320, 237234432, 239468736, 241715280, 243974080, 246245120, 248528464,+    250824112, 253132064, 255452368, 257785040, 260130080, 262487520, 264857376, 267239664,+};++static stbir_uint8 stbir__linear_to_srgb_uchar(float f)+{+    int x = (int) (f * (1 << 28)); // has headroom so you don't need to clamp+    int v = 0;+    int i;++    // Refine the guess with a short binary search.+    i = v + 128; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +  64; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +  32; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +  16; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +   8; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +   4; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +   2; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;+    i = v +   1; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;++    return (stbir_uint8) v;+}+#endif++static float stbir__filter_trapezoid(float x, float scale)+{+    float halfscale = scale / 2;+    float t = 0.5f + halfscale;+    STBIR_ASSERT(scale <= 1);++    x = (float)fabs(x);++    if (x >= t)+        return 0;+    else+    {+        float r = 0.5f - halfscale;+        if (x <= r)+            return 1;+        else+            return (t - x) / scale;+    }+}++static float stbir__support_trapezoid(float scale)+{+    STBIR_ASSERT(scale <= 1);+    return 0.5f + scale / 2;+}++static float stbir__filter_triangle(float x, float s)+{+    STBIR__UNUSED_PARAM(s);++    x = (float)fabs(x);++    if (x <= 1.0f)+        return 1 - x;+    else+        return 0;+}++static float stbir__filter_cubic(float x, float s)+{+    STBIR__UNUSED_PARAM(s);++    x = (float)fabs(x);++    if (x < 1.0f)+        return (4 + x*x*(3*x - 6))/6;+    else if (x < 2.0f)+        return (8 + x*(-12 + x*(6 - x)))/6;++    return (0.0f);+}++static float stbir__filter_catmullrom(float x, float s)+{+    STBIR__UNUSED_PARAM(s);++    x = (float)fabs(x);++    if (x < 1.0f)+        return 1 - x*x*(2.5f - 1.5f*x);+    else if (x < 2.0f)+        return 2 - x*(4 + x*(0.5f*x - 2.5f));++    return (0.0f);+}++static float stbir__filter_mitchell(float x, float s)+{+    STBIR__UNUSED_PARAM(s);++    x = (float)fabs(x);++    if (x < 1.0f)+        return (16 + x*x*(21 * x - 36))/18;+    else if (x < 2.0f)+        return (32 + x*(-60 + x*(36 - 7*x)))/18;++    return (0.0f);+}++static float stbir__support_zero(float s)+{+    STBIR__UNUSED_PARAM(s);+    return 0;+}++static float stbir__support_one(float s)+{+    STBIR__UNUSED_PARAM(s);+    return 1;+}++static float stbir__support_two(float s)+{+    STBIR__UNUSED_PARAM(s);+    return 2;+}++static stbir__filter_info stbir__filter_info_table[] = {+        { NULL,                     stbir__support_zero },+        { stbir__filter_trapezoid,  stbir__support_trapezoid },+        { stbir__filter_triangle,   stbir__support_one },+        { stbir__filter_cubic,      stbir__support_two },+        { stbir__filter_catmullrom, stbir__support_two },+        { stbir__filter_mitchell,   stbir__support_two },+};++stbir__inline static int stbir__use_upsampling(float ratio)+{+    return ratio > 1;+}++stbir__inline static int stbir__use_width_upsampling(stbir__info* stbir_info)+{+    return stbir__use_upsampling(stbir_info->horizontal_scale);+}++stbir__inline static int stbir__use_height_upsampling(stbir__info* stbir_info)+{+    return stbir__use_upsampling(stbir_info->vertical_scale);+}++// This is the maximum number of input samples that can affect an output sample+// with the given filter+static int stbir__get_filter_pixel_width(stbir_filter filter, float scale)+{+    STBIR_ASSERT(filter != 0);+    STBIR_ASSERT(filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));++    if (stbir__use_upsampling(scale))+        return (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2);+    else+        return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2 / scale);+}++// This is how much to expand buffers to account for filters seeking outside+// the image boundaries.+static int stbir__get_filter_pixel_margin(stbir_filter filter, float scale)+{+    return stbir__get_filter_pixel_width(filter, scale) / 2;+}++static int stbir__get_coefficient_width(stbir_filter filter, float scale)+{+    if (stbir__use_upsampling(scale))+        return (int)ceil(stbir__filter_info_table[filter].support(1 / scale) * 2);+    else+        return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2);+}++static int stbir__get_contributors(float scale, stbir_filter filter, int input_size, int output_size)+{+    if (stbir__use_upsampling(scale))+        return output_size;+    else+        return (input_size + stbir__get_filter_pixel_margin(filter, scale) * 2);+}++static int stbir__get_total_horizontal_coefficients(stbir__info* info)+{+    return info->horizontal_num_contributors+         * stbir__get_coefficient_width      (info->horizontal_filter, info->horizontal_scale);+}++static int stbir__get_total_vertical_coefficients(stbir__info* info)+{+    return info->vertical_num_contributors+         * stbir__get_coefficient_width      (info->vertical_filter, info->vertical_scale);+}++static stbir__contributors* stbir__get_contributor(stbir__contributors* contributors, int n)+{+    return &contributors[n];+}++// For perf reasons this code is duplicated in stbir__resample_horizontal_upsample/downsample,+// if you change it here change it there too.+static float* stbir__get_coefficient(float* coefficients, stbir_filter filter, float scale, int n, int c)+{+    int width = stbir__get_coefficient_width(filter, scale);+    return &coefficients[width*n + c];+}++static int stbir__edge_wrap_slow(stbir_edge edge, int n, int max)+{+    switch (edge)+    {+    case STBIR_EDGE_ZERO:+        return 0; // we'll decode the wrong pixel here, and then overwrite with 0s later++    case STBIR_EDGE_CLAMP:+        if (n < 0)+            return 0;++        if (n >= max)+            return max - 1;++        return n; // NOTREACHED++    case STBIR_EDGE_REFLECT:+    {+        if (n < 0)+        {+            if (n < max)+                return -n;+            else+                return max - 1;+        }++        if (n >= max)+        {+            int max2 = max * 2;+            if (n >= max2)+                return 0;+            else+                return max2 - n - 1;+        }++        return n; // NOTREACHED+    }++    case STBIR_EDGE_WRAP:+        if (n >= 0)+            return (n % max);+        else+        {+            int m = (-n) % max;++            if (m != 0)+                m = max - m;++            return (m);+        }+        // NOTREACHED++    default:+        STBIR_ASSERT(!"Unimplemented edge type");+        return 0;+    }+}++stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)+{+    // avoid per-pixel switch+    if (n >= 0 && n < max)+        return n;+    return stbir__edge_wrap_slow(edge, n, max);+}++// What input pixels contribute to this output pixel?+static void stbir__calculate_sample_range_upsample(int n, float out_filter_radius, float scale_ratio, float out_shift, int* in_first_pixel, int* in_last_pixel, float* in_center_of_out)+{+    float out_pixel_center = (float)n + 0.5f;+    float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;+    float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;++    float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) / scale_ratio;+    float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) / scale_ratio;++    *in_center_of_out = (out_pixel_center + out_shift) / scale_ratio;+    *in_first_pixel = (int)(floor(in_pixel_influence_lowerbound + 0.5));+    *in_last_pixel = (int)(floor(in_pixel_influence_upperbound - 0.5));+}++// What output pixels does this input pixel contribute to?+static void stbir__calculate_sample_range_downsample(int n, float in_pixels_radius, float scale_ratio, float out_shift, int* out_first_pixel, int* out_last_pixel, float* out_center_of_in)+{+    float in_pixel_center = (float)n + 0.5f;+    float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius;+    float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius;++    float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale_ratio - out_shift;+    float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale_ratio - out_shift;++    *out_center_of_in = in_pixel_center * scale_ratio - out_shift;+    *out_first_pixel = (int)(floor(out_pixel_influence_lowerbound + 0.5));+    *out_last_pixel = (int)(floor(out_pixel_influence_upperbound - 0.5));+}++static void stbir__calculate_coefficients_upsample(stbir_filter filter, float scale, int in_first_pixel, int in_last_pixel, float in_center_of_out, stbir__contributors* contributor, float* coefficient_group)+{+    int i;+    float total_filter = 0;+    float filter_scale;++    STBIR_ASSERT(in_last_pixel - in_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.++    contributor->n0 = in_first_pixel;+    contributor->n1 = in_last_pixel;++    STBIR_ASSERT(contributor->n1 >= contributor->n0);++    for (i = 0; i <= in_last_pixel - in_first_pixel; i++)+    {+        float in_pixel_center = (float)(i + in_first_pixel) + 0.5f;+        coefficient_group[i] = stbir__filter_info_table[filter].kernel(in_center_of_out - in_pixel_center, 1 / scale);++        // If the coefficient is zero, skip it. (Don't do the <0 check here, we want the influence of those outside pixels.)+        if (i == 0 && !coefficient_group[i])+        {+            contributor->n0 = ++in_first_pixel;+            i--;+            continue;+        }++        total_filter += coefficient_group[i];+    }++    STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(in_last_pixel + 1) + 0.5f - in_center_of_out, 1/scale) == 0);++    STBIR_ASSERT(total_filter > 0.9);+    STBIR_ASSERT(total_filter < 1.1f); // Make sure it's not way off.++    // Make sure the sum of all coefficients is 1.+    filter_scale = 1 / total_filter;++    for (i = 0; i <= in_last_pixel - in_first_pixel; i++)+        coefficient_group[i] *= filter_scale;++    for (i = in_last_pixel - in_first_pixel; i >= 0; i--)+    {+        if (coefficient_group[i])+            break;++        // This line has no weight. We can skip it.+        contributor->n1 = contributor->n0 + i - 1;+    }+}++static void stbir__calculate_coefficients_downsample(stbir_filter filter, float scale_ratio, int out_first_pixel, int out_last_pixel, float out_center_of_in, stbir__contributors* contributor, float* coefficient_group)+{+    int i;++     STBIR_ASSERT(out_last_pixel - out_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(scale_ratio) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.++    contributor->n0 = out_first_pixel;+    contributor->n1 = out_last_pixel;++    STBIR_ASSERT(contributor->n1 >= contributor->n0);++    for (i = 0; i <= out_last_pixel - out_first_pixel; i++)+    {+        float out_pixel_center = (float)(i + out_first_pixel) + 0.5f;+        float x = out_pixel_center - out_center_of_in;+        coefficient_group[i] = stbir__filter_info_table[filter].kernel(x, scale_ratio) * scale_ratio;+    }++    STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(out_last_pixel + 1) + 0.5f - out_center_of_in, scale_ratio) == 0);++    for (i = out_last_pixel - out_first_pixel; i >= 0; i--)+    {+        if (coefficient_group[i])+            break;++        // This line has no weight. We can skip it.+        contributor->n1 = contributor->n0 + i - 1;+    }+}++static void stbir__normalize_downsample_coefficients(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, int input_size, int output_size)+{+    int num_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);+    int num_coefficients = stbir__get_coefficient_width(filter, scale_ratio);+    int i, j;+    int skip;++    for (i = 0; i < output_size; i++)+    {+        float scale;+        float total = 0;++        for (j = 0; j < num_contributors; j++)+        {+            if (i >= contributors[j].n0 && i <= contributors[j].n1)+            {+                float coefficient = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0);+                total += coefficient;+            }+            else if (i < contributors[j].n0)+                break;+        }++        STBIR_ASSERT(total > 0.9f);+        STBIR_ASSERT(total < 1.1f);++        scale = 1 / total;++        for (j = 0; j < num_contributors; j++)+        {+            if (i >= contributors[j].n0 && i <= contributors[j].n1)+                *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0) *= scale;+            else if (i < contributors[j].n0)+                break;+        }+    }++    // Optimize: Skip zero coefficients and contributions outside of image bounds.+    // Do this after normalizing because normalization depends on the n0/n1 values.+    for (j = 0; j < num_contributors; j++)+    {+        int range, max, width;++        skip = 0;+        while (*stbir__get_coefficient(coefficients, filter, scale_ratio, j, skip) == 0)+            skip++;++        contributors[j].n0 += skip;++        while (contributors[j].n0 < 0)+        {+            contributors[j].n0++;+            skip++;+        }++        range = contributors[j].n1 - contributors[j].n0 + 1;+        max = stbir__min(num_coefficients, range);++        width = stbir__get_coefficient_width(filter, scale_ratio);+        for (i = 0; i < max; i++)+        {+            if (i + skip >= width)+                break;++            *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i) = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i + skip);+        }++        continue;+    }++    // Using min to avoid writing into invalid pixels.+    for (i = 0; i < num_contributors; i++)+        contributors[i].n1 = stbir__min(contributors[i].n1, output_size - 1);+}++// Each scan line uses the same kernel values so we should calculate the kernel+// values once and then we can use them for every scan line.+static void stbir__calculate_filters(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, float shift, int input_size, int output_size)+{+    int n;+    int total_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);++    if (stbir__use_upsampling(scale_ratio))+    {+        float out_pixels_radius = stbir__filter_info_table[filter].support(1 / scale_ratio) * scale_ratio;++        // Looping through out pixels+        for (n = 0; n < total_contributors; n++)+        {+            float in_center_of_out; // Center of the current out pixel in the in pixel space+            int in_first_pixel, in_last_pixel;++            stbir__calculate_sample_range_upsample(n, out_pixels_radius, scale_ratio, shift, &in_first_pixel, &in_last_pixel, &in_center_of_out);++            stbir__calculate_coefficients_upsample(filter, scale_ratio, in_first_pixel, in_last_pixel, in_center_of_out, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));+        }+    }+    else+    {+        float in_pixels_radius = stbir__filter_info_table[filter].support(scale_ratio) / scale_ratio;++        // Looping through in pixels+        for (n = 0; n < total_contributors; n++)+        {+            float out_center_of_in; // Center of the current out pixel in the in pixel space+            int out_first_pixel, out_last_pixel;+            int n_adjusted = n - stbir__get_filter_pixel_margin(filter, scale_ratio);++            stbir__calculate_sample_range_downsample(n_adjusted, in_pixels_radius, scale_ratio, shift, &out_first_pixel, &out_last_pixel, &out_center_of_in);++            stbir__calculate_coefficients_downsample(filter, scale_ratio, out_first_pixel, out_last_pixel, out_center_of_in, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));+        }++        stbir__normalize_downsample_coefficients(contributors, coefficients, filter, scale_ratio, input_size, output_size);+    }+}++static float* stbir__get_decode_buffer(stbir__info* stbir_info)+{+    // The 0 index of the decode buffer starts after the margin. This makes+    // it okay to use negative indexes on the decode buffer.+    return &stbir_info->decode_buffer[stbir_info->horizontal_filter_pixel_margin * stbir_info->channels];+}++#define STBIR__DECODE(type, colorspace) ((type) * (STBIR_MAX_COLORSPACES) + (colorspace))++static void stbir__decode_scanline(stbir__info* stbir_info, int n)+{+    int c;+    int channels = stbir_info->channels;+    int alpha_channel = stbir_info->alpha_channel;+    int type = stbir_info->type;+    int colorspace = stbir_info->colorspace;+    int input_w = stbir_info->input_w;+    size_t input_stride_bytes = stbir_info->input_stride_bytes;+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);+    stbir_edge edge_horizontal = stbir_info->edge_horizontal;+    stbir_edge edge_vertical = stbir_info->edge_vertical;+    size_t in_buffer_row_offset = stbir__edge_wrap(edge_vertical, n, stbir_info->input_h) * input_stride_bytes;+    const void* input_data = (char *) stbir_info->input_data + in_buffer_row_offset;+    int max_x = input_w + stbir_info->horizontal_filter_pixel_margin;+    int decode = STBIR__DECODE(type, colorspace);++    int x = -stbir_info->horizontal_filter_pixel_margin;++    // special handling for STBIR_EDGE_ZERO because it needs to return an item that doesn't appear in the input,+    // and we want to avoid paying overhead on every pixel if not STBIR_EDGE_ZERO+    if (edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->input_h))+    {+        for (; x < max_x; x++)+            for (c = 0; c < channels; c++)+                decode_buffer[x*channels + c] = 0;+        return;+    }++    switch (decode)+    {+    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned char*)input_data)[input_pixel_index + c]) / stbir__max_uint8_as_float;+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = stbir__srgb_uchar_to_linear_float[((const unsigned char*)input_data)[input_pixel_index + c]];++            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned char*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint8_as_float;+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float;+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float);++            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned short*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint16_as_float;+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float);+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear((float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float));++            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                decode_buffer[decode_pixel_index + alpha_channel] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint32_as_float);+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = ((const float*)input_data)[input_pixel_index + c];+        }+        break;++    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):+        for (; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;+            for (c = 0; c < channels; c++)+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((const float*)input_data)[input_pixel_index + c]);++            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                decode_buffer[decode_pixel_index + alpha_channel] = ((const float*)input_data)[input_pixel_index + alpha_channel];+        }++        break;++    default:+        STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");+        break;+    }++    if (!(stbir_info->flags & STBIR_FLAG_ALPHA_PREMULTIPLIED))+    {+        for (x = -stbir_info->horizontal_filter_pixel_margin; x < max_x; x++)+        {+            int decode_pixel_index = x * channels;++            // If the alpha value is 0 it will clobber the color values. Make sure it's not.+            float alpha = decode_buffer[decode_pixel_index + alpha_channel];+#ifndef STBIR_NO_ALPHA_EPSILON+            if (stbir_info->type != STBIR_TYPE_FLOAT) {+                alpha += STBIR_ALPHA_EPSILON;+                decode_buffer[decode_pixel_index + alpha_channel] = alpha;+            }+#endif+            for (c = 0; c < channels; c++)+            {+                if (c == alpha_channel)+                    continue;++                decode_buffer[decode_pixel_index + c] *= alpha;+            }+        }+    }++    if (edge_horizontal == STBIR_EDGE_ZERO)+    {+        for (x = -stbir_info->horizontal_filter_pixel_margin; x < 0; x++)+        {+            for (c = 0; c < channels; c++)+                decode_buffer[x*channels + c] = 0;+        }+        for (x = input_w; x < max_x; x++)+        {+            for (c = 0; c < channels; c++)+                decode_buffer[x*channels + c] = 0;+        }+    }+}++static float* stbir__get_ring_buffer_entry(float* ring_buffer, int index, int ring_buffer_length)+{+    return &ring_buffer[index * ring_buffer_length];+}++static float* stbir__add_empty_ring_buffer_entry(stbir__info* stbir_info, int n)+{+    int ring_buffer_index;+    float* ring_buffer;++    stbir_info->ring_buffer_last_scanline = n;++    if (stbir_info->ring_buffer_begin_index < 0)+    {+        ring_buffer_index = stbir_info->ring_buffer_begin_index = 0;+        stbir_info->ring_buffer_first_scanline = n;+    }+    else+    {+        ring_buffer_index = (stbir_info->ring_buffer_begin_index + (stbir_info->ring_buffer_last_scanline - stbir_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries;+        STBIR_ASSERT(ring_buffer_index != stbir_info->ring_buffer_begin_index);+    }++    ring_buffer = stbir__get_ring_buffer_entry(stbir_info->ring_buffer, ring_buffer_index, stbir_info->ring_buffer_length_bytes / sizeof(float));+    memset(ring_buffer, 0, stbir_info->ring_buffer_length_bytes);++    return ring_buffer;+}+++static void stbir__resample_horizontal_upsample(stbir__info* stbir_info, float* output_buffer)+{+    int x, k;+    int output_w = stbir_info->output_w;+    int channels = stbir_info->channels;+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);+    stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;+    float* horizontal_coefficients = stbir_info->horizontal_coefficients;+    int coefficient_width = stbir_info->horizontal_coefficient_width;++    for (x = 0; x < output_w; x++)+    {+        int n0 = horizontal_contributors[x].n0;+        int n1 = horizontal_contributors[x].n1;++        int out_pixel_index = x * channels;+        int coefficient_group = coefficient_width * x;+        int coefficient_counter = 0;++        STBIR_ASSERT(n1 >= n0);+        STBIR_ASSERT(n0 >= -stbir_info->horizontal_filter_pixel_margin);+        STBIR_ASSERT(n1 >= -stbir_info->horizontal_filter_pixel_margin);+        STBIR_ASSERT(n0 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);+        STBIR_ASSERT(n1 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);++        switch (channels) {+            case 1:+                for (k = n0; k <= n1; k++)+                {+                    int in_pixel_index = k * 1;+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                }+                break;+            case 2:+                for (k = n0; k <= n1; k++)+                {+                    int in_pixel_index = k * 2;+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                }+                break;+            case 3:+                for (k = n0; k <= n1; k++)+                {+                    int in_pixel_index = k * 3;+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;+                }+                break;+            case 4:+                for (k = n0; k <= n1; k++)+                {+                    int in_pixel_index = k * 4;+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;+                    output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;+                }+                break;+            default:+                for (k = n0; k <= n1; k++)+                {+                    int in_pixel_index = k * channels;+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];+                    int c;+                    STBIR_ASSERT(coefficient != 0);+                    for (c = 0; c < channels; c++)+                        output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;+                }+                break;+        }+    }+}++static void stbir__resample_horizontal_downsample(stbir__info* stbir_info, float* output_buffer)+{+    int x, k;+    int input_w = stbir_info->input_w;+    int channels = stbir_info->channels;+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);+    stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;+    float* horizontal_coefficients = stbir_info->horizontal_coefficients;+    int coefficient_width = stbir_info->horizontal_coefficient_width;+    int filter_pixel_margin = stbir_info->horizontal_filter_pixel_margin;+    int max_x = input_w + filter_pixel_margin * 2;++    STBIR_ASSERT(!stbir__use_width_upsampling(stbir_info));++    switch (channels) {+        case 1:+            for (x = 0; x < max_x; x++)+            {+                int n0 = horizontal_contributors[x].n0;+                int n1 = horizontal_contributors[x].n1;++                int in_x = x - filter_pixel_margin;+                int in_pixel_index = in_x * 1;+                int max_n = n1;+                int coefficient_group = coefficient_width * x;++                for (k = n0; k <= max_n; k++)+                {+                    int out_pixel_index = k * 1;+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                }+            }+            break;++        case 2:+            for (x = 0; x < max_x; x++)+            {+                int n0 = horizontal_contributors[x].n0;+                int n1 = horizontal_contributors[x].n1;++                int in_x = x - filter_pixel_margin;+                int in_pixel_index = in_x * 2;+                int max_n = n1;+                int coefficient_group = coefficient_width * x;++                for (k = n0; k <= max_n; k++)+                {+                    int out_pixel_index = k * 2;+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                }+            }+            break;++        case 3:+            for (x = 0; x < max_x; x++)+            {+                int n0 = horizontal_contributors[x].n0;+                int n1 = horizontal_contributors[x].n1;++                int in_x = x - filter_pixel_margin;+                int in_pixel_index = in_x * 3;+                int max_n = n1;+                int coefficient_group = coefficient_width * x;++                for (k = n0; k <= max_n; k++)+                {+                    int out_pixel_index = k * 3;+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;+                }+            }+            break;++        case 4:+            for (x = 0; x < max_x; x++)+            {+                int n0 = horizontal_contributors[x].n0;+                int n1 = horizontal_contributors[x].n1;++                int in_x = x - filter_pixel_margin;+                int in_pixel_index = in_x * 4;+                int max_n = n1;+                int coefficient_group = coefficient_width * x;++                for (k = n0; k <= max_n; k++)+                {+                    int out_pixel_index = k * 4;+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];+                    STBIR_ASSERT(coefficient != 0);+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;+                    output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;+                }+            }+            break;++        default:+            for (x = 0; x < max_x; x++)+            {+                int n0 = horizontal_contributors[x].n0;+                int n1 = horizontal_contributors[x].n1;++                int in_x = x - filter_pixel_margin;+                int in_pixel_index = in_x * channels;+                int max_n = n1;+                int coefficient_group = coefficient_width * x;++                for (k = n0; k <= max_n; k++)+                {+                    int c;+                    int out_pixel_index = k * channels;+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];+                    STBIR_ASSERT(coefficient != 0);+                    for (c = 0; c < channels; c++)+                        output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;+                }+            }+            break;+    }+}++static void stbir__decode_and_resample_upsample(stbir__info* stbir_info, int n)+{+    // Decode the nth scanline from the source image into the decode buffer.+    stbir__decode_scanline(stbir_info, n);++    // Now resample it into the ring buffer.+    if (stbir__use_width_upsampling(stbir_info))+        stbir__resample_horizontal_upsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));+    else+        stbir__resample_horizontal_downsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));++    // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.+}++static void stbir__decode_and_resample_downsample(stbir__info* stbir_info, int n)+{+    // Decode the nth scanline from the source image into the decode buffer.+    stbir__decode_scanline(stbir_info, n);++    memset(stbir_info->horizontal_buffer, 0, stbir_info->output_w * stbir_info->channels * sizeof(float));++    // Now resample it into the horizontal buffer.+    if (stbir__use_width_upsampling(stbir_info))+        stbir__resample_horizontal_upsample(stbir_info, stbir_info->horizontal_buffer);+    else+        stbir__resample_horizontal_downsample(stbir_info, stbir_info->horizontal_buffer);++    // Now it's sitting in the horizontal buffer ready to be distributed into the ring buffers.+}++// Get the specified scan line from the ring buffer.+static float* stbir__get_ring_buffer_scanline(int get_scanline, float* ring_buffer, int begin_index, int first_scanline, int ring_buffer_num_entries, int ring_buffer_length)+{+    int ring_buffer_index = (begin_index + (get_scanline - first_scanline)) % ring_buffer_num_entries;+    return stbir__get_ring_buffer_entry(ring_buffer, ring_buffer_index, ring_buffer_length);+}+++static void stbir__encode_scanline(stbir__info* stbir_info, int num_pixels, void *output_buffer, float *encode_buffer, int channels, int alpha_channel, int decode)+{+    int x;+    int n;+    int num_nonalpha;+    stbir_uint16 nonalpha[STBIR_MAX_CHANNELS];++    if (!(stbir_info->flags&STBIR_FLAG_ALPHA_PREMULTIPLIED))+    {+        for (x=0; x < num_pixels; ++x)+        {+            int pixel_index = x*channels;++            float alpha = encode_buffer[pixel_index + alpha_channel];+            float reciprocal_alpha = alpha ? 1.0f / alpha : 0;++            // unrolling this produced a 1% slowdown upscaling a large RGBA linear-space image on my machine - stb+            for (n = 0; n < channels; n++)+                if (n != alpha_channel)+                    encode_buffer[pixel_index + n] *= reciprocal_alpha;++            // We added in a small epsilon to prevent the color channel from being deleted with zero alpha.+            // Because we only add it for integer types, it will automatically be discarded on integer+            // conversion, so we don't need to subtract it back out (which would be problematic for+            // numeric precision reasons).+        }+    }++    // build a table of all channels that need colorspace correction, so+    // we don't perform colorspace correction on channels that don't need it.+    for (x = 0, num_nonalpha = 0; x < channels; ++x)+    {+        if (x != alpha_channel || (stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))+        {+            nonalpha[num_nonalpha++] = (stbir_uint16)x;+        }+    }++    #define STBIR__ROUND_INT(f)    ((int)          ((f)+0.5))+    #define STBIR__ROUND_UINT(f)   ((stbir_uint32) ((f)+0.5))++    #ifdef STBIR__SATURATE_INT+    #define STBIR__ENCODE_LINEAR8(f)   stbir__saturate8 (STBIR__ROUND_INT((f) * stbir__max_uint8_as_float ))+    #define STBIR__ENCODE_LINEAR16(f)  stbir__saturate16(STBIR__ROUND_INT((f) * stbir__max_uint16_as_float))+    #else+    #define STBIR__ENCODE_LINEAR8(f)   (unsigned char ) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint8_as_float )+    #define STBIR__ENCODE_LINEAR16(f)  (unsigned short) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint16_as_float)+    #endif++    switch (decode)+    {+        case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < channels; n++)+                {+                    int index = pixel_index + n;+                    ((unsigned char*)output_buffer)[index] = STBIR__ENCODE_LINEAR8(encode_buffer[index]);+                }+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < num_nonalpha; n++)+                {+                    int index = pixel_index + nonalpha[n];+                    ((unsigned char*)output_buffer)[index] = stbir__linear_to_srgb_uchar(encode_buffer[index]);+                }++                if (!(stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))+                    ((unsigned char *)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR8(encode_buffer[pixel_index+alpha_channel]);+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < channels; n++)+                {+                    int index = pixel_index + n;+                    ((unsigned short*)output_buffer)[index] = STBIR__ENCODE_LINEAR16(encode_buffer[index]);+                }+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < num_nonalpha; n++)+                {+                    int index = pixel_index + nonalpha[n];+                    ((unsigned short*)output_buffer)[index] = (unsigned short)STBIR__ROUND_INT(stbir__linear_to_srgb(stbir__saturate(encode_buffer[index])) * stbir__max_uint16_as_float);+                }++                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                    ((unsigned short*)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR16(encode_buffer[pixel_index + alpha_channel]);+            }++            break;++        case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < channels; n++)+                {+                    int index = pixel_index + n;+                    ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__saturate(encode_buffer[index])) * stbir__max_uint32_as_float);+                }+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < num_nonalpha; n++)+                {+                    int index = pixel_index + nonalpha[n];+                    ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__linear_to_srgb(stbir__saturate(encode_buffer[index]))) * stbir__max_uint32_as_float);+                }++                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                    ((unsigned int*)output_buffer)[pixel_index + alpha_channel] = (unsigned int)STBIR__ROUND_INT(((double)stbir__saturate(encode_buffer[pixel_index + alpha_channel])) * stbir__max_uint32_as_float);+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < channels; n++)+                {+                    int index = pixel_index + n;+                    ((float*)output_buffer)[index] = encode_buffer[index];+                }+            }+            break;++        case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):+            for (x=0; x < num_pixels; ++x)+            {+                int pixel_index = x*channels;++                for (n = 0; n < num_nonalpha; n++)+                {+                    int index = pixel_index + nonalpha[n];+                    ((float*)output_buffer)[index] = stbir__linear_to_srgb(encode_buffer[index]);+                }++                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))+                    ((float*)output_buffer)[pixel_index + alpha_channel] = encode_buffer[pixel_index + alpha_channel];+            }+            break;++        default:+            STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");+            break;+    }+}++static void stbir__resample_vertical_upsample(stbir__info* stbir_info, int n)+{+    int x, k;+    int output_w = stbir_info->output_w;+    stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;+    float* vertical_coefficients = stbir_info->vertical_coefficients;+    int channels = stbir_info->channels;+    int alpha_channel = stbir_info->alpha_channel;+    int type = stbir_info->type;+    int colorspace = stbir_info->colorspace;+    int ring_buffer_entries = stbir_info->ring_buffer_num_entries;+    void* output_data = stbir_info->output_data;+    float* encode_buffer = stbir_info->encode_buffer;+    int decode = STBIR__DECODE(type, colorspace);+    int coefficient_width = stbir_info->vertical_coefficient_width;+    int coefficient_counter;+    int contributor = n;++    float* ring_buffer = stbir_info->ring_buffer;+    int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;+    int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);++    int n0,n1, output_row_start;+    int coefficient_group = coefficient_width * contributor;++    n0 = vertical_contributors[contributor].n0;+    n1 = vertical_contributors[contributor].n1;++    output_row_start = n * stbir_info->output_stride_bytes;++    STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));++    memset(encode_buffer, 0, output_w * sizeof(float) * channels);++    // I tried reblocking this for better cache usage of encode_buffer+    // (using x_outer, k, x_inner), but it lost speed. -- stb++    coefficient_counter = 0;+    switch (channels) {+        case 1:+            for (k = n0; k <= n1; k++)+            {+                int coefficient_index = coefficient_counter++;+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];+                for (x = 0; x < output_w; ++x)+                {+                    int in_pixel_index = x * 1;+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;+                }+            }+            break;+        case 2:+            for (k = n0; k <= n1; k++)+            {+                int coefficient_index = coefficient_counter++;+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];+                for (x = 0; x < output_w; ++x)+                {+                    int in_pixel_index = x * 2;+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;+                }+            }+            break;+        case 3:+            for (k = n0; k <= n1; k++)+            {+                int coefficient_index = coefficient_counter++;+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];+                for (x = 0; x < output_w; ++x)+                {+                    int in_pixel_index = x * 3;+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;+                    encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;+                }+            }+            break;+        case 4:+            for (k = n0; k <= n1; k++)+            {+                int coefficient_index = coefficient_counter++;+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];+                for (x = 0; x < output_w; ++x)+                {+                    int in_pixel_index = x * 4;+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;+                    encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;+                    encode_buffer[in_pixel_index + 3] += ring_buffer_entry[in_pixel_index + 3] * coefficient;+                }+            }+            break;+        default:+            for (k = n0; k <= n1; k++)+            {+                int coefficient_index = coefficient_counter++;+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];+                for (x = 0; x < output_w; ++x)+                {+                    int in_pixel_index = x * channels;+                    int c;+                    for (c = 0; c < channels; c++)+                        encode_buffer[in_pixel_index + c] += ring_buffer_entry[in_pixel_index + c] * coefficient;+                }+            }+            break;+    }+    stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, encode_buffer, channels, alpha_channel, decode);+}++static void stbir__resample_vertical_downsample(stbir__info* stbir_info, int n)+{+    int x, k;+    int output_w = stbir_info->output_w;+    stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;+    float* vertical_coefficients = stbir_info->vertical_coefficients;+    int channels = stbir_info->channels;+    int ring_buffer_entries = stbir_info->ring_buffer_num_entries;+    float* horizontal_buffer = stbir_info->horizontal_buffer;+    int coefficient_width = stbir_info->vertical_coefficient_width;+    int contributor = n + stbir_info->vertical_filter_pixel_margin;++    float* ring_buffer = stbir_info->ring_buffer;+    int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;+    int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);+    int n0,n1;++    n0 = vertical_contributors[contributor].n0;+    n1 = vertical_contributors[contributor].n1;++    STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));++    for (k = n0; k <= n1; k++)+    {+        int coefficient_index = k - n0;+        int coefficient_group = coefficient_width * contributor;+        float coefficient = vertical_coefficients[coefficient_group + coefficient_index];++        float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);++        switch (channels) {+            case 1:+                for (x = 0; x < output_w; x++)+                {+                    int in_pixel_index = x * 1;+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;+                }+                break;+            case 2:+                for (x = 0; x < output_w; x++)+                {+                    int in_pixel_index = x * 2;+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;+                }+                break;+            case 3:+                for (x = 0; x < output_w; x++)+                {+                    int in_pixel_index = x * 3;+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;+                    ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;+                }+                break;+            case 4:+                for (x = 0; x < output_w; x++)+                {+                    int in_pixel_index = x * 4;+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;+                    ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;+                    ring_buffer_entry[in_pixel_index + 3] += horizontal_buffer[in_pixel_index + 3] * coefficient;+                }+                break;+            default:+                for (x = 0; x < output_w; x++)+                {+                    int in_pixel_index = x * channels;++                    int c;+                    for (c = 0; c < channels; c++)+                        ring_buffer_entry[in_pixel_index + c] += horizontal_buffer[in_pixel_index + c] * coefficient;+                }+                break;+        }+    }+}++static void stbir__buffer_loop_upsample(stbir__info* stbir_info)+{+    int y;+    float scale_ratio = stbir_info->vertical_scale;+    float out_scanlines_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(1/scale_ratio) * scale_ratio;++    STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));++    for (y = 0; y < stbir_info->output_h; y++)+    {+        float in_center_of_out = 0; // Center of the current out scanline in the in scanline space+        int in_first_scanline = 0, in_last_scanline = 0;++        stbir__calculate_sample_range_upsample(y, out_scanlines_radius, scale_ratio, stbir_info->vertical_shift, &in_first_scanline, &in_last_scanline, &in_center_of_out);++        STBIR_ASSERT(in_last_scanline - in_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);++        if (stbir_info->ring_buffer_begin_index >= 0)+        {+            // Get rid of whatever we don't need anymore.+            while (in_first_scanline > stbir_info->ring_buffer_first_scanline)+            {+                if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)+                {+                    // We just popped the last scanline off the ring buffer.+                    // Reset it to the empty state.+                    stbir_info->ring_buffer_begin_index = -1;+                    stbir_info->ring_buffer_first_scanline = 0;+                    stbir_info->ring_buffer_last_scanline = 0;+                    break;+                }+                else+                {+                    stbir_info->ring_buffer_first_scanline++;+                    stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;+                }+            }+        }++        // Load in new ones.+        if (stbir_info->ring_buffer_begin_index < 0)+            stbir__decode_and_resample_upsample(stbir_info, in_first_scanline);++        while (in_last_scanline > stbir_info->ring_buffer_last_scanline)+            stbir__decode_and_resample_upsample(stbir_info, stbir_info->ring_buffer_last_scanline + 1);++        // Now all buffers should be ready to write a row of vertical sampling.+        stbir__resample_vertical_upsample(stbir_info, y);++        STBIR_PROGRESS_REPORT((float)y / stbir_info->output_h);+    }+}++static void stbir__empty_ring_buffer(stbir__info* stbir_info, int first_necessary_scanline)+{+    int output_stride_bytes = stbir_info->output_stride_bytes;+    int channels = stbir_info->channels;+    int alpha_channel = stbir_info->alpha_channel;+    int type = stbir_info->type;+    int colorspace = stbir_info->colorspace;+    int output_w = stbir_info->output_w;+    void* output_data = stbir_info->output_data;+    int decode = STBIR__DECODE(type, colorspace);++    float* ring_buffer = stbir_info->ring_buffer;+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);++    if (stbir_info->ring_buffer_begin_index >= 0)+    {+        // Get rid of whatever we don't need anymore.+        while (first_necessary_scanline > stbir_info->ring_buffer_first_scanline)+        {+            if (stbir_info->ring_buffer_first_scanline >= 0 && stbir_info->ring_buffer_first_scanline < stbir_info->output_h)+            {+                int output_row_start = stbir_info->ring_buffer_first_scanline * output_stride_bytes;+                float* ring_buffer_entry = stbir__get_ring_buffer_entry(ring_buffer, stbir_info->ring_buffer_begin_index, ring_buffer_length);+                stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, ring_buffer_entry, channels, alpha_channel, decode);+                STBIR_PROGRESS_REPORT((float)stbir_info->ring_buffer_first_scanline / stbir_info->output_h);+            }++            if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)+            {+                // We just popped the last scanline off the ring buffer.+                // Reset it to the empty state.+                stbir_info->ring_buffer_begin_index = -1;+                stbir_info->ring_buffer_first_scanline = 0;+                stbir_info->ring_buffer_last_scanline = 0;+                break;+            }+            else+            {+                stbir_info->ring_buffer_first_scanline++;+                stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;+            }+        }+    }+}++static void stbir__buffer_loop_downsample(stbir__info* stbir_info)+{+    int y;+    float scale_ratio = stbir_info->vertical_scale;+    int output_h = stbir_info->output_h;+    float in_pixels_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(scale_ratio) / scale_ratio;+    int pixel_margin = stbir_info->vertical_filter_pixel_margin;+    int max_y = stbir_info->input_h + pixel_margin;++    STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));++    for (y = -pixel_margin; y < max_y; y++)+    {+        float out_center_of_in; // Center of the current out scanline in the in scanline space+        int out_first_scanline, out_last_scanline;++        stbir__calculate_sample_range_downsample(y, in_pixels_radius, scale_ratio, stbir_info->vertical_shift, &out_first_scanline, &out_last_scanline, &out_center_of_in);++        STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);++        if (out_last_scanline < 0 || out_first_scanline >= output_h)+            continue;++        stbir__empty_ring_buffer(stbir_info, out_first_scanline);++        stbir__decode_and_resample_downsample(stbir_info, y);++        // Load in new ones.+        if (stbir_info->ring_buffer_begin_index < 0)+            stbir__add_empty_ring_buffer_entry(stbir_info, out_first_scanline);++        while (out_last_scanline > stbir_info->ring_buffer_last_scanline)+            stbir__add_empty_ring_buffer_entry(stbir_info, stbir_info->ring_buffer_last_scanline + 1);++        // Now the horizontal buffer is ready to write to all ring buffer rows.+        stbir__resample_vertical_downsample(stbir_info, y);+    }++    stbir__empty_ring_buffer(stbir_info, stbir_info->output_h);+}++static void stbir__setup(stbir__info *info, int input_w, int input_h, int output_w, int output_h, int channels)+{+    info->input_w = input_w;+    info->input_h = input_h;+    info->output_w = output_w;+    info->output_h = output_h;+    info->channels = channels;+}++static void stbir__calculate_transform(stbir__info *info, float s0, float t0, float s1, float t1, float *transform)+{+    info->s0 = s0;+    info->t0 = t0;+    info->s1 = s1;+    info->t1 = t1;++    if (transform)+    {+        info->horizontal_scale = transform[0];+        info->vertical_scale   = transform[1];+        info->horizontal_shift = transform[2];+        info->vertical_shift   = transform[3];+    }+    else+    {+        info->horizontal_scale = ((float)info->output_w / info->input_w) / (s1 - s0);+        info->vertical_scale = ((float)info->output_h / info->input_h) / (t1 - t0);++        info->horizontal_shift = s0 * info->output_w / (s1 - s0);+        info->vertical_shift = t0 * info->output_h / (t1 - t0);+    }+}++static void stbir__choose_filter(stbir__info *info, stbir_filter h_filter, stbir_filter v_filter)+{+    if (h_filter == 0)+        h_filter = stbir__use_upsampling(info->horizontal_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;+    if (v_filter == 0)+        v_filter = stbir__use_upsampling(info->vertical_scale)   ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;+    info->horizontal_filter = h_filter;+    info->vertical_filter = v_filter;+}++static stbir_uint32 stbir__calculate_memory(stbir__info *info)+{+    int pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);+    int filter_height = stbir__get_filter_pixel_width(info->vertical_filter, info->vertical_scale);++    info->horizontal_num_contributors = stbir__get_contributors(info->horizontal_scale, info->horizontal_filter, info->input_w, info->output_w);+    info->vertical_num_contributors   = stbir__get_contributors(info->vertical_scale  , info->vertical_filter  , info->input_h, info->output_h);++    // One extra entry because floating point precision problems sometimes cause an extra to be necessary.+    info->ring_buffer_num_entries = filter_height + 1;++    info->horizontal_contributors_size = info->horizontal_num_contributors * sizeof(stbir__contributors);+    info->horizontal_coefficients_size = stbir__get_total_horizontal_coefficients(info) * sizeof(float);+    info->vertical_contributors_size = info->vertical_num_contributors * sizeof(stbir__contributors);+    info->vertical_coefficients_size = stbir__get_total_vertical_coefficients(info) * sizeof(float);+    info->decode_buffer_size = (info->input_w + pixel_margin * 2) * info->channels * sizeof(float);+    info->horizontal_buffer_size = info->output_w * info->channels * sizeof(float);+    info->ring_buffer_size = info->output_w * info->channels * info->ring_buffer_num_entries * sizeof(float);+    info->encode_buffer_size = info->output_w * info->channels * sizeof(float);++    STBIR_ASSERT(info->horizontal_filter != 0);+    STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late+    STBIR_ASSERT(info->vertical_filter != 0);+    STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late++    if (stbir__use_height_upsampling(info))+        // The horizontal buffer is for when we're downsampling the height and we+        // can't output the result of sampling the decode buffer directly into the+        // ring buffers.+        info->horizontal_buffer_size = 0;+    else+        // The encode buffer is to retain precision in the height upsampling method+        // and isn't used when height downsampling.+        info->encode_buffer_size = 0;++    return info->horizontal_contributors_size + info->horizontal_coefficients_size+        + info->vertical_contributors_size + info->vertical_coefficients_size+        + info->decode_buffer_size + info->horizontal_buffer_size+        + info->ring_buffer_size + info->encode_buffer_size;+}++static int stbir__resize_allocated(stbir__info *info,+    const void* input_data, int input_stride_in_bytes,+    void* output_data, int output_stride_in_bytes,+    int alpha_channel, stbir_uint32 flags, stbir_datatype type,+    stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace,+    void* tempmem, size_t tempmem_size_in_bytes)+{+    size_t memory_required = stbir__calculate_memory(info);++    int width_stride_input = input_stride_in_bytes ? input_stride_in_bytes : info->channels * info->input_w * stbir__type_size[type];+    int width_stride_output = output_stride_in_bytes ? output_stride_in_bytes : info->channels * info->output_w * stbir__type_size[type];++#ifdef STBIR_DEBUG_OVERWRITE_TEST+#define OVERWRITE_ARRAY_SIZE 8+    unsigned char overwrite_output_before_pre[OVERWRITE_ARRAY_SIZE];+    unsigned char overwrite_tempmem_before_pre[OVERWRITE_ARRAY_SIZE];+    unsigned char overwrite_output_after_pre[OVERWRITE_ARRAY_SIZE];+    unsigned char overwrite_tempmem_after_pre[OVERWRITE_ARRAY_SIZE];++    size_t begin_forbidden = width_stride_output * (info->output_h - 1) + info->output_w * info->channels * stbir__type_size[type];+    memcpy(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);+    memcpy(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE);+    memcpy(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);+    memcpy(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE);+#endif++    STBIR_ASSERT(info->channels >= 0);+    STBIR_ASSERT(info->channels <= STBIR_MAX_CHANNELS);++    if (info->channels < 0 || info->channels > STBIR_MAX_CHANNELS)+        return 0;++    STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));+    STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));++    if (info->horizontal_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))+        return 0;+    if (info->vertical_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))+        return 0;++    if (alpha_channel < 0)+        flags |= STBIR_FLAG_ALPHA_USES_COLORSPACE | STBIR_FLAG_ALPHA_PREMULTIPLIED;++    if (!(flags&STBIR_FLAG_ALPHA_USES_COLORSPACE) || !(flags&STBIR_FLAG_ALPHA_PREMULTIPLIED))+        STBIR_ASSERT(alpha_channel >= 0 && alpha_channel < info->channels);++    if (alpha_channel >= info->channels)+        return 0;++    STBIR_ASSERT(tempmem);++    if (!tempmem)+        return 0;++    STBIR_ASSERT(tempmem_size_in_bytes >= memory_required);++    if (tempmem_size_in_bytes < memory_required)+        return 0;++    memset(tempmem, 0, tempmem_size_in_bytes);++    info->input_data = input_data;+    info->input_stride_bytes = width_stride_input;++    info->output_data = output_data;+    info->output_stride_bytes = width_stride_output;++    info->alpha_channel = alpha_channel;+    info->flags = flags;+    info->type = type;+    info->edge_horizontal = edge_horizontal;+    info->edge_vertical = edge_vertical;+    info->colorspace = colorspace;++    info->horizontal_coefficient_width   = stbir__get_coefficient_width  (info->horizontal_filter, info->horizontal_scale);+    info->vertical_coefficient_width     = stbir__get_coefficient_width  (info->vertical_filter  , info->vertical_scale  );+    info->horizontal_filter_pixel_width  = stbir__get_filter_pixel_width (info->horizontal_filter, info->horizontal_scale);+    info->vertical_filter_pixel_width    = stbir__get_filter_pixel_width (info->vertical_filter  , info->vertical_scale  );+    info->horizontal_filter_pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);+    info->vertical_filter_pixel_margin   = stbir__get_filter_pixel_margin(info->vertical_filter  , info->vertical_scale  );++    info->ring_buffer_length_bytes = info->output_w * info->channels * sizeof(float);+    info->decode_buffer_pixels = info->input_w + info->horizontal_filter_pixel_margin * 2;++#define STBIR__NEXT_MEMPTR(current, newtype) (newtype*)(((unsigned char*)current) + current##_size)++    info->horizontal_contributors = (stbir__contributors *) tempmem;+    info->horizontal_coefficients = STBIR__NEXT_MEMPTR(info->horizontal_contributors, float);+    info->vertical_contributors = STBIR__NEXT_MEMPTR(info->horizontal_coefficients, stbir__contributors);+    info->vertical_coefficients = STBIR__NEXT_MEMPTR(info->vertical_contributors, float);+    info->decode_buffer = STBIR__NEXT_MEMPTR(info->vertical_coefficients, float);++    if (stbir__use_height_upsampling(info))+    {+        info->horizontal_buffer = NULL;+        info->ring_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);+        info->encode_buffer = STBIR__NEXT_MEMPTR(info->ring_buffer, float);++        STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->encode_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);+    }+    else+    {+        info->horizontal_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);+        info->ring_buffer = STBIR__NEXT_MEMPTR(info->horizontal_buffer, float);+        info->encode_buffer = NULL;++        STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->ring_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);+    }++#undef STBIR__NEXT_MEMPTR++    // This signals that the ring buffer is empty+    info->ring_buffer_begin_index = -1;++    stbir__calculate_filters(info->horizontal_contributors, info->horizontal_coefficients, info->horizontal_filter, info->horizontal_scale, info->horizontal_shift, info->input_w, info->output_w);+    stbir__calculate_filters(info->vertical_contributors, info->vertical_coefficients, info->vertical_filter, info->vertical_scale, info->vertical_shift, info->input_h, info->output_h);++    STBIR_PROGRESS_REPORT(0);++    if (stbir__use_height_upsampling(info))+        stbir__buffer_loop_upsample(info);+    else+        stbir__buffer_loop_downsample(info);++    STBIR_PROGRESS_REPORT(1);++#ifdef STBIR_DEBUG_OVERWRITE_TEST+    STBIR_ASSERT(memcmp(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);+    STBIR_ASSERT(memcmp(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0);+    STBIR_ASSERT(memcmp(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);+    STBIR_ASSERT(memcmp(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE) == 0);+#endif++    return 1;+}+++static int stbir__resize_arbitrary(+    void *alloc_context,+    const void* input_data, int input_w, int input_h, int input_stride_in_bytes,+    void* output_data, int output_w, int output_h, int output_stride_in_bytes,+    float s0, float t0, float s1, float t1, float *transform,+    int channels, int alpha_channel, stbir_uint32 flags, stbir_datatype type,+    stbir_filter h_filter, stbir_filter v_filter,+    stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace)+{+    stbir__info info;+    int result;+    size_t memory_required;+    void* extra_memory;++    stbir__setup(&info, input_w, input_h, output_w, output_h, channels);+    stbir__calculate_transform(&info, s0,t0,s1,t1,transform);+    stbir__choose_filter(&info, h_filter, v_filter);+    memory_required = stbir__calculate_memory(&info);+    extra_memory = STBIR_MALLOC(memory_required, alloc_context);++    if (!extra_memory)+        return 0;++    result = stbir__resize_allocated(&info, input_data, input_stride_in_bytes,+                                            output_data, output_stride_in_bytes, +                                            alpha_channel, flags, type,+                                            edge_horizontal, edge_vertical,+                                            colorspace, extra_memory, memory_required);++    STBIR_FREE(extra_memory, alloc_context);++    return result;+}++STBIRDEF int stbir_resize_uint8(     const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels)+{+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);+}++STBIRDEF int stbir_resize_float(     const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels)+{+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_FLOAT, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);+}++STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                     int num_channels, int alpha_channel, int flags)+{+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_SRGB);+}++STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                                    unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                              int num_channels, int alpha_channel, int flags,+                                              stbir_edge edge_wrap_mode)+{+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,+        edge_wrap_mode, edge_wrap_mode, STBIR_COLORSPACE_SRGB);+}++STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                               unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context)+{+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, filter, filter,+        edge_wrap_mode, edge_wrap_mode, space);+}++STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels  , int input_w , int input_h , int input_stride_in_bytes,+                                               stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context)+{+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT16, filter, filter,+        edge_wrap_mode, edge_wrap_mode, space);+}+++STBIRDEF int stbir_resize_float_generic( const float *input_pixels         , int input_w , int input_h , int input_stride_in_bytes,+                                               float *output_pixels        , int output_w, int output_h, int output_stride_in_bytes,+                                         int num_channels, int alpha_channel, int flags,+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, +                                         void *alloc_context)+{+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_FLOAT, filter, filter,+        edge_wrap_mode, edge_wrap_mode, space);+}+++STBIRDEF int stbir_resize(         const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context)+{+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,+        edge_mode_horizontal, edge_mode_vertical, space);+}+++STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context,+                                   float x_scale, float y_scale,+                                   float x_offset, float y_offset)+{+    float transform[4];+    transform[0] = x_scale;+    transform[1] = y_scale;+    transform[2] = x_offset;+    transform[3] = y_offset;+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        0,0,1,1,transform,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,+        edge_mode_horizontal, edge_mode_vertical, space);+}++STBIRDEF int stbir_resize_region(  const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,+                                   stbir_datatype datatype,+                                   int num_channels, int alpha_channel, int flags,+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, +                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,+                                   stbir_colorspace space, void *alloc_context,+                                   float s0, float t0, float s1, float t1)+{+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,+        output_pixels, output_w, output_h, output_stride_in_bytes,+        s0,t0,s1,t1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,+        edge_mode_horizontal, edge_mode_vertical, space);+}++#endif // STB_IMAGE_RESIZE_IMPLEMENTATION++/*+------------------------------------------------------------------------------+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.+------------------------------------------------------------------------------+*/

@@ -0,0 +1,260 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleContexts #-}+module Codec.Picture.STBIR+( -- * Resize function+  resize+  -- * Options+, Options(..)+, defaultOptions+, Flag+, flag_ALPHA_PREMULTIPLIED+, flag_ALPHA_USES_COLORSPACE+, Edge(..)+, Filter(..)+, Colorspace(..)+, Scale(..)+, Region(..)+  -- * Supported pixel types+, STBIRPixel(..)+, STBIRComponent(..)+, Datatype(..)+) where++import Foreign+import Foreign.C+import Codec.Picture+import Codec.Picture.Types+import qualified Data.Vector.Storable as V+import System.IO.Unsafe (unsafePerformIO)+import Data.Default.Class (Default(..))++#include "stb_image_resize.h"++newtype Flag = Flag { fromFlag :: CInt }+  deriving (Eq, Ord, Show, Read)++{- |+Set this flag if your texture has premultiplied alpha. Otherwise, `stbir` will+use alpha-weighted resampling (effectively premultiplying, resampling,+then unpremultiplying).+-}+flag_ALPHA_PREMULTIPLIED :: Flag+flag_ALPHA_PREMULTIPLIED = Flag 1 -- c2hs const has problems due to <<++{- |+The specified alpha channel should be handled as gamma-corrected value even+when doing sRGB operations.+-}+flag_ALPHA_USES_COLORSPACE :: Flag+flag_ALPHA_USES_COLORSPACE = Flag 2++{#enum stbir_edge as Edge {}+  with prefix = "STBIR_"+  deriving (Eq, Ord, Show, Read, Bounded)+#}++data Filter+  = FILTER_DEFAULT      -- ^ use same filter type that easy-to-use API chooses+  | FILTER_BOX          -- ^ A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios+  | FILTER_TRIANGLE     -- ^ On upsampling, produces same results as bilinear texture filtering+  | FILTER_CUBICBSPLINE -- ^ The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque+  | FILTER_CATMULLROM   -- ^ An interpolating cubic spline+  | FILTER_MITCHELL     -- ^ Mitchell-Netrevalli filter with B=1\/3, C=1\/3+  deriving (Eq, Ord, Show, Read, Enum, Bounded)++-- the separate types here are because c2hs doesn't let me insert haddocks+{#enum stbir_filter as C_Filter {}+  deriving (Eq, Ord, Show, Read, Bounded)+#}++cFilter :: Filter -> CInt+cFilter FILTER_DEFAULT      = fromIntegral $ fromEnum STBIR_FILTER_DEFAULT+cFilter FILTER_BOX          = fromIntegral $ fromEnum STBIR_FILTER_BOX+cFilter FILTER_TRIANGLE     = fromIntegral $ fromEnum STBIR_FILTER_TRIANGLE+cFilter FILTER_CUBICBSPLINE = fromIntegral $ fromEnum STBIR_FILTER_CUBICBSPLINE+cFilter FILTER_CATMULLROM   = fromIntegral $ fromEnum STBIR_FILTER_CATMULLROM+cFilter FILTER_MITCHELL     = fromIntegral $ fromEnum STBIR_FILTER_MITCHELL++{#enum stbir_colorspace as Colorspace {}+  omit (STBIR_MAX_COLORSPACES)+  with prefix = "STBIR_"+  deriving (Eq, Ord, Show, Read, Bounded)+#}++{#enum stbir_datatype as Datatype {}+  omit (STBIR_MAX_TYPES)+  with prefix = "STBIR_"+#}++-- | Specify scale explicitly for subpixel correctness+data Scale = Scale+  { x_scale :: Float+  , y_scale :: Float+  , x_offset :: Float+  , y_offset :: Float+  } deriving (Eq, Ord, Show, Read)++-- | Specify image source tile using texture coordinates+data Region = Region+  { region_s0 :: Float -- ^ x of top-left corner from 0 to 1+  , region_t0 :: Float -- ^ y of top-left corner from 0 to 1+  , region_s1 :: Float -- ^ x of bottom-right corner from 0 to 1+  , region_t1 :: Float -- ^ y of bottom-right corner from 0 to 1+  } deriving (Eq, Ord, Show, Read)++data Options = Options+  { flags :: [Flag]+  , edgeModeHorizontal :: Edge+  , edgeModeVertical :: Edge+  , filterHorizontal :: Filter+  , filterVertical :: Filter+  , colorspace :: Colorspace+  , transform :: Either Scale Region+  } deriving (Eq, Ord, Show, Read)++-- | These are the options that correspond to the \"Easy-to-use API\".+defaultOptions :: Options+defaultOptions = Options+  { flags = []+  , edgeModeHorizontal = EDGE_CLAMP+  , edgeModeVertical = EDGE_CLAMP+  , filterHorizontal = FILTER_DEFAULT+  , filterVertical = FILTER_DEFAULT+  , colorspace = COLORSPACE_LINEAR+  , transform = Right $ Region 0 0 1 1+  }++instance Default Options where+  def = defaultOptions++class STBIRComponent a where+  stbirType :: a -> Datatype+instance STBIRComponent Word8  where stbirType _ = TYPE_UINT8+instance STBIRComponent Word16 where stbirType _ = TYPE_UINT16+instance STBIRComponent Word32 where stbirType _ = TYPE_UINT32+instance STBIRComponent Float  where stbirType _ = TYPE_FLOAT++noAlpha :: CInt+noAlpha = {#const STBIR_ALPHA_CHANNEL_NONE #}++-- | All types currently covered by JP's 'Pixel' are supported.+class (Pixel a, STBIRComponent (PixelBaseComponent a)) => STBIRPixel a where+  alphaIndex :: a -> Maybe Int+instance STBIRPixel PixelRGBA16  where alphaIndex _ = Just 3+instance STBIRPixel PixelRGBA8   where alphaIndex _ = Just 3+instance STBIRPixel PixelCMYK16  where alphaIndex _ = Nothing+instance STBIRPixel PixelCMYK8   where alphaIndex _ = Nothing+instance STBIRPixel PixelYCbCr8  where alphaIndex _ = Nothing+instance STBIRPixel PixelRGBF    where alphaIndex _ = Nothing+instance STBIRPixel PixelRGB16   where alphaIndex _ = Nothing+instance STBIRPixel PixelYCbCrK8 where alphaIndex _ = Nothing+instance STBIRPixel PixelRGB8    where alphaIndex _ = Nothing+instance STBIRPixel PixelYA16    where alphaIndex _ = Just 1+instance STBIRPixel PixelYA8     where alphaIndex _ = Just 1+instance STBIRPixel PixelF       where alphaIndex _ = Nothing+instance STBIRPixel Pixel32      where alphaIndex _ = Nothing+instance STBIRPixel Pixel16      where alphaIndex _ = Nothing+instance STBIRPixel Pixel8       where alphaIndex _ = Nothing++{#fun stbir_resize_subpixel+  { id `Ptr ()' -- ^ const void *input_pixels+  , `CInt' -- ^ int input_w+  , `CInt' -- ^ int input_h+  , `CInt' -- ^ int input_stride_in_bytes+  , id `Ptr ()' -- ^ void *output_pixels+  , `CInt' -- ^ int output_w+  , `CInt' -- ^ int output_h+  , `CInt' -- ^ int output_stride_in_bytes+  , `Datatype' -- ^ stbir_datatype datatype+  , `CInt' -- ^ int num_channels+  , `CInt' -- ^ int alpha_channel+  , `CInt' -- ^ int flags+  , `Edge' -- ^ stbir_edge edge_mode_horizontal+  , `Edge' -- ^ stbir_edge edge_mode_vertical+  , cFilter `Filter' -- ^ stbir_filter filter_horizontal+  , cFilter `Filter' -- ^ stbir_filter filter_vertical+  , `Colorspace' -- ^ stbir_colorspace space+  , id `Ptr ()' -- ^ void *alloc_context+  , `CFloat' -- ^ float x_scale+  , `CFloat' -- ^ float y_scale+  , `CFloat' -- ^ float x_offset+  , `CFloat' -- ^ float y_offset+  } -> `CInt'+#}++{#fun stbir_resize_region+  { id `Ptr ()' -- ^ const void *input_pixels+  , `CInt' -- ^ int input_w+  , `CInt' -- ^ int input_h+  , `CInt' -- ^ int input_stride_in_bytes+  , id `Ptr ()' -- ^ void *output_pixels+  , `CInt' -- ^ int output_w+  , `CInt' -- ^ int output_h+  , `CInt' -- ^ int output_stride_in_bytes+  , `Datatype' -- ^ stbir_datatype datatype+  , `CInt' -- ^ int num_channels+  , `CInt' -- ^ int alpha_channel+  , `CInt' -- ^ int flags+  , `Edge' -- ^ stbir_edge edge_mode_horizontal+  , `Edge' -- ^ stbir_edge edge_mode_vertical+  , cFilter `Filter' -- ^ stbir_filter filter_horizontal+  , cFilter `Filter' -- ^ stbir_filter filter_vertical+  , `Colorspace' -- ^ stbir_colorspace space+  , id `Ptr ()' -- ^ void *alloc_context+  , `CFloat' -- ^ float s0+  , `CFloat' -- ^ float t0+  , `CFloat' -- ^ float s1+  , `CFloat' -- ^ float t1+  } -> `CInt'+#}++pixelProperty :: (a -> b) -> Image a -> b+pixelProperty f img = let+  getFakePixel :: Image a -> a+  getFakePixel = undefined+  in f $ getFakePixel img++-- | This function allows access to all \"API levels\" of the C library.+-- Pass 'defaultOptions' to use the easy API, or override whichever options+-- you need.+resize+  :: (STBIRPixel a)+  => Options+  -> Int -- ^ new width+  -> Int -- ^ new height+  -> Image a+  -> Image a+resize opts w' h' img@(Image w h v) = unsafePerformIO $ do+  V.unsafeWith v $ \p -> do+    let comps = pixelProperty componentCount img+    fp <- mallocForeignPtrArray $ w' * h' * comps+    let (cfun, f0, f1, f2, f3) = case transform opts of+          Left  (Scale  a b c d) -> (stbir_resize_subpixel, a, b, c, d)+          Right (Region a b c d) -> (stbir_resize_region  , a, b, c, d)+    res <- withForeignPtr fp $ \p' -> cfun+      (castPtr p)+      (fromIntegral w)+      (fromIntegral h)+      0+      (castPtr p')+      (fromIntegral w')+      (fromIntegral h')+      0+      (pixelProperty (stbirType . pixelOpacity) img)+      (fromIntegral comps)+      (maybe noAlpha fromIntegral $ pixelProperty alphaIndex img)+      (fromIntegral $ foldr (.|.) 0 $ map fromFlag $ flags opts)+      (edgeModeHorizontal opts)+      (edgeModeVertical opts)+      (filterHorizontal opts)+      (filterVertical opts)+      (colorspace opts)+      nullPtr+      (realToFrac f0)+      (realToFrac f1)+      (realToFrac f2)+      (realToFrac f3)+    if res == 0+      then error "Codec.Picture.STBIR.resize returned an error"+      else return $ Image w' h' $ V.unsafeFromForeignPtr0 fp $ w' * h' * comps