lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/utils/phaseone_processing.cpp

@@ -0,0 +1,101 @@
+/* -*- 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/libraw_cxx_defs.h"
+
+void LibRaw::phase_one_allocate_tempbuffer()
+{
+  // Allocate temp raw_image buffer
+  imgdata.rawdata.raw_image = (ushort *)malloc(S.raw_pitch * S.raw_height);
+}
+void LibRaw::phase_one_free_tempbuffer()
+{
+  free(imgdata.rawdata.raw_image);
+  imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc;
+}
+
+int LibRaw::phase_one_subtract_black(ushort *src, ushort *dest)
+{
+
+  try
+  {
+    if (O.user_black < 0 && O.user_cblack[0] <= -1000000 &&
+        O.user_cblack[1] <= -1000000 && O.user_cblack[2] <= -1000000 &&
+        O.user_cblack[3] <= -1000000)
+    {
+      if (!imgdata.rawdata.ph1_cblack || !imgdata.rawdata.ph1_rblack)
+      {
+        int bl = imgdata.color.phase_one_data.t_black;
+        for (int row = 0; row < S.raw_height; row++)
+        {
+          checkCancel();
+          for (int col = 0; col < S.raw_width; col++)
+          {
+            int idx = row * S.raw_width + col;
+            int val = int(src[idx]) - bl;
+            dest[idx] = val > 0 ? val : 0;
+          }
+        }
+      }
+      else
+      {
+        int bl = imgdata.color.phase_one_data.t_black;
+        for (int row = 0; row < S.raw_height; row++)
+        {
+          checkCancel();
+          for (int col = 0; col < S.raw_width; col++)
+          {
+            int idx = row * S.raw_width + col;
+            int val =
+                int(src[idx]) - bl +
+                imgdata.rawdata
+                    .ph1_cblack[row][col >= imgdata.rawdata.color.phase_one_data
+                                                .split_col] +
+                imgdata.rawdata
+                    .ph1_rblack[col][row >= imgdata.rawdata.color.phase_one_data
+                                                .split_row];
+            dest[idx] = val > 0 ? val : 0;
+          }
+        }
+      }
+    }
+    else // black set by user interaction
+    {
+      // Black level in cblack!
+      for (int row = 0; row < S.raw_height; row++)
+      {
+        checkCancel();
+        unsigned short cblk[16];
+        for (int cc = 0; cc < 16; cc++)
+          cblk[cc] = C.cblack[fcol(row, cc)];
+        for (int col = 0; col < S.raw_width; col++)
+        {
+          int idx = row * S.raw_width + col;
+          ushort val = src[idx];
+          ushort bl = cblk[col & 0xf];
+          dest[idx] = val > bl ? val - bl : 0;
+        }
+      }
+    }
+    return 0;
+  }
+  catch (const LibRaw_exceptions& )
+  {
+    return LIBRAW_CANCELLED_BY_CALLBACK;
+  }
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/utils/read_utils.cpp

@@ -0,0 +1,176 @@
+/* -*- 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"
+
+ushort LibRaw::sget2Rev(uchar *s) // specific to some Canon Makernotes fields,
+                                  // where they have endian in reverse
+{
+  if (order == 0x4d4d) /* "II" means little-endian, and we reverse to "MM" - big
+                          endian */
+    return s[0] | s[1] << 8;
+  else /* "MM" means big-endian... */
+    return s[0] << 8 | s[1];
+}
+
+ushort libraw_sget2_static(short _order, uchar *s)
+{
+    if (_order == 0x4949) /* "II" means little-endian */
+        return s[0] | s[1] << 8;
+    else /* "MM" means big-endian */
+        return s[0] << 8 | s[1];
+}
+
+ushort LibRaw::sget2(uchar *s)
+{
+    return libraw_sget2_static(order, s);
+}
+
+
+ushort LibRaw::get2()
+{
+  uchar str[2] = {0xff, 0xff};
+  fread(str, 1, 2, ifp);
+  return sget2(str);
+}
+
+unsigned LibRaw::sget4(uchar *s)
+{
+    return libraw_sget4_static(order, s);
+}
+
+
+unsigned libraw_sget4_static(short _order, uchar *s)
+{
+  if (_order == 0x4949)
+    return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
+  else
+    return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
+}
+
+unsigned LibRaw::get4()
+{
+  uchar str[4] = {0xff, 0xff, 0xff, 0xff};
+  fread(str, 1, 4, ifp);
+  return sget4(str);
+}
+
+unsigned LibRaw::getint(int type) { return tagtypeIs(LIBRAW_EXIFTAG_TYPE_SHORT) ? get2() : get4(); }
+
+float libraw_int_to_float(int i)
+{
+  union {
+    int i;
+    float f;
+  } u;
+  u.i = i;
+  return u.f;
+}
+
+float LibRaw::int_to_float(int i) { return libraw_int_to_float(i); }
+
+double LibRaw::getreal(int type)
+{
+  union {
+    char c[8];
+    double d;
+  } u, v;
+  int i, rev;
+
+  switch (type)
+  {
+  case LIBRAW_EXIFTAG_TYPE_SHORT:
+    return (unsigned short)get2();
+  case LIBRAW_EXIFTAG_TYPE_LONG:
+    return (unsigned int)get4();
+  case LIBRAW_EXIFTAG_TYPE_RATIONAL: // (unsigned, unsigned)
+    u.d = (unsigned int)get4();
+    v.d = (unsigned int)get4();
+    return u.d / (v.d ? v.d : 1);
+  case LIBRAW_EXIFTAG_TYPE_SSHORT:
+    return (signed short)get2();
+  case LIBRAW_EXIFTAG_TYPE_SLONG:
+    return (signed int)get4();
+  case LIBRAW_EXIFTAG_TYPE_SRATIONAL: // (int, int)
+    u.d = (signed int)get4();
+    v.d = (signed int)get4();
+    return u.d / (v.d ? v.d : 1);
+  case LIBRAW_EXIFTAG_TYPE_FLOAT:
+    return int_to_float(get4());
+  case LIBRAW_EXIFTAG_TYPE_DOUBLE:
+    rev = 7 * ((order == 0x4949) == (ntohs(0x1234) == 0x1234));
+    for (i = 0; i < 8; i++)
+      u.c[i ^ rev] = fgetc(ifp);
+    return u.d;
+  default:
+    return fgetc(ifp);
+  }
+}
+
+double LibRaw::sgetreal(int type, uchar *s)
+{
+    return libraw_sgetreal_static(order, type, s);
+}
+
+
+double libraw_sgetreal_static(short _order, int type, uchar *s)
+{
+  union {
+    char c[8];
+    double d;
+  } u, v;
+  int i, rev;
+
+  switch (type)
+  {
+  case LIBRAW_EXIFTAG_TYPE_SHORT:
+    return (unsigned short) libraw_sget2_static(_order,s);
+  case LIBRAW_EXIFTAG_TYPE_LONG:
+      return (unsigned int)libraw_sget4_static(_order, s);
+  case LIBRAW_EXIFTAG_TYPE_RATIONAL: // (unsigned, unsigned)
+    u.d = (unsigned int)libraw_sget4_static(_order,s);
+    v.d = (unsigned int)libraw_sget4_static(_order,s+4);
+    return u.d / (v.d ? v.d : 1);
+  case LIBRAW_EXIFTAG_TYPE_SSHORT:
+    return (signed short)libraw_sget2_static(_order,s);
+  case LIBRAW_EXIFTAG_TYPE_SLONG:
+    return (signed int) libraw_sget4_static(_order,s);
+  case LIBRAW_EXIFTAG_TYPE_SRATIONAL: // (int, int)
+    u.d = (signed int)libraw_sget4_static(_order,s);
+    v.d = (signed int)libraw_sget4_static(_order,s+4);
+    return u.d / (v.d ? v.d : 1);
+  case LIBRAW_EXIFTAG_TYPE_FLOAT:
+    return libraw_int_to_float(libraw_sget4_static(_order,s));
+  case LIBRAW_EXIFTAG_TYPE_DOUBLE:
+    rev = 7 * ((_order == 0x4949) == (ntohs(0x1234) == 0x1234));
+    for (i = 0; i < 8; i++)
+      u.c[i ^ rev] = *(s+1);
+    return u.d;
+  default:
+    return *(s+1);
+  }
+}
+
+
+void LibRaw::read_shorts(ushort *pixel, unsigned count)
+{
+  if ((unsigned)fread(pixel, 2, count, ifp) < count)
+    derror();
+  if ((order == 0x4949) == (ntohs(0x1234) == 0x1234))
+    libraw_swab(pixel, count * 2);
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/utils/thumb_utils.cpp

@@ -0,0 +1,338 @@
+/* -*- 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"
+
+void LibRaw::kodak_thumb_loader()
+{
+  INT64 est_datasize =
+      T.theight * T.twidth / 3; // is 0.3 bytes per pixel good estimate?
+  if (ID.toffset < 0)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+
+  if (ID.toffset + est_datasize > ID.input->size() + THUMB_READ_BEYOND)
+    throw LIBRAW_EXCEPTION_IO_EOF;
+
+  if(INT64(T.theight) * INT64(T.twidth) > 1024ULL * 1024ULL * LIBRAW_MAX_THUMBNAIL_MB)
+      throw LIBRAW_EXCEPTION_IO_CORRUPT;
+
+  if (INT64(T.theight) * INT64(T.twidth) < 64ULL)
+      throw LIBRAW_EXCEPTION_IO_CORRUPT;
+
+  if(T.twidth < 16 || T.twidth > 8192 || T.theight < 16 || T.theight > 8192)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+
+  // some kodak cameras
+  ushort s_height = S.height, s_width = S.width, s_iwidth = S.iwidth,
+         s_iheight = S.iheight;
+  ushort s_flags = libraw_internal_data.unpacker_data.load_flags;
+  libraw_internal_data.unpacker_data.load_flags = 12;
+  int s_colors = P1.colors;
+  unsigned s_filters = P1.filters;
+  ushort(*s_image)[4] = imgdata.image;
+
+  S.height = T.theight;
+  S.width = T.twidth;
+  P1.filters = 0;
+
+#define Tformat libraw_internal_data.unpacker_data.thumb_format
+
+
+  if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_YCBCR)
+  {
+    S.height += S.height & 1;
+    S.width += S.width & 1;
+  }
+
+  S.iheight = S.height;
+  S.iwidth = S.width;
+
+  imgdata.image =
+      (ushort(*)[4])calloc(S.iheight * S.iwidth, sizeof(*imgdata.image));
+
+  ID.input->seek(ID.toffset, SEEK_SET);
+  // read kodak thumbnail into T.image[]
+  try
+  {
+      if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_YCBCR)
+          kodak_ycbcr_load_raw();
+      else if(Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_RGB)
+        kodak_rgb_load_raw();
+      else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_THUMB)
+        kodak_thumb_load_raw();
+  }
+  catch (...)
+  {
+    free(imgdata.image);
+    imgdata.image = s_image;
+
+    T.twidth = 0;
+    S.width = s_width;
+
+    S.iwidth = s_iwidth;
+    S.iheight = s_iheight;
+
+    T.theight = 0;
+    S.height = s_height;
+
+    T.tcolors = 0;
+    P1.colors = s_colors;
+
+    P1.filters = s_filters;
+    T.tlength = 0;
+    libraw_internal_data.unpacker_data.load_flags = s_flags;
+    return;
+  }
+
+  // from scale_colors
+  {
+    double dmax;
+    float scale_mul[4];
+    int c, val;
+    for (dmax = DBL_MAX, c = 0; c < 3; c++)
+      if (dmax > C.pre_mul[c])
+        dmax = C.pre_mul[c];
+
+    for (c = 0; c < 3; c++)
+      scale_mul[c] = (C.pre_mul[c] / dmax) * 65535.0 / C.maximum;
+    scale_mul[3] = scale_mul[1];
+
+    size_t size = S.height * S.width;
+    for (unsigned i = 0; i < size * 4; i++)
+    {
+      val = imgdata.image[0][i];
+      if (!val)
+        continue;
+      val *= scale_mul[i & 3];
+      imgdata.image[0][i] = CLIP(val);
+    }
+  }
+
+  // from convert_to_rgb
+  ushort *img;
+  int row, col;
+
+  int(*t_hist)[LIBRAW_HISTOGRAM_SIZE] =
+      (int(*)[LIBRAW_HISTOGRAM_SIZE])calloc(sizeof(*t_hist), 4);
+
+  if (imgdata.idata.maker_index == LIBRAW_CAMERAMAKER_Canon) // Skip color conversion for canon PPM tiffs
+  {
+    for (img = imgdata.image[0], row = 0; row < S.height; row++)
+      for (col = 0; col < S.width; col++, img += 4)
+        for (int c = 0; c < P1.colors; c++)
+          t_hist[c][img[c] >> 3]++;
+  }
+  else
+  {
+    float out[3], out_cam[3][4] = {{2.81761312f, -1.98369181f, 0.166078627f, 0},
+                                   {-0.111855984f, 1.73688626f, -0.625030339f, 0},
+                                   {-0.0379119813f, -0.891268849f, 1.92918086f, 0}};
+    
+	for (img = imgdata.image[0], row = 0; row < S.height; row++)
+      for (col = 0; col < S.width; col++, img += 4)
+      {
+        out[0] = out[1] = out[2] = 0;
+        int c;
+        for (c = 0; c < 3; c++)
+        {
+          out[0] += out_cam[0][c] * img[c];
+          out[1] += out_cam[1][c] * img[c];
+          out[2] += out_cam[2][c] * img[c];
+        }
+        for (c = 0; c < 3; c++)
+          img[c] = CLIP((int)out[c]);
+        for (c = 0; c < P1.colors; c++)
+          t_hist[c][img[c] >> 3]++;
+      }
+  }
+
+  // from gamma_lut
+  int(*save_hist)[LIBRAW_HISTOGRAM_SIZE] =
+      libraw_internal_data.output_data.histogram;
+  libraw_internal_data.output_data.histogram = t_hist;
+
+  // make curve output curve!
+  ushort *t_curve = (ushort *)calloc(sizeof(C.curve), 1);
+  memmove(t_curve, C.curve, sizeof(C.curve));
+  memset(C.curve, 0, sizeof(C.curve));
+  {
+    int perc, val, total, t_white = 0x2000, c;
+
+    perc = S.width * S.height * 0.01; /* 99th percentile white level */
+    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);
+  }
+
+  libraw_internal_data.output_data.histogram = save_hist;
+  free(t_hist);
+
+  // from write_ppm_tiff - copy pixels into bitmap
+
+  int s_flip = imgdata.sizes.flip;
+  if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_NO_ROTATE_FOR_KODAK_THUMBNAILS)
+    imgdata.sizes.flip = 0;
+
+  S.iheight = S.height;
+  S.iwidth = S.width;
+  if (S.flip & 4)
+    SWAP(S.height, S.width);
+
+  if (T.thumb)
+    free(T.thumb);
+  T.thumb = (char *)calloc(S.width * S.height, P1.colors);
+  T.tlength = S.width * S.height * P1.colors;
+
+  // from write_tiff_ppm
+  {
+    int soff = flip_index(0, 0);
+    int cstep = flip_index(0, 1) - soff;
+    int rstep = flip_index(1, 0) - flip_index(0, S.width);
+
+    for (int rr = 0; rr < S.height; rr++, soff += rstep)
+    {
+      char *ppm = T.thumb + rr * S.width * P1.colors;
+      for (int cc = 0; cc < S.width; cc++, soff += cstep)
+        for (int c = 0; c < P1.colors; c++)
+          ppm[cc * P1.colors + c] =
+              imgdata.color.curve[imgdata.image[soff][c]] >> 8;
+    }
+  }
+
+  memmove(C.curve, t_curve, sizeof(C.curve));
+  free(t_curve);
+
+  // restore variables
+  free(imgdata.image);
+  imgdata.image = s_image;
+
+  if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_NO_ROTATE_FOR_KODAK_THUMBNAILS)
+    imgdata.sizes.flip = s_flip;
+
+  T.twidth = S.width;
+  S.width = s_width;
+
+  S.iwidth = s_iwidth;
+  S.iheight = s_iheight;
+
+  T.theight = S.height;
+  S.height = s_height;
+
+  T.tcolors = P1.colors;
+  P1.colors = s_colors;
+
+  P1.filters = s_filters;
+  libraw_internal_data.unpacker_data.load_flags = s_flags;
+}
+
+// ������� thumbnail �� �����, ������ thumb_format � ������������ � ��������
+
+int LibRaw::thumbOK(INT64 maxsz)
+{
+  if (!ID.input)
+    return 0;
+  if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 &&
+                       load_raw == &LibRaw::broadcom_load_raw) // RPi
+#ifdef USE_6BY9RPI
+      && !(imgdata.thumbnail.tlength > 0 && libraw_internal_data.unpacker_data.load_flags & 0x4000 &&
+           (load_raw == &LibRaw::rpi_load_raw8 || load_raw == &LibRaw::nokia_load_raw ||
+            load_raw == &LibRaw::rpi_load_raw12 || load_raw == &LibRaw::rpi_load_raw14))
+#endif
+  )
+    return 0;
+  INT64 fsize = ID.input->size();
+  if (fsize > 0xffffffffU)
+    return 0; // No thumb for raw > 4Gb-1
+  int tsize = 0;
+  int tcol = (T.tcolors > 0 && T.tcolors < 4) ? T.tcolors : 3;
+  if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_JPEG)
+    tsize = T.tlength;
+  else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_PPM)
+    tsize = tcol * T.twidth * T.theight;
+  else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_PPM16)
+    tsize = tcol * T.twidth * T.theight *
+            ((imgdata.rawparams.options & LIBRAW_RAWOPTIONS_USE_PPM16_THUMBS) ? 2 : 1);
+#ifdef USE_X3FTOOLS
+  else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_X3F)
+  {
+    tsize = x3f_thumb_size();
+  }
+#endif
+  else // Kodak => no check
+    tsize = 1;
+  if (tsize < 0)
+    return 0;
+  if (maxsz > 0 && tsize > maxsz)
+    return 0;
+  return (tsize + ID.toffset <= fsize) ? 1 : 0;
+}
+
+int LibRaw::dcraw_thumb_writer(const char *fname)
+{
+  //    CHECK_ORDER_LOW(LIBRAW_PROGRESS_THUMB_LOAD);
+
+  if (!fname)
+    return ENOENT;
+
+  FILE *tfp = fopen(fname, "wb");
+
+  if (!tfp)
+    return errno;
+
+  if (!T.thumb)
+  {
+    fclose(tfp);
+    return LIBRAW_OUT_OF_ORDER_CALL;
+  }
+
+  try
+  {
+    switch (T.tformat)
+    {
+    case LIBRAW_THUMBNAIL_JPEG:
+      jpeg_thumb_writer(tfp, T.thumb, T.tlength);
+      break;
+    case LIBRAW_THUMBNAIL_BITMAP:
+      fprintf(tfp, "P%d\n%d %d\n255\n", T.tcolors == 1 ? 5 : 6,  T.twidth, T.theight);
+      fwrite(T.thumb, 1, T.tlength, tfp);
+      break;
+    default:
+      fclose(tfp);
+      return LIBRAW_UNSUPPORTED_THUMBNAIL;
+    }
+    fclose(tfp);
+    return 0;
+  }
+  catch (const std::bad_alloc&)
+  {
+      fclose(tfp);
+      EXCEPTION_HANDLER(LIBRAW_EXCEPTION_ALLOC);
+  }
+  catch (const LibRaw_exceptions& err)
+  {
+    fclose(tfp);
+    EXCEPTION_HANDLER(err);
+  }
+}