/* -*- 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 "../../internal/dcraw_defs.h"

#include "../../internal/libraw_cameraids.h"

unsigned LibRaw::getbithuff(int nbits, ushort *huff)

{

#ifdef LIBRAW_NOTHREADS

  static unsigned bitbuf = 0;

  static int vbits = 0, reset = 0;

#else

#define bitbuf tls->getbits.bitbuf

#define vbits tls->getbits.vbits

#define reset tls->getbits.reset

#endif

  unsigned c;

  if (nbits > 25)

    return 0;

  if (nbits < 0)

    return bitbuf = vbits = reset = 0;

  if (nbits == 0 || vbits < 0)

    return 0;

  while (!reset && vbits < nbits && (c = fgetc(ifp)) != (unsigned)EOF &&

         !(reset = zero_after_ff && c == 0xff && fgetc(ifp)))

  {

    bitbuf = (bitbuf << 8) + (uchar)c;

    vbits += 8;

  }

  c = vbits == 0 ? 0 : bitbuf << (32 - vbits) >> (32 - nbits);

  if (huff)

  {

    vbits -= huff[c] >> 8;

    c = (uchar)huff[c];

  }

  else

    vbits -= nbits;

  if (vbits < 0)

    derror();

  return c;

#ifndef LIBRAW_NOTHREADS

#undef bitbuf

#undef vbits

#undef reset

#endif

}

/*

   Construct a decode tree according the specification in *source.

   The first 16 bytes specify how many codes should be 1-bit, 2-bit

   3-bit, etc.  Bytes after that are the leaf values.

   For example, if the source is

    { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,

      0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff  },

   then the code is

        00    0x04

        010   0x03

        011   0x05

        100   0x06

        101   0x02

        1100    0x07

        1101    0x01

        11100   0x08

        11101   0x09

        11110   0x00

        111110    0x0a

        1111110   0x0b

        1111111   0xff

 */

ushort *LibRaw::make_decoder_ref(const uchar **source)

{

  int max, len, h, i, j;

  const uchar *count;

  ushort *huff;

  count = (*source += 16) - 17;

  for (max = 16; max && !count[max]; max--)

    ;

  huff = (ushort *)calloc(1 + (1 << max), sizeof *huff);

  huff[0] = max;

  for (h = len = 1; len <= max; len++)

    for (i = 0; i < count[len]; i++, ++*source)

      for (j = 0; j < 1 << (max - len); j++)

        if (h <= 1 << max)

          huff[h++] = len << 8 | **source;

  return huff;

}

ushort *LibRaw::make_decoder(const uchar *source)

{

  return make_decoder_ref(&source);

}

void LibRaw::crw_init_tables(unsigned table, ushort *huff[2])

{

  static const uchar first_tree[3][29] = {

      {0,    1,    4,    2,    3,    1,    2,    0,    0,    0,

       0,    0,    0,    0,    0,    0,    0x04, 0x03, 0x05, 0x06,

       0x02, 0x07, 0x01, 0x08, 0x09, 0x00, 0x0a, 0x0b, 0xff},

      {0,    2,    2,    3,    1,    1,    1,    1,    2,    0,

       0,    0,    0,    0,    0,    0,    0x03, 0x02, 0x04, 0x01,

       0x05, 0x00, 0x06, 0x07, 0x09, 0x08, 0x0a, 0x0b, 0xff},

      {0,    0,    6,    3,    1,    1,    2,    0,    0,    0,

       0,    0,    0,    0,    0,    0,    0x06, 0x05, 0x07, 0x04,

       0x08, 0x03, 0x09, 0x02, 0x00, 0x0a, 0x01, 0x0b, 0xff},

  };

  static const uchar second_tree[3][180] = {

      {0,    2,    2,    2,    1,    4,    2,    1,    2,    5,    1,    1,

       0,    0,    0,    139,  0x03, 0x04, 0x02, 0x05, 0x01, 0x06, 0x07, 0x08,

       0x12, 0x13, 0x11, 0x14, 0x09, 0x15, 0x22, 0x00, 0x21, 0x16, 0x0a, 0xf0,

       0x23, 0x17, 0x24, 0x31, 0x32, 0x18, 0x19, 0x33, 0x25, 0x41, 0x34, 0x42,

       0x35, 0x51, 0x36, 0x37, 0x38, 0x29, 0x79, 0x26, 0x1a, 0x39, 0x56, 0x57,

       0x28, 0x27, 0x52, 0x55, 0x58, 0x43, 0x76, 0x59, 0x77, 0x54, 0x61, 0xf9,

       0x71, 0x78, 0x75, 0x96, 0x97, 0x49, 0xb7, 0x53, 0xd7, 0x74, 0xb6, 0x98,

       0x47, 0x48, 0x95, 0x69, 0x99, 0x91, 0xfa, 0xb8, 0x68, 0xb5, 0xb9, 0xd6,

       0xf7, 0xd8, 0x67, 0x46, 0x45, 0x94, 0x89, 0xf8, 0x81, 0xd5, 0xf6, 0xb4,

       0x88, 0xb1, 0x2a, 0x44, 0x72, 0xd9, 0x87, 0x66, 0xd4, 0xf5, 0x3a, 0xa7,

       0x73, 0xa9, 0xa8, 0x86, 0x62, 0xc7, 0x65, 0xc8, 0xc9, 0xa1, 0xf4, 0xd1,

       0xe9, 0x5a, 0x92, 0x85, 0xa6, 0xe7, 0x93, 0xe8, 0xc1, 0xc6, 0x7a, 0x64,

       0xe1, 0x4a, 0x6a, 0xe6, 0xb3, 0xf1, 0xd3, 0xa5, 0x8a, 0xb2, 0x9a, 0xba,

       0x84, 0xa4, 0x63, 0xe5, 0xc5, 0xf3, 0xd2, 0xc4, 0x82, 0xaa, 0xda, 0xe4,

       0xf2, 0xca, 0x83, 0xa3, 0xa2, 0xc3, 0xea, 0xc2, 0xe2, 0xe3, 0xff, 0xff},

      {0,    2,    2,    1,    4,    1,    4,    1,    3,    3,    1,    0,

       0,    0,    0,    140,  0x02, 0x03, 0x01, 0x04, 0x05, 0x12, 0x11, 0x06,

       0x13, 0x07, 0x08, 0x14, 0x22, 0x09, 0x21, 0x00, 0x23, 0x15, 0x31, 0x32,

       0x0a, 0x16, 0xf0, 0x24, 0x33, 0x41, 0x42, 0x19, 0x17, 0x25, 0x18, 0x51,

       0x34, 0x43, 0x52, 0x29, 0x35, 0x61, 0x39, 0x71, 0x62, 0x36, 0x53, 0x26,

       0x38, 0x1a, 0x37, 0x81, 0x27, 0x91, 0x79, 0x55, 0x45, 0x28, 0x72, 0x59,

       0xa1, 0xb1, 0x44, 0x69, 0x54, 0x58, 0xd1, 0xfa, 0x57, 0xe1, 0xf1, 0xb9,

       0x49, 0x47, 0x63, 0x6a, 0xf9, 0x56, 0x46, 0xa8, 0x2a, 0x4a, 0x78, 0x99,

       0x3a, 0x75, 0x74, 0x86, 0x65, 0xc1, 0x76, 0xb6, 0x96, 0xd6, 0x89, 0x85,

       0xc9, 0xf5, 0x95, 0xb4, 0xc7, 0xf7, 0x8a, 0x97, 0xb8, 0x73, 0xb7, 0xd8,

       0xd9, 0x87, 0xa7, 0x7a, 0x48, 0x82, 0x84, 0xea, 0xf4, 0xa6, 0xc5, 0x5a,

       0x94, 0xa4, 0xc6, 0x92, 0xc3, 0x68, 0xb5, 0xc8, 0xe4, 0xe5, 0xe6, 0xe9,

       0xa2, 0xa3, 0xe3, 0xc2, 0x66, 0x67, 0x93, 0xaa, 0xd4, 0xd5, 0xe7, 0xf8,

       0x88, 0x9a, 0xd7, 0x77, 0xc4, 0x64, 0xe2, 0x98, 0xa5, 0xca, 0xda, 0xe8,

       0xf3, 0xf6, 0xa9, 0xb2, 0xb3, 0xf2, 0xd2, 0x83, 0xba, 0xd3, 0xff, 0xff},

      {0,    0,    6,    2,    1,    3,    3,    2,    5,    1,    2,    2,

       8,    10,   0,    117,  0x04, 0x05, 0x03, 0x06, 0x02, 0x07, 0x01, 0x08,

       0x09, 0x12, 0x13, 0x14, 0x11, 0x15, 0x0a, 0x16, 0x17, 0xf0, 0x00, 0x22,

       0x21, 0x18, 0x23, 0x19, 0x24, 0x32, 0x31, 0x25, 0x33, 0x38, 0x37, 0x34,

       0x35, 0x36, 0x39, 0x79, 0x57, 0x58, 0x59, 0x28, 0x56, 0x78, 0x27, 0x41,

       0x29, 0x77, 0x26, 0x42, 0x76, 0x99, 0x1a, 0x55, 0x98, 0x97, 0xf9, 0x48,

       0x54, 0x96, 0x89, 0x47, 0xb7, 0x49, 0xfa, 0x75, 0x68, 0xb6, 0x67, 0x69,

       0xb9, 0xb8, 0xd8, 0x52, 0xd7, 0x88, 0xb5, 0x74, 0x51, 0x46, 0xd9, 0xf8,

       0x3a, 0xd6, 0x87, 0x45, 0x7a, 0x95, 0xd5, 0xf6, 0x86, 0xb4, 0xa9, 0x94,

       0x53, 0x2a, 0xa8, 0x43, 0xf5, 0xf7, 0xd4, 0x66, 0xa7, 0x5a, 0x44, 0x8a,

       0xc9, 0xe8, 0xc8, 0xe7, 0x9a, 0x6a, 0x73, 0x4a, 0x61, 0xc7, 0xf4, 0xc6,

       0x65, 0xe9, 0x72, 0xe6, 0x71, 0x91, 0x93, 0xa6, 0xda, 0x92, 0x85, 0x62,

       0xf3, 0xc5, 0xb2, 0xa4, 0x84, 0xba, 0x64, 0xa5, 0xb3, 0xd2, 0x81, 0xe5,

       0xd3, 0xaa, 0xc4, 0xca, 0xf2, 0xb1, 0xe4, 0xd1, 0x83, 0x63, 0xea, 0xc3,

       0xe2, 0x82, 0xf1, 0xa3, 0xc2, 0xa1, 0xc1, 0xe3, 0xa2, 0xe1, 0xff, 0xff}};

  if (table > 2)

    table = 2;

  huff[0] = make_decoder(first_tree[table]);

  huff[1] = make_decoder(second_tree[table]);

}

/*

   Return 0 if the image starts with compressed data,

   1 if it starts with uncompressed low-order bits.

   In Canon compressed data, 0xff is always followed by 0x00.

 */

int LibRaw::canon_has_lowbits()

{

  uchar test[0x4000];

  int ret = 1, i;

  fseek(ifp, 0, SEEK_SET);

  fread(test, 1, sizeof test, ifp);

  for (i = 540; i < int(sizeof test - 1); i++)

    if (test[i] == 0xff)

    {

      if (test[i + 1])

        return 1;

      ret = 0;

    }

  return ret;

}

void LibRaw::canon_load_raw()

{

  ushort *pixel, *prow, *huff[2];

  int nblocks, lowbits, i, c, row, r, val;

  INT64 save;

  int block, diffbuf[64], leaf, len, diff, carry = 0, pnum = 0, base[2];

  crw_init_tables(tiff_compress, huff);

  lowbits = canon_has_lowbits();

  if (!lowbits)

    maximum = 0x3ff;

  fseek(ifp, 540 + lowbits * raw_height * raw_width / 4, SEEK_SET);

  zero_after_ff = 1;

  getbits(-1);

  try

  {

    for (row = 0; row < raw_height; row += 8)

    {

      checkCancel();

      pixel = raw_image + row * raw_width;

      nblocks = MIN(8, raw_height - row) * raw_width >> 6;

      for (block = 0; block < nblocks; block++)

      {

        memset(diffbuf, 0, sizeof diffbuf);

        for (i = 0; i < 64; i++)

        {

          leaf = gethuff(huff[i > 0]);

          if (leaf == 0 && i)

            break;

          if (leaf == 0xff)

            continue;

          i += leaf >> 4;

          len = leaf & 15;

          if (len == 0)

            continue;

          diff = getbits(len);

          if ((diff & (1 << (len - 1))) == 0)

            diff -= (1 << len) - 1;

          if (i < 64)

            diffbuf[i] = diff;

        }

        diffbuf[0] += carry;

        carry = diffbuf[0];

        for (i = 0; i < 64; i++)

        {

          if (pnum++ % raw_width == 0)

            base[0] = base[1] = 512;

          if ((pixel[(block << 6) + i] = base[i & 1] += diffbuf[i]) >> 10)

            derror();

        }

      }

      if (lowbits)

      {

        save = ftell(ifp);

        fseek(ifp, 26 + row * raw_width / 4, SEEK_SET);

        for (prow = pixel, i = 0; i < raw_width * 2; i++)

        {

          c = fgetc(ifp);

          for (r = 0; r < 8; r += 2, prow++)

          {

            val = (*prow << 2) + ((c >> r) & 3);

            if (raw_width == 2672 && val < 512)

              val += 2;

            *prow = val;

          }

        }

        fseek(ifp, save, SEEK_SET);

      }

    }

  }

  catch (...)

  {

    FORC(2) free(huff[c]);

    throw;

  }

  FORC(2) free(huff[c]);

}

int LibRaw::ljpeg_start(struct jhead *jh, int info_only)

{

  ushort c, tag, len;

  int cnt = 0;

  std::vector<uchar> data_buffer(0x10000);

  uchar* data = &data_buffer[0];

  const uchar *dp;

  memset(jh, 0, sizeof *jh);

  jh->restart = INT_MAX;

  if (fread(data, 2, 1, ifp) != 1 || data[1] != 0xd8)

    return 0;

  do

  {

    if (feof(ifp))

      return 0;

    if (cnt++ > 1024)

      return 0; // 1024 tags limit

    if (fread(data, 2, 2, ifp) != 2)

      return 0;

    tag = data[0] << 8 | data[1];

    len = (data[2] << 8 | data[3]) - 2;

    if (tag <= 0xff00)

      return 0;

    if (fread(data, 1, len, ifp) != len)

      return 0;

    switch (tag)

    {

    case 0xffc3: // start of frame; lossless, Huffman

      jh->sraw = ((data[7] >> 4) * (data[7] & 15) - 1) & 3;

    case 0xffc1:

    case 0xffc0:

      jh->algo = tag & 0xff;

      jh->bits = data[0];

      jh->high = data[1] << 8 | data[2];

      jh->wide = data[3] << 8 | data[4];

      jh->clrs = data[5] + jh->sraw;

      if (len == 9 && !dng_version)

        getc(ifp);

      break;

    case 0xffc4: // define Huffman tables

      if (info_only)

        break;

      for (dp = data; dp < data + len && !((c = *dp++) & -20);)

        jh->free[c] = jh->huff[c] = make_decoder_ref(&dp);

      break;

    case 0xffda: // start of scan

      jh->psv = data[1 + data[0] * 2];

      jh->bits -= data[3 + data[0] * 2] & 15;

      break;

    case 0xffdb:

      FORC(64) jh->quant[c] = data[c * 2 + 1] << 8 | data[c * 2 + 2];

      break;

    case 0xffdd:

      jh->restart = data[0] << 8 | data[1];

    }

  } while (tag != 0xffda);

  if (jh->bits > 16 || jh->clrs > 6 || !jh->bits || !jh->high || !jh->wide ||

      !jh->clrs)

    return 0;

  if (info_only)

    return 1;

  if (!jh->huff[0])

    return 0;

  FORC(19) if (!jh->huff[c + 1]) jh->huff[c + 1] = jh->huff[c];

  if (jh->sraw)

  {

    FORC(4) jh->huff[2 + c] = jh->huff[1];

    FORC(jh->sraw) jh->huff[1 + c] = jh->huff[0];

  }

  jh->row = (ushort *)calloc(jh->wide * jh->clrs, 16);

  return zero_after_ff = 1;

}

void LibRaw::ljpeg_end(struct jhead *jh)

{

  int c;

  FORC4 if (jh->free[c]) free(jh->free[c]);

  free(jh->row);

}

int LibRaw::ljpeg_diff(ushort *huff)

{

  int len, diff;

  if (!huff)

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  len = gethuff(huff);

  if (len == 16 && (!dng_version || dng_version >= 0x1010000))

    return -32768;

  diff = getbits(len);

  if ((diff & (1 << (len - 1))) == 0)

    diff -= (1 << len) - 1;

  return diff;

}

ushort *LibRaw::ljpeg_row(int jrow, struct jhead *jh)

{

  int col, c, diff, pred, spred = 0;

  ushort mark = 0, *row[3];

  // Use the optimized, unrolled version if possible.

  if (!jh->sraw)

    return ljpeg_row_unrolled(jrow, jh);

  if (jh->restart != 0 && jrow * jh->wide % jh->restart == 0)

  {

    FORC(6) jh->vpred[c] = 1 << (jh->bits - 1);

    if (jrow)

    {

      fseek(ifp, -2, SEEK_CUR);

      do

        mark = (mark << 8) + (c = fgetc(ifp));

      while (c != EOF && mark >> 4 != 0xffd);

    }

    getbits(-1);

  }

  FORC3 row[c] = jh->row + jh->wide * jh->clrs * ((jrow + c) & 1);

  for (col = 0; col < jh->wide; col++)

    FORC(jh->clrs)

    {

      diff = ljpeg_diff(jh->huff[c]);

      if (jh->sraw && c <= jh->sraw && (col | c))

        pred = spred;

      else if (col)

        pred = row[0][-jh->clrs];

      else

        pred = (jh->vpred[c] += diff) - diff;

      if (jrow && col)

        switch (jh->psv)

        {

        case 1:

          break;

        case 2:

          pred = row[1][0];

          break;

        case 3:

          pred = row[1][-jh->clrs];

          break;

        case 4:

          pred = pred + row[1][0] - row[1][-jh->clrs];

          break;

        case 5:

          pred = pred + ((row[1][0] - row[1][-jh->clrs]) >> 1);

          break;

        case 6:

          pred = row[1][0] + ((pred - row[1][-jh->clrs]) >> 1);

          break;

        case 7:

          pred = (pred + row[1][0]) >> 1;

          break;

        default:

          pred = 0;

        }

      if ((**row = pred + diff) >> jh->bits)

      if(!(load_flags & 512))

      derror();

      if (c <= jh->sraw)

        spred = **row;

      row[0]++;

      row[1]++;

    }

  return row[2];

}

ushort *LibRaw::ljpeg_row_unrolled(int jrow, struct jhead *jh)

{

  int col, c, diff, pred;

  ushort mark = 0, *row[3];

  if (jh->restart != 0 && jrow * jh->wide % jh->restart == 0)

  {

    FORC(6) jh->vpred[c] = 1 << (jh->bits - 1);

    if (jrow)

    {

      fseek(ifp, -2, SEEK_CUR);

      do

        mark = (mark << 8) + (c = fgetc(ifp));

      while (c != EOF && mark >> 4 != 0xffd);

    }

    getbits(-1);

  }

  FORC3 row[c] = jh->row + jh->wide * jh->clrs * ((jrow + c) & 1);

  // The first column uses one particular predictor.

  FORC(jh->clrs)

  {

    diff = ljpeg_diff(jh->huff[c]);

    pred = (jh->vpred[c] += diff) - diff;

    if ((**row = pred + diff) >> jh->bits)

      derror();

    row[0]++;

    row[1]++;

  }

  if (!jrow)

  {

    for (col = 1; col < jh->wide; col++)

      FORC(jh->clrs)

      {

        diff = ljpeg_diff(jh->huff[c]);

        pred = row[0][-jh->clrs];

        if ((**row = pred + diff) >> jh->bits)

          derror();

        row[0]++;

        row[1]++;

      }

  }

  else if (jh->psv == 1)

  {

    for (col = 1; col < jh->wide; col++)

      FORC(jh->clrs)

      {

        diff = ljpeg_diff(jh->huff[c]);

        pred = row[0][-jh->clrs];

        if ((**row = pred + diff) >> jh->bits)

          derror();

        row[0]++;

      }

  }

  else

  {

    for (col = 1; col < jh->wide; col++)

      FORC(jh->clrs)

      {

        diff = ljpeg_diff(jh->huff[c]);

        pred = row[0][-jh->clrs];

        switch (jh->psv)

        {

        case 1:

          break;

        case 2:

          pred = row[1][0];

          break;

        case 3:

          pred = row[1][-jh->clrs];

          break;

        case 4:

          pred = pred + row[1][0] - row[1][-jh->clrs];

          break;

        case 5:

          pred = pred + ((row[1][0] - row[1][-jh->clrs]) >> 1);

          break;

        case 6:

          pred = row[1][0] + ((pred - row[1][-jh->clrs]) >> 1);

          break;

        case 7:

          pred = (pred + row[1][0]) >> 1;

          break;

        default:

          pred = 0;

        }

        if ((**row = pred + diff) >> jh->bits)

          derror();

        row[0]++;

        row[1]++;

      }

  }

  return row[2];

}

void LibRaw::lossless_jpeg_load_raw()

{

  int jwide, jhigh, jrow, jcol, val, jidx, i, j, row = 0, col = 0;

  struct jhead jh;

  ushort *rp;

  if (!ljpeg_start(&jh, 0))

    return;

  if (jh.wide < 1 || jh.high < 1 || jh.clrs < 1 || jh.bits < 1)

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  if(cr2_slice[0] && !cr2_slice[1])

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  jwide = jh.wide * jh.clrs;

  jhigh = jh.high;

  if (jh.clrs == 4 && jwide >= raw_width * 2)

    jhigh *= 2;

  try

  {

    for (jrow = 0; jrow < jh.high; jrow++)

    {

      checkCancel();

      rp = ljpeg_row(jrow, &jh);

      if (load_flags & 1)

        row = jrow & 1 ? height - 1 - jrow / 2 : jrow / 2;

      for (jcol = 0; jcol < jwide; jcol++)

      {

        val = curve[*rp++];

        if (cr2_slice[0])

        {

          jidx = jrow * jwide + jcol;

          i = jidx / (cr2_slice[1] * raw_height);

          if ((j = i >= cr2_slice[0]))

            i = cr2_slice[0];

      if(!cr2_slice[1+j])

            throw LIBRAW_EXCEPTION_IO_CORRUPT;

          jidx -= i * (cr2_slice[1] * raw_height);

          row = jidx / cr2_slice[1 + j];

          col = jidx % cr2_slice[1 + j] + i * cr2_slice[1];

        }

        if (raw_width == 3984 && (col -= 2) < 0)

          col += (row--, raw_width);

        if (row > raw_height)

          throw LIBRAW_EXCEPTION_IO_CORRUPT;

        if (((unsigned)row < raw_height) && ((unsigned)col < raw_width))

          RAW(row, col) = val;

        if (++col >= raw_width)

          col = (row++, 0);

      }

    }

  }

  catch (...)

  {

    ljpeg_end(&jh);

    throw;

  }

  ljpeg_end(&jh);

}

void LibRaw::canon_sraw_load_raw()

{

  struct jhead jh;

  short *rp = 0, (*ip)[4];

  int jwide, slice, scol, ecol, row, col, jrow = 0, jcol = 0, pix[3], c;

  int v[3] = {0, 0, 0}, ver, hue;

  int saved_w = width, saved_h = height;

  char *cp;

  if(!image)

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  if (!ljpeg_start(&jh, 0) || jh.clrs < 4)

    return;

  jwide = (jh.wide >>= 1) * jh.clrs;

  if (jwide < 32 || jwide > 65535)

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  if (load_flags & 256)

  {

    width = raw_width;

    height = raw_height;

  }

  try

  {

    for (ecol = slice = 0; slice <= cr2_slice[0]; slice++)

    {

      scol = ecol;

      ecol += cr2_slice[1] * 2 / jh.clrs;

      if (!cr2_slice[0] || ecol > raw_width - 1)

        ecol = raw_width & -2;

      for (row = 0; row < height; row += (jh.clrs >> 1) - 1)

      {

        checkCancel();

        ip = (short(*)[4])image + row * width;

        for (col = scol; col < ecol; col += 2, jcol += jh.clrs)

        {

          if ((jcol %= jwide) == 0)

            rp = (short *)ljpeg_row(jrow++, &jh);

          if (col >= width)

            continue;

          if (imgdata.rawparams.specials & LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE)

          {

            FORC(jh.clrs - 2)

            {

              ip[col + (c >> 1) * width + (c & 1)][0] = rp[jcol + c];

              ip[col + (c >> 1) * width + (c & 1)][1] =

                  ip[col + (c >> 1) * width + (c & 1)][2] = 8192;

            }

            ip[col][1] = rp[jcol + jh.clrs - 2] - 8192;

            ip[col][2] = rp[jcol + jh.clrs - 1] - 8192;

          }

          else if (imgdata.rawparams.specials & LIBRAW_RAWSPECIAL_SRAW_NO_RGB)

          {

            FORC(jh.clrs - 2)

            ip[col + (c >> 1) * width + (c & 1)][0] = rp[jcol + c];

            ip[col][1] = rp[jcol + jh.clrs - 2] - 8192;

            ip[col][2] = rp[jcol + jh.clrs - 1] - 8192;

          }

          else

          {

            FORC(jh.clrs - 2)

            ip[col + (c >> 1) * width + (c & 1)][0] = rp[jcol + c];

            ip[col][1] = rp[jcol + jh.clrs - 2] - 16384;

            ip[col][2] = rp[jcol + jh.clrs - 1] - 16384;

          }

        }

      }

    }

  }

  catch (...)

  {

    ljpeg_end(&jh);

    throw;

  }

  if (imgdata.rawparams.specials & LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE)

  {

    ljpeg_end(&jh);

    maximum = 0x3fff;

    height = saved_h;

    width = saved_w;

    return;

  }

  try

  {

    for (cp = model2; *cp && !isdigit(*cp); cp++)

      ;

    sscanf(cp, "%d.%d.%d", v, v + 1, v + 2);

    ver = (v[0] * 1000 + v[1]) * 1000 + v[2];

    hue = (jh.sraw + 1) << 2;

    if (unique_id >= 0x80000281ULL ||

        (unique_id == 0x80000218ULL && ver > 1000006))

      hue = jh.sraw << 1;

    ip = (short(*)[4])image;

    rp = ip[0];

    for (row = 0; row < height; row++, ip += width)

    {

      checkCancel();

      if (row & (jh.sraw >> 1))

      {

        for (col = 0; col < width; col += 2)

          for (c = 1; c < 3; c++)

            if (row == height - 1)

            {

              ip[col][c] = ip[col - width][c];

            }

            else

            {

              ip[col][c] = (ip[col - width][c] + ip[col + width][c] + 1) >> 1;

            }

      }

      for (col = 1; col < width; col += 2)

        for (c = 1; c < 3; c++)

          if (col == width - 1)

            ip[col][c] = ip[col - 1][c];

          else

            ip[col][c] = (ip[col - 1][c] + ip[col + 1][c] + 1) >> 1;

    }

    if (!(imgdata.rawparams.specials & LIBRAW_RAWSPECIAL_SRAW_NO_RGB))

      for (; rp < ip[0]; rp += 4)

      {

        checkCancel();

        if ((unique_id == CanonID_EOS_5D_Mark_II) ||

            (unique_id == CanonID_EOS_7D)         ||

            (unique_id == CanonID_EOS_50D)        ||

            (unique_id == CanonID_EOS_1D_Mark_IV) ||

            (unique_id == CanonID_EOS_60D))

        {

          rp[1] = (rp[1] << 2) + hue;

          rp[2] = (rp[2] << 2) + hue;

          pix[0] = rp[0] + ((50 * rp[1] + 22929 * rp[2]) >> 14);

          pix[1] = rp[0] + ((-5640 * rp[1] - 11751 * rp[2]) >> 14);

          pix[2] = rp[0] + ((29040 * rp[1] - 101 * rp[2]) >> 14);

        }

        else

        {

          if (unique_id < CanonID_EOS_5D_Mark_II)

            rp[0] -= 512;

          pix[0] = rp[0] + rp[2];

          pix[2] = rp[0] + rp[1];

          pix[1] = rp[0] + ((-778 * rp[1] - (rp[2] << 11)) >> 12);

        }

        FORC3 rp[c] = CLIP15(pix[c] * sraw_mul[c] >> 10);

      }

  }

  catch (...)

  {

    ljpeg_end(&jh);

    throw;

  }

  height = saved_h;

  width = saved_w;

  ljpeg_end(&jh);

  maximum = 0x3fff;

}

void LibRaw::ljpeg_idct(struct jhead *jh)

{

  int c, i, j, len, skip, coef;

  float work[3][8][8];

  static float cs[106] = {0};

  static const uchar zigzag[80] = {

      0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, 18, 11, 4,  5,

      12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6,  7,  14, 21, 28,

      35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,

      58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,

      63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63};

  if (!cs[0])

    FORC(106) cs[c] = float(cos((c & 31) * M_PI / 16) / 2);

  memset(work, 0, sizeof work);

  work[0][0][0] = float(jh->vpred[0] += ljpeg_diff(jh->huff[0]) * jh->quant[0]);

  for (i = 1; i < 64; i++)

  {

    len = gethuff(jh->huff[16]);

    i += skip = len >> 4;

    if (!(len &= 15) && skip < 15)

      break;

    coef = getbits(len);

    if ((coef & (1 << (len - 1))) == 0)

      coef -= (1 << len) - 1;

    ((float *)work)[zigzag[i]] =  float(coef * jh->quant[i]);

  }

  FORC(8) work[0][0][c] *= float(M_SQRT1_2);

  FORC(8) work[0][c][0] *= float(M_SQRT1_2);

  for (i = 0; i < 8; i++)

    for (j = 0; j < 8; j++)

      FORC(8) work[1][i][j] += work[0][i][c] * cs[(j * 2 + 1) * c];

  for (i = 0; i < 8; i++)

    for (j = 0; j < 8; j++)

      FORC(8) work[2][i][j] += work[1][c][j] * cs[(i * 2 + 1) * c];

  FORC(64) jh->idct[c] = CLIP(((float *)work[2])[c] + 0.5);

}

void LibRaw::pentax_load_raw()

{

  ushort bit[2][15], huff[4097];

  int dep, row, col, diff, c, i;

  ushort vpred[2][2] = {{0, 0}, {0, 0}}, hpred[2];

  fseek(ifp, meta_offset, SEEK_SET);

  dep = (get2() + 12) & 15;

  fseek(ifp, 12, SEEK_CUR);

  FORC(dep) bit[0][c] = get2();

  FORC(dep) bit[1][c] = fgetc(ifp);

  FORC(dep)

  for (i = bit[0][c]; i <= ((bit[0][c] + (4096 >> bit[1][c]) - 1) & 4095);)

    huff[++i] = bit[1][c] << 8 | c;

  huff[0] = 12;

  fseek(ifp, data_offset, SEEK_SET);

  getbits(-1);

  for (row = 0; row < raw_height; row++)

  {

    checkCancel();

    for (col = 0; col < raw_width; col++)

    {

      diff = ljpeg_diff(huff);

      if (col < 2)

        hpred[col] = vpred[row & 1][col] += diff;

      else

        hpred[col & 1] += diff;

      RAW(row, col) = hpred[col & 1];

      if (hpred[col & 1] >> tiff_bps)

        derror();

    }

  }

}

void LibRaw::nikon_read_curve()

{

  ushort ver0, ver1, vpred[2][2], csize;

  int i, step, max;

  fseek(ifp, meta_offset, SEEK_SET);

  ver0 = fgetc(ifp);

  ver1 = fgetc(ifp);

  if (ver0 == 0x49 || ver1 == 0x58)

    fseek(ifp, 2110, SEEK_CUR);

  read_shorts(vpred[0], 4);

  step = max = 1 << tiff_bps & 0x7fff;

  if ((csize = get2()) > 1)

    step = max / (csize - 1);

  if (ver0 == 0x44 && (ver1 == 0x20 || (ver1 == 0x40 && step > 3)) && step > 0)

  {

    if (ver1 == 0x40)

    {

      step /= 4;

      max /= 4;

    }

    for (i = 0; i < csize; i++)

      curve[i * step] = get2();

    for (i = 0; i < max; i++)

      curve[i] = (curve[i - i % step] * (step - i % step) +

                  curve[i - i % step + step] * (i % step)) /

                 step;

  }

  else if (ver0 != 0x46 && csize <= 0x4001)

    read_shorts(curve, max = csize);

}

void LibRaw::nikon_load_raw()

{

  static const uchar nikon_tree[][32] = {

      {0, 1, 5, 1, 1, 1, 1, 1, 1, 2, 0,  0,  0, 0, 0, 0, /* 12-bit lossy */

       5, 4, 3, 6, 2, 7, 1, 0, 8, 9, 11, 10, 12},

      {0,    1,    5,    1,    1,    1, 1, 1, 1, 2, 0, 0,  0,  0,

       0,    0, /* 12-bit lossy after split */

       0x39, 0x5a, 0x38, 0x27, 0x16, 5, 4, 3, 2, 1, 0, 11, 12, 12},

      {0, 1, 4, 2, 3, 1, 2, 0, 0, 0, 0,  0,  0, 0, 0, 0, /* 12-bit lossless */

       5, 4, 6, 3, 7, 2, 8, 1, 9, 0, 10, 11, 12},

      {0, 1, 4, 3, 1, 1, 1, 1, 1, 2, 0,  0,  0,  0,  0, 0, /* 14-bit lossy */

       5, 6, 4, 7, 8, 3, 9, 2, 1, 0, 10, 11, 12, 13, 14},

      {0, 1,    5,    1,    1,    1, 1, 1, 1, 1, 2, 0, 0, 0,  0,

       0, /* 14-bit lossy after split */

       8, 0x5c, 0x4b, 0x3a, 0x29, 7, 6, 5, 4, 3, 2, 1, 0, 13, 14},

      {0, 1, 4, 2, 2, 3, 1,  2, 0,  0,  0, 0, 0, 0,  0, 0, /* 14-bit lossless */

       7, 6, 8, 5, 9, 4, 10, 3, 11, 12, 2, 0, 1, 13, 14}};

  ushort *huff, ver0, ver1, vpred[2][2], hpred[2];

  int i, min, max, tree = 0, split = 0, row, col, len, shl, diff;

  fseek(ifp, meta_offset, SEEK_SET);

  ver0 = fgetc(ifp);

  ver1 = fgetc(ifp);

  if (ver0 == 0x49 || ver1 == 0x58)

    fseek(ifp, 2110, SEEK_CUR);

  if (ver0 == 0x46)

    tree = 2;

  if (tiff_bps == 14)

    tree += 3;

  read_shorts(vpred[0], 4);

  max = 1 << tiff_bps & 0x7fff;

  if (ver0 == 0x44 && (ver1 == 0x20 || ver1 == 0x40))

  {

    if (ver1 == 0x40)

      max /= 4;

    fseek(ifp, meta_offset + 562, SEEK_SET);

    split = get2();

  }

  while (max > 2 && (curve[max - 2] == curve[max - 1]))

    max--;

  huff = make_decoder(nikon_tree[tree]);

  fseek(ifp, data_offset, SEEK_SET);

  getbits(-1);

  try

  {

    for (min = row = 0; row < height; row++)

    {

      checkCancel();

      if (split && row == split)

      {

        free(huff);

        huff = make_decoder(nikon_tree[tree + 1]);

        max += (min = 16) << 1;

      }

      for (col = 0; col < raw_width; col++)

      {

        i = gethuff(huff);

        len = i & 15;

        shl = i >> 4;

        diff = ((getbits(len - shl) << 1) + 1) << shl >> 1;

        if (len > 0 && (diff & (1 << (len - 1))) == 0)

          diff -= (1 << len) - !shl;

        if (col < 2)

          hpred[col] = vpred[row & 1][col] += diff;

        else

          hpred[col & 1] += diff;

        if ((ushort)(hpred[col & 1] + min) >= max)

          derror();

        RAW(row, col) = curve[LIM((short)hpred[col & 1], 0, 0x3fff)];

      }

    }

  }

  catch (...)

  {

    free(huff);

    throw;

  }

  free(huff);

}

void LibRaw::nikon_yuv_load_raw()

{

  if (!image)

    throw LIBRAW_EXCEPTION_IO_CORRUPT;

  int row, col, yuv[4]={0,0,0,0}, rgb[3], b, c;

  UINT64 bitbuf = 0;

  float cmul[4];

  FORC4 { cmul[c] = cam_mul[c] > 0.001f ? cam_mul[c] : 1.f; }

  for (row = 0; row < raw_height; row++)

  {

    checkCancel();

    for (col = 0; col < raw_width; col++)

    {

      if (!(b = col & 1))

      {

        bitbuf = 0;

        FORC(6) bitbuf |= (UINT64)fgetc(ifp) << c * 8;

        FORC(4) yuv[c] = (bitbuf >> c * 12 & 0xfff) - (c >> 1 << 11);

      }

      rgb[0] = int(yuv[b] + 1.370705f * yuv[3]);

      rgb[1] = int(yuv[b] - 0.337633f * yuv[2] - 0.698001f * yuv[3]);

      rgb[2] = int(yuv[b] + 1.732446f * yuv[2]);

      FORC3 image[row * width + col][c] = 

      ushort(

      curve[LIM(rgb[c], 0, 0xfff)] / cmul[c]);