/* -*- C++ -*-
 * File: identify.cpp
 * Copyright 2008-2025 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 "third_party/libraw/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, " %u", 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);
}