lightdrift-libraw 1.0.0-alpha.1

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

@@ -0,0 +1,282 @@
+/* -*- C++ -*-
+ * File: mem_image.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ *
+ * LibRaw mem_image/mem_thumb API test. Results should be same (bitwise) to
+dcraw [-4] [-6] [-e]
+ * Testing note: for ppm-thumbnails you should use dcraw -w -e for thumbnail
+extraction
+
+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"
+
+#ifdef USE_JPEG
+#include "jpeglib.h"
+#endif
+
+#ifdef LIBRAW_WIN32_CALLS
+#define snprintf _snprintf
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <netinet/in.h>
+#endif
+
+#ifdef USE_JPEG
+void write_jpeg(libraw_processed_image_t *img, const char *basename, int quality)
+{
+  char fn[1024];
+  if(img->colors != 1 && img->colors != 3)
+  {
+	printf("Only BW and 3-color images supported for JPEG output\n");
+	return;
+  }
+  snprintf(fn, 1024, "%s.jpg", basename);
+  FILE *f = fopen(fn, "wb");
+  if (!f)
+    return;
+  struct jpeg_compress_struct cinfo;
+  struct jpeg_error_mgr jerr;
+  JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
+  int row_stride;          /* physical row width in image buffer */
+
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  jpeg_stdio_dest(&cinfo, f);
+  cinfo.image_width = img->width;      /* image width and height, in pixels */
+  cinfo.image_height = img->height;
+  cinfo.input_components = img->colors;           /* # of color components per pixel */
+  cinfo.in_color_space = img->colors==3?JCS_RGB:JCS_GRAYSCALE;       /* colorspace of input image */
+  jpeg_set_defaults(&cinfo);
+  jpeg_set_quality(&cinfo, quality, TRUE);
+  jpeg_start_compress(&cinfo, TRUE);
+  row_stride = img->width * img->colors; /* JSAMPLEs per row in image_buffer */
+  while (cinfo.next_scanline < cinfo.image_height) {
+    row_pointer[0] = &img->data[cinfo.next_scanline * row_stride];
+    (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+  jpeg_finish_compress(&cinfo);
+  fclose(f);
+  jpeg_destroy_compress(&cinfo);
+}
+
+#endif
+
+// no error reporting, only params check
+void write_ppm(libraw_processed_image_t *img, const char *basename)
+{
+  if (!img)
+    return;
+  // type SHOULD be LIBRAW_IMAGE_BITMAP, but we'll check
+  if (img->type != LIBRAW_IMAGE_BITMAP)
+    return;
+  if (img->colors != 3 && img->colors != 1)
+  {
+    printf("Only monochrome and 3-color images supported for PPM output\n");
+    return;
+   }
+
+  char fn[1024];
+  snprintf(fn, 1024, "%s.p%cm", basename, img->colors==1?'g':'p');
+  FILE *f = fopen(fn, "wb");
+  if (!f)
+    return;
+  fprintf(f, "P%d\n%d %d\n%d\n", img->colors/2 + 5, img->width, img->height, (1 << img->bits) - 1);
+/*
+  NOTE:
+  data in img->data is not converted to network byte order.
+  So, we should swap values on some architectures for dcraw compatibility
+  (unfortunately, xv cannot display 16-bit PPMs with network byte order data
+*/
+#define SWAP(a, b)                                                             \
+  {                                                                            \
+    a ^= b;                                                                    \
+    a ^= (b ^= a);                                                             \
+  }
+  if (img->bits == 16 && htons(0x55aa) != 0x55aa)
+    for (unsigned i = 0; i < img->data_size-1; i += 2)
+      SWAP(img->data[i], img->data[i + 1]);
+#undef SWAP
+
+  fwrite(img->data, img->data_size, 1, f);
+  fclose(f);
+}
+
+void write_thumb(libraw_processed_image_t *img, const char *basename)
+{
+  if (!img)
+    return;
+
+  if (img->type == LIBRAW_IMAGE_BITMAP)
+  {
+    char fnt[1024];
+    snprintf(fnt, 1024, "%s.thumb", basename);
+    write_ppm(img, fnt);
+  }
+  else if (img->type == LIBRAW_IMAGE_JPEG)
+  {
+    char fn[1024];
+    snprintf(fn, 1024, "%s.thumb.jpg", basename);
+    FILE *f = fopen(fn, "wb");
+    if (!f)
+      return;
+    fwrite(img->data, img->data_size, 1, f);
+    fclose(f);
+  }
+}
+
+int main(int ac, char *av[])
+{
+  int i, ret, output_thumbs = 0;
+#ifdef USE_JPEG
+  int output_jpeg = 0, jpgqual = 90;
+#endif
+  // don't use fixed size buffers in real apps!
+
+  LibRaw RawProcessor;
+
+  if (ac < 2)
+  {
+    printf("mem_image - LibRaw sample, to illustrate work for memory buffers.\n"
+           "Emulates dcraw [-4] [-1] [-e] [-h]\n"
+#ifdef USE_JPEG
+           "Usage: %s [-D] [-j[nn]] [-T] [-v] [-e] raw-files....\n"
+#else
+           "Usage: %s [-D] [-T] [-v] [-e] raw-files....\n"
+#endif
+           "\t-6 - output 16-bit PPM\n"
+           "\t-4 - linear 16-bit data\n"
+           "\t-e - extract thumbnails (same as dcraw -e in separate run)\n"
+#ifdef USE_JPEG
+           "\t-j[qual] - output JPEG with qual quality (e.g. -j90)\n"
+#endif
+           "\t-h - use half_size\n", av[0]);
+    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] == '6' && av[i][2] == 0)
+        OUT.output_bps = 16;
+      if (av[i][1] == '4' && av[i][2] == 0)
+      {
+        OUT.output_bps = 16;
+        OUT.gamm[0] = OUT.gamm[1] = OUT.no_auto_bright = 1;
+      }
+      if (av[i][1] == 'e' && av[i][2] == 0)
+        output_thumbs++;
+      if (av[i][1] == 'h' && av[i][2] == 0)
+        OUT.half_size = 1;
+#ifdef USE_JPEG
+      if (av[i][1] == 'j')
+      {
+        output_jpeg = 1;
+        if(av[i][2] != 0)
+        jpgqual = atoi(av[i]+2);
+      } 
+#endif
+      continue;
+    }
+#ifdef USE_JPEG
+    if(output_jpeg && OUT.output_bps>8)
+    {
+      printf("JPEG is limited to 8 bit\n");
+      OUT.output_bps = 8;
+    }
+#endif
+    printf("Processing %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 ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot unpack %s: %s\n", av[i], libraw_strerror(ret));
+      continue;
+    }
+
+    // we should call dcraw_process before thumbnail extraction because for
+    // some cameras (i.e. Kodak ones) white balance for thumbnail should be set
+    // from main image settings
+
+    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;
+    }
+    libraw_processed_image_t *image = RawProcessor.dcraw_make_mem_image(&ret);
+    if (image)
+    {
+#ifdef USE_JPEG
+      if(output_jpeg)
+        write_jpeg(image, av[i], jpgqual);
+      else
+#endif
+        write_ppm(image, av[i]);
+      LibRaw::dcraw_clear_mem(image);
+    }
+    else
+      fprintf(stderr, "Cannot unpack %s to memory buffer: %s\n", av[i],
+              libraw_strerror(ret));
+
+    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
+      {
+        libraw_processed_image_t *thumb =
+            RawProcessor.dcraw_make_mem_thumb(&ret);
+        if (thumb)
+        {
+          write_thumb(thumb, av[i]);
+          LibRaw::dcraw_clear_mem(thumb);
+        }
+        else
+          fprintf(stderr,
+                  "Cannot unpack thumbnail of %s to memory buffer: %s\n", av[i],
+                  libraw_strerror(ret));
+      }
+    }
+
+    RawProcessor.recycle(); // just for show this call
+  }
+  return 0;
+}

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

@@ -0,0 +1,107 @@
+/* -*- C++ -*-
+ * File: multirender_test.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Jul 10, 2011
+ *
+ * LibRaw simple C++ API:  creates 8 different renderings from 1 source file.
+The 1st and 4th one should be identical
+
+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 process_once(LibRaw &RawProcessor, int half_mode, int camera_wb,
+                 int auto_wb, int suffix, int user_flip, char *fname)
+{
+  char outfn[1024];
+  RawProcessor.imgdata.params.half_size = half_mode;
+  RawProcessor.imgdata.params.use_camera_wb = camera_wb;
+  RawProcessor.imgdata.params.use_auto_wb = auto_wb;
+  RawProcessor.imgdata.params.user_flip = user_flip;
+
+  int ret = RawProcessor.dcraw_process();
+
+  if (LIBRAW_SUCCESS != ret)
+  {
+    fprintf(stderr, "Cannot do postprocessing on %s: %s\n", fname,
+            libraw_strerror(ret));
+    return ret;
+  }
+  snprintf(outfn, sizeof(outfn), "%s.%d.%s", fname, suffix,
+           (RawProcessor.imgdata.idata.colors > 1 ? "ppm" : "pgm"));
+
+  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));
+  return ret;
+}
+
+int main(int ac, char *av[])
+{
+  int i, ret;
+
+  LibRaw RawProcessor;
+  if (ac < 2)
+  {
+    printf("multirender_test - LibRaw %s sample. Performs 4 different "
+           "renderings of one file\n"
+           " %d cameras supported\n"
+           "Usage: %s raw-files....\n",
+           LibRaw::version(), LibRaw::cameraCount(), av[0]);
+    return 0;
+  }
+
+  for (i = 1; i < ac; i++)
+  {
+
+    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 ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot unpack %s: %s\n", av[i], libraw_strerror(ret));
+      continue;
+    }
+    process_once(RawProcessor, 0, 0, 0, 1, -1, av[i]); // default flip
+    process_once(RawProcessor, 1, 0, 1, 2, -1, av[i]);
+    process_once(RawProcessor, 1, 1, 0, 3, -1, av[i]); // default flip
+    process_once(RawProcessor, 1, 1, 0, 4, 1, av[i]);  // flip 1
+    process_once(RawProcessor, 1, 1, 0, 5, 3, av[i]);  // flip 3
+    process_once(RawProcessor, 1, 1, 0, 6, 1, av[i]);  // 1 again same as 4
+    process_once(RawProcessor, 1, 1, 0, 7, -1,
+                 av[i]); // default again, same as 3
+    process_once(RawProcessor, 0, 0, 0, 8, -1, av[i]); // same as 1
+
+    RawProcessor.recycle(); // just for show this call
+  }
+  return 0;
+}

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

@@ -0,0 +1,65 @@
+/* -*- C++ -*-
+ * File: openvayer_sample.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Feb 11, 2020
+ *
+ * LibRaw simple C++ API:  opens bayer data (Kodak KAI-0340 sensor) from buffer,
+dump as 8-bit tiff
+
+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
+
+int main(int ac, char *av[])
+{
+  if (ac != 2)
+    return 1;
+  FILE *in = fopen(av[1], "rb");
+  fseek(in, 0, SEEK_END);
+  unsigned fsz = ftell(in);
+  unsigned char *buffer = (unsigned char *)malloc(fsz);
+  if (!buffer)
+    return 2;
+  fseek(in, 0, SEEK_SET);
+  unsigned readb = fread(buffer, 1, fsz, in);
+  if (readb != fsz)
+    return 3;
+  LibRaw rp;
+  rp.imgdata.params.output_tiff = 1;
+  int ret = rp.open_bayer(buffer, fsz, 640, 480, 0, 0, 0, 0, 0,
+                          LIBRAW_OPENBAYER_RGGB, 0, 0, 1400);
+  if (ret != LIBRAW_SUCCESS)
+    return 4;
+  if ((ret = rp.unpack()) != LIBRAW_SUCCESS)
+    printf("Unpack error: %d\n", ret);
+
+  if ((ret = rp.dcraw_process()) != LIBRAW_SUCCESS)
+    printf("Processing error: %d\n", ret);
+
+  char outfn[256];
+  sprintf(outfn, "%s.tif", av[1]);
+  if (LIBRAW_SUCCESS != (ret = rp.dcraw_ppm_tiff_writer(outfn)))
+    printf("Cannot write %s: %s\n", outfn, libraw_strerror(ret));
+  else
+    printf("Created %s\n", outfn);
+}

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

@@ -0,0 +1,223 @@
+/* -*- C++ -*-
+ * File: postprocessing_benchmark.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Jul 13, 2011
+ *
+ * LibRaw simple C++ API:  creates 8 different renderings from 1 source file.
+The 1st and 4th one should be identical
+
+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>
+#else
+#include <winsock2.h>
+#endif
+
+#include "libraw/libraw.h"
+
+void timerstart(void);
+float timerend(void);
+
+int main(int argc, char *argv[])
+{
+  int i, ret, rep = 1;
+  LibRaw RawProcessor;
+#ifdef OUT
+#undef OUT
+#endif
+#define OUT RawProcessor.imgdata.params
+#define OUTR RawProcessor.imgdata.rawparams
+#define S RawProcessor.imgdata.sizes
+
+  if (argc < 2)
+  {
+    printf(
+        "postprocessing benchmark: LibRaw %s sample, %d cameras supported\n"
+        "Measures postprocessing speed with different options\n"
+        "Usage: %s [-a] [-H N] [-q N] [-h] [-m N] [-n N] [-s N] [-B x y w h] "
+        "[-R N]\n"
+        "-a             average image for white balance\n"
+        "-H <num>       Highlight mode (0=clip, 1=unclip, 2=blend, "
+        "3+=rebuild)\n"
+        "-q <num>       Set the interpolation quality\n"
+        "-h             Half-size color image\n"
+        "-m <num>       Apply a num-passes 3x3 median filter to R-G and B-G\n"
+        "-n <num>       Set threshold for wavelet denoising\n"
+        "-s <num>       Select one raw image from input file\n"
+        "-B <x y w h>   Crop output image\n"
+        "-R <num>       Number of repetitions\n"
+        "-c             Do not use rawspeed\n",
+        LibRaw::version(), LibRaw::cameraCount(), argv[0]);
+    return 0;
+  }
+  char opm, opt, *cp, *sp;
+  int arg, c;
+  int shrink = 0;
+
+  argv[argc] = (char *)"";
+  for (arg = 1; (((opm = argv[arg][0]) - 2) | 2) == '+';)
+  {
+    char *optstr = argv[arg];
+    opt = argv[arg++][1];
+    if ((cp = strchr(sp = (char *)"HqmnsBR", opt)) != 0)
+      for (i = 0; i < "1111141"[cp - sp] - '0'; i++)
+        if (!isdigit(argv[arg + i][0]) && !optstr[2])
+        {
+          fprintf(stderr, "Non-numeric argument to \"-%c\"\n", opt);
+          return 1;
+        }
+    switch (opt)
+    {
+    case 'a':
+      OUT.use_auto_wb = 1;
+      break;
+    case 'H':
+      OUT.highlight = atoi(argv[arg++]);
+      break;
+    case 'q':
+      OUT.user_qual = atoi(argv[arg++]);
+      break;
+    case 'h':
+      OUT.half_size = 1;
+      OUT.four_color_rgb = 1;
+      shrink = 1;
+      break;
+    case 'm':
+      OUT.med_passes = atoi(argv[arg++]);
+      break;
+    case 'n':
+      OUT.threshold = (float)atof(argv[arg++]);
+      break;
+    case 's':
+      OUTR.shot_select = abs(atoi(argv[arg++]));
+      break;
+    case 'B':
+      for (c = 0; c < 4; c++)
+        OUT.cropbox[c] = atoi(argv[arg++]);
+      break;
+    case 'R':
+      rep = abs(atoi(argv[arg++]));
+      if (rep < 1)
+        rep = 1;
+      break;
+    case 'c':
+      RawProcessor.imgdata.rawparams.use_rawspeed = 0;
+      break;
+    default:
+      fprintf(stderr, "Unknown option \"-%c\".\n", opt);
+      return 1;
+    }
+  }
+  for (; arg < argc; arg++)
+  {
+    printf("Processing file %s\n", argv[arg]);
+    timerstart();
+    if ((ret = RawProcessor.open_file(argv[arg])) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot open_file %s: %s\n", argv[arg],
+              libraw_strerror(ret));
+      continue; // no recycle b/c open file will recycle itself
+    }
+
+    if ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot unpack %s: %s\n", argv[arg],
+              libraw_strerror(ret));
+      continue;
+    }
+    float qsec = timerend();
+    printf("\n%.1f msec for unpack\n", qsec);
+    float mpix, rmpix;
+    timerstart();
+    for (c = 0; c < rep; c++)
+    {
+      if ((ret = RawProcessor.dcraw_process()) != LIBRAW_SUCCESS)
+      {
+        fprintf(stderr, "Cannot postprocess %s: %s\n", argv[arg],
+                libraw_strerror(ret));
+        break;
+      }
+      libraw_processed_image_t *p = RawProcessor.dcraw_make_mem_image();
+      if (p)
+        RawProcessor.dcraw_clear_mem(p);
+      RawProcessor.free_image();
+    }
+    float msec = timerend() / (float)rep;
+
+    if ((ret = RawProcessor.adjust_sizes_info_only()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot adjust sizes for %s: %s\n", argv[arg],
+              libraw_strerror(ret));
+      break;
+    }
+    rmpix = (S.iwidth * S.iheight) / 1000000.0f;
+
+    if (c == rep) // no failure
+    {
+      unsigned int crop[4];
+      for (int i = 0; i < 4; i++)
+        crop[i] = (OUT.cropbox[i]) >> shrink;
+      if (crop[0] + crop[2] > S.iwidth)
+        crop[2] = S.iwidth - crop[0];
+      if (crop[1] + crop[3] > S.iheight)
+        crop[3] = S.iheight - crop[1];
+
+      mpix = float(crop[2] * crop[3]) / 1000000.0f;
+      float mpixsec = mpix * 1000.0f / msec;
+
+      printf("Performance: %.2f Mpix/sec\n"
+             "File: %s, Frame: %d %.1f total Mpix, %.1f msec\n"
+             "Params:      WB=%s Highlight=%d Qual=%d HalfSize=%s Median=%d "
+             "Wavelet=%.0f\n"
+             "Crop:        %u-%u:%ux%u, active Mpix: %.2f, %.1f frames/sec\n",
+             mpixsec, argv[arg], OUTR.shot_select, rmpix, msec,
+             OUT.use_auto_wb ? "auto" : "default", OUT.highlight, OUT.user_qual,
+             OUT.half_size ? "YES" : "No", OUT.med_passes, OUT.threshold,
+             crop[0], crop[1], crop[2], crop[3], mpix, 1000.0f / msec);
+    }
+  }
+
+  return 0;
+}
+
+#ifndef LIBRAW_WIN32_CALLS
+static struct timeval start, end;
+void timerstart(void) { gettimeofday(&start, NULL); }
+float timerend(void)
+{
+  gettimeofday(&end, NULL);
+  float msec = (end.tv_sec - start.tv_sec) * 1000.0f +
+               (end.tv_usec - start.tv_usec) / 1000.0f;
+  return msec;
+}
+#else
+LARGE_INTEGER start;
+void timerstart(void) { QueryPerformanceCounter(&start); }
+float timerend()
+{
+  LARGE_INTEGER unit, end;
+  QueryPerformanceCounter(&end);
+  QueryPerformanceFrequency(&unit);
+  float msec = (float)(end.QuadPart - start.QuadPart);
+  msec /= (float)unit.QuadPart / 1000.0f;
+  return msec;
+}
+
+#endif