| /* -*- 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/dcraw_defs.h" |
| |
| |
| static libraw_area_t sget_CanonArea(uchar *s) { |
| libraw_area_t la = {}; |
| la.l = s[0] << 8 | s[1]; |
| la.t = s[2] << 8 | s[3]; |
| la.r = s[4] << 8 | s[5]; |
| la.b = s[6] << 8 | s[7]; |
| return la; |
| } |
| |
| int LibRaw::selectCRXFrame(short trackNum, unsigned frameIndex) |
| { |
| uint32_t sample_size; |
| uint32_t stsc_index = 0; |
| uint32_t current_sample = 0; |
| crx_data_header_t *hdr = &libraw_internal_data.unpacker_data.crx_header[trackNum]; |
| |
| if (frameIndex >= hdr->sample_count) |
| return -1; |
| |
| for (unsigned i = 0; i < hdr->chunk_count; i++) |
| { |
| int64_t current_offset = hdr->chunk_offsets[i]; |
| |
| while((stsc_index < hdr->stsc_count) && (i+1 == hdr->stsc_data[stsc_index+1].first)) |
| stsc_index++; |
| |
| for (unsigned j = 0; j < hdr->stsc_data[stsc_index].count; j++) |
| { |
| if (current_sample > hdr->sample_count) |
| return -1; |
| |
| sample_size = hdr->sample_size > 0 ? hdr->sample_size : hdr->sample_sizes[current_sample]; |
| if(current_sample == frameIndex) |
| { |
| hdr->MediaOffset = current_offset; |
| hdr->MediaSize = sample_size; |
| return 0; |
| } |
| current_offset += sample_size; |
| current_sample++; |
| } |
| } |
| return -1; |
| } |
| |
| void LibRaw::selectCRXTrack() |
| { |
| short maxTrack = libraw_internal_data.unpacker_data.crx_track_count; |
| if (maxTrack < 0) |
| return; |
| |
| INT64 bitcounts[LIBRAW_CRXTRACKS_MAXCOUNT], maxbitcount = 0; |
| int framecounts[LIBRAW_CRXTRACKS_MAXCOUNT]; |
| uint32_t maxjpegbytes = 0; |
| int framecnt = 0; |
| int media_tracks = 0; |
| int track_select = 0; |
| int frame_select = 0; |
| memset(bitcounts, 0, sizeof(bitcounts)); |
| memset(framecounts, 0, sizeof(framecounts)); |
| |
| // Calc max frame bitcount for max-sized RAW track(s) selection |
| for (int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) |
| { |
| crx_data_header_t *d = &libraw_internal_data.unpacker_data.crx_header[i]; |
| if (d->MediaType == 1) // RAW |
| { |
| bitcounts[i] = INT64(d->nBits) * INT64(d->f_width) * INT64(d->f_height); |
| maxbitcount = MAX(bitcounts[i], maxbitcount); |
| if (d->sample_count > 1) |
| framecounts[i] = d->sample_count; |
| } |
| } |
| |
| if (maxbitcount < 8) // no raw tracks |
| return; |
| |
| // Calc RAW tracks and frames |
| for (int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) |
| { |
| if (bitcounts[i] == maxbitcount) |
| { |
| media_tracks++; |
| if (framecounts[i] > 1) |
| framecnt = MAX(framecnt, framecounts[i]); |
| } |
| } |
| |
| // If the file has only 1 media track shot_select represents frames select. |
| // If the file has multiple media tracks shot_select represents track select. |
| // If the file has multiple media tracks and multiple frames it is currently unsupported. |
| |
| if (framecnt && media_tracks > 1) |
| return; |
| else if (framecnt) |
| frame_select = shot_select; |
| else |
| track_select = shot_select; |
| |
| int tracki = -1; |
| for (int i = 0, trackcnt = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) |
| { |
| if (bitcounts[i] == maxbitcount) |
| { |
| if (trackcnt <= (int)track_select) |
| tracki = i; |
| trackcnt++; |
| } |
| } |
| |
| if (tracki >= 0 && tracki < LIBRAW_CRXTRACKS_MAXCOUNT /* && frame_select > 0 */) |
| { |
| framecnt = framecounts[tracki]; // Update to selected track |
| frame_select = LIM(frame_select, 0, framecnt); |
| if(frame_select > 0) |
| if (selectCRXFrame(tracki, frame_select)) |
| return; |
| } |
| else |
| return; // No RAW track index |
| |
| int ctmdcount = 0; |
| // Frame selected: parse CTMD metadata |
| for (int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) |
| { |
| crx_data_header_t *d = &libraw_internal_data.unpacker_data.crx_header[i]; |
| int fsel = LIM(frame_select, 0, int(d->sample_count)); |
| if (d->MediaType == 3) // CTMD metadata |
| { |
| /* ignore errors !*/ |
| if (fsel) |
| selectCRXFrame(i, fsel); |
| parseCR3_CTMD(i); |
| ctmdcount++; |
| } |
| else if (d->MediaType == 2) // JPEG |
| { |
| if (fsel) |
| selectCRXFrame(i, fsel); |
| if (d->MediaSize > maxjpegbytes) |
| { |
| maxjpegbytes = d->MediaSize; |
| thumb_offset = d->MediaOffset; |
| thumb_length = d->MediaSize; |
| if (imgdata.thumbs_list.thumbcount < LIBRAW_THUMBNAIL_MAXCOUNT) |
| { |
| bool do_add = true; |
| for (int idx = 0; idx < imgdata.thumbs_list.thumbcount; idx++) |
| if (imgdata.thumbs_list.thumblist[idx].toffset == thumb_offset) |
| { |
| do_add = false; |
| break; |
| } |
| if (do_add) |
| { |
| int idx = imgdata.thumbs_list.thumbcount; |
| imgdata.thumbs_list.thumblist[idx].tformat = LIBRAW_INTERNAL_THUMBNAIL_JPEG; |
| imgdata.thumbs_list.thumblist[idx].toffset = thumb_offset; |
| imgdata.thumbs_list.thumblist[idx].tlength = thumb_length; |
| imgdata.thumbs_list.thumblist[idx].tflip = 0xffff; |
| imgdata.thumbs_list.thumblist[idx].tmisc = (3 << 5) | 8; // 3 samples/8 bps |
| imgdata.thumbs_list.thumblist[idx].twidth = 0; |
| imgdata.thumbs_list.thumblist[idx].theight = 0; |
| imgdata.thumbs_list.thumbcount++; |
| } |
| } |
| } |
| } |
| } |
| |
| if (framecnt) |
| is_raw = framecnt; |
| else |
| is_raw = media_tracks; |
| |
| if (tracki >= 0 && tracki < LIBRAW_CRXTRACKS_MAXCOUNT) |
| { |
| crx_data_header_t *d = |
| &libraw_internal_data.unpacker_data.crx_header[tracki]; |
| data_offset = d->MediaOffset; |
| data_size = d->MediaSize; |
| raw_width = d->f_width; |
| raw_height = d->f_height; |
| load_raw = &LibRaw::crxLoadRaw; |
| tiff_bps = d->encType == 3? d->medianBits : d->nBits; |
| switch (d->cfaLayout) |
| { |
| case 0: |
| filters = 0x94949494; |
| break; |
| case 1: |
| filters = 0x61616161; |
| break; |
| case 2: |
| filters = 0x49494949; |
| break; |
| case 3: |
| filters = 0x16161616; |
| break; |
| } |
| |
| libraw_internal_data.unpacker_data.crx_track_selected = tracki; |
| |
| int tiff_idx = -1; |
| INT64 tpixels = 0; |
| for (unsigned i = 0; i < tiff_nifds && i < LIBRAW_IFD_MAXCOUNT; i++) |
| if (INT64(tiff_ifd[i].t_height) * INT64(tiff_ifd[i].t_height) > tpixels) |
| { |
| tpixels = INT64(tiff_ifd[i].t_height) * INT64(tiff_ifd[i].t_height); |
| tiff_idx = i; |
| } |
| if (tiff_idx >= 0) |
| flip = tiff_ifd[tiff_idx].t_flip; |
| |
| if (ctmdcount == 1 && imgdata.makernotes.canon.multishot[0] && imgdata.makernotes.canon.multishot[1]) |
| for (int c = 0; c < 4; c++) |
| cam_mul[c] = 1024; |
| } |
| } |
| |
| #define bad_hdr() \ |
| (((order != 0x4d4d) && (order != 0x4949)) || (get2() != 0x002a) || \ |
| (get4() != 0x00000008)) |
| |
| int LibRaw::parseCR3_CTMD(short trackNum) |
| { |
| int err = 0; |
| short s_order = order; |
| order = 0x4949; |
| uint32_t relpos_inDir = 0; |
| uint32_t relpos_inBox = 0; |
| unsigned szItem, Tag, lTag; |
| ushort tItem; |
| |
| #define track libraw_internal_data.unpacker_data.crx_header[trackNum] |
| |
| if (track.MediaType != 3) |
| { |
| err = -10; |
| goto ctmd_fin; |
| } |
| |
| while (relpos_inDir + 6 < track.MediaSize) |
| { |
| if (track.MediaOffset + relpos_inDir > ifp->size() - 6) // need at least 6 bytes |
| { |
| err = -11; |
| goto ctmd_fin; |
| } |
| fseek(ifp, track.MediaOffset + relpos_inDir, SEEK_SET); |
| szItem = get4(); |
| tItem = get2(); |
| if (szItem < 1 || ( (relpos_inDir + szItem) > track.MediaSize)) |
| { |
| err = -11; |
| goto ctmd_fin; |
| } |
| if ((tItem == 7) || (tItem == 8) || (tItem == 9)) |
| { |
| relpos_inBox = relpos_inDir + 12L; |
| while (relpos_inBox + 8 < relpos_inDir + szItem) |
| { |
| if (track.MediaOffset + relpos_inBox > ifp->size() - 8) // need at least 8 bytes |
| { |
| err = -11; |
| goto ctmd_fin; |
| } |
| fseek(ifp, track.MediaOffset + relpos_inBox, SEEK_SET); |
| lTag = get4(); |
| Tag = get4(); |
| if (lTag < 8) |
| { |
| err = -12; |
| goto ctmd_fin; |
| } |
| else if ((relpos_inBox + lTag) > (relpos_inDir + szItem)) |
| { |
| err = -11; |
| goto ctmd_fin; |
| } |
| if (Tag == 0x927c) |
| { |
| fseek(ifp, track.MediaOffset + relpos_inBox + 8L, |
| SEEK_SET); |
| short q_order = order; |
| order = get2(); |
| if (bad_hdr()) |
| { |
| err = -13; |
| goto ctmd_fin; |
| } |
| if (callbacks.exif_cb) |
| { |
| INT64 savepos = ifp->tell(); |
| callbacks.exif_cb(callbacks.exifparser_data, (tItem << 20) | 0x80000 | 0x927c, 7, lTag-8, order, ifp, |
| track.MediaOffset + relpos_inBox + 8); |
| fseek(ifp, savepos, SEEK_SET); |
| } |
| |
| if ((tItem == 7) || (tItem == 8)) |
| { |
| fseek(ifp, -8L, SEEK_CUR); |
| libraw_internal_data.unpacker_data.CR3_CTMDtag = 1; |
| parse_makernote(track.MediaOffset + relpos_inBox + 8, |
| 0); |
| libraw_internal_data.unpacker_data.CR3_CTMDtag = 0; |
| } |
| order = q_order; |
| } |
| relpos_inBox += lTag; |
| } |
| } |
| relpos_inDir += szItem; |
| } |
| |
| ctmd_fin: |
| order = s_order; |
| return err; |
| } |
| #undef track |
| |
| int LibRaw::parseCR3(UINT64 oAtomList, |
| UINT64 szAtomList, short &nesting, |
| char *AtomNameStack, short &nTrack, short &TrackType, UINT64 filesz) |
| { |
| /* |
| Atom starts with 4 bytes for Atom size and 4 bytes containing Atom name |
| Atom size includes the length of the header and the size of all "contained" |
| Atoms if Atom size == 1, Atom has the extended size stored in 8 bytes located |
| after the Atom name if Atom size == 0, it is the last top-level Atom extending |
| to the end of the file Atom name is often a 4 symbol mnemonic, but can be a |
| 4-byte integer |
| */ |
| const char UIID_Canon[17] = |
| "\x85\xc0\xb6\x87\x82\x0f\x11\xe0\x81\x11\xf4\xce\x46\x2b\x6a\x48"; |
| const unsigned char UIID_CanonPreview[17] = "\xea\xf4\x2b\x5e\x1c\x98\x4b\x88\xb9\xfb\xb7\xdc\x40\x6e\x4d\x16"; |
| const unsigned char UUID_XMP[17] = "\xbe\x7a\xcf\xcb\x97\xa9\x42\xe8\x9c\x71\x99\x94\x91\xe3\xaf\xac"; |
| |
| /* |
| AtomType = 0 - unknown: "unk." |
| AtomType = 1 - container atom: "cont" |
| AtomType = 2 - leaf atom: "leaf" |
| AtomType = 3 - can be container, can be leaf: "both" |
| */ |
| short AtomType; |
| static const struct |
| { |
| char AtomName[5]; |
| short AtomType; |
| } AtomNamesList[] = { |
| {"dinf", 1}, |
| {"edts", 1}, |
| {"fiin", 1}, |
| {"ipro", 1}, |
| {"iprp", 1}, |
| {"mdia", 1}, |
| {"meco", 1}, |
| {"mere", 1}, |
| {"mfra", 1}, |
| {"minf", 1}, |
| {"moof", 1}, |
| {"moov", 1}, |
| {"mvex", 1}, |
| {"paen", 1}, |
| {"schi", 1}, |
| {"sinf", 1}, |
| {"skip", 1}, |
| {"stbl", 1}, |
| {"stsd", 1}, |
| {"strk", 1}, |
| {"tapt", 1}, |
| {"traf", 1}, |
| {"trak", 1}, |
| |
| {"cdsc", 2}, |
| {"colr", 2}, |
| {"dimg", 2}, |
| // {"dref", 2}, |
| {"free", 2}, |
| {"frma", 2}, |
| {"ftyp", 2}, |
| {"hdlr", 2}, |
| {"hvcC", 2}, |
| {"iinf", 2}, |
| {"iloc", 2}, |
| {"infe", 2}, |
| {"ipco", 2}, |
| {"ipma", 2}, |
| {"iref", 2}, |
| {"irot", 2}, |
| {"ispe", 2}, |
| {"meta", 2}, |
| {"mvhd", 2}, |
| {"pitm", 2}, |
| {"pixi", 2}, |
| {"schm", 2}, |
| {"thmb", 2}, |
| {"tkhd", 2}, |
| {"url ", 2}, |
| {"urn ", 2}, |
| |
| {"CCTP", 1}, |
| {"CRAW", 1}, |
| |
| {"JPEG", 2}, |
| {"CDI1", 2}, |
| {"CMP1", 2}, |
| |
| {"CNCV", 2}, |
| {"CCDT", 2}, |
| {"CTBO", 2}, |
| {"CMT1", 2}, |
| {"CMT2", 2}, |
| {"CMT3", 2}, |
| {"CMT4", 2}, |
| {"CNOP", 2}, |
| {"THMB", 2}, |
| {"co64", 2}, |
| {"mdat", 2}, |
| {"mdhd", 2}, |
| {"nmhd", 2}, |
| {"stsc", 2}, |
| {"stsz", 2}, |
| {"stts", 2}, |
| {"vmhd", 2}, |
| |
| {"dref", 3}, |
| {"uuid", 3}, |
| }; |
| |
| const char sHandlerType[5][5] = {"unk.", "soun", "vide", "hint", "meta"}; |
| |
| int c, err=0; |
| |
| ushort tL; // Atom length represented in 4 or 8 bytes |
| char nmAtom[5]; // Atom name |
| UINT64 oAtom, szAtom; // Atom offset and Atom size |
| UINT64 oAtomContent, |
| szAtomContent; // offset and size of Atom content |
| UINT64 lHdr; |
| |
| char UIID[16]; |
| uchar CMP1[85]; |
| uchar thdr[4]; |
| uchar CDI1[60]; |
| char HandlerType[5], MediaFormatID[5]; |
| |
| nmAtom[0] = MediaFormatID[0] = nmAtom[4] = MediaFormatID[4] = '\0'; |
| strcpy(HandlerType, sHandlerType[0]); |
| oAtom = oAtomList; |
| nesting++; |
| if (nesting > 31) |
| return -14; // too deep nesting |
| short s_order = order; |
| |
| while (((oAtom + 8ULL) <= (oAtomList + szAtomList)) && ((oAtom+8ULL) < filesz)) |
| { |
| lHdr = 0ULL; |
| err = 0; |
| order = 0x4d4d; |
| fseek(ifp, oAtom, SEEK_SET); |
| if (nesting == 0) |
| { |
| memset(thdr, 0, 4); |
| fread(thdr, 1, 4, ifp); |
| fseek(ifp, oAtom, SEEK_SET); |
| } |
| uint32_t sz = get4(); |
| szAtom = sz; |
| FORC4 nmAtom[c] = AtomNameStack[nesting * 4 + c] = fgetc(ifp); |
| AtomNameStack[(nesting + 1) * 4] = '\0'; |
| tL = 4; |
| AtomType = 0; |
| |
| for (c = 0; c < int(sizeof AtomNamesList / sizeof *AtomNamesList); c++) |
| if (!strcmp(nmAtom, AtomNamesList[c].AtomName)) |
| { |
| AtomType = AtomNamesList[c].AtomType; |
| break; |
| } |
| |
| if (!AtomType) |
| { |
| if (nesting == 0) |
| { |
| if(!memcmp(thdr,"II*\0",4) || !memcmp(thdr,"MM*\0",4) || |
| ( !memcmp(HandlerType, "unk.", 4) && nTrack >=0)) |
| { |
| err = 0; |
| goto fin; |
| } |
| } |
| err = 1; |
| } |
| |
| if (szAtom == 0ULL) |
| { |
| if (nesting != 0) |
| { |
| err = -2; |
| goto fin; |
| } |
| szAtom = szAtomList - oAtom; |
| oAtomContent = oAtom + 8ULL; |
| szAtomContent = szAtom - 8ULL; |
| } |
| else if (szAtom == 1LL) |
| { |
| if ((oAtom + 16LL) > (oAtomList + szAtomList)) |
| { |
| err = -3; |
| goto fin; |
| } |
| tL = 8; |
| uint64_t upper = get4(); |
| uint64_t lower = get4(); |
| szAtom = ((upper & 0x7fffffff) << 32) | lower; // This will limit atom size to 2^63-1. In practice, you can live with this |
| if (szAtom < 16ULL) |
| { |
| err = -3; |
| goto fin; |
| } |
| |
| oAtomContent = oAtom + 16ULL; |
| szAtomContent = szAtom - 16ULL; |
| } |
| else |
| { |
| oAtomContent = oAtom + 8ULL; |
| szAtomContent = szAtom - 8ULL; |
| } |
| if (szAtom < 8ULL) |
| { |
| err = -3; |
| goto fin; |
| } |
| |
| if (!strcmp(AtomNameStack, "uuid")) // Top level uuid |
| { |
| INT64 tt = ftell(ifp); |
| lHdr = 16ULL; |
| memset(UIID, 0, lHdr); |
| fread(UIID, 1, lHdr, ifp); |
| if (!memcmp(UIID, UUID_XMP, 16) && szAtom > 24LL && szAtom < 1024000LL) |
| { |
| xmpdata = (char *)calloc(xmplen = unsigned(szAtom - 23),1); |
| unsigned br = fread(xmpdata,1, szAtom - 24, ifp); |
| xmpdata[br] = 0; |
| } |
| else if (!memcmp(UIID, UIID_CanonPreview, 16) && szAtom > 48LL && szAtom < 100LL * 1024000LL) |
| { |
| // read next 48 bytes, check for 'PRVW' |
| unsigned char xdata[32]; |
| memset(xdata, 0, sizeof(xdata)); |
| fread(xdata, 32, 1, ifp); |
| if (!memcmp(xdata + 12, "PRVW", 4)) |
| { |
| thumb_length = unsigned(szAtom - 56); |
| thumb_offset = ftell(ifp); |
| if (imgdata.thumbs_list.thumbcount < LIBRAW_THUMBNAIL_MAXCOUNT) |
| { |
| bool do_add = true; |
| for(int idx = 0; idx < imgdata.thumbs_list.thumbcount; idx++) |
| if (imgdata.thumbs_list.thumblist[idx].toffset == thumb_offset) |
| { |
| do_add = false; |
| break; |
| } |
| if (do_add) |
| { |
| int idx = imgdata.thumbs_list.thumbcount; |
| imgdata.thumbs_list.thumblist[idx].tformat = LIBRAW_INTERNAL_THUMBNAIL_JPEG; |
| imgdata.thumbs_list.thumblist[idx].toffset = thumb_offset; |
| imgdata.thumbs_list.thumblist[idx].tlength = thumb_length; |
| imgdata.thumbs_list.thumblist[idx].tflip = 0xffff; |
| imgdata.thumbs_list.thumblist[idx].tmisc = (3 << 5) | 8; // 3 samples/8 bps |
| imgdata.thumbs_list.thumblist[idx].twidth = (xdata[22] << 8) + xdata[23]; |
| imgdata.thumbs_list.thumblist[idx].theight = (xdata[24] << 8) + xdata[25]; |
| imgdata.thumbs_list.thumbcount++; |
| } |
| } |
| |
| } |
| } |
| fseek(ifp, tt, SEEK_SET); |
| } |
| |
| if (!strcmp(nmAtom, "trak")) |
| { |
| nTrack++; |
| TrackType = 0; |
| if (nTrack >= LIBRAW_CRXTRACKS_MAXCOUNT) |
| break; |
| } |
| if (!strcmp(AtomNameStack, "moovuuid")) |
| { |
| lHdr = 16ULL; |
| memset(UIID, 0, lHdr); |
| fread(UIID, 1, lHdr, ifp); |
| if (!strncmp(UIID, UIID_Canon, lHdr)) |
| { |
| AtomType = 1; |
| } |
| else |
| fseek(ifp, -lHdr, SEEK_CUR); |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidCCTP")) |
| { |
| lHdr = 12ULL; |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidCMT1")) |
| { |
| short q_order = order; |
| order = get2(); |
| if ((tL != 4) || bad_hdr()) |
| { |
| err = -4; |
| goto fin; |
| } |
| if (!libraw_internal_data.unpacker_data.cr3_ifd0_length) |
| libraw_internal_data.unpacker_data.cr3_ifd0_length = unsigned(szAtomContent); |
| parse_tiff_ifd(oAtomContent); |
| order = q_order; |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidTHMB") && szAtom > 24) |
| { |
| unsigned char xdata[16]; |
| memset(xdata, 0, sizeof(xdata)); |
| fread(xdata, 16, 1, ifp); |
| INT64 xoffset = ftell(ifp); |
| if (imgdata.thumbs_list.thumbcount < LIBRAW_THUMBNAIL_MAXCOUNT) |
| { |
| bool do_add = true; |
| for (int idx = 0; idx < imgdata.thumbs_list.thumbcount; idx++) |
| if (imgdata.thumbs_list.thumblist[idx].toffset == xoffset) |
| { |
| do_add = false; |
| break; |
| } |
| if (do_add) |
| { |
| int idx = imgdata.thumbs_list.thumbcount; |
| imgdata.thumbs_list.thumblist[idx].tformat = LIBRAW_INTERNAL_THUMBNAIL_JPEG; |
| imgdata.thumbs_list.thumblist[idx].toffset = xoffset; |
| imgdata.thumbs_list.thumblist[idx].tlength = unsigned(szAtom-24LL); |
| imgdata.thumbs_list.thumblist[idx].tflip = 0xffff; |
| imgdata.thumbs_list.thumblist[idx].tmisc = (3 << 5) | 8; // 3 samples/8 bps |
| imgdata.thumbs_list.thumblist[idx].twidth = (xdata[4] << 8) + xdata[5]; |
| imgdata.thumbs_list.thumblist[idx].theight = (xdata[6] << 8) + xdata[7]; |
| imgdata.thumbs_list.thumbcount++; |
| } |
| } |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidCMT2")) |
| { |
| short q_order = order; |
| order = get2(); |
| if ((tL != 4) || bad_hdr()) |
| { |
| err = -5; |
| goto fin; |
| } |
| if (!libraw_internal_data.unpacker_data.cr3_exif_length) |
| libraw_internal_data.unpacker_data.cr3_exif_length = unsigned(szAtomContent); |
| parse_exif(oAtomContent); |
| order = q_order; |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidCMT3")) |
| { |
| short q_order = order; |
| order = get2(); |
| if ((tL != 4) || bad_hdr()) |
| { |
| err = -6; |
| goto fin; |
| } |
| if (callbacks.exif_cb) |
| { |
| INT64 savepos = ifp->tell(); |
| callbacks.exif_cb(callbacks.exifparser_data, 0x70000 | 0x927c, 7, szAtomContent, order, ifp, oAtomContent); |
| fseek(ifp, savepos, SEEK_SET); |
| } |
| fseek(ifp, -12L, SEEK_CUR); |
| parse_makernote(oAtomContent, 0); |
| order = q_order; |
| } |
| else if (!strcmp(AtomNameStack, "moovuuidCMT4")) |
| { |
| short q_order = order; |
| order = get2(); |
| if ((tL != 4) || bad_hdr()) |
| { |
| err = -6; |
| goto fin; |
| } |
| INT64 off = ftell(ifp); |
| parse_gps(oAtomContent); |
| fseek(ifp, off, SEEK_SET); |
| parse_gps_libraw(oAtomContent); |
| order = q_order; |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiahdlr")) |
| { |
| fseek(ifp, 8L, SEEK_CUR); |
| FORC4 HandlerType[c] = fgetc(ifp); |
| for (c = 1; c < int(sizeof sHandlerType / sizeof *sHandlerType); c++) |
| if (!strcmp(HandlerType, sHandlerType[c])) |
| { |
| TrackType = c; |
| break; |
| } |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsd")) |
| { |
| if (szAtomContent >= 16) |
| { |
| fseek(ifp, 12L, SEEK_CUR); |
| lHdr = 8; |
| } |
| else |
| { |
| err = -7; |
| goto fin; |
| } |
| FORC4 MediaFormatID[c] = fgetc(ifp); |
| if ((TrackType == 2) && (!strcmp(MediaFormatID, "CRAW"))) |
| { |
| if (szAtomContent >= 44) |
| fseek(ifp, 24L, SEEK_CUR); |
| else |
| { |
| err = -8; |
| goto fin; |
| } |
| } |
| else |
| { |
| AtomType = 2; // only continue for CRAW |
| lHdr = 0; |
| } |
| #define current_track libraw_internal_data.unpacker_data.crx_header[nTrack] |
| |
| /*ImageWidth =*/ get2(); |
| /*ImageHeight =*/ get2(); |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsdCRAW")) |
| { |
| lHdr = 82; |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsdCRAWCMP1")) |
| { |
| INT64 read_size = szAtomContent > 85LL ? 85 : INT64(szAtomContent); |
| if (szAtomContent >= 40) |
| { |
| memset(CMP1, 0, read_size); |
| fread(CMP1, 1, size_t(read_size), ifp); |
| } |
| else |
| { |
| err = -7; |
| goto fin; |
| } |
| if (!crxParseImageHeader(CMP1, nTrack, read_size)) |
| current_track.MediaType = 1; |
| } |
| |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsdCRAWCDI1")) { |
| if (szAtomContent >= 60) { |
| memset(CDI1, 0, 60); |
| fread(CDI1, 1, 60, ifp); |
| if (!strncmp((char *)CDI1+8, "IAD1", 4) && (sgetn(8, CDI1) == 0x38)) { |
| // sensor area at CDI1+12, 4 16-bit values |
| // Bayer pattern? - next 4 16-bit values |
| imCanon.RecommendedImageArea = sget_CanonArea(CDI1+12 + 2*4*2); |
| imCanon.LeftOpticalBlack = sget_CanonArea(CDI1+12 + 3*4*2); |
| imCanon.UpperOpticalBlack = sget_CanonArea(CDI1+12 + 4*4*2); |
| imCanon.ActiveArea = sget_CanonArea(CDI1+12 + 5*4*2); |
| } |
| } |
| } |
| |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsdCRAWJPEG")) |
| { |
| current_track.MediaType = 2; |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsc")) |
| { |
| if (szAtomContent >= 12) { |
| fseek(ifp, 4L, SEEK_CUR); |
| int entries = get4(); |
| if (entries < 1 || entries > 1000000) |
| { |
| err = -9; |
| goto fin; |
| } |
| |
| current_track.stsc_data = (crx_sample_to_chunk_t*) calloc(entries * sizeof(crx_sample_to_chunk_t),1); |
| if(!current_track.stsc_data) |
| { |
| err = -9; |
| goto fin; |
| } |
| current_track.stsc_count = entries; |
| for(int i = 0; i < entries; i++) |
| { |
| current_track.stsc_data[i].first = get4(); |
| current_track.stsc_data[i].count = get4(); |
| current_track.stsc_data[i].id = get4(); |
| } |
| } |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblstsz")) |
| { |
| if (szAtomContent >= 12) |
| { |
| fseek(ifp, 4L, SEEK_CUR); |
| int sample_size = get4(); |
| int entries = get4(); |
| current_track.sample_count = entries; |
| |
| // if sample size is zero sample size is fixed |
| if (sample_size) |
| { |
| current_track.MediaSize = sample_size; |
| current_track.sample_size = sample_size; |
| } |
| else |
| { |
| current_track.sample_size = 0; |
| if (entries < 1 || entries > 1000000) { |
| err = -10; |
| goto fin; |
| } |
| current_track.sample_sizes = (int32_t*)calloc(entries * sizeof(int32_t),1); |
| if (!current_track.sample_sizes) |
| { |
| err = -10; |
| goto fin; |
| } |
| for (int i = 0; i < entries; i++) |
| current_track.sample_sizes[i] = get4(); |
| |
| current_track.MediaSize = current_track.sample_sizes[0]; |
| } |
| } |
| } |
| else if (!strcmp(AtomNameStack, "moovtrakmdiaminfstblco64")) |
| { |
| if (szAtomContent >= 16) { |
| fseek(ifp, 4L, SEEK_CUR); |
| uint32_t entries = get4(); |
| uint32_t i; |
| if (entries < 1 || entries > 1000000) |
| { |
| err = -11; |
| goto fin; |
| } |
| current_track.chunk_offsets = (INT64*)calloc(entries * sizeof(int64_t),1); |
| if(!current_track.chunk_offsets) |
| { |
| err = -11; |
| goto fin; |
| } |
| |
| current_track.chunk_count = entries; |
| for (i = 0; i < entries; i++) |
| current_track.chunk_offsets[i] = (((int64_t)get4()) << 32) | get4(); |
| |
| current_track.chunk_count = i; |
| current_track.MediaOffset = current_track.chunk_offsets[0]; |
| } |
| } |
| |
| if (nTrack >= 0 && nTrack < LIBRAW_CRXTRACKS_MAXCOUNT && |
| current_track.MediaSize && current_track.MediaOffset && |
| ((oAtom + szAtom) >= (oAtomList + szAtomList)) && |
| !strncmp(AtomNameStack, "moovtrakmdiaminfstbl", 20)) |
| { |
| if ((TrackType == 4) && (!strcmp(MediaFormatID, "CTMD"))) |
| { |
| current_track.MediaType = 3; |
| } |
| } |
| #undef current_track |
| if (AtomType == 1) |
| { |
| err = parseCR3(oAtomContent + lHdr, szAtomContent - lHdr, nesting, |
| AtomNameStack, nTrack, TrackType,filesz); |
| if (err) |
| goto fin; |
| } |
| oAtom += szAtom; |
| } |
| |
| fin: |
| nesting--; |
| if (nesting >= 0) |
| AtomNameStack[nesting * 4] = '\0'; |
| order = s_order; |
| return err; |
| } |
| #undef bad_hdr |
| |
| void LibRaw::parseCR3_Free() |
| { |
| short maxTrack = libraw_internal_data.unpacker_data.crx_track_count; |
| if (maxTrack < 0) |
| return; |
| |
| for (int i = 0; i <= maxTrack && i < LIBRAW_CRXTRACKS_MAXCOUNT; i++) |
| { |
| crx_data_header_t *d = &libraw_internal_data.unpacker_data.crx_header[i]; |
| if (d->stsc_data) |
| { |
| free(d->stsc_data); |
| d->stsc_data = NULL; |
| } |
| if (d->chunk_offsets) |
| { |
| free(d->chunk_offsets); |
| d->chunk_offsets = NULL; |
| } |
| |
| if (d->sample_sizes) |
| { |
| free(d->sample_sizes); |
| d->sample_sizes = NULL; |
| } |
| d->stsc_count = 0; |
| d->sample_count = 0; |
| d->sample_size = 0; |
| d->chunk_count = 0; |
| } |
| libraw_internal_data.unpacker_data.crx_track_count = -1; |
| } |
