/src/libraw/src/metadata/identify.cpp

Source
/* -*- C++ -*-
 * Copyright 2019-2026 LibRaw LLC (info@libraw.org)
 *
 LibRaw uses code from dcraw.c -- Dave Coffin's raw photo decoder,
 dcraw.c is copyright 1997-2018 by Dave Coffin, dcoffin a cybercom o net.
 LibRaw do not use RESTRICTED code from dcraw.c

 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 "../../internal/dcraw_defs.h"
#include "../../internal/libraw_cameraids.h"

// clang-format on
static const struct
{
    const int CorpId;
    const char *CorpName;
} CorpTable[] = {
    {LIBRAW_CAMERAMAKER_Agfa,           "AgfaPhoto"},
    {LIBRAW_CAMERAMAKER_Apple,          "Apple"},
    {LIBRAW_CAMERAMAKER_Broadcom,       "Broadcom"},
    {LIBRAW_CAMERAMAKER_Canon,          "Canon"},
    {LIBRAW_CAMERAMAKER_Casio,          "Casio"},
    {LIBRAW_CAMERAMAKER_CINE,           "CINE"},
    {LIBRAW_CAMERAMAKER_Epson,          "Epson"},
    {LIBRAW_CAMERAMAKER_Fujifilm,       "Fujifilm"},
    {LIBRAW_CAMERAMAKER_Mamiya,         "Mamiya"},
    {LIBRAW_CAMERAMAKER_Motorola,       "Motorola"},
    {LIBRAW_CAMERAMAKER_Kodak,          "Kodak"},
    {LIBRAW_CAMERAMAKER_Konica,         "Konica"},
    {LIBRAW_CAMERAMAKER_Minolta,        "Minolta"},
    {LIBRAW_CAMERAMAKER_Leica,          "Leica"},
    {LIBRAW_CAMERAMAKER_Nikon,          "Nikon"},
    {LIBRAW_CAMERAMAKER_Nokia,          "Nokia"},
    {LIBRAW_CAMERAMAKER_Olympus,        "Olympus"},
    {LIBRAW_CAMERAMAKER_OmDigital,      "OM Digital"},
    {LIBRAW_CAMERAMAKER_Ricoh,          "Ricoh"},
    {LIBRAW_CAMERAMAKER_Pentax,         "Pentax"},
    {LIBRAW_CAMERAMAKER_PhaseOne,       "Phase One"},
    {LIBRAW_CAMERAMAKER_PhaseOne,       "PhaseOne"},
    {LIBRAW_CAMERAMAKER_Samsung,        "Samsung"},
    {LIBRAW_CAMERAMAKER_Sigma,          "Sigma"},
    {LIBRAW_CAMERAMAKER_Sinar,          "Sinar"},
    {LIBRAW_CAMERAMAKER_Sony,           "Sony"},
    {LIBRAW_CAMERAMAKER_YI,             "YI"},
    // add corp. names below
    {LIBRAW_CAMERAMAKER_Alcatel,        "Alcatel"},
    {LIBRAW_CAMERAMAKER_Aptina,         "Aptina"},
    {LIBRAW_CAMERAMAKER_AVT,            "AVT"},
    {LIBRAW_CAMERAMAKER_Baumer,         "Baumer"},
    {LIBRAW_CAMERAMAKER_Clauss,         "Clauss"},
    {LIBRAW_CAMERAMAKER_Contax,         "Contax"},
    {LIBRAW_CAMERAMAKER_Creative,       "Creative"},
    {LIBRAW_CAMERAMAKER_DJI,            "DJI"},
    {LIBRAW_CAMERAMAKER_Foculus,        "Foculus"},
    {LIBRAW_CAMERAMAKER_Generic,        "Generic"},
    {LIBRAW_CAMERAMAKER_Gione,          "Gione"},
    {LIBRAW_CAMERAMAKER_GITUP,          "GITUP"},
    {LIBRAW_CAMERAMAKER_Hasselblad,     "Hasselblad"},
    {LIBRAW_CAMERAMAKER_HTC,            "HTC"},
    {LIBRAW_CAMERAMAKER_I_Mobile,       "I_Mobile"},
    {LIBRAW_CAMERAMAKER_Imacon,         "Imacon"},
    {LIBRAW_CAMERAMAKER_ISG,            "ISG"},
    {LIBRAW_CAMERAMAKER_JK_Imaging,     "JK Imaging"}, // Kodak
    {LIBRAW_CAMERAMAKER_Leaf,           "Leaf"},
    {LIBRAW_CAMERAMAKER_Lenovo,         "Lenovo"},
    {LIBRAW_CAMERAMAKER_LG,             "LG"},
    {LIBRAW_CAMERAMAKER_Logitech,       "Logitech"},
    {LIBRAW_CAMERAMAKER_Matrix,         "Matrix"},
    {LIBRAW_CAMERAMAKER_Meizu,          "Meizu"},
    {LIBRAW_CAMERAMAKER_Micron,         "Micron"},
    {LIBRAW_CAMERAMAKER_NGM,            "NGM"},
    {LIBRAW_CAMERAMAKER_OmniVison,      "OmniVison"},
    {LIBRAW_CAMERAMAKER_Panasonic,      "Panasonic"},
    {LIBRAW_CAMERAMAKER_Photron,        "Photron"},
    {LIBRAW_CAMERAMAKER_Pixelink,       "Pixelink"},
    {LIBRAW_CAMERAMAKER_Polaroid,       "Polaroid"},
    {LIBRAW_CAMERAMAKER_Rollei,         "Rollei"},
    {LIBRAW_CAMERAMAKER_RoverShot,      "RoverShot"},
    {LIBRAW_CAMERAMAKER_SMaL,           "SMaL"},
    {LIBRAW_CAMERAMAKER_ST_Micro,       "ST Micro"},
    {LIBRAW_CAMERAMAKER_THL,            "THL"},
    {LIBRAW_CAMERAMAKER_Xiaomi,         "Xiaomi"},
    {LIBRAW_CAMERAMAKER_XIAOYI,         "Xiayi"},
    {LIBRAW_CAMERAMAKER_Yuneec,         "Yuneec"},
    {LIBRAW_CAMERAMAKER_DXO,            "DxO"},
    {LIBRAW_CAMERAMAKER_RED,            "Red"},
    {LIBRAW_CAMERAMAKER_PhotoControl,   "Photo Control"},
    {LIBRAW_CAMERAMAKER_Google,         "Google"},
    {LIBRAW_CAMERAMAKER_GoPro,          "GoPro"},
    {LIBRAW_CAMERAMAKER_Parrot,         "Parrot"},
    {LIBRAW_CAMERAMAKER_Zeiss,          "Zeiss"},
    {LIBRAW_CAMERAMAKER_OnePlus,        "OnePlus"},
    {LIBRAW_CAMERAMAKER_VIVO,           "Vivo"},
    {LIBRAW_CAMERAMAKER_HMD_Global,     "HMD Global"},
    {LIBRAW_CAMERAMAKER_HUAWEI,         "Huawei"},
    {LIBRAW_CAMERAMAKER_RaspberryPi,    "RaspberryPi"},
};
// clang-format on

int LibRaw::setMakeFromIndex(unsigned makei)
{
  if (makei <= LIBRAW_CAMERAMAKER_Unknown || makei >= LIBRAW_CAMERAMAKER_TheLastOne) return 0;

  for (int i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++)
    if ((unsigned)CorpTable[i].CorpId == makei)
    {
      strcpy(normalized_make, CorpTable[i].CorpName);
      maker_index = makei;
      return 1;
    }
  return 0;
}

const char *LibRaw::cameramakeridx2maker(unsigned maker)
{
    for (int i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++)
        if((unsigned)CorpTable[i].CorpId == maker)
            return CorpTable[i].CorpName;
    return 0;
}

int LibRaw::simplify_make_model(unsigned *_maker_index, 
  char *_make, unsigned _make_buf_size, char *_model, unsigned _model_buf_size)
{
  if (!_make || _make_buf_size < 2 || !_model || _model_buf_size < 2)
    return -1;

  unsigned mkindex = 0;
    for (int i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++)
    {
      if (strcasestr(_make, CorpTable[i].CorpName))
      { /* Simplify company names */
        mkindex = CorpTable[i].CorpId;
        break;
      }
    }

    if (mkindex == LIBRAW_CAMERAMAKER_HMD_Global && !strncasecmp(_model, "Nokia", 5))
    {
      mkindex = LIBRAW_CAMERAMAKER_Nokia;
    }
    else if (mkindex == LIBRAW_CAMERAMAKER_JK_Imaging && !strncasecmp(_model, "Kodak", 5))
    {
      mkindex = LIBRAW_CAMERAMAKER_Kodak;
    }
    else if (mkindex == LIBRAW_CAMERAMAKER_Ricoh && !strncasecmp(_model, "PENTAX", 6))
    {
      mkindex = LIBRAW_CAMERAMAKER_Pentax;
    }

  for (int i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++)
    {
      if (mkindex == (unsigned)CorpTable[i].CorpId)
      {
        strncpy(_make, CorpTable[i].CorpName, _make_buf_size - 1);
        _make[_make_buf_size - 1] = 0;
        break;
      }
    }

    char *cp = 0;
    if ((mkindex == LIBRAW_CAMERAMAKER_Kodak || mkindex == LIBRAW_CAMERAMAKER_Leica) &&
        ((cp = strcasestr(_model, " DIGITAL CAMERA")) || (cp = strstr(_model, "FILE VERSION"))))
    {
      *cp = 0;
    }

    remove_trailing_spaces(_make, _make_buf_size);
    remove_trailing_spaces(_model, _model_buf_size);

    int i = int(strnlen(_make, _make_buf_size - 1)); /* Remove make from model */
    if (!strncasecmp(_model, _make, i) && _model[i++] == ' ')
      memmove(_model, _model + i, _model_buf_size - i);

    if (mkindex == LIBRAW_CAMERAMAKER_Fujifilm && !strncmp(_model, "FinePix", 7))
    {
      memmove(_model, _model + 7, strlen(_model) - 6);
      if (_model[0] == ' ')
      {
        memmove(_model, _model + 1, strlen(_model));
      }
    }
    else if ((mkindex == LIBRAW_CAMERAMAKER_Kodak || mkindex == LIBRAW_CAMERAMAKER_Konica) &&
             !strncmp(_model, "Digital Camera ", 15))
    {
      memmove(_model, _model + 15, strlen(_model) - 14);
    }

    if (mkindex)
    {
      if (_maker_index)
        *_maker_index = mkindex;
      return 0; // maker index is set
    }
    return 1; // maker index is not set
}

/*
   Identify which camera created this file, and set global variables
   accordingly.
 */
void LibRaw::identify()
{
  // clang-format off
  static const ushort canon[][11] = {
      // raw_width, raw_height, left_margin, top_margin,
      // width_decrement, height_decrement,
      // mask01, mask03, mask11, mask13,
      // CFA_filters.
    { 1944, 1416, 0, 0, 48, 0 }, // 00 "PowerShot Pro90 IS"
    { 2144, 1560, 4, 8, 52, 2, 0, 0, 0, 25 }, // 01 "PowerShot S30", "PowerShot G1"
    { 2224, 1456, 48, 6, 0, 2 }, // 02 "EOS D30"
    { 2376, 1728, 12, 6, 52, 2 }, // 03 "PowerShot G2", "PowerShot S40", "PowerShot G3", "PowerShot S45"
    { 2672, 1968, 12, 6, 44, 2 }, // 04 "PowerShot G5", "PowerShot S50", "PowerShot S60"
    { 3152, 2068, 64, 12, 0, 0, 16 }, // 05 "EOS D60", "EOS 10D", "EOS 300D"
    { 3160, 2344, 44, 12, 4, 4 }, // 06 "PowerShot G6", "PowerShot S70"
    { 3344, 2484, 4, 6, 52, 6 }, // 07 "PowerShot Pro1"
    { 3516, 2328, 42, 14, 0, 0 }, // 08 "EOS 350D"
    { 3596, 2360, 74, 12, 0, 0 }, // 09 "EOS-1D Mark II", "EOS 20D", "EOS-1D Mark II N", "EOS 30D"
    { 3744, 2784, 52, 12, 8, 12 }, // 10 "PowerShot G11", "PowerShot S90", "PowerShot G12", "PowerShot S95"
    { 3944, 2622, 30, 18, 6, 2 }, // 11 "EOS 40D"
    { 3948, 2622, 42, 18, 0, 2 }, // 12 "EOS 400D", "EOS 1000D"
    { 3984, 2622, 76, 20, 0, 2, 14 }, // 13 "EOS-1D Mark III"
    { 4032, 2656, 112, 44, 10, 0 }, // 14 APS-C crop mode: "EOS 6D Mark II"??, "EOS RP"
    { 4104, 3048, 48, 12, 24, 12 }, // 15 "PowerShot G9"
    { 4116, 2178, 4, 2, 0, 0 },  // 16 ??
    { 4152, 2772, 192, 12, 0, 0 }, // 17 "PowerShot SX1 IS"
    { 4160, 3124, 104, 11, 8, 65 }, // 18 "PowerShot S100 (new)", "PowerShot S100V", "PowerShot G15", "PowerShot S110 (new)"
    { 4176, 3062, 96, 17, 8, 0, 0, 16, 0, 7, 0x49 }, // 19 "PowerShot SX50 HS"
    { 4192, 3062, 96, 17, 24, 0, 0, 16, 0, 0, 0x49 }, // 20 "PowerShot G16", "PowerShot S120"
    { 4312, 2876, 22, 18, 0, 2 }, // 21 "EOS 450D"
    { 4352, 2850, 144, 46, 0, 0 }, // 22 APS-C crop mode: "EOS R", "EOS Ra"
    { 4352, 2874, 62, 18, 0, 0 }, // 23 "EOS 1100D"
    { 4476, 2954, 90, 34, 0, 0 }, // 24 "EOS 5D"
    { 4480, 3348, 12, 10, 36, 12, 0, 0, 0, 18, 0x49 }, // 25 "PowerShot G10"
    { 4480, 3366, 80, 50, 0, 0 }, // 26 "PowerShot G1 X Mark II"
    { 4496, 3366, 80, 50, 12, 0 }, // 27 "PowerShot G1 X"
    { 4768, 3516, 96, 16, 0, 0, 0, 16 }, // 28 "PowerShot SX60 HS"
    { 4832, 3204, 62, 26, 0, 0 }, // 29 "EOS 500D"
    { 4832, 3228, 62, 51, 0, 0 }, // 30 "EOS 50D"
    { 5108, 3349, 98, 13, 0, 0 }, // 31 "EOS-1Ds Mark II"
    { 5120, 3318, 142, 45, 62, 0 }, // 32  "EOS-1D Mark IV"
    { 5280, 3528, 72, 52, 0, 0 }, // 33 "EOS M10", "EOS 650D", "EOS 700D", "EOS M", "EOS 100D", "EOS M2"
    { 5344, 3516, 142, 51, 0, 0 }, // 34 "EOS 550D", "EOS 600D", "EOS 60D", "EOS 1200D", "EOS 1300D", "EOS 3000D"
    { 5344, 3584, 126, 100, 0, 2 }, // 35 "EOS-1D X", "EOS-1D C"
    { 5344, 3950, 98, 18, 0, 0, 0, 24, 0, 0 }, // 36 "PowerShot SX70 HS"
    { 5360, 3516, 158, 51, 0, 0 }, // 37 "EOS 7D"
    { 5568, 3708, 72, 38, 0, 0 }, // 38; "EOS 7D Mark II", "EOS 6D", "EOS 70D", "EOS-1D X MARK II"
    { 5632, 3710, 96, 17, 0, 0, 0, 16, 0, 0, 0x49 }, // 39 "PowerShot G7 X", "PowerShot G3 X", "PowerShot G9 X", "PowerShot G5 X", "PowerShot G7 X Mark II", "PowerShot G9 X Mark II"
    { 5712, 3774, 62, 20, 10, 2 }, // 40 "EOS-1Ds Mark III"
    { 5792, 3804, 158, 51, 0, 0 }, // 41 "EOS 5D Mark II"
    { 5920, 3950, 122, 80, 2, 0 }, // 42 "EOS 5D Mark III"
    { 6096, 4051, 76, 35, 0, 0 }, // 43 "EOS 1500D"
    { 6096, 4056, 72, 34, 0, 0 }, // 44 "EOS M3", "EOS 760D", "EOS 750D"
    { 6288, 4056, 264, 36, 0, 0 }, // 45 "EOS M5", "EOS M100", "EOS M6", "PowerShot G1 X Mark III", "EOS 80D", "EOS 800D", "EOS 77D", "EOS 200D", "EOS 250D", "EOS M50", "EOS R100"
    { 6384, 4224, 120, 44, 0, 0 }, // 46 "EOS 6D Mark II", "EOS RP"
    { 6880, 4544, 136, 42, 0, 0 }, // 47 "EOS 5D Mark IV"
    { 6888, 4546, 146, 48, 0, 0 }, // 48 "EOS R", "EOS Ra"
    { 7128, 4732, 144, 72, 0, 0 }, // 49 "EOS M6 II", "EOS 90D"
    { 8896, 5920, 160, 64, 0, 0 }, // 50 "EOS 5DS", "EOS 5DS R"
    { 6192, 4152, 160, 120, 0, 0}, // EOS R3
    { 6192, 4060, 144, 40, 0,0}, // EOS R10, R50, R50V
    //{ 6192, 4060, 168, 52, 24, 8, 16,48,32,0}, // EOS R10
    { 6188, 4120, 154, 96, 12, 0, 16, 48, 32, 0}, // EOS R6mk2
    { 3936, 2612, 154, 96, 0, 0}, // EOS R6mk2 APS
    { 8480, 5650, 258, 162, 0, 0, 128, 2, 128, 0}, // EOS R5mk2, FF
    { 5376, 3574, 258, 162, 0, 0, 128, 2, 128, 0}, // EOS R5mk2, APS
    { 6160, 4144, 128, 120, 0, 0}, // EOS R1, FF
    { 5928, 3944, 144, 80, 0, 0}, // PowerShot V1
    { 7144, 4760, 158, 96, 0, 0}, // EOS C50 && EOS R6mk3
    { 4512, 2994, 160, 96, 0, 0}, // EOS R6mk3 crop
  };

  static const libraw_custom_camera_t const_table[] = {
    { 786432,   1024,  768, 0, 0,  0, 0,  0, 0x94, 0, 0, "AVT", "F-080C" },
    { 1447680,  1392, 1040, 0, 0,  0, 0,  0, 0x94, 0, 0, "AVT", "F-145C" },
    { 1920000,  1600, 1200, 0, 0,  0, 0,  0, 0x94, 0, 0, "AVT", "F-201C" },
    { 5067304,  2588, 1958, 0, 0,  0, 0,  0, 0x94, 0, 0, "AVT", "F-510C" },
    { 5067316,  2588, 1958, 0, 0,  0, 0,  0, 0x94, 0, 0, "AVT", "F-510C", 12 },
    { 10134608, 2588, 1958, 0, 0,  0, 0,  9, 0x94, 0, 0, "AVT", "F-510C" },
    { 10134620, 2588, 1958, 0, 0,  0, 0,  9, 0x94, 0, 0, "AVT", "F-510C", 12 },
    { 16157136, 3272, 2469, 0, 0,  0, 0,  9, 0x94, 0, 0, "AVT", "F-810C" },
    { 3995136,  1632, 1224, 0, 0,  0, 0,  8, 0x61, 0, 1, "AgfaPhoto", "DC-833m" },
    { 15980544, 3264, 2448, 0, 0,  0, 0,  8, 0x61, 0, 1, "AgfaPhoto", "DC-833m" },
    { 9631728,  2532, 1902, 0, 0,  0, 0, 96, 0x61, 0, 0, "Alcatel", "5035D" },
    { 31850496, 4608, 3456, 0, 0,  0, 0,  0, 0x94, 0, 0, "GITUP", "GIT2 4:3" },
    { 23887872, 4608, 2592, 0, 0,  0, 0,  0, 0x94, 0, 0, "GITUP", "GIT2 16:9" },
    { 32257024, 4624, 3488, 8, 2, 16, 2,  0, 0x94, 0, 0, "GITUP", "GIT2P 4:3" },
    { 24192768, 4624, 2616, 8, 2, 16, 2,  0, 0x94, 0, 0, "GITUP", "GIT2P 16:9" },
    { 18016000, 4000, 2252, 0, 0,  0, 0,  0, 0x94, 0, 0, "GITUP", "G3DUO 16:9" },
    //          {24000000, 4000, 3000, 0, 0, 0, 0, 0, 0x94, 0, 0, "GITUP",
      //          "G3DUO 4:3"}, // Conflict w/ Samsung WB550

      //   Android Raw dumps id start
      //   File Size in bytes Horizontal Res Vertical Flag then bayer order eg
      //   0x16 bbgr 0x94 rggb
    {  1540857, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "Samsung", "S3" },
    {  2658304, 1212, 1096,   0, 0, 0, 0,  1, 0x16, 0, 0, "LG", "G3FrontMipi" },
    {  2842624, 1296, 1096,   0, 0, 0, 0,  1, 0x16, 0, 0, "LG", "G3FrontQCOM" },
    {  2969600, 1976, 1200,   0, 0, 0, 0,  1, 0x16, 0, 0, "Xiaomi", "MI3wMipi" },
    {  3170304, 1976, 1200,   0, 0, 0, 0,  1, 0x16, 0, 0, "Xiaomi", "MI3wQCOM" },
    {  3763584, 1584, 1184,   0, 0, 0, 0, 96, 0x61, 0, 0, "I_Mobile", "I_StyleQ6" },
    {  5107712, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "OmniVisi", "UltraPixel1" },
    {  5382640, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "OmniVisi", "UltraPixel2" },
    {  5664912, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "OmniVisi", "4688" },
    {  5664912, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "OmniVisi", "4688" },
    {  5364240, 2688, 1520,   0, 0, 0, 0,  1, 0x61, 0, 0, "OmniVisi", "4688" },
    {  6299648, 2592, 1944,   0, 0, 0, 0,  1, 0x16, 0, 0, "OmniVisi", "OV5648" },
    {  6721536, 2592, 1944,   0, 0, 0, 0,  0, 0x16, 0, 0, "OmniVisi", "OV56482" },
    {  6746112, 2592, 1944,   0, 0, 0, 0,  0, 0x16, 0, 0, "HTC", "OneSV" },
    {  9631728, 2532, 1902,   0, 0, 0, 0, 96, 0x61, 0, 0, "Sony", "5mp" },
    {  9830400, 2560, 1920,   0, 0, 0, 0, 96, 0x61, 0, 0, "NGM", "ForwardArt" },
    { 10186752, 3264, 2448,   0, 0, 0, 0,  1, 0x94, 0, 0, "Sony", "IMX219-mipi 8mp" },
    { 10223360, 2608, 1944,   0, 0, 0, 0, 96, 0x16, 0, 0, "Sony", "IMX" },
    { 10782464, 3282, 2448,   0, 0, 0, 0,  0, 0x16, 0, 0, "HTC", "MyTouch4GSlide" },
    { 10788864, 3282, 2448,   0, 0, 0, 0,  0, 0x16, 0, 0, "Xperia", "L" },
    { 15967488, 3264, 2446,   0, 0, 0, 0, 96, 0x16, 0, 0, "OmniVison", "OV8850" },
    { 16224256, 4208, 3082,   0, 0, 0, 0,  1, 0x16, 0, 0, "LG", "G3MipiL" },
    { 16424960, 4208, 3120,   0, 0, 0, 0,  1, 0x16, 0, 0, "IMX135", "MipiL" },
    { 17326080, 4164, 3120,   0, 0, 0, 0,  1, 0x16, 0, 0, "LG", "G3LQCom" },
    { 17522688, 4212, 3120,   0, 0, 0, 0,  0, 0x16, 0, 0, "Sony", "IMX135-QCOM" },
    { 19906560, 4608, 3456,   0, 0, 0, 0,  1, 0x16, 0, 0, "Gione", "E7mipi" },
    { 19976192, 5312, 2988,   0, 0, 0, 0,  1, 0x16, 0, 0, "LG", "G4" },
    { 20389888, 4632, 3480,   0, 0, 0, 0,  1, 0x16, 0, 0, "Xiaomi", "RedmiNote3Pro" },
    { 20500480, 4656, 3496,   0, 0, 0, 0,  1, 0x94, 0, 0, "Sony", "IMX298-mipi 16mp" },
    { 21233664, 4608, 3456,   0, 0, 0, 0,  1, 0x16, 0, 0, "Gione", "E7qcom" },
    { 26023936, 4192, 3104,   0, 0, 0, 0, 96, 0x94, 0, 0, "THL", "5000" },
    { 26257920, 4208, 3120,   0, 0, 0, 0, 96, 0x94, 0, 0, "Sony", "IMX214" },
    { 26357760, 4224, 3120,   0, 0, 0, 0, 96, 0x61, 0, 0, "OV", "13860" },
    { 41312256, 5248, 3936,   0, 0, 0, 0, 96, 0x61, 0, 0, "Meizu", "MX4" },
    { 42923008, 5344, 4016,   0, 0, 0, 0, 96, 0x61, 0, 0, "Sony", "IMX230" },
      //   Android Raw dumps id end
    { 20137344, 3664, 2748,   0,  0,  0,  0, 64, 0x49, 0, 0, "Aptina", "MT9J003", 0xffff },
    {  2868726, 1384, 1036,   0,  0,  0,  0, 64, 0x49, 0, 8, "Baumer", "TXG14", 1078 },
    {  6553440, 2664, 1968,   4,  4, 44,  4, 40, 0x94, 0, 2, "Canon", "PowerShot A460" }, // chdk hack
    {  9243240, 3152, 2346,  12,  7, 44, 13, 40, 0x49, 0, 2, "Canon", "PowerShot A470" }, // chdk hack
    {  6653280, 2672, 1992,  10,  6, 42,  2, 40, 0x94, 0, 2, "Canon", "PowerShot A530" }, // chdk hack
    {  6573120, 2672, 1968,  12,  8, 44,  0, 40, 0x94, 0, 2, "Canon", "PowerShot A610" }, // chdk hack
    {  9219600, 3152, 2340,  36, 12,  4,  0, 40, 0x94, 0, 2, "Canon", "PowerShot A620" }, // chdk hack
    { 10383120, 3344, 2484,  12,  6, 44,  6, 40, 0x94, 0, 2, "Canon", "PowerShot A630" }, // chdk hack
    { 12945240, 3736, 2772,  12,  6, 52,  6, 40, 0x94, 0, 2, "Canon", "PowerShot A640" }, // chdk hack
    { 15636240, 4104, 3048,  48, 12, 24, 12, 40, 0x94, 0, 2, "Canon", "PowerShot A650 IS" }, // chdk hack
    { 10341600, 3336, 2480,   6,  5, 32,  3, 40, 0x94, 0, 2, "Canon", "PowerShot A720 IS" }, // chdk hack
    { 24724224, 4704, 3504,   8, 16, 56,  8, 40, 0x49, 0, 2, "Canon", "PowerShot A3300 IS" }, // chdk hack
    { 18763488, 4104, 3048,  10, 22, 82, 22,  8, 0x49, 0, 0, "Canon", "PowerShot D10" }, // ? chdk hack ?
    { 19493760, 4160, 3124, 104, 12,  8, 66, 40, 0x49, 0, 2,  "Canon", "PowerShot S100" }, // chdk hack CRW
    {  7710960, 2888, 2136,  44,  8,  4,  0, 40, 0x94, 0, 2, "Canon", "PowerShot S3 IS" }, // chdk hack
    {  5298000, 2400, 1766,  12, 12, 44,  2, 40, 0x94, 0, 2, "Canon", "PowerShot SD300" }, // chdk hack
    { 18653760, 4080, 3048,  24, 12, 24, 12, 40, 0x94, 0, 2, "Canon", "PowerShot SX20 IS" }, // chdk hack
    { 21936096, 4464, 3276,  25, 10, 73, 12, 40, 0x16, 0, 2, "Canon", "PowerShot SX30 IS" }, // chdk hack
    { 19167840, 4176, 3060,  96, 16,  8,  0, 40, 0x94, 0, 2, "Canon", "PowerShot SX40 HS" }, // chdk hack CR2
    { 15467760, 3720, 2772,   6, 12, 30,  0, 40, 0x94, 0, 2, "Canon", "PowerShot SX110 IS" }, // chdk hack
    { 15534576, 3728, 2778,  12,  9, 44,  9, 40, 0x94, 0, 2, "Canon", "PowerShot SX120 IS" }, // chdk hack
    { 19131120, 4168, 3060,  92, 16,  4,  1, 40, 0x94, 0, 2, "Canon", "PowerShot SX220 HS" }, // chdk hack
    { 31663200, 5344, 3950,  96, 18,  0,  0, 40, 0x94, 0, 2, "Canon", "PowerShot SX710 HS" }, // chdk hack
    { 30858240, 5248, 3920,   8, 16, 56, 16, 40, 0x94, 0, 2, "Canon", "IXUS 160" }, // chdk hack
    {  1976352, 1632, 1211,   0,  2,  0,  1,  0, 0x94, 0, 1, "Casio", "QV-2000UX" },
    {  3217760, 2080, 1547,   0,  0, 10,  1,  0, 0x94, 0, 1, "Casio", "QV-3*00EX" },
    {  6218368, 2585, 1924,   0,  0,  9,  0,  0, 0x94, 0, 1, "Casio", "QV-5700" },
    {  7816704, 2867, 2181,   0,  0, 34, 36,  0, 0x16, 0, 1, "Casio", "EX-Z60" },
    {  2937856, 1621, 1208,   0,  0,  1,  0,  0, 0x94, 7, 13, "Casio", "EX-S20" },
    {  4948608, 2090, 1578,   0,  0, 32, 34,  0, 0x94, 7, 1, "Casio", "EX-S100" },
    {  6054400, 2346, 1720,   2,  0, 32,  0,  0, 0x94, 7, 1, "Casio", "QV-R41" },
    {  7426656, 2568, 1928,   0,  0,  0,  0,  0, 0x94, 0, 1, "Casio", "EX-P505" },
    {  7530816, 2602, 1929,   0,  0, 22,  0,  0, 0x94, 7, 1, "Casio", "QV-R51" },
    {  7542528, 2602, 1932,   0,  0, 32,  0,  0, 0x94, 7, 1, "Casio", "EX-Z50" },
    {  7562048, 2602, 1937,   0,  0, 25,  0,  0, 0x16, 7, 1, "Casio", "EX-Z500" },
    {  7753344, 2602, 1986,   0,  0, 32, 26,  0, 0x94, 7, 1, "Casio", "EX-Z55" },
    {  9313536, 2858, 2172,   0,  0, 14, 30,  0, 0x94, 7, 1, "Casio", "EX-P600" },
    { 10834368, 3114, 2319,   0,  0, 27,  0,  0, 0x94, 0, 1, "Casio", "EX-Z750" },
    { 10843712, 3114, 2321,   0,  0, 25,  0,  0, 0x94, 0, 1, "Casio", "EX-Z75" },
    { 10979200, 3114, 2350,   0,  0, 32, 32,  0, 0x94, 7, 1, "Casio", "EX-P700" },
    { 12310144, 3285, 2498,   0,  0,  6, 30,  0, 0x94, 0, 1, "Casio", "EX-Z850" },
    { 12489984, 3328, 2502,   0,  0, 47, 35,  0, 0x94, 0, 1, "Casio", "EX-Z8" },
    { 15499264, 3754, 2752,   0,  0, 82,  0,  0, 0x94, 0, 1, "Casio", "EX-Z1050" },
    { 18702336, 4096, 3044,   0,  0, 24,  0, 80, 0x94, 7, 1, "Casio", "EX-ZR100" },
    {  7684000, 2260, 1700,   0,  0,  0,  0, 13, 0x94, 0, 1, "Casio", "QV-4000" },
    {   787456, 1024,  769,   0,  1,  0,  0,  0, 0x49, 0, 0, "Creative", "PC-CAM 600" },
    { 28829184, 4384, 3288,   0,  0,  0,  0, 36, 0x61, 0, 0, "DJI" },
    { 15151104, 4608, 3288,   0,  0,  0,  0,  0, 0x94, 0, 0, "Matrix" },
    {  3840000, 1600, 1200,   0,  0,  0,  0, 65, 0x49, 0, 0, "Foculus", "531C" },
    {   307200,  640,  480,   0,  0,  0,  0,  0, 0x94, 0, 0, "Generic" },
    {    62464,  256,  244,   1,  1,  6,  1,  0, 0x8d, 0, 0, "Kodak", "DC20" },
    {   124928,  512,  244,   1,  1, 10,  1,  0, 0x8d, 0, 0, "Kodak", "DC20" },
    {  1652736, 1536, 1076,   0, 52,  0,  0,  0, 0x61, 0, 0, "Kodak", "DCS200" },
    {  4159302, 2338, 1779,   1, 33,  1,  2,  0, 0x94, 0, 0, "Kodak", "C330" },
    {  4162462, 2338, 1779,   1, 33,  1,  2,  0, 0x94, 0, 0, "Kodak", "C330", 3160 },
    {  2247168, 1232,  912,   0,  0, 16,  0,  0, 0x00, 0, 0, "Kodak", "C330" },
    {  3370752, 1232,  912,   0,  0, 16,  0,  0, 0x00, 0, 0, "Kodak", "C330" },
    {  6163328, 2864, 2152,   0,  0,  0,  0,  0, 0x94, 0, 0, "Kodak", "C603" },
    {  6166488, 2864, 2152,   0,  0,  0,  0,  0, 0x94, 0, 0, "Kodak", "C603", 3160 },
    {   460800,  640,  480,   0,  0,  0,  0,  0, 0x00, 0, 0, "Kodak", "C603" },
    {  9116448, 2848, 2134,   0,  0,  0,  0,  0, 0x00, 0, 0, "Kodak", "C603" },
    { 12241200, 4040, 3030,   2,  0,  0, 13,  0, 0x49, 0, 0, "Kodak", "12MP" },
    { 12272756, 4040, 3030,   2,  0,  0, 13,  0, 0x49, 0, 0, "Kodak", "12MP", 31556 },
    { 18000000, 4000, 3000,   0,  0,  0,  0,  0, 0x00, 0, 0, "Kodak", "12MP" },
    {   614400,  640,  480,   0,  3,  0,  0, 64, 0x94, 0, 0, "Kodak", "KAI-0340" },
    { 15360000, 3200, 2400,   0,  0,  0,  0, 96, 0x16, 0, 0, "Lenovo", "A820" },
    {  3884928, 1608, 1207,   0,  0,  0,  0, 96, 0x16, 0, 0, "Micron", "2010", 3212 },
    {  1138688, 1534,  986,   0,  0,  0,  0,  0, 0x61, 0, 0, "Minolta", "RD175", 513 },
    {  1581060, 1305,  969,   0,  0, 18,  6,  6, 0x1e, 4, 1, "Nikon", "E900" }, // "diag raw" hack
    {  2465792, 1638, 1204,   0,  0, 22,  1,  6, 0x4b, 5, 1, "Nikon", "E950" }, // "diag raw" hack; possibly also Nikon E700, E800, E775;
                                                                          // Olympus C-2020Z
    {  2940928, 1616, 1213,   0,  0,  0,  7, 30, 0x94, 0, 1, "Nikon", "E2100" }, // "diag raw" hack; also Nikon E2500
    {  4771840, 2064, 1541,   0,  0,  0,  1,  6, 0xe1, 0, 1, "Nikon", "E990" }, // "diag raw" hack; possibly also Nikon E880, E885, E995;
                                                                         // Olympus C-3030Z
    {  4775936, 2064, 1542,   0,  0,  0,  0, 30, 0x94, 0, 1, "Nikon", "E3700" }, // "diag raw" hack; Nikon E3100, E3200, E3500;
                                                                           // Pentax "Optio 33WR"; possibly also Olympus C-740UZ
    {  5865472, 2288, 1709,   0,  0,  0,  1,  6, 0xb4, 0, 1, "Nikon", "E4500" }, // "diag raw" hack; possibly also Olympus C-4040Z
    {  5869568, 2288, 1710,   0,  0,  0,  0,  6, 0x16, 0, 1, "Nikon", "E4300" }, // "diag raw" hack; also Minolta "DiMAGE Z2"
    {  7438336, 2576, 1925,   0,  0,  0,  1,  6, 0xb4, 0, 1, "Nikon", "E5000" }, // also Nikon E5700
    {  8998912, 2832, 2118,   0,  0,  0,  0, 30, 0x94, 7, 1, "Nikon", "COOLPIX S6" }, // "diag raw" hack
    {  5939200, 2304, 1718,   0,  0,  0,  0, 30, 0x16, 0, 0, "Olympus", "C-770UZ" }, // possibly also Olympus C-4100Z, C-765UZ
    {  3178560, 2064, 1540,   0,  0,  0,  0,  0, 0x94, 0, 1, "Pentax", "Optio S V1.01" },
    {  4841984, 2090, 1544,   0,  0, 22,  0,  0, 0x94, 7, 1, "Pentax", "Optio S" },
    {  6114240, 2346, 1737,   0,  0, 22,  0,  0, 0x94, 7, 1, "Pentax", "Optio S4" },
    { 10702848, 3072, 2322,   0,  0,  0, 21, 30, 0x94, 0, 1, "Pentax", "Optio 750Z" },
    {  4147200, 1920, 1080,   0,  0,  0,  0,  0, 0x49, 0, 0, "Photron", "BC2-HD" },
    {  4151666, 1920, 1080,   0,  0,  0,  0,  0, 0x49, 0, 0, "Photron", "BC2-HD", 8 },
    { 13248000, 2208, 3000,   0,  0,  0,  0, 13, 0x61, 0, 0, "Pixelink", "A782" },
    {  6291456, 2048, 1536,   0,  0,  0,  0, 96, 0x61, 0, 0, "RoverShot", "3320AF" },
    {   311696,  644,  484,   0,  0,  0,  0,  0, 0x16, 0, 8, "ST Micro", "STV680 VGA" },
    { 16098048, 3288, 2448,   0,  0, 24,  0,  9, 0x94, 0, 1, "Samsung", "S85" }, // hack
    { 16215552, 3312, 2448,   0,  0, 48,  0,  9, 0x94, 0, 1, "Samsung", "S85" }, // hack
    { 20487168, 3648, 2808,   0,  0,  0,  0, 13, 0x94, 5, 1, "Samsung", "WB550" },
    { 24000000, 4000, 3000,   0,  0,  0,  0, 13, 0x94, 5, 1, "Samsung", "WB550" },
    { 12582980, 3072, 2048,   0,  0,  0,  0, 33, 0x61, 0, 0, "Sinar", "", 68 }, // Sinarback 23; same res. as Leaf Volare & Cantare
    { 33292868, 4080, 4080,   0,  0,  0,  0, 33, 0x61, 0, 0, "Sinar", "", 68 }, // Sinarback 44
    { 44390468, 4080, 5440,   0,  0,  0,  0, 33, 0x61, 0, 0, "Sinar", "", 68 }, // Sinarback 54
    {  1409024, 1376, 1024,   0,  0,  1,  0,  0, 0x49, 0, 0, "Sony", "XCD-SX910CR" },
    {  2818048, 1376, 1024,   0,  0,  1,  0, 97, 0x49, 0, 0, "Sony", "XCD-SX910CR" },
  };

  libraw_custom_camera_t
      table[64 + sizeof(const_table) / sizeof(const_table[0])];


  // clang-format on

  char head[64] = {0}, *cp;
  int hlen, zero_fsize = 1, i, c;
  INT64 flen, fsize;
  struct jhead jh;

  unsigned camera_count =
      parse_custom_cameras(64, table, imgdata.rawparams.custom_camera_strings);
  for (int q = 0; q < int(sizeof(const_table) / sizeof(const_table[0])); q++)
    memmove(&table[q + camera_count], &const_table[q], sizeof(const_table[0]));
  camera_count += sizeof(const_table) / sizeof(const_table[0]);

  tiff_flip = flip = filters = UINT_MAX; /* unknown */
  raw_height = raw_width = fuji_width = fuji_layout = cr2_slice[0] = 0;
  maximum = height = width = top_margin = left_margin = 0;
  cdesc[0] = desc[0] = artist[0] = make[0] = model[0] = model2[0] = 0;
  iso_speed = shutter = aperture = focal_len = 0;
  unique_id = 0ULL;
  tiff_nifds = 0;
  is_NikonTransfer = 0;
  is_Olympus = 0;
  OlympusDNG_SubDirOffsetValid = 0;
  is_Sony = 0;
  is_pana_raw = 0;
  maker_index = LIBRAW_CAMERAMAKER_Unknown;
  FujiCropMode = 0;
  is_PentaxRicohMakernotes = 0;
  normalized_model[0] = 0;
  normalized_make[0] = 0;
  CM_found = 0;
  memset(tiff_ifd, 0, sizeof tiff_ifd);
  libraw_internal_data.unpacker_data.crx_track_selected = -1;
  libraw_internal_data.unpacker_data.crx_track_count = -1;
  libraw_internal_data.unpacker_data.CR3_CTMDtag = 0;
  imHassy.nIFD_CM[0] = imHassy.nIFD_CM[1] = -1;
  imKodak.ISOCalibrationGain = 1.0f;
  imCommon.CameraTemperature = imCommon.SensorTemperature =
      imCommon.SensorTemperature2 = imCommon.LensTemperature =
          imCommon.AmbientTemperature = imCommon.BatteryTemperature =
              imCommon.exifAmbientTemperature = -1000.0f;

  imCanon.AutoRotateMode = 1; // Camera+Computer
  imCanon.AsShotCT = 5200; // 

  libraw_internal_data.unpacker_data.ifd0_offset = -1LL;
  FORC4 imgdata.color.as_shot_wb_corr[c] = 1.0f;

  imgdata.color.ExifColorSpace = LIBRAW_COLORSPACE_Unknown;
  for (i = 0; i < LIBRAW_IFD_MAXCOUNT; i++)
  {
    tiff_ifd[i].dng_color[0].illuminant = tiff_ifd[i].dng_color[1].illuminant =
        0xffff;
    for (int q = 0; q < 4; q++)
      tiff_ifd[i].dng_levels.analogbalance[q] = 1.0f;
  }

  memset(gpsdata, 0, sizeof gpsdata);
  memset(cblack, 0, sizeof cblack);
  memset(white, 0, sizeof white);
  memset(mask, 0, sizeof mask);
  thumb_offset = thumb_length = thumb_width = thumb_height = 0;
  load_raw = 0;
  thumb_format = LIBRAW_INTERNAL_THUMBNAIL_JPEG; // default to JPEG
  data_offset = meta_offset = meta_length = tiff_bps = tiff_compress = 0;
  kodak_cbpp = zero_after_ff = dng_version = load_flags = 0;
  timestamp = shot_order = tiff_samples = black = is_foveon = 0;
  mix_green = profile_length = data_error = zero_is_bad = 0;
  pixel_aspect = is_raw = raw_color = 1;
  tile_width = tile_length = 0;
  metadata_blocks = 0;

  for (i = 0; i < 4; i++)
  {
    cam_mul[i] = i == 1;
    pre_mul[i] = i < 3;
    FORC3 cmatrix[c][i] = 0;
    FORC3 rgb_cam[c][i] = c == i;
  }
  colors = 3;
  for (i = 0; i < 0x10000; i++)
    curve[i] = i;

  order = get2();
  hlen = get4();
  fseek(ifp, 0, SEEK_SET);

  if (fread(head, 1, 64, ifp) < 64)
    throw LIBRAW_EXCEPTION_IO_CORRUPT;
  libraw_internal_data.unpacker_data.lenRAFData = 0;
  libraw_internal_data.unpacker_data.posRAFData = 0;

  fseek(ifp, 0, SEEK_END);
  flen = fsize = ftell(ifp);

  bool checkcr3 = true;
  if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CR3_DYNAMIC_FRAME_LIMIT)
  {
    if (!memcmp((unsigned char *)head + 4, "ftypcrx ", 8))
      checkcr3 = false;
  }

  if(checkcr3 && fsize > LIBRAW_MAX_NONDNG_RAW_FILE_SIZE && fsize > LIBRAW_MAX_DNG_RAW_FILE_SIZE 
    && fsize > LIBRAW_MAX_CR3_RAW_FILE_SIZE)
      throw LIBRAW_EXCEPTION_TOOBIG;

  if ((cp = (char *)memmem(head, 32, (char *)"MMMM", 4)) ||
      (cp = (char *)memmem(head, 32, (char *)"IIII", 4)))
  {
    parse_phase_one(int(cp - head));
    if (cp - head && parse_tiff(0))
      apply_tiff();
  }
  else if (order == 0x4949 || order == 0x4d4d)
  {
    if (!memcmp(head + 6, "HEAPCCDR", 8))
    {
      data_offset = hlen;
      parse_ciff(INT64(hlen), int(flen - hlen), 0);
      load_raw = &LibRaw::canon_load_raw;
    }
    else if (parse_tiff(0))
      apply_tiff();
  }
  else if (!memcmp(head, "\xff\xd8\xff\xe1", 4) && !memcmp(head + 6, "Exif", 4))
  {
    fseek(ifp, 4, SEEK_SET);
    data_offset = 4 + get2();
    fseek(ifp, data_offset, SEEK_SET);
    if (fgetc(ifp) != 0xff)
      parse_tiff(12);
    thumb_offset = 0;
  }
  else if (!memcmp(head + 25, "ARECOYK", 7)) // 'KYOCERA' right-to-left
  {
    strcpy(make, "Contax");
    strcpy(model, "N Digital");
    parse_kyocera();
  }
  else if (!strcmp(head, "PXN"))
  {
    strcpy(make, "Logitech");
    strcpy(model, "Fotoman Pixtura");
  }
  else if (!strcmp(head, "qktk"))
  {
    strcpy(make, "Apple");
    strcpy(model, "QuickTake 100");
    load_raw = &LibRaw::quicktake_100_load_raw;
  }
  else if (!strcmp(head, "qktn"))
  {
    strcpy(make, "Apple");
    strcpy(model, "QuickTake 150");
    load_raw = &LibRaw::kodak_radc_load_raw;
  }
  else if (!memcmp(head, "FUJIFILM", 8))
  {
    memcpy(imFuji.SerialSignature, head + 0x10, 0x0c);
    imFuji.SerialSignature[0x0c] = 0;
    memcpy(imFuji.SensorID, imFuji.SerialSignature + 0x06, 0x04);
    imFuji.SensorID[0x04] = 0;
    strncpy(model, head + 0x1c, 0x20);
    model[0x20] = 0;
    c = 11;
    while (imFuji.SerialSignature[c] > 0 && isdigit(imFuji.SerialSignature[c]) && (c>0))
      c--;
  if(c < 11)
    unique_id = (unsigned long long)atoi(imFuji.SerialSignature+c+1);
    memcpy(imFuji.RAFVersion, head + 0x3c, 4);
    imFuji.RAFVersion[4] = 0;
    fseek(ifp, 84, SEEK_SET);
    thumb_offset = get4();
    thumb_length = get4();
    fseek(ifp, 92, SEEK_SET);
    parse_fuji(get4());
    if (thumb_offset > 120)
    {
      fseek(ifp, 120, SEEK_SET);
      is_raw += (i = get4()) ? 1 : 0;
      if (is_raw == 2 && shot_select)
        parse_fuji(i);
    }
    load_raw = &LibRaw::unpacked_load_raw;
    fseek(ifp, 100 + 28 * (shot_select > 0), SEEK_SET);
    parse_tiff(data_offset = get4());
    parse_tiff(thumb_offset + 12);
    parse_fuji_thumbnail(thumb_offset);
    apply_tiff();
  }
  else if (!memcmp(head, "RIFF", 4))
  {
    fseek(ifp, 0, SEEK_SET);
    parse_riff(100);
  }
  else if (!memcmp(head + 4, "ftypqt   ", 9))
  {
    fseek(ifp, 0, SEEK_SET);
  // Use existing variable that definitely not used in parse_qt/parse_jpeg to avoid ABI change
  short cr3save = libraw_internal_data.unpacker_data.CR3_Version;
  libraw_internal_data.unpacker_data.CR3_Version = 32;
    parse_qt(fsize);
  libraw_internal_data.unpacker_data.CR3_Version = cr3save;
    is_raw = 0;
  }
  else if (!memcmp(head, "\0\001\0\001\0@", 6))
  {
    fseek(ifp, 6, SEEK_SET);
    fread(make, 1, 8, ifp);
    fread(model, 1, 8, ifp);
    fread(model2, 1, 16, ifp);
    data_offset = get2();
    get2();
    raw_width = get2();
    raw_height = get2();
    load_raw = &LibRaw::nokia_load_raw;
    filters = 0x61616161;
  }
  else if (!memcmp(head, "NOKIARAW", 8))
  {
    strcpy(make, "NOKIA");
    order = 0x4949;
    fseek(ifp, 300, SEEK_SET);
    data_offset = get4();
    i = get4(); // bytes count
    width = get2();
    height = get2();

    // Data integrity check
    if (width < 1 || width > 16000 || height < 1 || height > 16000 ||
        i < (width * height) || i > (2 * width * height))
      throw LIBRAW_EXCEPTION_IO_CORRUPT;

    switch (tiff_bps = i * 8 / (width * height))
    {
    case 8:
      load_raw = &LibRaw::eight_bit_load_raw;
      break;
    case 10:
      load_raw = &LibRaw::nokia_load_raw;
      break;
    case 0:
      throw LIBRAW_EXCEPTION_IO_CORRUPT;
      break;
    }
    raw_height = height + (top_margin = i / (width * tiff_bps / 8) - height);
    mask[0][3] = 1;
    filters = 0x61616161;
  }
  else if (!memcmp(head, "DSC-Image", 9))
    parse_rollei();
  else if (!memcmp(head, "PWAD", 4))
    parse_sinar_ia();
  else if (!memcmp(head, "\0MRM", 4))
    parse_minolta(0);
  else if (!memcmp(head, "FOVb", 4))
  {
    parse_x3f(); /* Does nothing if USE_X3FTOOLS is not defined */
  }
  else if (!memcmp(head, "CI", 2))
    parse_cine();
#ifdef USE_6BY9RPI
  else if (!memcmp(head, "BRCM", 4)) {
  fseek(ifp, 0, SEEK_SET);
  strcpy(make, "RaspberryPi");
  strcpy(model, "Pi");
  parse_raspberrypi();
  }
#endif
  else if (!memcmp(head + 4, "ftypcrx ", 8))
  {
    int err;
    UINT64 szAtomList;
    short nesting = -1;
    short nTrack = -1;
    short TrackType;
    char AtomNameStack[129];
    strcpy(make, "Canon");

    szAtomList = ifp->size();
    err = parseCR3(0ULL, szAtomList, nesting, AtomNameStack, nTrack, TrackType,szAtomList);
    libraw_internal_data.unpacker_data.crx_track_count = nTrack;
    if ((err == 0 || err == -14) &&
        nTrack >= 0) // no error, or too deep nesting
      selectCRXTrack();
  }

  if (dng_version)
  {
      if (fsize > LIBRAW_MAX_DNG_RAW_FILE_SIZE)
          throw LIBRAW_EXCEPTION_TOOBIG;
  }
  else if (load_raw == &LibRaw::crxLoadRaw)
  {
    if (checkcr3 && fsize > LIBRAW_MAX_CR3_RAW_FILE_SIZE)
      throw LIBRAW_EXCEPTION_TOOBIG;
  }
  else
  {
    if (fsize > LIBRAW_MAX_NONDNG_RAW_FILE_SIZE)
      throw LIBRAW_EXCEPTION_TOOBIG;
  }

  if (make[0] == 0)
    for (zero_fsize = i = 0; i < (int)camera_count; i++)
      if (fsize == (INT64)table[i].fsize)
      {
        strcpy(make, table[i].t_make);
        strcpy(model, table[i].t_model);
        flip = table[i].flags >> 2;
        zero_is_bad = table[i].flags & 2;
        data_offset = table[i].offset == 0xffff ? 0 : table[i].offset;
        raw_width = table[i].rw;
        raw_height = table[i].rh;
        left_margin = table[i].lm;
        top_margin = table[i].tm;
        width = raw_width - left_margin - table[i].rm;
        height = raw_height - top_margin - table[i].bm;
        filters = 0x1010101U * table[i].cf;
        colors = 4 - !((filters & filters >> 1) & 0x5555);
        load_flags = table[i].lf & 0xff;
        if (table[i].lf & 0x100) /* Monochrome sensor dump */
        {
          colors = 1;
          filters = 0;
        }
        switch (tiff_bps = unsigned((fsize - data_offset) * 8LL / (INT64(raw_width) * INT64(raw_height))))
        {
        case 6:
          load_raw = &LibRaw::minolta_rd175_load_raw;
          ilm.CameraMount = LIBRAW_MOUNT_Minolta_A;
          break;
        case 8:
          load_raw = &LibRaw::eight_bit_load_raw;
          break;
        case 10:
          if ((fsize - data_offset) / INT64(raw_height) * 3LL >= INT64(raw_width) * 4LL)
          {
            load_raw = &LibRaw::android_loose_load_raw;
            break;
          }
          else if (load_flags & 1)
          {
            load_raw = &LibRaw::android_tight_load_raw;
            break;
          }
        case 12:
          load_flags |= 128;
          load_raw = &LibRaw::packed_load_raw;
          break;
        case 16:
          order = 0x4949 | 0x404 * (load_flags & 1);
          tiff_bps -= load_flags >> 4;
          tiff_bps -= load_flags = load_flags >> 1 & 7;
          load_raw = table[i].offset == 0xffff
                         ? &LibRaw::unpacked_load_raw_reversed
                         : &LibRaw::unpacked_load_raw;
        }
        maximum = (1 << tiff_bps) - (1 << table[i].max);
        break;
      }
  if (zero_fsize)
    fsize = 0;
  if (make[0] == 0 && fsize < 25000000LL)
    parse_smal(0, flen);
  if (make[0] == 0)
  {
    parse_jpeg(0);
#ifdef USE_6BY9RPI
  if (!(strncmp(model, "ov", 2) && strncmp(model, "RP_", 3) && strncmp(model, "imx477", 6))) {
    //Assume that this isn't a raw unless the header can be found
    is_raw = 0;

    if (!strncasecmp(model, "RP_testc",8) 
            || !strncasecmp(model, "imx477", 6) //  from PyDNG
        || !strncasecmp(model, "RP_imx477",9)) {
      const long offsets[] = {
        //IMX477 offsets
        3375104,  //2028x1080 12bit
        4751360,  //2028x1520 12bit
        18711040, //4056x3040 12bit
        1015808,  //1012x760 10bit
        -1        //Marker for end of table
      };
      int offset_idx;
      for (offset_idx=0; offsets[offset_idx]!=-1; offset_idx++) {
        if(!fseek (ifp, -offsets[offset_idx], SEEK_END) &&
           fread (head, 1, 32, ifp) && !strncmp(head,"BRCM", 4)) {
          fseek(ifp, -32, SEEK_CUR);
          strcpy (make, "RaspberryPi");
                    strcpy(model, "RP_imx477"); // Force single model
          black = (offset_idx == 3) ? 64 : 256;
          parse_raspberrypi();
          break;
        }
      }
    }
    else if (!strncasecmp(model, "RP_imx", 6)) {
      const long offsets[] = {
        //IMX219 offsets
        10270208, //8MPix 3280x2464
        2678784,  //1920x1080
        2628608,  //1640x1232
        1963008,  //1640x922
        1233920,  //1280x720
        445440,   //640x480
        -1        //Marker for end of table
      };
      int offset_idx;
      for (offset_idx = 0; offsets[offset_idx] != -1; offset_idx++) {
        if (!fseek(ifp, -offsets[offset_idx], SEEK_END) &&
          fread(head, 1, 32, ifp) && !strncmp(head, "BRCM", 4)) {

          fseek(ifp, -32, SEEK_CUR);
          strcpy(make, "RaspberryPi");
                    black = 66;
          parse_raspberrypi();
          break;
        }
      }
    }
    else if (!strncasecmp(model, "RP_OV", 5) || !strncasecmp(model, "ov5647", 6)) {
      const long offsets[] = {
          6404096,  //5MPix 2592x1944
          2717696,  //1920x1080
          1625600,  //1296x972
          1233920,  //1296x730
          445440,   //640x480
          -1        //Marker for end of table
      };
      int offset_idx;
      for (offset_idx = 0; offsets[offset_idx] != -1; offset_idx++) {
        if (!fseek(ifp, -offsets[offset_idx], SEEK_END) &&
          fread(head, 1, 32, ifp) && !strncmp(head, "BRCM", 4)) {
          fseek(ifp, -32, SEEK_CUR);
          strcpy(make, "RaspberryPi");
                    strcpy(model, "ov5647"); // Force single model
                    width = raw_width;
          //Defaults
          raw_width = 2611;
          filters = 0x16161616;
                    black = 16;
          parse_raspberrypi();
          break;
        }
      }
    }
  }// else is_raw = 0;
#else
    fseek(ifp, 0, SEEK_END);
    int sz = ftell(ifp);
    if (!strncmp(model, "RP_imx219", 9) && sz >= 0x9cb600 &&
        !fseek(ifp, -0x9cb600, SEEK_END) && fread(head, 1, 0x20, ifp) &&
        !strncmp(head, "BRCM", 4))
    {
      strcpy(make, "Broadcom");
      strcpy(model, "RPi IMX219");
      if (raw_height > raw_width)
        flip = 5;
      data_offset = ftell(ifp) + 0x8000 - 0x20;
      parse_broadcom();
      black = 66;
      maximum = 0x3ff;
      load_raw = &LibRaw::broadcom_load_raw;
      thumb_offset = 0;
      thumb_length = sz - 0x9cb600 - 1;
    }
    else if (!(strncmp(model, "ov5647", 6) && strncmp(model, "RP_OV5647", 9)) &&
             sz >= 0x61b800 && !fseek(ifp, -0x61b800, SEEK_END) &&
             fread(head, 1, 0x20, ifp) && !strncmp(head, "BRCM", 4))
    {
      strcpy(make, "Broadcom");
      if (!strncmp(model, "ov5647", 6))
        strcpy(model, "RPi OV5647 v.1");
      else
        strcpy(model, "RPi OV5647 v.2");
      if (raw_height > raw_width)
        flip = 5;
      data_offset = ftell(ifp) + 0x8000 - 0x20;
      parse_broadcom();
      black = 16;
      maximum = 0x3ff;
      load_raw = &LibRaw::broadcom_load_raw;
      thumb_offset = 0;
      thumb_length = sz - 0x61b800 - 1;
    }
    else
      is_raw = 0;
#endif
  }

  // make sure strings are terminated
  desc[511] = artist[63] = make[63] = model[63] = model2[63] = 0;

#if 1
  unsigned mkindex = 0;
  if (simplify_make_model(&mkindex, make, sizeof(make), model, sizeof(model)) == 0)
  {
    maker_index = mkindex;
  }
#else

  for (i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++)
  {
    if (strcasestr(make, CorpTable[i].CorpName))
    { /* Simplify company names */
      maker_index = CorpTable[i].CorpId;
      break;
    }
  }

  if (makeIs(LIBRAW_CAMERAMAKER_HMD_Global) && !strncasecmp(model, "Nokia", 5)) {
    maker_index = LIBRAW_CAMERAMAKER_Nokia;
  }  else if (makeIs(LIBRAW_CAMERAMAKER_JK_Imaging) && !strncasecmp(model, "Kodak", 5)) {
    maker_index = LIBRAW_CAMERAMAKER_Kodak;
  } else if (makeIs(LIBRAW_CAMERAMAKER_Ricoh) && !strncasecmp(model, "PENTAX", 6)) {
    maker_index = LIBRAW_CAMERAMAKER_Pentax;
  }

  for (i = 0; i < int(sizeof CorpTable / sizeof *CorpTable); i++) {
    if (maker_index == (unsigned)CorpTable[i].CorpId) {
      strcpy(make, CorpTable[i].CorpName);
      break;
    }
  }

  if ((makeIs(LIBRAW_CAMERAMAKER_Kodak) || makeIs(LIBRAW_CAMERAMAKER_Leica)) &&
      ((cp = strcasestr(model, " DIGITAL CAMERA")) ||
       (cp = strstr(model, "FILE VERSION")))) {
    *cp = 0;
  }

  remove_trailing_spaces(make, sizeof(make));
  remove_trailing_spaces(model, sizeof(model));

  i = int(strbuflen(make)); /* Remove make from model */
  if (!strncasecmp(model, make, i) && model[i++] == ' ')
    memmove(model, model + i, 64 - i);

  if (makeIs(LIBRAW_CAMERAMAKER_Fujifilm) && !strncmp(model, "FinePix", 7)) {
    memmove(model, model + 7, strlen(model) - 6);
    if (model[0] == ' ') {
      memmove(model, model + 1, strlen(model));
    }
  } else if ((makeIs(LIBRAW_CAMERAMAKER_Kodak) || makeIs(LIBRAW_CAMERAMAKER_Konica)) &&
             !strncmp(model, "Digital Camera ", 15)) {
    memmove(model, model + 15, strlen(model) - 14);
  }
#endif

  desc[511] = artist[63] = make[63] = model[63] = model2[63] = 0;
  if (!is_raw)
    goto notraw;

  if (!height)
    height = raw_height;
  if (!width)
    width = raw_width;

  identify_finetune_pentax();


  if (dng_version)
  {
    if (filters == UINT_MAX)
      filters = 0;
    if (!filters)
      colors = tiff_samples;
    switch (tiff_compress)
    {
    case 0: // Compression not set, assuming uncompressed
    case 1:
      // Uncompressed float: decoder set in apply_tiff for valid files; not set for non-valid with sampleformat==3
      if ((load_raw != &LibRaw::uncompressed_fp_dng_load_raw)  && (tiff_sampleformat != 3))
        load_raw = &LibRaw::packed_dng_load_raw;
      break;
    case 7:
      load_raw = &LibRaw::lossless_dng_load_raw;
      break;
    case 8:
        if (tiff_sampleformat == 3 && tiff_bps > 8 && (tiff_bps % 8 == 0) && tiff_bps <= 32)
            load_raw = &LibRaw::deflate_dng_load_raw;
        else if((tiff_sampleformat == 0 || tiff_sampleformat == 1) && tiff_bps>=8 && tiff_bps <=16)
          load_raw = &LibRaw::deflate_dng_load_raw;
        break;
    case 9:
        load_raw = &LibRaw::vc5_dng_load_raw_placeholder;
        break;
    case 52546:
      load_raw = &LibRaw::jxl_dng_load_raw_placeholder;
      break;
    case 34892:
      load_raw = &LibRaw::lossy_dng_load_raw;
      break;
    default:
      load_raw = 0;
    }
    GetNormalizedModel();
    if (makeIs(LIBRAW_CAMERAMAKER_Leica)) {
      if (!strcmp(model, "SL2")) 
              height -= 3;
          if (!strncasecmp(model, "Q2 MONO",7))
              height -= 18;
    }

    else if (makeIs(LIBRAW_CAMERAMAKER_Olympus) &&
        (OlyID == OlyID_STYLUS_1) && // don't use normalized_model below, it is 'Stylus 1'
        (strchr(model+6, 's') ||
         strchr(model+6, 'S')))
    {
      width -= 16;
    }
    goto dng_skip;
  }

  if (makeIs(LIBRAW_CAMERAMAKER_Canon) && !fsize && tiff_bps != 15)
  {
      bool fromtable = false;
    if (!load_raw)
      load_raw = &LibRaw::lossless_jpeg_load_raw;
    for (i = 0; i < int(sizeof canon / sizeof *canon); i++)
      if (raw_width == canon[i][0] && raw_height == canon[i][1])
      {
        width = raw_width - (left_margin = canon[i][2]);
        height = raw_height - (top_margin = canon[i][3]);
        width -= canon[i][4];
        height -= canon[i][5];
        mask[0][1] = canon[i][6];
        mask[0][3] = -canon[i][7];
        mask[1][1] = canon[i][8];
        mask[1][3] = -canon[i][9];
        if (canon[i][10])
          filters = canon[i][10] * 0x01010101U;
        fromtable = true;
      }
    if ((unique_id | 0x20000ULL) ==
        0x2720000ULL) // "PowerShot G11", "PowerShot S90": 0x2700000, 0x2720000
                      // possibly "PowerShot SX120 IS" (if not chdk hack?): 0x2710000
    {
      left_margin = 8;
      top_margin = 16;
    }
    if(!fromtable && imCanon.AverageBlackLevel) // not known, but metadata known
    {
        FORC4 cblack[c] = imCanon.ChannelBlackLevel[c];
        black = cblack[4] = cblack[5] = 0;
        // Prevent automatic BL calculation
        mask[0][3] = 1;
        mask[0][1] = 2;

        if ((imCanon.SensorWidth == raw_width) &&
            (imCanon.SensorHeight == raw_height))
        {
            left_margin = (imCanon.DefaultCropAbsolute.l+1) & 0xfffe; // round to 2
            width = imCanon.DefaultCropAbsolute.r - left_margin;
            top_margin = (imCanon.DefaultCropAbsolute.t +1)  & 0xfffe;
            height = imCanon.DefaultCropAbsolute.b - top_margin;
        }
    }
  }

  identify_finetune_by_filesize(fsize);

  if (!strcmp(model, "KAI-0340") && find_green(16, 16, 3840, 5120) < 25)
  {
    height = 480;
    top_margin = filters = 0;
    strcpy(model, "C603");
  }

  GetNormalizedModel();

  identify_finetune_dcr(head, fsize, flen);

  /* Early reject for damaged images */
  if (!load_raw || height < 22 || width < 22 ||
      (tiff_bps > 16 &&
       (load_raw != &LibRaw::deflate_dng_load_raw &&
        load_raw != &LibRaw::uncompressed_fp_dng_load_raw)) ||
      tiff_samples > 4 || colors > 4 ||
      colors < 1
      /* alloc in unpack() may be fooled by size adjust */
      || ((int)width + (int)left_margin > 65535) ||
      ((int)height + (int)top_margin > 65535))
  {
    is_raw = 0;
    RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY, 1, 2);
    return;
  }
  if (!model[0])
  {
    sprintf(model, "%dx%d", width, height);
    strcpy(normalized_model, model);
  }

  if (!(imgdata.rawparams.options & LIBRAW_RAWOPTIONS_ZEROFILTERS_FOR_MONOCHROMETIFFS) &&
      (filters == UINT_MAX)) // Default dcraw behaviour
    filters = 0x94949494;
  else if (filters == UINT_MAX)
  {
    if (tiff_nifds > 0 && tiff_samples == 1)
    {
      colors = 1;
      filters = 0;
    }
    else
      filters = 0x94949494;
  }

  if (thumb_offset && !thumb_height)
  {
    fseek(ifp, thumb_offset, SEEK_SET);
    if (ljpeg_start(&jh, 1))
    {
      thumb_width = jh.wide;
      thumb_height = jh.high;
    }
  }

dng_skip:
  if (dng_version)
    identify_process_dng_fields();

  /* Early reject for damaged images again (after dng fields processing) */
  if (!load_raw || height < 22 || width < 22 ||
      (tiff_bps > 16 &&
       (load_raw != &LibRaw::deflate_dng_load_raw &&
        load_raw != &LibRaw::uncompressed_fp_dng_load_raw )) ||
      ((load_raw == &LibRaw::deflate_dng_load_raw || load_raw == &LibRaw::uncompressed_fp_dng_load_raw)
        && (tiff_bps < 16 || tiff_bps > 32 || (tiff_bps % 8))   )
      ||tiff_samples > 4 || colors > 4 || colors < 1)
  {
    is_raw = 0;
    RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY, 1, 2);
    return;
  }
  {
    // Check cam_mul range
    int cmul_ok = 1;
    FORCC if (cam_mul[c] <= 0.001f) cmul_ok = 0;
    ;

    if (cmul_ok)
    {
      double cmin = cam_mul[0], cmax;
      double cnorm[4];
      FORCC cmin = MIN(cmin, cam_mul[c]);
      FORCC cnorm[c] = cam_mul[c] / cmin;
      cmax = cmin = cnorm[0];
      FORCC
      {
        cmin = MIN(cmin, cnorm[c]);
        cmax = MAX(cmax, cnorm[c]);
      }
      if (cmin <= 0.01f || cmax > 100.f)
        cmul_ok = false;
    }
    if (!cmul_ok)
    {
      if (cam_mul[0] > 0)
        cam_mul[0] = 0;
      cam_mul[3] = 0;
    }
  }
  if ((use_camera_matrix & (((use_camera_wb || dng_version)?1:0) | 0x2)) &&
      cmatrix[0][0] > 0.125)
  {
    memcpy(rgb_cam, cmatrix, sizeof cmatrix);
    raw_color = 0;
  }
  if (raw_color && !CM_found)
    CM_found = adobe_coeff(maker_index, normalized_model);
  else if ((imgdata.color.cam_xyz[0][0] < 0.01) && !CM_found)
    CM_found = adobe_coeff(maker_index, normalized_model, 1);

  if (load_raw == &LibRaw::kodak_radc_load_raw)
    if ((raw_color) && !CM_found)
    CM_found = adobe_coeff(LIBRAW_CAMERAMAKER_Apple, "Quicktake");

  if ((maker_index != LIBRAW_CAMERAMAKER_Unknown) && normalized_model[0])
    SetStandardIlluminants (maker_index, normalized_model);

  // Clear erroneous fuji_width if not set through parse_fuji or for DNG
  if (fuji_width && !dng_version &&
      !(imgdata.process_warnings & LIBRAW_WARN_PARSEFUJI_PROCESSED))
    fuji_width = 0;

  if (fuji_width)
  {
    fuji_width = width >> int(!fuji_layout);
    filters = fuji_width & 1 ? 0x94949494 : 0x49494949;
    width = (height >> fuji_layout) + fuji_width;
    height = width - 1;
    pixel_aspect = 1;
  // Prevent incorrect-sized fuji-rotated files
  if (INT64(width)*INT64(height) > INT64(raw_width) * INT64(raw_height) * 8LL)
    is_raw = 0;

  // All 'fuji-rotated' images are 6Mpix or less, so 8k x 8k limit is OK
  if(width > 8192 || height > 8192 || raw_width > 8192 || raw_height > 8192)
      is_raw = 0;
  }
  else
  {
    if (raw_height < height)
      raw_height = height;
    if (raw_width < width)
      raw_width = width;
  }
  if (!tiff_bps)
    tiff_bps = 12;
  if (!maximum)
  {
    maximum = (1 << tiff_bps) - 1;
    if (maximum < 0x10000 && curve[maximum] > 0 &&
        load_raw == &LibRaw::sony_arw2_load_raw)
      maximum = curve[maximum];
  }
  if (maximum > 0xffff)
    maximum = 0xffff;
  if (!load_raw || height < 22 || width < 22 ||
      (tiff_bps > 16 &&
       (load_raw != &LibRaw::deflate_dng_load_raw &&
        load_raw != &LibRaw::uncompressed_fp_dng_load_raw)) ||
      tiff_samples > 6 || colors > 4 || colors == 2)
    is_raw = 0;

  if (raw_width < 22 || raw_width > 64000 || raw_height < 22 ||
      pixel_aspect < 0.1 || pixel_aspect > 10. ||
      raw_height > 64000)
    is_raw = 0;
   if(raw_width <= left_margin || raw_height <= top_margin)
       is_raw = 0;
   if (dng_version && (tiff_samples < 1 || tiff_samples > 4))
       is_raw = 0; // we do not handle DNGs with more than 4 values per pixel

#ifdef NO_JPEG
  if (load_raw == &LibRaw::kodak_jpeg_load_raw ||
      load_raw == &LibRaw::lossy_dng_load_raw)
  {
    is_raw = 0;
    imgdata.process_warnings |= LIBRAW_WARN_NO_JPEGLIB;
  }
#endif
  if (!cdesc[0])
    strcpy(cdesc, colors == 3 ? "RGBG" : "GMCY");
  if (!raw_height)
    raw_height = height;
  if (!raw_width)
    raw_width = width;
  if (filters > 999 && colors == 3)
    filters |= ((filters >> 2 & 0x22222222) | (filters << 2 & 0x88888888)) &
               filters << 1;
notraw:
  if (flip == (int)UINT_MAX)
    flip = tiff_flip;
  if (flip == (int)UINT_MAX)
    flip = 0;

  // Convert from degrees to bit-field if needed
  if (flip > 89 || flip < -89)
  {
    switch ((flip + 3600) % 360)
    {
    case 270:
      flip = 5;
      break;
    case 180:
      flip = 3;
      break;
    case 90:
      flip = 6;
      break;
    }
  }

  if (pana_bpp)
    imgdata.color.raw_bps = pana_bpp;
  else if ((load_raw == &LibRaw::phase_one_load_raw) ||
       (load_raw == &LibRaw::phase_one_load_raw_s) ||
           (load_raw == &LibRaw::phase_one_load_raw_c))
    imgdata.color.raw_bps = ph1.format;
  else
    imgdata.color.raw_bps = tiff_bps;

  RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY, 1, 2);
}

void LibRaw::identify_process_dng_fields()
{
  if (!dng_version) return;

  // Cleanup inset_crops if set by makernotes parser
  imgdata.sizes.raw_inset_crops[0].cleft = imgdata.sizes.raw_inset_crops[0].ctop =
        imgdata.sizes.raw_inset_crops[1].cleft = imgdata.sizes.raw_inset_crops[1].ctop = 0xffff;
    imgdata.sizes.raw_inset_crops[0].cwidth = imgdata.sizes.raw_inset_crops[0].cheight =
        imgdata.sizes.raw_inset_crops[1].cwidth = imgdata.sizes.raw_inset_crops[1].cheight = 0;


  int c;
  {
    /* copy DNG data from per-IFD field to color.dng */
    int iifd = find_ifd_by_offset(data_offset);
    int pifd = find_ifd_by_offset(thumb_offset);


#define IFDCOLORINDEX(ifd, subset, bit)                                        \
  (tiff_ifd[ifd].dng_color[subset].parsedfields & bit)                         \
      ? ifd                                                                    \
      : ((tiff_ifd[0].dng_color[subset].parsedfields & bit) ? 0 : -1)

#define IFDLEVELINDEX(ifd, bit)                                                \
  (tiff_ifd[ifd].dng_levels.parsedfields & bit)                                \
      ? ifd                                                                    \
      : ((tiff_ifd[0].dng_levels.parsedfields & bit) ? 0 : -1)

#define COPYARR(to, from) memmove(&to, &from, sizeof(from))

    if (iifd < (int)tiff_nifds && iifd >= 0)
    {
      int sidx;
      // Per field, not per structure
      if (!(imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DONT_CHECK_DNG_ILLUMINANT))
      {
        int illidx[2], cmidx[2], calidx[2], abidx;
        for (int i = 0; i < 2; i++)
        {
          illidx[i] = IFDCOLORINDEX(iifd, i, LIBRAW_DNGFM_ILLUMINANT);
          cmidx[i] = IFDCOLORINDEX(iifd, i, LIBRAW_DNGFM_COLORMATRIX);
          calidx[i] = IFDCOLORINDEX(iifd, i, LIBRAW_DNGFM_CALIBRATION);
        }
        abidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_ANALOGBALANCE);
        // Data found, all in same ifd, illuminants are inited
        if (illidx[0] >= 0 && illidx[0] < (int)tiff_nifds &&
          illidx[0] == illidx[1] && illidx[0] == cmidx[0] &&
          illidx[0] == cmidx[1] &&
          tiff_ifd[illidx[0]].dng_color[0].illuminant > 0 &&
          tiff_ifd[illidx[0]].dng_color[1].illuminant > 0)
        {
          sidx = illidx[0]; // => selected IFD
          double cc[4][4], cm[4][3], cam_xyz[4][3];
          // CM -> Color Matrix
          // CC -> Camera calibration
          for (int j = 0; j < 4; j++)
            for (int i = 0; i < 4; i++)
              cc[j][i] = i == j;
          int colidx = -1;

          // IS D65 here?
          for (int i = 0; i < 2; i++)
          {
            if (tiff_ifd[sidx].dng_color[i].illuminant == LIBRAW_WBI_D65)
            {
              colidx = i;
              break;
            }
          }

          // Other daylight-type ill
          if (colidx < 0)
            for (int i = 0; i < 2; i++)
            {
              int ill = tiff_ifd[sidx].dng_color[i].illuminant;
              if (ill == LIBRAW_WBI_Daylight || ill == LIBRAW_WBI_D55 ||
                ill == LIBRAW_WBI_D75 || ill == LIBRAW_WBI_D50 ||
                ill == LIBRAW_WBI_Flash)
              {
                colidx = i;
                break;
              }
            }
          if (colidx >= 0) // Selected
          {
            // Init camera matrix from DNG
            FORCC for (int j = 0; j < 3; j++) cm[c][j] =
              tiff_ifd[sidx].dng_color[colidx].colormatrix[c][j];

            if (calidx[colidx] == sidx)
            {
              for (int i = 0; i < colors && i < 4; i++)
                FORCC
                cc[i][c] = tiff_ifd[sidx].dng_color[colidx].calibration[i][c];
            }

            if (abidx == sidx)
              for (int i = 0; i < colors && i < 4; i++)
                FORCC cc[i][c] *= tiff_ifd[sidx].dng_levels.analogbalance[i];
            int j;
            FORCC for (int i = 0; i < 3; i++)
                            for (cam_xyz[c][i] = j = 0; j < colors && j < 4; j++)
                  cam_xyz[c][i] +=
                      cc[c][j] * cm[j][i]; // add AsShotXY later * xyz[i];
            cam_xyz_coeff(cmatrix, cam_xyz);
          }
        }
      }

      bool noFujiDNGCrop = makeIs(LIBRAW_CAMERAMAKER_Fujifilm)
        && (!strcmp(normalized_model, "S3Pro")
          || !strcmp(normalized_model, "S5Pro")
          || !strcmp(normalized_model, "S2Pro"));

      if (!noFujiDNGCrop) // Promote DNG Crops to raw_inset_crops
      {
        sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_CROPORIGIN);
        int sidx2 = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_CROPSIZE);
                if (sidx >= 0 && sidx == sidx2 &&
                    tiff_ifd[sidx].dng_levels.default_crop[2] > 0 &&
                    tiff_ifd[sidx].dng_levels.default_crop[3] > 0)
                {
                    int lm = tiff_ifd[sidx].dng_levels.default_crop[0];
                    int tm = tiff_ifd[sidx].dng_levels.default_crop[1];
                    int ww = tiff_ifd[sidx].dng_levels.default_crop[2];
                    int hh = tiff_ifd[sidx].dng_levels.default_crop[3];
                    if ((lm + ww < int(raw_width) + int(left_margin))
                        && (tm + hh < int(raw_height) + int(top_margin))) // Crop data is correct
                    {
                        imgdata.sizes.raw_inset_crops[0].cleft = left_margin + lm;
                        imgdata.sizes.raw_inset_crops[0].cwidth = ww;
                        imgdata.sizes.raw_inset_crops[0].ctop = top_margin + tm;
                        imgdata.sizes.raw_inset_crops[0].cheight = hh;

                        int sidx3 = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_USERCROP);
                        if (sidx3 >= 0 && sidx3 == sidx) // No need to check values range, it is checked at parse
                        {
                            int dt = int(imgdata.sizes.raw_inset_crops[0].cheight * tiff_ifd[sidx].dng_levels.user_crop[0]);
                            int dl = int(imgdata.sizes.raw_inset_crops[0].cwidth * tiff_ifd[sidx].dng_levels.user_crop[1]);
                            int db = int(imgdata.sizes.raw_inset_crops[0].cheight * tiff_ifd[sidx].dng_levels.user_crop[2]);
                            int dr = int(imgdata.sizes.raw_inset_crops[0].cwidth * tiff_ifd[sidx].dng_levels.user_crop[3]);

                            int dh = db - dt;
                            int dw = dr - dl;

                            if (dh > 0 && dw > 0
                                && dh < imgdata.sizes.raw_inset_crops[0].cheight // No need to repeat crop for 0,0,1,1
                                && dw < imgdata.sizes.raw_inset_crops[0].cwidth)
                            {
                                imgdata.sizes.raw_inset_crops[1].cleft = imgdata.sizes.raw_inset_crops[0].cleft + dl;
                                imgdata.sizes.raw_inset_crops[1].cwidth = dw;
                                imgdata.sizes.raw_inset_crops[1].ctop = imgdata.sizes.raw_inset_crops[0].ctop + dt;
                                imgdata.sizes.raw_inset_crops[1].cheight = dh;
                            }
                        }

                    }
                }
      }
      if (!(imgdata.color.dng_color[0].parsedfields &
        LIBRAW_DNGFM_FORWARDMATRIX)) // Not set already (Leica makernotes)
      {
        sidx = IFDCOLORINDEX(iifd, 0, LIBRAW_DNGFM_FORWARDMATRIX);
        if (sidx >= 0)
          COPYARR(imgdata.color.dng_color[0].forwardmatrix,
            tiff_ifd[sidx].dng_color[0].forwardmatrix);
      }
      if (!(imgdata.color.dng_color[1].parsedfields &
        LIBRAW_DNGFM_FORWARDMATRIX)) // Not set already (Leica makernotes)
      {
        sidx = IFDCOLORINDEX(iifd, 1, LIBRAW_DNGFM_FORWARDMATRIX);
        if (sidx >= 0)
          COPYARR(imgdata.color.dng_color[1].forwardmatrix,
            tiff_ifd[sidx].dng_color[1].forwardmatrix);
      }
      for (int ss = 0; ss < 2; ss++)
      {
        sidx = IFDCOLORINDEX(iifd, ss, LIBRAW_DNGFM_COLORMATRIX);
        if (sidx >= 0)
          COPYARR(imgdata.color.dng_color[ss].colormatrix,
            tiff_ifd[sidx].dng_color[ss].colormatrix);

        sidx = IFDCOLORINDEX(iifd, ss, LIBRAW_DNGFM_CALIBRATION);
        if (sidx >= 0)
          COPYARR(imgdata.color.dng_color[ss].calibration,
            tiff_ifd[sidx].dng_color[ss].calibration);

        sidx = IFDCOLORINDEX(iifd, ss, LIBRAW_DNGFM_ILLUMINANT);
        if (sidx >= 0)
          imgdata.color.dng_color[ss].illuminant =
          tiff_ifd[sidx].dng_color[ss].illuminant;
      }
      // Levels
      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_ANALOGBALANCE);
      if (sidx >= 0)
        COPYARR(imgdata.color.dng_levels.analogbalance,
          tiff_ifd[sidx].dng_levels.analogbalance);

      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_BASELINEEXPOSURE);
      if (sidx >= 0)
        imgdata.color.dng_levels.baseline_exposure =
        tiff_ifd[sidx].dng_levels.baseline_exposure;

      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_WHITE);
      if (sidx >= 0 && tiff_ifd[sidx].dng_levels.dng_whitelevel[0])
        COPYARR(imgdata.color.dng_levels.dng_whitelevel,
          tiff_ifd[sidx].dng_levels.dng_whitelevel);
      else if (tiff_ifd[iifd].sample_format <= 2 && tiff_ifd[iifd].bps > 0 && tiff_ifd[iifd].bps < 32)
        FORC4
        imgdata.color.dng_levels.dng_whitelevel[c] = (1 << tiff_ifd[iifd].bps) - 1;

      // Copy dng opcode data for selected ifd to imgdata.color: if no opcodes present just 0/null copied
      // DNG OpcodeListN should be in the selected IFD, not at global level (??)
      // Note: pointer is copied; the data will be free'ed at recycle() by mem manager.
      for (int i = 0; i < 3; i++)
      {
        imgdata.color.dng_levels.rawopcodes[i].len = tiff_ifd[iifd].dng_levels.rawopcodes[i].len;
        imgdata.color.dng_levels.rawopcodes[i].data = tiff_ifd[iifd].dng_levels.rawopcodes[i].data;
      }

      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_ASSHOTNEUTRAL);
      if (sidx >= 0)
      {
        COPYARR(imgdata.color.dng_levels.asshotneutral,
          tiff_ifd[sidx].dng_levels.asshotneutral);
        if (imgdata.color.dng_levels.asshotneutral[0])
        {
          cam_mul[3] = 0;
          FORCC
            if (fabs(imgdata.color.dng_levels.asshotneutral[c]) > 0.0001)
              cam_mul[c] = 1 / imgdata.color.dng_levels.asshotneutral[c];
        }
      }
      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_BLACK);
      if (sidx >= 0)
      {
        imgdata.color.dng_levels.dng_fblack =
          tiff_ifd[sidx].dng_levels.dng_fblack;
        imgdata.color.dng_levels.dng_black =
          tiff_ifd[sidx].dng_levels.dng_black;
        COPYARR(imgdata.color.dng_levels.dng_cblack,
          tiff_ifd[sidx].dng_levels.dng_cblack);
        COPYARR(imgdata.color.dng_levels.dng_fcblack,
          tiff_ifd[sidx].dng_levels.dng_fcblack);
      }


      if (pifd >= 0)
      {
        sidx = IFDLEVELINDEX(pifd, LIBRAW_DNGFM_PREVIEWCS);
        if (sidx >= 0)
          imgdata.color.dng_levels.preview_colorspace =
          tiff_ifd[sidx].dng_levels.preview_colorspace;
      }
      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_OPCODE2);
      if (sidx >= 0)
        meta_offset = tiff_ifd[sidx].opcode2_offset;

      sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_LINTABLE);
      INT64 linoff = -1;
      int linlen = 0;
      if (sidx >= 0)
      {
        linoff = tiff_ifd[sidx].lineartable_offset;
        linlen = tiff_ifd[sidx].lineartable_len;
      }

      if (linoff >= 0 && linlen > 0)
      {
        INT64 pos = ftell(ifp);
        fseek(ifp, linoff, SEEK_SET);
        linear_table(linlen);
        fseek(ifp, pos, SEEK_SET);
      }
      // Need to add curve too
    }
    /* Copy DNG black level to LibRaw's */
    if (load_raw == &LibRaw::lossy_dng_load_raw)
    {
      maximum = 0xffff;
      FORC4 imgdata.color.linear_max[c] = imgdata.color.dng_levels.dng_whitelevel[c] = 0xffff;
    }
    else
    {
      maximum = imgdata.color.dng_levels.dng_whitelevel[0];
    }
    black = imgdata.color.dng_levels.dng_black;
    if (tiff_samples == 2 &&
        !imgdata.color.dng_levels.dng_cblack[2] &&
        !imgdata.color.dng_levels.dng_cblack[3] &&
        (imgdata.color.dng_levels.dng_cblack[4] == 1) &&
        (imgdata.color.dng_levels.dng_cblack[5] == 1)
            && (imgdata.color.dng_levels.dng_cblack[LIBRAW_CBLACK_SIZE - 1] == tiff_samples)
            ) {
      black = imgdata.color.dng_levels.dng_cblack[shot_select];
      imgdata.color.dng_levels.dng_cblack[0] = imgdata.color.dng_levels.dng_cblack[1] = 0;
      imgdata.color.dng_levels.dng_cblack[4] = imgdata.color.dng_levels.dng_cblack[5] = 0;
      imgdata.color.dng_levels.dng_fcblack[0] = imgdata.color.dng_levels.dng_fcblack[1] = 0.0f;
      imgdata.color.dng_levels.dng_fcblack[4] = imgdata.color.dng_levels.dng_fcblack[5] = 0.0f;
    }
    else if (tiff_samples == 2 && imgdata.color.dng_levels.dng_cblack[4] * imgdata.color.dng_levels.dng_cblack[5] * tiff_samples
      == imgdata.color.dng_levels.dng_cblack[LIBRAW_CBLACK_SIZE - 1])
    {
      unsigned ff = filters;
      if (filters > 999 && colors == 3)
        filters |= ((filters >> 2 & 0x22222222) | (filters << 2 & 0x88888888)) &
        filters << 1;

      /* Special case, Fuji SuperCCD dng */
      int csum[4] = { 0,0,0,0 }, ccount[4] = { 0,0,0,0 };
      int i = 6 + shot_select;
      for (unsigned row = 0; row < imgdata.color.dng_levels.dng_cblack[4]; row++)
        for (unsigned col = 0; col < imgdata.color.dng_levels.dng_cblack[5]; col++)
        {
          csum[FC(row, col)] += imgdata.color.dng_levels.dng_cblack[i];
          ccount[FC(row, col)]++;
          i += tiff_samples;
        }
      for (int q = 0; q < 4; q++)
        if (ccount[q])
          imgdata.color.dng_levels.dng_cblack[q] += csum[q] / ccount[q];
      imgdata.color.dng_levels.dng_cblack[4] = imgdata.color.dng_levels.dng_cblack[5] = 0;
      filters = ff;
    }
    else if (tiff_samples > 2 && tiff_samples <= 4 && imgdata.color.dng_levels.dng_cblack[4] * imgdata.color.dng_levels.dng_cblack[5] * tiff_samples
      == imgdata.color.dng_levels.dng_cblack[LIBRAW_CBLACK_SIZE - 1])
    {
      /* Special case, per_channel blacks in RepeatDim, average for per-channel */
      int csum[4] = { 0,0,0,0 }, ccount[4] = { 0,0,0,0 };
      int i = 6;
      for (unsigned row = 0; row < imgdata.color.dng_levels.dng_cblack[4]; row++)
        for (unsigned col = 0; col < imgdata.color.dng_levels.dng_cblack[5]; col++)
          for (unsigned q = 0; q < tiff_samples && q < 4; q++)
          {
            csum[q] += imgdata.color.dng_levels.dng_cblack[i];
            ccount[q]++;
            i++;
          }
      for (int q = 0; q < 4; q++)
        if (ccount[q])
          imgdata.color.dng_levels.dng_cblack[q] += csum[q] / ccount[q];
      imgdata.color.dng_levels.dng_cblack[4] = imgdata.color.dng_levels.dng_cblack[5] = 0;
    }

    memmove(cblack, imgdata.color.dng_levels.dng_cblack, sizeof(cblack));

    if (iifd < (int)tiff_nifds && iifd >= 0)
    {
      int sidx = IFDLEVELINDEX(iifd, LIBRAW_DNGFM_LINEARRESPONSELIMIT);
      if (sidx >= 0)
      {
        imgdata.color.dng_levels.LinearResponseLimit =
          tiff_ifd[sidx].dng_levels.LinearResponseLimit;
        if (imgdata.color.dng_levels.LinearResponseLimit > 0.1 &&
          imgdata.color.dng_levels.LinearResponseLimit <= 1.0)
        {
          // And approx promote it to linear_max:
          int bl4 = 0, bl64 = 0;
          for (int chan = 0; chan < colors && chan < 4; chan++)
            bl4 += cblack[chan];
          bl4 /= LIM(colors, 1, 4);

          if (cblack[4] * cblack[5] > 0)
          {
            unsigned cnt = 0;
            for (unsigned q = 0; q < 4096 && q < cblack[4] * cblack[5]; q++)
            {
              bl64 += cblack[q + 6];
              cnt++;
            }
            bl64 /= LIM(cnt, 1, 4096);
          }
          int rblack = black + bl4 + bl64;
          for (int chan = 0; chan < colors && chan < 4; chan++)
            imgdata.color.linear_max[chan] =
            unsigned(
            (maximum - rblack) *
              imgdata.color.dng_levels.LinearResponseLimit +
              rblack
              );
                    if (imgdata.color.linear_max[1] && !imgdata.color.linear_max[3])
                        imgdata.color.linear_max[3] = imgdata.color.linear_max[1];
        }
      }
    }
  }
}

void LibRaw::identify_finetune_pentax()
{
    if (dng_version && data_offset)
    {
        for(int i = 0; i < (int)tiff_nifds; i++)
            if (tiff_ifd[i].offset == data_offset)
            {
                if (tiff_ifd[i].phint == 34892) return; // Linear DNG made from Pentax source
                break;
            }
    }

  if (makeIs(LIBRAW_CAMERAMAKER_Pentax) ||
    makeIs(LIBRAW_CAMERAMAKER_Samsung)) {
    if (height == 2624 &&
      width == 3936) // Pentax K10D, Samsung GX10;
    {
      height = 2616;
      width = 3896;
    }
    if (height == 3136 &&
      width == 4864) // Pentax K20D, Samsung GX20;
    {
      height = 3124;
      width = 4688;
      filters = 0x16161616;
    }
  }

  if (makeIs(LIBRAW_CAMERAMAKER_Pentax)) {
    if ((width == 4352) &&
      ((unique_id == PentaxID_K_r) ||
      (unique_id == PentaxID_K_x)))
    {
      width = 4309;
      filters = 0x16161616;
    }
    if ((width >= 4960) &&
      ((unique_id == PentaxID_K_5) ||
      (unique_id == PentaxID_K_5_II) ||
        (unique_id == PentaxID_K_5_II_s)))
    {
      left_margin = 10;
      width = 4950;
      filters = 0x16161616;
    }
    if ((width == 6080) && (unique_id == PentaxID_K_70))
    {
      height = 4016;
      top_margin = 32;
      width = 6020;
      left_margin = 60;
    }
    if ((width == 4736) && (unique_id == PentaxID_K_7))
    {
      height = 3122;
      width = 4684;
      filters = 0x16161616;
      top_margin = 2;
    }
    if (width == 6080 && (unique_id == PentaxID_KF))
    {
      top_margin = 28;
      height = 4024;
      left_margin = 56;
      width = 6024;
    }
    if ((width == 6080) && (unique_id == PentaxID_K_3_II))
    {
      left_margin = 4;
      width = 6040;
    }
        if ((width == 6304) && (unique_id == PentaxID_K_3_III)) // From DNG ActiveArea
        {
          left_margin = 26;
          width = 6224;
          top_margin = 34;
          height = 4160;
        }
        if (unique_id == PentaxID_K_3_III_Mono) 
        {
      if (width == 6304)
      {
              left_margin = 26;
              width = 6224;
              top_margin = 34;
              height = 4160;
            }
      filters = 0;
      colors = 1;
        }
        if ((width == 6112) && (unique_id == PentaxID_KP))
    {
      // From DNG, maybe too strict
      left_margin = 54;
      top_margin = 28;
      width = 6028;
      height = raw_height - top_margin;
    }
    if ((width == 6080) && (unique_id == PentaxID_K_3))
    {
      left_margin = 4;
      width = 6040;
    }
    if ((width == 7424) && (unique_id == PentaxID_645D))
    {
      height = 5502;
      width = 7328;
      filters = 0x61616161;
      top_margin = 29;
      left_margin = 48;
    }
  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Ricoh) &&
    (height == 3014) && (width == 4096))  // Ricoh GX200
    width = 4014;
}

void LibRaw::identify_finetune_by_filesize(INT64 fsize)
{

  if (fsize == 4771840)
  { // hack Nikon 3mpix: E880, E885, E990, E995;
    // Olympus C-3030Z
    if (!timestamp && nikon_e995())
      strcpy(model, "E995");
  }
  else if (fsize == 2940928)
  { // hack Nikon 2mpix: E2100, E2500
    if (!timestamp && !nikon_e2100())
      strcpy(model, "E2500");
  }
  else if (fsize == 4775936)
  { // hack Nikon 3mpix: E3100, E3200, E3500, E3700;
    // Pentax "Optio 33WR";
    // Olympus C-740UZ
    if (!timestamp)
      nikon_3700();
  }
  else if (fsize == 5869568)
  { // hack Nikon 4mpix: E4300;
    // hack Minolta "DiMAGE Z2"
    if (!timestamp && minolta_z2())
    {
      maker_index = LIBRAW_CAMERAMAKER_Minolta;
      strcpy(make, "Minolta");
      strcpy(model, "DiMAGE Z2");
    }
  }
}

void LibRaw::identify_finetune_dcr(char head[64], INT64 fsize, INT64 flen)
{
  static const short pana[][6] = {
    // raw_width, raw_height, left_margin, top_margin, width_increment,
    // height_increment
    {3130, 1743, 4, 0, -6, 0},      /* 00 */
    {3130, 2055, 4, 0, -6, 0},      /* 01 */
    {3130, 2319, 4, 0, -6, 0},      /* 02 DMC-FZ8 */
    {3170, 2103, 18, 0, -42, 20},   /* 03 */
    {3170, 2367, 18, 13, -42, -21}, /* 04 */
    {3177, 2367, 0, 0, -1, 0},      /* 05 DMC-L1 */
    {3304, 2458, 0, 0, -1, 0},      /* 06 DMC-FZ30 */
    {3330, 2463, 9, 0, -5, 0},      /* 07 DMC-FZ18 */
    {3330, 2479, 9, 0, -17, 4},     /* 08 */
    {3370, 1899, 15, 0, -44, 20},   /* 09 */
    {3370, 2235, 15, 0, -44, 20},   /* 10 */
    {3370, 2511, 15, 10, -44, -21}, /* 11 */
    {3690, 2751, 3, 0, -8, -3},     /* 12 DMC-FZ50 */
    {3710, 2751, 0, 0, -3, 0},      /* 13 DMC-L10 */
    {3724, 2450, 0, 0, 0, -2},      /* 14 */
    {3770, 2487, 17, 0, -44, 19},   /* 15 */
    {3770, 2799, 17, 15, -44, -19}, /* 16 */
    {3880, 2170, 6, 0, -6, 0},      /* 17 DMC-LX1 */
    {4060, 3018, 0, 0, 0, -2},      /* 18 DMC-FZ35, DMC-FZ38 */
    {4290, 2391, 3, 0, -8, -1},     /* 19 DMC-LX2 */
    {4330, 2439, 17, 15, -44, -19}, /* 20 "D-LUX 3" */
    {4508, 2962, 0, 0, -3, -4},     /* 21 */
    {4508, 3330, 0, 0, -3, -6},     /* 22 */
    {10480, 7794, 0, 0, -2, 0},     /* 23: G9 in high-res */
        {11560, 8680, 8, 8, -16, -16},     /* 24: GH7 in high-res */
  };
  int i,c;
  struct jhead jh;

  if (makeIs(LIBRAW_CAMERAMAKER_Canon) 
        && ( !tiff_flip || unique_id == CanonID_EOS_40D)
    && !(imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CANON_IGNORE_MAKERNOTES_ROTATION)
    // Do not check Auto-Rotate, or AutoRotateMode is not Off (0)
    && (!(imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CANON_CHECK_CAMERA_AUTO_ROTATION_MODE) || imCanon.AutoRotateMode )
        && imCanon.MakernotesFlip)
  {
    tiff_flip = imCanon.MakernotesFlip;
  }

  else if (makeIs(LIBRAW_CAMERAMAKER_Nikon))
  {
    if (!load_raw)
      load_raw = &LibRaw::packed_load_raw;
    if (model[0] == 'E') // Nikon E8800, E8700, E8400, E5700, E5400, E5000,
               // others are diag hacks?
      load_flags |= !data_offset << 2 | 2;
  }
  /* Set parameters based on camera name (for non-DNG files). */

  /* Always 512 for arw2_load_raw */
  else if (makeIs(LIBRAW_CAMERAMAKER_Sony) &&
    (raw_width > 3888) && !black && !cblack[0])
  {
    black = (load_raw == &LibRaw::sony_arw2_load_raw)
      ? 512
      : (128 << (tiff_bps - 12));
  }

  if (is_foveon) {
    if (height * 2 < width)
      pixel_aspect = 0.5;
    if (height > width)
      pixel_aspect = 2;
    filters = 0;

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Pentax)) {
    if ((unique_id == PentaxID_K_1) ||
      (unique_id == PentaxID_K_1_Mark_II)) {
      top_margin = 18;
      height = raw_height - top_margin;
      if (raw_width == 7392) {
        left_margin = 6;
        width = 7376;
      }

    }
    else if (unique_id == PentaxID_Optio_S_V101) { // (fsize == 3178560)
      cam_mul[0] *= 4;
      cam_mul[2] *= 4;

    }
    else if (unique_id == PentaxID_Optio_33WR) { // (fsize == 4775936)
      flip = 1;
      filters = 0x16161616;

    }
    else if (unique_id == PentaxID_staristD) {
      load_raw = &LibRaw::unpacked_load_raw;
      /* data_error = -1; */ /* No way to know why data_error was raised in dcraw.c, looks not needed esp. for unpacked_load_raw */
    }
    else if (unique_id == PentaxID_staristDS) {
      height -= 2;
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Canon)) {
    if (tiff_bps == 15) { // Canon sRAW
      if (width == 3344)
        width = 3272;
      else if (width == 3872)
        width = 3866;

      if (height > width) {
        SWAP(height, width);
        SWAP(raw_height, raw_width);
      }
      if (width == 7200 &&
        height == 3888) { // Canon EOS 5DS (R);
        raw_width = width = 6480;
        raw_height = height = 4320;
      }
      filters = 0;
      tiff_samples = colors = 3;
      load_raw = &LibRaw::canon_sraw_load_raw;
    }

    if (!strcmp(normalized_model, "PowerShot 600")) {
      height = 613;
      width = 854;
      raw_width = 896;
      colors = 4;
      filters = 0xe1e4e1e4;
      load_raw = &LibRaw::canon_600_load_raw;

    }
    else if (!strcmp(normalized_model, "PowerShot A5") ||
      !strcmp(normalized_model, "PowerShot A5 Zoom")) {
      height = 773;
      width = 960;
      raw_width = 992;
      pixel_aspect = 256 / 235.0;
      filters = 0x1e4e1e4e;
      goto canon_a5;

    }
    else if (!strcmp(normalized_model, "PowerShot A50")) {
      height = 968;
      width = 1290;
      raw_width = 1320;
      filters = 0x1b4e4b1e;
      goto canon_a5;

    }
    else if (!strcmp(normalized_model, "PowerShot Pro70")) {
      height = 1024;
      width = 1552;
      filters = 0x1e4b4e1b;
    canon_a5:
      colors = 4;
      tiff_bps = 10;
      load_raw = &LibRaw::packed_load_raw;
      load_flags = 40;

    }
    else if (!strcmp(normalized_model, "PowerShot Pro90 IS") ||
      !strcmp(normalized_model, "PowerShot G1")) {
      colors = 4;
      filters = 0xb4b4b4b4;

    }
    else if (!strcmp(normalized_model, "PowerShot A610")) { // chdk hack
      if (canon_s2is()) {
        strcpy(model + 10, "S2 IS");
        strcpy(normalized_model + 10, "S2 IS");
      }

    }
    else if (!strcmp(normalized_model, "PowerShot SX220 HS")) { // chdk hack
      mask[1][3] = -4;
      top_margin = 16;
      left_margin = 92;

    }
    else if (!strcmp(normalized_model, "PowerShot S120")) { // chdk hack
      raw_width = 4192;
      raw_height = 3062;
      width = 4022;
      height = 3016;
      mask[0][0] = top_margin = 31;
      mask[0][2] = top_margin + height;
      left_margin = 120;
      mask[0][1] = 23;
      mask[0][3] = 72;

    }
    else if (!strcmp(normalized_model, "PowerShot G16")) {
      mask[0][0] = 0;
      mask[0][2] = 80;
      mask[0][1] = 0;
      mask[0][3] = 16;
      top_margin = 29;
      left_margin = 120;
      width = raw_width - left_margin - 48;
      height = raw_height - top_margin - 14;

    }
    else if (!strcmp(normalized_model, "PowerShot SX50 HS")) {
      top_margin = 17;
    }

  }

  else if (makeIs(LIBRAW_CAMERAMAKER_Nikon)) {
    if (!strcmp(model, "D1"))
    {
      imgdata.other.analogbalance[0] = cam_mul[0];
      imgdata.other.analogbalance[2] = cam_mul[2];
      imgdata.other.analogbalance[1] = imgdata.other.analogbalance[3] =
        cam_mul[1];
      cam_mul[0] = cam_mul[1] = cam_mul[2] = 1.0f;
    }

    else if (!strcmp(model, "D1X"))
    {
      width -= 4;
      pixel_aspect = 0.5;
    }
    else if (!strcmp(model, "D40X") ||
      !strcmp(model, "D60") ||
      !strcmp(model, "D80") ||
      !strcmp(model, "D3000"))
    {
      height -= 3;
      width -= 4;
    }
    else if (!strcmp(model, "D3") ||
      !strcmp(model, "D3S") ||
      !strcmp(model, "D700"))
    {
      width -= 4;
      left_margin = 2;
    }
    else if (!strcmp(model, "D3100"))
    {
      width -= 28;
      left_margin = 6;
    }
    else if (!strcmp(model, "D5000") ||
      !strcmp(model, "D90"))
    {
      width -= 42;
    }
    else if (!strcmp(model, "D5100") ||
      !strcmp(model, "D7000") ||
      !strcmp(model, "COOLPIX A"))
    {
      width -= 44;
    }
    else if (!strcmp(model, "D3200") ||
      !strcmp(model, "D600") ||
      !strcmp(model, "D610") ||
      !strncmp(model, "D800", 4)) // Nikons: D800, D800E
    {
      width -= 46;
    }
    else if (!strcmp(model, "D4") ||
      !strcmp(model, "Df"))
    {
      width -= 52;
      left_margin = 2;
    }
    else if (!strcmp(model, "D500"))
    {
      // Empty - to avoid width-1 below
    }
    else if (!strncmp(model, "D40", 3) ||
      !strncmp(model, "D50", 3) ||
      !strncmp(model, "D70", 3))
    {
      width--;
    }
    else if (!strcmp(model, "D100"))
    {
      if (load_flags) // compressed NEF
        raw_width = (width += 3) + 3;
    }
    else if (!strcmp(model, "D200"))
    {
      left_margin = 1;
      width -= 4;
      filters = 0x94949494;
    }
    else if (!strncmp(model, "D2H", 3)) // Nikons: D2H, D2Hs
    {
      left_margin = 6;
      width -= 14;
    }
    else if (!strncmp(model, "D2X", 3)) // Nikons: D2X, D2Xs
    {
      if (width == 3264) // in-camera Hi-speed crop: On
        width -= 32;
      else
        width -= 8;
    }
    else if (!strncmp(model, "D300", 4)) // Nikons: D300, D300s
    {
      width -= 32;
    }
    else if (raw_width == 4032) // Nikon "COOLPIX P7700", "COOLPIX P7800",
                  // "COOLPIX P330", "COOLPIX P340"
    {
      if (!strcmp(normalized_model, "COOLPIX P7700"))
      {
        maximum = 65504;
        load_flags = 0;
      }
      else if (!strcmp(normalized_model, "COOLPIX P7800"))
      {
        maximum = 65504;
        load_flags = 0;
      }
      else if (!strcmp(model, "COOLPIX P340"))
      {
        load_flags = 0;
      }
    }
    else if (!strncmp(model, "COOLPIX P", 9) &&
      raw_width != 4032) // Nikon "COOLPIX P1000", "COOLPIX P6000",
                 // "COOLPIX P7000", "COOLPIX P7100"
    {
      load_flags = 24;
      filters = 0x94949494;
      /* the following 'if' is most probably obsolete, because we now read black
       * level from metadata */
      if ((model[9] == '7') && /* P7000, P7100 */
        ((iso_speed >= 400) || (iso_speed == 0)) &&
        !strstr(software, "V1.2")) /* v. 1.2 seen for P7000 only */
        black = 255;
    }
    else if (!strncmp(model, "COOLPIX B700", 12))
    {
      load_flags = 24;
    }
    else if (!strncmp(model, "1 ",
      2)) // Nikons: "1 AW1", "1 J1", "1 J2", "1 J3", "1 J4",
        // "1 J5", "1 S1", "1 S2", "1 V1", "1 V2", "1 V3"
    {
      height -= 2;
    }
    else if (fsize == 1581060) // hack Nikon 1mpix: E900
    {
      simple_coeff(3);
      pre_mul[0] = 1.2085f;
      pre_mul[1] = 1.0943f;
      pre_mul[3] = 1.1103f;
    }
    else if ((fsize == 4771840) &&  // hack Nikon 3mpix: E880, E885, E990
      strcmp(model, "E995")) // but not E995
    {
      filters = 0xb4b4b4b4;
      simple_coeff(3);
      pre_mul[0] = 1.196f;
      pre_mul[1] = 1.246f;
      pre_mul[2] = 1.018f;
    }
    else if ((fsize == 4775936) && // hack Nikon 3mpix: E3100, E3200, E3500
      (atoi(model + 1) < 3700)) // but not E3700;
    {
      filters = 0x49494949;
    }
    else if (fsize == 5869568) // hack Nikon 4mpix: E4300;
    {
      load_flags = 6;
    }
    else if (!strcmp(model, "E2500"))
    {
      height -= 2;
      load_flags = 6;
      colors = 4;
      filters = 0x4b4b4b4b;
    }
  }

  else if (makeIs(LIBRAW_CAMERAMAKER_Olympus)) {
    if (OlyID == OlyID_C_740UZ) { // (fsize == 4775936)
      i = int(find_green(12, 32, 1188864, 3576832));
      c = int(find_green(12, 32, 2383920, 2387016));
      if (abs(i) < abs(c)) {
        SWAP(i, c);
        load_flags = 24;
      }
      if (i < 0)
        filters = 0x61616161;
    }
    else if (OlyID == OlyID_C_770UZ) {
      height = 1718;
      width = 2304;
      filters = 0x16161616;
      load_raw = &LibRaw::packed_load_raw;
      load_flags = 30;
    }
    else {
      height += height & 1;
      if (exif_cfa)
        filters = exif_cfa;

      if (width == 4100) // Olympus E-PL2, E-PL1, E-P2, E-P1, E-620, E-600, E-5, E-30;
        width -= 4;

      if (width == 4080) // Olympus E-PM1, E-PL3, E-P3;
        width -= 24;

      if (width == 10400) // Olympus PEN-F, E-M1-II, E-M1-III, E-M1X, OM-1
        width -= 12;

      if (width == 8200) // E-M1-III in 50Mp mode, E-M1X
        width -= 30;

      if (width == 8180) // OM-1 in 50Mp
              width -= 10;

      if (width == 9280) { // Olympus E-M5 Mark II;
        width -= 6;
        height -= 6;
      }

      if (load_raw == &LibRaw::unpacked_load_raw) {
        load_flags = 4;
        if (imOly.ValidBits == 10) load_flags += 2;
      }
      tiff_bps = imOly.ValidBits;
      if (tiff_bps == 14)
      {
        black *= 4;
        FORC(4) cblack[c] *= 4;
        FORC(4) imgdata.color.linear_max[c] *= 4;
        FORC(MIN(cblack[4] * cblack[5], LIBRAW_CBLACK_SIZE - 6)) cblack[c+6] *= 4;
      }


      if ((OlyID == OlyID_E_300) ||
        (OlyID == OlyID_E_500)) {
        width -= 20;
        if (load_raw == &LibRaw::unpacked_load_raw) {
          maximum = 0xfc3;
          memset(cblack, 0, sizeof cblack);
        }
      }
      else if (OlyID == OlyID_STYLUS_1) {
        width -= 16;
        maximum = 0xfff;

      }
      else if (OlyID == OlyID_E_330) {
        width -= 30;
        if (load_raw == &LibRaw::unpacked_load_raw)
          maximum = 0xf79;

      }
      else if (OlyID == OlyID_SP_550UZ) {
        thumb_length = unsigned(flen - INT64(thumb_offset = 0xa39800));
        thumb_height = 480;
        thumb_width = 640;

      }
      else if (OlyID == OlyID_TG_4) {
        width -= 16;
      }
      else if (
         (OlyID == OlyID_TG_5) ||
         (OlyID == OlyID_TG_6) ||
         (OlyID == OlyID_TG_7)
        ) {
        width -= 26;
      }
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_RoverShot) &&
    (fsize == 6291456)) { // RoverShot 3320AF
    fseek(ifp, 0x300000, SEEK_SET);
    if ((order = guess_byte_order(0x10000)) == 0x4d4d)
    {
      height -= (top_margin = 16);
      width -= (left_margin = 28);
      maximum = 0xf5c0;
      strcpy(make, "ISG");
      maker_index = LIBRAW_CAMERAMAKER_ISG;
      model[0] = 0;
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Fujifilm)) {
    if (!imFuji.RAFDataGeneration && (raw_width == 2944)) // S2Pro
    {
      height = 2144;
      width = 2880;
      flip = 6;
    }
    else if (load_raw != &LibRaw::packed_load_raw &&
             strncmp(model, "X-", 2)              &&
             filters >= 1000) // Bayer and not an X-model
      maximum = (is_raw == 2 && shot_select) ? 0x2f00 : 0x3e00;

    if (!FujiCropMode && imFuji.RAFDataGeneration && (imFuji.RAFDataGeneration != 4096))
    {
      width  = imFuji.RAFData_ImageSizeTable[0];
      height = imFuji.RAFData_ImageSizeTable[1];
    }
    else if (FujiCropMode == 1) // FF crop on GFX
    {
      width = raw_width;
      height = raw_height;
    }
        // Do we need set height = raw_height for CropMode == 2 for all cameras??
    else if (FujiCropMode == 4) // electronic shutter, high speed mode (1.25x crop)
    {
      height = raw_height;
    }

    top_margin = (raw_height >= height) ? (raw_height - height) >> 2 << 1 : 0;
    left_margin = (raw_width >= width) ? (raw_width - width) >> 2 << 1 : 0;

    if (imFuji.RAFDataGeneration && (imFuji.RAFDataGeneration != 4096)) {
      switch (raw_width) {
      case 2944:                // X-S1, X10, XF1
        filters = 0x16161616;
        break;
      case 4096:                // X20, X30, XQ1, XQ2
      case 5120:                // X-Pro1, X-E1, X-A1, X-A2, X-M1
      case 6048:                // lossless compressed X100F, X-T2, X-T20, X-Pro2, X-H1, X-E3
      case 6160:                // uncompressed (unpacked) X100F, X-T2, X-T20, X-Pro2, X-H1, X-E3
        left_margin = 0;
        break;
      case 4992:                // X-E2S, X-E2, X-T10, X-T1, X100S, X100T, X70
        left_margin = 4;
        break;
    case 7872: // X-H2, full image
      switch (FujiCropMode)
      {
      case 0: // no crop
        top_margin = 6;
        left_margin = 0;
        width = 7752;
        height = 5178;
        break;
          default:
            /* try to guess from crop inset*/
            if (imgdata.sizes.raw_inset_crops[0].cwidth > 0 && imgdata.sizes.raw_inset_crops[0].cwidth <= raw_width &&
                imgdata.sizes.raw_inset_crops[0].cheight > 0 && imgdata.sizes.raw_inset_crops[0].cheight <= raw_height)
            {
              top_margin = imgdata.sizes.raw_inset_crops[0].ctop;
              left_margin = imgdata.sizes.raw_inset_crops[0].cleft;
              width = imgdata.sizes.raw_inset_crops[0].cwidth;
              height = imgdata.sizes.raw_inset_crops[0].cheight;
            }
            break;
      }
      break;
      case 6336: // X-H2S, XT30-III
      switch (FujiCropMode)
      {
          case 0: // no crop
            top_margin = 6;
            left_margin = 0;
      if(!strcasecmp(model,"X-S20") || !strcasecmp(model, "X-T30 III"))
              width = 6252;
      else
        width = 6264;
            height = 4176;
      break;
      case 2: /* sports finder*/
      case 4: /* Electronic shutter crop */
        left_margin = 630;
        top_margin = 0;
        height = 3348;
        width = 5004;
        break;
      default:
        /* try to guess from crop inset*/
        if (imgdata.sizes.raw_inset_crops[0].cwidth > 0 && imgdata.sizes.raw_inset_crops[0].cwidth <= raw_width
          && imgdata.sizes.raw_inset_crops[0].cheight > 0 && imgdata.sizes.raw_inset_crops[0].cheight <= raw_height)
        {
                top_margin = imgdata.sizes.raw_inset_crops[0].ctop;
                left_margin = imgdata.sizes.raw_inset_crops[0].cleft;
        width = imgdata.sizes.raw_inset_crops[0].cwidth;
        height = imgdata.sizes.raw_inset_crops[0].cheight;
        }
        break;
      }
      break;
      case 6384:                // X-T3, X-T4, X100V, X-S10, X-T30, X-Pro3
        top_margin = 0;
        switch (FujiCropMode) {
        case 0:        // no crop
          left_margin = 0;
          top_margin = 6;
          width = 6246;
          height = 4170;
          break;
        case 2:        // sports finder mode
          left_margin = 624;
          width = 5004;
          height = raw_height;
          break;
        case 4:        // electronic shutter, high speed mode (1.25x crop)
          left_margin = 624;
          width = 5004;
          break;
        }
        break;
      case 6912:                // GFX 50S, GFX 50R; FF crop
      case 9216:                // GFX 50S, GFX 50R; no crop
        left_margin = 0;
        top_margin = 0;
        break;
      case 8472:                // GFX 50S II
        left_margin = 0;
        top_margin  = 0;
        width = raw_width - 192;
        break;
      case 9696:                // GFX 100; FF crop
      case 11808:               // GFX 100; no crop
        left_margin = 0;
        width = raw_width - 146;
        height = raw_height - 8;
        top_margin = 2;
        if (tiff_bps == 16)
          maximum = 0xffff;
      default:
      /* insert model name-based width/height/margins/etc. assignments */
        break;
      }

    } else if (!imFuji.RAFDataGeneration) {
      switch (raw_width) {
      case 2304:                // S5100
        height -= (top_margin = 6);
        break;
      case 3328:                // F550EXR, F600EXR, F770EXR, F800EXR, F900EXR,
                                // HS20EXR, HS30EXR, HS33EXR, HS50EXR
        if ((width = raw_width - 66))
          left_margin = 34;
        if (imgdata.sizes.raw_inset_crops[0].cleft == 8) // HS50EXR, F900EXR
        {
          left_margin = 0;
          width += 2;
          filters = 0x16161616;
        }
        break;
      case 3664:                // "HS10 HS11"
        filters = 0x16161616;
        break;
      case 5504:                // DBP for GX680 aka DX-2000

//         7712 2752 -> 5504 3856
//         width = 688;
//         height = 30848;
//         raw_width = 688;
//         raw_height = 30848;

        left_margin = 32; // imgdata.sizes.raw_inset_crops[0].cleft
        top_margin = 8;
        width = raw_width - 2*left_margin;
        height = raw_height - 2*top_margin;

        load_raw = &LibRaw::unpacked_load_raw_FujiDBP;
        //  maximum = 0x0fff;
        filters = 0x16161616;
        load_flags = 0;
        flip = 6;
        break;
      default:
        /* insert model name-based width/height/margins/etc. assignments */

      if (strncmp(model, "S6000", 5) && strncmp(model, "S6500", 5))
      {
        /* raw_inset_crops default*/
        if (imgdata.sizes.raw_inset_crops[0].cwidth > 0 && imgdata.sizes.raw_inset_crops[0].cwidth <= raw_width &&
          imgdata.sizes.raw_inset_crops[0].cheight > 0 && imgdata.sizes.raw_inset_crops[0].cheight <= raw_height)
        {
          top_margin = imgdata.sizes.raw_inset_crops[0].ctop;
          left_margin = imgdata.sizes.raw_inset_crops[0].cleft;
          width = imgdata.sizes.raw_inset_crops[0].cwidth;
          height = imgdata.sizes.raw_inset_crops[0].cheight;
        }
      }
        break;
      }
    }
    if (fuji_layout)
      raw_width *= is_raw;
    if (filters == 9)
      FORC(36)
      ((char *)xtrans)[c] =
      xtrans_abs[(c / 6 + top_margin) % 6][(c + left_margin) % 6];
  }

  else if (makeIs(LIBRAW_CAMERAMAKER_Konica)) {
    if (!strcmp(model, "KD-400Z")) {
      height = 1711; // 1712
      width = 2312;
      raw_width = 2336;
      goto konica_400z;
    }
    else if (!strcmp(model, "KD-510Z")) {
      goto konica_510z;
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Minolta)) {
    if (fsize == 5869568) { // hack "DiMAGE Z2"
      load_flags = 30;
    }

    if (imSony.prd_StorageMethod == LIBRAW_MINOLTA_UNPACKED) {
      load_raw = &LibRaw::unpacked_load_raw;
    } else if (imSony.prd_StorageMethod == LIBRAW_MINOLTA_PACKED) {
      load_raw = &LibRaw::packed_load_raw;
      } else if (!load_raw && (maximum = 0xfff)) {
      load_raw = &LibRaw::unpacked_load_raw;
    }

      if (imSony.prd_BayerPattern == LIBRAW_MINOLTA_G2BRG1) {
      filters = 0x49494949;
      } else if (imSony.prd_BayerPattern == LIBRAW_MINOLTA_RGGB) {
      filters = 0x94949494;
      }

      if (imSony.prd_Active_bps && imSony.prd_Total_bps) {
      tiff_bps = imSony.prd_Active_bps;
      }

    if (!strncmp(model, "DiMAGE G", 8)) // hack "DiMAGE G400", "DiMAGE G500",
                                               // "DiMAGE G530", "DiMAGE G600"
    {
      if (model[8] == '4') // DiMAGE G400
      {
        height = 1716;
        width = 2304;
      }
      else if (model[8] == '5') // DiMAGE G500 / G530
      {
      konica_510z:
        height = 1956;
        width = 2607;
        raw_width = 2624;
      }
      else if (model[8] == '6') // DiMAGE G600
      {
        height = 2136;
        width = 2848;
      }
      data_offset += 14;
      filters = 0x61616161;
    konica_400z:
      load_raw = &LibRaw::unpacked_load_raw;
      maximum = 0x3df;
      order = 0x4d4d;
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Samsung)) {
    if (raw_width == 4704) // Samsung NX100, NX10, NX11,
    {
      height -= top_margin = 8;
      width -= 2 * (left_margin = 8);
      load_flags = 32;
    }
    else if (!strcmp(model, "NX3000")) // Samsung NX3000; raw_width: 5600
    {
      top_margin = 38;
      left_margin = 92;
      width = 5456;
      height = 3634;
      filters = 0x61616161;
      colors = 3;
    }
    else if (raw_height == 3714) // Samsung NX2000, NX300M, NX300, NX30,
                                 // "NX U" (aka:
                                 //         "EK-GN100", "EK-GN110", "EK-GN120",
                                 //         "EK-KN120", "Galaxy NX")
    {
      height -= top_margin = 18;
      left_margin = raw_width - (width = 5536);
      if (raw_width != 5600)
        left_margin = top_margin = 0;
      filters = 0x61616161;
      colors = 3;
    }
    else if (raw_width == 5632) // Samsung NX1000, NX200, NX20, NX210
    {
      order = 0x4949;
      height = 3694;
      top_margin = 2;
      width = 5574 - (left_margin = 32 + tiff_bps);
      if (tiff_bps == 12)
        load_flags = 80;
    }
    else if (raw_width == 5664) // Samsung "NX mini"
    {
      height -= top_margin = 17;
      left_margin = 96;
      width = 5544;
      filters = 0x49494949;
    }
    else if (raw_width == 6496) // Samsung NX1, NX500
    {
      filters = 0x61616161;
      if (!black && !cblack[0] && !cblack[1] && !cblack[2] && !cblack[3])
        black = 1 << (tiff_bps - 7);
    }
    else if (!strcmp(normalized_model, "EX1")) // Samsung EX1; raw_width: 3688
    {
      order = 0x4949;
      height -= 20;
      top_margin = 2;
      if ((width -= 6) > 3682)
      {
        height -= 10;
        width -= 46;
        top_margin = 8;
      }
    }
    else if (!strcmp(normalized_model, "WB2000")) // Samsung WB2000; raw_width: 3728
    {
      order = 0x4949;
      height -= 3;
      top_margin = 2;
      if ((width -= 10) > 3718)
      {
        height -= 28;
        width -= 56;
        top_margin = 8;
      }
    }
    else if (!strcmp(model, "WB550")) // Samsung WB550; raw_width: 4000
    {
      order = 0x4949;
    }
    else if (!strcmp(model, "EX2F")) // Samsung EX2F; raw_width: 4176
    {
      height = 3030;
      width = 4040;
      top_margin = 15;
      left_margin = 24;
      order = 0x4949;
      filters = 0x49494949;
      load_raw = &LibRaw::unpacked_load_raw;
    }
  }

  else if (makeIs(LIBRAW_CAMERAMAKER_ST_Micro) && !strcmp(model, "STV680 VGA"))
  {
    black = 16;
  }
  else if (!strcmp(model, "N95"))
  {
    height = raw_height - (top_margin = 2);
  }
  else if (!strcmp(model, "640x480"))
  {
    gamma_curve(0.45, 4.5, 1, 255);
  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Hasselblad))
  {
    if (load_raw == &LibRaw::lossless_jpeg_load_raw)
      load_raw = &LibRaw::hasselblad_load_raw;

    if ((imHassy.SensorCode == 4) && !strncmp(model, "V96C", 4)) { // Hasselblad V96C
      strcpy(model, "V96C");
      strcpy(normalized_model, model);
      height -= (top_margin = 6);
      width -= (left_margin = 3) + 7;
      filters = 0x61616161;

    }
    else if ((imHassy.SensorCode == 9) && imHassy.uncropped) { // various Hasselblad '-39'
      height = 5444;
      width = 7248;
      top_margin = 4;
      left_margin = 7;
      filters = 0x61616161;

    }
    else if ((imHassy.SensorCode == 13) && imHassy.uncropped) { // Hasselblad H4D-40, H5D-40
      height -= 84;
      width -= 82;
      top_margin = 4;
      left_margin = 41;
      filters = 0x61616161;

    }
    else if ((imHassy.SensorCode == 11) && imHassy.uncropped) { // Hasselblad H5D-50
      height -= 84;
      width -= 82;
      top_margin = 4;
      left_margin = 41;
      filters = 0x61616161;

    }
    else if ((imHassy.SensorCode == 15) &&
      !imHassy.SensorSubCode && // Hasselblad H5D-50c, CFV-50c
      imHassy.uncropped) {
      left_margin = 52;
      top_margin = 100;
      width = 8272;
      height = 6200;
      black = 256;

    }
    else if ((imHassy.SensorCode == 15) &&
      (imHassy.SensorSubCode == 2) && // various Hasselblad X1D cameras
      imHassy.uncropped) {
      top_margin = 96;
      height -= 96;
      left_margin = 48;
      width -= 106;
      maximum = 0xffff;
      tiff_bps = 16;

    }
    else if ((imHassy.SensorCode == 12) && imHassy.uncropped) { // Hasselblad H4D-60
      if (black > 500) { // (imHassy.format == LIBRAW_HF_FFF)
        top_margin = 12;
        left_margin = 44;
        width = 8956;
        height = 6708;
        memset(cblack, 0, sizeof(cblack));
        black = 512;
      }
      else { // (imHassy.format == LIBRAW_HF_3FR)
        top_margin = 8;
        left_margin = 40;
        width = 8964;
        height = 6716;
        black += load_flags = 256;
        maximum = 0x8101;
      }

    }
    else if ((imHassy.SensorCode == 17) && imHassy.uncropped) { // Hasselblad H6D-100c, A6D-100c
      left_margin = 64;
      width = 11608;
      top_margin = 108;
      height = raw_height - top_margin;
    }
    else if (((imHassy.SensorCode == 20)|| (imHassy.SensorCode == 22)) && imHassy.uncropped) { // Hasselblad X2D-100c, 100c-II CFV-100c
      left_margin = 124;
      width = 11664;
      top_margin = 92;
      height = raw_height - top_margin;
    }

    if (tiff_samples > 1)
    {
      is_raw = tiff_samples + 1;
      if (!shot_select && !half_size)
        filters = 0;
    }
  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Sinar))
  {
    if (!load_raw)
      load_raw = &LibRaw::unpacked_load_raw;
    if (is_raw > 1 && !shot_select)
      filters = 0;
    maximum = 0x3fff;
  }

  if (load_raw == &LibRaw::sinar_4shot_load_raw)
  {
    if (is_raw > 1 && !shot_select)
      filters = 0;
  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Leaf))
  {
    maximum = 0x3fff;
    fseek(ifp, data_offset, SEEK_SET);
    if (ljpeg_start(&jh, 1) && jh.bits == 15)
      maximum = 0x1fff;
    if (tiff_samples > 1)
      filters = 0;
    if (tiff_samples > 1 || tile_length < raw_height)
    {
      load_raw = &LibRaw::leaf_hdr_load_raw;
      raw_width = tile_width;
    }
    if ((width | height) == 2048)
    {
      if (tiff_samples == 1)
      {
        filters = 1;
        strcpy(cdesc, "RBTG");
        strcpy(model, "CatchLight");
        strcpy(normalized_model, model);
        top_margin = 8;
        left_margin = 18;
        height = 2032;
        width = 2016;
      }
      else
      {
        strcpy(model, "DCB2");
        strcpy(normalized_model, model);
        top_margin = 10;
        left_margin = 16;
        height = 2028;
        width = 2022;
      }
    }
    else if (width + height == 3144 + 2060)
    {
      if (!model[0])
      {
        strcpy(model, "Cantare");
        strcpy(normalized_model, model);
      }
      if (width > height)
      {
        top_margin = 6;
        left_margin = 32;
        height = 2048;
        width = 3072;
        filters = 0x61616161;
      }
      else
      {
        left_margin = 6;
        top_margin = 32;
        width = 2048;
        height = 3072;
        filters = 0x16161616;
      }
      if (!cam_mul[0] || model[0] == 'V')
        filters = 0;
      else
        is_raw = tiff_samples;
    }
    else if (width == 2116) // Leaf "Valeo 6"
    {
      strcpy(model, "Valeo 6");
      strcpy(normalized_model, model);
      height -= 2 * (top_margin = 30);
      width -= 2 * (left_margin = 55);
      filters = 0x49494949;
    }
    else if (width == 3171) // Leaf "Valeo 6"
    {
      strcpy(model, "Valeo 6");
      strcpy(normalized_model, model);
      height -= 2 * (top_margin = 24);
      width -= 2 * (left_margin = 24);
      filters = 0x16161616;
    }
  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Panasonic))
  {
    if (raw_width > 0 &&
      ((flen - data_offset) / (raw_width * 8 / 7) == raw_height))
      load_raw = &LibRaw::panasonic_load_raw;
    if (!load_raw)
    {
      load_raw = &LibRaw::unpacked_load_raw;
      load_flags = 4;
    }
    zero_is_bad = 1;
    if ((height += 12) > raw_height)
      height = raw_height;
    for (i = 0; i < int(sizeof pana / sizeof *pana); i++)
      if (raw_width == pana[i][0] && raw_height == pana[i][1])
      {
        left_margin = pana[i][2];
        top_margin = pana[i][3];
        width += pana[i][4];
        height += pana[i][5];
      }
    if (!tiff_bps && pana_bpp >= 12 && pana_bpp <= 14)
      tiff_bps = pana_bpp;

        if (!strcmp(model, "DC-LX100M2") && raw_height == 3568 && raw_width == 4816 && filters == 3)
            filters = 4;

    filters = 0x01010101U *
      (uchar) "\x94\x61\x49\x16"[((filters - 1) ^ (left_margin & 1) ^
      (top_margin << 1)) &
      3];

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Contax) &&
    !strcmp(model, "N Digital")) {
    height = 2047;
    width = 3072;
    filters = 0x61616161;
    data_offset = 0x1a00;
    load_raw = &LibRaw::packed_load_raw;

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Sony)) {
    if (!strcmp(model, "DSC-F828")) { // Sony DSC-F828
      width = 3288;
      left_margin = 5;
      mask[1][3] = -17;
      data_offset = 862144;
      load_raw = &LibRaw::sony_load_raw;
      filters = 0x9c9c9c9c;
      colors = 4;
      strcpy(cdesc, "RGBE");

    }
    else if (!strcmp(model, "DSC-V3")) { // Sony DSC-V3
      width = 3109;
      left_margin = 59;
      mask[0][1] = 9;
      data_offset = 787392;
      load_raw = &LibRaw::sony_load_raw;

    }
        else if ((unique_id == SonyID_ILCE_7RM5) ||
                 (unique_id == SonyID_ILCE_7CR)  ||
        (unique_id == SonyID_DSC_RX1RM3) || // only Lossless/FF samples for now
                 (unique_id == SonyID_ILX_LR1))
        {
          if (raw_width == 6304)
          {
            /* nothing: APS-C Uncompressed, handled in open_datastream*/
          }
          else if (raw_width == 6656) /* 7RM5 Lossy compressed, medium */
          {
            width = 6272;
            height = 4180;
          }
          else if (raw_width == 9728) // FF, Lossless compresssed
          {
            width = 9566;
            height = 6374;
          }
          else if (raw_width == 5120) // APS-C??/Lossy-Small?
          {
            width = 4776;
            height = 3180;
          }
      else if (raw_width == 9600)
      {
        width = raw_width - 36;
      }
          else
          {
            width = raw_width - 32; // fallback
      imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;

          }
        }
    else if (raw_width == 3984) 
    { // Sony DSC-R1;
      width = 3925;
      order = 0x4d4d;

    }
    else if (raw_width == 4288) { // Sony ILCE-7S, ILCE-7SM2, ILCE-7SM3, DSLR-A700, DSLR-A500;
      width -= 32;
    }
    else if (raw_width == 4600) { // Sony DSLR-A290, DSLR-A350, DSLR-A380;
      if (!strcmp(model, "DSLR-A350"))
        height -= 4;
      black = 0;

    }
    else if (raw_width == 4928) {
      // Sony DSLR-A580, NEX-C3, SLT-A35, DSC-HX99, DSC-HX95, SLT-A55,
      // NEX-5N, SLT-A37, SLT-A57, NEX-F3, NEX-6, NEX-5R, NEX-3N, NEX-5T;
      if (height < 3280)
        width -= 8;

    }
    else if (raw_width == 5504) {
      // Sony ILCE-3000, SLT-A58, DSC-RX100M3, ILCE-QX1,
      // DSC-RX10M4, DSC-RX100M6, DSC-RX100, DSC-RX100M2, DSC-RX10,
      // ILCE-5000, DSC-RX100M4, DSC-RX10M2, DSC-RX10M3,
      // DSC-RX100M5, DSC-RX100M5A;
      width -= height > 3664 ? 8 : 32;

    }
    else if (unique_id == SonyID_ILCE_9M3)
    {
      if (raw_width == 6048)
        width -= 36; // 
      else if (raw_width == 6144) // Lossless/L, FF
      {
        width = 6012;
        height = 4020;
      }
      else if (raw_width == 4096) // Lossless/M
      {
        width = 3944;
        height = 2644;
      }
      else if (raw_width == 3072) // Lossless/S
      {
        width = 3016;
        height = 2008;
      }
      else if (raw_width == 3968)   // Uncompressed, APS
      {
        width = 3948;
      }
      else // We do not have other samples, offer vendor crop to caller
      {
              width = raw_width - 32; // fallback
              imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;
      }
    }
    else if (raw_width == 6048) {
      // Sony SLT-A65, DSC-RX1, SLT-A77, DSC-RX1, ILCA-77M2,
      // ILCE-7M3, NEX-7, SLT-A99, ILCE-7, DSC-RX1R, ILCE-6000,
      // ILCE-5100, ILCE-7M2, ILCA-68, ILCE-6300, ILCE-9,
      // ILCE-6500, ILCE-6400;
      width -= 24;
      if (strstr(normalized_model, "RX1") ||
        strstr(normalized_model, "A99"))
        width -= 6;

    }
    else if (raw_width == 7392) { // Sony ILCE-7R;
      width -= 30;

    }
    else if (raw_width == 8000) {
      // Sony ILCE-7RM2, ILCE-7RM2, ILCE-7RM3, DSC-RX1RM2, ILCA-99M2;
      width -= 32;

    }
    else if (raw_width == 9600) { // Sony ILCE-7RM4 && 7RM5
      width -= 32;

    }
        else if (unique_id == SonyID_ZV_E1)
        {
          if (raw_width == 4608 && raw_height == 3072) // SonyID_ZV_E1
          {
            width  = 4256;
            height = 2846;
          }
        }
        else if((unique_id == SonyID_ILCE_1) || (unique_id == SonyID_ILCE_1M2))
        {
          if (raw_width == 8704 && raw_height == 6144) // ILCE-1 FF@Compressed
          {
            width = 8660;
            height = 5784;
          }
          else if (raw_width == 8672) // FF uncompressed/lossy
          {
            width -= 12;
          }
          else if (raw_width == 6144 && raw_height == 4096) // APSC/Lossless
          {
            width = 5636;
            height = 3768;
          }
          else if (raw_width == 5664) // APS-C/Uncompressed or lossy
          {
              width -= 28;
          }
          else if (raw_width == 5632) // Lossy/Medium
          {
            width -= 4;
      height = 3756;
          }
          else if (raw_width == 4608) // Lossy/small
          {
            width = 4332;
            height = 2892;
          }
      else
            imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;

      /* need samples for lossy small/medium w/ APC crop*/
        }
        else if (unique_id == SonyID_ILCE_7M5)
    {
      if (raw_width == 7168 && raw_height == 5120) // FF, lossless
      {
              width = 7028;
              height = 4688;
      }
            else if (raw_width == 7040) // FF compressed/compressedHQ
            {
              width -= 12;
            }
      else if (raw_width == 5120 && raw_height == 3584) // APS-C, lossless
      {
              width = 4628;
              height = 3088;
      }
      else if (raw_width == 4640) // APS-C Compressed/CompressedHQ
      {
              width -= 12;
      }
      else
              imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;
    }
    else if (unique_id == SonyID_ILCE_7RM6)
    {
          if (raw_width == 10240 && raw_height == 7168) // FF, lossless
          {
            width = 10002;
            height = 6668; // ensure 2:3
          }
          else if (raw_width == 10016 && raw_height == 6672) // FF, Compressed
          {
            width = 10002;
            height = 6668; // ensure 2:3
          }
          else if (raw_width == 6656 && raw_height == 4608) // APS, Lossless
          {
            width = 6540;
            height = 4360; // ensure 2:3
          }
          else if (raw_width == 6592 && raw_height == 4372) // APS, Compressed
          {
            width = 6540;
            height = 4360; // ensure 2:3
          }
          else
            imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;
    }
    else if ((unique_id == SonyID_ILCE_7M4)|| (unique_id == SonyID_ILCE_7CM2) || (unique_id == SonyID_ILME_FX2))
        {
          if (raw_width == 7168 && raw_height == 5120) 
          {
            width = 7028;
            height = 4688;
          }
          else if (raw_width == 4736) // APS-C crop
          {
            width = 4692;
            //height = 3080;
          }
          else if (raw_width == 5120) // Lossy/Medium
          {
            width = 4624;
            height = 3080;
          }
          else if (raw_width == 3584) // Lossy/Small
          {
            width = 3516;
            height = 2344;
          }
          else if (raw_width == 7040) // FF uncompressed/lossy
          {
            width -= 12;
          }
      else
            imgdata.process_warnings |= LIBRAW_WARN_VENDOR_CROP_SUGGESTED;
          /* FIXME: need APS-C samples, both losslesscompressed and uncompressed or lossy */
        }
    else if ((unique_id == SonyID_ILCE_6700) || (unique_id == SonyID_ZV_E10M2)
        || (unique_id == SonyID_ILME_FX30)) // same sensor
    {
      if (raw_width == 6656)
      {
        width = 6240;
        height = 4168;
      }
            else if (raw_width == 6272) // APS-C uncompressed
            {
              width = raw_width - 32;
            }
      else // fallback
      {
        width = raw_width - 32;
      }
    }
        else if (!strcmp(model, "DSLR-A100")) {
      if (width == 3880) {
        height--;
        width = ++raw_width;
      }
      else {
        height -= 4;
        width -= 4;
        order = 0x4d4d;
        load_flags = 2;
      }
      filters = 0x61616161;
    }
  }

  else if (!strcmp(model, "PIXL")) {
    height -= top_margin = 4;
    width -= left_margin = 32;
    gamma_curve(0, 7, 1, 255);

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Kodak)) {

    if (!strncasecmp(model, "EasyShare", 9)) {
      data_offset = data_offset < 0x15000 ? 0x15000 : 0x17000;
      load_raw = &LibRaw::packed_load_raw;

    }
    else if (!strcmp(model, "C603") ||
      !strcmp(model, "C330") ||
      !strcmp(model, "12MP")) {
      order = 0x4949;
      if (filters && data_offset) {
        fseek(ifp, data_offset < 4096 ? 168 : 5252, SEEK_SET);
        read_shorts(curve, 256);
      }
      else
        gamma_curve(0, 3.875, 1, 255);

      load_raw = filters ? &LibRaw::eight_bit_load_raw
        : strcmp(model, "C330") ? &LibRaw::kodak_c603_load_raw
        : &LibRaw::kodak_c330_load_raw;
      load_flags = tiff_bps > 16;
      tiff_bps = 8;

    }
    else {
      if (!strncmp(model, "NC2000", 6) ||
        !strncmp(model, "EOSDCS", 6) ||
        !strncmp(model, "DCS4", 4)) {
        width -= 4;
        left_margin = 2;

      }
      else if (!strcmp(model, "DCS660M")) {
        black = 214;

      }
      else if (!strcmp(model, "EOS D2000C")) {
        filters = 0x61616161;
        if (!black) black = curve[200];
      }

      if (filters == UINT_MAX) filters = 0x61616161;

      if (!strcmp(model + 4, "20X"))
        strcpy(cdesc, "MYCY");
      if (!strcmp(model, "DC25")) {
        data_offset = 15424;
      }

      if (!strncmp(model, "DC2", 3)) {
        raw_height = 2 + (height = 242);
        if (!strncmp(model, "DC290", 5))
          iso_speed = 100;
        if (!strncmp(model, "DC280", 5))
          iso_speed = 70;
        if (flen < 100000) {
          raw_width = 256;
          width = 249;
          pixel_aspect = (4.0 * height) / (3.0 * width);
        }
        else {
          raw_width = 512;
          width = 501;
          pixel_aspect = (493.0 * height) / (373.0 * width);
        }
        top_margin = left_margin = 1;
        colors = 4;
        filters = 0x8d8d8d8d;
        simple_coeff(1);
        pre_mul[1] = 1.179f;
        pre_mul[2] = 1.209f;
        pre_mul[3] = 1.036f;
        load_raw = &LibRaw::eight_bit_load_raw;
      }
      else if (!strcmp(model, "DC40")) {
        height = 512;
        width = 768;
        data_offset = 1152;
        load_raw = &LibRaw::kodak_radc_load_raw;
        tiff_bps = 12;
        FORC4 cam_mul[c] = 1.0f;

      }
      else if (!strcmp(model, "DC50")) {
        height = 512;
        width = 768;
        iso_speed = 84;
        data_offset = 19712;
        load_raw = &LibRaw::kodak_radc_load_raw;
        FORC4 cam_mul[c] = 1.0f;

      }
      else if (!strcmp(model, "DC120")) {
        raw_height = height = 976;
        raw_width = width = 848;
        iso_speed = 160;
        pixel_aspect = height / 0.75 / width;
        load_raw = tiff_compress == 7 ? &LibRaw::kodak_jpeg_load_raw
          : &LibRaw::kodak_dc120_load_raw;

      }
      else if (!strcmp(model, "DCS200")) {
        thumb_height = 128;
        thumb_width = 192;
        thumb_offset = 6144;
        thumb_misc = 360;
        iso_speed = 140;
        thumb_format = LIBRAW_INTERNAL_THUMBNAIL_LAYER;
        black = 17;
      }
    }

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Logitech) &&
    !strcmp(model, "Fotoman Pixtura")) {
    height = 512;
    width = 768;
    data_offset = 3632;
    load_raw = &LibRaw::kodak_radc_load_raw;
    filters = 0x61616161;
    simple_coeff(2);

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Apple) &&
    !strncmp(model, "QuickTake", 9)) {
    if (head[5]) {
      strcpy(model + 10, "200");
      strcpy(normalized_model, model);
    }
    fseek(ifp, 544, SEEK_SET);
    height = get2();
    width = get2();
    data_offset = (get4(), get2()) == 30 ? 738 : 736;
    if (height > width) {
      SWAP(height, width);
      fseek(ifp, data_offset - 6, SEEK_SET);
      flip = ~get2() & 3 ? 5 : 6;
    }
    filters = 0x61616161;

  }
  else if (makeIs(LIBRAW_CAMERAMAKER_Rollei) &&
    !load_raw) {
    switch (raw_width) {
    case 1316: // Rollei d530flex
      height = 1030;
      width = 1300;
      top_margin = 1;
      left_margin = 6;
      break;
    case 2568:
      height = 1960;
      width = 2560;
      top_margin = 2;
      left_margin = 8;
    }
    filters = 0x16161616;
    load_raw = &LibRaw::rollei_load_raw;

  }
  else if (!strcmp(model, "GRAS-50S5C")) {
    height = 2048;
    width = 2440;
    load_raw = &LibRaw::unpacked_load_raw;
    data_offset = 0;
    filters = 0x49494949;
    order = 0x4949;
    maximum = 0xfffC;

  }
  else if (!strcmp(model, "BB-500CL")) {
    height = 2058;
    width = 2448;
    load_raw = &LibRaw::unpacked_load_raw;
    data_offset = 0;
    filters = 0x94949494;
    order = 0x4949;
    maximum = 0x3fff;

  }
  else if (!strcmp(model, "BB-500GE")) {
    height = 2058;
    width = 2456;
    load_raw = &LibRaw::unpacked_load_raw;
    data_offset = 0;
    filters = 0x94949494;
    order = 0x4949;
    maximum = 0x3fff;

  }
  else if (!strcmp(model, "SVS625CL")) {
    height = 2050;
    width = 2448;
    load_raw = &LibRaw::unpacked_load_raw;
    data_offset = 0;
    filters = 0x94949494;
    order = 0x4949;
    maximum = 0x0fff;
  }
}

Coverage Report

Created: 2026-11-12 07:35