lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/samples/rawtextdump.cpp

@@ -0,0 +1,144 @@
+/* -*- C++ -*-
+ * File: raw2text.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Sun Sept 01, 2020
+ *
+ * LibRaw sample
+ * Dumps (small) selection of RAW data to text file
+ *
+
+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 <stdio.h>
+#include <string.h>
+#include <math.h>
+#ifndef WIN32
+#include <netinet/in.h>
+#else
+#include <winsock2.h>
+#endif
+
+#include "libraw/libraw.h"
+
+void usage(const char *av)
+{
+	printf(
+		"Dump (small) selection of RAW file as tab-separated text file\n"
+		"Usage: %s inputfile COL ROW [CHANNEL] [width] [height]\n"
+		"  COL - start column\n"
+		"  ROW - start row\n"
+		"  CHANNEL - raw channel to dump, default is 0 (red for rggb)\n"
+		"  width - area width to dump, default is 16\n"
+		"  height - area height to dump, default is 4\n"
+		, av);
+}
+
+unsigned subtract_bl(unsigned int val, int bl)
+{
+	return val > (unsigned)bl ? val - (unsigned)bl : 0;
+}
+
+class LibRaw_bl : public LibRaw
+{
+	public:
+		void adjust_blacklevel() { LibRaw::adjust_bl(); }
+};
+
+int main(int ac, char *av[])
+{
+	if (ac < 4)
+	{
+		usage(av[0]);
+		exit(1);
+	}
+	int colstart = atoi(av[2]);
+	int rowstart = atoi(av[3]);
+	int channel = 0;
+	if (ac > 4) channel = atoi(av[4]);
+	int width = 16;
+	if (ac > 5) width = atoi(av[5]);
+	int height = 4;
+	if (ac > 6) height = atoi(av[6]);
+	if (width <1 || height<1)
+	{
+		usage(av[0]);
+		exit(1);
+	}
+
+	LibRaw_bl lr;
+
+	if (lr.open_file(av[1]) != LIBRAW_SUCCESS)
+	{
+		fprintf(stderr, "Unable to open file %s\n", av[1]);
+		exit(1);
+	}
+	if ((lr.imgdata.idata.colors == 1 && channel>0) || (channel >3))
+	{
+		fprintf(stderr, "Incorrect CHANNEL specified: %d\n", channel);
+		exit(1);
+	}
+	if (lr.unpack() != LIBRAW_SUCCESS)
+	{
+		fprintf(stderr, "Unable to unpack raw data from %s\n", av[1]);
+		exit(1);
+	}
+	lr.adjust_blacklevel();
+	printf("%s\t%d-%d-%dx%d\tchannel: %d\n", av[1], colstart, rowstart, width, height, channel);
+
+	printf("%6s", "R\\C");
+	for (int col = colstart; col < colstart + width && col < lr.imgdata.sizes.raw_width; col++)
+		printf("%6u", col);
+	printf("\n");
+
+	if (lr.imgdata.rawdata.raw_image)
+	{
+		for (int row = rowstart; row < rowstart + height && row < lr.imgdata.sizes.raw_height; row++)
+		{
+			unsigned rcolors[48];
+			if (lr.imgdata.idata.colors > 1)
+				for (int c = 0; c < 48; c++)
+					rcolors[c] = lr.COLOR(row, c);
+			else
+				memset(rcolors, 0, sizeof(rcolors));
+			unsigned short *rowdata = &lr.imgdata.rawdata.raw_image[row * lr.imgdata.sizes.raw_pitch / 2];
+			printf("%6u", row);
+			for (int col = colstart; col < colstart + width && col < lr.imgdata.sizes.raw_width; col++)
+				if (rcolors[col % 48] == (unsigned)channel) printf("%6u", subtract_bl(rowdata[col],lr.imgdata.color.cblack[channel]));
+				else printf("     -");
+			printf("\n");
+		}
+	}
+	else if (lr.imgdata.rawdata.color4_image && channel < 4)
+	{
+		for (int row = rowstart; row < rowstart + height && row < lr.imgdata.sizes.raw_height; row++)
+		{
+			unsigned short(*rowdata)[4] = &lr.imgdata.rawdata.color4_image[row * lr.imgdata.sizes.raw_pitch / 8];
+			printf("%6u", row);
+			for (int col = colstart; col < colstart + width && col < lr.imgdata.sizes.raw_width; col++)
+				printf("%6u", subtract_bl(rowdata[col][channel],lr.imgdata.color.cblack[channel]));
+			printf("\n");
+		}
+	}
+	else if (lr.imgdata.rawdata.color3_image && channel < 3)
+	{
+		for (int row = rowstart; row < rowstart + height && row < lr.imgdata.sizes.raw_height; row++)
+		{
+			unsigned short(*rowdata)[3] = &lr.imgdata.rawdata.color3_image[row * lr.imgdata.sizes.raw_pitch / 6];
+			printf("%6u", row);
+			for (int col = colstart; col < colstart + width && col < lr.imgdata.sizes.raw_width; col++)
+				printf("%6u", subtract_bl(rowdata[col][channel],lr.imgdata.color.cblack[channel]));
+			printf("\n");
+		}
+	}
+	else
+		printf("Unsupported file data (e.g. floating point format), or incorrect channel specified\n");
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/samples/simple_dcraw.cpp

@@ -0,0 +1,217 @@
+/* -*- C++ -*-
+ * File: simple_dcraw.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Sat Mar  8, 2008
+ *
+ * LibRaw simple C++ API:  emulates call to "dcraw  [-D]  [-T] [-v] [-e] [-4]"
+
+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 <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "libraw/libraw.h"
+
+#ifndef LIBRAW_WIN32_CALLS
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#endif
+
+#ifdef LIBRAW_WIN32_CALLS
+#define snprintf _snprintf
+#endif
+
+int my_progress_callback(void *unused_data, enum LibRaw_progress state,
+                         int iter, int expected)
+{
+  if (iter == 0)
+    printf("CB: state=%x, expected %d iterations\n", state, expected);
+  return 0;
+}
+
+char *customCameras[] = {
+    (char *)"43704960,4080,5356, 0, 0, 0, 0,0,148,0,0, Dalsa, FTF4052C Full,0",
+    (char *)"42837504,4008,5344, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF4052C 3:4",
+    (char *)"32128128,4008,4008, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF4052C 1:1",
+    (char *)"24096096,4008,3006, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF4052C 4:3",
+    (char *)"18068064,4008,2254, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF4052C 16:9",
+    (char *)"67686894,5049,6703, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF5066C Full",
+    (char *)"66573312,4992,6668, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF5066C 3:4",
+    (char *)"49840128,4992,4992, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF5066C 1:1",
+    (char *)"37400064,4992,3746, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF5066C 4:3",
+    (char *)"28035072,4992,2808, 0, 0, 0, 0,0,148,0,0,Dalsa, FTF5066C 16:9",
+    NULL};
+
+int main(int ac, char *av[])
+{
+  int i, ret, verbose = 0, output_thumbs = 0, output_all_thumbs = 0;
+
+  // don't use fixed size buffers in real apps!
+  char outfn[1024], thumbfn[1024];
+
+  LibRaw* RawProcessor = new LibRaw;
+  RawProcessor->imgdata.rawparams.custom_camera_strings = customCameras;
+  if (ac < 2)
+  {
+    printf("simple_dcraw - LibRaw %s sample. Emulates dcraw [-D] [-T] [-v] "
+           "[-e] [-E]\n"
+           " %d cameras supported\n"
+           "Usage: %s [-D] [-T] [-v] [-e] raw-files....\n"
+           "\t-4 - 16-bit mode\n"
+           "\t-L - list supported cameras and exit\n"
+           "\t-v - verbose output\n"
+           "\t-T - output TIFF files instead of .pgm/ppm\n"
+           "\t-e - extract thumbnails (same as dcraw -e in separate run)\n"
+           "\t-E - extract all thumbnails\n",
+           LibRaw::version(), LibRaw::cameraCount(), av[0]);
+    delete RawProcessor;
+    return 0;
+  }
+
+  putenv((char *)"TZ=UTC"); // dcraw compatibility, affects TIFF datestamp field
+
+#define P1 RawProcessor->imgdata.idata
+#define S RawProcessor->imgdata.sizes
+#define C RawProcessor->imgdata.color
+#define T RawProcessor->imgdata.thumbnail
+#define P2 RawProcessor->imgdata.other
+#define OUT RawProcessor->imgdata.params
+
+  for (i = 1; i < ac; i++)
+  {
+    if (av[i][0] == '-')
+    {
+      if (av[i][1] == 'T' && av[i][2] == 0)
+        OUT.output_tiff = 1;
+      if (av[i][1] == 'v' && av[i][2] == 0)
+        verbose++;
+      if (av[i][1] == 'e' && av[i][2] == 0)
+        output_thumbs++;
+      if (av[i][1] == 'E' && av[i][2] == 0)
+      {
+        output_thumbs++;
+        output_all_thumbs++;
+      }
+      if (av[i][1] == '4' && av[i][2] == 0)
+        OUT.output_bps = 16;
+      if (av[i][1] == 'C' && av[i][2] == 0)
+        RawProcessor->set_progress_handler(my_progress_callback, NULL);
+      if (av[i][1] == 'L' && av[i][2] == 0)
+      {
+        const char **clist = LibRaw::cameraList();
+        const char **cc = clist;
+        while (*cc)
+        {
+          printf("%s\n", *cc);
+          cc++;
+        }
+        delete RawProcessor;
+        exit(0);
+      }
+      continue;
+    }
+
+    if (verbose)
+      printf("Processing file %s\n", av[i]);
+
+    if ((ret = RawProcessor->open_file(av[i])) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot open_file %s: %s\n", av[i], libraw_strerror(ret));
+      continue; // no recycle b/c open file will recycle itself
+    }
+
+    if (!output_thumbs) // No unpack for thumb extraction
+      if ((ret = RawProcessor->unpack()) != LIBRAW_SUCCESS)
+      {
+        fprintf(stderr, "Cannot unpack %s: %s\n", av[i], libraw_strerror(ret));
+        continue;
+      }
+
+    // thumbnail unpacking and output in the middle of main
+    // image processing - for test purposes!
+    if(output_all_thumbs)
+    {
+      if (verbose)
+        printf("Extracting %d thumbnails\n", RawProcessor->imgdata.thumbs_list.thumbcount);
+      for (int t = 0; t < RawProcessor->imgdata.thumbs_list.thumbcount; t++)
+      {
+        if ((ret = RawProcessor->unpack_thumb_ex(t)) != LIBRAW_SUCCESS)
+          fprintf(stderr, "Cannot unpack_thumb #%d from %s: %s\n", t, av[i], libraw_strerror(ret));
+        if (LIBRAW_FATAL_ERROR(ret))
+          break; // skip to next file
+        snprintf(thumbfn, sizeof(thumbfn), "%s.thumb.%d.%s", av[i], t,
+                 T.tformat == LIBRAW_THUMBNAIL_JPEG ? "jpg" : "ppm");
+        if (verbose)
+          printf("Writing thumbnail file %s\n", thumbfn);
+        if (LIBRAW_SUCCESS != (ret = RawProcessor->dcraw_thumb_writer(thumbfn)))
+        {
+          fprintf(stderr, "Cannot write %s: %s\n", thumbfn, libraw_strerror(ret));
+          if (LIBRAW_FATAL_ERROR(ret))
+            break;
+        }
+      }
+      continue;
+    }
+    else if (output_thumbs)
+    {
+      if ((ret = RawProcessor->unpack_thumb()) != LIBRAW_SUCCESS)
+      {
+        fprintf(stderr, "Cannot unpack_thumb %s: %s\n", av[i],
+                libraw_strerror(ret));
+        if (LIBRAW_FATAL_ERROR(ret))
+          continue; // skip to next file
+      }
+      else
+      {
+        snprintf(thumbfn, sizeof(thumbfn), "%s.%s", av[i],
+                 T.tformat == LIBRAW_THUMBNAIL_JPEG ? "thumb.jpg"
+                                                    : (T.tcolors == 1? "thumb.pgm" : "thumb.ppm"));
+        if (verbose)
+          printf("Writing thumbnail file %s\n", thumbfn);
+        if (LIBRAW_SUCCESS != (ret = RawProcessor->dcraw_thumb_writer(thumbfn)))
+        {
+          fprintf(stderr, "Cannot write %s: %s\n", thumbfn,
+                  libraw_strerror(ret));
+          if (LIBRAW_FATAL_ERROR(ret))
+            continue;
+        }
+      }
+      continue;
+    }
+
+    ret = RawProcessor->dcraw_process();
+
+    if (LIBRAW_SUCCESS != ret)
+    {
+      fprintf(stderr, "Cannot do postprocessing on %s: %s\n", av[i],
+              libraw_strerror(ret));
+      if (LIBRAW_FATAL_ERROR(ret))
+        continue;
+    }
+    snprintf(outfn, sizeof(outfn), "%s.%s", av[i],
+             OUT.output_tiff ? "tiff" : (P1.colors > 1 ? "ppm" : "pgm"));
+
+    if (verbose)
+      printf("Writing file %s\n", outfn);
+
+    if (LIBRAW_SUCCESS != (ret = RawProcessor->dcraw_ppm_tiff_writer(outfn)))
+      fprintf(stderr, "Cannot write %s: %s\n", outfn, libraw_strerror(ret));
+
+    RawProcessor->recycle(); // just for show this call
+  }
+  
+  delete RawProcessor;
+  return 0;
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/samples/unprocessed_raw.cpp

@@ -0,0 +1,319 @@
+/* -*- C++ -*-
+ * File: unprocessed_raw.cpp
+ * Copyright 2009-2021 LibRaw LLC (info@libraw.org)
+ * Created: Fri Jan 02, 2009
+ *
+ * LibRaw sample
+ * Generates unprocessed raw image: with masked pixels and without black
+subtraction
+ *
+
+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 <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+
+#include "libraw/libraw.h"
+
+#ifndef LIBRAW_WIN32_CALLS
+#include <netinet/in.h>
+#else
+#include <sys/utime.h>
+#include <winsock2.h>
+#endif
+
+#ifdef LIBRAW_WIN32_CALLS
+#define snprintf _snprintf
+#endif
+
+#if !(LIBRAW_COMPILE_CHECK_VERSION_NOTLESS(0, 14))
+#error This code is for LibRaw 0.14+ only
+#endif
+
+void gamma_curve(unsigned short curve[]);
+void write_ppm(unsigned width, unsigned height, unsigned short *bitmap,
+               const char *basename);
+void write_tiff(int width, int height, unsigned short *bitmap,
+                const char *basename);
+
+int main(int ac, char *av[])
+{
+  int i, ret;
+  int verbose = 1, autoscale = 0, use_gamma = 0, out_tiff = 0;
+  char outfn[1024];
+
+  LibRaw RawProcessor;
+  if (ac < 2)
+  {
+  usage:
+    printf("unprocessed_raw - LibRaw %s sample. %d cameras supported\n"
+           "Usage: %s [-q] [-A] [-g] [-s N] raw-files....\n"
+           "\t-q - be quiet\n"
+           "\t-s N - select Nth image in file (default=0)\n"
+           "\t-g - use gamma correction with gamma 2.2 (not precise,use for "
+           "visual inspection only)\n"
+           "\t-A - autoscaling (by integer factor)\n"
+           "\t-T - write tiff instead of pgm\n",
+           LibRaw::version(), LibRaw::cameraCount(), av[0]);
+    return 0;
+  }
+
+#define S RawProcessor.imgdata.sizes
+#define OUT RawProcessor.imgdata.params
+#define OUTR RawProcessor.imgdata.rawparams
+
+  for (i = 1; i < ac; i++)
+  {
+    if (av[i][0] == '-')
+    {
+      if (av[i][1] == 'q' && av[i][2] == 0)
+        verbose = 0;
+      else if (av[i][1] == 'A' && av[i][2] == 0)
+        autoscale = 1;
+      else if (av[i][1] == 'g' && av[i][2] == 0)
+        use_gamma = 1;
+      else if (av[i][1] == 'T' && av[i][2] == 0)
+        out_tiff = 1;
+      else if (av[i][1] == 's' && av[i][2] == 0)
+      {
+        i++;
+        OUTR.shot_select = av[i] ? atoi(av[i]) : 0;
+      }
+      else
+        goto usage;
+      continue;
+    }
+
+    if (verbose)
+      printf("Processing file %s\n", av[i]);
+    if ((ret = RawProcessor.open_file(av[i])) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot open %s: %s\n", av[i], libraw_strerror(ret));
+      continue; // no recycle b/c open file will recycle itself
+    }
+    if (verbose)
+    {
+      printf("Image size: %dx%d\nRaw size: %dx%d\n", S.width, S.height,
+             S.raw_width, S.raw_height);
+      printf("Margins: top=%d, left=%d\n", S.top_margin, S.left_margin);
+    }
+
+    if ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot unpack %s: %s\n", av[i], libraw_strerror(ret));
+      continue;
+    }
+
+    if (verbose)
+      printf("Unpacked....\n");
+
+    if (!(RawProcessor.imgdata.idata.filters ||
+          RawProcessor.imgdata.idata.colors == 1))
+    {
+      printf("Only Bayer-pattern RAW files supported, sorry....\n");
+      continue;
+    }
+
+    if (autoscale)
+    {
+      unsigned max = 0, scale;
+      for (int j = 0; j < S.raw_height * S.raw_width; j++)
+        if (max < RawProcessor.imgdata.rawdata.raw_image[j])
+          max = RawProcessor.imgdata.rawdata.raw_image[j];
+      if (max > 0 && max < 1 << 15)
+      {
+        scale = (1 << 16) / max;
+        if (verbose)
+          printf("Scaling with multiplier=%d (max=%d)\n", scale, max);
+
+        for (int j = 0; j < S.raw_height * S.raw_width; j++)
+          RawProcessor.imgdata.rawdata.raw_image[j] *= scale;
+      }
+    }
+    if (use_gamma)
+    {
+      unsigned short curve[0x10000];
+      gamma_curve(curve);
+      for (int j = 0; j < S.raw_height * S.raw_width; j++)
+        RawProcessor.imgdata.rawdata.raw_image[j] =
+            curve[RawProcessor.imgdata.rawdata.raw_image[j]];
+      if (verbose)
+        printf("Gamma-corrected....\n");
+    }
+
+    if (OUTR.shot_select)
+      snprintf(outfn, sizeof(outfn), "%s-%d.%s", av[i], OUTR.shot_select,
+               out_tiff ? "tiff" : "pgm");
+    else
+      snprintf(outfn, sizeof(outfn), "%s.%s", av[i], out_tiff ? "tiff" : "pgm");
+
+    if (out_tiff)
+      write_tiff(S.raw_width, S.raw_height,
+                 RawProcessor.imgdata.rawdata.raw_image, outfn);
+    else
+      write_ppm(S.raw_width, S.raw_height,
+                RawProcessor.imgdata.rawdata.raw_image, outfn);
+
+    if (verbose)
+      printf("Stored to file %s\n", outfn);
+  }
+  return 0;
+}
+
+void write_ppm(unsigned width, unsigned height, unsigned short *bitmap,
+               const char *fname)
+{
+  if (!bitmap)
+    return;
+
+  FILE *f = fopen(fname, "wb");
+  if (!f)
+    return;
+  int bits = 16;
+  fprintf(f, "P5\n%d %d\n%d\n", width, height, (1 << bits) - 1);
+  unsigned char *data = (unsigned char *)bitmap;
+  unsigned data_size = width * height * 2;
+#define SWAP(a, b)                                                             \
+  {                                                                            \
+    a ^= b;                                                                    \
+    a ^= (b ^= a);                                                             \
+  }
+  for (unsigned i = 0; i < data_size; i += 2)
+    SWAP(data[i], data[i + 1]);
+#undef SWAP
+  fwrite(data, data_size, 1, f);
+  fclose(f);
+}
+
+/*  == gamma curve and tiff writer - simplified cut'n'paste from dcraw.c */
+
+#define SQR(x) ((x) * (x))
+
+void gamma_curve(unsigned short *curve)
+{
+
+  double pwr = 1.0 / 2.2;
+  double ts = 0.0;
+  int imax = 0xffff;
+  int mode = 2;
+  int i;
+  double g[6], bnd[2] = {0, 0}, r;
+
+  g[0] = pwr;
+  g[1] = ts;
+  g[2] = g[3] = g[4] = 0;
+  bnd[g[1] >= 1] = 1;
+  if (g[1] && (g[1] - 1) * (g[0] - 1) <= 0)
+  {
+    for (i = 0; i < 48; i++)
+    {
+      g[2] = (bnd[0] + bnd[1]) / 2;
+      if (g[0])
+        bnd[(pow(g[2] / g[1], -g[0]) - 1) / g[0] - 1 / g[2] > -1] = g[2];
+      else
+        bnd[g[2] / exp(1 - 1 / g[2]) < g[1]] = g[2];
+    }
+    g[3] = g[2] / g[1];
+    if (g[0])
+      g[4] = g[2] * (1 / g[0] - 1);
+  }
+  if (g[0])
+    g[5] = 1 / (g[1] * SQR(g[3]) / 2 - g[4] * (1 - g[3]) +
+                (1 - pow(g[3], 1 + g[0])) * (1 + g[4]) / (1 + g[0])) -
+           1;
+  else
+    g[5] = 1 / (g[1] * SQR(g[3]) / 2 + 1 - g[2] - g[3] -
+                g[2] * g[3] * (log(g[3]) - 1)) -
+           1;
+  for (i = 0; i < 0x10000; i++)
+  {
+    curve[i] = 0xffff;
+    if ((r = (double)i / imax) < 1)
+      curve[i] =
+          0x10000 *
+          (mode ? (r < g[3] ? r * g[1]
+                            : (g[0] ? pow(r, g[0]) * (1 + g[4]) - g[4]
+                                    : log(r) * g[2] + 1))
+                : (r < g[2] ? r / g[1]
+                            : (g[0] ? pow((r + g[4]) / (1 + g[4]), 1 / g[0])
+                                    : exp((r - 1) / g[2]))));
+  }
+}
+
+void tiff_set(ushort *ntag, ushort tag, ushort type, int count, int val)
+{
+  struct libraw_tiff_tag *tt;
+  int c;
+
+  tt = (struct libraw_tiff_tag *)(ntag + 1) + (*ntag)++;
+  tt->tag = tag;
+  tt->type = type;
+  tt->count = count;
+  if ((type < LIBRAW_EXIFTAG_TYPE_SHORT) && (count <= 4))
+    for (c = 0; c < 4; c++)
+      tt->val.c[c] = val >> (c << 3);
+  else if (tagtypeIs(LIBRAW_EXIFTAG_TYPE_SHORT) && (count <= 2))
+    for (c = 0; c < 2; c++)
+      tt->val.s[c] = val >> (c << 4);
+  else
+    tt->val.i = val;
+}
+#define TOFF(ptr) ((char *)(&(ptr)) - (char *)th)
+
+void tiff_head(int width, int height, struct tiff_hdr *th)
+{
+  int c;
+  time_t timestamp = time(NULL);
+  struct tm *t;
+
+  memset(th, 0, sizeof *th);
+  th->t_order = htonl(0x4d4d4949) >> 16;
+  th->magic = 42;
+  th->ifd = 10;
+  tiff_set(&th->ntag, 254, 4, 1, 0);
+  tiff_set(&th->ntag, 256, 4, 1, width);
+  tiff_set(&th->ntag, 257, 4, 1, height);
+  tiff_set(&th->ntag, 258, 3, 1, 16);
+  for (c = 0; c < 4; c++)
+    th->bps[c] = 16;
+  tiff_set(&th->ntag, 259, 3, 1, 1);
+  tiff_set(&th->ntag, 262, 3, 1, 1);
+  tiff_set(&th->ntag, 273, 4, 1, sizeof *th);
+  tiff_set(&th->ntag, 277, 3, 1, 1);
+  tiff_set(&th->ntag, 278, 4, 1, height);
+  tiff_set(&th->ntag, 279, 4, 1, height * width * 2);
+  tiff_set(&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
+  tiff_set(&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
+  tiff_set(&th->ntag, 284, 3, 1, 1);
+  tiff_set(&th->ntag, 296, 3, 1, 2);
+  tiff_set(&th->ntag, 306, 2, 20, TOFF(th->date));
+  th->rat[0] = th->rat[2] = 300;
+  th->rat[1] = th->rat[3] = 1;
+  t = localtime(&timestamp);
+  if (t)
+    sprintf(th->date, "%04d:%02d:%02d %02d:%02d:%02d", t->tm_year + 1900,
+            t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+}
+
+void write_tiff(int width, int height, unsigned short *bitmap, const char *fn)
+{
+  struct tiff_hdr th;
+
+  FILE *ofp = fopen(fn, "wb");
+  if (!ofp)
+    return;
+  tiff_head(width, height, &th);
+  fwrite(&th, sizeof th, 1, ofp);
+  fwrite(bitmap, 2, width * height, ofp);
+  fclose(ofp);
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/shlib-version.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+vfile=./libraw/libraw_version.h
+
+major=`grep LIBRAW_SHLIB_CURRENT $vfile |head -1 | awk '{print $3}'`
+minor=`grep LIBRAW_SHLIB_REVISION $vfile | head -1 | awk '{print $3}'`
+patch=`grep LIBRAW_SHLIB_AGE $vfile | head -1 | awk '{print $3}'`
+
+echo "$major:$minor:$patch" | awk '{printf $1}'
+
+

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/Makefile

@@ -0,0 +1,2 @@
+all: 
+	(cd ..; make library)