lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/demosaic/ahd_demosaic.cpp

@@ -0,0 +1,355 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
+ *
+ LibRaw uses code from dcraw.c -- Dave Coffin's raw photo decoder,
+ dcraw.c is copyright 1997-2018 by Dave Coffin, dcoffin a cybercom o net.
+ LibRaw do not use RESTRICTED code from dcraw.c
+
+ LibRaw is free software; you can redistribute it and/or modify
+ it under the terms of the one of two licenses as you choose:
+
+1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
+   (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
+
+2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
+   (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
+
+ */
+
+#include "../../internal/dcraw_defs.h"
+
+/*
+   Adaptive Homogeneity-Directed interpolation is based on
+   the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
+ */
+
+void LibRaw::cielab(ushort rgb[3], short lab[3])
+{
+  int c, i, j, k;
+  float r, xyz[3];
+#ifdef LIBRAW_NOTHREADS
+  static float cbrt[0x10000], xyz_cam[3][4];
+#else
+#define cbrt tls->ahd_data.cbrt
+#define xyz_cam tls->ahd_data.xyz_cam
+#endif
+
+  if (!rgb)
+  {
+#ifndef LIBRAW_NOTHREADS
+    if (cbrt[0] < -1.0f)
+#endif
+      for (i = 0; i < 0x10000; i++)
+      {
+        r = i / 65535.0;
+        cbrt[i] =
+            r > 0.008856 ? pow(r, 1.f / 3.0f) : 7.787f * r + 16.f / 116.0f;
+      }
+    for (i = 0; i < 3; i++)
+      for (j = 0; j < colors; j++)
+        for (xyz_cam[i][j] = k = 0; k < 3; k++)
+          xyz_cam[i][j] += LibRaw_constants::xyz_rgb[i][k] * rgb_cam[k][j] /
+                           LibRaw_constants::d65_white[i];
+    return;
+  }
+  xyz[0] = xyz[1] = xyz[2] = 0.5;
+  FORCC
+  {
+    xyz[0] += xyz_cam[0][c] * rgb[c];
+    xyz[1] += xyz_cam[1][c] * rgb[c];
+    xyz[2] += xyz_cam[2][c] * rgb[c];
+  }
+  xyz[0] = cbrt[CLIP((int)xyz[0])];
+  xyz[1] = cbrt[CLIP((int)xyz[1])];
+  xyz[2] = cbrt[CLIP((int)xyz[2])];
+  lab[0] = 64 * (116 * xyz[1] - 16);
+  lab[1] = 64 * 500 * (xyz[0] - xyz[1]);
+  lab[2] = 64 * 200 * (xyz[1] - xyz[2]);
+#ifndef LIBRAW_NOTHREADS
+#undef cbrt
+#undef xyz_cam
+#endif
+}
+
+void LibRaw::ahd_interpolate_green_h_and_v(
+    int top, int left, ushort (*out_rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3])
+{
+  int row, col;
+  int c, val;
+  ushort(*pix)[4];
+  const int rowlimit = MIN(top + LIBRAW_AHD_TILE, height - 2);
+  const int collimit = MIN(left + LIBRAW_AHD_TILE, width - 2);
+
+  for (row = top; row < rowlimit; row++)
+  {
+    col = left + (FC(row, left) & 1);
+    for (c = FC(row, col); col < collimit; col += 2)
+    {
+      pix = image + row * width + col;
+      val =
+          ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2 - pix[-2][c] - pix[2][c]) >>
+          2;
+      out_rgb[0][row - top][col - left][1] = ULIM(val, pix[-1][1], pix[1][1]);
+      val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2 -
+             pix[-2 * width][c] - pix[2 * width][c]) >>
+            2;
+      out_rgb[1][row - top][col - left][1] =
+          ULIM(val, pix[-width][1], pix[width][1]);
+    }
+  }
+}
+void LibRaw::ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(
+    int top, int left, ushort (*inout_rgb)[LIBRAW_AHD_TILE][3],
+    short (*out_lab)[LIBRAW_AHD_TILE][3])
+{
+  unsigned row, col;
+  int c, val;
+  ushort(*pix)[4];
+  ushort(*rix)[3];
+  short(*lix)[3];
+  const unsigned num_pix_per_row = 4 * width;
+  const unsigned rowlimit = MIN(top + LIBRAW_AHD_TILE - 1, height - 3);
+  const unsigned collimit = MIN(left + LIBRAW_AHD_TILE - 1, width - 3);
+  ushort *pix_above;
+  ushort *pix_below;
+  int t1, t2;
+
+  for (row = top + 1; row < rowlimit; row++)
+  {
+    pix = image + row * width + left;
+    rix = &inout_rgb[row - top][0];
+    lix = &out_lab[row - top][0];
+
+    for (col = left + 1; col < collimit; col++)
+    {
+      pix++;
+      pix_above = &pix[0][0] - num_pix_per_row;
+      pix_below = &pix[0][0] + num_pix_per_row;
+      rix++;
+      lix++;
+
+      c = 2 - FC(row, col);
+
+      if (c == 1)
+      {
+        c = FC(row + 1, col);
+        t1 = 2 - c;
+        val = pix[0][1] +
+              ((pix[-1][t1] + pix[1][t1] - rix[-1][1] - rix[1][1]) >> 1);
+        rix[0][t1] = CLIP(val);
+        val =
+            pix[0][1] + ((pix_above[c] + pix_below[c] -
+                          rix[-LIBRAW_AHD_TILE][1] - rix[LIBRAW_AHD_TILE][1]) >>
+                         1);
+      }
+      else
+      {
+        t1 = -4 + c; /* -4+c: pixel of color c to the left */
+        t2 = 4 + c;  /* 4+c: pixel of color c to the right */
+        val = rix[0][1] +
+              ((pix_above[t1] + pix_above[t2] + pix_below[t1] + pix_below[t2] -
+                rix[-LIBRAW_AHD_TILE - 1][1] - rix[-LIBRAW_AHD_TILE + 1][1] -
+                rix[+LIBRAW_AHD_TILE - 1][1] - rix[+LIBRAW_AHD_TILE + 1][1] +
+                1) >>
+               2);
+      }
+      rix[0][c] = CLIP(val);
+      c = FC(row, col);
+      rix[0][c] = pix[0][c];
+      cielab(rix[0], lix[0]);
+    }
+  }
+}
+void LibRaw::ahd_interpolate_r_and_b_and_convert_to_cielab(
+    int top, int left, ushort (*inout_rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3],
+    short (*out_lab)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3])
+{
+  int direction;
+  for (direction = 0; direction < 2; direction++)
+  {
+    ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(
+        top, left, inout_rgb[direction], out_lab[direction]);
+  }
+}
+
+void LibRaw::ahd_interpolate_build_homogeneity_map(
+    int top, int left, short (*lab)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3],
+    char (*out_homogeneity_map)[LIBRAW_AHD_TILE][2])
+{
+  int row, col;
+  int tr;
+  int direction;
+  int i;
+  short(*lix)[3];
+  short(*lixs[2])[3];
+  short *adjacent_lix;
+  unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
+  static const int dir[4] = {-1, 1, -LIBRAW_AHD_TILE, LIBRAW_AHD_TILE};
+  const int rowlimit = MIN(top + LIBRAW_AHD_TILE - 2, height - 4);
+  const int collimit = MIN(left + LIBRAW_AHD_TILE - 2, width - 4);
+  int homogeneity;
+  char(*homogeneity_map_p)[2];
+
+  memset(out_homogeneity_map, 0, 2 * LIBRAW_AHD_TILE * LIBRAW_AHD_TILE);
+
+  for (row = top + 2; row < rowlimit; row++)
+  {
+    tr = row - top;
+    homogeneity_map_p = &out_homogeneity_map[tr][1];
+    for (direction = 0; direction < 2; direction++)
+    {
+      lixs[direction] = &lab[direction][tr][1];
+    }
+
+    for (col = left + 2; col < collimit; col++)
+    {
+      homogeneity_map_p++;
+
+      for (direction = 0; direction < 2; direction++)
+      {
+        lix = ++lixs[direction];
+        for (i = 0; i < 4; i++)
+        {
+          adjacent_lix = lix[dir[i]];
+          ldiff[direction][i] = ABS(lix[0][0] - adjacent_lix[0]);
+          abdiff[direction][i] = SQR(lix[0][1] - adjacent_lix[1]) +
+                                 SQR(lix[0][2] - adjacent_lix[2]);
+        }
+      }
+      leps = MIN(MAX(ldiff[0][0], ldiff[0][1]), MAX(ldiff[1][2], ldiff[1][3]));
+      abeps =
+          MIN(MAX(abdiff[0][0], abdiff[0][1]), MAX(abdiff[1][2], abdiff[1][3]));
+      for (direction = 0; direction < 2; direction++)
+      {
+        homogeneity = 0;
+        for (i = 0; i < 4; i++)
+        {
+          if (ldiff[direction][i] <= leps && abdiff[direction][i] <= abeps)
+          {
+            homogeneity++;
+          }
+        }
+        homogeneity_map_p[0][direction] = homogeneity;
+      }
+    }
+  }
+}
+void LibRaw::ahd_interpolate_combine_homogeneous_pixels(
+    int top, int left, ushort (*rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3],
+    char (*homogeneity_map)[LIBRAW_AHD_TILE][2])
+{
+  int row, col;
+  int tr, tc;
+  int i, j;
+  int direction;
+  int hm[2];
+  int c;
+  const int rowlimit = MIN(top + LIBRAW_AHD_TILE - 3, height - 5);
+  const int collimit = MIN(left + LIBRAW_AHD_TILE - 3, width - 5);
+
+  ushort(*pix)[4];
+  ushort(*rix[2])[3];
+
+  for (row = top + 3; row < rowlimit; row++)
+  {
+    tr = row - top;
+    pix = &image[row * width + left + 2];
+    for (direction = 0; direction < 2; direction++)
+    {
+      rix[direction] = &rgb[direction][tr][2];
+    }
+
+    for (col = left + 3; col < collimit; col++)
+    {
+      tc = col - left;
+      pix++;
+      for (direction = 0; direction < 2; direction++)
+      {
+        rix[direction]++;
+      }
+
+      for (direction = 0; direction < 2; direction++)
+      {
+        hm[direction] = 0;
+        for (i = tr - 1; i <= tr + 1; i++)
+        {
+          for (j = tc - 1; j <= tc + 1; j++)
+          {
+            hm[direction] += homogeneity_map[i][j][direction];
+          }
+        }
+      }
+      if (hm[0] != hm[1])
+      {
+        memcpy(pix[0], rix[hm[1] > hm[0]][0], 3 * sizeof(ushort));
+      }
+      else
+      {
+        FORC3 { pix[0][c] = (rix[0][0][c] + rix[1][0][c]) >> 1; }
+      }
+    }
+  }
+}
+void LibRaw::ahd_interpolate()
+{
+    int terminate_flag = 0;
+    cielab(0, 0);
+    border_interpolate(5);
+
+#ifdef LIBRAW_USE_OPENMP
+    int buffer_count = omp_get_max_threads();
+#else
+    int buffer_count = 1;
+#endif
+
+    size_t buffer_size = 26 * LIBRAW_AHD_TILE * LIBRAW_AHD_TILE; /* 1664 kB */
+    char** buffers = malloc_omp_buffers(buffer_count, buffer_size);
+
+#ifdef LIBRAW_USE_OPENMP
+#pragma omp parallel for schedule(dynamic) default(none) shared(terminate_flag) firstprivate(buffers)
+#endif
+    for (int top = 2; top < height - 5; top += LIBRAW_AHD_TILE - 6)
+    {
+#ifdef LIBRAW_USE_OPENMP
+        if (0 == omp_get_thread_num())
+#endif
+            if (callbacks.progress_cb)
+            {
+                int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,
+                    LIBRAW_PROGRESS_INTERPOLATE,
+                    top - 2, height - 7);
+                if (rr)
+                    terminate_flag = 1;
+            }
+
+#if defined(LIBRAW_USE_OPENMP)
+        char* buffer = buffers[omp_get_thread_num()];
+#else
+        char* buffer = buffers[0];
+#endif
+
+        ushort(*rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3];
+        short(*lab)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3];
+        char(*homo)[LIBRAW_AHD_TILE][2];
+
+        rgb = (ushort(*)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3])buffer;
+        lab = (short(*)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3])(
+            buffer + 12 * LIBRAW_AHD_TILE * LIBRAW_AHD_TILE);
+        homo = (char(*)[LIBRAW_AHD_TILE][2])(buffer + 24 * LIBRAW_AHD_TILE *
+            LIBRAW_AHD_TILE);
+
+        for (int left = 2; !terminate_flag && (left < width - 5);
+            left += LIBRAW_AHD_TILE - 6)
+        {
+            ahd_interpolate_green_h_and_v(top, left, rgb);
+            ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab);
+            ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
+            ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
+        }
+    }
+
+    free_omp_buffers(buffers, buffer_count);
+
+    if (terminate_flag)
+        throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
+}