/* -*- C++ -*-
 * Copyright 2019-2025 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 "third_party/libraw/internal/dcraw_defs.h"
#include "third_party/libraw/internal/libraw_cameraids.h"

int LibRaw::parse_tiff_ifd(INT64 base)
{
  unsigned entries, tag, type, len, plen = 16, utmp;
  INT64 save;
  int ifd, use_cm = 0, cfa, i, j, c, ima_len = 0;
  char *cbuf, *cp;
  uchar cfa_pat[16], cfa_pc[] = {0, 1, 2, 3}, tab[256];
  double fm[3][4], cc[4][4], cm[4][3], cam_xyz[4][3], num;
  double ab[] = {1, 1, 1, 1}, asn[] = {0, 0, 0, 0}, xyz[] = {1, 1, 1};
  unsigned sony_curve[] = {0, 0, 0, 0, 0, 4095};
  unsigned *buf, sony_offset = 0, sony_length = 0, sony_key = 0;
  struct jhead jh;

  ushort *rafdata;

  if (tiff_nifds >= sizeof tiff_ifd / sizeof tiff_ifd[0])
    return 1;
  ifd = tiff_nifds++;
  for (j = 0; j < 4; j++)
    for (i = 0; i < 4; i++)
      cc[j][i] = i == j;

  if (libraw_internal_data.unpacker_data.ifd0_offset == -1LL)
    libraw_internal_data.unpacker_data.ifd0_offset = base;

  entries = get2();
  if (entries > 512)
    return 1;

  INT64 fsize = ifp->size();

  while (entries--)
  {
    tiff_get(base, &tag, &type, &len, &save);
    INT64 savepos = ftell(ifp);
    if (len > 8 && savepos + len > 2 * fsize)
    {
      fseek(ifp, save, SEEK_SET); // Recover tiff-read position!!
      continue;
    }
    if (callbacks.exif_cb)
    {
      callbacks.exif_cb(callbacks.exifparser_data,
                        tag | (is_pana_raw ? 0x30000 : ((ifd + 1) << 20)), type,
                        len, order, ifp, base);
      fseek(ifp, savepos, SEEK_SET);
    }
    if (!is_pana_raw)
    { /* processing of EXIF tags that collide w/ PanasonicRaw tags */
      switch (tag)
      {
      case 0x0001:
        if (len == 4)
          is_pana_raw = get4();
        break;
      case 0x000b: /* 11, Std. EXIF Software tag */
        fgets(software, 64, ifp);
        if (!strncmp(software, "Adobe", 5) || !strncmp(software, "dcraw", 5) ||
            !strncmp(software, "UFRaw", 5) || !strncmp(software, "Bibble", 6) ||
            !strcmp(software, "Digital Photo Professional"))
          is_raw = 0;
        break;
      case 0x001c: /*  28, safeguard, probably not needed */
      case 0x001d: /*  29, safeguard, probably not needed */
      case 0x001e: /*  30, safeguard, probably not needed */
        cblack[tag - 0x001c] = get2();
        cblack[3] = cblack[1];
        break;

      case 0x0111: /* 273, StripOffset */
        if (len > 1 && len < 16384)
        {
          INT64 sav = ftell(ifp);
          tiff_ifd[ifd].strip_offsets = (INT64 *)calloc(len, sizeof(INT64));
          tiff_ifd[ifd].strip_offsets_count = len;
          for (int ii = 0; ii < (int)len; ii++)
            tiff_ifd[ifd].strip_offsets[ii] = get4() + base;
          fseek(ifp, sav, SEEK_SET); // restore position
        }
        /* fallback */
      case 0x0201: /* 513, JpegIFOffset */
      case 0xf007: // 61447
        tiff_ifd[ifd].offset = get4() + base;
        if (!tiff_ifd[ifd].bps && tiff_ifd[ifd].offset > 0)
        {
          fseek(ifp, tiff_ifd[ifd].offset, SEEK_SET);
          if (ljpeg_start(&jh, 1))
          {
            if (!dng_version && !strcasecmp(make, "SONY") && tiff_ifd[ifd].phint == 32803 &&
                tiff_ifd[ifd].comp == 7) // Sony/lossless compressed IFD
            {
              tiff_ifd[ifd].comp = 6;
              tiff_ifd[ifd].bps = jh.bits;
              tiff_ifd[ifd].samples = 1;
            }
            else if (!dng_version && !strcasecmp(make, "SONY") && tiff_ifd[ifd].phint == 6 &&
                tiff_ifd[ifd].comp == 7 && tiff_ifd[ifd].samples == 3) // Sony/lossless YCbCr
            {
              tiff_ifd[ifd].comp = 6;
              tiff_ifd[ifd].bps = jh.bits;
              // tiff_ifd[ifd].samples = 3; // no change
            }
            else
            {
              tiff_ifd[ifd].comp = 6;
              tiff_ifd[ifd].bps = jh.bits;
              tiff_ifd[ifd].t_width = jh.wide;
              tiff_ifd[ifd].t_height = jh.high;
              tiff_ifd[ifd].samples = jh.clrs;
              if (!(jh.sraw || (jh.clrs & 1)))
                tiff_ifd[ifd].t_width *= jh.clrs;
              if ((tiff_ifd[ifd].t_width > 4 * tiff_ifd[ifd].t_height) & ~jh.clrs)
              {
                tiff_ifd[ifd].t_width /= 2;
                tiff_ifd[ifd].t_height *= 2;
              }
              i = order;
              parse_tiff(tiff_ifd[ifd].offset + 12);
              order = i;
            }
          }
        }
        break;
      }
    }
    else
    { /* processing Panasonic-specific "PanasonicRaw" tags */
      switch (tag)
      {
      case 0x0004: /*   4, SensorTopBorder */
        imgdata.sizes.raw_inset_crops[0].ctop = get2();
        break;
      case 0x000a: /*  10, BitsPerSample */
        pana_bpp = get2();
		pana_bpp = LIM(pana_bpp, 8, 16);
        break;
      case 0x000b: /*  11, Compression */
        imPana.Compression = get2();
        break;
      case 0x000e: /*  14, LinearityLimitRed */
      case 0x000f: /*  15, LinearityLimitGreen */
      case 0x0010: /*  16, LinearityLimitBlue */
        imgdata.color.linear_max[tag - 14] = get2();
        if (imgdata.color.linear_max[tag - 14] == 16383)
            imgdata.color.linear_max[tag - 14] -= 64;
        if (imgdata.color.linear_max[tag - 14] == 4095)
          imgdata.color.linear_max[tag - 14] -= 16;
        if (tag == 0x000f) // 15, LinearityLimitGreen
          imgdata.color.linear_max[3] = imgdata.color.linear_max[1];
        break;
      case 0x0013: /*  19, WBInfo */
        if ((i = get2()) > 0x100)
          break;
        for (c = 0; c < i; c++)
        {
          if ((j = get2()) < 0x100)
          {
			  if (j >= 0) {
				  icWBC[j][0] = get2();
				  icWBC[j][2] = get2();
				  icWBC[j][1] = icWBC[j][3] =
					  0x100;
			  }
          }
          else // light source out of EXIF numbers range
            get4();
        }
        break;
      case 0x0018: /* 24, HighISOMultiplierRed */
      case 0x0019: /* 25, HighISOMultiplierGreen */
      case 0x001a: /* 26, HighISOMultiplierBlue */
        imPana.HighISOMultiplier[tag - 0x0018] = get2();
        break;
      case 0x001c: /*  28, BlackLevelRed */
      case 0x001d: /*  29, BlackLevelGreen */
      case 0x001e: /*  30, BlackLevelBlue */
        pana_black[tag - 0x001c] = get2();
        break;
      case 0x002d: /*  45, RawFormat */
                   /* pana_encoding: tag 0x002d (45dec) not used - DMC-LX1/FZ30/FZ50/L1/LX1/LX2
                        2 - RAW DMC-FZ8/FZ18
                        3 - RAW DMC-L10
                        4 - RW2 for most other models, including G9 in "pixel shift off" mode and YUNEEC CGO4
                            (must add 15 to black levels for RawFormat == 4)
                        5 - RW2 DC-GH5s; G9 in "pixel shift on" mode
                        6 - RW2 DC-S1, DC-S1R in "pixel shift off" mode
                        7 - RW2 DC-S1R (probably DC-S1 too) in "pixel shift on" mode
                        8 - RW2 DC-GH6, DC-S5M2
                   */
        pana_encoding = get2();
        break;
      case 0x002f: /*  47, CropTop */
        imgdata.sizes.raw_inset_crops[0].ctop = get2();
        break;
      case 0x0030: /*  48, CropLeft */
        imgdata.sizes.raw_inset_crops[0].cleft = get2();
        break;
      case 0x0031: /*  49, CropBottom */
        imgdata.sizes.raw_inset_crops[0].cheight =
            get2() - imgdata.sizes.raw_inset_crops[0].ctop;
        break;
      case 0x0032: /*  50, CropRight */
        imgdata.sizes.raw_inset_crops[0].cwidth =
            get2() - imgdata.sizes.raw_inset_crops[0].cleft;
        break;
      case 0x0037: /*  55, ISO if  ISO in 0x8827 & ISO in 0x0017 == 65535 */
        if (iso_speed == 65535)
          iso_speed = float(get4());
        break;
	  case 0x0039:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 26)
        {
          ushort cnt = get2();
          if (cnt > 6)
            cnt = 6;
          for (i = 0; i < cnt; i++)
            pana8.tag39[i] = get4();
        }
        break;
      case 0x003A:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 26)
        {
          ushort cnt = get2();
          if (cnt > 6)
            cnt = 6;
		  for (i = 0; i < cnt; i++)
		  {
			  get2();
			  pana8.tag3A[i] = get2();
		  }
        }
        break;
      case 0x003B:
        if (type == LIBRAW_EXIFTAG_TYPE_SHORT && len == 1)
            pana8.tag3B = get2();
        break;
      case 0x003C:
      case 0x003D:
      case 0x003E:
      case 0x003F:
        if (type == LIBRAW_EXIFTAG_TYPE_SHORT && len == 1)
          pana8.initial[tag - 0x3c] = get2();
        break;
      case 0x0040:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 70)
        {
			ushort count = get2();
			if (count > 17) count = 17;
			for (i = 0; i < count; i++)
			{
				ushort v1 = get2();
				if (v1 > 16u) v1 = 16u;
				pana8.tag40a[i] = v1;
				ushort v2 = get2();
				if (v2 > 0xfffu)
					v2 = 0xfffu;
				pana8.tag40b[i] = v2;
			}
        }
        break;
      case 0x0041:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 36)
        {
          ushort count = get2();
          if (count > 17)
            count = 17;
          for (i = 0; i < count; i++)
          {
            ushort v1 = get2();
			if (v1 > 0x40u) v1 = 64;
            pana8.tag41[i] = v1;
          }
        }
        break;
      case 0x0042:
        if (type == LIBRAW_EXIFTAG_TYPE_SHORT && len == 1)
        {
          ushort val = get2();
          if (val > 5)
            val = 5;
          pana8.stripe_count = val;
        }
        break;
      case 0x0043:
        if (type == LIBRAW_EXIFTAG_TYPE_SHORT && len == 1)
        {
          ushort val = get2();
          if (val > 5)
            val = 5;
          pana8.tag43 = val;
        }
        break;
      case 0x0044:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 50)
        {
          ushort count = get2();
          if (count > 5)
            count = 5;
          for (i = 0; i < count; i++)
            pana8.stripe_offsets[i] = get4();
        }
        break;
      case 0x0045:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 50)
        {
          ushort count = get2();
          if (count > 5)
            count = 5;
          for (i = 0; i < count; i++)
            pana8.stripe_left[i] = get4();
        }
        break;
      case 0x0046:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 50)
        {
          ushort count = get2();
          if (count > 5)
            count = 5;
          for (i = 0; i < count; i++)
            pana8.stripe_compressed_size[i] = get4();
        }
        break;
      case 0x0047:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 26)
        {
          ushort count = get2();
          if (count > 5)
            count = 5;
          for (i = 0; i < count; i++)
            pana8.stripe_width[i] = get2();
        }
        break;
      case 0x0048:
        if (type == LIBRAW_EXIFTAG_TYPE_UNDEFINED && len == 26)
        {
          ushort count = get2();
          if (count > 5)
            count = 5;
          for (i = 0; i < count; i++)
            pana8.stripe_height[i] = get2();
        }
        break;
	  case 0x011c: /* 284, Gamma */
      {
        int n = get2();
        if (n >= 1024)
          imPana.gamma = (float)n / 1024.0f;
        else if (n >= 256)
          imPana.gamma = (float)n / 256.0f;
        else
          imPana.gamma = (float)n / 100.0f;
      }
      break;
      case 0x0120: /* 288, CameraIFD, contains tags 0x1xxx, 0x2xxx, 0x3xxx */
      {
        unsigned sorder = order;
        INT64 sbase = base;
        base = ftell(ifp);
        order = get2();
        fseek(ifp, 2, SEEK_CUR);
        fseek(ifp, INT64(get4()) - 8LL, SEEK_CUR);
        parse_tiff_ifd(base);
        base = sbase;
        order = sorder;
      }
      break;
      case 0x0121: /* 289, Multishot, 0 is Off, 65536 is Pixel Shift */
        imPana.Multishot = get4();
        break;
      case 0x1001:
      	if (imPana.Multishot == 0) {
      	  imPana.Multishot = get4();
      	  if (imPana.Multishot)
      	    imPana.Multishot += 65535;
      	}
        break;
      case 0x1100:
        imPana.FocusStepNear = get2();
        break;
      case 0x1101:
        imPana.FocusStepCount = get2();
        break;
      case 0x1105:
        imPana.ZoomPosition = get4();
        break;
      case 0x1201:
        if (tagtypeIs(LIBRAW_EXIFTAG_TYPE_SHORT)) {
          imPana.LensManufacturer = fgetc(ifp);
        } else if (type == 258) {
          imPana.LensManufacturer = get4();
          if (imPana.LensManufacturer >= 257) {
            ilm.LensMount = LIBRAW_MOUNT_LPS_L;
            ilm.LensFormat = LIBRAW_FORMAT_FF;
          }
        }
        break;
      case 0x1202:
        if (ilm.LensMount == LIBRAW_MOUNT_LPS_L) {
          if ((utmp = get2())) ilm.LensID = utmp;
        } else if ((imPana.LensManufacturer != 0xff) &&
                   (imPana.LensManufacturer != 0xffffffff)) {
          if ((utmp = (fgetc(ifp) << 8) | fgetc(ifp)))
            ilm.LensID = (imPana.LensManufacturer << 16) + utmp;
        }
        break;
      case 0x1203: /* 4611, FocalLengthIn35mmFormat, contained in 0x0120
                      CameraIFD */
        if (imgdata.lens.FocalLengthIn35mmFormat < 0.65f)
          imgdata.lens.FocalLengthIn35mmFormat = get2();
        break;
      case 0x2009: /* 8201, contained in 0x0120 CameraIFD */
        if ((pana_encoding == 4) || (pana_encoding == 5))
        {
          i = MIN(8, len);
          int permut[8] = {3, 2, 1, 0, 3 + 4, 2 + 4, 1 + 4, 0 + 4};
          imPana.BlackLevelDim = len;
          for (j = 0; j < i; j++)
          {
            imPana.BlackLevel[permut[j]] =
                (float)(get2()) / (float)(powf(2.f, 14.f - pana_bpp));
          }
        }
        break;
      case 0x3420: /* 13344, WB_RedLevelAuto, contained in 0x0120 CameraIFD */
        icWBC[LIBRAW_WBI_Auto][0] = get2();
        icWBC[LIBRAW_WBI_Auto][1] = icWBC[LIBRAW_WBI_Auto][3] = 1024;
        break;
      case 0x3421: /* 13345, WB_BlueLevelAuto, contained in 0x0120 CameraIFD */
        icWBC[LIBRAW_WBI_Auto][2] = get2();
        break;
      case 0x0002: /*   2, ImageWidth */
        tiff_ifd[ifd].t_width = getint(type);
        break;
      case 0x0003: /*   3, ImageHeight */
        tiff_ifd[ifd].t_height = getint(type);
        break;
      case 0x0005: /*   5, SensorLeftBorder */
        width = get2();
        imgdata.sizes.raw_inset_crops[0].cleft = width;
        break;
      case 0x0006: /*   6, SensorBottomBorder */
        height = get2();
        imgdata.sizes.raw_inset_crops[0].cheight =
            height - imgdata.sizes.raw_inset_crops[0].ctop;
        break;
      case 0x0007: /*   7, SensorRightBorder */
        i = get2();
        width += i;
        imgdata.sizes.raw_inset_crops[0].cwidth =
            i - imgdata.sizes.raw_inset_crops[0].cleft;
        break;
      case 0x0009: /*   9, CFAPattern */
        if ((i = get2()))
          filters = i;
        break;
      case 0x0011: /*  17, RedBalance */
      case 0x0012: /*  18, BlueBalance */
        if (tagtypeIs(LIBRAW_EXIFTAG_TYPE_SHORT) && len == 1)
          cam_mul[(tag - 0x0011) * 2] = get2() / 256.f;
        break;
      case 0x0017: /*  23, ISO */
        if (tagtypeIs(LIBRAW_EXIFTAG_TYPE_SHORT))
          iso_speed = get2();
        break;
      case 0x0024: /*  36, WBRedLevel */
      case 0x0025: /*  37, WBGreenLevel */
      case 0x0026: /*  38, WBBlueLevel */
        cam_mul[tag - 0x0024] = get2();
        break;
      case 0x0027: /*  39, WBInfo2 */
        if ((i = get2()) > 0x100)
          break;
        for (c = 0; c < i; c++)
        {
          if ((j = get2()) < 0x100)
          {
			  if (j >= 0) {
				  icWBC[j][0] = get2();
				  icWBC[j][1] = icWBC[j][3] = get2();
				  icWBC[j][2] = get2();
				  if (c == 1 && i > 6 && cam_mul[0] <= 0.001f)
					  for (int q = 0; q < 4; q++)
						  cam_mul[q] = float(icWBC[j][q]);
			  }
          }
          else
            fseek(ifp, 6, SEEK_CUR);
        }
        break;
      case 0x002e: /*  46, JpgFromRaw */
        if ((type != LIBRAW_EXIFTAG_TYPE_UNDEFINED) || (fgetc(ifp) != 0xff) || (fgetc(ifp) != 0xd8))
          break;
        thumb_offset = ftell(ifp) - 2;
        thumb_length = len;
        break;

      case 0x0118: /* 280, Panasonic RW2 offset */
        if (type != LIBRAW_EXIFTAG_TYPE_LONG)
          break;
        load_raw = &LibRaw::panasonic_load_raw;
        load_flags = 0x2008;
      case 0x0111: /* 273, StripOffset */
        if (len > 1 && len < 16384)
        {
          INT64 sav = ftell(ifp);
          tiff_ifd[ifd].strip_offsets = (INT64 *)calloc(len, sizeof(INT64));
          tiff_ifd[ifd].strip_offsets_count = len;
          for (int ii = 0; ii < (int)len; ii++)
            tiff_ifd[ifd].strip_offsets[ii] = get4() + base;
          fseek(ifp, sav, SEEK_SET); // restore position
        }
        /* fallthrough */
        tiff_ifd[ifd].offset = get4() + base;
        if (!tiff_ifd[ifd].bps && tiff_ifd[ifd].offset > 0)
        {
          fseek(ifp, tiff_ifd[ifd].offset, SEEK_SET);
          if (ljpeg_start(&jh, 1))
          {
            tiff_ifd[ifd].comp = 6;
            tiff_ifd[ifd].t_width = jh.wide;
            tiff_ifd[ifd].t_height = jh.high;
            tiff_ifd[ifd].bps = jh.bits;
            tiff_ifd[ifd].samples = jh.clrs;
            if (!(jh.sraw || (jh.clrs & 1)))
              tiff_ifd[ifd].t_width *= jh.clrs;
            if ((tiff_ifd[ifd].t_width > 4 * tiff_ifd[ifd].t_height) & ~jh.clrs)
            {
              tiff_ifd[ifd].t_width /= 2;
              tiff_ifd[ifd].t_height *= 2;
            }
            i = order;
            parse_tiff(tiff_ifd[ifd].offset + 12);
            order = i;
          }
        }
        break;
      }

    } /* processing of Panasonic-specific tags finished */

    switch (tag)
    {            /* processing of general EXIF tags */
    case 0xf000: /* 61440, Fuji HS10 table */
      fseek(ifp, get4() + base, SEEK_SET);
      parse_tiff_ifd(base);
      break;
    case 0x00fe: /* NewSubfileType */
      tiff_ifd[ifd].newsubfiletype = int(getreal(type));
      break;
    case 0x0100: /* 256, ImageWidth */
    case 0xf001: /* 61441, Fuji RAF RawImageFullWidth */
      tiff_ifd[ifd].t_width = getint(type);
      break;
    case 0x0101: /* 257, ImageHeight */
    case 0xf002: /* 61442, Fuji RAF RawImageFullHeight */
      tiff_ifd[ifd].t_height = getint(type);
      break;
    case 0x0102: /* 258, BitsPerSample */
    case 0xf003: /* 61443, Fuji RAF 0xf003 */
      if(!tiff_ifd[ifd].samples || tag != 0x0102) // ??? already set by tag 0x115
        tiff_ifd[ifd].samples = len & 7;
      tiff_ifd[ifd].bps = getint(type);
      if (tiff_bps < (unsigned)tiff_ifd[ifd].bps)
        tiff_bps = tiff_ifd[ifd].bps;
      break;
    case 0xf006: /* 61446, Fuji RAF 0xf006 */
      raw_height = 0;
      if (tiff_ifd[ifd].bps > 12)
        break;
      load_raw = &LibRaw::packed_load_raw;
      load_flags = get4() ? 24 : 80;
      break;
    case 0x0103: /* 259, Compression */
                 /*
                    262	 = Kodak 262
                  32767  = Sony ARW Compressed
                  32769  = Packed RAW
                  32770  = Samsung SRW Compressed
                  32772  = Samsung SRW Compressed 2
                  32867  = Kodak KDC Compressed
                  34713  = Nikon NEF Compressed
                  65000  = Kodak DCR Compressed
                  65535  = Pentax PEF Compressed
                 */
      tiff_ifd[ifd].comp = getint(type);
      break;
    case 0x0106: /* 262, PhotometricInterpretation */
      tiff_ifd[ifd].phint = get2();
      break;
    case 0x010e: /* 270, ImageDescription */
      fread(desc, 512, 1, ifp);
      desc[511] = 0;
      break;
    case 0x010f: /* 271, Make */
      fgets(make, 64, ifp);
      break;
    case 0x0110: /* 272, Model */
      if (!strncmp(make, "Hasselblad", 10) && model[0] &&
          (imHassy.format != LIBRAW_HF_Imacon))
        break;
      fgets(model, 64, ifp);
      break;
    case 0x0116: // 278
      tiff_ifd[ifd].rows_per_strip = getint(type);
      break;
    case 0x0112: /* 274, Orientation */
      tiff_ifd[ifd].t_flip = "50132467"[get2() & 7] - '0';
      break;
    case 0x0115: /* 277, SamplesPerPixel */
      tiff_ifd[ifd].samples = getint(type) & 7;
      break;
    case 0x0152: /* Extrasamples */
      tiff_ifd[ifd].extrasamples = (getint(type) & 0xff) + 1024;
      break;
    case 0x0117: /* 279, StripByteCounts */
      if (len > 1 && len < 16384)
      {
        INT64 sav = ftell(ifp);
        tiff_ifd[ifd].strip_byte_counts = (INT64 *)calloc(len, sizeof(INT64));
        tiff_ifd[ifd].strip_byte_counts_count = len;
        for (int ii = 0; ii < (int)len; ii++)
          tiff_ifd[ifd].strip_byte_counts[ii] = get4();
        fseek(ifp, sav, SEEK_SET); // restore position
      }
      /* fallback */
    case 0x0202: // 514
    case 0xf008: // 61448
      tiff_ifd[ifd].bytes = get4();
      break;
    case 0xf00e: // 61454, FujiFilm "As Shot"
      FORC3 cam_mul[GRBG_2_RGBG(c)] = float(getint(type));
      break;
    case 0x0131: /* 305, Software */
      fgets(software, 64, ifp);
      if (!strncmp(software, "Adobe", 5) || !strncmp(software, "dcraw", 5) ||
          !strncmp(software, "UFRaw", 5) || !strncmp(software, "Bibble", 6) ||
          !strcmp(software, "Digital Photo Professional"))
        is_raw = 0;
      break;
    case 0x0132: /* 306, DateTime */
      get_timestamp(0);
      break;
    case 0x013b: /* 315, Artist */
      fread(artist, 64, 1, ifp);
      artist[63] = 0;
      break;
    case 0x013d: // 317
      tiff_ifd[ifd].predictor = getint(type);
      break;
    case 0x0142: /* 322, TileWidth */
      tiff_ifd[ifd].t_tile_width = getint(type);
      break;
    case 0x0143: /* 323, TileLength */
      tiff_ifd[ifd].t_tile_length = getint(type);
      break;
    case 0x0144: /* 324, TileOffsets */
      tiff_ifd[ifd].offset = len > 1 ? ftell(ifp) : get4(); // FIXME: get8 for BigTIFF
      if (len == 1)
        tiff_ifd[ifd].t_tile_width = tiff_ifd[ifd].t_tile_length = 0;
      if (len == 4)
      {
        load_raw = &LibRaw::sinar_4shot_load_raw;
        is_raw = 5;
      }
      break;
    case 0x0145: // 325
      tiff_ifd[ifd].bytes = len > 1 ? ftell(ifp) : get4(); // FIXME: get8 for BigTIFF
      break;
    case 0x014a: /* 330, SubIFDs */
      if (!strcmp(model, "DSLR-A100") && tiff_ifd[ifd].t_width == 3872)
      {
        load_raw = &LibRaw::sony_arw_load_raw;
        data_offset = get4() + base;
        ifd++;
        if (ifd >= int(sizeof tiff_ifd / sizeof tiff_ifd[0]))
          throw LIBRAW_EXCEPTION_IO_CORRUPT;
        break;
      }
      if (!strncmp(make, "Hasselblad", 10) &&
          libraw_internal_data.unpacker_data.hasselblad_parser_flag)
      {
        fseek(ifp, ftell(ifp) + 4, SEEK_SET);
        fseek(ifp, get4() + base, SEEK_SET);
        parse_tiff_ifd(base);
        break;
      }
      if (len > 1000)
        len = 1000; /* 1000 SubIFDs is enough */
      while (len--)
      {
        INT64 ii = ftell(ifp);
        fseek(ifp, get4() + base, SEEK_SET);
        if (parse_tiff_ifd(base))
          break;
        fseek(ifp, ii + 4LL, SEEK_SET);
      }
      break;
    case 0x0153: // 339
      tiff_ifd[ifd].sample_format = getint(type);
      break;
    case 0x0190: // 400
      strcpy(make, "Sarnoff");
      maximum = 0xfff;
      break;
    case 0x02bc: // 700
      if ((tagtypeIs(LIBRAW_EXIFTAG_TYPE_BYTE) ||
          tagtypeIs(LIBRAW_EXIFTAG_TYPE_ASCII) ||
          tagtypeIs(LIBRAW_EXIFTAG_TYPE_SBYTE) ||
          tagtypeIs(LIBRAW_EXIFTOOLTAGTYPE_binary)) &&
          (len > 1) && (len < 5100000))
      {
        xmpdata = (char *)calloc(xmplen = len + 1,1);
        unsigned br = fread(xmpdata,1, len, ifp);
        xmpdata[br] = 0;
      }
      break;
    case 0x7000:
      imSony.SonyRawFileType = get2();
      break;
    case 0x7010: // 28688
      FORC4 sony_curve[c + 1] = get2() >> 2 & 0xfff;
      for (i = 0; i < 5; i++)
        for (j = sony_curve[i] + 1; j <= (int)sony_curve[i + 1]; j++)
          curve[j] = curve[j - 1] + (1 << i);
      break;
    case 0x7200: // 29184, Sony SR2Private
      sony_offset = get4();
      break;
    case 0x7201: // 29185, Sony SR2Private
      sony_length = get4();
      break;
    case 0x7221: // 29217, Sony SR2Private
      sony_key = get4();
      break;
    case 0x7250: // 29264, Sony SR2Private
      parse_minolta(ftell(ifp));
      raw_width = 0;
      break;
    case 0x7303: // 29443, Sony SR2SubIFD
      FORC4 cam_mul[GRBG_2_RGBG(c)] = get2();
      break;
    case 0x7313: // 29459, Sony SR2SubIFD
      FORC4 cam_mul[RGGB_2_RGBG(c)] = get2();
      break;
    case 0x7310: // 29456, Sony SR2SubIFD
      FORC4 cblack[RGGB_2_RGBG(c)] = get2();
      i = cblack[3];
      FORC3 if (i > (int)cblack[c]) i = cblack[c];
      FORC4 cblack[c] -= i;
      black = i;
      break;
    case 0x827d: /* 33405, Model2 */
                 /*
                  for Kodak ProBack 645 PB645x-yyyy 'x' is:
                  'M' for Mamiya 645
                  'C' for Contax 645
                  'H' for Hasselblad H-series
                 */
      fgets(model2, 64, ifp);
      break;
    case 0x828d: /* 33421, CFARepeatPatternDim */
      if (get2() == 6 && get2() == 6)
        tiff_ifd[ifd].t_filters = filters = 9;
      break;
    case 0x828e: /* 33422, CFAPattern */
      if (filters == 9)
      {
        FORC(36)((char *)xtrans)[c] = fgetc(ifp) & 3;
        break;
      }
    case 0xfd09: /* 64777, Kodak P-series */
      if (len == 36)
      {
        tiff_ifd[ifd].t_filters = filters = 9;
        colors = 3;
        FORC(36)((char *)xtrans)[c] = fgetc(ifp) & 3;
      }
      else if (len > 0)
      {
        if ((plen = len) > 16)
          plen = 16;
        fread(cfa_pat, 1, plen, ifp);
        for (colors = cfa = i = 0; i < (int)plen && colors < 4; i++)
        {
          if (cfa_pat[i] > 31)
            continue; // Skip wrong data
          colors += !(cfa & (1 << cfa_pat[i]));
          cfa |= 1 << cfa_pat[i];
        }
        if (cfa == 070)
          memcpy(cfa_pc, "\003\004\005", 3); /* CMY */
        if (cfa == 072)
          memcpy(cfa_pc, "\005\003\004\001", 4); /* GMCY */
        goto guess_cfa_pc;
      }
      break;
    case 0x8290: // 33424
    case 0xfe00: // 65024
      fseek(ifp, get4() + base, SEEK_SET);
      parse_kodak_ifd(base);
      break;
    case 0x829a: /* 33434, ExposureTime */
      tiff_ifd[ifd].t_shutter = shutter = getrealf(type);
      break;
    case 0x829d: /* 33437, FNumber */
      aperture = getrealf(type);
      break;
    case 0x9400:
      imCommon.exifAmbientTemperature = getrealf(type);
      if ((imCommon.CameraTemperature > -273.15f) &&
          ((OlyID == OlyID_TG_5) ||
           (OlyID == OlyID_TG_6) ||
           (OlyID == OlyID_TG_7)))
        imCommon.CameraTemperature +=
            imCommon.exifAmbientTemperature;
      break;
    case 0x9401:
      imCommon.exifHumidity = getrealf(type);
      break;
    case 0x9402:
      imCommon.exifPressure = getrealf(type);
      break;
    case 0x9403:
      imCommon.exifWaterDepth = getrealf(type);
      break;
    case 0x9404:
      imCommon.exifAcceleration = getrealf(type);
      break;
    case 0x9405:
      imCommon.exifCameraElevationAngle = getrealf(type);
      break;
    case 0xa405: // FocalLengthIn35mmFormat
      imgdata.lens.FocalLengthIn35mmFormat = get2();
      break;
    case 0xa431: // BodySerialNumber
    case 0xc62f:
      stmread(imgdata.shootinginfo.BodySerial, len, ifp);
      break;
    case 0xa432: // LensInfo, 42034dec, Lens Specification per EXIF standard
      imgdata.lens.MinFocal = getrealf(type);
      imgdata.lens.MaxFocal = getrealf(type);
      imgdata.lens.MaxAp4MinFocal = getrealf(type);
      imgdata.lens.MaxAp4MaxFocal = getrealf(type);
      break;
    case 0xa435: // LensSerialNumber
      stmread(imgdata.lens.LensSerial, len, ifp);
      break;
    case 0xc630: // DNG LensInfo, Lens Specification per EXIF standard
      imgdata.lens.MinFocal = getrealf(type);
      imgdata.lens.MaxFocal = getrealf(type);
      imgdata.lens.MaxAp4MinFocal = getrealf(type);
      imgdata.lens.MaxAp4MaxFocal = getrealf(type);
      break;
    case 0xa420: /* 42016, ImageUniqueID */
      stmread(imgdata.color.ImageUniqueID, len, ifp);
      break;
    case 0xc65d: /* 50781, RawDataUniqueID */
      imgdata.color.RawDataUniqueID[16] = 0;
      fread(imgdata.color.RawDataUniqueID, 1, 16, ifp);
      break;
    case 0xa433: // LensMake
      stmread(imgdata.lens.LensMake, len, ifp);
      break;
    case 0xa434: // LensModel
      stmread(imgdata.lens.Lens, len, ifp);
      if (!strncmp(imgdata.lens.Lens, "----", 4))
        imgdata.lens.Lens[0] = 0;
      break;
    case 0x9205:
      imgdata.lens.EXIF_MaxAp = libraw_powf64l(2.0f, (getrealf(type) / 2.0f));
      break;
    case 0x8602: /* 34306, Leaf white balance */
      FORC4
      {
        int q = get2();
        if (q)
          cam_mul[GRGB_2_RGBG(c)] = 4096.f / q;
      }
      break;
    case 0x8603: /* 34307, Leaf CatchLight color matrix */
      fread(software, 1, 7, ifp);
      if (strncmp(software, "MATRIX", 6))
        break;
      colors = 4;
      for (raw_color = i = 0; i < 3; i++)
      {
        FORC4 fscanf(ifp, "%f", &rgb_cam[i][GRGB_2_RGBG(c)]);
        if (!use_camera_wb)
          continue;
        num = 0;
        FORC4 num += rgb_cam[i][c];
        FORC4 rgb_cam[i][c] /= float(MAX(1, num));
      }
      break;
    case 0x8606: /* 34310, Leaf metadata */
      parse_mos(ftell(ifp));
    case 0x85ff: // 34303
      strcpy(make, "Leaf");
      break;
    case 0x8769: /* 34665, EXIF tag */
      fseek(ifp, get4() + base, SEEK_SET);
      parse_exif(base);
      break;
    case 0x8825: /* 34853, GPSInfo tag */
    {
      INT64 pos;
      fseek(ifp, pos = (get4() + base), SEEK_SET);
      parse_gps(base);
      fseek(ifp, pos, SEEK_SET);
      parse_gps_libraw(base);
    }
    break;
    case 0x8773: /* 34675, InterColorProfile */
    case 0xc68f: /* 50831, AsShotICCProfile */
      profile_offset = ftell(ifp);
      profile_length = len;
      break;
    case 0x9102: /* 37122, CompressedBitsPerPixel */
      kodak_cbpp = get4();
      break;
    case 0x920a: /* 37386, FocalLength */
      focal_len = getrealf(type);
      break;
    case 0x9211: /* 37393, ImageNumber */
      shot_order = getint(type);
      break;
    case 0x9215: /* 37397, ExposureIndex */
      imCommon.exifExposureIndex = getrealf(type);
      break;
    case 0x9218: /* 37400, old Kodak KDC tag */
      for (raw_color = i = 0; i < 3; i++)
      {
        getreal(type);
        FORC3 rgb_cam[i][c] = getrealf(type);
      }
      break;
    case 0xa010: // 40976
      strip_offset = get4();
      switch (tiff_ifd[ifd].comp)
      {
      case 0x8002: // 32770
        load_raw = &LibRaw::samsung_load_raw;
        break;
      case 0x8004: // 32772
        load_raw = &LibRaw::samsung2_load_raw;
        break;
      case 0x8005: // 32773
        load_raw = &LibRaw::samsung3_load_raw;
        break;
      }
      break;
    case 0xb4c3: /* 46275, Imacon tags */
      imHassy.format = LIBRAW_HF_Imacon;
      strcpy(make, "Imacon");
      data_offset = ftell(ifp);
      ima_len = len;
      break;
    case 0xb4c7: // 46279
      if (!ima_len)
        break;
      fseek(ifp, 38, SEEK_CUR);
    case 0xb4c2: // 46274
      fseek(ifp, 40, SEEK_CUR);
      raw_width = get4();
      raw_height = get4();
      left_margin = get4() & 7;
      width = raw_width - left_margin - (get4() & 7);
      top_margin = get4() & 7;
      height = raw_height - top_margin - (get4() & 7);
      if (raw_width == 7262 && ima_len == 234317952)
      {
        height = 5412;
        width = 7216;
        left_margin = 7;
        filters = 0;
      }
      else if (raw_width == 7262)
      {
        height = 5444;
        width = 7244;
        left_margin = 7;
      }
      fseek(ifp, 52, SEEK_CUR);
      FORC3 cam_mul[c] = getrealf(LIBRAW_EXIFTAG_TYPE_FLOAT);
      fseek(ifp, 114, SEEK_CUR);
      flip = (get2() >> 7) * 90;
      if (width * (height * 6l) == ima_len)
      {
        if (flip % 180 == 90)
          SWAP(width, height);
        raw_width = width;
        raw_height = height;
        left_margin = top_margin = filters = flip = 0;
      }
      c = unsigned(height) * unsigned(width) / 1000000;
      if (c == 32)
        c--;
      sprintf(model, "Ixpress %d-Mp", c);
      load_raw = &LibRaw::imacon_full_load_raw;
      if (filters)
      {
        if (left_margin & 1)
          filters = 0x61616161;
        load_raw = &LibRaw::unpacked_load_raw;
      }
      maximum = 0xffff;
      break;
    case 0xc516: /* 50454, Sinar tag */
    case 0xc517: // 50455
      if (len < 1 || len > 2560000 || !(cbuf = (char *)malloc(len)))
        break;
      if (fread(cbuf, 1, len, ifp) != (int)len)
        throw LIBRAW_EXCEPTION_IO_CORRUPT; // cbuf to be free'ed in recycle
      cbuf[len - 1] = 0;
      for (cp = cbuf - 1; cp && cp < cbuf + len; cp = strchr(cp, '\n'))
        if (!strncmp(++cp, "Neutral ", 8))
          sscanf(cp + 8, "%f %f %f", cam_mul, cam_mul + 1, cam_mul + 2);
      free(cbuf);
      break;
    case 0xc51a: // 50458
      if (!make[0])
        strcpy(make, "Hasselblad");
      break;
    case 0xc51b: /* 50459, Hasselblad tag */
      if (!libraw_internal_data.unpacker_data.hasselblad_parser_flag)
      {
        libraw_internal_data.unpacker_data.hasselblad_parser_flag = 1;
        i = order;
        INT64 jj = ftell(ifp);
        c = tiff_nifds;
        order = get2();
		get2();
        fseek(ifp, jj + get4(), SEEK_SET);
        parse_tiff_ifd(jj);
        maximum = 0xffff;
        tiff_nifds = c;
        order = i;
        break;
      }
    case 0xc612: /* 50706, DNGVersion */
      FORC4 dng_version = (dng_version << 8) + fgetc(ifp);
      if (!make[0])
        strcpy(make, "DNG");
      is_raw = 1;
      break;
    case 0xc614: /* 50708, UniqueCameraModel */
      stmread(imgdata.color.UniqueCameraModel, len, ifp);
      if (model[0])
        break;
      strncpy(make, imgdata.color.UniqueCameraModel,
              MIN(len, sizeof(imgdata.color.UniqueCameraModel)));
      if ((cp = strchr(make, ' ')))
      {
        strcpy(model, cp + 1);
        *cp = 0;
      }
      break;
    case 0xc616: /* 50710, CFAPlaneColor */
      if (filters == 9)
        break;
      if (len > 4)
        len = 4;
      colors = len;
      fread(cfa_pc, 1, colors, ifp);
    guess_cfa_pc:
      FORCC tab[cfa_pc[c]] = c;
      cdesc[c] = 0;
      for (i = 16; i--;)
        filters = filters << 2 | tab[cfa_pat[i % plen]];
      filters -= !filters;
      tiff_ifd[ifd].t_filters = filters;
      break;
    case 0xc617: /* 50711, CFALayout */
      if (get2() == 2)
        tiff_ifd[ifd].t_fuji_width = fuji_width = 1;
      break;
    case 0x0123: // 291
    case 0xc618: /* 50712, LinearizationTable */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_LINTABLE;
      tiff_ifd[ifd].lineartable_offset = ftell(ifp);
      tiff_ifd[ifd].lineartable_len = len;
      linear_table(len);
      break;
    case 0xc619: /* 50713, BlackLevelRepeatDim */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
      
	  tiff_ifd[ifd].dng_levels.dng_cblack[4] = cblack[4] = get2();
	  tiff_ifd[ifd].dng_levels.dng_fcblack[4] = float(cblack[4]);
		 
	  
      tiff_ifd[ifd].dng_levels.dng_cblack[5] = cblack[5] = get2();
	  tiff_ifd[ifd].dng_levels.dng_fcblack[5] = float(cblack[5]);

	  if (cblack[4] * cblack[5] >
		  (LIBRAW_CBLACK_SIZE -
			  7)) // Use last cblack item as DNG black level count
	  {
		  tiff_ifd[ifd].dng_levels.dng_fcblack[4] =
			  tiff_ifd[ifd].dng_levels.dng_fcblack[5] = 1.f;
		  tiff_ifd[ifd].dng_levels.dng_cblack[4] = tiff_ifd[ifd].dng_levels.dng_cblack[5] =
			  cblack[4] = cblack[5] = 1;
	  }
      break;

    case 0xf00c:
      if (imFuji.RAFDataGeneration != 4096)
      {
        unsigned fwb[4];
        FORC4 fwb[c] = get4();
        if (fwb[3] < 0x100)
        {
          FORC3 icWBC[fwb[3]][GRBG_2_RGBG(c)] = fwb[c];
          icWBC[fwb[3]][3] = icWBC[fwb[3]][1];
          if ((fwb[3] == 17) &&                                      // Tungsten WB
              (libraw_internal_data.unpacker_data.lenRAFData > 3) &&
              (libraw_internal_data.unpacker_data.lenRAFData < 10240000))
          {
            INT64 f_save = ftell(ifp);
            rafdata = (ushort *)calloc(
                sizeof(ushort) * libraw_internal_data.unpacker_data.lenRAFData+1,1);
            fseek(ifp, libraw_internal_data.unpacker_data.posRAFData, SEEK_SET);
            fread(rafdata, sizeof(ushort),
                  libraw_internal_data.unpacker_data.lenRAFData, ifp);
            fseek(ifp, f_save, SEEK_SET);

            uchar *PrivateMknBuf = (uchar *)rafdata;
            int PrivateMknLength = libraw_internal_data.unpacker_data.lenRAFData
                                   << 1;
            for (int pos = 0; pos < PrivateMknLength - 16; pos++)
            {
              if (!memcmp(PrivateMknBuf + pos, "TSNERDTS", 8)) // STDRENST
              {
                imFuji.isTSNERDTS = 1;
                break;
              }
            }
            int fj; // 31? (fj<<1)-0x3c : 34? (fj<<1)-0x4e : undef
            int is34 = 0;
            if ((imFuji.RAFDataVersion == 0x0260) || // X-Pro3, GFX 100S
                (imFuji.RAFDataVersion == 0x0261) || // X100V, GFX 50S II
                (imFuji.RAFDataVersion == 0x0262) || // X-T4
                (imFuji.RAFDataVersion == 0x0263) || // X-H2S
                (imFuji.RAFDataVersion == 0x0264) || // X-S10, X-H2
                (imFuji.RAFDataVersion == 0x0265) || // X-E4, X-T5
                (imFuji.RAFDataVersion == 0x0266) || // X-T30 II, X-S20
                (imFuji.RAFDataVersion == 0x0267) || // GFX 100 II
                (imFuji.RAFDataVersion == 0x0368) || // GFX 100S II
                (imFuji.RAFDataVersion == 0x0369) || // X100VI
                (imFuji.RAFDataVersion == 0x036a) || // X-T50
                (imFuji.RAFDataVersion == 0x036b) || // X-M5
                !strcmp(model, "X-Pro3")     ||
                !strcmp(model, "GFX100S II") || !strcmp(model, "GFX 100S II") ||
                !strcmp(model, "GFX100S")    || !strcmp(model, "GFX 100S")    ||
                !strcmp(model, "GFX100 II")  || !strcmp(model, "GFX 100 II")  ||
                !strcmp(model, "GFX50S II")  || !strcmp(model, "GFX 50S II")  ||
                !strcmp(model, "X100VI")     ||
                !strcmp(model, "X100V")      ||
                !strcmp(model, "X-T4")       ||
                !strcmp(model, "X-H2S")      ||
                !strcmp(model, "X-H2")       ||
                !strcmp(model, "X-E4")       ||
                !strcmp(model, "X-T50")      ||
                !strcmp(model, "X-T5")       ||
                !strcmp(model, "X-M5")       ||
                !strcmp(model, "X-T30 II")   ||
                !strcmp(model, "X-S10")      ||
                !strcmp(model, "X-S20"))
// is34 cameras have 34 CCT values instead of 31, manual still claims 2500 to 10000 K
// aligned 3000 K to Incandescent, as it is usual w/ other Fujifilm cameras
              is34 = 1;

            for (int fi = 0;
                 fi < int(libraw_internal_data.unpacker_data.lenRAFData - 3); fi++) // looking for Tungsten WB
            {
              if ((fwb[0] == rafdata[fi]) && (fwb[1] == rafdata[fi + 1]) &&
                  (fwb[2] == rafdata[fi + 2])) // found Tungsten WB
              {
                if (fi > 14 && rafdata[fi - 15] !=
                    fwb[0]) // 15 is offset of Tungsten WB from the first
                            // preset, Fine Weather WB
                  continue;
				if (fi >= 15)
				{
					for (int wb_ind = 0, ofst = fi - 15; wb_ind < (int)Fuji_wb_list1.size();
						wb_ind++, ofst += 3)
					{
						icWBC[Fuji_wb_list1[wb_ind]][1] =
							icWBC[Fuji_wb_list1[wb_ind]][3] = rafdata[ofst];
						icWBC[Fuji_wb_list1[wb_ind]][0] = rafdata[ofst + 1];
						icWBC[Fuji_wb_list1[wb_ind]][2] = rafdata[ofst + 2];
					}
				}

                if (is34)
                  fi += 24;
                fi += 96;
                for (fj = fi; fj < (fi + 15); fj += 3) // looking for the end of the WB table
                {
					if (fj > libraw_internal_data.unpacker_data.lenRAFData - 3)
						break;
                  if (rafdata[fj] != rafdata[fi])
                  {
                    fj -= 93;
                    if (is34)
                      fj -= 9;
//printf ("wb start in DNG: 0x%04x\n", fj*2-0x4e);
                    for (int iCCT = 0, ofst = fj; iCCT < 31 
						&& ofst < libraw_internal_data.unpacker_data.lenRAFData - 3;
                         iCCT++, ofst += 3)
                    {
                      icWBCCTC[iCCT][0] = float(FujiCCT_K[iCCT]);
                      icWBCCTC[iCCT][1] = rafdata[ofst + 1];
                      icWBCCTC[iCCT][2] = icWBCCTC[iCCT][4] = rafdata[ofst];
                      icWBCCTC[iCCT][3] = rafdata[ofst + 2];
                    }
                    break;
                  }
                }
                free(rafdata);
                break;
              }
            }
          }
        }
        FORC4 fwb[c] = get4();
        if (fwb[3] < 0x100) {
          FORC3 icWBC[fwb[3]][GRBG_2_RGBG(c)] = fwb[c];
          icWBC[fwb[3]][3] = icWBC[fwb[3]][1];
        }
      }
      break;
    case 0xf00d:
      if (imFuji.RAFDataGeneration != 4096)
      {
        FORC3 icWBC[LIBRAW_WBI_Auto][GRBG_2_RGBG(c)] = getint(type);
        icWBC[LIBRAW_WBI_Auto][3] = icWBC[LIBRAW_WBI_Auto][1];
      }
      break;
    case 0xc615: /* 50709, LocalizedCameraModel */
      stmread(imgdata.color.LocalizedCameraModel, len, ifp);
      break;
    case 0xf00a: // 61450
      cblack[4] = cblack[5] = int(MIN(sqrtf((float)len), 64.f));
    case 0xc61a: /* 50714, BlackLevel */
      if (tiff_ifd[ifd].samples > 1 &&
          tiff_ifd[ifd].samples == (int)len) // LinearDNG, per-channel black
      {
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
        for (i = 0; i < 4 && i < (int)len; i++)
        {
          tiff_ifd[ifd].dng_levels.dng_fcblack[i] = getrealf(type);
          tiff_ifd[ifd].dng_levels.dng_cblack[i] = cblack[i] =
              unsigned(tiff_ifd[ifd].dng_levels.dng_fcblack[i] + 0.5f);
        }
        // Record len in last cblack field
        tiff_ifd[ifd].dng_levels.dng_cblack[LIBRAW_CBLACK_SIZE - 1] = len;

		tiff_ifd[ifd].dng_levels.dng_fblack = 0.f;
        tiff_ifd[ifd].dng_levels.dng_black = black = 0;
      }
      else if (tiff_ifd[ifd].samples > 1 // Linear DNG w repeat dim
               && (tiff_ifd[ifd].samples * cblack[4] * cblack[5] == len))
      {
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
        tiff_ifd[ifd].dng_levels.dng_cblack[LIBRAW_CBLACK_SIZE - 1] =
            cblack[LIBRAW_CBLACK_SIZE - 1] = len;
        for (i = 0; i < (int)len && i < LIBRAW_CBLACK_SIZE - 7; i++)
        {
          tiff_ifd[ifd].dng_levels.dng_fcblack[i + 6] = getrealf(type);
          tiff_ifd[ifd].dng_levels.dng_cblack[i + 6] = cblack[i + 6] =
              unsigned(tiff_ifd[ifd].dng_levels.dng_fcblack[i + 6] + 0.5f);
        }
      }
      else if ((cblack[4] * cblack[5] < 2) && len == 1)
      {
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
        tiff_ifd[ifd].dng_levels.dng_fblack = getrealf(type);
        black = tiff_ifd[ifd].dng_levels.dng_black =
            unsigned(tiff_ifd[ifd].dng_levels.dng_fblack);
      }
      else if (cblack[4] * cblack[5] <= len)
      {
        FORC(int(cblack[4] * cblack[5]))
        {
          tiff_ifd[ifd].dng_levels.dng_fcblack[6 + c] = getrealf(type);
          cblack[6 + c] = unsigned(tiff_ifd[ifd].dng_levels.dng_fcblack[6 + c]);
        }
        black = 0;
        FORC4
        cblack[c] = 0;

        if (tag == 0xc61a)
        {
          tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
          FORC(int(cblack[4] * cblack[5]))
          tiff_ifd[ifd].dng_levels.dng_cblack[6 + c] = cblack[6 + c];
          tiff_ifd[ifd].dng_levels.dng_fblack = 0;
          tiff_ifd[ifd].dng_levels.dng_black = 0;
		  FORC4
		  {
			  tiff_ifd[ifd].dng_levels.dng_fcblack[c] = 0.f;
			  tiff_ifd[ifd].dng_levels.dng_cblack[c] = 0;
		  }
        }
      }
      break;
    case 0xc61b: /* 50715, BlackLevelDeltaH */
    case 0xc61c: /* 50716, BlackLevelDeltaV */
      for (num = i = 0; i < (int)len && i < 65536; i++)
        num += getreal(type);
      if (len > 0)
      {
        black += unsigned(num / len + 0.5);
        tiff_ifd[ifd].dng_levels.dng_fblack += float(num / len);
        tiff_ifd[ifd].dng_levels.dng_black += unsigned(num / len + 0.5);
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BLACK;
      }
      break;
    case 0xc61d: /* 50717, WhiteLevel */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_WHITE;
      tiff_ifd[ifd].dng_levels.dng_whitelevel[0] = maximum = getint(type);
      if (tiff_ifd[ifd].samples > 1) // Linear DNG case
        for (i = 1; i < 4 && i < (int)len; i++)
          tiff_ifd[ifd].dng_levels.dng_whitelevel[i] = getint(type);
      break;
    case 0xc61e: /* DefaultScale */
    {
      float q1 = getrealf(type);
      float q2 = getrealf(type);
      if (q1 > 0.00001f && q2 > 0.00001f)
      {
        pixel_aspect = q1 / q2;
        if (pixel_aspect > 0.995 && pixel_aspect < 1.005)
          pixel_aspect = 1.0;
      }
    }
    break;
    case 0xc61f: /* 50719, DefaultCropOrigin */
      if (len == 2)
      {
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_CROPORIGIN;
        tiff_ifd[ifd].dng_levels.default_crop[0] = ushort(getreal(type));
        tiff_ifd[ifd].dng_levels.default_crop[1] = ushort(getreal(type));
        if (!strncasecmp(make, "SONY", 4))
        {
          imgdata.sizes.raw_inset_crops[0].cleft =
              tiff_ifd[ifd].dng_levels.default_crop[0];
          imgdata.sizes.raw_inset_crops[0].ctop =
              tiff_ifd[ifd].dng_levels.default_crop[1];
        }
      }
      break;

    case 0xc620: /* 50720, DefaultCropSize */
      if (len == 2)
      {
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_CROPSIZE;
        tiff_ifd[ifd].dng_levels.default_crop[2] = ushort(getreal(type));
        tiff_ifd[ifd].dng_levels.default_crop[3] = ushort(getreal(type));
        if (!strncasecmp(make, "SONY", 4))
        {
          imgdata.sizes.raw_inset_crops[0].cwidth =
              tiff_ifd[ifd].dng_levels.default_crop[2];
          imgdata.sizes.raw_inset_crops[0].cheight =
              tiff_ifd[ifd].dng_levels.default_crop[3];
        }
      }
      break;

    case 0xc7b5: /* 51125 DefaultUserCrop */
      if (len == 4)
      {
          int cnt = 0;
          FORC4
          {
              float v = getrealf(type);
              if (v >= 0.f && v <= 1.f)
              {
                  tiff_ifd[ifd].dng_levels.user_crop[c] = v;
                  cnt++;
              }
          }
          if(cnt == 4 // valid values
              && tiff_ifd[ifd].dng_levels.user_crop[0] < tiff_ifd[ifd].dng_levels.user_crop[2] // top < bottom
              && tiff_ifd[ifd].dng_levels.user_crop[1] < tiff_ifd[ifd].dng_levels.user_crop[3] // left < right
              )
            tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_USERCROP;
      }
      break;
    case 0x74c7:
      if ((len == 2) && !strncasecmp(make, "SONY", 4))
      {
        imgdata.sizes.raw_inset_crops[0].cleft = get4();
        imgdata.sizes.raw_inset_crops[0].ctop = get4();
      }
      break;

    case 0x74c8:
      if ((len == 2) && !strncasecmp(make, "SONY", 4))
      {
        imgdata.sizes.raw_inset_crops[0].cwidth = get4();
        imgdata.sizes.raw_inset_crops[0].cheight = get4();
      }
      break;

    case 0xc65a: // 50778
      tiff_ifd[ifd].dng_color[0].illuminant = get2();
      tiff_ifd[ifd].dng_color[0].parsedfields |= LIBRAW_DNGFM_ILLUMINANT;
      break;
    case 0xc65b: // 50779
      tiff_ifd[ifd].dng_color[1].illuminant = get2();
      tiff_ifd[ifd].dng_color[1].parsedfields |= LIBRAW_DNGFM_ILLUMINANT;
      break;

    case 0xc621: /* 50721, ColorMatrix1 */
    case 0xc622: /* 50722, ColorMatrix2 */
    {
      int chan = (len == 9) ? 3 : (len == 12 ? 4 : 0);
      i = tag == 0xc621 ? 0 : 1;
      if (chan)
      {
        tiff_ifd[ifd].dng_color[i].parsedfields |= LIBRAW_DNGFM_COLORMATRIX;
        imHassy.nIFD_CM[i] = ifd;
      }
      FORC(chan) for (j = 0; j < 3; j++)
      {
		  cm[c][j] = getreal(type);
		  tiff_ifd[ifd].dng_color[i].colormatrix[c][j] = float(cm[c][j]);
      }
      use_cm = 1;
    }
    break;

    case 0xc714: /* ForwardMatrix1 */
    case 0xc715: /* ForwardMatrix2 */
    {
      int chan = (len == 9) ? 3 : (len == 12 ? 4 : 0);
      i = tag == 0xc714 ? 0 : 1;
      if (chan)
        tiff_ifd[ifd].dng_color[i].parsedfields |= LIBRAW_DNGFM_FORWARDMATRIX;
      for (j = 0; j < 3; j++)
        FORC(chan)
        {
          fm[j][c] = getreal(type);
		  tiff_ifd[ifd].dng_color[i].forwardmatrix[j][c] = float(fm[j][c]);
        }
    }
    break;

    case 0xc623: /* 50723, CameraCalibration1 */
    case 0xc624: /* 50724, CameraCalibration2 */
    {
      int chan = (len == 9) ? 3 : (len == 16 ? 4 : 0);
      j = tag == 0xc623 ? 0 : 1;
      if (chan)
        tiff_ifd[ifd].dng_color[j].parsedfields |= LIBRAW_DNGFM_CALIBRATION;
      for (i = 0; i < chan; i++)
        FORC(chan)
        {         
		  cc[i][c] = getreal(type);
          tiff_ifd[ifd].dng_color[j].calibration[i][c] = float(cc[i][c]);
        }
    }
    break;
    case 0xc627: /* 50727, AnalogBalance */
      if (len >= 3)
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_ANALOGBALANCE;
      for (c = 0; c < (int)len && c < 4; c++)
      {
        ab[c] = getreal(type);
        tiff_ifd[ifd].dng_levels.analogbalance[c] = float(ab[c]);
      }
      break;
    case 0xc628: /* 50728, AsShotNeutral */
      if (len >= 3)
        tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_ASSHOTNEUTRAL;
	  for (c = 0; c < (int)len && c < 4; c++)
	  {
		  asn[c] = getreal(type);
		  tiff_ifd[ifd].dng_levels.asshotneutral[c] = float(asn[c]);
	  }
      break;
    case 0xc629: /* 50729, AsShotWhiteXY */
      xyz[0] = getreal(type);
      xyz[1] = getreal(type);
      xyz[2] = 1 - xyz[0] - xyz[1];
      FORC3 xyz[c] /= LibRaw_constants::d65_white[c];
      break;
    case 0xc62a: /* DNG: 50730 BaselineExposure */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_BASELINEEXPOSURE;
      tiff_ifd[ifd].dng_levels.baseline_exposure = getrealf(type);
      break;
    case 0xc62e: /* DNG: 50734 LinearResponseLimit */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_LINEARRESPONSELIMIT;
      tiff_ifd[ifd].dng_levels.LinearResponseLimit = getrealf(type);
      break;

    case 0xc634: /* 50740 : DNG Adobe, DNG Pentax, Sony SR2, DNG Private */
      {
        char mbuf[64];
        INT64 curr_pos, start_pos = ftell(ifp);
        unsigned MakN_order, m_sorder = order;
        unsigned MakN_length;
        unsigned pos_in_original_raw;
        fread(mbuf, 1, 6, ifp);

        if (!strcmp(mbuf, "Adobe"))
        {
          order = 0x4d4d; // Adobe header is always in "MM" / big endian
          curr_pos = start_pos + 6;
          while (curr_pos + 8 - start_pos <= len)
          {
            fread(mbuf, 1, 4, ifp);
            curr_pos += 8;

            if (!strncmp(mbuf, "Pano", 4))
            { // PanasonicRaw, yes, they use "Pano" as signature
              parseAdobePanoMakernote();
            }

            if (!strncmp(mbuf, "MakN", 4))
            {
              MakN_length = get4();
              MakN_order = get2();
              pos_in_original_raw = get4();
              order = MakN_order;

              INT64 save_pos = ifp->tell();
              parse_makernote_0xc634(curr_pos + 6 - pos_in_original_raw, 0,
                                     AdobeDNG);

              curr_pos = save_pos + MakN_length - 6;
              fseek(ifp, curr_pos, SEEK_SET);

              fread(mbuf, 1, 4, ifp);
              curr_pos += 8;

              if (!strncmp(mbuf, "Pano ", 4))
              {
                parseAdobePanoMakernote();
              }

              if (!strncmp(mbuf, "RAF ", 4))
              { // Fujifilm Raw, AdobeRAF
				  try {
                    parseAdobeRAFMakernote(); // May raise exception for out-of buffer reads
				  }
				  catch (...)
				  {
					  // just ignore it
				  }
              }

              if (!strncmp(mbuf, "SR2 ", 4))
              {
                order = 0x4d4d;
                MakN_length = get4();
                MakN_order = get2();
                pos_in_original_raw = get4();
                order = MakN_order;

                unsigned *buf_SR2;
                unsigned SR2SubIFDOffset = 0;
                unsigned SR2SubIFDLength = 0;
                unsigned SR2SubIFDKey = 0;
                {
                  INT64 _base = curr_pos + 6 - pos_in_original_raw;
                  unsigned _entries, _tag, _type, _len;
				  INT64 _save;
				  _entries = get2();
                  while (_entries--)
                  {
                    tiff_get(_base, &_tag, &_type, &_len, &_save);
                    if (callbacks.exif_cb)
                    {
                      INT64 _savepos = ftell(ifp);
                      callbacks.exif_cb(callbacks.exifparser_data, tag | 0x60000,
                                        _type, _len, order, ifp, base);
                      fseek(ifp, _savepos, SEEK_SET);
                    }

                    if (_tag == 0x7200)
                    {
                      SR2SubIFDOffset = get4();
                    }
                    else if (_tag == 0x7201)
                    {
                      SR2SubIFDLength = get4();
                    }
                    else if (_tag == 0x7221)
                    {
                      SR2SubIFDKey = get4();
                    }
                    fseek(ifp, _save, SEEK_SET);
                  }
                }

                if (SR2SubIFDLength && (SR2SubIFDLength < 10240000) &&
                    (buf_SR2 = (unsigned *)calloc(SR2SubIFDLength + 1024,1)))
                { // 1024b for safety
                  fseek(ifp, SR2SubIFDOffset + base, SEEK_SET);
                  int items = fread(buf_SR2, 1, SR2SubIFDLength, ifp);
				  if (items == SR2SubIFDLength)
				  {
					  sony_decrypt(buf_SR2, SR2SubIFDLength / 4, 1, SR2SubIFDKey);
					  parseSonySR2((uchar *)buf_SR2, SR2SubIFDOffset,
						  SR2SubIFDLength, AdobeDNG);
				  }
                  free(buf_SR2);
                }

              } /* SR2 processed */
              break;
            }
          }
        }
        else
        {
          fread(mbuf + 6, 1, 2, ifp);
          if (!strcmp(mbuf, "RICOH") && ((sget2((uchar *)mbuf + 6) == 0x4949) ||
                                         (sget2((uchar *)mbuf + 6) == 0x4d4d)))
          {
            is_PentaxRicohMakernotes = 1;
          }
          if (!strcmp(mbuf, "PENTAX ") || !strcmp(mbuf, "SAMSUNG") ||
              is_PentaxRicohMakernotes)
          {
            fseek(ifp, start_pos, SEEK_SET);
            parse_makernote_0xc634(base, 0, CameraDNG);
          }
        }
        fseek(ifp, start_pos, SEEK_SET);
        order = m_sorder;
      }
      if (dng_version)
      {
        break;
      }

	  {
		  INT64 jj = get4() + base;
		  parse_minolta(jj);
		  fseek(ifp, jj, SEEK_SET);
	  }
      parse_tiff_ifd(base);
      break;
    case 0xc640: // 50752
      read_shorts(cr2_slice, 3);
      break;
    case 0xc68b: /* 50827, OriginalRawFileName */
      stmread(imgdata.color.OriginalRawFileName, len, ifp);
      break;
    case 0xc68d: /* 50829 ActiveArea */
      tiff_ifd[ifd].t_tm = top_margin = getint(type);
      tiff_ifd[ifd].t_lm = left_margin = getint(type);
      tiff_ifd[ifd].t_vheight = height = getint(type) - top_margin;
      tiff_ifd[ifd].t_vwidth = width = getint(type) - left_margin;
      break;
    case 0xc68e: /* 50830 MaskedAreas */
      for (i = 0; i < (int)len && i < 32; i++)
        ((int *)mask)[i] = getint(type);
      black = 0;
      break;
    case 0xc71a: /* 50970, PreviewColorSpace */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_PREVIEWCS;
      tiff_ifd[ifd].dng_levels.preview_colorspace = getint(type);
      break;
    case 0xc740: /* 51008, OpcodeList1 */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_OPCODE1;
	  if (len < 4 * 1024 * 1024) // 4M per opcode list limit
	  {
		  tiff_ifd[ifd].dng_levels.rawopcodes[0].len = len;
		  tiff_ifd[ifd].dng_levels.rawopcodes[0].data = calloc(len,1);
		  fread(tiff_ifd[ifd].dng_levels.rawopcodes[0].data, 1, len, ifp);
	  }
      break;
    case 0xc741: /* 51009, OpcodeList2 */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_OPCODE2;
      tiff_ifd[ifd].opcode2_offset = meta_offset = ftell(ifp);
      if (len < 4 * 1024 * 1024) // 4M per opcode list limit
      {
        tiff_ifd[ifd].dng_levels.rawopcodes[1].len = len;
        tiff_ifd[ifd].dng_levels.rawopcodes[1].data = calloc(len,1);
        fread(tiff_ifd[ifd].dng_levels.rawopcodes[1].data, 1, len, ifp);
      }
      break;
    case 0xc74e: /* 51022, OpcodeList3 */
      tiff_ifd[ifd].dng_levels.parsedfields |= LIBRAW_DNGFM_OPCODE3;
      if (len < 4 * 1024 * 1024) // 4M per opcode list limit
      {
        tiff_ifd[ifd].dng_levels.rawopcodes[2].len = len;
        tiff_ifd[ifd].dng_levels.rawopcodes[2].data = calloc(len,1);
        fread(tiff_ifd[ifd].dng_levels.rawopcodes[2].data, 1, len, ifp);
      }
      break;
    case 0xfd04: /* 64772, Kodak P-series */
      if (len < 13)
        break;
      fseek(ifp, 16, SEEK_CUR);
      data_offset = get4();
      fseek(ifp, 28, SEEK_CUR);
      data_offset += get4();
      load_raw = &LibRaw::packed_load_raw;
      break;
    case 0xfe02: // 65026
      if (tagtypeIs(LIBRAW_EXIFTAG_TYPE_ASCII))
        fgets(model2, 64, ifp);
    }
    fseek(ifp, save, SEEK_SET);
  }
  if (sony_length && sony_length < 10240000 &&
      (buf = (unsigned *)calloc(sony_length, 1)))
  {
    fseek(ifp, sony_offset, SEEK_SET);
    int items = fread(buf, 1, sony_length, ifp);
	if (items == sony_length)
	{
		sony_decrypt(buf, sony_length / 4, 1, sony_key);
		parseSonySR2((uchar *)buf, sony_offset, sony_length, nonDNG);
	}
    free(buf);
  }
  for (i = 0; i < colors && i < 4; i++)
    FORCC cc[i][c] *= ab[i];
  if (use_cm)
  {
    FORCC for (i = 0; i < 3; i++) for (cam_xyz[c][i] = j = 0; j < colors; j++)
        cam_xyz[c][i] += cc[c][j] * cm[j][i] * xyz[i];
    cam_xyz_coeff(cmatrix, cam_xyz);
  }
  if (asn[0])
  {
    cam_mul[3] = 0;
    FORCC
    if (fabs(asn[c]) > 0.0001)
      cam_mul[c] = float(1. / asn[c]);
  }
  if (!use_cm)
    FORCC if (fabs(cc[c][c]) > 0.0001) pre_mul[c] /= float(cc[c][c]);
  return 0;
}

int LibRaw::parse_tiff(INT64 _base)
{
  INT64 base = _base;
  int doff;
  fseek(ifp, base, SEEK_SET);
  order = get2();
  if (order != 0x4949 && order != 0x4d4d)
    return 0;
  get2();
  while ((doff = get4()))
  {
	INT64 doff64 = doff;
	if (doff64 + base > ifp->size()) break;
    fseek(ifp, doff64 + base, SEEK_SET);
    if (parse_tiff_ifd(_base))
      break;
  }
  return 1;
}

struct ifd_size_t
{
  int ifdi;
  INT64 databits;
};

int ifd_size_t_cmp(const void *a, const void *b)
{
  if (!a || !b)
    return 0;
  const ifd_size_t *ai = (ifd_size_t *)a;
  const ifd_size_t *bi = (ifd_size_t *)b;
  return bi->databits > ai->databits ? 1
                                     : (bi->databits < ai->databits ? -1 : 0);
}

static LibRaw_internal_thumbnail_formats tiff2thumbformat(int _comp, int _phint, int _bps, const char *_make, bool isDNG);

void LibRaw::apply_tiff()
{
  int max_samp = 0, ties = 0, raw = -1, thm = -1, i;
  unsigned long long ns, os;
  struct jhead jh;

  thumb_misc = 16;
  if (thumb_offset)
  {
    fseek(ifp, thumb_offset, SEEK_SET);
    if (ljpeg_start(&jh, 1))
    {
      if ((unsigned)jh.bits < 17 && (unsigned)jh.wide < 0x10000 &&
          (unsigned)jh.high < 0x10000)
      {
        thumb_misc = jh.bits;
        thumb_width = jh.wide;
        thumb_height = jh.high;
      }
    }
  }
  for (i = tiff_nifds; i--;)
  {
    if (tiff_ifd[i].t_shutter)
      shutter = tiff_ifd[i].t_shutter;
    tiff_ifd[i].t_shutter = shutter;
  }

  if (dng_version)
  {
    int ifdc = 0;
    for (i = 0; i < (int)tiff_nifds; i++)
    {
      if (tiff_ifd[i].t_width < 1 || tiff_ifd[i].t_width > 65535 ||
          tiff_ifd[i].t_height < 1 || tiff_ifd[i].t_height > 65535)
        continue; /* wrong image dimensions */

      int samp = tiff_ifd[i].samples;
      if (samp == 2)
        samp = 1; // Fuji 2-frame
      max_samp = LIM(MAX(max_samp, samp), 1,
                     3); // max_samp is needed for thumbnail selection below

     if ( // Check phint only for RAW subfiletype
         (tiff_ifd[i].newsubfiletype == 16
             || tiff_ifd[i].newsubfiletype == 0
             || (tiff_ifd[i].newsubfiletype & 0xffff) == 1)
         &&
          (tiff_ifd[i].phint != 32803 && tiff_ifd[i].phint != 34892)
         )
              continue;

      if ((tiff_ifd[i].newsubfiletype == 0) // main image
                                            // Enhanced demosaiced:
          || (tiff_ifd[i].newsubfiletype == 16 &&
              (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_ADD_ENHANCED))
          // Preview: 0x1 or 0x10001
          || ((tiff_ifd[i].newsubfiletype & 0xffff) == 1 &&
              (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_ADD_PREVIEWS))
        // Transparency mask: 0x4
          || ((tiff_ifd[i].newsubfiletype & 0xffff) == 4 &&
          (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_ADD_MASKS)))
      {
        // Add this IFD to dng_frames
        libraw_internal_data.unpacker_data.dng_frames[ifdc] =
            ((tiff_ifd[i].newsubfiletype & 0xffff) << 16) | ((i << 8) & 0xff00);
        ifdc++;
        // Fuji SuperCCD: second frame:
        if ((tiff_ifd[i].newsubfiletype == 0) && tiff_ifd[i].samples == 2)
        {
          libraw_internal_data.unpacker_data.dng_frames[ifdc] =
              ((tiff_ifd[i].newsubfiletype & 0xffff) << 16) |
              ((i << 8) & 0xff00) | 1;
          ifdc++;
        }
      }
    }
    if (ifdc)
    {
      if (ifdc > 1 && (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_PREFER_LARGEST_IMAGE))
      {
        ifd_size_t arr[LIBRAW_IFD_MAXCOUNT * 2];
        memset(arr, 0, sizeof(arr));
        for (int q = 0; q < ifdc && q < LIBRAW_IFD_MAXCOUNT * 2; q++)
        {
          int ifdidx =
              (libraw_internal_data.unpacker_data.dng_frames[q] >> 8) & 0xff;
          arr[q].ifdi = libraw_internal_data.unpacker_data.dng_frames[q];
          arr[q].databits =
              INT64(tiff_ifd[ifdidx].t_width) * INT64(tiff_ifd[ifdidx].t_height) *
                  INT64(tiff_ifd[ifdidx].samples) * INT64(tiff_ifd[ifdidx].bps) +
              INT64(0x100 -
               (arr[q].ifdi & 0xff)); // add inverted frame # to ensure same
                                      // sort order for similar sized frames.
          if (tiff_ifd[ifdidx].phint == 4)
              arr[q].databits /= 4; // Force lower bit count for Transp. mask images
        }
        qsort(arr, MIN(ifdc, LIBRAW_IFD_MAXCOUNT * 2), sizeof(arr[0]),
              ifd_size_t_cmp);
        for (int q = 0; q < ifdc && q < LIBRAW_IFD_MAXCOUNT * 2; q++)
          libraw_internal_data.unpacker_data.dng_frames[q] = arr[q].ifdi;
      }

      int idx = LIM((int)shot_select, 0, ifdc - 1);
      i = (libraw_internal_data.unpacker_data.dng_frames[idx] >> 8) &
          0xff; // extract frame# back

      raw_width = tiff_ifd[i].t_width;
      raw_height = tiff_ifd[i].t_height;
      tiff_bps = tiff_ifd[i].bps;
      tiff_compress = tiff_ifd[i].comp;
      tiff_sampleformat = tiff_ifd[i].sample_format;
      data_offset = tiff_ifd[i].offset;
      data_size = tiff_ifd[i].bytes;
      tiff_flip = tiff_ifd[i].t_flip;
      tiff_samples = tiff_ifd[i].samples;
      tile_width = tiff_ifd[i].t_tile_width;
      tile_length = tiff_ifd[i].t_tile_length;
      fuji_width = tiff_ifd[i].t_fuji_width;
      if (tiff_samples != 2) /* special case: Fuji SuperCCD */
      {
        if (tiff_ifd[i].phint == 34892)
          filters = 0;
        else if (i > 0 && tiff_ifd[i].phint == 32803 &&
                 tiff_ifd[0].phint == 32803 && !tiff_ifd[i].t_filters &&
                 tiff_ifd[0].t_filters)
          filters = tiff_ifd[0].t_filters;
        else
          filters = tiff_ifd[i].t_filters;
        width = tiff_ifd[i].t_vwidth;
        height = tiff_ifd[i].t_vheight;
        top_margin = tiff_ifd[i].t_tm;
        left_margin = tiff_ifd[i].t_lm;
        shutter = tiff_ifd[i].t_shutter;
        if (tiff_ifd[i].dng_levels.dng_whitelevel[0])
          maximum = tiff_ifd[i].dng_levels.dng_whitelevel[0];
        else if (tiff_ifd[i].sample_format <= 2 && tiff_bps > 0 &&
                 tiff_bps < 32) // SampleFormat: 0-default(1), 1 - Uint, 2 - Int
          maximum = (1 << tiff_bps) - 1;
        else if (tiff_ifd[i].sample_format == 3)
          maximum = 1; // Defaults for FP
      }
      raw = i;
      is_raw = ifdc;
    }
    else
      is_raw = 0;
  }
  else
  {
    // Fix for broken Sony bps tag
    if (!strncasecmp(make, "Sony", 4))
    {
        for (i = 0; i < (int)tiff_nifds; i++)
        {
            if (tiff_ifd[i].bps > 33 && tiff_ifd[i].samples == 1)
            {
                int bps = 14; // default
                if (tiff_ifd[i].dng_levels.dng_whitelevel[0] > 0)
                {
                    for(int c = 0,j=1; c < 16; c++, j<<=1)
                        if (j > (int)tiff_ifd[i].dng_levels.dng_whitelevel[0])
                        {
                            bps = c; break;
                        }
                }
                tiff_ifd[i].bps = bps;
            }
        }
    }

    for (i = 0; i < (int)tiff_nifds; i++)
    {
      if (tiff_ifd[i].t_width < 1 || tiff_ifd[i].t_width > 65535 ||
          tiff_ifd[i].t_height < 1 || tiff_ifd[i].t_height > 65535)
        continue; /* wrong image dimensions */
      if (max_samp < tiff_ifd[i].samples)
        max_samp = tiff_ifd[i].samples;
      if (max_samp > 3)
        max_samp = 3;

      os = unsigned(raw_width) * unsigned(raw_height);
      ns = unsigned(tiff_ifd[i].t_width) * unsigned(tiff_ifd[i].t_height);
      if (tiff_bps)
      {
        os *= tiff_bps;
        ns *= tiff_ifd[i].bps;
      }
      /* too complex if below, so separate if to skip RGB+Alpha TIFFs*/
      if (tiff_ifd[i].phint == 2 && tiff_ifd[i].extrasamples > 0 && tiff_ifd[i].samples > 3)
          continue; // SKIP RGB+Alpha IFDs

	  if (!strncasecmp(make, "Sony", 4) && tiff_ifd[i].bps == 8 && tiff_ifd[i].phint == 6 && tiff_ifd[i].comp == 7 &&
          tiff_ifd[i].samples == 3 && tiff_ifd[i].newsubfiletype == 1)
        continue; // Sony RGB preview

      if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3 ||
		  (tiff_ifd[i].comp == 6 && tiff_ifd[i].samples == 3 && !strncasecmp(make, "Sony", 4) && tiff_ifd[i].bps >=12)
		  ) &&
            unsigned(tiff_ifd[i].t_width | tiff_ifd[i].t_height) < 0x10000 &&
            (unsigned)tiff_ifd[i].bps < 33 &&
            (unsigned)tiff_ifd[i].samples < 13 && ns &&
            ((ns > os && (ties = 1)) || (ns == os && (int)shot_select == ties++)))
      {
        raw_width = tiff_ifd[i].t_width;
        raw_height = tiff_ifd[i].t_height;
        tiff_bps = tiff_ifd[i].bps;
        tiff_compress = tiff_ifd[i].comp;
        tiff_sampleformat = tiff_ifd[i].sample_format;
        data_offset = tiff_ifd[i].offset;
        data_size = tiff_ifd[i].bytes;
        tiff_flip = tiff_ifd[i].t_flip;
        tiff_samples = tiff_ifd[i].samples;
        tile_width = tiff_ifd[i].t_tile_width;
        tile_length = tiff_ifd[i].t_tile_length;
        shutter = tiff_ifd[i].t_shutter;
        raw = i;
      }
    }
    if (is_raw == 1 && ties)
      is_raw = ties;
  }
  if (is_NikonTransfer && raw >= 0)
  {
    if (tiff_ifd[raw].bps == 16)
    {
      if (tiff_compress == 1)
      {
        if ((INT64(raw_width) * INT64(raw_height) * 3LL) == (tiff_ifd[raw].bytes << 1))
        {
          tiff_bps = tiff_ifd[raw].bps = 12;
        }
        else
        {
          tiff_bps = tiff_ifd[raw].bps = 14;
        }
      }
    }
    else if (tiff_ifd[raw].bps == 8)
    {
      if (tiff_compress == 1)
      {
        is_NikonTransfer = 2; // 8-bit debayered TIFF, like CoolScan NEFs
        imgdata.rawparams.coolscan_nef_gamma = 2.2f;
      }
    }
  }

  if (!tile_width)
    tile_width = INT_MAX;
  if (!tile_length)
    tile_length = INT_MAX;
  for (i = tiff_nifds; i--;)
    if (tiff_ifd[i].t_flip)
      tiff_flip = tiff_ifd[i].t_flip;

#if 0
  if (raw < 0 && is_raw)
      is_raw = 0;
#endif

  if (raw >= 0 && !load_raw)
    switch (tiff_compress)
    {
    case 32767:
      if (!dng_version &&
          tiff_ifd[raw].bytes == INT64(raw_width) * INT64(raw_height))
      {
        tiff_bps = 14;
        load_raw = &LibRaw::sony_arw2_load_raw;
        break;
      }
      if (!dng_version && !strncasecmp(make, "Sony", 4) &&
          tiff_ifd[raw].bytes == INT64(raw_width) * INT64(raw_height) * 2LL)
      {
        tiff_bps = 14;
        load_raw = &LibRaw::unpacked_load_raw;
        break;
      }
      if (tiff_ifd[raw].bytes * 8LL !=
          INT64(raw_width) * INT64(raw_height) * INT64(tiff_bps))
      {
        raw_height += 8;
        load_raw = &LibRaw::sony_arw_load_raw;
        break;
      }
      load_flags = 79;
    case 32769:
      load_flags++;
    case 32770:
    case 32773:
      goto slr;
    case 0:
    case 1:
        if (dng_version && tiff_sampleformat == 3 &&
          (tiff_bps > 8 && (tiff_bps % 8 == 0) && (tiff_bps <= 32))) // only 16,24, and 32 are allowed
        {
            load_raw = &LibRaw::uncompressed_fp_dng_load_raw;
            break;
        }
      // Sony 14-bit uncompressed
        if (!dng_version && !strncasecmp(make, "Sony", 4) &&
            tiff_ifd[raw].bytes == INT64(raw_width) * INT64(raw_height) * 2LL)
      {
        tiff_bps = 14;
        load_raw = &LibRaw::unpacked_load_raw;
        break;
      }
      if (!dng_version && !strncasecmp(make, "Sony", 4) && tiff_ifd[raw].samples == 4 &&
          tiff_ifd[raw].bytes == INT64(raw_width) * INT64(raw_height) * 8LL) // Sony ARQ
      {
        // maybe to detect ARQ with the following:
        // if (tiff_ifd[raw].phint == 32892)
        tiff_bps = 14;
        tiff_samples = 4;
        load_raw = &LibRaw::sony_arq_load_raw;
        filters = 0;
        strcpy(cdesc, "RGBG");
        break;
      }
      if (!strncasecmp(make, "Nikon", 5) &&
          (!strncmp(software, "Nikon Scan", 10) || (is_NikonTransfer == 2) ||
           strcasestr(model, "COOLSCAN")))
      {
        load_raw = &LibRaw::nikon_coolscan_load_raw;
        raw_color = 1;
        colors = (tiff_samples == 3) ? 3 : 1;
        filters = 0;
        break;
      }
      if ((!strncmp(make, "OLYMPUS", 7) || !strncmp(make, "OM Digi", 7) ||
           (!strncasecmp(make, "CLAUSS", 6) && !strncasecmp(model, "piX 5oo", 7))) && // 0x5330303539 works here
          (tiff_ifd[raw].bytes * 2LL == INT64(raw_width) * INT64(raw_height) * 3LL))
        load_flags = 24;
      if (!dng_version && tiff_ifd[raw].bytes * 5LL == INT64(raw_width) * INT64(raw_height) * 8LL)
      {
        load_flags = 81;
        tiff_bps = 12;
      }
    slr:
      switch (tiff_bps)
      {
      case 8:
        load_raw = &LibRaw::eight_bit_load_raw;
        break;
      case 12:
        if (tiff_ifd[raw].phint == 2)
          load_flags = 6;
        if (!strncasecmp(make, "NIKON", 5) &&
            !strncasecmp(model, "COOLPIX A1000", 13) &&
            data_size == raw_width * raw_height * 2u)
          load_raw = &LibRaw::unpacked_load_raw;
        else
          load_raw = &LibRaw::packed_load_raw;
        break;
      case 14:
        load_flags = 0;
      case 16:
        load_raw = &LibRaw::unpacked_load_raw;
		if ((!strncmp(make, "OLYMPUS", 7) || !strncmp(make, "OM Digi", 7) ||
			(!strncasecmp(make, "CLAUSS", 6) && !strncasecmp(model, "piX 5oo", 7))) && // 0x5330303539 works here
			(tiff_ifd[raw].bytes * 7LL > INT64(raw_width) * INT64(raw_height)))
		{
				load_raw = &LibRaw::olympus_load_raw;
		}
      }
      break;
    case 6:
    case 7:
    case 99:
		if (!dng_version && tiff_compress == 6 && !strcasecmp(make, "SONY"))
		{
			if (tiff_ifd[raw].phint == 6 && tiff_ifd[raw].bps >= 12 && tiff_ifd[raw].samples == 3)
			{
				load_raw = &LibRaw::sony_ycbcr_load_raw;
				filters = 0;
				colors = 3;
			}
			else
				load_raw = &LibRaw::sony_ljpeg_load_raw;
	    }
		// Allow A1/Compression=7
		else if(!dng_version && tiff_compress == 7 && !strcasecmp(make, "SONY") &&
			(!strcasecmp(model,"ILCE-1") || !strncasecmp(model, "ILCE-7",6)
				|| !strncasecmp(model, "ILCE-9", 6) // Most likely ILCE-9 will use tiff_compr=7 this w/ updated FW
				) &&
			tiff_bps == 14 && tiff_samples == 1)
          load_raw = &LibRaw::sony_ljpeg_load_raw;
        else
        load_raw = &LibRaw::lossless_jpeg_load_raw;
      break;
    case 262:
      load_raw = &LibRaw::kodak_262_load_raw;
      break;
    case 34713:
      if ((INT64(raw_width) + 9LL) / 10LL * 16LL * INT64(raw_height) == tiff_ifd[raw].bytes)
      {
        load_raw = &LibRaw::packed_load_raw;
        load_flags = 1;
      }
      else if (INT64(raw_width) * INT64(raw_height) * 3LL == tiff_ifd[raw].bytes * 2LL)
      {
        load_raw = &LibRaw::packed_load_raw;
        if (model[0] == 'N')
          load_flags = 80;
      }
      else if (INT64(raw_width) * INT64(raw_height) * 3LL == tiff_ifd[raw].bytes)
      {
        load_raw = &LibRaw::nikon_yuv_load_raw;
        gamma_curve(1 / 2.4, 12.92, 1, 4095);
        memset(cblack, 0, sizeof cblack);
        filters = 0;
      }
      else if (INT64(raw_width) * INT64(raw_height) * 2LL == tiff_ifd[raw].bytes)
      {
        load_raw = &LibRaw::unpacked_load_raw;
        load_flags = 4;
        order = 0x4d4d;
      }
#if 0 /* Never used because of same condition above, but need to recheck */
      else if (INT64(raw_width) * INT64(raw_height) * 3LL ==
               INT64(tiff_ifd[raw].bytes) * 2LL)
      {
        load_raw = &LibRaw::packed_load_raw;
        load_flags = 80;
      }
#endif
      else if (tiff_ifd[raw].rows_per_strip &&
               tiff_ifd[raw].strip_offsets_count &&
               tiff_ifd[raw].strip_offsets_count ==
                   tiff_ifd[raw].strip_byte_counts_count)
      {
        int fit = 1;
        for (int q = 0; q < tiff_ifd[raw].strip_byte_counts_count - 1;
             q++) // all but last
          if (INT64(tiff_ifd[raw].strip_byte_counts[q]) * 2LL !=
              INT64(tiff_ifd[raw].rows_per_strip) * INT64(raw_width) * 3LL)
          {
            fit = 0;
            break;
          }
        if (fit)
          load_raw = &LibRaw::nikon_load_striped_packed_raw;
        else
          load_raw = &LibRaw::nikon_load_raw; // fallback
      }
      else if ((((INT64(raw_width) * 3LL / 2LL) + 15LL) / 16LL) * 16LL * INT64(raw_height) == tiff_ifd[raw].bytes)
      {
        load_raw = &LibRaw::nikon_load_padded_packed_raw;
      }
      else if ((!strncmp(model, "NIKON Z 9", 9) || !strncmp(model, "NIKON Z 8", 9) || !strcmp(model, "NIKON Z f")
		  || !strcmp(model, "NIKON Z6_3")) &&
               tiff_ifd[raw].offset)
      {
          INT64 pos = ftell(ifp);
          unsigned char cmp[] = {0xff, 0x10, 0xff, 0x50 }; // JpegXS SOC + Cap
          unsigned char buf[4];
          fseek(ifp, INT64(tiff_ifd[raw].offset), SEEK_SET);
          fread(buf, 1, 4, ifp);
          fseek(ifp, pos, SEEK_SET);
          if(!memcmp(buf,cmp,4))
            load_raw = &LibRaw::nikon_he_load_raw;
          else
            load_raw = &LibRaw::nikon_load_raw;
      }
      else
        load_raw = &LibRaw::nikon_load_raw;
      break;
    case 65535:
      load_raw = &LibRaw::pentax_load_raw;
      break;
    case 65000:
      switch (tiff_ifd[raw].phint)
      {
      case 2:
        load_raw = &LibRaw::kodak_rgb_load_raw;
        filters = 0;
        break;
      case 6:
        load_raw = &LibRaw::kodak_ycbcr_load_raw;
        filters = 0;
        break;
      case 32803:
        load_raw = &LibRaw::kodak_65000_load_raw;
      }
    case 32867:
    case 34892:
      break;
    case 8:
      break;
    case 52546:
      if (dng_version) /* DNG 1.7 JPEG XL: if not compiled w/ DNG SDK decoder will return NOT SUPPORTED*/
        break;
	  // else: fallthrough
    case 9:
      if (dng_version)
        break; /* Compression=9 supported for dng if we compiled with GPR SDK; if NO SDK: decoder will return NOT Supported */
	  // else: fallthrough
    default:
      is_raw = 0;
    }
  if (!dng_version)
  {
      if (((tiff_samples == 3 && tiff_ifd[raw].bytes &&
          !(tiff_bps == 16 &&
              !strncmp(make, "Leaf", 4)) && // Allow Leaf/16bit/3color files
		  !(tiff_ifd[raw].comp == 6 && tiff_ifd[raw].phint == 6 && tiff_bps >= 12 && !strncasecmp(make,"Sony",4)) && // Sony YCbCr
          tiff_bps != 14 &&
          (tiff_compress & -16) != 32768) ||
          (tiff_bps == 8 && strncmp(make, "Phase", 5) &&
              strncmp(make, "Leaf", 4) && !strcasestr(make, "Kodak") &&
              !strstr(model2, "DEBUG RAW"))) &&
          !strcasestr(model, "COOLSCAN") && strncmp(software, "Nikon Scan", 10) &&
          is_NikonTransfer != 2)
          is_raw = 0;

      if (is_raw && raw >= 0 && tiff_ifd[raw].phint == 2 && tiff_ifd[raw].extrasamples > 0 && tiff_ifd[raw].samples > 3)
          is_raw = 0; // SKIP RGB+Alpha IFDs
  }

  INT64 fsizecheck = 0ULL;

  if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CHECK_THUMBNAILS_ALL_VENDORS)
      fsizecheck = ifp->size();
  else if ((imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CHECK_THUMBNAILS_KNOWN_VENDORS) &&
           (!strncasecmp(make, "Ricoh", 5) || (dng_version && !strncasecmp(make, "Samsung", 7))))
      fsizecheck = ifp->size();

  for (i = 0; i < (int)tiff_nifds; i++)
    if (i != raw &&
        (tiff_ifd[i].samples == max_samp ||
         (tiff_ifd[i].comp == 7 &&
          tiff_ifd[i].samples == 1)) /* Allow 1-bps JPEGs */
        && tiff_ifd[i].bps > 0 && tiff_ifd[i].bps < 33 &&
        tiff_ifd[i].phint != 32803 && tiff_ifd[i].phint != 34892 &&
		(tiff_ifd[i].comp != 52546 || (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_ALLOW_JPEGXL_PREVIEWS)) &&
        unsigned(tiff_ifd[i].t_width | tiff_ifd[i].t_height) < 0x10000 &&
        tiff_ifd[i].comp != 34892)
    {
        if (fsizecheck > 0LL)
        {
            bool ok = true;
            if (tiff_ifd[i].strip_byte_counts_count && tiff_ifd[i].strip_offsets_count)
                for (int s = 0; s < MIN(tiff_ifd[i].strip_byte_counts_count, tiff_ifd[i].strip_offsets_count); s++)
                {
                    if (tiff_ifd[i].strip_offsets[s] + tiff_ifd[i].strip_byte_counts[s] > fsizecheck)
                    {
                        ok = false;
                        break;
                    }
                }
            else if (tiff_ifd[i].bytes > 0)
                if (tiff_ifd[i].offset + tiff_ifd[i].bytes > fsizecheck)
                    ok = false;

            if(!ok)
                continue;
        }
		if ( (INT64(tiff_ifd[i].t_width) * INT64(tiff_ifd[i].t_height) / INT64(SQR(tiff_ifd[i].bps) + 1)) >
			 (INT64(thumb_width) * INT64(thumb_height) / INT64(SQR(thumb_misc) + 1)) ) 
		{

			thumb_width = tiff_ifd[i].t_width;
			thumb_height = tiff_ifd[i].t_height;
			thumb_offset = tiff_ifd[i].offset;
			thumb_length = unsigned(tiff_ifd[i].bytes); // do we expect >4GB thumbnail?
			thumb_misc = tiff_ifd[i].bps;
			thm = i;
		}
		if (imgdata.thumbs_list.thumbcount < LIBRAW_THUMBNAIL_MAXCOUNT && tiff_ifd[i].bytes > 0)
		{
			bool already = false;
			for(int idx = 0; idx < imgdata.thumbs_list.thumbcount ; idx++)
				if (imgdata.thumbs_list.thumblist[idx].toffset == tiff_ifd[i].offset)
				{
					already = true;
					break;
				}
			if (!already)
			{
				int idx = imgdata.thumbs_list.thumbcount;
				imgdata.thumbs_list.thumblist[idx].tformat = tiff2thumbformat(tiff_ifd[i].comp, tiff_ifd[i].phint,
					tiff_ifd[i].bps, make, dng_version);
				imgdata.thumbs_list.thumblist[idx].twidth = tiff_ifd[i].t_width;
				imgdata.thumbs_list.thumblist[idx].theight = tiff_ifd[i].t_height;
				imgdata.thumbs_list.thumblist[idx].tflip = tiff_ifd[i].t_flip;
				imgdata.thumbs_list.thumblist[idx].tlength = unsigned(tiff_ifd[i].bytes);
				imgdata.thumbs_list.thumblist[idx].tmisc = tiff_ifd[i].bps | (tiff_ifd[i].samples << 5);
				imgdata.thumbs_list.thumblist[idx].toffset = tiff_ifd[i].offset;
				imgdata.thumbs_list.thumbcount++;
			}
		}
    }
  if (thm >= 0)
  {
    thumb_misc |= tiff_ifd[thm].samples << 5;
	thumb_format = tiff2thumbformat(tiff_ifd[thm].comp, tiff_ifd[thm].phint, tiff_ifd[thm].bps, make, dng_version);
  }
}

static LibRaw_internal_thumbnail_formats tiff2thumbformat(int _comp, int _phint, int _bps, const char *_make, bool isDNG)
{
  switch (_comp)
  {
  case 0:
    return LIBRAW_INTERNAL_THUMBNAIL_LAYER;
  case 1:
	  if (_bps <= 8)
		  return LIBRAW_INTERNAL_THUMBNAIL_PPM;
	  else if (!strncmp(_make, "Imacon", 6))
		  return LIBRAW_INTERNAL_THUMBNAIL_PPM16;
	  else if (isDNG &&  _phint == 6 && _bps == 12)
		  return LIBRAW_INTERNAL_THUMBNAIL_DNG_YCBCR;
    else
      return LIBRAW_INTERNAL_THUMBNAIL_KODAK_THUMB;
  case 52546:
	  return LIBRAW_INTERNAL_THUMBNAIL_JPEGXL;
  case 65000:
    return _phint == 6 ? LIBRAW_INTERNAL_THUMBNAIL_KODAK_YCBCR : LIBRAW_INTERNAL_THUMBNAIL_KODAK_RGB;
  }
  return LIBRAW_INTERNAL_THUMBNAIL_JPEG; // default
}