lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/samples/raw-identify.cpp

@@ -0,0 +1,743 @@
+/* -*- C++ -*-
+ * File: identify.cpp
+ * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
+ * Created: Sat Mar  8, 2008
+ *
+ * LibRaw C++ demo: emulates dcraw -i [-v]
+ *
+
+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 <string>
+#include <list>
+
+#include "libraw/libraw.h"
+
+#ifdef LIBRAW_WIN32_CALLS
+#define snprintf _snprintf
+#define strcasecmp stricmp
+#define strncasecmp strnicmp
+#endif
+
+#ifndef LIBRAW_WIN32_CALLS
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#ifndef MAX_PATH
+#ifdef PATH_MAX
+#define MAX_PATH PATH_MAX
+#else
+#define MAX_PATH 4096
+#endif
+#endif
+#endif
+
+#ifdef _MSC_VER
+#if _MSC_VER < 1800 /* below MSVC 2013 */
+float roundf(float f) { return floorf(f + 0.5); }
+
+#endif
+#endif
+
+#define P1 MyCoolRawProcessor.imgdata.idata
+#define P2 MyCoolRawProcessor.imgdata.other
+#define P3 MyCoolRawProcessor.imgdata.makernotes.common
+
+#define mnLens MyCoolRawProcessor.imgdata.lens.makernotes
+#define exifLens MyCoolRawProcessor.imgdata.lens
+#define ShootingInfo MyCoolRawProcessor.imgdata.shootinginfo
+
+#define S MyCoolRawProcessor.imgdata.sizes
+#define O MyCoolRawProcessor.imgdata.params
+#define C MyCoolRawProcessor.imgdata.color
+#define T MyCoolRawProcessor.imgdata.thumbnail
+
+void print_verbose(FILE *, LibRaw &MyCoolRawProcessor, std::string &fn);
+void print_wbfun(FILE *, LibRaw &MyCoolRawProcessor, std::string &fn);
+void print_szfun(FILE *, LibRaw &MyCoolRawProcessor, std::string &fn);
+void print_unpackfun(FILE *, LibRaw &MyCoolRawProcessor, int print_frame, std::string &fn);
+
+/*
+table of fluorescents:
+12 = FL-D; Daylight fluorescent (D 5700K – 7100K) (F1,F5)
+13 = FL-N; Day white fluorescent (N 4600K – 5400K) (F7,F8)
+14 = FL-W; Cool white fluorescent (W 3900K – 4500K) (F2,F6, office,
+store,warehouse) 15 = FL-WW; White fluorescent (WW 3200K – 3700K) (F3,
+residential) 16 = FL-L; Soft/Warm white fluorescent (L 2600K - 3250K) (F4,
+kitchen, bath)
+*/
+
+static const struct
+{
+  const int NumId;
+  const char *StrId;
+  const char *hrStrId; // human-readable
+  const int aux_setting;
+} WBToStr[] = {
+    {LIBRAW_WBI_Unknown, "WBI_Unknown", "Unknown", 0},
+    {LIBRAW_WBI_Daylight, "WBI_Daylight", "Daylight", 0},
+    {LIBRAW_WBI_Fluorescent, "WBI_Fluorescent", "Fluorescent", 0},
+    {LIBRAW_WBI_Tungsten, "WBI_Tungsten", "Tungsten (Incandescent)", 0},
+    {LIBRAW_WBI_Flash, "WBI_Flash", "Flash", 0},
+    {LIBRAW_WBI_FineWeather, "WBI_FineWeather", "Fine Weather", 0},
+    {LIBRAW_WBI_Cloudy, "WBI_Cloudy", "Cloudy", 0},
+    {LIBRAW_WBI_Shade, "WBI_Shade", "Shade", 0},
+    {LIBRAW_WBI_FL_D, "WBI_FL_D", "Daylight Fluorescent", 0},
+    {LIBRAW_WBI_FL_N, "WBI_FL_N", "Day White Fluorescent", 0},
+    {LIBRAW_WBI_FL_W, "WBI_FL_W", "Cool White Fluorescent", 0},
+    {LIBRAW_WBI_FL_WW, "WBI_FL_WW", "White Fluorescent", 0},
+    {LIBRAW_WBI_FL_L, "WBI_FL_L", "Warm White Fluorescent", 0},
+    {LIBRAW_WBI_Ill_A, "WBI_Ill_A", "Illuminant A", 0},
+    {LIBRAW_WBI_Ill_B, "WBI_Ill_B", "Illuminant B", 0},
+    {LIBRAW_WBI_Ill_C, "WBI_Ill_C", "Illuminant C", 0},
+    {LIBRAW_WBI_D55, "WBI_D55", "D55", 0},
+    {LIBRAW_WBI_D65, "WBI_D65", "D65", 0},
+    {LIBRAW_WBI_D75, "WBI_D75", "D75", 0},
+    {LIBRAW_WBI_D50, "WBI_D50", "D50", 0},
+    {LIBRAW_WBI_StudioTungsten, "WBI_StudioTungsten", "ISO Studio Tungsten", 0},
+    {LIBRAW_WBI_BW, "WBI_BW", "BW", 0},
+    {LIBRAW_WBI_Other, "WBI_Other", "Other", 0},
+    {LIBRAW_WBI_Sunset, "WBI_Sunset", "Sunset", 1},
+    {LIBRAW_WBI_Underwater, "WBI_Underwater", "Underwater", 1},
+    {LIBRAW_WBI_FluorescentHigh, "WBI_FluorescentHigh", "Fluorescent High", 1},
+    {LIBRAW_WBI_HT_Mercury, "WBI_HT_Mercury", "HT Mercury", 1},
+    {LIBRAW_WBI_AsShot, "WBI_AsShot", "As Shot", 1},
+    {LIBRAW_WBI_Measured, "WBI_Measured", "Camera Measured", 1},
+    {LIBRAW_WBI_Auto, "WBI_Auto", "Camera Auto", 1},
+    {LIBRAW_WBI_Auto1, "WBI_Auto1", "Camera Auto 1", 1},
+    {LIBRAW_WBI_Auto2, "WBI_Auto2", "Camera Auto 2", 1},
+    {LIBRAW_WBI_Auto3, "WBI_Auto3", "Camera Auto 3", 1},
+    {LIBRAW_WBI_Auto4, "WBI_Auto4", "Camera Auto 4", 1},
+    {LIBRAW_WBI_Custom, "WBI_Custom", "Custom", 1},
+    {LIBRAW_WBI_Custom1, "WBI_Custom1", "Custom 1", 1},
+    {LIBRAW_WBI_Custom2, "WBI_Custom2", "Custom 2", 1},
+    {LIBRAW_WBI_Custom3, "WBI_Custom3", "Custom 3", 1},
+    {LIBRAW_WBI_Custom4, "WBI_Custom4", "Custom 4", 1},
+    {LIBRAW_WBI_Custom5, "WBI_Custom5", "Custom 5", 1},
+    {LIBRAW_WBI_Custom6, "WBI_Custom6", "Custom 6", 1},
+    {LIBRAW_WBI_PC_Set1, "WBI_PC_Set1", "PC Set 1", 1},
+    {LIBRAW_WBI_PC_Set2, "WBI_PC_Set2", "PC Set 2", 1},
+    {LIBRAW_WBI_PC_Set3, "WBI_PC_Set3", "PC Set 3", 1},
+    {LIBRAW_WBI_PC_Set4, "WBI_PC_Set4", "PC Set 4", 1},
+    {LIBRAW_WBI_PC_Set5, "WBI_PC_Set5", "PC Set 5", 1},
+    {LIBRAW_WBI_Kelvin, "WBI_Kelvin", "Kelvin", 1},
+};
+
+const char *WB_idx2str(unsigned WBi)
+{
+  for (int i = 0; i < int(sizeof WBToStr / sizeof *WBToStr); i++)
+    if (WBToStr[i].NumId == (int)WBi)
+      return WBToStr[i].StrId;
+  return 0;
+}
+
+const char *WB_idx2hrstr(unsigned WBi)
+{
+  for (int i = 0; i < int(sizeof WBToStr / sizeof *WBToStr); i++)
+    if (WBToStr[i].NumId == (int)WBi)
+      return WBToStr[i].hrStrId;
+  return 0;
+}
+
+double _log2(double a)
+{
+  if(a > 0.00000000001) return log(a)/log(2.0);
+  return -1000;
+}
+
+void trimSpaces(char *s)
+{
+  char *p = s;
+  if (!strncasecmp(p, "NO=", 3))
+    p = p + 3; /* fix for Nikon D70, D70s */
+  int l = strlen(p);
+  if (!l)
+    return;
+  while (isspace(p[l - 1]))
+    p[--l] = 0; /* trim trailing spaces */
+  while (*p && isspace(*p))
+    ++p, --l; /* trim leading spaces */
+  memmove(s, p, l + 1);
+}
+
+void print_usage(const char *pname)
+{
+  printf("Usage: %s [options] inputfiles\n", pname);
+  printf("Options:\n"
+         "\t-v\tverbose output\n"
+         "\t-w\tprint white balance\n"
+         "\t-u\tprint unpack function\n"
+         "\t-f\tprint frame size (only w/ -u)\n"
+         "\t-s\tprint output image size\n"
+         "\t-h\tforce half-size mode (only for -s)\n"
+         "\t-M\tdisable use of raw-embedded color data\n"
+         "\t+M\tforce use of raw-embedded color data\n"
+         "\t-L filename\tread input files list from filename\n"
+         "\t-o filename\toutput to filename\n");
+}
+
+int main(int ac, char *av[])
+{
+  int ret;
+  int verbose = 0, print_sz = 0, print_unpack = 0, print_frame = 0, print_wb = 0;
+  LibRaw MyCoolRawProcessor;
+  char *filelistfile = NULL;
+  char *outputfilename = NULL;
+  FILE *outfile = stdout;
+  std::vector<std::string> filelist;
+
+  filelist.reserve(ac - 1);
+
+  for (int i = 1; i < ac; i++)
+  {
+    if (av[i][0] == '-')
+    {
+      if (!strcmp(av[i], "-v"))
+        verbose++;
+      if (!strcmp(av[i], "-w"))
+        print_wb++;
+      if (!strcmp(av[i], "-u"))
+        print_unpack++;
+      if (!strcmp(av[i], "-s"))
+        print_sz++;
+      if (!strcmp(av[i], "-h"))
+        O.half_size = 1;
+      if (!strcmp(av[i], "-f"))
+        print_frame++;
+      if (!strcmp(av[i], "-M"))
+        MyCoolRawProcessor.imgdata.params.use_camera_matrix = 0;
+      if (!strcmp(av[i], "-L") && i < ac - 1)
+      {
+        filelistfile = av[i + 1];
+        i++;
+      }
+      if (!strcmp(av[i], "-o") && i < ac - 1)
+      {
+        outputfilename = av[i + 1];
+        i++;
+      }
+      continue;
+    }
+    else if (!strcmp(av[i], "+M"))
+    {
+      MyCoolRawProcessor.imgdata.params.use_camera_matrix = 3;
+      continue;
+    }
+    filelist.push_back(av[i]);
+  }
+  if (filelistfile)
+  {
+    char *p;
+    char path[MAX_PATH + 1];
+    FILE *f = fopen(filelistfile, "r");
+    if (f)
+    {
+      while (fgets(path, MAX_PATH, f))
+      {
+        if ((p = strchr(path, '\n')))
+          *p = 0;
+        if ((p = strchr(path, '\r')))
+          *p = 0;
+        filelist.push_back(path);
+      }
+      fclose(f);
+    }
+  }
+  if (filelist.size() < 1)
+  {
+    print_usage(av[0]);
+    return 1;
+  }
+  if (outputfilename)
+    outfile = fopen(outputfilename, "wt");
+
+  for (int i = 0; i < (int)filelist.size(); i++)
+  {
+    if ((ret = MyCoolRawProcessor.open_file(filelist[i].c_str())) != LIBRAW_SUCCESS)
+    {
+      fprintf(stderr, "Cannot decode %s: %s\n", filelist[i].c_str(), libraw_strerror(ret));
+      continue; // no recycle, open_file will recycle
+    }
+
+    if (print_sz)
+      print_szfun(outfile, MyCoolRawProcessor, filelist[i]);
+    else if (verbose)
+      print_verbose(outfile, MyCoolRawProcessor, filelist[i]);
+    else if (print_unpack)
+      print_unpackfun(outfile, MyCoolRawProcessor, print_frame, filelist[i]);
+    else if (print_wb)
+      print_wbfun(outfile, MyCoolRawProcessor, filelist[i]);
+    else
+      fprintf(outfile, "%s is a %s %s image.\n", filelist[i].c_str(), P1.make, P1.model);
+
+    MyCoolRawProcessor.recycle();
+  } // endfor
+  return 0;
+}
+
+#define PRINTMATRIX3x4(of, mat, clrs)                                                                                  \
+  do                                                                                                                   \
+  {                                                                                                                    \
+    for (int r = 0; r < 3; r++)                                                                                        \
+      if (clrs == 4)                                                                                                   \
+        fprintf(of, "%6.4f\t%6.4f\t%6.4f\t%6.4f\n", mat[r][0], mat[r][1], mat[r][2], mat[r][3]);                       \
+      else                                                                                                             \
+        fprintf(of, "%6.4f\t%6.4f\t%6.4f\n", mat[r][0], mat[r][1], mat[r][2]);                                         \
+  } while (0)
+
+#define PRINTMATRIX4x3(of, mat, clrs)                                                                                  \
+  do                                                                                                                   \
+  {                                                                                                                    \
+    for (int r = 0; r < clrs && r < 4; r++)                                                                            \
+      fprintf(of, "%6.4f\t%6.4f\t%6.4f\n", mat[r][0], mat[r][1], mat[r][2]);                                           \
+  } while (0)
+
+void print_verbose(FILE *outfile, LibRaw &MyCoolRawProcessor, std::string &fn)
+{
+  int WBi;
+  float denom;
+  int ret;
+
+  if ((ret = MyCoolRawProcessor.adjust_sizes_info_only()))
+  {
+    fprintf(outfile, "Cannot decode %s: %s\n", fn.c_str(), libraw_strerror(ret));
+    return; // no recycle, open_file will recycle
+  }
+
+  fprintf(outfile, "\nFilename: %s\n", fn.c_str());
+  if (C.OriginalRawFileName[0])
+    fprintf(outfile, "OriginalRawFileName: =%s=\n", C.OriginalRawFileName);
+  fprintf(outfile, "Timestamp: %s", ctime(&(P2.timestamp)));
+  fprintf(outfile, "Camera: %s %s ID: 0x%llx\n", P1.make, P1.model, mnLens.CamID);
+  fprintf(outfile, "Normalized Make/Model: =%s/%s= ", P1.normalized_make, P1.normalized_model);
+  fprintf(outfile, "CamMaker ID: %d\n", P1.maker_index);
+
+  {
+    int i = 0;
+    char sep[] = ", ";
+    if (C.UniqueCameraModel[0])
+    {
+      i++;
+      fprintf(outfile, "UniqueCameraModel: =%s=", C.UniqueCameraModel);
+    }
+    if (C.LocalizedCameraModel[0])
+    {
+      if (i)
+      {
+        fprintf(outfile, "%s", sep);
+        i++;
+      }
+      fprintf(outfile, "LocalizedCameraModel: =%s=", C.LocalizedCameraModel);
+    }
+    if (i)
+    {
+      fprintf(outfile, "\n");
+      i = 0;
+    }
+    if (C.ImageUniqueID[0])
+    {
+      if (i)
+        fprintf(outfile, "%s", sep);
+      i++;
+      fprintf(outfile, "ImageUniqueID: =%s=", C.ImageUniqueID);
+    }
+    if (C.RawDataUniqueID[0])
+    {
+      if (i)
+        fprintf(outfile, "%s", sep);
+      i++;
+      fprintf(outfile, "RawDataUniqueID: =%s=", C.RawDataUniqueID);
+    }
+    if (i)
+      fprintf(outfile, "\n");
+  }
+
+  if (ShootingInfo.BodySerial[0] && strcmp(ShootingInfo.BodySerial, "0"))
+  {
+    trimSpaces(ShootingInfo.BodySerial);
+    fprintf(outfile, "Body#: %s", ShootingInfo.BodySerial);
+  }
+  else if (C.model2[0] && (!strncasecmp(P1.normalized_make, "Kodak", 5)))
+  {
+    trimSpaces(C.model2);
+    fprintf(outfile, "Body#: %s", C.model2);
+  }
+  if (ShootingInfo.InternalBodySerial[0])
+  {
+    trimSpaces(ShootingInfo.InternalBodySerial);
+    fprintf(outfile, " BodyAssy#: %s", ShootingInfo.InternalBodySerial);
+  }
+  if (exifLens.LensSerial[0])
+  {
+    trimSpaces(exifLens.LensSerial);
+    fprintf(outfile, " Lens#: %s", exifLens.LensSerial);
+  }
+  if (exifLens.InternalLensSerial[0])
+  {
+    trimSpaces(exifLens.InternalLensSerial);
+    fprintf(outfile, " LensAssy#: %s", exifLens.InternalLensSerial);
+  }
+  if (P2.artist[0])
+    fprintf(outfile, " Owner: %s\n", P2.artist);
+  if (P1.dng_version)
+  {
+    fprintf(outfile, " DNG Version: ");
+    for (int i = 24; i >= 0; i -= 8)
+      fprintf(outfile, "%d%c", P1.dng_version >> i & 255, i ? '.' : '\n');
+  }
+  fprintf(outfile, "\nEXIF:\n");
+  fprintf(outfile, "\tMinFocal: %0.1f mm\n", exifLens.MinFocal);
+  fprintf(outfile, "\tMaxFocal: %0.1f mm\n", exifLens.MaxFocal);
+  fprintf(outfile, "\tMaxAp @MinFocal: f/%0.1f\n", exifLens.MaxAp4MinFocal);
+  fprintf(outfile, "\tMaxAp @MaxFocal: f/%0.1f\n", exifLens.MaxAp4MaxFocal);
+  fprintf(outfile, "\tCurFocal: %0.1f mm\n", P2.focal_len);
+  fprintf(outfile, "\tMaxAperture @CurFocal: f/%0.1f\n", exifLens.EXIF_MaxAp);
+  fprintf(outfile, "\tFocalLengthIn35mmFormat: %d mm\n", exifLens.FocalLengthIn35mmFormat);
+  fprintf(outfile, "\tLensMake: %s\n", exifLens.LensMake);
+  fprintf(outfile, "\tLens: %s\n", exifLens.Lens);
+  fprintf(outfile, "\n");
+
+  fprintf(outfile, "\nMakernotes:\n");
+  fprintf(outfile, "\tDriveMode: %d\n", ShootingInfo.DriveMode);
+  fprintf(outfile, "\tFocusMode: %d\n", ShootingInfo.FocusMode);
+  fprintf(outfile, "\tMeteringMode: %d\n", ShootingInfo.MeteringMode);
+  fprintf(outfile, "\tAFPoint: %d\n", ShootingInfo.AFPoint);
+  fprintf(outfile, "\tExposureMode: %d\n", ShootingInfo.ExposureMode);
+  fprintf(outfile, "\tExposureProgram: %d\n", ShootingInfo.ExposureProgram);
+  fprintf(outfile, "\tImageStabilization: %d\n", ShootingInfo.ImageStabilization);
+
+  fprintf(outfile, "\tLens: %s\n", mnLens.Lens);
+  fprintf(outfile, "\tLensFormat: %d, ", mnLens.LensFormat);
+
+  fprintf(outfile, "\tLensMount: %d, ", mnLens.LensMount);
+  fprintf(outfile, "\tFocalType: %d, ", mnLens.FocalType);
+  switch (mnLens.FocalType)
+  {
+  case LIBRAW_FT_UNDEFINED:
+    fprintf(outfile, "Undefined\n");
+    break;
+  case LIBRAW_FT_PRIME_LENS:
+    fprintf(outfile, "Prime lens\n");
+    break;
+  case LIBRAW_FT_ZOOM_LENS:
+    fprintf(outfile, "Zoom lens\n");
+    break;
+  default:
+    fprintf(outfile, "Unknown\n");
+    break;
+  }
+  fprintf(outfile, "\tLensFeatures_pre: %s\n", mnLens.LensFeatures_pre);
+  fprintf(outfile, "\tLensFeatures_suf: %s\n", mnLens.LensFeatures_suf);
+  fprintf(outfile, "\tMinFocal: %0.1f mm\n", mnLens.MinFocal);
+  fprintf(outfile, "\tMaxFocal: %0.1f mm\n", mnLens.MaxFocal);
+  fprintf(outfile, "\tMaxAp @MinFocal: f/%0.1f\n", mnLens.MaxAp4MinFocal);
+  fprintf(outfile, "\tMaxAp @MaxFocal: f/%0.1f\n", mnLens.MaxAp4MaxFocal);
+  fprintf(outfile, "\tMinAp @MinFocal: f/%0.1f\n", mnLens.MinAp4MinFocal);
+  fprintf(outfile, "\tMinAp @MaxFocal: f/%0.1f\n", mnLens.MinAp4MaxFocal);
+  fprintf(outfile, "\tMaxAp: f/%0.1f\n", mnLens.MaxAp);
+  fprintf(outfile, "\tMinAp: f/%0.1f\n", mnLens.MinAp);
+  fprintf(outfile, "\tCurFocal: %0.1f mm\n", mnLens.CurFocal);
+  fprintf(outfile, "\tCurAp: f/%0.1f\n", mnLens.CurAp);
+  fprintf(outfile, "\tMaxAp @CurFocal: f/%0.1f\n", mnLens.MaxAp4CurFocal);
+  fprintf(outfile, "\tMinAp @CurFocal: f/%0.1f\n", mnLens.MinAp4CurFocal);
+
+  if (exifLens.makernotes.FocalLengthIn35mmFormat > 1.0f)
+    fprintf(outfile, "\tFocalLengthIn35mmFormat: %0.1f mm\n", exifLens.makernotes.FocalLengthIn35mmFormat);
+
+  if (exifLens.nikon.EffectiveMaxAp > 0.1f)
+    fprintf(outfile, "\tEffectiveMaxAp: f/%0.1f\n", exifLens.nikon.EffectiveMaxAp);
+
+  if (exifLens.makernotes.LensFStops > 0.1f)
+    fprintf(outfile, "\tLensFStops @CurFocal: %0.2f\n", exifLens.makernotes.LensFStops);
+
+  fprintf(outfile, "\tTeleconverterID: %lld\n", mnLens.TeleconverterID);
+  fprintf(outfile, "\tTeleconverter: %s\n", mnLens.Teleconverter);
+  fprintf(outfile, "\tAdapterID: %lld\n", mnLens.AdapterID);
+  fprintf(outfile, "\tAdapter: %s\n", mnLens.Adapter);
+  fprintf(outfile, "\tAttachmentID: %lld\n", mnLens.AttachmentID);
+  fprintf(outfile, "\tAttachment: %s\n", mnLens.Attachment);
+  fprintf(outfile, "\n");
+
+  fprintf(outfile, "ISO speed: %d\n", (int)P2.iso_speed);
+  if (P3.real_ISO > 0.1f)
+    fprintf(outfile, "real ISO speed: %d\n", (int)P3.real_ISO);
+  fprintf(outfile, "Shutter: ");
+  if (P2.shutter > 0 && P2.shutter < 1)
+    P2.shutter = fprintf(outfile, "1/%0.1f\n", 1.0f / P2.shutter);
+  else if (P2.shutter >= 1)
+    fprintf(outfile, "%0.1f sec\n", P2.shutter);
+  else /* negative*/
+    fprintf(outfile, " negative value\n");
+  fprintf(outfile, "Aperture: f/%0.1f\n", P2.aperture);
+  fprintf(outfile, "Focal length: %0.1f mm\n", P2.focal_len);
+  if (P3.exifAmbientTemperature > -273.15f)
+    fprintf(outfile, "Ambient temperature (exif data): %6.2f° C\n", P3.exifAmbientTemperature);
+  if (P3.CameraTemperature > -273.15f)
+    fprintf(outfile, "Camera temperature: %6.2f° C\n", P3.CameraTemperature);
+  if (P3.SensorTemperature > -273.15f)
+    fprintf(outfile, "Sensor temperature: %6.2f° C\n", P3.SensorTemperature);
+  if (P3.SensorTemperature2 > -273.15f)
+    fprintf(outfile, "Sensor temperature2: %6.2f° C\n", P3.SensorTemperature2);
+  if (P3.LensTemperature > -273.15f)
+    fprintf(outfile, "Lens temperature: %6.2f° C\n", P3.LensTemperature);
+  if (P3.AmbientTemperature > -273.15f)
+    fprintf(outfile, "Ambient temperature: %6.2f° C\n", P3.AmbientTemperature);
+  if (P3.BatteryTemperature > -273.15f)
+    fprintf(outfile, "Battery temperature: %6.2f° C\n", P3.BatteryTemperature);
+  if (P3.FlashGN > 1.0f)
+    fprintf(outfile, "Flash Guide Number: %6.2f\n", P3.FlashGN);
+  fprintf(outfile, "Flash exposure compensation: %0.2f EV\n", P3.FlashEC);
+  if (C.profile)
+    fprintf(outfile, "Embedded ICC profile: yes, %d bytes\n", C.profile_length);
+  else
+    fprintf(outfile, "Embedded ICC profile: no\n");
+
+  if (C.dng_levels.baseline_exposure > -999.f)
+    fprintf(outfile, "Baseline exposure: %04.3f\n", C.dng_levels.baseline_exposure);
+
+  fprintf(outfile, "Number of raw images: %d\n", P1.raw_count);
+
+  if (S.pixel_aspect != 1)
+    fprintf(outfile, "Pixel Aspect Ratio: %0.6f\n", S.pixel_aspect);
+  if (T.tlength)
+    fprintf(outfile, "Thumb size:  %4d x %d\n", T.twidth, T.theight);
+  fprintf(outfile, "Full size:   %4d x %d\n", S.raw_width, S.raw_height);
+
+  if (S.raw_inset_crops[0].cwidth)
+  {
+    fprintf(outfile, "Raw inset, width x height: %4d x %d ", S.raw_inset_crops[0].cwidth, S.raw_inset_crops[0].cheight);
+    if (S.raw_inset_crops[0].cleft != 0xffff)
+      fprintf(outfile, "left: %d ", S.raw_inset_crops[0].cleft);
+    if (S.raw_inset_crops[0].ctop != 0xffff)
+      fprintf(outfile, "top: %d", S.raw_inset_crops[0].ctop);
+    fprintf(outfile, "\n");
+  }
+
+  fprintf(outfile, "Image size:  %4d x %d\n", S.width, S.height);
+  fprintf(outfile, "Output size: %4d x %d\n", S.iwidth, S.iheight);
+  fprintf(outfile, "Image flip: %d\n", S.flip);
+
+  fprintf(outfile, "Raw colors: %d", P1.colors);
+  if (P1.filters)
+  {
+    fprintf(outfile, "\nFilter pattern: ");
+    if (!P1.cdesc[3])
+      P1.cdesc[3] = 'G';
+    for (int i = 0; i < 16; i++)
+      putchar(P1.cdesc[MyCoolRawProcessor.fcol(i >> 1, i & 1)]);
+  }
+
+  if (C.black)
+  {
+    fprintf(outfile, "\nblack: %d", C.black);
+  }
+  if (C.cblack[0] != 0)
+  {
+    fprintf(outfile, "\ncblack[0 .. 3]:");
+    for (int c = 0; c < 4; c++)
+      fprintf(outfile, " %d", C.cblack[c]);
+  }
+  if ((C.cblack[4] * C.cblack[5]) > 0)
+  {
+    fprintf(outfile, "\nBlackLevelRepeatDim: %d x %d\n", C.cblack[4], C.cblack[5]);
+    int n = C.cblack[4] * C.cblack[5];
+    fprintf(outfile, "cblack[6 .. %d]:", 6 + n - 1);
+    for (int c = 6; c < 6 + n; c++)
+      fprintf(outfile, " %d", C.cblack[c]);
+  }
+
+  if (C.linear_max[0] != 0)
+  {
+    fprintf(outfile, "\nHighlight linearity limits:");
+    for (int c = 0; c < 4; c++)
+      fprintf(outfile, " %ld", C.linear_max[c]);
+  }
+
+  if (P1.colors > 1)
+  {
+    fprintf(outfile, "\nMakernotes WB data:               coeffs                  EVs");
+    if ((C.cam_mul[0] > 0) && (C.cam_mul[1] > 0))
+    {
+      fprintf(outfile, "\n  %-23s   %g %g %g %g   %5.2f %5.2f %5.2f %5.2f", "As shot", C.cam_mul[0], C.cam_mul[1],
+              C.cam_mul[2], C.cam_mul[3], roundf(_log2(C.cam_mul[0] / C.cam_mul[1]) * 100.0f) / 100.0f, 0.0f,
+              roundf(_log2(C.cam_mul[2] / C.cam_mul[1]) * 100.0f) / 100.0f,
+              C.cam_mul[3] ? roundf(_log2(C.cam_mul[3] / C.cam_mul[1]) * 100.0f) / 100.0f : 0.0f);
+    }
+
+    for (int cnt = 0; cnt < int(sizeof WBToStr / sizeof *WBToStr); cnt++)
+    {
+      WBi = WBToStr[cnt].NumId;
+      if ((C.WB_Coeffs[WBi][0] > 0) && (C.WB_Coeffs[WBi][1] > 0))
+      {
+        denom = (float)C.WB_Coeffs[WBi][1];
+        fprintf(outfile, "\n  %-23s   %4d %4d %4d %4d   %5.2f %5.2f %5.2f %5.2f", WBToStr[cnt].hrStrId,
+                C.WB_Coeffs[WBi][0], C.WB_Coeffs[WBi][1], C.WB_Coeffs[WBi][2], C.WB_Coeffs[WBi][3],
+                roundf(_log2((float)C.WB_Coeffs[WBi][0] / denom) * 100.0f) / 100.0f, 0.0f,
+                roundf(_log2((float)C.WB_Coeffs[WBi][2] / denom) * 100.0f) / 100.0f,
+                C.WB_Coeffs[3] ? roundf(_log2((float)C.WB_Coeffs[WBi][3] / denom) * 100.0f) / 100.0f : 0.0f);
+      }
+    }
+
+    if (C.rgb_cam[0][0] > 0.0001)
+    {
+      fprintf(outfile, "\n\nCamera2RGB matrix (mode: %d):\n", MyCoolRawProcessor.imgdata.params.use_camera_matrix);
+      PRINTMATRIX3x4(outfile, C.rgb_cam, P1.colors);
+    }
+
+    fprintf(outfile, "\nXYZ->CamRGB matrix:\n");
+    PRINTMATRIX4x3(outfile, C.cam_xyz, P1.colors);
+
+    for (int cnt = 0; cnt < 2; cnt++)
+    {
+      if (fabsf(C.P1_color[cnt].romm_cam[0]) > 0)
+      {
+        fprintf(outfile, "\nPhaseOne Matrix %d:\n", cnt + 1);
+        for (int i = 0; i < 3; i++)
+          fprintf(outfile, "%6.4f\t%6.4f\t%6.4f\n", C.P1_color[cnt].romm_cam[i * 3],
+                  C.P1_color[cnt].romm_cam[i * 3 + 1], C.P1_color[cnt].romm_cam[i * 3 + 2]);
+      }
+    }
+
+    if (fabsf(C.cmatrix[0][0]) > 0)
+    {
+      fprintf(outfile, "\ncamRGB -> sRGB Matrix:\n");
+      PRINTMATRIX3x4(outfile, C.cmatrix, P1.colors);
+    }
+
+    if (fabsf(C.ccm[0][0]) > 0)
+    {
+      fprintf(outfile, "\nColor Correction Matrix:\n");
+      PRINTMATRIX3x4(outfile, C.ccm, P1.colors);
+    }
+
+    for (int cnt = 0; cnt < 2; cnt++)
+    {
+      if (C.dng_color[cnt].illuminant != LIBRAW_WBI_None)
+      {
+        if (C.dng_color[cnt].illuminant <= LIBRAW_WBI_StudioTungsten)
+        {
+          fprintf(outfile, "\nDNG Illuminant %d: %s", cnt + 1, WB_idx2hrstr(C.dng_color[cnt].illuminant));
+        }
+        else if (C.dng_color[cnt].illuminant == LIBRAW_WBI_Other)
+        {
+          fprintf(outfile, "\nDNG Illuminant %d: Other", cnt + 1);
+        }
+        else
+        {
+          fprintf(outfile,
+                  "\nDNG Illuminant %d is out of EXIF LightSources range "
+                  "[0:24, 255]: %d",
+                  cnt + 1, C.dng_color[cnt].illuminant);
+        }
+      }
+    }
+
+    for (int n = 0; n < 2; n++)
+    {
+      if (fabsf(C.dng_color[n].colormatrix[0][0]) > 0)
+      {
+        fprintf(outfile, "\nDNG color matrix %d:\n", n + 1);
+        PRINTMATRIX4x3(outfile, C.dng_color[n].colormatrix, P1.colors);
+      }
+    }
+
+    for (int n = 0; n < 2; n++)
+    {
+      if (fabsf(C.dng_color[n].calibration[0][0]) > 0)
+      {
+        fprintf(outfile, "\nDNG calibration matrix %d:\n", n + 1);
+        for (int i = 0; i < P1.colors && i < 4; i++)
+        {
+          for (int j = 0; j < P1.colors && j < 4; j++)
+            fprintf(outfile, "%6.4f\t", C.dng_color[n].calibration[j][i]);
+          fprintf(outfile, "\n");
+        }
+      }
+    }
+
+    for (int n = 0; n < 2; n++)
+    {
+      if (fabsf(C.dng_color[n].forwardmatrix[0][0]) > 0)
+      {
+        fprintf(outfile, "\nDNG forward matrix %d:\n", n + 1);
+        PRINTMATRIX3x4(outfile, C.dng_color[n].forwardmatrix, P1.colors);
+      }
+    }
+
+    fprintf(outfile, "\nDerived D65 multipliers:");
+    for (int c = 0; c < P1.colors; c++)
+      fprintf(outfile, " %f", C.pre_mul[c]);
+    fprintf(outfile, "\n");
+  }
+}
+
+void print_wbfun(FILE *outfile, LibRaw &MyCoolRawProcessor, std::string &fn)
+{
+  int WBi;
+  float denom;
+  fprintf(outfile, "// %s %s\n", P1.make, P1.model);
+  for (int cnt = 0; cnt < int(sizeof WBToStr / sizeof *WBToStr); cnt++)
+  {
+    WBi = WBToStr[cnt].NumId;
+    if (C.WB_Coeffs[WBi][0] && C.WB_Coeffs[WBi][1] && !WBToStr[cnt].aux_setting)
+    {
+      denom = (float)C.WB_Coeffs[WBi][1];
+      fprintf(outfile, "{\"%s\", \"%s\", %s, {%6.5ff, 1.0f, %6.5ff, ", P1.normalized_make, P1.normalized_model,
+              WBToStr[cnt].StrId, C.WB_Coeffs[WBi][0] / denom, C.WB_Coeffs[WBi][2] / denom);
+      if (C.WB_Coeffs[WBi][1] == C.WB_Coeffs[WBi][3])
+        fprintf(outfile, "1.0f}},\n");
+      else
+        fprintf(outfile, "%6.5ff}},\n", C.WB_Coeffs[WBi][3] / denom);
+    }
+  }
+
+  for (int cnt = 0; cnt < 64; cnt++)
+    if (C.WBCT_Coeffs[cnt][0])
+    {
+      fprintf(outfile, "{\"%s\", \"%s\", %d, {%6.5ff, 1.0f, %6.5ff, ", P1.normalized_make, P1.normalized_model,
+              (int)C.WBCT_Coeffs[cnt][0], C.WBCT_Coeffs[cnt][1] / C.WBCT_Coeffs[cnt][2],
+              C.WBCT_Coeffs[cnt][3] / C.WBCT_Coeffs[cnt][2]);
+      if (C.WBCT_Coeffs[cnt][2] == C.WBCT_Coeffs[cnt][4])
+        fprintf(outfile, "1.0f}},\n");
+      else
+        fprintf(outfile, "%6.5ff}},\n", C.WBCT_Coeffs[cnt][4] / C.WBCT_Coeffs[cnt][2]);
+    }
+    else
+      break;
+  fprintf(outfile, "\n");
+}
+
+void print_szfun(FILE *outfile, LibRaw &MyCoolRawProcessor, std::string &fn)
+{
+  fprintf(outfile, "%s\t%s\t%s\t%d\t%d\n", fn.c_str(), P1.make, P1.model, S.width, S.height);
+}
+
+void print_unpackfun(FILE *outfile, LibRaw &MyCoolRawProcessor, int print_frame, std::string &fn)
+{
+  char frame[48] = "";
+  if (print_frame)
+  {
+    ushort right_margin = S.raw_width - S.width - S.left_margin;
+    ushort bottom_margin = S.raw_height - S.height - S.top_margin;
+    snprintf(frame, 48, "F=%dx%dx%dx%d RS=%dx%d", S.left_margin, S.top_margin, right_margin, bottom_margin, S.raw_width,
+             S.raw_height);
+  }
+  fprintf(outfile, "%s\t%s\t%s\t%s/%s\n", fn.c_str(), MyCoolRawProcessor.unpack_function_name(), frame, P1.make,
+          P1.model);
+}