lightdrift-libraw 1.0.0-alpha.1

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

@@ -0,0 +1,670 @@
+/* -*- C++ -*-
+ * File: dcraw_emu.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Sun Mar 23,   2008
+ *
+ * LibRaw simple C++ API sample: almost complete dcraw emulator
+ *
+
+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).
+
+
+ */
+#ifdef _MSC_VER
+// suppress sprintf-related warning. sprintf() is permitted in sample code
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <ctype.h>
+
+#include "libraw/libraw.h"
+
+#ifndef LIBRAW_WIN32_CALLS
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#ifdef LIBRAW_WIN32_CALLS
+#define snprintf _snprintf
+#include <windows.h>
+#else
+#define O_BINARY 0
+#endif
+
+#ifdef USE_DNGSDK
+#include "dng_host.h"
+#include "dng_negative.h"
+#include "dng_simple_image.h"
+#include "dng_info.h"
+#endif
+
+void usage(const char *prog)
+{
+  printf("dcraw_emu: almost complete dcraw emulator\n");
+  printf("Usage:  %s [OPTION]... [FILE]...\n", prog);
+  printf("-c float-num       Set adjust maximum threshold (default 0.75)\n"
+         "-v        Verbose: print progress messages (repeated -v will add "
+         "verbosity)\n"
+         "-w        Use camera white balance, if possible\n"
+         "-a        Average the whole image for white balance\n"
+         "-A <x y w h> Average a grey box for white balance\n"
+         "-r <r g b g> Set custom white balance\n"
+         "+M/-M     Use/don't use an embedded color matrix\n"
+         "-C <r b>  Correct chromatic aberration\n"
+         "-P <file> Fix the dead pixels listed in this file\n"
+         "-K <file> Subtract dark frame (16-bit raw PGM)\n"
+         "-k <num>  Set the darkness level\n"
+         "-S <num>  Set the saturation level\n"
+         "-R <num>  Set raw processing options to num\n"
+         "-n <num>  Set threshold for wavelet denoising\n"
+         "-H [0-9]  Highlight mode (0=clip, 1=unclip, 2=blend, 3+=rebuild)\n"
+         "-t [0-7]  Flip image (0=none, 3=180, 5=90CCW, 6=90CW)\n"
+         "-o [0-8]  Output colorspace (raw,sRGB,Adobe,Wide,ProPhoto,XYZ,ACES,\n"
+         "          DCI-P3,Rec2020)\n"
+#ifndef NO_LCMS
+         "-o file   Output ICC profile\n"
+         "-p file   Camera input profile (use \'embed\' for embedded profile)\n"
+#endif
+         "-j        Don't stretch or rotate raw pixels\n"
+         "-W        Don't automatically brighten the image\n"
+         "-b <num>  Adjust brightness (default = 1.0)\n"
+         "-q N      Set the interpolation quality:\n"
+         "          0 - linear, 1 - VNG, 2 - PPG, 3 - AHD, 4 - DCB\n"
+         "          11 - DHT, 12 - AAHD\n"
+         "-h        Half-size color image (twice as fast as \"-q 0\")\n"
+         "-f        Interpolate RGGB as four colors\n"
+         "-m <num>  Apply a 3x3 median filter to R-G and B-G\n"
+         "-s [0..N-1] Select one raw image from input file\n"
+         "-4        Linear 16-bit, same as \"-6 -W -g 1 1\n"
+         "-6        Write 16-bit output\n"
+         "-g pow ts Set gamma curve to gamma pow and toe slope ts (default = "
+         "2.222 4.5)\n"
+         "-T        Write TIFF instead of PPM\n"
+         "-G        Use green_matching() filter\n"
+         "-B <x y w h> use cropbox\n"
+         "-F        Use FILE I/O instead of streambuf API\n"
+         "-Z <suf>  Output filename generation rules\n"
+         "          .suf => append .suf to input name, keeping existing suffix "
+         "too\n"
+         "           suf => replace input filename last extension\n"
+         "          - => output to stdout\n"
+         "          filename.suf => output to filename.suf\n"
+         "-timing   Detailed timing report\n"
+         "-fbdd N   0 - disable FBDD noise reduction (default), 1 - light "
+         "FBDD, 2 - full\n"
+         "-dcbi N   Number of extra DCD iterations (default - 0)\n"
+         "-dcbe     DCB color enhance\n"
+         "-aexpo <e p> exposure correction\n"
+         "-apentax4shot enables merge of 4-shot pentax files\n"
+         "-apentax4shotorder 3102 sets pentax 4-shot alignment order\n"
+#ifdef USE_RAWSPEED_BITS
+         "-arsbits V Set use_rawspeed to V\n"
+#endif
+         "-mmap     Use memory mmaped buffer instead of plain FILE I/O\n"
+         "-mem	   Use memory buffer instead of FILE I/O\n"
+         "-disars   Do not use RawSpeed library\n"
+         "-disinterp Do not run interpolation step\n"
+         "-dsrawrgb1 Disable YCbCr to RGB conversion for sRAW (Cb/Cr "
+         "interpolation enabled)\n"
+         "-dsrawrgb2 Disable YCbCr to RGB conversion for sRAW (Cb/Cr "
+         "interpolation disabled)\n"
+#ifdef USE_DNGSDK
+         "-dngsdk   Use Adobe DNG SDK for DNG decode\n"
+         "-dngflags N set DNG decoding options to value N\n"
+#endif
+         "-doutputflags N set params.output_flags to N\n"
+  );
+  exit(1);
+}
+
+static int verbosity = 0;
+int cnt = 0;
+int my_progress_callback(void *d, enum LibRaw_progress p, int iteration,
+                         int expected)
+{
+  char *passed = (char *)(d ? d : "default string"); // data passed to callback
+                                                     // at set_callback stage
+
+  if (verbosity > 2) // verbosity set by repeat -v switches
+  {
+    printf("CB: %s  pass %d of %d (data passed=%s)\n", libraw_strprogress(p),
+           iteration, expected, passed);
+  }
+  else if (iteration == 0) // 1st iteration of each step
+    printf("Starting %s (expecting %d iterations)\n", libraw_strprogress(p),
+           expected);
+  else if (iteration == expected - 1)
+    printf("%s finished\n", libraw_strprogress(p));
+
+  ///    if(++cnt>10) return 1; // emulate user termination on 10-th callback
+  ///    call
+
+  return 0; // always return 0 to continue processing
+}
+
+// timer
+#ifndef LIBRAW_WIN32_CALLS
+static struct timeval start, end;
+void timerstart(void) { gettimeofday(&start, NULL); }
+void timerprint(const char *msg, const char *filename)
+{
+  gettimeofday(&end, NULL);
+  float msec = (end.tv_sec - start.tv_sec) * 1000.0f +
+               (end.tv_usec - start.tv_usec) / 1000.0f;
+  printf("Timing: %s/%s: %6.3f msec\n", filename, msg, msec);
+}
+#else
+LARGE_INTEGER start;
+void timerstart(void) { QueryPerformanceCounter(&start); }
+void timerprint(const char *msg, const char *filename)
+{
+  LARGE_INTEGER unit, end;
+  QueryPerformanceCounter(&end);
+  QueryPerformanceFrequency(&unit);
+  float msec = (float)(end.QuadPart - start.QuadPart);
+  msec /= (float)unit.QuadPart / 1000.0f;
+  printf("Timing: %s/%s: %6.3f msec\n", filename, msg, msec);
+}
+
+#endif
+
+struct file_mapping
+{
+	void *map;
+	INT64 fsize;
+#ifdef LIBRAW_WIN32_CALLS
+	HANDLE fd, fd_map;
+	file_mapping() : map(0), fsize(0), fd(INVALID_HANDLE_VALUE), fd_map(INVALID_HANDLE_VALUE){}
+#else
+	int  fd;
+	file_mapping() : map(0), fsize(0), fd(-1){}
+#endif
+};
+
+void create_mapping(struct file_mapping& data, const std::string& fn)
+{
+#ifdef LIBRAW_WIN32_CALLS
+	std::wstring fpath(fn.begin(), fn.end());
+	if ((data.fd = CreateFileW(fpath.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) == INVALID_HANDLE_VALUE) return;
+	LARGE_INTEGER fs;
+	if (!GetFileSizeEx(data.fd, &fs)) return;
+	data.fsize = fs.QuadPart;
+	if ((data.fd_map = ::CreateFileMapping(data.fd, 0, PAGE_READONLY, fs.HighPart, fs.LowPart, 0)) == INVALID_HANDLE_VALUE) return;
+	data.map = MapViewOfFile(data.fd_map, FILE_MAP_READ, 0, 0, data.fsize);
+#else
+	struct stat stt;
+	if ((data.fd = open(fn.c_str(), O_RDONLY)) < 0) return;
+	if (fstat(data.fd, &stt) != 0) return;
+	data.fsize = stt.st_size;
+	data.map = mmap(0, data.fsize, PROT_READ | PROT_WRITE, MAP_PRIVATE, data.fd, 0);
+	return;
+#endif
+}
+
+void close_mapping(struct file_mapping& data)
+{
+#ifdef LIBRAW_WIN32_CALLS
+	if (data.map) UnmapViewOfFile(data.map);
+	if (data.fd_map != INVALID_HANDLE_VALUE) CloseHandle(data.fd_map);
+	if (data.fd != INVALID_HANDLE_VALUE) CloseHandle(data.fd);
+	data.map = 0;
+	data.fsize = 0;
+	data.fd = data.fd_map = INVALID_HANDLE_VALUE;
+#else
+	if (data.map)
+		munmap(data.map, data.fsize);
+	if (data.fd >= 0)
+		close(data.fd);
+	data.map = 0;
+	data.fsize = 0;
+	data.fd = -1;
+#endif
+}
+
+
+int main(int argc, char *argv[])
+{
+  if (argc == 1)
+    usage(argv[0]);
+
+  LibRaw RawProcessor;
+  int i, arg, c, ret;
+  char opm, opt, *cp, *sp;
+  int use_timing = 0, use_mem = 0, use_mmap = 0;
+  char *outext = NULL;
+#ifdef USE_DNGSDK
+  dng_host *dnghost = NULL;
+#endif
+  struct file_mapping mapping;
+  void *iobuffer = 0;
+#ifdef OUT
+#undef OUT
+#endif
+#define OUT RawProcessor.imgdata.params
+#define OUTR RawProcessor.imgdata.rawparams
+
+  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 *)"cnbrkStqmHABCgU", opt)) != 0)
+      for (i = 0; i < "111411111144221"[cp - sp] - '0'; i++)
+        if (!isdigit(argv[arg + i][0]) && !optstr[2])
+        {
+          fprintf(stderr, "Non-numeric argument to \"-%c\"\n", opt);
+          return 1;
+        }
+    if (!strchr("ftdeam", opt) && argv[arg - 1][2]) {
+      fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      continue;
+    }
+    switch (opt)
+    {
+    case 'v':
+      verbosity++;
+      break;
+    case 'G':
+      OUT.green_matching = 1;
+      break;
+    case 'c':
+      OUT.adjust_maximum_thr = (float)atof(argv[arg++]);
+      break;
+    case 'U':
+      OUT.auto_bright_thr = (float)atof(argv[arg++]);
+      break;
+    case 'n':
+      OUT.threshold = (float)atof(argv[arg++]);
+      break;
+    case 'b':
+      OUT.bright = (float)atof(argv[arg++]);
+      break;
+    case 'P':
+      OUT.bad_pixels = argv[arg++];
+      break;
+    case 'K':
+      OUT.dark_frame = argv[arg++];
+      break;
+    case 'r':
+      for (c = 0; c < 4; c++)
+        OUT.user_mul[c] = (float)atof(argv[arg++]);
+      break;
+    case 'C':
+      OUT.aber[0] = 1 / atof(argv[arg++]);
+      OUT.aber[2] = 1 / atof(argv[arg++]);
+      break;
+    case 'g':
+      OUT.gamm[0] = 1 / atof(argv[arg++]);
+      OUT.gamm[1] = atof(argv[arg++]);
+      break;
+    case 'k':
+      OUT.user_black = atoi(argv[arg++]);
+      break;
+    case 'S':
+      OUT.user_sat = atoi(argv[arg++]);
+      break;
+    case 'R':
+      OUTR.options = atoi(argv[arg++]);
+      break;
+    case 't':
+      if (!strcmp(optstr, "-timing"))
+        use_timing = 1;
+      else if (!argv[arg - 1][2])
+        OUT.user_flip = atoi(argv[arg++]);
+      else
+        fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      break;
+    case 'q':
+      OUT.user_qual = atoi(argv[arg++]);
+      break;
+    case 'm':
+      if (!strcmp(optstr, "-mmap"))
+        use_mmap = 1;
+      else
+          if (!strcmp(optstr, "-mem"))
+        use_mem = 1;
+      else
+      {
+        if (!argv[arg - 1][2])
+          OUT.med_passes = atoi(argv[arg++]);
+        else
+          fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      }
+      break;
+    case 'H':
+      OUT.highlight = atoi(argv[arg++]);
+      break;
+    case 's':
+      OUTR.shot_select = abs(atoi(argv[arg++]));
+      break;
+    case 'o':
+      if (isdigit(argv[arg][0]) && !isdigit(argv[arg][1]))
+        OUT.output_color = atoi(argv[arg++]);
+#ifndef NO_LCMS
+      else
+        OUT.output_profile = argv[arg++];
+      break;
+    case 'p':
+      OUT.camera_profile = argv[arg++];
+#endif
+      break;
+    case 'h':
+      OUT.half_size = 1;
+      break;
+    case 'f':
+      if (!strcmp(optstr, "-fbdd"))
+        OUT.fbdd_noiserd = atoi(argv[arg++]);
+      else
+      {
+        if (!argv[arg - 1][2])
+          OUT.four_color_rgb = 1;
+        else
+          fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      }
+      break;
+    case 'A':
+      for (c = 0; c < 4; c++)
+        OUT.greybox[c] = atoi(argv[arg++]);
+      break;
+    case 'B':
+      for (c = 0; c < 4; c++)
+        OUT.cropbox[c] = atoi(argv[arg++]);
+      break;
+    case 'a':
+      if (!strcmp(optstr, "-aexpo"))
+      {
+        OUT.exp_correc = 1;
+        OUT.exp_shift = (float)atof(argv[arg++]);
+        OUT.exp_preser = (float)atof(argv[arg++]);
+      }
+#ifdef USE_RAWSPEED_BITS
+      else if (!strcmp(optstr, "-arsbits"))
+      {
+	OUTR.use_rawspeed = atoi(argv[arg++]);
+      }
+#endif
+      else if (!strcmp(optstr, "-apentax4shot"))
+      {
+        OUTR.options |= LIBRAW_RAWOPTIONS_PENTAX_PS_ALLFRAMES;
+      }
+      else if (!strcmp(optstr, "-apentax4shotorder"))
+      {
+        strncpy(OUTR.p4shot_order, argv[arg++], 5);
+      }
+      else if (!argv[arg - 1][2])
+        OUT.use_auto_wb = 1;
+      else
+        fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      break;
+    case 'w':
+      OUT.use_camera_wb = 1;
+      break;
+    case 'M':
+      OUT.use_camera_matrix = (opm == '+')?3:0;
+      break;
+    case 'j':
+      OUT.use_fuji_rotate = 0;
+      break;
+    case 'W':
+      OUT.no_auto_bright = 1;
+      break;
+    case 'T':
+      OUT.output_tiff = 1;
+      break;
+    case '4':
+      OUT.gamm[0] = OUT.gamm[1] = OUT.no_auto_bright = 1; /* no break here! */
+    case '6':
+      OUT.output_bps = 16;
+      break;
+    case 'Z':
+      outext = strdup(argv[arg++]);
+      break;
+    case 'd':
+      if (!strcmp(optstr, "-dcbi"))
+        OUT.dcb_iterations = atoi(argv[arg++]);
+      else if (!strcmp(optstr, "-doutputflags"))
+        OUT.output_flags = atoi(argv[arg++]);
+      else if (!strcmp(optstr, "-disars"))
+        OUTR.use_rawspeed = 0;
+      else if (!strcmp(optstr, "-disinterp"))
+        OUT.no_interpolation = 1;
+      else if (!strcmp(optstr, "-dcbe"))
+        OUT.dcb_enhance_fl = 1;
+      else if (!strcmp(optstr, "-dsrawrgb1"))
+      {
+        OUTR.specials |= LIBRAW_RAWSPECIAL_SRAW_NO_RGB;
+        OUTR.specials &= ~LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE;
+      }
+      else if (!strcmp(optstr, "-dsrawrgb2"))
+      {
+        OUTR.specials &= ~LIBRAW_RAWSPECIAL_SRAW_NO_RGB;
+        OUTR.specials |= LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE;
+      }
+#ifdef USE_DNGSDK
+      else if (!strcmp(optstr, "-dngsdk"))
+      {
+        dnghost = new dng_host;
+        RawProcessor.set_dng_host(dnghost);
+      }
+      else if (!strcmp(optstr, "-dngflags"))
+      {
+        OUTR.use_dngsdk = atoi(argv[arg++]);
+      }
+#endif
+      else
+        fprintf(stderr, "Unknown option \"%s\".\n", argv[arg - 1]);
+      break;
+    default:
+      fprintf(stderr, "Unknown option \"-%c\".\n", opt);
+      break;
+    }
+  }
+#ifndef LIBRAW_WIN32_CALLS
+  putenv((char *)"TZ=UTC"); // dcraw compatibility, affects TIFF datestamp field
+#else
+  _putenv(
+      (char *)"TZ=UTC"); // dcraw compatibility, affects TIFF datestamp field
+#endif
+#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
+
+  if (outext && !strcmp(outext, "-"))
+    use_timing = verbosity = 0;
+
+  if (verbosity > 1)
+    RawProcessor.set_progress_handler(my_progress_callback,
+                                      (void *)"Sample data passed");
+#ifdef LIBRAW_USE_OPENMP
+  if (verbosity)
+    printf("Using %d threads\n", omp_get_max_threads());
+#endif
+
+  int done = 0;
+  int total = argc - arg;
+  for (; arg < argc; arg++)
+  {
+    char outfn[1024];
+
+    if (verbosity)
+      printf("Processing file %s\n", argv[arg]);
+
+    timerstart();
+
+	if (use_mmap)
+	{
+		create_mapping(mapping, argv[arg]);
+		if (!mapping.map)
+		{
+			fprintf(stderr, "Cannot map %s\n", argv[arg]);
+			close_mapping(mapping);
+			continue;
+		}
+      if ((ret = RawProcessor.open_buffer(mapping.map,mapping.fsize) !=
+                 LIBRAW_SUCCESS))
+      {
+        fprintf(stderr, "Cannot open_buffer %s: %s\n", argv[arg], libraw_strerror(ret));
+		close_mapping(mapping);
+        continue; // no recycle b/c open file will recycle itself
+      }
+    }
+    else  if (use_mem)
+    {
+      int file = open(argv[arg], O_RDONLY | O_BINARY);
+      struct stat st;
+      if (file < 0)
+      {
+        fprintf(stderr, "Cannot open %s: %s\n", argv[arg], strerror(errno));
+        continue;
+      }
+      if (fstat(file, &st))
+      {
+        fprintf(stderr, "Cannot stat %s: %s\n", argv[arg], strerror(errno));
+        close(file);
+        continue;
+      }
+      if (!(iobuffer = malloc(st.st_size)))
+      {
+        fprintf(stderr, "Cannot allocate %d kbytes for memory buffer\n",
+                (int)(st.st_size / 1024));
+        close(file);
+        continue;
+      }
+      int rd;
+      if (st.st_size != (rd = read(file, iobuffer, st.st_size)))
+      {
+        fprintf(stderr,
+                "Cannot read %d bytes instead of  %d to memory buffer\n",
+                (int)rd, (int)st.st_size);
+        close(file);
+        free(iobuffer);
+        continue;
+      }
+      close(file);
+      if ((ret = RawProcessor.open_buffer(iobuffer, st.st_size)) !=
+          LIBRAW_SUCCESS)
+      {
+        fprintf(stderr, "Cannot open_buffer %s: %s\n", argv[arg],
+                libraw_strerror(ret));
+        free(iobuffer);
+        continue; // no recycle b/c open file will recycle itself
+      }
+    }
+    else
+    {
+        ret = RawProcessor.open_file(argv[arg]);
+
+      if (ret != LIBRAW_SUCCESS)
+      {
+        fprintf(stderr, "Cannot open %s: %s\n", argv[arg],
+                libraw_strerror(ret));
+        continue; // no recycle b/c open_file will recycle itself
+      }
+    }
+
+    if (use_timing)
+      timerprint("LibRaw::open_file()", argv[arg]);
+
+    timerstart();
+    if ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot unpack %s: %s\n", argv[arg],
+              libraw_strerror(ret));
+      continue;
+    }
+
+    if (use_timing)
+      timerprint("LibRaw::unpack()", argv[arg]);
+
+    timerstart();
+    if (LIBRAW_SUCCESS != (ret = RawProcessor.dcraw_process()))
+    {
+      fprintf(stderr, "Cannot do postprocessing on %s: %s\n", argv[arg],
+              libraw_strerror(ret));
+      if (LIBRAW_FATAL_ERROR(ret))
+        continue;
+    }
+    if (use_timing)
+      timerprint("LibRaw::dcraw_process()", argv[arg]);
+
+    if (!outext)
+      snprintf(outfn, sizeof(outfn), "%s.%s", argv[arg],
+               OUT.output_tiff ? "tiff" : (P1.colors > 1 ? "ppm" : "pgm"));
+    else if (!strcmp(outext, "-"))
+      snprintf(outfn, sizeof(outfn), "-");
+    else
+    {
+      if (*outext == '.') // append
+        snprintf(outfn, sizeof(outfn), "%s%s", argv[arg], outext);
+      else if (strchr(outext, '.') && *outext != '.') // dot is not 1st char
+        strncpy(outfn, outext, sizeof(outfn));
+      else
+      {
+        strncpy(outfn, argv[arg], sizeof(outfn));
+        if (strlen(outfn) > 0)
+        {
+          char *lastchar = outfn + strlen(outfn); // points to term 0
+          while (--lastchar > outfn)
+          {
+            if (*lastchar == '/' || *lastchar == '\\')
+              break;
+            if (*lastchar == '.')
+            {
+              *lastchar = 0;
+              break;
+            };
+          }
+        }
+        strncat(outfn, ".", sizeof(outfn) - strlen(outfn) - 1);
+        strncat(outfn, outext, sizeof(outfn) - strlen(outfn) - 1);
+      }
+    }
+
+    if (verbosity)
+    {
+      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));
+    else
+      done++;
+
+	RawProcessor.recycle(); // just for show this call
+
+	if (use_mmap && mapping.map)
+		close_mapping(mapping);
+    else if (use_mem && iobuffer)
+    {
+      free(iobuffer);
+      iobuffer = 0;
+    }
+  }
+#ifdef USE_DNGSDK
+  if (dnghost)
+    delete dnghost;
+#endif
+  if (total == 0)
+    return 1;
+  if (done < total)
+    return 2;
+  return 0;
+}