Initial import

dsp/scale/magikarp.c

@@ -0,0 +1,129 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ This program is free software; you can redistribute it and/or modify         │
+│ it under the terms of the GNU General Public License as published by         │
+│ the Free Software Foundation; version 2 of the License.                      │
+│                                                                              │
+│ This program is distributed in the hope that it will be useful, but          │
+│ WITHOUT ANY WARRANTY; without even the implied warranty of                   │
+│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU             │
+│ General Public License for more details.                                     │
+│                                                                              │
+│ You should have received a copy of the GNU General Public License            │
+│ along with this program; if not, write to the Free Software                  │
+│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA                │
+│ 02110-1301 USA                                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/core/half.h"
+#include "dsp/core/ks8.h"
+#include "dsp/core/kss8.h"
+#include "dsp/scale/scale.h"
+#include "libc/macros.h"
+#include "libc/nexgen32e/x86feature.h"
+#include "libc/str/str.h"
+#include "libc/x/x.h"
+
+/**
+ * @fileoverview Magikarp resizes graphics in half very fast.
+ * @note H/T John Costella, Facebook, and Photoshop
+ * @note sharpening is good for luma but not chroma
+ * @see Gyarados
+ */
+
+#define CLAMP(X) MIN(255, MAX(0, X))
+#define MAGIKARP(...) \
+  CLAMP(KS8(5, K[0], K[1], K[2], K[3], K[4], K[5], K[6], K[7], __VA_ARGS__))
+
+signed char g_magikarp[8];
+const signed char kMagikarp[8][8] = {
+    {-1, -3, 3, 17, 17, 3, -3, -1}, /* 1331+161 derived w/ one off cas */
+    {-1, -3, 6, 28, 6, -3, -1, 0},  /* due to the convolution theorem? */
+    {0, 0, -11, 53, -11, 0, 0, 0},  /* plus, some random experimenting */
+    {-2, -6, 2, 22, 22, 2, -6, -2}, /* one a line please clang-format? */
+    {-3, -9, 1, 27, 27, 1, -9, -3},
+};
+
+signed char g_magkern[8];
+const signed char kMagkern[8][8] = {
+    {1, 2, 3, 10, 10, 3, 2, 1},
+    {0, 4, 4, 16, 4, 4, 0, 0},
+    {0, 1, 2, 6, 14, 6, 2, 1},
+    {0, 1, 2, 13, 13, 2, 1, 0},
+};
+
+void *Magikarp2xX(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
+  long y;
+  if (yn && xn > 1) {
+    for (y = 0; y < yn; ++y) {
+      /* gcc/clang both struggle with left-to-right matrix ops */
+      cDecimate2xUint8x8(xn, p[y], g_magikarp);
+    }
+  }
+  return p;
+}
+
+void *Magikarp2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
+  long y, x, h;
+  signed char K[8];
+  memcpy(K, g_magikarp, sizeof(K));
+  for (h = HALF(yn), y = 0; y < h; ++y) {
+    for (x = 0; x < xn; ++x) {
+      p[y][x] = /* gcc/clang are good at optimizing top-to-bottom matrix ops */
+          MAGIKARP(p[MAX(00 + 0, y * 2 - 3)][x], p[MAX(00 + 0, y * 2 - 2)][x],
+                   p[MAX(00 + 0, y * 2 - 1)][x], p[MIN(yn - 1, y * 2 + 0)][x],
+                   p[MIN(yn - 1, y * 2 + 1)][x], p[MIN(yn - 1, y * 2 + 2)][x],
+                   p[MIN(yn - 1, y * 2 + 3)][x], p[MIN(yn - 1, y * 2 + 4)][x]);
+    }
+  }
+  return p;
+}
+
+void *Magkern2xX(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
+  long y;
+  if (yn && xn > 1) {
+    for (y = 0; y < yn; ++y) {
+      cDecimate2xUint8x8(xn, p[y], g_magkern);
+    }
+  }
+  return p;
+}
+
+void *Magkern2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
+  long y, x, h;
+  signed char K[8];
+  memcpy(K, g_magkern, sizeof(K));
+  for (h = HALF(yn), y = 0; y < h; ++y) {
+    for (x = 0; x < xn; ++x) {
+      p[y][x] =
+          MAGIKARP(p[MAX(00 + 0, y * 2 - 3)][x], p[MAX(00 + 0, y * 2 - 2)][x],
+                   p[MAX(00 + 0, y * 2 - 1)][x], p[MIN(yn - 1, y * 2 + 0)][x],
+                   p[MIN(yn - 1, y * 2 + 1)][x], p[MIN(yn - 1, y * 2 + 2)][x],
+                   p[MIN(yn - 1, y * 2 + 3)][x], p[MIN(yn - 1, y * 2 + 4)][x]);
+    }
+  }
+  return p;
+}
+
+void *MagikarpY(long dys, long dxs, unsigned char d[restrict dys][dxs],
+                long sys, long sxs, const unsigned char s[sys][sxs], long yn,
+                long xn, const signed char K[8]) {
+  long y, x;
+  for (y = 0; y < yn; ++y) {
+    for (x = 0; x < xn; ++x) {
+      d[y][x] = MAGIKARP(s[MAX(00 + 0, y - 3)][x], s[MAX(00 + 0, y - 2)][x],
+                         s[MAX(00 + 0, y - 1)][x], s[MIN(yn - 1, y + 0)][x],
+                         s[MIN(yn - 1, y + 1)][x], s[MIN(yn - 1, y + 2)][x],
+                         s[MIN(yn - 1, y + 3)][x], s[MIN(yn - 1, y + 4)][x]);
+    }
+  }
+  return d;
+}
+
+static textstartup void g_magikarp_init() {
+  memcpy(g_magkern, kMagkern[0], sizeof(g_magkern));
+  memcpy(g_magikarp, kMagikarp[0], sizeof(g_magikarp));
+}
+const void *const g_magikarp_ctor[] initarray = {g_magikarp_init};