lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/postprocessing/aspect_ratio.cpp

@@ -0,0 +1,113 @@
+/* -*- 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"
+
+void LibRaw::fuji_rotate()
+{
+  int i, row, col;
+  double step;
+  float r, c, fr, fc;
+  unsigned ur, uc;
+  ushort wide, high, (*img)[4], (*pix)[4];
+
+  if (!fuji_width)
+    return;
+  fuji_width = (fuji_width - 1 + shrink) >> shrink;
+  step = sqrt(0.5);
+  wide = fuji_width / step;
+  high = (height - fuji_width) / step;
+
+  // All real fuji/rotated images are small, so check against max_raw_memory_mb here is safe
+  if (INT64(wide) * INT64(high) * INT64(sizeof(*img))    >
+      INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024))
+    throw LIBRAW_EXCEPTION_TOOBIG;
+
+  img = (ushort(*)[4])calloc(high, wide * sizeof *img);
+
+  RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE, 0, 2);
+
+  for (row = 0; row < high; row++)
+    for (col = 0; col < wide; col++)
+    {
+      ur = r = fuji_width + (row - col) * step;
+      uc = c = (row + col) * step;
+      if (ur > (unsigned)height - 2 || uc > (unsigned)width - 2)
+        continue;
+      fr = r - ur;
+      fc = c - uc;
+      pix = image + ur * width + uc;
+      for (i = 0; i < colors; i++)
+        img[row * wide + col][i] =
+            (pix[0][i] * (1 - fc) + pix[1][i] * fc) * (1 - fr) +
+            (pix[width][i] * (1 - fc) + pix[width + 1][i] * fc) * fr;
+    }
+
+  free(image);
+  width = wide;
+  height = high;
+  image = img;
+  fuji_width = 0;
+  RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE, 1, 2);
+}
+
+void LibRaw::stretch()
+{
+  ushort newdim, (*img)[4], *pix0, *pix1;
+  int row, col, c;
+  double rc, frac;
+
+  if (pixel_aspect == 1)
+    return;
+  RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH, 0, 2);
+  if (pixel_aspect < 1)
+  {
+    newdim = height / pixel_aspect + 0.5;
+    img = (ushort(*)[4])calloc(width, newdim * sizeof *img);
+    for (rc = row = 0; row < newdim; row++, rc += pixel_aspect)
+    {
+      frac = rc - (c = rc);
+      pix0 = pix1 = image[c * width];
+      if (c + 1 < height)
+        pix1 += width * 4;
+      for (col = 0; col < width; col++, pix0 += 4, pix1 += 4)
+        FORCC img[row * width + col][c] =
+            pix0[c] * (1 - frac) + pix1[c] * frac + 0.5;
+    }
+    height = newdim;
+  }
+  else
+  {
+    newdim = width * pixel_aspect + 0.5;
+    img = (ushort(*)[4])calloc(height, newdim * sizeof *img);
+    for (rc = col = 0; col < newdim; col++, rc += 1 / pixel_aspect)
+    {
+      frac = rc - (c = rc);
+      pix0 = pix1 = image[c];
+      if (c + 1 < width)
+        pix1 += 4;
+      for (row = 0; row < height; row++, pix0 += width * 4, pix1 += width * 4)
+        FORCC img[row * newdim + col][c] =
+            pix0[c] * (1 - frac) + pix1[c] * frac + 0.5;
+    }
+    width = newdim;
+  }
+  free(image);
+  image = img;
+  RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH, 1, 2);
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/postprocessing/dcraw_process.cpp

@@ -0,0 +1,259 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
+ *
+ 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/libraw_cxx_defs.h"
+
+int LibRaw::dcraw_process(void)
+{
+  int quality, i;
+
+  int iterations = -1, dcb_enhance = 1, noiserd = 0;
+  float preser = 0;
+  float expos = 1.0;
+
+  CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
+  //    CHECK_ORDER_HIGH(LIBRAW_PROGRESS_PRE_INTERPOLATE);
+
+  try
+  {
+
+    int no_crop = 1;
+
+    if (~O.cropbox[2] && ~O.cropbox[3])
+      no_crop = 0;
+
+    libraw_decoder_info_t di;
+    get_decoder_info(&di);
+
+    bool is_bayer = (imgdata.idata.filters || P1.colors == 1);
+    int subtract_inline =
+        !O.bad_pixels && !O.dark_frame && is_bayer && !IO.zero_is_bad;
+
+    int rc = raw2image_ex(subtract_inline); // allocate imgdata.image and copy data!
+	if (rc != LIBRAW_SUCCESS)
+		return rc;
+
+    // Adjust sizes
+
+    int save_4color = O.four_color_rgb;
+
+    if (IO.zero_is_bad)
+    {
+      remove_zeroes();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_REMOVE_ZEROES);
+    }
+
+    if (O.bad_pixels && no_crop)
+    {
+      bad_pixels(O.bad_pixels);
+      SET_PROC_FLAG(LIBRAW_PROGRESS_BAD_PIXELS);
+    }
+
+    if (O.dark_frame && no_crop)
+    {
+      subtract(O.dark_frame);
+      SET_PROC_FLAG(LIBRAW_PROGRESS_DARK_FRAME);
+    }
+    /* pre subtract black callback: check for it above to disable subtract
+     * inline */
+
+    if (callbacks.pre_subtractblack_cb)
+      (callbacks.pre_subtractblack_cb)(this);
+
+    quality = 2 + !IO.fuji_width;
+
+    if (O.user_qual >= 0)
+      quality = O.user_qual;
+
+    if (!subtract_inline || !C.data_maximum)
+    {
+      adjust_bl();
+      subtract_black_internal();
+    }
+
+    if (!(di.decoder_flags & LIBRAW_DECODER_FIXEDMAXC))
+      adjust_maximum();
+
+    if (O.user_sat > 0)
+      C.maximum = O.user_sat;
+
+    if (P1.is_foveon)
+    {
+      if (load_raw == &LibRaw::x3f_load_raw)
+      {
+        // Filter out zeroes
+        for (int q = 0; q < S.height * S.width; q++)
+        {
+          for (int c = 0; c < 4; c++)
+            if ((short)imgdata.image[q][c] < 0)
+              imgdata.image[q][c] = 0;
+        }
+      }
+      SET_PROC_FLAG(LIBRAW_PROGRESS_FOVEON_INTERPOLATE);
+    }
+
+    if (O.green_matching && !O.half_size)
+    {
+      green_matching();
+    }
+
+    if (callbacks.pre_scalecolors_cb)
+      (callbacks.pre_scalecolors_cb)(this);
+
+    if (!O.no_auto_scale)
+    {
+      scale_colors();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_SCALE_COLORS);
+    }
+
+    if (callbacks.pre_preinterpolate_cb)
+      (callbacks.pre_preinterpolate_cb)(this);
+
+    pre_interpolate();
+
+    SET_PROC_FLAG(LIBRAW_PROGRESS_PRE_INTERPOLATE);
+
+    if (O.dcb_iterations >= 0)
+      iterations = O.dcb_iterations;
+    if (O.dcb_enhance_fl >= 0)
+      dcb_enhance = O.dcb_enhance_fl;
+    if (O.fbdd_noiserd >= 0)
+      noiserd = O.fbdd_noiserd;
+
+    /* pre-exposure correction callback */
+
+    if (O.exp_correc > 0)
+    {
+      expos = O.exp_shift;
+      preser = O.exp_preser;
+      exp_bef(expos, preser);
+    }
+
+    if (callbacks.pre_interpolate_cb)
+      (callbacks.pre_interpolate_cb)(this);
+
+    /* post-exposure correction fallback */
+    if (P1.filters && !O.no_interpolation)
+    {
+      if (noiserd > 0 && P1.colors == 3 && P1.filters > 1000)
+        fbdd(noiserd);
+
+      if (P1.filters > 1000 && callbacks.interpolate_bayer_cb)
+        (callbacks.interpolate_bayer_cb)(this);
+      else if (P1.filters == 9 && callbacks.interpolate_xtrans_cb)
+        (callbacks.interpolate_xtrans_cb)(this);
+      else if (quality == 0)
+        lin_interpolate();
+      else if (quality == 1 || P1.colors > 3)
+        vng_interpolate();
+      else if (quality == 2 && P1.filters > 1000)
+        ppg_interpolate();
+      else if (P1.filters == LIBRAW_XTRANS)
+      {
+        // Fuji X-Trans
+        xtrans_interpolate(quality > 2 ? 3 : 1);
+      }
+      else if (quality == 3)
+        ahd_interpolate(); // really don't need it here due to fallback op
+      else if (quality == 4)
+        dcb(iterations, dcb_enhance);
+
+      else if (quality == 11)
+        dht_interpolate();
+      else if (quality == 12)
+        aahd_interpolate();
+      // fallback to AHD
+      else
+      {
+        ahd_interpolate();
+        imgdata.process_warnings |= LIBRAW_WARN_FALLBACK_TO_AHD;
+      }
+
+      SET_PROC_FLAG(LIBRAW_PROGRESS_INTERPOLATE);
+    }
+    if (IO.mix_green)
+    {
+      for (P1.colors = 3, i = 0; i < S.height * S.width; i++)
+        imgdata.image[i][1] = (imgdata.image[i][1] + imgdata.image[i][3]) >> 1;
+      SET_PROC_FLAG(LIBRAW_PROGRESS_MIX_GREEN);
+    }
+
+    if (callbacks.post_interpolate_cb)
+      (callbacks.post_interpolate_cb)(this);
+    else if (!P1.is_foveon && P1.colors == 3 && O.med_passes > 0)
+    {
+      median_filter();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_MEDIAN_FILTER);
+    }
+
+    if (O.highlight == 2)
+    {
+      blend_highlights();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
+    }
+
+    if (O.highlight > 2)
+    {
+      recover_highlights();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
+    }
+
+    if (O.use_fuji_rotate)
+    {
+      fuji_rotate();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
+    }
+
+    if (!libraw_internal_data.output_data.histogram)
+    {
+      libraw_internal_data.output_data.histogram =
+          (int(*)[LIBRAW_HISTOGRAM_SIZE])calloc(1,
+              sizeof(*libraw_internal_data.output_data.histogram) * 4);
+    }
+#ifndef NO_LCMS
+    if (O.camera_profile)
+    {
+      apply_profile(O.camera_profile, O.output_profile);
+      SET_PROC_FLAG(LIBRAW_PROGRESS_APPLY_PROFILE);
+    }
+#endif
+
+    if (callbacks.pre_converttorgb_cb)
+      (callbacks.pre_converttorgb_cb)(this);
+
+    convert_to_rgb();
+    SET_PROC_FLAG(LIBRAW_PROGRESS_CONVERT_RGB);
+
+    if (callbacks.post_converttorgb_cb)
+      (callbacks.post_converttorgb_cb)(this);
+
+    if (O.use_fuji_rotate)
+    {
+      stretch();
+      SET_PROC_FLAG(LIBRAW_PROGRESS_STRETCH);
+    }
+    O.four_color_rgb = save_4color; // also, restore
+
+    return 0;
+  }
+  catch (const std::bad_alloc&)
+  {
+      recycle();
+      return LIBRAW_UNSUFFICIENT_MEMORY;
+  }
+  catch (const LibRaw_exceptions& err)
+  {
+    EXCEPTION_HANDLER(err);
+  }
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/postprocessing/mem_image.cpp

@@ -0,0 +1,292 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
+ *
+ 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/libraw_cxx_defs.h"
+
+libraw_processed_image_t *LibRaw::dcraw_make_mem_thumb(int *errcode)
+{
+  if (!T.thumb)
+  {
+    if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 &&
+                         load_raw == &LibRaw::broadcom_load_raw) // RPi
+    )
+    {
+      if (errcode)
+        *errcode = LIBRAW_NO_THUMBNAIL;
+    }
+    else
+    {
+      if (errcode)
+        *errcode = LIBRAW_OUT_OF_ORDER_CALL;
+    }
+    return NULL;
+  }
+
+  if (T.tlength < 64u)
+  {
+      if (errcode)
+          *errcode = EINVAL;
+      return NULL;
+  }
+
+  if (INT64(T.tlength) > 1024ULL * 1024ULL * LIBRAW_MAX_THUMBNAIL_MB)
+  {
+      if (errcode)
+          *errcode = LIBRAW_TOO_BIG;
+      return NULL;
+  }
+
+  if (T.tformat == LIBRAW_THUMBNAIL_BITMAP)
+  {
+    libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(
+        sizeof(libraw_processed_image_t) + T.tlength);
+
+    if (!ret)
+    {
+      if (errcode)
+        *errcode = ENOMEM;
+      return NULL;
+    }
+
+    memset(ret, 0, sizeof(libraw_processed_image_t));
+    ret->type = LIBRAW_IMAGE_BITMAP;
+    ret->height = T.theight;
+    ret->width = T.twidth;
+    if (T.tcolors > 0 && T.tcolors < 4)
+        ret->colors = T.tcolors;
+    else
+        ret->colors = 3; // defaults
+    ret->bits = 8;
+    ret->data_size = T.tlength;
+    memmove(ret->data, T.thumb, T.tlength);
+    if (errcode)
+      *errcode = 0;
+    return ret;
+  }
+  else if (T.tformat == LIBRAW_THUMBNAIL_JPEG)
+  {
+    ushort exif[5];
+    int mk_exif = 0;
+    if (strcmp(T.thumb + 6, "Exif"))
+      mk_exif = 1;
+
+    int dsize = T.tlength + mk_exif * (sizeof(exif) + sizeof(tiff_hdr));
+
+    libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(
+        sizeof(libraw_processed_image_t) + dsize);
+
+    if (!ret)
+    {
+      if (errcode)
+        *errcode = ENOMEM;
+      return NULL;
+    }
+
+    memset(ret, 0, sizeof(libraw_processed_image_t));
+
+    ret->type = LIBRAW_IMAGE_JPEG;
+    ret->data_size = dsize;
+
+    ret->data[0] = 0xff;
+    ret->data[1] = 0xd8;
+    if (mk_exif)
+    {
+      struct tiff_hdr th;
+      memcpy(exif, "\xff\xe1  Exif\0\0", 10);
+      exif[1] = htons(8 + sizeof th);
+      memmove(ret->data + 2, exif, sizeof(exif));
+      tiff_head(&th, 0);
+      memmove(ret->data + (2 + sizeof(exif)), &th, sizeof(th));
+      memmove(ret->data + (2 + sizeof(exif) + sizeof(th)), T.thumb + 2,
+              T.tlength - 2);
+    }
+    else
+    {
+      memmove(ret->data + 2, T.thumb + 2, T.tlength - 2);
+    }
+    if (errcode)
+      *errcode = 0;
+    return ret;
+  }
+  else
+  {
+    if (errcode)
+      *errcode = LIBRAW_UNSUPPORTED_THUMBNAIL;
+    return NULL;
+  }
+}
+
+// jlb
+// macros for copying pixels to either BGR or RGB formats
+#define FORBGR for (c = P1.colors - 1; c >= 0; c--)
+#define FORRGB for (c = 0; c < P1.colors; c++)
+
+void LibRaw::get_mem_image_format(int *width, int *height, int *colors,
+                                  int *bps) const
+
+{
+  *width = S.width;
+  *height = S.height;
+  if (imgdata.progress_flags < LIBRAW_PROGRESS_FUJI_ROTATE)
+  {
+    if (O.use_fuji_rotate)
+    {
+      if (IO.fuji_width)
+      {
+        int fuji_width = (IO.fuji_width - 1 + IO.shrink) >> IO.shrink;
+        *width = (ushort)(fuji_width / sqrt(0.5));
+        *height = (ushort)((*height - fuji_width) / sqrt(0.5));
+      }
+      else
+      {
+        if (S.pixel_aspect < 0.995)
+          *height = (ushort)(*height / S.pixel_aspect + 0.5);
+        if (S.pixel_aspect > 1.005)
+          *width = (ushort)(*width * S.pixel_aspect + 0.5);
+      }
+    }
+  }
+  if (S.flip & 4)
+  {
+    std::swap(*width, *height);
+  }
+  *colors = P1.colors;
+  *bps = O.output_bps;
+}
+
+int LibRaw::copy_mem_image(void *scan0, int stride, int bgr)
+
+{
+  // the image memory pointed to by scan0 is assumed to be in the format
+  // returned by get_mem_image_format
+  if ((imgdata.progress_flags & LIBRAW_PROGRESS_THUMB_MASK) <
+      LIBRAW_PROGRESS_PRE_INTERPOLATE)
+    return LIBRAW_OUT_OF_ORDER_CALL;
+
+  if (libraw_internal_data.output_data.histogram)
+  {
+    int perc, val, total, t_white = 0x2000, c;
+    perc = S.width * S.height * O.auto_bright_thr;
+    if (IO.fuji_width)
+      perc /= 2;
+    if (!((O.highlight & ~2) || O.no_auto_bright))
+      for (t_white = c = 0; c < P1.colors; c++)
+      {
+        for (val = 0x2000, total = 0; --val > 32;)
+          if ((total += libraw_internal_data.output_data.histogram[c][val]) >
+              perc)
+            break;
+        if (t_white < val)
+          t_white = val;
+      }
+    gamma_curve(O.gamm[0], O.gamm[1], 2, (t_white << 3) / O.bright);
+  }
+
+  int s_iheight = S.iheight;
+  int s_iwidth = S.iwidth;
+  int s_width = S.width;
+  int s_hwight = S.height;
+
+  S.iheight = S.height;
+  S.iwidth = S.width;
+
+  if (S.flip & 4)
+    SWAP(S.height, S.width);
+  uchar *ppm;
+  ushort *ppm2;
+  int c, row, col, soff, rstep, cstep;
+
+  soff = flip_index(0, 0);
+  cstep = flip_index(0, 1) - soff;
+  rstep = flip_index(1, 0) - flip_index(0, S.width);
+
+  for (row = 0; row < S.height; row++, soff += rstep)
+  {
+    uchar *bufp = ((uchar *)scan0) + row * stride;
+    ppm2 = (ushort *)(ppm = bufp);
+    // keep trivial decisions in the outer loop for speed
+    if (bgr)
+    {
+      if (O.output_bps == 8)
+      {
+        for (col = 0; col < S.width; col++, soff += cstep)
+          FORBGR *ppm++ = imgdata.color.curve[imgdata.image[soff][c]] >> 8;
+      }
+      else
+      {
+        for (col = 0; col < S.width; col++, soff += cstep)
+          FORBGR *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
+      }
+    }
+    else
+    {
+      if (O.output_bps == 8)
+      {
+        for (col = 0; col < S.width; col++, soff += cstep)
+          FORRGB *ppm++ = imgdata.color.curve[imgdata.image[soff][c]] >> 8;
+      }
+      else
+      {
+        for (col = 0; col < S.width; col++, soff += cstep)
+          FORRGB *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
+      }
+    }
+
+    //            bufp += stride;           // go to the next line
+  }
+
+  S.iheight = s_iheight;
+  S.iwidth = s_iwidth;
+  S.width = s_width;
+  S.height = s_hwight;
+
+  return 0;
+}
+#undef FORBGR
+#undef FORRGB
+
+libraw_processed_image_t *LibRaw::dcraw_make_mem_image(int *errcode)
+
+{
+  int width, height, colors, bps;
+  get_mem_image_format(&width, &height, &colors, &bps);
+  int stride = width * (bps / 8) * colors;
+  unsigned ds = height * stride;
+  libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(
+      sizeof(libraw_processed_image_t) + ds);
+  if (!ret)
+  {
+    if (errcode)
+      *errcode = ENOMEM;
+    return NULL;
+  }
+  memset(ret, 0, sizeof(libraw_processed_image_t));
+
+  // metadata init
+  ret->type = LIBRAW_IMAGE_BITMAP;
+  ret->height = height;
+  ret->width = width;
+  ret->colors = colors;
+  ret->bits = bps;
+  ret->data_size = ds;
+  copy_mem_image(ret->data, stride, 0);
+
+  return ret;
+}
+
+void LibRaw::dcraw_clear_mem(libraw_processed_image_t *p)
+{
+  if (p)
+    ::free(p);
+}