| /* -*- C++ -*- |
| * Copyright 2019-2025 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 "third_party/libraw/internal/libraw_cameraids.h" |
| #include "third_party/libraw/internal/libraw_cxx_defs.h" |
| |
| #ifdef USE_RAWSPEED3 |
| #include "rawspeed3_capi.h" |
| #include <array> |
| #endif |
| |
| int LibRaw::unpack(void) |
| { |
| CHECK_ORDER_HIGH(LIBRAW_PROGRESS_LOAD_RAW); |
| CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY); |
| try |
| { |
| |
| if (!libraw_internal_data.internal_data.input) |
| return LIBRAW_INPUT_CLOSED; |
| |
| RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW, 0, 2); |
| if (imgdata.rawparams.shot_select >= P1.raw_count) |
| return LIBRAW_REQUEST_FOR_NONEXISTENT_IMAGE; |
| |
| if (!load_raw) |
| return LIBRAW_UNSPECIFIED_ERROR; |
| |
| // already allocated ? |
| if (imgdata.image) |
| { |
| free(imgdata.image); |
| imgdata.image = 0; |
| } |
| if (imgdata.rawdata.raw_alloc) |
| { |
| free(imgdata.rawdata.raw_alloc); |
| imgdata.rawdata.raw_alloc = 0; |
| } |
| if (libraw_internal_data.unpacker_data.meta_length) |
| { |
| if (libraw_internal_data.unpacker_data.meta_length > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| libraw_internal_data.internal_data.meta_data = |
| #ifdef LIBRAW_CALLOC_RAWSTORE |
| (char *)calloc(libraw_internal_data.unpacker_data.meta_length,1); |
| #else |
| (char *)malloc(libraw_internal_data.unpacker_data.meta_length); |
| #endif |
| } |
| |
| libraw_decoder_info_t decoder_info; |
| get_decoder_info(&decoder_info); |
| |
| int save_iwidth = S.iwidth, save_iheight = S.iheight, |
| save_shrink = IO.shrink; |
| |
| int rwidth = S.raw_width, rheight = S.raw_height; |
| if (!IO.fuji_width) |
| { |
| // adjust non-Fuji allocation |
| if (rwidth < S.width + S.left_margin) |
| rwidth = S.width + S.left_margin; |
| if (rheight < S.height + S.top_margin) |
| rheight = S.height + S.top_margin; |
| } |
| if (rwidth > 65535 || |
| rheight > 65535) // No way to make image larger than 64k pix |
| throw LIBRAW_EXCEPTION_IO_CORRUPT; |
| |
| imgdata.rawdata.raw_image = 0; |
| imgdata.rawdata.color4_image = 0; |
| imgdata.rawdata.color3_image = 0; |
| imgdata.rawdata.float_image = 0; |
| imgdata.rawdata.float3_image = 0; |
| |
| #ifdef USE_DNGSDK |
| if (imgdata.idata.dng_version && dnghost |
| && libraw_internal_data.unpacker_data.tiff_samples != 2 // Fuji SuperCCD; it is better to detect is more rigid way |
| && valid_for_dngsdk() && load_raw != &LibRaw::pentax_4shot_load_raw) |
| { |
| // Data size check |
| INT64 pixcount = |
| INT64(MAX(S.width, S.raw_width)) * INT64(MAX(S.height, S.raw_height)); |
| INT64 planecount = |
| (imgdata.idata.filters || P1.colors == 1) ? 1 : LIM(P1.colors, 3, 4); |
| INT64 samplesize = is_floating_point() ? 4 : 2; |
| INT64 bytes = pixcount * planecount * samplesize; |
| if (bytes + INT64(libraw_internal_data.unpacker_data.meta_length ) |
| > INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| // find ifd to check sample |
| try_dngsdk(); |
| if (raw_was_read()) |
| imgdata.process_warnings |= LIBRAW_WARN_DNGSDK_PROCESSED; |
| } |
| #endif |
| #ifdef USE_RAWSPEED3 |
| if (!raw_was_read() |
| && ID.input->size() < 2147483615LL |
| && (!IO.fuji_width) // Do not use for fuji rotated |
| && ((imgdata.idata.raw_count == 1) |
| // Canon dual pixel, 1st frame |
| || (makeIs(LIBRAW_CAMERAMAKER_Canon) && imgdata.idata.raw_count == 2 && imgdata.rawparams.shot_select==0) |
| ) |
| #ifdef USE_RAWSPEED_BITS |
| && (imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV3_USE) |
| #else |
| && imgdata.rawparams.use_rawspeed |
| #endif |
| && (decoder_info.decoder_flags & LIBRAW_DECODER_TRYRAWSPEED3) |
| ) |
| { |
| INT64 pixcount = INT64(MAX(S.width, S.raw_width)) * INT64(MAX(S.height, S.raw_height)); |
| INT64 planecount = (imgdata.idata.filters || P1.colors == 1) ? 1 : LIM(P1.colors, 3, 4); |
| INT64 bytes = pixcount * planecount * 2; // sample size is always 2 for rawspeed |
| if (bytes + INT64(libraw_internal_data.unpacker_data.meta_length) |
| > INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| if (!_rawspeed3_handle) |
| _rawspeed3_handle = rawspeed3_initdefault(); |
| |
| if (_rawspeed3_handle && ID.input->size() > 0) // large bound is checked at identify |
| { |
| 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, ID.input->size(), 1); |
| |
| rawspeed3_ret_t rs3ret; |
| rawspeed3_clearresult(&rs3ret); |
| int status = rawspeed3_decodefile(_rawspeed3_handle, &rs3ret, _rawspeed_buffer, ID.input->size(), |
| #ifdef USE_RAWSPEED_BITS |
| !(imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV3_FAILONUNKNOWN) |
| #else |
| false |
| #endif |
| ); |
| if (status != rawspeed3_ok) |
| imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_UNSUPPORTED; |
| |
| if (status == rawspeed3_not_supported) |
| imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED3_NOTLISTED; |
| |
| if (status == rawspeed3_ok |
| #ifdef USE_RAWSPEED_BITS |
| || |
| (status == rawspeed3_ok_warnings && (imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV3_IGNOREERRORS)) |
| #endif |
| ) |
| { |
| |
| if ((S.raw_width != rs3ret.width) || (S.raw_height != rs3ret.height)) |
| throw "Size mismatch"; |
| |
| // DECODED w/ success |
| if (rs3ret.cpp == 4) |
| { |
| imgdata.rawdata.color4_image = (ushort(*)[4])rs3ret.pixeldata; |
| //if (r->whitePoint > 0 && r->whitePoint < 65536) |
| // C.maximum = r->whitePoint; |
| } |
| else if (rs3ret.cpp == 3) |
| { |
| imgdata.rawdata.color3_image = (ushort(*)[3])rs3ret.pixeldata; |
| //if (r->whitePoint > 0 && r->whitePoint < 65536) |
| // C.maximum = r->whitePoint; |
| } |
| else if (rs3ret.cpp == 1 && rs3ret.filters > 1) // Fuji or bayer |
| { |
| imgdata.rawdata.raw_image = (ushort *)rs3ret.pixeldata; |
| } |
| |
| if (raw_was_read()) // buffers are assigned above |
| { |
| // set sizes |
| S.raw_pitch = rs3ret.pitch; |
| S.raw_width = rs3ret.width; |
| S.raw_height = rs3ret.height; |
| imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED3_PROCESSED; |
| |
| if (imgdata.rawdata.raw_image && |
| load_raw == &LibRaw::phase_one_load_raw_c && imgdata.color.phase_one_data.format != 8) |
| { |
| // Scale data to match libraw own decoder |
| for (unsigned row = 0; row < rs3ret.height; row++) |
| for (unsigned col = 0; col < rs3ret.pitch / 2; col++) |
| imgdata.rawdata.raw_image[row * rs3ret.pitch / 2 + col] <<= 2; |
| } |
| |
| // if (r->whitePoint > 0 && r->whitePoint < 65536) |
| // C.maximum = r->whitePoint; |
| } |
| } |
| free(_rawspeed_buffer); |
| } |
| catch (...) |
| { |
| imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED3_PROBLEM; |
| if (_rawspeed_buffer) |
| free(_rawspeed_buffer); |
| } |
| } |
| } |
| #endif |
| #ifdef USE_RAWSPEED |
| if (!raw_was_read() && ID.input->size() < 2147483615LL) |
| { |
| int rawspeed_enabled = 1; |
| |
| if (imgdata.idata.dng_version && (libraw_internal_data.unpacker_data.tiff_samples == 2 || imgdata.idata.raw_count > 1)) |
| rawspeed_enabled = 0; |
| |
| if (libraw_internal_data.unpacker_data.is_NikonTransfer) |
| rawspeed_enabled = 0; |
| |
| if (libraw_internal_data.unpacker_data.pana_encoding == 5) |
| rawspeed_enabled = 0; |
| |
| if (imgdata.idata.raw_count > 1) |
| rawspeed_enabled = 0; |
| if (!strncasecmp(imgdata.idata.software, "Magic", 5)) |
| rawspeed_enabled = 0; |
| // Disable rawspeed for double-sized Oly files |
| if (makeIs(LIBRAW_CAMERAMAKER_Olympus) && |
| ((imgdata.sizes.raw_width > 6000) || |
| !strncasecmp(imgdata.idata.model, "SH-", 3) || |
| !strncasecmp(imgdata.idata.model, "TG-", 3) )) |
| rawspeed_enabled = 0; |
| |
| if (makeIs(LIBRAW_CAMERAMAKER_Canon) && |
| (libraw_internal_data.identify_data.unique_id == CanonID_EOS_6D_Mark_II)) |
| rawspeed_enabled = 0; |
| |
| if (imgdata.idata.dng_version && imgdata.idata.filters == 0 && |
| libraw_internal_data.unpacker_data.tiff_bps == 8) // Disable for 8 bit |
| rawspeed_enabled = 0; |
| |
| if (load_raw == &LibRaw::packed_load_raw && |
| makeIs(LIBRAW_CAMERAMAKER_Nikon) && |
| (!strncasecmp(imgdata.idata.model, "E", 1) || |
| !strncasecmp(imgdata.idata.model, "COOLPIX B", 9) || |
| !strncasecmp(imgdata.idata.model, "COOLPIX P9", 10) || |
| !strncasecmp(imgdata.idata.model, "COOLPIX P1000", 13))) |
| rawspeed_enabled = 0; |
| |
| if (load_raw == &LibRaw::nikon_load_raw && makeIs(LIBRAW_CAMERAMAKER_Nikon) && |
| !strcasecmp(imgdata.idata.model, "D6")) |
| rawspeed_enabled = 0; |
| |
| if (load_raw == &LibRaw::lossless_jpeg_load_raw && |
| MN.canon.RecordMode && makeIs(LIBRAW_CAMERAMAKER_Kodak) && |
| /* Not normalized models here, it is intentional */ |
| (!strncasecmp(imgdata.idata.model, "EOS D2000", 9) || |
| !strncasecmp(imgdata.idata.model, "EOS D6000", 9))) |
| rawspeed_enabled = 0; |
| |
| if (load_raw == &LibRaw::nikon_load_raw && |
| makeIs(LIBRAW_CAMERAMAKER_Nikon) && |
| (!strncasecmp(imgdata.idata.model, "Z", 1) || !strncasecmp(imgdata.idata.model,"D780",4))) |
| rawspeed_enabled = 0; |
| |
| if (load_raw == &LibRaw::panasonic_load_raw && |
| libraw_internal_data.unpacker_data.pana_encoding > 4) |
| rawspeed_enabled = 0; |
| |
| // RawSpeed Supported, |
| if ( |
| #ifdef USE_RAWSPEED_BITS |
| (imgdata.rawparams.use_rawspeed & LIBRAW_RAWSPEEDV1_USE) |
| #else |
| imgdata.rawparams.use_rawspeed |
| #endif |
| && rawspeed_enabled && |
| !(is_sraw() && (imgdata.rawparams.specials & |
| (LIBRAW_RAWSPECIAL_SRAW_NO_RGB | |
| LIBRAW_RAWSPECIAL_SRAW_NO_INTERPOLATE))) && |
| (decoder_info.decoder_flags & LIBRAW_DECODER_TRYRAWSPEED) && |
| _rawspeed_camerameta) |
| { |
| INT64 pixcount = INT64(MAX(S.width, S.raw_width)) * |
| INT64(MAX(S.height, S.raw_height)); |
| INT64 planecount = (imgdata.idata.filters || P1.colors == 1) |
| ? 1 |
| : LIM(P1.colors, 3, 4); |
| INT64 bytes = |
| pixcount * planecount * 2; // sample size is always 2 for rawspeed |
| if (bytes + +INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| /*int rr = */ try_rawspeed(); |
| |
| } |
| } |
| #endif |
| if (!raw_was_read()) // RawSpeed failed or not run |
| { |
| // Not allocated on RawSpeed call, try call LibRaow |
| int zero_rawimage = 0; |
| if (decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC) |
| { |
| // x3f foveon decoder and DNG float |
| // Do nothing! Decoder will allocate data internally |
| } |
| else if (decoder_info.decoder_flags & LIBRAW_DECODER_SINAR4SHOT) |
| { |
| if (imgdata.rawparams.shot_select) // single image extract |
| { |
| if (INT64(rwidth) * INT64(rheight + 8) * |
| INT64(sizeof(imgdata.rawdata.raw_image[0])) |
| + +INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| #ifdef LIBRAW_CALLOC_RAWSTORE |
| imgdata.rawdata.raw_alloc = calloc(size_t(rwidth) * (size_t(rheight) + 8), sizeof(imgdata.rawdata.raw_image[0])); |
| #else |
| imgdata.rawdata.raw_alloc = malloc( |
| size_t(rwidth) * (size_t(rheight) + 8) * sizeof(imgdata.rawdata.raw_image[0])); |
| #endif |
| imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc; |
| if (!S.raw_pitch) |
| S.raw_pitch = S.raw_width * 2; // Bayer case, not set before |
| } |
| else // Full image extract |
| { |
| if (INT64(rwidth) * INT64(rheight + 8) * |
| INT64(sizeof(imgdata.rawdata.raw_image[0])) * 4 |
| +INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| S.raw_pitch = S.raw_width * 8; |
| imgdata.rawdata.raw_alloc = 0; |
| #ifdef LIBRAW_CALLOC_RAWSTORE |
| imgdata.image = (ushort(*)[4])calloc( |
| size_t(MAX(S.width, S.raw_width)) * |
| (size_t(MAX(S.height, S.raw_height)) + 8), |
| sizeof(*imgdata.image)); |
| #else |
| imgdata.image = (ushort(*)[4])malloc( |
| size_t(MAX(S.width, S.raw_width)) * (size_t(MAX(S.height, S.raw_height)) + 8) * sizeof(*imgdata.image)); |
| #endif |
| } |
| } |
| else if (decoder_info.decoder_flags & LIBRAW_DECODER_3CHANNEL) |
| { |
| if (INT64(rwidth) * INT64(rheight + 8) * |
| INT64(sizeof(imgdata.rawdata.raw_image[0])) * 3 |
| + INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| #ifdef LIBRAW_CALLOC_RAWSTORE |
| imgdata.rawdata.raw_alloc = |
| calloc(size_t(rwidth) * (size_t(rheight) + 8), sizeof(imgdata.rawdata.raw_image[0]) * 3); |
| #else |
| imgdata.rawdata.raw_alloc = malloc( |
| size_t(rwidth) * (size_t(rheight) + 8) * sizeof(imgdata.rawdata.raw_image[0]) * 3); |
| #endif |
| imgdata.rawdata.color3_image = (ushort(*)[3])imgdata.rawdata.raw_alloc; |
| if (!S.raw_pitch) |
| S.raw_pitch = S.raw_width * 6; |
| } |
| else if (imgdata.idata.filters || |
| P1.colors == |
| 1) // Bayer image or single color -> decode to raw_image |
| { |
| if (INT64(rwidth) * INT64(rheight + 8) * |
| INT64(sizeof(imgdata.rawdata.raw_image[0])) |
| + INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| #ifdef LIBRAW_CALLOC_RAWSTORE |
| imgdata.rawdata.raw_alloc = |
| calloc(size_t(rwidth) * (size_t(rheight) + 8),sizeof(imgdata.rawdata.raw_image[0])); |
| #else |
| imgdata.rawdata.raw_alloc = malloc( |
| size_t(rwidth) * (size_t(rheight) + 8) * sizeof(imgdata.rawdata.raw_image[0])); |
| #endif |
| imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc; |
| if (!S.raw_pitch) |
| S.raw_pitch = S.raw_width * 2; // Bayer case, not set before |
| } |
| else // NO LEGACY FLAG if (decoder_info.decoder_flags & |
| // LIBRAW_DECODER_LEGACY) |
| { |
| if (decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL) |
| { |
| S.raw_pitch = S.raw_width * 8; |
| } |
| else |
| { |
| S.iwidth = S.width; |
| S.iheight = S.height; |
| IO.shrink = 0; |
| if (!S.raw_pitch) |
| S.raw_pitch = (decoder_info.decoder_flags & |
| LIBRAW_DECODER_LEGACY_WITH_MARGINS) |
| ? S.raw_width * 8 |
| : S.width * 8; |
| } |
| // sRAW and old Foveon decoders only, so extra buffer size is just 1/4 |
| // allocate image as temporary buffer, size |
| if (INT64(MAX(S.width, S.raw_width)) * |
| INT64(MAX(S.height, S.raw_height) + 8) * |
| INT64(sizeof(*imgdata.image)) |
| + INT64(libraw_internal_data.unpacker_data.meta_length) > |
| INT64(imgdata.rawparams.max_raw_memory_mb) * INT64(1024 * 1024)) |
| throw LIBRAW_EXCEPTION_TOOBIG; |
| |
| imgdata.rawdata.raw_alloc = 0; |
| imgdata.image = |
| (ushort(*)[4])calloc(unsigned(MAX(S.width, S.raw_width)) * |
| unsigned(MAX(S.height, S.raw_height) + 8), |
| sizeof(*imgdata.image)); |
| if (!(decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL)) |
| { |
| imgdata.rawdata.raw_image = (ushort *)imgdata.image; |
| zero_rawimage = 1; |
| } |
| } |
| ID.input->seek(libraw_internal_data.unpacker_data.data_offset, SEEK_SET); |
| |
| unsigned m_save = C.maximum; |
| if (load_raw == &LibRaw::unpacked_load_raw && |
| (!strcasecmp(imgdata.idata.make, "Nikon") || !strcasecmp(imgdata.idata.make, "Hasselblad")) |
| ) |
| C.maximum = 65535; |
| (this->*load_raw)(); |
| if (zero_rawimage) |
| imgdata.rawdata.raw_image = 0; |
| if (load_raw == &LibRaw::unpacked_load_raw && |
| (!strcasecmp(imgdata.idata.make, "Nikon") || !strcasecmp(imgdata.idata.make, "Hasselblad")) |
| ) |
| C.maximum = m_save; |
| if (decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC) |
| { |
| // x3f foveon decoder only: do nothing |
| } |
| else if (decoder_info.decoder_flags & LIBRAW_DECODER_SINAR4SHOT && |
| imgdata.rawparams.shot_select == 0) |
| { |
| imgdata.rawdata.raw_alloc = imgdata.image; |
| imgdata.rawdata.color4_image = (ushort(*)[4])imgdata.rawdata.raw_alloc; |
| imgdata.image = 0; |
| } |
| else if (!(imgdata.idata.filters || |
| P1.colors == 1)) // legacy decoder, ownalloc handled above |
| { |
| // successfully decoded legacy image, attach image to raw_alloc |
| imgdata.rawdata.raw_alloc = imgdata.image; |
| imgdata.rawdata.color4_image = (ushort(*)[4])imgdata.rawdata.raw_alloc; |
| imgdata.image = 0; |
| // Restore saved values. Note: Foveon have masked frame |
| // Other 4-color legacy data: no borders |
| if (!(libraw_internal_data.unpacker_data.load_flags & 256) && |
| !(decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL) && |
| !(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY_WITH_MARGINS)) |
| { |
| S.raw_width = S.width; |
| S.left_margin = 0; |
| S.raw_height = S.height; |
| S.top_margin = 0; |
| } |
| } |
| } |
| |
| if (imgdata.rawdata.raw_image) |
| crop_masked_pixels(); // calculate black levels |
| |
| // recover image sizes |
| S.iwidth = save_iwidth; |
| S.iheight = save_iheight; |
| IO.shrink = save_shrink; |
| |
| // adjust black to possible maximum |
| unsigned int i = C.cblack[3]; |
| unsigned int c; |
| for (c = 0; c < 3; c++) |
| if (i > C.cblack[c]) |
| i = C.cblack[c]; |
| for (c = 0; c < 4; c++) |
| C.cblack[c] -= i; |
| C.black += i; |
| |
| // Save color,sizes and internal data into raw_image fields |
| memmove(&imgdata.rawdata.color, &imgdata.color, sizeof(imgdata.color)); |
| memmove(&imgdata.rawdata.sizes, &imgdata.sizes, sizeof(imgdata.sizes)); |
| memmove(&imgdata.rawdata.iparams, &imgdata.idata, sizeof(imgdata.idata)); |
| memmove(&imgdata.rawdata.ioparams, |
| &libraw_internal_data.internal_output_params, |
| sizeof(libraw_internal_data.internal_output_params)); |
| |
| SET_PROC_FLAG(LIBRAW_PROGRESS_LOAD_RAW); |
| RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW, 1, 2); |
| |
| return 0; |
| } |
| catch (const std::bad_alloc&) |
| { |
| EXCEPTION_HANDLER(LIBRAW_EXCEPTION_ALLOC); |
| } |
| catch (const LibRaw_exceptions& err) |
| { |
| EXCEPTION_HANDLER(err); |
| } |
| catch (const std::exception& ) |
| { |
| EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT); |
| } |
| } |
