lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/decoders/generic.cpp

@@ -0,0 +1,101 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 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"
+
+void LibRaw::unpacked_load_raw()
+{
+  int row, col, bits = 0;
+  while (1 << ++bits < (int)maximum)
+    ;
+  read_shorts(raw_image, raw_width * raw_height);
+  fseek(ifp, -2, SEEK_CUR); // avoid EOF error
+  if (maximum < 0xffff || load_flags)
+    for (row = 0; row < raw_height; row++)
+    {
+      checkCancel();
+      for (col = 0; col < raw_width; col++)
+        if ((RAW(row, col) >>= load_flags) >> bits &&
+            (unsigned)(row - top_margin) < height &&
+            (unsigned)(col - left_margin) < width)
+          derror();
+    }
+}
+
+void LibRaw::packed_load_raw()
+{
+  int vbits = 0, bwide, rbits, bite, half, irow, row, col, val, i;
+  UINT64 bitbuf = 0;
+
+  bwide = raw_width * tiff_bps / 8;
+  bwide += bwide & load_flags >> 7;
+  rbits = bwide * 8 - raw_width * tiff_bps;
+  if (load_flags & 1)
+    bwide = bwide * 16 / 15;
+  bite = 8 + (load_flags & 24);
+  half = (raw_height + 1) >> 1;
+  for (irow = 0; irow < raw_height; irow++)
+  {
+    checkCancel();
+    row = irow;
+    if (load_flags & 2 && (row = irow % half * 2 + irow / half) == 1 &&
+        load_flags & 4)
+    {
+      if (vbits = 0, tiff_compress)
+        fseek(ifp, data_offset - (-half * bwide & -2048), SEEK_SET);
+      else
+      {
+        fseek(ifp, 0, SEEK_END);
+        fseek(ifp, ftell(ifp) >> 3 << 2, SEEK_SET);
+      }
+    }
+    if (feof(ifp))
+      throw LIBRAW_EXCEPTION_IO_EOF;
+    for (col = 0; col < raw_width; col++)
+    {
+      for (vbits -= tiff_bps; vbits < 0; vbits += bite)
+      {
+        bitbuf <<= bite;
+        for (i = 0; i < bite; i += 8)
+          bitbuf |= (unsigned(fgetc(ifp)) << i);
+      }
+      val = bitbuf << (64 - tiff_bps - vbits) >> (64 - tiff_bps);
+      RAW(row, col ^ (load_flags >> 6 & 1)) = val;
+      if (load_flags & 1 && (col % 10) == 9 && fgetc(ifp) &&
+          row < height + top_margin && col < width + left_margin)
+        derror();
+    }
+    vbits -= rbits;
+  }
+}
+
+void LibRaw::eight_bit_load_raw()
+{
+  unsigned row, col;
+
+  std::vector<uchar> pixel(raw_width);
+  for (row = 0; row < raw_height; row++)
+  {
+      checkCancel();
+      if (fread(pixel.data(), 1, raw_width, ifp) < raw_width)
+          derror();
+      for (col = 0; col < raw_width; col++)
+          RAW(row, col) = curve[pixel[col]];
+  }
+  maximum = curve[0xff];
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/decoders/kodak_decoders.cpp

@@ -0,0 +1,524 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 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"
+
+#define radc_token(tree) ((signed char)getbithuff(8, huff + (tree) * 256))
+
+#define FORYX                                                                  \
+  for (y = 1; y < 3; y++)                                                      \
+    for (x = col + 1; x >= col; x--)
+
+#define PREDICTOR                                                              \
+  (c ? (buf[c][y - 1][x] + buf[c][y][x + 1]) / 2                               \
+     : (buf[c][y - 1][x + 1] + 2 * buf[c][y - 1][x] + buf[c][y][x + 1]) / 4)
+
+#ifdef __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+#pragma GCC optimize("no-aggressive-loop-optimizations")
+#endif
+#endif
+
+void LibRaw::kodak_radc_load_raw()
+{
+  // All kodak radc images are 768x512
+  if (width > 768 || raw_width > 768 || height > 512 || raw_height > 512)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  static const signed char src[] = {
+      1, 1,   2, 3,   3, 4,   4, 2,   5, 7,   6, 5,   7, 6,   7, 8,   1, 0,
+      2, 1,   3, 3,   4, 4,   5, 2,   6, 7,   7, 6,   8, 5,   8, 8,   2, 1,
+      2, 3,   3, 0,   3, 2,   3, 4,   4, 6,   5, 5,   6, 7,   6, 8,   2, 0,
+      2, 1,   2, 3,   3, 2,   4, 4,   5, 6,   6, 7,   7, 5,   7, 8,   2, 1,
+      2, 4,   3, 0,   3, 2,   3, 3,   4, 7,   5, 5,   6, 6,   6, 8,   2, 3,
+      3, 1,   3, 2,   3, 4,   3, 5,   3, 6,   4, 7,   5, 0,   5, 8,   2, 3,
+      2, 6,   3, 0,   3, 1,   4, 4,   4, 5,   4, 7,   5, 2,   5, 8,   2, 4,
+      2, 7,   3, 3,   3, 6,   4, 1,   4, 2,   4, 5,   5, 0,   5, 8,   2, 6,
+      3, 1,   3, 3,   3, 5,   3, 7,   3, 8,   4, 0,   5, 2,   5, 4,   2, 0,
+      2, 1,   3, 2,   3, 3,   4, 4,   4, 5,   5, 6,   5, 7,   4, 8,   1, 0,
+      2, 2,   2, -2,  1, -3,  1, 3,   2, -17, 2, -5,  2, 5,   2, 17,  2, -7,
+      2, 2,   2, 9,   2, 18,  2, -18, 2, -9,  2, -2,  2, 7,   2, -28, 2, 28,
+      3, -49, 3, -9,  3, 9,   4, 49,  5, -79, 5, 79,  2, -1,  2, 13,  2, 26,
+      3, 39,  4, -16, 5, 55,  6, -37, 6, 76,  2, -26, 2, -13, 2, 1,   3, -39,
+      4, 16,  5, -55, 6, -76, 6, 37};
+  std::vector<ushort> huff_buffer(19 * 256,0);
+  ushort* huff = &huff_buffer[0];
+  int row, col, tree, nreps, rep, step, i, c, s, r, x, y, val;
+  short last[3] = {16, 16, 16}, mul[3], buf[3][3][386];
+  static const ushort pt[] = {0,    0,    1280, 1344,  2320,  3616,
+                              3328, 8000, 4095, 16383, 65535, 16383};
+
+  for (i = 2; i < 12; i += 2)
+    for (c = pt[i - 2]; c <= pt[i]; c++)
+      curve[c] = (float)(c - pt[i - 2]) / (pt[i] - pt[i - 2]) *
+                     (pt[i + 1] - pt[i - 1]) +
+                 pt[i - 1] + 0.5;
+  for (s = i = 0; i < int(sizeof src); i += 2)
+    FORC(256 >> src[i])
+  ((ushort *)huff)[s++] = src[i] << 8 | (uchar)src[i + 1];
+  s = kodak_cbpp == 243 ? 2 : 3;
+  FORC(256) huff[18 * 256 + c] = (8 - s) << 8 | c >> s << s | 1 << (s - 1);
+  getbits(-1);
+  for (i = 0; i < int(sizeof(buf) / sizeof(short)); i++)
+    ((short *)buf)[i] = 2048;
+  for (row = 0; row < height; row += 4)
+  {
+    checkCancel();
+    FORC3 mul[c] = getbits(6);
+    if (!mul[0] || !mul[1] || !mul[2])
+      throw LIBRAW_EXCEPTION_IO_CORRUPT;
+    FORC3
+    {
+      val = ((0x1000000 / last[c] + 0x7ff) >> 12) * mul[c];
+      s = val > 65564 ? 10 : 12;
+      x = ~((~0u) << (s - 1));
+      val <<= 12 - s;
+      for (i = 0; i < int(sizeof(buf[0]) / sizeof(short)); i++)
+        ((short *)buf[c])[i] = MIN(0x7FFFFFFF, (((short *)buf[c])[i] * static_cast<long long>(val) + x)) >> s;
+      last[c] = mul[c];
+      for (r = 0; r <= int(!c); r++)
+      {
+        buf[c][1][width / 2] = buf[c][2][width / 2] = mul[c] << 7;
+        for (tree = 1, col = width / 2; col > 0;)
+        {
+          if ((tree = radc_token(tree)))
+          {
+            col -= 2;
+            if (col >= 0)
+            {
+              if (tree == 8)
+                FORYX buf[c][y][x] = (uchar)radc_token(18) * mul[c];
+              else
+                FORYX buf[c][y][x] = radc_token(tree + 10) * 16 + PREDICTOR;
+            }
+          }
+          else
+            do
+            {
+              nreps = (col > 2) ? radc_token(9) + 1 : 1;
+              for (rep = 0; rep < 8 && rep < nreps && col > 0; rep++)
+              {
+                col -= 2;
+                if (col >= 0)
+                  FORYX buf[c][y][x] = PREDICTOR;
+                if (rep & 1)
+                {
+                  step = radc_token(10) << 4;
+                  FORYX buf[c][y][x] += step;
+                }
+              }
+            } while (nreps == 9);
+        }
+        for (y = 0; y < 2; y++)
+          for (x = 0; x < width / 2; x++)
+          {
+            val = (buf[c][y + 1][x] << 4) / mul[c];
+            if (val < 0)
+              val = 0;
+            if (c)
+              RAW(row + y * 2 + c - 1, x * 2 + 2 - c) = val;
+            else
+              RAW(row + r * 2 + y, x * 2 + y) = val;
+          }
+        memcpy(buf[c][0] + !c, buf[c][2], sizeof buf[c][0] - 2 * !c);
+      }
+    }
+    for (y = row; y < row + 4; y++)
+      for (x = 0; x < width; x++)
+        if ((x + y) & 1)
+        {
+          r = x ? x - 1 : x + 1;
+          s = x + 1 < width ? x + 1 : x - 1;
+          val = (RAW(y, x) - 2048) * 2 + (RAW(y, r) + RAW(y, s)) / 2;
+          if (val < 0)
+            val = 0;
+          RAW(y, x) = val;
+        }
+  }
+  for (i = 0; i < height * width; i++)
+    raw_image[i] = curve[raw_image[i]];
+  maximum = 0x3fff;
+}
+
+#undef FORYX
+#undef PREDICTOR
+
+#ifdef NO_JPEG
+void LibRaw::kodak_jpeg_load_raw() {}
+#else
+static void jpegErrorExit_k(j_common_ptr /*cinfo*/)
+{
+  throw LIBRAW_EXCEPTION_DECODE_JPEG;
+}
+
+// LibRaw's Kodak_jpeg_load_raw
+void LibRaw::kodak_jpeg_load_raw()
+{
+  if (data_size < 1)
+    throw LIBRAW_EXCEPTION_DECODE_JPEG;
+
+  int row, col;
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr pub;
+  cinfo.err = jpeg_std_error(&pub);
+  pub.error_exit = jpegErrorExit_k;
+
+  if (INT64(data_size) >
+          INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024))
+	  throw LIBRAW_EXCEPTION_TOOBIG;
+
+  unsigned char *jpg_buf = (unsigned char *)calloc(data_size,1);
+  std::vector<uchar> pixel_buf(width * 3, 0);
+  jpeg_create_decompress(&cinfo);
+
+  fread(jpg_buf, data_size, 1, ifp);
+  libraw_swab(jpg_buf, data_size);
+  try
+  {
+    jpeg_mem_src(&cinfo, jpg_buf, data_size);
+    int rc = jpeg_read_header(&cinfo, TRUE);
+    if (rc != 1)
+      throw LIBRAW_EXCEPTION_DECODE_JPEG;
+
+    jpeg_start_decompress(&cinfo);
+    if ((cinfo.output_width != width) || (cinfo.output_height * 2 != height) ||
+        (cinfo.output_components != 3))
+    {
+      throw LIBRAW_EXCEPTION_DECODE_JPEG;
+    }
+
+    unsigned char *buf[1];
+    buf[0] = pixel_buf.data();
+
+    while (cinfo.output_scanline < cinfo.output_height)
+    {
+      checkCancel();
+      row = cinfo.output_scanline * 2;
+      jpeg_read_scanlines(&cinfo, buf, 1);
+      unsigned char(*pixel)[3] = (unsigned char(*)[3])buf[0];
+      for (col = 0; col < width; col += 2)
+      {
+        RAW(row + 0, col + 0) = pixel[col + 0][1] << 1;
+        RAW(row + 1, col + 1) = pixel[col + 1][1] << 1;
+        RAW(row + 0, col + 1) = pixel[col][0] + pixel[col + 1][0];
+        RAW(row + 1, col + 0) = pixel[col][2] + pixel[col + 1][2];
+      }
+    }
+  }
+  catch (...)
+  {
+    jpeg_finish_decompress(&cinfo);
+    jpeg_destroy_decompress(&cinfo);
+    free(jpg_buf);
+    throw;
+  }
+  jpeg_finish_decompress(&cinfo);
+  jpeg_destroy_decompress(&cinfo);
+  free(jpg_buf);
+  maximum = 0xff << 1;
+}
+#endif
+
+void LibRaw::kodak_dc120_load_raw()
+{
+  static const int mul[4] = {162, 192, 187, 92};
+  static const int add[4] = {0, 636, 424, 212};
+  uchar pixel[848];
+  int row, shift, col;
+
+  for (row = 0; row < height; row++)
+  {
+    checkCancel();
+    if (fread(pixel, 1, 848, ifp) < 848)
+      derror();
+    shift = row * mul[row & 3] + add[row & 3];
+    for (col = 0; col < width; col++)
+      RAW(row, col) = (ushort)pixel[(col + shift) % 848];
+  }
+  maximum = 0xff;
+}
+void LibRaw::kodak_c330_load_raw()
+{
+  if (!image)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  int row, col, y, cb, cr, rgb[3], c;
+
+  std::vector<uchar> pixel(raw_width*2 + 4);
+
+  for (row = 0; row < height; row++)
+  {
+      checkCancel();
+      if (fread(pixel.data(), raw_width, 2, ifp) < 2)
+          derror();
+      if (load_flags && (row & 31) == 31)
+          fseek(ifp, raw_width * 32, SEEK_CUR);
+      for (col = 0; col < width; col++)
+      {
+          y = pixel[col * 2];
+          cb = pixel[(col * 2 & -4) | 1] - 128;
+          cr = pixel[(col * 2 & -4) | 3] - 128;
+          rgb[1] = y - ((cb + cr + 2) >> 2);
+          rgb[2] = rgb[1] + cb;
+          rgb[0] = rgb[1] + cr;
+          FORC3 image[row * width + col][c] = curve[LIM(rgb[c], 0, 255)];
+      }
+  }
+  maximum = curve[0xff];
+}
+
+void LibRaw::kodak_c603_load_raw()
+{
+  if (!image)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  int row, col, y, cb, cr, rgb[3], c;
+
+  std::vector<uchar> pixel(raw_width * 3);
+  for (row = 0; row < height; row++)
+  {
+      checkCancel();
+      if (~row & 1)
+          if (fread(pixel.data(), raw_width, 3, ifp) < 3)
+              derror();
+      for (col = 0; col < width; col++)
+      {
+          y = pixel[width * 2 * (row & 1) + col];
+          cb = pixel[width + (col & -2)] - 128;
+          cr = pixel[width + (col & -2) + 1] - 128;
+          rgb[1] = y - ((cb + cr + 2) >> 2);
+          rgb[2] = rgb[1] + cb;
+          rgb[0] = rgb[1] + cr;
+          FORC3 image[row * width + col][c] = curve[LIM(rgb[c], 0, 255)];
+      }
+  }
+  maximum = curve[0xff];
+}
+
+void LibRaw::kodak_262_load_raw()
+{
+  static const uchar kodak_tree[2][26] = {
+      {0, 1, 5, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+      {0, 3, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
+  ushort *huff[2];
+  int *strip, ns, c, row, col, chess, pi = 0, pi1, pi2, pred, val;
+
+  FORC(2) huff[c] = make_decoder(kodak_tree[c]);
+  ns = (raw_height + 63) >> 5;
+  std::vector<uchar> pixel(raw_width * 32 + ns * 4);
+  strip = (int *)(pixel.data() + raw_width * 32);
+  order = 0x4d4d;
+  FORC(ns) strip[c] = get4();
+  try
+  {
+    for (row = 0; row < raw_height; row++)
+    {
+      checkCancel();
+      if ((row & 31) == 0)
+      {
+        fseek(ifp, strip[row >> 5], SEEK_SET);
+        getbits(-1);
+        pi = 0;
+      }
+      for (col = 0; col < raw_width; col++)
+      {
+        chess = (row + col) & 1;
+        pi1 = chess ? pi - 2 : pi - raw_width - 1;
+        pi2 = chess ? pi - 2 * raw_width : pi - raw_width + 1;
+        if (col <= chess)
+          pi1 = -1;
+        if (pi1 < 0)
+          pi1 = pi2;
+        if (pi2 < 0)
+          pi2 = pi1;
+        if (pi1 < 0 && col > 1)
+          pi1 = pi2 = pi - 2;
+        pred = (pi1 < 0) ? 0 : (pixel[pi1] + pixel[pi2]) >> 1;
+        pixel[pi] = val = pred + ljpeg_diff(huff[chess]);
+        if (val >> 8)
+          derror();
+        val = curve[pixel[pi++]];
+        RAW(row, col) = val;
+      }
+    }
+  }
+  catch (...)
+  {
+      FORC(2) free(huff[c]);
+      throw;
+  }
+  FORC(2) free(huff[c]);
+}
+
+int LibRaw::kodak_65000_decode(short *out, int bsize)
+{
+  uchar c, blen[768];
+  ushort raw[6];
+  INT64 bitbuf = 0;
+  int save, bits = 0, i, j, len, diff;
+
+  save = ftell(ifp);
+  bsize = (bsize + 3) & -4;
+  for (i = 0; i < bsize; i += 2)
+  {
+    c = fgetc(ifp);
+    if ((blen[i] = c & 15) > 12 || (blen[i + 1] = c >> 4) > 12)
+    {
+      fseek(ifp, save, SEEK_SET);
+      for (i = 0; i < bsize; i += 8)
+      {
+        read_shorts(raw, 6);
+        out[i] = raw[0] >> 12 << 8 | raw[2] >> 12 << 4 | raw[4] >> 12;
+        out[i + 1] = raw[1] >> 12 << 8 | raw[3] >> 12 << 4 | raw[5] >> 12;
+        for (j = 0; j < 6; j++)
+          out[i + 2 + j] = raw[j] & 0xfff;
+      }
+      return 1;
+    }
+  }
+  if ((bsize & 7) == 4)
+  {
+    bitbuf = fgetc(ifp) << 8;
+    bitbuf += fgetc(ifp);
+    bits = 16;
+  }
+  for (i = 0; i < bsize; i++)
+  {
+    len = blen[i];
+    if (bits < len)
+    {
+      for (j = 0; j < 32; j += 8)
+        bitbuf += (INT64)fgetc(ifp) << (bits + (j ^ 8));
+      bits += 32;
+    }
+    diff = bitbuf & (0xffff >> (16 - len));
+    bitbuf >>= len;
+    bits -= len;
+    if (len > 0 && (diff & (1 << (len - 1))) == 0)
+      diff -= (1 << len) - 1;
+    out[i] = diff;
+  }
+  return 0;
+}
+
+void LibRaw::kodak_65000_load_raw()
+{
+  short buf[272]; /* 264 looks enough */
+  int row, col, len, pred[2], ret, i;
+
+  for (row = 0; row < height; row++)
+  {
+    checkCancel();
+    for (col = 0; col < width; col += 256)
+    {
+      pred[0] = pred[1] = 0;
+      len = MIN(256, width - col);
+      ret = kodak_65000_decode(buf, len);
+      for (i = 0; i < len; i++)
+      {
+        int idx = ret ? buf[i] : (pred[i & 1] += buf[i]);
+        if (idx >= 0 && idx < 0xffff)
+        {
+          if ((RAW(row, col + i) = curve[idx]) >> 12)
+            derror();
+        }
+        else
+          derror();
+      }
+    }
+  }
+}
+
+void LibRaw::kodak_ycbcr_load_raw()
+{
+  if (!image)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  short buf[384], *bp;
+  int row, col, len, c, i, j, k, y[2][2], cb, cr, rgb[3];
+  ushort *ip;
+
+  unsigned int bits =
+      (load_flags && load_flags > 9 && load_flags < 17) ? load_flags : 10;
+  const int pixels = int(width)*int(height);
+  for (row = 0; row < height; row += 2)
+  {
+    checkCancel();
+    for (col = 0; col < width; col += 128)
+    {
+      len = MIN(128, width - col);
+      kodak_65000_decode(buf, len * 3);
+      y[0][1] = y[1][1] = cb = cr = 0;
+      for (bp = buf, i = 0; i < len; i += 2, bp += 2)
+      {
+        cb += bp[4];
+        cr += bp[5];
+        rgb[1] = -((cb + cr + 2) >> 2);
+        rgb[2] = rgb[1] + cb;
+        rgb[0] = rgb[1] + cr;
+        for (j = 0; j < 2; j++)
+          for (k = 0; k < 2; k++)
+          {
+            if ((y[j][k] = y[j][k ^ 1] + *bp++) >> bits)
+              derror();
+            int indx = (row + j) * width + col + i + k;
+            if(indx>=0 && indx < pixels)
+            {
+                ip = image[indx];
+                FORC3 ip[c] = curve[LIM(y[j][k] + rgb[c], 0, 0xfff)];
+            }
+          }
+      }
+    }
+  }
+}
+
+void LibRaw::kodak_rgb_load_raw()
+{
+  if (!image)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  short buf[768], *bp;
+  int row, col, len, c, i, rgb[3], ret;
+  ushort *ip = image[0];
+
+  for (row = 0; row < height; row++)
+  {
+    checkCancel();
+    for (col = 0; col < width; col += 256)
+    {
+      len = MIN(256, width - col);
+      ret = kodak_65000_decode(buf, len * 3);
+      memset(rgb, 0, sizeof rgb);
+      for (bp = buf, i = 0; i < len; i++, ip += 4)
+        if (load_flags == 12)
+          FORC3 ip[c] = ret ? (*bp++) : (rgb[c] += *bp++);
+        else
+          FORC3 if ((ip[c] = ret ? (*bp++) : (rgb[c] += *bp++)) >> 12) derror();
+    }
+  }
+}
+
+void LibRaw::kodak_thumb_load_raw()
+{
+  if (!image)
+    throw LIBRAW_EXCEPTION_IO_CORRUPT;
+  int row, col;
+  colors = thumb_misc >> 5;
+  for (row = 0; row < height; row++)
+    for (col = 0; col < width; col++)
+      read_shorts(image[row * width + col], colors);
+  maximum = (1 << (thumb_misc & 31)) - 1;
+}