File indexing completed on 2025-01-05 03:56:48

 /* -*- 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;
 }