pica 7.0.0 → 9.0.0

package/lib/mm_resize/convolve.c

@@ -4,6 +4,10 @@ inline uint8_t clampTo8(int32_t i) {
   return i < 0 ? 0 : (i > 255 ? 255 : i);
 }
 
+inline uint32_t clampNegative(int32_t i) {
+  return i >= 0 ? i : 0;
+}
+
 
 #define R(x) ((uint8_t)(x))
 #define G(x) ((uint8_t)((x) >> 8))
@@ -13,10 +17,9 @@ inline uint8_t clampTo8(int32_t i) {
 #define RGBA(r, g, b, a) ((r) | ((g) << 8) | ((b) << 16) | ((a) << 24))
 
 
-void convolve(uint32_t *src, uint32_t *dest, uint32_t srcW, uint32_t srcH, uint32_t destW, int16_t *filters)
+void convolveHor(uint32_t *src, uint16_t *dest, uint32_t srcW, uint32_t srcH, uint32_t destW, int16_t *filters)
 {
   int32_t  r, g, b, a;
-  uint32_t rgba;
   uint32_t filterPtr, filterShift, filterSize;
   uint32_t srcPtr, srcY, destX;
   int32_t  filterVal;
@@ -28,53 +31,226 @@ void convolve(uint32_t *src, uint32_t *dest, uint32_t srcW, uint32_t srcH, uint3
     for (destX = 0; destX < destW; destX++) {
       // Get the filter that determines the current output pixel.
       filterShift = filters[filterPtr++];
-      srcPtr      = srcOffset + filterShift;
       filterSize  = filters[filterPtr++];
 
+      srcPtr      = srcOffset + filterShift;
+
       r = g = b = a = 0;
       // Apply the filter to the row to get the destination pixel r, g, b, a
       for (; filterSize > 0; filterSize--) {
         filterVal = filters[filterPtr++];
-        rgba = src[srcPtr++];
+        uint32_t rgba = src[srcPtr++];
 
         r += filterVal * R(rgba);
         g += filterVal * G(rgba);
         b += filterVal * B(rgba);
         a += filterVal * A(rgba);
       };
-      // Bring this value back in range. All of the filter scaling factors
-      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.
+
+      // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
+      //
+      dest[destOffset++] = clampNegative(r >> 7);
+      dest[destOffset++] = clampNegative(g >> 7);
+      dest[destOffset++] = clampNegative(b >> 7);
+      dest[destOffset++] = clampNegative(a >> 7);
+      destOffset += srcH * 4 - 4;
+    };
+    destOffset = (srcY + 1) * 4;
+    srcOffset  = (srcY + 1) * srcW;
+  };
+}
+
+
+void convolveVert(uint16_t *src, uint32_t *dest, uint32_t srcW, uint32_t srcH, uint32_t destW, int16_t *filters)
+{
+  int32_t  r, g, b, a;
+  uint32_t filterPtr, filterShift, filterSize;
+  uint32_t srcPtr, srcY, destX;
+  int32_t  filterVal;
+  uint32_t srcOffset = 0, destOffset = 0;
+  //
+  for (srcY=0; srcY < srcH; srcY++) {
+    filterPtr = 0;
+
+    // Apply precomputed filters to each destination row point
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize  = filters[filterPtr++];
+
+      srcPtr = srcOffset + filterShift*4;
+
+      r = g = b = a = 0;
+
+      // Apply the filter to the row to get the destination pixel r, g, b, a
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++];
+
+        r += filterVal * src[srcPtr++];
+        g += filterVal * src[srcPtr++];
+        b += filterVal * src[srcPtr++];
+        a += filterVal * src[srcPtr++];
+      };
+
+      // Sync with premultiplied version for exact result match
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7;
+
+      // Bring this value back in range + round result.
       //
-      // (!) Add 1/2 of value before clamping to get proper rounding. In other
-      // case brightness loss will be noticeable if you resize image with white
-      // border and place it on white background.
       dest[destOffset] = RGBA(
-        clampTo8((r + (1<<13))>>14  /*FIXED_FRAC_BITS*/),
-        clampTo8((g + (1<<13))>>14  /*FIXED_FRAC_BITS*/),
-        clampTo8((b + (1<<13))>>14  /*FIXED_FRAC_BITS*/),
-        clampTo8((a + (1<<13))>>14  /*FIXED_FRAC_BITS*/));
+        clampTo8((r + (1 << 13)) >> 14),
+        clampTo8((g + (1 << 13)) >> 14),
+        clampTo8((b + (1 << 13)) >> 14),
+        clampTo8((a + (1 << 13)) >> 14)
+      );
       destOffset += srcH;
     };
     destOffset = srcY + 1;
+    srcOffset  = (srcY + 1) * srcW * 4;
+  };
+}
+
+
+void convolveHorWithPre(uint32_t *src, uint16_t *dest, uint32_t srcW, uint32_t srcH, uint32_t destW, int16_t *filters)
+{
+  int32_t  r, g, b, a;
+  uint32_t filterPtr, filterShift, filterSize;
+  uint32_t srcPtr, srcY, destX;
+  int32_t  filterVal;
+  uint32_t srcOffset = 0, destOffset = 0;
+  //
+  for (srcY=0; srcY < srcH; srcY++) {
+    filterPtr = 0;
+    // Apply precomputed filters to each destination row point
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize  = filters[filterPtr++];
+
+      srcPtr      = srcOffset + filterShift;
+
+      r = g = b = a = 0;
+      // Apply the filter to the row to get the destination pixel r, g, b, a
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++];
+        uint32_t rgba = src[srcPtr++];
+
+        uint8_t alpha = A(rgba);
+
+        r += filterVal * alpha * R(rgba);
+        g += filterVal * alpha * G(rgba);
+        b += filterVal * alpha * B(rgba);
+        a += filterVal * alpha;
+      };
+
+      // Premultiply is (* alpha / 255).
+      // Postpone division for better performance
+      r /= 255;
+      g /= 255;
+      b /= 255;
+
+      // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
+      //
+      dest[destOffset++] = clampNegative(r >> 7);
+      dest[destOffset++] = clampNegative(g >> 7);
+      dest[destOffset++] = clampNegative(b >> 7);
+      dest[destOffset++] = clampNegative(a >> 7);
+      destOffset += srcH * 4 - 4;
+    };
+    destOffset = (srcY + 1) * 4;
     srcOffset  = (srcY + 1) * srcW;
   };
 }
 
+
+void convolveVertWithPre(uint16_t *src, uint32_t *dest, uint32_t srcW, uint32_t srcH, uint32_t destW, int16_t *filters)
+{
+  int32_t  r, g, b, a;
+  uint32_t filterPtr, filterShift, filterSize;
+  uint32_t srcPtr, srcY, destX;
+  int32_t  filterVal;
+  uint32_t srcOffset = 0, destOffset = 0;
+  //
+  for (srcY=0; srcY < srcH; srcY++) {
+    filterPtr = 0;
+
+    // Apply precomputed filters to each destination row point
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize  = filters[filterPtr++];
+
+      srcPtr = srcOffset + filterShift*4;
+
+      r = g = b = a = 0;
+
+      // Apply the filter to the row to get the destination pixel r, g, b, a
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++];
+
+        r += filterVal * src[srcPtr++];
+        g += filterVal * src[srcPtr++];
+        b += filterVal * src[srcPtr++];
+        a += filterVal * src[srcPtr++];
+      };
+
+      // Downscale to leave room for un-premultiply
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7;
+
+      // Un-premultiply
+      a = clampTo8((a + (1 << 13)) >> 14);
+      if (a > 0) {
+        r = r * 255 / a;
+        g = g * 255 / a;
+        b = b * 255 / a;
+      }
+
+      // Bring this value back in range + round result.
+      // Shift value = FIXED_FRAC_BITS + 7
+      //
+      dest[destOffset] = RGBA(
+        clampTo8((r + (1 << 13)) >> 14),
+        clampTo8((g + (1 << 13)) >> 14),
+        clampTo8((b + (1 << 13)) >> 14),
+        a
+      );
+      destOffset += srcH;
+    };
+    destOffset = srcY + 1;
+    srcOffset  = (srcY + 1) * srcW * 4;
+  };
+}
+
+
 void convolveHV(uint32_t filtersX_offset,
                 uint32_t filtersY_offset,
                 uint32_t tmp_offset,
                 uint32_t srcW,
                 uint32_t srcH,
                 uint32_t destW,
-                uint32_t destH)
+                uint32_t destH,
+                uint8_t has_alpha)
 {
   uint8_t  *memory  = 0;
 
   uint32_t *src     = (uint32_t *)memory;
+  uint16_t *tmp     = (uint16_t *)(memory + tmp_offset);
   int16_t  *filterX = (int16_t *)(memory + filtersX_offset);
   int16_t  *filterY = (int16_t *)(memory + filtersY_offset);
-  uint32_t *tmp     = (uint32_t *)(memory + tmp_offset);
 
-  convolve(src, tmp, srcW, srcH, destW, filterX);
-  convolve(tmp, src, srcH, destW, destH, filterY);
+  if (has_alpha) {
+    convolveHorWithPre(src, tmp, srcW, srcH, destW, filterX);
+    convolveVertWithPre(tmp, src, srcH, destW, destH, filterY);
+  } else {
+    convolveHor(src, tmp, srcW, srcH, destW, filterX);
+    convolveVert(tmp, src, srcH, destW, destH, filterY);
+  }
 }

package/lib/mm_resize/convolve.js

@@ -8,18 +8,19 @@
 
 
 function clampTo8(i) { return i < 0 ? 0 : (i > 255 ? 255 : i); }
+function clampNegative(i) { return i >= 0 ? i : 0; }
 
-
-// Convolve image in horizontal directions and transpose output. In theory,
-// transpose allow:
+// Convolve image data in horizontal direction. Can be used for:
+//
+// 1. bitmap with premultiplied alpha
+// 2. bitmap without alpha (all values 255)
 //
-// - use the same convolver for both passes (this fails due different
-//   types of input array and temporary buffer)
-// - making vertical pass by horisonltal lines inprove CPU cache use.
+// Notes:
 //
-// But in real life this doesn't work :)
+// - output is transposed
+// - output resolution is ~15 bits per channel(for better precision).
 //
-function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {
+function convolveHor(src, dest, srcW, srcH, destW, filters) {
 
   var r, g, b, a;
   var filterPtr, filterShift, filterSize;
@@ -53,17 +54,69 @@ function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {
         srcPtr = (srcPtr + 4)|0;
       }
 
-      // Bring this value back in range. All of the filter scaling factors
-      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.
+      // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
       //
-      // (!) Add 1/2 of value before clamping to get proper rounding. In other
-      // case brightness loss will be noticeable if you resize image with white
-      // border and place it on white background.
+      dest[destOffset + 3] = clampNegative(a >> 7);
+      dest[destOffset + 2] = clampNegative(b >> 7);
+      dest[destOffset + 1] = clampNegative(g >> 7);
+      dest[destOffset]     = clampNegative(r >> 7);
+      destOffset = (destOffset + srcH * 4)|0;
+    }
+
+    destOffset = ((srcY + 1) * 4)|0;
+    srcOffset  = ((srcY + 1) * srcW * 4)|0;
+  }
+}
+
+// Supplementary method for `convolveHor()`
+//
+function convolveVert(src, dest, srcW, srcH, destW, filters) {
+
+  var r, g, b, a;
+  var filterPtr, filterShift, filterSize;
+  var srcPtr, srcY, destX, filterVal;
+  var srcOffset = 0, destOffset = 0;
+
+  // For each row
+  for (srcY = 0; srcY < srcH; srcY++) {
+    filterPtr  = 0;
+
+    // Apply precomputed filters to each destination row point
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize  = filters[filterPtr++];
+
+      srcPtr = (srcOffset + (filterShift * 4))|0;
+
+      r = g = b = a = 0;
+
+      // Apply the filter to the row to get the destination pixel r, g, b, a
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++];
+
+        // Use reverse order to workaround deopts in old v8 (node v.10)
+        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.
+        a = (a + filterVal * src[srcPtr + 3])|0;
+        b = (b + filterVal * src[srcPtr + 2])|0;
+        g = (g + filterVal * src[srcPtr + 1])|0;
+        r = (r + filterVal * src[srcPtr])|0;
+        srcPtr = (srcPtr + 4)|0;
+      }
+
+      // Sync with premultiplied version for exact result match
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7;
+
+      // Bring this value back in range + round result.
       //
-      dest[destOffset + 3] = clampTo8((a + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset + 2] = clampTo8((b + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset + 1] = clampTo8((g + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset]     = clampTo8((r + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
+      dest[destOffset + 3] = clampTo8((a + (1 << 13)) >> 14);
+      dest[destOffset + 2] = clampTo8((b + (1 << 13)) >> 14);
+      dest[destOffset + 1] = clampTo8((g + (1 << 13)) >> 14);
+      dest[destOffset]     = clampTo8((r + (1 << 13)) >> 14);
       destOffset = (destOffset + srcH * 4)|0;
     }
 
@@ -72,11 +125,73 @@ function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {
   }
 }
 
-// Technically, convolvers are the same. But input array and temporary
-// buffer can be of different type (especially, in old browsers). So,
-// keep code in separate functions to avoid deoptimizations & speed loss.
 
-function convolveVertically(src, dest, srcW, srcH, destW, filters) {
+// Premultiply & convolve image data in horizontal direction. Can be used for:
+//
+// - Any bitmap data, extracted with `.getImageData()` method (with
+//   non-premultiplied alpha)
+//
+// For images without alpha channel this method is slower than `convolveHor()`
+//
+function convolveHorWithPre(src, dest, srcW, srcH, destW, filters) {
+
+  var r, g, b, a, alpha;
+  var filterPtr, filterShift, filterSize;
+  var srcPtr, srcY, destX, filterVal;
+  var srcOffset = 0, destOffset = 0;
+
+  // For each row
+  for (srcY = 0; srcY < srcH; srcY++) {
+    filterPtr  = 0;
+
+    // Apply precomputed filters to each destination row point
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize  = filters[filterPtr++];
+
+      srcPtr = (srcOffset + (filterShift * 4))|0;
+
+      r = g = b = a = 0;
+
+      // Apply the filter to the row to get the destination pixel r, g, b, a
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++];
+
+        // Use reverse order to workaround deopts in old v8 (node v.10)
+        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.
+        alpha = src[srcPtr + 3];
+        a = (a + filterVal * alpha)|0;
+        b = (b + filterVal * src[srcPtr + 2] * alpha)|0;
+        g = (g + filterVal * src[srcPtr + 1] * alpha)|0;
+        r = (r + filterVal * src[srcPtr] * alpha)|0;
+        srcPtr = (srcPtr + 4)|0;
+      }
+
+      // Premultiply is (* alpha / 255).
+      // Postpone division for better performance
+      b = (b / 255)|0;
+      g = (g / 255)|0;
+      r = (r / 255)|0;
+
+      // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
+      //
+      dest[destOffset + 3] = clampNegative(a >> 7);
+      dest[destOffset + 2] = clampNegative(b >> 7);
+      dest[destOffset + 1] = clampNegative(g >> 7);
+      dest[destOffset]     = clampNegative(r >> 7);
+      destOffset = (destOffset + srcH * 4)|0;
+    }
+
+    destOffset = ((srcY + 1) * 4)|0;
+    srcOffset  = ((srcY + 1) * srcW * 4)|0;
+  }
+}
+
+// Supplementary method for `convolveHorWithPre()`
+//
+function convolveVertWithPre(src, dest, srcW, srcH, destW, filters) {
 
   var r, g, b, a;
   var filterPtr, filterShift, filterSize;
@@ -110,17 +225,27 @@ function convolveVertically(src, dest, srcW, srcH, destW, filters) {
         srcPtr = (srcPtr + 4)|0;
       }
 
-      // Bring this value back in range. All of the filter scaling factors
-      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.
-      //
-      // (!) Add 1/2 of value before clamping to get proper rounding. In other
-      // case brightness loss will be noticeable if you resize image with white
-      // border and place it on white background.
+      // Downscale to leave room for un-premultiply
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7;
+
+      // Un-premultiply
+      a = clampTo8((a + (1 << 13)) >> 14);
+      if (a > 0) {
+        r = (r * 255 / a)|0;
+        g = (g * 255 / a)|0;
+        b = (b * 255 / a)|0;
+      }
+
+      // Bring this value back in range + round result.
+      // Shift value = FIXED_FRAC_BITS + 7
       //
-      dest[destOffset + 3] = clampTo8((a + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset + 2] = clampTo8((b + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset + 1] = clampTo8((g + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
-      dest[destOffset]     = clampTo8((r + (1 << 13)) >> 14/*FIXED_FRAC_BITS*/);
+      dest[destOffset + 3] = a;
+      dest[destOffset + 2] = clampTo8((b + (1 << 13)) >> 14);
+      dest[destOffset + 1] = clampTo8((g + (1 << 13)) >> 14);
+      dest[destOffset]     = clampTo8((r + (1 << 13)) >> 14);
       destOffset = (destOffset + srcH * 4)|0;
     }
 
@@ -131,6 +256,8 @@ function convolveVertically(src, dest, srcW, srcH, destW, filters) {
 
 
 module.exports = {
-  convolveHorizontally,
-  convolveVertically
+  convolveHor,
+  convolveVert,
+  convolveHorWithPre,
+  convolveVertWithPre
 };

package/lib/mm_resize/convolve_wasm_base64.js

@@ -2,4 +2,4 @@
 //
 'use strict';
 /* eslint-disable max-len */
-module.exports = 'AGFzbQEAAAAADAZkeWxpbmsAAAAAAAEXA2AAAGAGf39/f39/AGAHf39/f39/fwACDwEDZW52Bm1lbW9yeQIAAAMEAwABAgYGAX8AQQALB1cFEV9fd2FzbV9jYWxsX2N0b3JzAAAIY29udm9sdmUAAQpjb252b2x2ZUhWAAIMX19kc29faGFuZGxlAwAYX193YXNtX2FwcGx5X2RhdGFfcmVsb2NzAAAK7AMDAwABC8YDAQ9/AkAgA0UNACAERQ0AA0AgDCENQQAhE0EAIQcDQCAHQQJqIQYCfyAHQQF0IAVqIgcuAQIiFEUEQEGAwAAhCEGAwAAhCUGAwAAhCkGAwAAhCyAGDAELIBIgBy4BAGohCEEAIQsgFCEHQQAhDiAGIQlBACEPQQAhEANAIAUgCUEBdGouAQAiESAAIAhBAnRqKAIAIgpBGHZsIBBqIRAgCkH/AXEgEWwgC2ohCyAKQRB2Qf8BcSARbCAPaiEPIApBCHZB/wFxIBFsIA5qIQ4gCEEBaiEIIAlBAWohCSAHQQFrIgcNAAsgC0GAQGshCCAOQYBAayEJIA9BgEBrIQogEEGAQGshCyAGIBRqCyEHIAEgDUECdGogCUEOdSIGQf8BIAZB/wFIGyIGQQAgBkEAShtBCHRBgP4DcSAKQQ51IgZB/wEgBkH/AUgbIgZBACAGQQBKG0EQdEGAgPwHcSALQQ51IgZB/wEgBkH/AUgbIgZBACAGQQBKG0EYdHJyIAhBDnUiBkH/ASAGQf8BSBsiBkEAIAZBAEobcjYCACADIA1qIQ0gE0EBaiITIARHDQALIAxBAWoiDCACbCESIAMgDEcNAAsLCx4AQQAgAiADIAQgBSAAEAEgAkEAIAQgBSAGIAEQAQs=';
+module.exports = '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';

package/lib/mm_resize/resize.js

@@ -2,10 +2,18 @@
 
 
 const createFilters        = require('./resize_filter_gen');
-const convolveHorizontally = require('./convolve').convolveHorizontally;
-const convolveVertically   = require('./convolve').convolveVertically;
+const { convolveHor, convolveVert, convolveHorWithPre, convolveVertWithPre } = require('./convolve');
 
 
+function hasAlpha(src, width, height) {
+  let ptr = 3, len = (width * height * 4)|0;
+  while (ptr < len) {
+    if (src[ptr] !== 255) return true;
+    ptr = (ptr + 4)|0;
+  }
+  return false;
+}
+
 function resetAlpha(dst, width, height) {
   let ptr = 3, len = (width * height * 4)|0;
   while (ptr < len) { dst[ptr] = 0xFF; ptr = (ptr + 4)|0; }
@@ -23,26 +31,22 @@ module.exports = function resize(options) {
   const offsetX = options.offsetX || 0;
   const offsetY = options.offsetY || 0;
   const dest  = options.dest || new Uint8Array(destW * destH * 4);
-  const quality = typeof options.quality === 'undefined' ? 3 : options.quality;
-  const alpha = options.alpha || false;
-
-  const filtersX = createFilters(quality, srcW, destW, scaleX, offsetX),
-        filtersY = createFilters(quality, srcH, destH, scaleY, offsetY);
-
-  const tmp  = new Uint8Array(destW * srcH * 4);
-
-  // To use single function we need src & tmp of the same type.
-  // But src can be CanvasPixelArray, and tmp - Uint8Array. So, keep
-  // vertical and horizontal passes separately to avoid deoptimization.
-
-  convolveHorizontally(src, tmp, srcW, srcH, destW, filtersX);
-  convolveVertically(tmp, dest, srcH, destW, destH, filtersY);
-
-  // That's faster than doing checks in convolver.
-  // !!! Note, canvas data is not premultipled. We don't need other
-  // alpha corrections.
 
-  if (!alpha) resetAlpha(dest, destW, destH);
+  const filter = typeof options.filter === 'undefined' ? 'mks2013' : options.filter;
+  const filtersX = createFilters(filter, srcW, destW, scaleX, offsetX),
+        filtersY = createFilters(filter, srcH, destH, scaleY, offsetY);
+
+  const tmp  = new Uint16Array(destW * srcH * 4);
+
+  // Autodetect if alpha channel exists, and use appropriate method
+  if (hasAlpha(src, srcW, srcH)) {
+    convolveHorWithPre(src, tmp, srcW, srcH, destW, filtersX);
+    convolveVertWithPre(tmp, dest, srcH, destW, destH, filtersY);
+  } else {
+    convolveHor(src, tmp, srcW, srcH, destW, filtersX);
+    convolveVert(tmp, dest, srcH, destW, destH, filtersY);
+    resetAlpha(dest, destW, destH);
+  }
 
   return dest;
 };

package/lib/mm_resize/resize_filter_gen.js

@@ -21,15 +21,15 @@ function toFixedPoint(num) {
 }
 
 
-module.exports = function resizeFilterGen(quality, srcSize, destSize, scale, offset) {
+module.exports = function resizeFilterGen(filter, srcSize, destSize, scale, offset) {
 
-  var filterFunction = FILTER_INFO[quality].filter;
+  var filterFunction = FILTER_INFO.filter[filter].fn;
 
   var scaleInverted = 1.0 / scale;
   var scaleClamped  = Math.min(1.0, scale); // For upscale
 
   // Filter window (averaging interval), scaled to src image
-  var srcWindow = FILTER_INFO[quality].win / scaleClamped;
+  var srcWindow = FILTER_INFO.filter[filter].win / scaleClamped;
 
   var destPixel, srcPixel, srcFirst, srcLast, filterElementSize,
       floatFilter, fxpFilter, total, pxl, idx, floatVal, filterTotal, filterVal;

package/lib/mm_resize/resize_filter_info.js

@@ -6,38 +6,65 @@
 'use strict';
 
 
-module.exports = [
-  { // Nearest neibor (Box)
+const filter = {
+  // Nearest neibor
+  box: {
     win: 0.5,
-    filter: function (x) {
-      return (x >= -0.5 && x < 0.5) ? 1.0 : 0.0;
+    fn: function (x) {
+      if (x < 0) x = -x;
+      return (x < 0.5) ? 1.0 : 0.0;
     }
   },
-  { // Hamming
+  // // Hamming
+  hamming: {
     win: 1.0,
-    filter: function (x) {
-      if (x <= -1.0 || x >= 1.0) { return 0.0; }
-      if (x > -1.19209290E-07 && x < 1.19209290E-07) { return 1.0; }
+    fn: function (x) {
+      if (x < 0) x = -x;
+      if (x >= 1.0) { return 0.0; }
+      if (x < 1.19209290E-07) { return 1.0; }
       var xpi = x * Math.PI;
       return ((Math.sin(xpi) / xpi) *  (0.54 + 0.46 * Math.cos(xpi / 1.0)));
     }
   },
-  { // Lanczos, win = 2
+  // Lanczos, win = 2
+  lanczos2: {
     win: 2.0,
-    filter: function (x) {
-      if (x <= -2.0 || x >= 2.0) { return 0.0; }
-      if (x > -1.19209290E-07 && x < 1.19209290E-07) { return 1.0; }
+    fn: function (x) {
+      if (x < 0) x = -x;
+      if (x >= 2.0) { return 0.0; }
+      if (x < 1.19209290E-07) { return 1.0; }
       var xpi = x * Math.PI;
       return (Math.sin(xpi) / xpi) * Math.sin(xpi / 2.0) / (xpi / 2.0);
     }
   },
-  { // Lanczos, win = 3
+  // Lanczos, win = 3
+  lanczos3: {
     win: 3.0,
-    filter: function (x) {
-      if (x <= -3.0 || x >= 3.0) { return 0.0; }
-      if (x > -1.19209290E-07 && x < 1.19209290E-07) { return 1.0; }
+    fn: function (x) {
+      if (x < 0) x = -x;
+      if (x >= 3.0) { return 0.0; }
+      if (x < 1.19209290E-07) { return 1.0; }
       var xpi = x * Math.PI;
       return (Math.sin(xpi) / xpi) * Math.sin(xpi / 3.0) / (xpi / 3.0);
     }
+  },
+  // Magic Kernel Sharp 2013, win = 2.5
+  // http://johncostella.com/magic/
+  mks2013: {
+    win: 2.5,
+    fn: function (x) {
+      if (x < 0) x = -x;
+      if (x >= 2.5) { return 0.0; }
+      if (x >= 1.5) { return -0.125 * (x - 2.5) * (x - 2.5); }
+      if (x >= 0.5) { return 0.25 * (4 * x * x - 11 * x + 7); }
+      return 1.0625 - 1.75 * x * x;
+    }
   }
-];
+};
+
+module.exports = {
+  filter: filter,
+  // Legacy mapping
+  f2q: { box: 0, hamming: 1, lanczos2: 2, lanczos3: 3 },
+  q2f: [ 'box', 'hamming', 'lanczos2', 'lanczos3' ]
+};