lightdrift-libraw 1.0.0-alpha.1

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/integration/dngsdk_glue.cpp

@@ -0,0 +1,416 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
+ *
+ 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/libraw_cxx_defs.h"
+
+#if defined (USE_GPRSDK) && !defined(USE_DNGSDK)
+#error  GPR (GoPro) SDK should be used with Adobe DNG SDK
+#endif
+#ifdef USE_DNGSDK
+#include "dng_read_image.h"
+#endif
+#ifdef USE_GPRSDK
+#include "gpr_read_image.h"
+#endif
+
+#ifdef USE_DNGSDK
+static dng_ifd* search_single_ifd(const std::vector <dng_ifd *>& v, uint64 offset, int& idx, dng_stream& stream)
+{
+    idx = -1;
+    for (int i = 0; i < v.size(); i++)
+    {
+        if (!v[i]) continue;
+        if (v[i]->fTileOffsetsOffset == offset)
+        {
+            idx = i;
+            return v[i];
+        }
+        else if (v[i]->fTileOffsetsCount == 1 && v[i]->fTileOffset[0] == offset)
+        {
+            idx = i;
+            return v[i];
+        }
+		else if (v[i]->fTileOffsetsCount > dng_ifd::kMaxTileInfo)
+		{
+			uint64 p  = stream.Position();
+			stream.SetReadPosition(v[i]->fTileOffsetsOffset);
+			int32 oo = stream.TagValue_uint32(v[i]->fTileOffsetsType);
+			stream.SetReadPosition(p);
+			if (oo == offset)
+			{
+				idx = i;
+				return v[i];
+			}
+		}
+    }
+    return NULL;
+}
+
+static dng_ifd* search_for_ifd(const dng_info& info, uint64 offset, ushort w, ushort h, int& ifdIndex, dng_stream& stream)
+{
+    dng_ifd *ret = 0;
+    ret = search_single_ifd(info.fIFD, offset, ifdIndex, stream);
+    int dummy;
+    if (!ret) ret = search_single_ifd(info.fChainedIFD, offset, dummy, stream);
+    if (!ret)
+    {
+        for (int c = 0; !ret && c < info.fChainedSubIFD.size(); c++)
+            ret = search_single_ifd(info.fChainedSubIFD[c], offset, dummy, stream);
+    }
+    if (ret && (ret->fImageLength == h) && ret->fImageWidth == w)
+        return ret;
+    ifdIndex = -1;
+    return 0;
+}
+#endif
+
+int LibRaw::valid_for_dngsdk()
+{
+#ifndef USE_DNGSDK
+  return 0;
+#else
+  if (!imgdata.idata.dng_version)
+    return 0;
+
+  // All DNG larger than 2GB - to DNG SDK
+  if (libraw_internal_data.internal_data.input->size() > 2147483647ULL)
+      return 1;
+
+  if (!strcasecmp(imgdata.idata.make, "Blackmagic") 
+      && (libraw_internal_data.unpacker_data.tiff_compress == 7)
+      && (libraw_internal_data.unpacker_data.tiff_bps > 8)
+      )
+      return 0;
+
+  if (libraw_internal_data.unpacker_data.tiff_compress == 34892
+	  && libraw_internal_data.unpacker_data.tiff_bps == 8
+	  && (libraw_internal_data.unpacker_data.tiff_samples == 3
+		  || libraw_internal_data.unpacker_data.tiff_samples == 1
+		  || libraw_internal_data.unpacker_data.tiff_samples == 4 )
+	  && load_raw == &LibRaw::lossy_dng_load_raw
+	  )
+  {
+      if (!dnghost)
+          return 0;
+      dng_host *host = static_cast<dng_host *>(dnghost);
+      libraw_dng_stream stream(libraw_internal_data.internal_data.input);
+      AutoPtr<dng_negative> negative;
+      negative.Reset(host->Make_dng_negative());
+      dng_info info;
+      info.Parse(*host, stream);
+      info.PostParse(*host);
+      if (!info.IsValidDNG())
+          return 0;
+      negative->Parse(*host, stream, info);
+      negative->PostParse(*host, stream, info);
+      int ifdindex = -1;
+      dng_ifd *rawIFD = search_for_ifd(info, libraw_internal_data.unpacker_data.data_offset, imgdata.sizes.raw_width, imgdata.sizes.raw_height, ifdindex,stream);
+      if (rawIFD && ifdindex >= 0 && ifdindex == info.fMainIndex)
+          return 1;
+	  return 0;
+  }
+
+#ifdef USE_GPRSDK
+  if (load_raw == &LibRaw::vc5_dng_load_raw_placeholder) // regardless of flags or use_dngsdk value!
+      return 1;
+#endif
+  if (!imgdata.rawparams.use_dngsdk)
+    return 0;
+  if (load_raw == &LibRaw::lossy_dng_load_raw) // WHY??
+    return 0;
+  if (is_floating_point() && (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_FLOAT))
+    return 1;
+  if (!imgdata.idata.filters && (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_LINEAR))
+    return 1;
+  if (libraw_internal_data.unpacker_data.tiff_bps == 8 &&
+      (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_8BIT))
+    return 1;
+  if (libraw_internal_data.unpacker_data.tiff_compress == 8 &&
+      (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_DEFLATE))
+    return 1;
+  if (libraw_internal_data.unpacker_data.tiff_samples == 2)
+    return 0; // Always deny 2-samples (old fuji superccd)
+  if (imgdata.idata.filters == 9 &&
+      (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_XTRANS))
+    return 1;
+  if (is_fuji_rotated())
+    return 0; // refuse
+  if (imgdata.rawparams.use_dngsdk & LIBRAW_DNG_OTHER)
+    return 1;
+  return 0;
+#endif
+}
+
+
+
+
+int LibRaw::try_dngsdk()
+{
+#ifdef USE_DNGSDK
+  if (!dnghost)
+    return LIBRAW_UNSPECIFIED_ERROR;
+
+  dng_host *host = static_cast<dng_host *>(dnghost);
+
+  try
+  {
+    libraw_dng_stream stream(libraw_internal_data.internal_data.input);
+
+    AutoPtr<dng_negative> negative;
+    negative.Reset(host->Make_dng_negative());
+
+    dng_info info;
+    info.Parse(*host, stream);
+    info.PostParse(*host);
+
+    if (!info.IsValidDNG())
+    {
+      return LIBRAW_DATA_ERROR;
+    }
+    negative->Parse(*host, stream, info);
+    negative->PostParse(*host, stream, info);
+    int ifdindex;
+    dng_ifd *rawIFD = search_for_ifd(info,libraw_internal_data.unpacker_data.data_offset,imgdata.sizes.raw_width,imgdata.sizes.raw_height,ifdindex,stream);
+    if(!rawIFD)
+        return LIBRAW_DATA_ERROR;
+
+    AutoPtr<dng_simple_image> stage2;
+    bool stage23used = false;
+	bool zerocopy = false;
+
+    //(new dng_simple_image(rawIFD->Bounds(), rawIFD->fSamplesPerPixel, rawIFD->PixelType(), host->Allocator()));
+
+    if (((libraw_internal_data.unpacker_data.tiff_compress == 34892 
+        && libraw_internal_data.unpacker_data.tiff_bps == 8
+        && libraw_internal_data.unpacker_data.tiff_samples == 3
+        && load_raw == &LibRaw::lossy_dng_load_raw) 
+        || (imgdata.rawparams.options & (LIBRAW_RAWOPTIONS_DNG_STAGE2| LIBRAW_RAWOPTIONS_DNG_STAGE3))
+        || ((tiff_ifd[ifdindex].dng_levels.parsedfields & (LIBRAW_DNGFM_OPCODE2| LIBRAW_DNGFM_OPCODE3))
+            && (imgdata.rawparams.options & (LIBRAW_RAWOPTIONS_DNG_STAGE2_IFPRESENT | LIBRAW_RAWOPTIONS_DNG_STAGE3_IFPRESENT)))
+        )
+        && ifdindex >= 0)
+    {
+        if (info.fMainIndex != ifdindex)
+            info.fMainIndex = ifdindex;
+
+        negative->ReadStage1Image(*host, stream, info);
+        negative->BuildStage2Image(*host);
+		imgdata.process_warnings |= LIBRAW_WARN_DNG_STAGE2_APPLIED;
+		if (  (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_STAGE3) ||
+            ((tiff_ifd[ifdindex].dng_levels.parsedfields & LIBRAW_DNGFM_OPCODE3) &&
+             (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_STAGE3_IFPRESENT))
+            )
+		{
+			negative->BuildStage3Image(*host);
+			stage2.Reset((dng_simple_image*)negative->Stage3Image());
+			imgdata.process_warnings |= LIBRAW_WARN_DNG_STAGE3_APPLIED;
+		}
+		else
+			stage2.Reset((dng_simple_image*)negative->Stage2Image());
+        stage23used = true;
+    }
+    else
+    {
+        stage2.Reset(new dng_simple_image(rawIFD->Bounds(), rawIFD->fSamplesPerPixel, rawIFD->PixelType(), host->Allocator()));
+#ifdef USE_GPRSDK
+        if (libraw_internal_data.unpacker_data.tiff_compress == 9)
+        {
+            gpr_allocator allocator;
+            allocator.Alloc = ::malloc;
+            allocator.Free = ::free;
+            gpr_buffer_auto vc5_image_obj(allocator.Alloc, allocator.Free);
+
+            gpr_read_image reader(&vc5_image_obj);
+            reader.Read(*host, *rawIFD, stream, *stage2.Get(), NULL, NULL);
+        }
+        else
+#endif
+        {
+            dng_read_image reader;
+            reader.Read(*host, *rawIFD, stream, *stage2.Get(), NULL, NULL);
+        }
+    }
+
+    if (stage2->Bounds().W() != S.raw_width ||
+        stage2->Bounds().H() != S.raw_height)
+    {
+		if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNG_ALLOWSIZECHANGE)
+		{
+			S.raw_width = S.width = stage2->Bounds().W();
+			S.left_margin = 0;
+			S.raw_height = S.height = stage2->Bounds().H();
+			S.top_margin = 0;
+		}
+		else
+		{
+			stage2.Release(); // It holds copy to internal dngnegative
+			return LIBRAW_DATA_ERROR;
+		}
+    }
+	if (stage23used)
+	{
+		if (stage2->Planes() > 1)
+		{
+			imgdata.idata.filters = 0;
+			imgdata.idata.colors = stage2->Planes();
+		}
+		// reset BL and whitepoint
+		imgdata.color.black = 0;
+		memset(imgdata.color.cblack, 0, sizeof(imgdata.color.cblack));
+		imgdata.color.maximum = 0xffff;
+	}
+
+    int pplanes = stage2->Planes();
+    int ptype = stage2->PixelType();
+
+    dng_pixel_buffer buffer;
+    stage2->GetPixelBuffer(buffer);
+
+    int pixels = stage2->Bounds().H() * stage2->Bounds().W() * pplanes;
+
+    if (ptype == ttShort && !stage23used &&  !is_curve_linear())
+    {
+      imgdata.rawdata.raw_alloc = malloc(pixels * TagTypeSize(ptype));
+      ushort *src = (ushort *)buffer.fData;
+      ushort *dst = (ushort *)imgdata.rawdata.raw_alloc;
+      for (int i = 0; i < pixels; i++)
+        dst[i] = imgdata.color.curve[src[i]];
+      S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ptype);
+
+    }
+    else if (ptype == ttByte)
+    {
+      imgdata.rawdata.raw_alloc = malloc(pixels * TagTypeSize(ttShort));
+      unsigned char *src = (unsigned char *)buffer.fData;
+      ushort *dst = (ushort *)imgdata.rawdata.raw_alloc;
+      if (is_curve_linear())
+      {
+        for (int i = 0; i < pixels; i++)
+          dst[i] = src[i];
+      }
+      else
+      {
+        for (int i = 0; i < pixels; i++)
+          dst[i] = imgdata.color.curve[src[i]];
+      }
+      S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ttShort);
+    }
+    else
+    {
+      // Alloc
+      if ((imgdata.rawparams.options & LIBRAW_RAWOPTIONS_DNGSDK_ZEROCOPY) && !stage23used)
+      {
+        zerocopy = true;
+      }
+      else
+      {
+        imgdata.rawdata.raw_alloc = malloc(pixels * TagTypeSize(ptype));
+        memmove(imgdata.rawdata.raw_alloc, buffer.fData,
+                pixels * TagTypeSize(ptype));
+      }
+      S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ptype);
+    }
+
+    if (stage23used)
+        stage2.Release();
+
+    if ((ptype == ttFloat) && (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CONVERTFLOAT_TO_INT))
+        zerocopy = true;
+
+    if (zerocopy)
+    {
+      switch (ptype)
+      {
+      case ttFloat:
+        if (pplanes == 1)
+          imgdata.rawdata.float_image = (float *)buffer.fData;
+        else if (pplanes == 3)
+          imgdata.rawdata.float3_image = (float(*)[3])buffer.fData;
+        else if (pplanes == 4)
+          imgdata.rawdata.float4_image = (float(*)[4])buffer.fData;
+        break;
+
+      case ttShort:
+        if (pplanes == 1)
+          imgdata.rawdata.raw_image = (ushort *)buffer.fData;
+        else if (pplanes == 3)
+          imgdata.rawdata.color3_image = (ushort(*)[3])buffer.fData;
+        else if (pplanes == 4)
+          imgdata.rawdata.color4_image = (ushort(*)[4])buffer.fData;
+        break;
+      default:
+        /* do nothing */
+        break;
+      }
+    }
+    else
+    {
+      switch (ptype)
+      {
+      case ttFloat:
+        if (pplanes == 1)
+          imgdata.rawdata.float_image = (float *)imgdata.rawdata.raw_alloc;
+        else if (pplanes == 3)
+          imgdata.rawdata.float3_image = (float(*)[3])imgdata.rawdata.raw_alloc;
+        else if (pplanes == 4)
+          imgdata.rawdata.float4_image = (float(*)[4])imgdata.rawdata.raw_alloc;
+        break;
+
+      case ttByte:
+      case ttShort:
+        if (pplanes == 1)
+          imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc;
+        else if (pplanes == 3)
+          imgdata.rawdata.color3_image =
+              (ushort(*)[3])imgdata.rawdata.raw_alloc;
+        else if (pplanes == 4)
+          imgdata.rawdata.color4_image =
+              (ushort(*)[4])imgdata.rawdata.raw_alloc;
+        break;
+      default:
+        /* do nothing */
+        break;
+      }
+    }
+
+    if ((ptype == ttFloat) && (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_CONVERTFLOAT_TO_INT))
+    {
+        convertFloatToInt();
+        zerocopy = false;
+    }
+
+    if (zerocopy)
+    {
+      dng_negative *stolen = negative.Release();
+      dngnegative = stolen;
+      dng_simple_image *simage = stage2.Release();
+      dngimage = simage;
+    }
+  }
+  catch (...)
+  {
+    return LIBRAW_UNSPECIFIED_ERROR;
+  }
+  
+  return (dngnegative || imgdata.rawdata.raw_alloc) ? LIBRAW_SUCCESS : LIBRAW_UNSPECIFIED_ERROR;
+#else
+  return LIBRAW_UNSPECIFIED_ERROR;
+#endif
+}
+void LibRaw::set_dng_host(void *p)
+{
+#ifdef USE_DNGSDK
+  dnghost = p;
+#endif
+}

package/deps/LibRaw-Win64/LibRaw-0.21.4/src/integration/rawspeed_glue.cpp

@@ -0,0 +1,286 @@
+/* -*- C++ -*-
+ * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
+ *
+ 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/libraw_cxx_defs.h"
+
+#ifdef USE_RAWSPEED
+using namespace RawSpeed;
+
+CameraMetaDataLR::CameraMetaDataLR(char *data, int sz) : CameraMetaData()
+{
+  ctxt = xmlNewParserCtxt();
+  if (ctxt == NULL)
+  {
+    ThrowCME("CameraMetaData:Could not initialize context.");
+  }
+
+  xmlResetLastError();
+  doc = xmlCtxtReadMemory(ctxt, data, sz, "", NULL, XML_PARSE_DTDVALID);
+
+  if (doc == NULL)
+  {
+    ThrowCME("CameraMetaData: XML Document could not be parsed successfully. "
+             "Error was: %s",
+             ctxt->lastError.message);
+  }
+
+  if (ctxt->valid == 0)
+  {
+    if (ctxt->lastError.code == 0x5e)
+    {
+      // ignore this error code
+    }
+    else
+    {
+      ThrowCME("CameraMetaData: XML file does not validate. DTD Error was: %s",
+               ctxt->lastError.message);
+    }
+  }
+
+  xmlNodePtr cur;
+  cur = xmlDocGetRootElement(doc);
+  if (xmlStrcmp(cur->name, (const xmlChar *)"Cameras"))
+  {
+    ThrowCME("CameraMetaData: XML document of the wrong type, root node is not "
+             "cameras.");
+    return;
+  }
+
+  cur = cur->xmlChildrenNode;
+  while (cur != NULL)
+  {
+    if ((!xmlStrcmp(cur->name, (const xmlChar *)"Camera")))
+    {
+      Camera *camera = new Camera(doc, cur);
+      addCamera(camera);
+
+      // Create cameras for aliases.
+      for (unsigned int i = 0; i < camera->aliases.size(); i++)
+      {
+        addCamera(new Camera(camera, i));
+      }
+    }
+    cur = cur->next;
+  }
+  if (doc)
+    xmlFreeDoc(doc);
+  doc = 0;
+  if (ctxt)
+    xmlFreeParserCtxt(ctxt);
+  ctxt = 0;
+}
+
+CameraMetaDataLR *make_camera_metadata()
+{
+  int len = 0, i;
+  for (i = 0; i < RAWSPEED_DATA_COUNT; i++)
+    if (_rawspeed_data_xml[i])
+    {
+      len += int(strlen(_rawspeed_data_xml[i]));
+    }
+  char *rawspeed_xml =
+      (char *)calloc(len + 1, sizeof(_rawspeed_data_xml[0][0]));
+  if (!rawspeed_xml)
+    return NULL;
+  int offt = 0;
+  for (i = 0; i < RAWSPEED_DATA_COUNT; i++)
+    if (_rawspeed_data_xml[i])
+    {
+      int ll = int(strlen(_rawspeed_data_xml[i]));
+      if (offt + ll > len)
+        break;
+      memmove(rawspeed_xml + offt, _rawspeed_data_xml[i], ll);
+      offt += ll;
+    }
+  rawspeed_xml[offt] = 0;
+  CameraMetaDataLR *ret = NULL;
+  try
+  {
+    ret = new CameraMetaDataLR(rawspeed_xml, offt);
+  }
+  catch (...)
+  {
+    // Mask all exceptions
+  }
+  free(rawspeed_xml);
+  return ret;
+}
+
+#endif
+
+int LibRaw::set_rawspeed_camerafile(char * filename)
+{
+#ifdef USE_RAWSPEED
+  try
+  {
+    CameraMetaDataLR *camerameta = new CameraMetaDataLR(filename);
+    if (_rawspeed_camerameta)
+    {
+      CameraMetaDataLR *d =
+          static_cast<CameraMetaDataLR *>(_rawspeed_camerameta);
+      delete d;
+    }
+    _rawspeed_camerameta = static_cast<void *>(camerameta);
+  }
+  catch (...)
+  {
+    // just return error code
+    return -1;
+  }
+#else
+    (void)filename;
+#endif
+  return 0;
+}
+#ifdef USE_RAWSPEED
+void LibRaw::fix_after_rawspeed(int /*bl*/)
+{
+  if (load_raw == &LibRaw::lossy_dng_load_raw)
+    C.maximum = 0xffff;
+  else if (load_raw == &LibRaw::sony_load_raw)
+    C.maximum = 0x3ff0;
+}
+#else
+void LibRaw::fix_after_rawspeed(int) {}
+#endif
+
+int LibRaw::try_rawspeed()
+{
+#ifdef USE_RAWSPEED
+  int ret = LIBRAW_SUCCESS;
+
+#ifdef USE_RAWSPEED_BITS
+  int rawspeed_ignore_errors = (imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV1_IGNOREERRORS);
+#else
+  int rawspeed_ignore_errors = 0;
+#endif
+  if (imgdata.idata.dng_version && imgdata.idata.colors == 3 &&
+      !strcasecmp(imgdata.idata.software,
+                  "Adobe Photoshop Lightroom 6.1.1 (Windows)"))
+    rawspeed_ignore_errors = 1;
+
+  // RawSpeed Supported,
+  INT64 spos = ID.input->tell();
+  void *_rawspeed_buffer = 0;
+  try
+  {
+    ID.input->seek(0, SEEK_SET);
+    INT64 _rawspeed_buffer_sz = ID.input->size() + 32;
+    _rawspeed_buffer = malloc(_rawspeed_buffer_sz);
+    if (!_rawspeed_buffer)
+      throw LIBRAW_EXCEPTION_ALLOC;
+    ID.input->read(_rawspeed_buffer, _rawspeed_buffer_sz, 1);
+    FileMap map((uchar8 *)_rawspeed_buffer, _rawspeed_buffer_sz);
+    RawParser t(&map);
+    RawDecoder *d = 0;
+    CameraMetaDataLR *meta =
+        static_cast<CameraMetaDataLR *>(_rawspeed_camerameta);
+    d = t.getDecoder();
+    if (!d)
+      throw "Unable to find decoder";
+
+#ifdef USE_RAWSPEED_BITS
+    if (imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV1_FAILONUNKNOWN)
+      d->failOnUnknown = TRUE;
+    else
+        d->failOnUnknown = FALSE;
+#endif
+    d->interpolateBadPixels = FALSE;
+    d->applyStage1DngOpcodes = FALSE;
+
+    try
+    {
+      d->checkSupport(meta);
+    }
+    catch (const RawDecoderException &e)
+    {
+      imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_UNSUPPORTED;
+      throw e;
+    }
+    _rawspeed_decoder = static_cast<void *>(d);
+    d->decodeRaw();
+    d->decodeMetaData(meta);
+    RawImage r = d->mRaw;
+    if (r->errors.size() > 0 && !rawspeed_ignore_errors)
+    {
+      delete d;
+      _rawspeed_decoder = 0;
+      throw 1;
+    }
+    if (r->isCFA)
+    {
+      imgdata.rawdata.raw_image = (ushort *)r->getDataUncropped(0, 0);
+    }
+    else if (r->getCpp() == 4)
+    {
+      imgdata.rawdata.color4_image = (ushort(*)[4])r->getDataUncropped(0, 0);
+      if (r->whitePoint > 0 && r->whitePoint < 65536)
+        C.maximum = r->whitePoint;
+    }
+    else if (r->getCpp() == 3)
+    {
+      imgdata.rawdata.color3_image = (ushort(*)[3])r->getDataUncropped(0, 0);
+      if (r->whitePoint > 0 && r->whitePoint < 65536)
+        C.maximum = r->whitePoint;
+    }
+    else
+    {
+      delete d;
+      _rawspeed_decoder = 0;
+      ret = LIBRAW_UNSPECIFIED_ERROR;
+    }
+    if (_rawspeed_decoder)
+    {
+      // set sizes
+      iPoint2D rsdim = r->getUncroppedDim();
+      S.raw_pitch = r->pitch;
+      S.raw_width = rsdim.x;
+      S.raw_height = rsdim.y;
+      // C.maximum = r->whitePoint;
+      fix_after_rawspeed(r->blackLevel);
+    }
+    free(_rawspeed_buffer);
+    _rawspeed_buffer = 0;
+    imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROCESSED;
+  }
+  catch (const RawDecoderException &RDE)
+  {
+    imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROBLEM;
+    if (_rawspeed_buffer)
+    {
+      free(_rawspeed_buffer);
+      _rawspeed_buffer = 0;
+    }
+    if (!strncmp(RDE.what(), "Decoder canceled", strlen("Decoder canceled")))
+      throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
+    ret = LIBRAW_UNSPECIFIED_ERROR;
+  }
+  catch (...)
+  {
+    // We may get here due to cancellation flag
+    imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROBLEM;
+    if (_rawspeed_buffer)
+    {
+      free(_rawspeed_buffer);
+      _rawspeed_buffer = 0;
+    }
+    ret = LIBRAW_UNSPECIFIED_ERROR;
+  }
+  ID.input->seek(spos, SEEK_SET);
+
+  return ret;
+#else
+  return LIBRAW_NOT_IMPLEMENTED;
+#endif
+}