void PefDecoder::decodeMetaDataInternal(const CameraMetaData* meta) { int iso = 0; mRaw->cfa.setCFA(iPoint2D(2,2), CFA_RED, CFA_GREEN, CFA_GREEN, CFA_BLUE); if (mRootIFD->hasEntryRecursive(ISOSPEEDRATINGS)) iso = mRootIFD->getEntryRecursive(ISOSPEEDRATINGS)->getU32(); setMetaData(meta, "", iso); // Read black level if (mRootIFD->hasEntryRecursive(static_cast<TiffTag>(0x200))) { TiffEntry* black = mRootIFD->getEntryRecursive(static_cast<TiffTag>(0x200)); if (black->count == 4) { for (int i = 0; i < 4; i++) mRaw->blackLevelSeparate[i] = black->getU32(i); } } // Set the whitebalance if (mRootIFD->hasEntryRecursive(static_cast<TiffTag>(0x0201))) { TiffEntry* wb = mRootIFD->getEntryRecursive(static_cast<TiffTag>(0x0201)); if (wb->count == 4) { mRaw->metadata.wbCoeffs[0] = wb->getU32(0); mRaw->metadata.wbCoeffs[1] = wb->getU32(1); mRaw->metadata.wbCoeffs[2] = wb->getU32(3); } } }
MosDecoder::MosDecoder(TiffIFD *rootIFD, FileMap* file) : RawDecoder(file), mRootIFD(rootIFD) { decoderVersion = 0; black_level = 0; vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(MAKE); if (!data.empty()) { make = data[0]->getEntry(MAKE)->getString(); model = data[0]->getEntry(MODEL)->getString(); } else { TiffEntry *xmp = mRootIFD->getEntryRecursive(XMP); if (!xmp) ThrowRDE("MOS Decoder: Couldn't find the XMP"); string xmpText = xmp->getString(); make = getXMPTag(xmpText, "Make"); model = getXMPTag(xmpText, "Model"); } }
RawImage DcsDecoder::decodeRawInternal() { SimpleTiffDecoder::prepareForRawDecoding(); TiffEntry *linearization = mRootIFD->getEntryRecursive(GRAYRESPONSECURVE); if (!linearization || linearization->count != 256 || linearization->type != TIFF_SHORT) ThrowRDE("Couldn't find the linearization table"); assert(linearization != nullptr); auto table = linearization->getU16Array(256); RawImageCurveGuard curveHandler(&mRaw, table, uncorrectedRawValues); UncompressedDecompressor u(*mFile, off, c2, mRaw); if (uncorrectedRawValues) u.decode8BitRaw<true>(width, height); else u.decode8BitRaw<false>(width, height); return mRaw; }
RawImage KdcDecoder::decodeRawInternal() { int compression = mRootIFD->getEntryRecursive(COMPRESSION)->getInt(); if (7 != compression) ThrowRDE("KDC Decoder: Unsupported compression %d", compression); TiffEntry *ex = mRootIFD->getEntryRecursive(PIXELXDIMENSION); TiffEntry *ey = mRootIFD->getEntryRecursive(PIXELYDIMENSION); if (NULL == ex || NULL == ey) ThrowRDE("KDC Decoder: Unable to retrieve image size"); uint32 width = ex->getInt(); uint32 height = ey->getInt(); TiffEntry *offset = mRootIFD->getEntryRecursive(KODAK_KDC_OFFSET); if (!offset || offset->count < 13) ThrowRDE("KDC Decoder: Couldn't find the KDC offset"); const uint32 *offsetarray = offset->getIntArray(); uint32 off = offsetarray[4] + offsetarray[12]; mRaw->dim = iPoint2D(width, height); mRaw->createData(); ByteStream input(mFile->getData(off), mFile->getSize()-off); Decode12BitRawBE(input, width, height); return mRaw; }
void KdcDecoder::decodeMetaDataInternal(CameraMetaData *meta) { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(MODEL); if (data.empty()) ThrowRDE("KDC Decoder: Model name found"); if (!data[0]->hasEntry(MAKE)) ThrowRDE("KDC Decoder: Make name not found"); string make = data[0]->getEntry(MAKE)->getString(); string model = data[0]->getEntry(MODEL)->getString(); setMetaData(meta, make, model, "", 0); if (mRootIFD->hasEntryRecursive(KODAKWB)) { TiffEntry *wb = mRootIFD->getEntryRecursive(KODAKWB); if (wb->count == 734 || wb->count == 1502) { const uchar8 *tmp = wb->getData(); mRaw->metadata.wbCoeffs[0] = (float)((((ushort16) tmp[148])<<8)|tmp[149])/256.0f; mRaw->metadata.wbCoeffs[1] = 1.0f; mRaw->metadata.wbCoeffs[2] = (float)((((ushort16) tmp[150])<<8)|tmp[151])/256.0f; } } }
void PefDecoder::decodeMetaDataInternal(CameraMetaData *meta) { int iso = 0; mRaw->cfa.setCFA(iPoint2D(2,2), CFA_RED, CFA_GREEN, CFA_GREEN2, CFA_BLUE); vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(MODEL); if (data.empty()) ThrowRDE("PEF Meta Decoder: Model name found"); TiffIFD* raw = data[0]; string make = raw->getEntry(MAKE)->getString(); string model = raw->getEntry(MODEL)->getString(); if (mRootIFD->hasEntryRecursive(ISOSPEEDRATINGS)) iso = mRootIFD->getEntryRecursive(ISOSPEEDRATINGS)->getInt(); setMetaData(meta, make, model, "", iso); // Read black level if (mRootIFD->hasEntryRecursive((TiffTag)0x200)) { TiffEntry *black = mRootIFD->getEntryRecursive((TiffTag)0x200); const ushort16 *levels = black->getShortArray(); for (int i = 0; i < 4; i++) mRaw->blackLevelSeparate[i] = levels[i]; } // Set the whitebalance if (mRootIFD->hasEntryRecursive((TiffTag) 0x0201)) { TiffEntry *wb = mRootIFD->getEntryRecursive((TiffTag) 0x0201); if (wb->count == 4) { const ushort16 *tmp = wb->getShortArray(); mRaw->metadata.wbCoeffs[0] = tmp[0]; mRaw->metadata.wbCoeffs[1] = tmp[1]; mRaw->metadata.wbCoeffs[2] = tmp[3]; } } }
void KdcDecoder::decodeMetaDataInternal(CameraMetaData *meta) { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(MODEL); if (data.empty()) ThrowRDE("KDC Decoder: Model name found"); if (!data[0]->hasEntry(MAKE)) ThrowRDE("KDC Decoder: Make name not found"); string make = data[0]->getEntry(MAKE)->getString(); string model = data[0]->getEntry(MODEL)->getString(); setMetaData(meta, make, model, "", 0); // Try the kodak hidden IFD for WB if (mRootIFD->hasEntryRecursive(KODAK_IFD2)) { TiffEntry *ifdoffset = mRootIFD->getEntryRecursive(KODAK_IFD2); TiffIFD *kodakifd = NULL; try { if (mRootIFD->endian == getHostEndianness()) kodakifd = new TiffIFD(mFile, ifdoffset->getInt()); else kodakifd = new TiffIFDBE(mFile, ifdoffset->getInt()); if (kodakifd && kodakifd->hasEntryRecursive(KODAK_KDC_WB)) { TiffEntry *wb = kodakifd->getEntryRecursive(KODAK_KDC_WB); if (wb->count == 3) { const uint32 *tmp = wb->getIntArray(); mRaw->metadata.wbCoeffs[0] = (float)tmp[0]; mRaw->metadata.wbCoeffs[1] = (float)tmp[1]; mRaw->metadata.wbCoeffs[2] = (float)tmp[2]; } } } catch(TiffParserException e) { mRaw->setError(e.what()); } if (kodakifd) delete kodakifd; } // Use the normal WB if available if (mRootIFD->hasEntryRecursive(KODAKWB)) { TiffEntry *wb = mRootIFD->getEntryRecursive(KODAKWB); if (wb->count == 734 || wb->count == 1502) { const uchar8 *tmp = wb->getData(); mRaw->metadata.wbCoeffs[0] = (float)((((ushort16) tmp[148])<<8)|tmp[149])/256.0f; mRaw->metadata.wbCoeffs[1] = 1.0f; mRaw->metadata.wbCoeffs[2] = (float)((((ushort16) tmp[150])<<8)|tmp[151])/256.0f; } } }
RawImage PefDecoder::decodeRawInternal() { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(STRIPOFFSETS); if (data.empty()) ThrowRDE("PEF Decoder: No image data found"); TiffIFD* raw = data[0]; int compression = raw->getEntry(COMPRESSION)->getInt(); if (1 == compression) { decodeUncompressed(raw, true); return mRaw; } if (65535 != compression) ThrowRDE("PEF Decoder: Unsupported compression"); TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); if (offsets->count != 1) { ThrowRDE("PEF Decoder: Multiple Strips found: %u", offsets->count); } if (counts->count != offsets->count) { ThrowRDE("PEF Decoder: Byte count number does not match strip size: count:%u, strips:%u ", counts->count, offsets->count); } if (!mFile->isValid(offsets->getInt() + counts->getInt())) ThrowRDE("PEF Decoder: Truncated file."); uint32 width = raw->getEntry(IMAGEWIDTH)->getInt(); uint32 height = raw->getEntry(IMAGELENGTH)->getInt(); mRaw->dim = iPoint2D(width, height); mRaw->createData(); try { PentaxDecompressor l(mFile, mRaw); l.decodePentax(mRootIFD, offsets->getInt(), counts->getInt()); } catch (IOException &e) { errors.push_back(_strdup(e.what())); // Let's ignore it, it may have delivered somewhat useful data. } return mRaw; }
RawImage PefDecoder::decodeRawInternal() { auto raw = mRootIFD->getIFDWithTag(STRIPOFFSETS); int compression = raw->getEntry(COMPRESSION)->getU32(); if (1 == compression || compression == 32773) { decodeUncompressed(raw, BitOrder_MSB); return mRaw; } if (65535 != compression) ThrowRDE("Unsupported compression"); TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); if (offsets->count != 1) { ThrowRDE("Multiple Strips found: %u", offsets->count); } if (counts->count != offsets->count) { ThrowRDE( "Byte count number does not match strip size: count:%u, strips:%u ", counts->count, offsets->count); } if (!mFile->isValid(offsets->getU32(), counts->getU32())) ThrowRDE("Truncated file."); uint32 width = raw->getEntry(IMAGEWIDTH)->getU32(); uint32 height = raw->getEntry(IMAGELENGTH)->getU32(); mRaw->dim = iPoint2D(width, height); mRaw->createData(); try { PentaxDecompressor::decompress( mRaw, ByteStream(mFile, offsets->getU32(), counts->getU32()), getRootIFD()); } catch (IOException &e) { mRaw->setError(e.what()); // Let's ignore it, it may have delivered somewhat useful data. } return mRaw; }
RawImage KdcDecoder::decodeRawInternal() { if (!mRootIFD->hasEntryRecursive(COMPRESSION)) ThrowRDE("KDC Decoder: Couldn't find compression setting"); int compression = mRootIFD->getEntryRecursive(COMPRESSION)->getInt(); if (7 != compression) ThrowRDE("KDC Decoder: Unsupported compression %d", compression); uint32 width = 0; uint32 height = 0; TiffEntry *ew = mRootIFD->getEntryRecursive(KODAK_KDC_WIDTH); TiffEntry *eh = mRootIFD->getEntryRecursive(KODAK_KDC_HEIGHT); if (ew && eh) { width = ew->getInt()+80; height = eh->getInt()+70; } else ThrowRDE("KDC Decoder: Unable to retrieve image size"); TiffEntry *offset = mRootIFD->getEntryRecursive(KODAK_KDC_OFFSET); if (!offset || offset->count < 13) ThrowRDE("KDC Decoder: Couldn't find the KDC offset"); const uint32 *offsetarray = offset->getIntArray(); uint32 off = offsetarray[4] + offsetarray[12]; // Offset hardcoding gotten from dcraw if (hints.find("easyshare_offset_hack") != hints.end()) off = off < 0x15000 ? 0x15000 : 0x17000; if (off > mFile->getSize()) ThrowRDE("KDC Decoder: offset is out of bounds"); mRaw->dim = iPoint2D(width, height); mRaw->createData(); ByteStream input(mFile, off); Decode12BitRawBE(input, width, height); return mRaw; }
RawImage Rw2Decoder::decodeRawInternal() { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(PANASONIC_STRIPOFFSET); bool isOldPanasonic = FALSE; if (data.empty()) { if (!mRootIFD->hasEntryRecursive(STRIPOFFSETS)) ThrowRDE("RW2 Decoder: No image data found"); isOldPanasonic = TRUE; data = mRootIFD->getIFDsWithTag(STRIPOFFSETS); } TiffIFD* raw = data[0]; uint32 height = raw->getEntry((TiffTag)3)->getShort(); uint32 width = raw->getEntry((TiffTag)2)->getShort(); if (isOldPanasonic) { ThrowRDE("Cannot decode old-style Panasonic RAW files"); TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); if (offsets->count != 1) { ThrowRDE("RW2 Decoder: Multiple Strips found: %u", offsets->count); } int off = offsets->getInt(); if (!mFile->isValid(off)) ThrowRDE("Panasonic RAW Decoder: Invalid image data offset, cannot decode."); int count = counts->getInt(); if (count != (int)(width*height*2)) ThrowRDE("Panasonic RAW Decoder: Byte count is wrong."); if (!mFile->isValid(off+count)) ThrowRDE("Panasonic RAW Decoder: Invalid image data offset, cannot decode."); mRaw->dim = iPoint2D(width, height); mRaw->createData(); ByteStream input_start(mFile->getData(off), mFile->getSize() - off); iPoint2D pos(0, 0); readUncompressedRaw(input_start, mRaw->dim,pos, width*2, 16, BitOrder_Plain); } else { mRaw->dim = iPoint2D(width, height); mRaw->createData(); TiffEntry *offsets = raw->getEntry(PANASONIC_STRIPOFFSET); if (offsets->count != 1) { ThrowRDE("RW2 Decoder: Multiple Strips found: %u", offsets->count); } load_flags = 0x2008; int off = offsets->getInt(); if (!mFile->isValid(off)) ThrowRDE("RW2 Decoder: Invalid image data offset, cannot decode."); input_start = new ByteStream(mFile->getData(off), mFile->getSize() - off); DecodeRw2(); } // Read blacklevels if (raw->hasEntry((TiffTag)0x1c) && raw->hasEntry((TiffTag)0x1d) && raw->hasEntry((TiffTag)0x1e)) { mRaw->blackLevelSeparate[0] = raw->getEntry((TiffTag)0x1c)->getInt() + 15; mRaw->blackLevelSeparate[1] = mRaw->blackLevelSeparate[2] = raw->getEntry((TiffTag)0x1d)->getInt() + 15; mRaw->blackLevelSeparate[3] = raw->getEntry((TiffTag)0x1e)->getInt() + 15; } return mRaw; }
RawDecoder* RawParser::getDecoder(CameraMetaData* meta) { const unsigned char* data = mInput->getData(0); // We need some data. // For now it is 104 bytes for RAF images. if (mInput->getSize() <= 104) ThrowRDE("File too small"); // MRW images are easy to check for, let's try that first if (MrwDecoder::isMRW(mInput)) { try { return new MrwDecoder(mInput); } catch (RawDecoderException) { } } if (0 == memcmp(&data[0], "ARRI\x12\x34\x56\x78", 8)) { try { return new AriDecoder(mInput); } catch (RawDecoderException) { } } // FUJI has pointers to IFD's at fixed byte offsets // So if camera is FUJI, we cannot use ordinary TIFF parser if (0 == memcmp(&data[0], "FUJIFILM", 8)) { // First IFD typically JPEG and EXIF uint32 first_ifd = data[87] | (data[86]<<8) | (data[85]<<16) | (data[84]<<24); first_ifd += 12; if (mInput->getSize() <= first_ifd) ThrowRDE("File too small (FUJI first IFD)"); // RAW IFD on newer, pointer to raw data on older models, so we try parsing first // And adds it as data if parsin fails uint32 second_ifd = (uint32)data[103] | (data[102]<<8) | (data[101]<<16) | (data[100]<<24); if (mInput->getSize() <= second_ifd) second_ifd = 0; // RAW information IFD on older uint32 third_ifd = data[95] | (data[94]<<8) | (data[93]<<16) | (data[92]<<24); if (mInput->getSize() <= third_ifd) third_ifd = 0; // Open the IFDs and merge them try { FileMap *m1 = new FileMap(mInput->getDataWrt(first_ifd), mInput->getSize()-first_ifd); FileMap *m2 = NULL; TiffParser p(m1); p.parseData(); if (second_ifd) { m2 = new FileMap(mInput->getDataWrt(second_ifd), mInput->getSize()-second_ifd); try { TiffParser p2(m2); p2.parseData(); p.MergeIFD(&p2); } catch (TiffParserException e) { delete m2; m2 = NULL; } } TiffIFD *new_ifd = new TiffIFD(mInput); p.RootIFD()->mSubIFD.push_back(new_ifd); if (third_ifd) { try { ParseFuji(third_ifd, new_ifd); } catch (TiffParserException e) { } } // Make sure these aren't leaked. RawDecoder *d = p.getDecoder(); d->ownedObjects.push_back(m1); if (m2) d->ownedObjects.push_back(m2); if (!m2 && second_ifd) { TiffEntry *entry = new TiffEntry(FUJI_STRIPOFFSETS, TIFF_LONG, 1); entry->setData(&second_ifd, 4); new_ifd->mEntry[entry->tag] = entry; entry = new TiffEntry(FUJI_STRIPBYTECOUNTS, TIFF_LONG, 1); uint32 max_size = mInput->getSize()-second_ifd; entry->setData(&max_size, 4); new_ifd->mEntry[entry->tag] = entry; } return d; } catch (TiffParserException) {} ThrowRDE("No decoder found. Sorry."); } // Ordinary TIFF images try { TiffParser p(mInput); p.parseData(); return p.getDecoder(); } catch (TiffParserException) {} try { X3fParser parser(mInput); return parser.getDecoder(); } catch (RawDecoderException) { } // CIFF images try { CiffParser p(mInput); p.parseData(); return p.getDecoder(); } catch (CiffParserException) { } // Detect camera on filesize (CHDK). if (meta != NULL && meta->hasChdkCamera(mInput->getSize())) { Camera* c = meta->getChdkCamera(mInput->getSize()); try { return new NakedDecoder(mInput, c); } catch (RawDecoderException) { } } // File could not be decoded, so no further options for now. ThrowRDE("No decoder found. Sorry."); return NULL; }
RawImage NefDecoder::decodeRawInternal() { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(CFAPATTERN); if (data.empty()) ThrowRDE("NEF Decoder: No image data found"); TiffIFD* raw = data[0]; int compression = raw->getEntry(COMPRESSION)->getInt(); data = mRootIFD->getIFDsWithTag(MODEL); if (data.empty()) ThrowRDE("NEF Decoder: No model data found"); TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); if (!data[0]->getEntry(MODEL)->getString().compare("NIKON D100 ")) { /**Sigh**/ if (!mFile->isValid(offsets->getInt())) ThrowRDE("NEF Decoder: Image data outside of file."); if (!D100IsCompressed(offsets->getInt())) { DecodeD100Uncompressed(); return mRaw; } } if (compression == 1 || (hints.find(string("force_uncompressed")) != hints.end()) || NEFIsUncompressed(raw)) { DecodeUncompressed(); return mRaw; } if (NEFIsUncompressedRGB(raw)) { DecodeSNefUncompressed(); return mRaw; } if (offsets->count != 1) { ThrowRDE("NEF Decoder: Multiple Strips found: %u", offsets->count); } if (counts->count != offsets->count) { ThrowRDE("NEF Decoder: Byte count number does not match strip size: count:%u, strips:%u ", counts->count, offsets->count); } if (!mFile->isValid(offsets->getInt(), counts->getInt())) ThrowRDE("NEF Decoder: Invalid strip byte count. File probably truncated."); if (34713 != compression) ThrowRDE("NEF Decoder: Unsupported compression"); uint32 width = raw->getEntry(IMAGEWIDTH)->getInt(); uint32 height = raw->getEntry(IMAGELENGTH)->getInt(); uint32 bitPerPixel = raw->getEntry(BITSPERSAMPLE)->getInt(); mRaw->dim = iPoint2D(width, height); mRaw->createData(); data = mRootIFD->getIFDsWithTag((TiffTag)0x8c); if (data.empty()) ThrowRDE("NEF Decoder: Decompression info tag not found"); TiffEntry *meta; if (data[0]->hasEntry((TiffTag)0x96)) { meta = data[0]->getEntry((TiffTag)0x96); } else { meta = data[0]->getEntry((TiffTag)0x8c); // Fall back } try { NikonDecompressor decompressor(mFile, mRaw); decompressor.uncorrectedRawValues = uncorrectedRawValues; ByteStream* metastream; if (getHostEndianness() == data[0]->endian) metastream = new ByteStream(meta->getData(), meta->count); else metastream = new ByteStreamSwap(meta->getData(), meta->count); decompressor.DecompressNikon(metastream, width, height, bitPerPixel, offsets->getInt(), counts->getInt()); delete metastream; } catch (IOException &e) { mRaw->setError(e.what()); // Let's ignore it, it may have delivered somewhat useful data. } return mRaw; }
RawImage Cr2Decoder::decodeRawInternal() { if(hints.find("old_format") != hints.end()) { uint32 off = 0; if (mRootIFD->getEntryRecursive((TiffTag)0x81)) off = mRootIFD->getEntryRecursive((TiffTag)0x81)->getInt(); else { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(CFAPATTERN); if (data.empty()) ThrowRDE("CR2 Decoder: Couldn't find offset"); else { if (data[0]->hasEntry(STRIPOFFSETS)) off = data[0]->getEntry(STRIPOFFSETS)->getInt(); else ThrowRDE("CR2 Decoder: Couldn't find offset"); } } ByteStream *b; if (getHostEndianness() == big) b = new ByteStream(mFile, off+41); else b = new ByteStreamSwap(mFile, off+41); uint32 height = b->getShort(); uint32 width = b->getShort(); // Every two lines can be encoded as a single line, probably to try and get // better compression by getting the same RGBG sequence in every line if(hints.find("double_line_ljpeg") != hints.end()) { height *= 2; mRaw->dim = iPoint2D(width*2, height/2); } else { width *= 2; mRaw->dim = iPoint2D(width, height); } mRaw->createData(); LJpegPlain *l = new LJpegPlain(mFile, mRaw); try { l->startDecoder(off, mFile->getSize()-off, 0, 0); } catch (IOException& e) { mRaw->setError(e.what()); } delete l; if(hints.find("double_line_ljpeg") != hints.end()) { // We now have a double width half height image we need to convert to the // normal format iPoint2D final_size(width, height); RawImage procRaw = RawImage::create(final_size, TYPE_USHORT16, 1); procRaw->metadata = mRaw->metadata; procRaw->copyErrorsFrom(mRaw); for (uint32 y = 0; y < height; y++) { ushort16 *dst = (ushort16*)procRaw->getData(0,y); ushort16 *src = (ushort16*)mRaw->getData(y%2 == 0 ? 0 : width, y/2); for (uint32 x = 0; x < width; x++) dst[x] = src[x]; } mRaw = procRaw; } if (mRootIFD->getEntryRecursive((TiffTag)0x123)) { TiffEntry *curve = mRootIFD->getEntryRecursive((TiffTag)0x123); if (curve->type == TIFF_SHORT && curve->count == 4096) { TiffEntry *linearization = mRootIFD->getEntryRecursive((TiffTag)0x123); uint32 len = linearization->count; ushort16 *table = new ushort16[len]; linearization->getShortArray(table, len); if (!uncorrectedRawValues) { mRaw->setTable(table, 4096, true); // Apply table mRaw->sixteenBitLookup(); // Delete table mRaw->setTable(NULL); } else { // We want uncorrected, but we store the table. mRaw->setTable(table, 4096, false); } } } return mRaw; } vector<TiffIFD*> data = mRootIFD->getIFDsWithTag((TiffTag)0xc5d8); if (data.empty()) ThrowRDE("CR2 Decoder: No image data found"); TiffIFD* raw = data[0]; mRaw = RawImage::create(); mRaw->isCFA = true; vector<Cr2Slice> slices; int completeH = 0; bool doubleHeight = false; try { TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); // Iterate through all slices for (uint32 s = 0; s < offsets->count; s++) { Cr2Slice slice; slice.offset = offsets[0].getInt(); slice.count = counts[0].getInt(); SOFInfo sof; LJpegPlain *l = new LJpegPlain(mFile, mRaw); l->getSOF(&sof, slice.offset, slice.count); delete l; slice.w = sof.w * sof.cps; slice.h = sof.h; if (sof.cps == 4 && slice.w > slice.h * 4) { doubleHeight = true; } if (!slices.empty()) if (slices[0].w != slice.w) ThrowRDE("CR2 Decoder: Slice width does not match."); if (mFile->isValid(slice.offset, slice.count)) // Only decode if size is valid slices.push_back(slice); completeH += slice.h; } } catch (TiffParserException) { ThrowRDE("CR2 Decoder: Unsupported format."); } // Override with canon_double_height if set. map<string,string>::iterator msb_hint = hints.find("canon_double_height"); if (msb_hint != hints.end()) doubleHeight = (0 == (msb_hint->second).compare("true")); if (slices.empty()) { ThrowRDE("CR2 Decoder: No Slices found."); } mRaw->dim = iPoint2D(slices[0].w, completeH); // Fix for Canon 6D mRaw, which has flipped width & height for some part of the image // In that case, we swap width and height, since this is the correct dimension bool flipDims = false; bool wrappedCr2Slices = false; if (raw->hasEntry((TiffTag)0xc6c5)) { ushort16 ss = raw->getEntry((TiffTag)0xc6c5)->getInt(); // sRaw if (ss == 4) { mRaw->dim.x /= 3; mRaw->setCpp(3); mRaw->isCFA = false; // Fix for Canon 80D mraw format. // In that format, the frame (as read by getSOF()) is 4032x3402, while the // real image should be 4536x3024 (where the full vertical slices in // the frame "wrap around" the image. if (hints.find("wrapped_cr2_slices") != hints.end() && raw->hasEntry(IMAGEWIDTH) && raw->hasEntry(IMAGELENGTH)) { wrappedCr2Slices = true; int w = raw->getEntry(IMAGEWIDTH)->getInt(); int h = raw->getEntry(IMAGELENGTH)->getInt(); if (w * h != mRaw->dim.x * mRaw->dim.y) { ThrowRDE("CR2 Decoder: Wrapped slices don't match image size"); } mRaw->dim = iPoint2D(w, h); } } flipDims = mRaw->dim.x < mRaw->dim.y; if (flipDims) { int w = mRaw->dim.x; mRaw->dim.x = mRaw->dim.y; mRaw->dim.y = w; } } mRaw->createData(); vector<int> s_width; if (raw->hasEntry(CANONCR2SLICE)) { TiffEntry *ss = raw->getEntry(CANONCR2SLICE); for (int i = 0; i < ss->getShort(0); i++) { s_width.push_back(ss->getShort(1)); } s_width.push_back(ss->getShort(2)); } else { s_width.push_back(slices[0].w); } uint32 offY = 0; if (s_width.size() > 15) ThrowRDE("CR2 Decoder: No more than 15 slices supported"); _RPT1(0,"Org slices:%d\n", s_width.size()); for (uint32 i = 0; i < slices.size(); i++) { Cr2Slice slice = slices[i]; try { LJpegPlain *l = new LJpegPlain(mFile, mRaw); l->addSlices(s_width); l->mUseBigtable = true; l->mCanonFlipDim = flipDims; l->mCanonDoubleHeight = doubleHeight; l->mWrappedCr2Slices = wrappedCr2Slices; l->startDecoder(slice.offset, slice.count, 0, offY); delete l; } catch (RawDecoderException &e) { if (i == 0) throw; // These may just be single slice error - store the error and move on mRaw->setError(e.what()); } catch (IOException &e) { // Let's try to ignore this - it might be truncated data, so something might be useful. mRaw->setError(e.what()); } offY += slice.w; } if (mRaw->metadata.subsampling.x > 1 || mRaw->metadata.subsampling.y > 1) sRawInterpolate(); return mRaw; }
RawImage NefDecoder::decodeRawInternal() { vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(CFAPATTERN); if (data.empty()) ThrowRDE("NEF Decoder: No image data found"); TiffIFD* raw = data[0]; int compression = raw->getEntry(COMPRESSION)->getInt(); data = mRootIFD->getIFDsWithTag(MODEL); if (data.empty()) ThrowRDE("NEF Decoder: No model data found"); TiffEntry *offsets = raw->getEntry(STRIPOFFSETS); TiffEntry *counts = raw->getEntry(STRIPBYTECOUNTS); if (!data[0]->getEntry(MODEL)->getString().compare("NIKON D100 ")) { /**Sigh**/ if (!mFile->isValid(offsets->getInt())) ThrowRDE("NEF Decoder: Image data outside of file."); if (!D100IsCompressed(offsets->getInt())) { DecodeD100Uncompressed(); return mRaw; } } if (compression == 1) { DecodeUncompressed(); return mRaw; } if (offsets->count != 1) { ThrowRDE("NEF Decoder: Multiple Strips found: %u", offsets->count); } if (counts->count != offsets->count) { ThrowRDE("NEF Decoder: Byte count number does not match strip size: count:%u, strips:%u ", counts->count, offsets->count); } if (!mFile->isValid(offsets->getInt() + counts->getInt())) ThrowRDE("NEF Decoder: Invalid strip byte count. File probably truncated."); if (34713 != compression) ThrowRDE("NEF Decoder: Unsupported compression"); uint32 width = raw->getEntry(IMAGEWIDTH)->getInt(); uint32 height = raw->getEntry(IMAGELENGTH)->getInt(); uint32 bitPerPixel = raw->getEntry(BITSPERSAMPLE)->getInt(); mRaw->dim = iPoint2D(width, height); mRaw->createData(); data = mRootIFD->getIFDsWithTag(MAKERNOTE); if (data.empty()) ThrowRDE("NEF Decoder: No EXIF data found"); TiffIFD* exif = data[0]; TiffEntry *makernoteEntry = exif->getEntry(MAKERNOTE); const uchar8* makernote = makernoteEntry->getData(); FileMap makermap((uchar8*)&makernote[10], mFile->getSize() - makernoteEntry->getDataOffset() - 10); TiffParser makertiff(&makermap); makertiff.parseData(); data = makertiff.RootIFD()->getIFDsWithTag((TiffTag)0x8c); if (data.empty()) ThrowRDE("NEF Decoder: Decompression info tag not found"); TiffEntry *meta; try { meta = data[0]->getEntry((TiffTag)0x96); } catch (TiffParserException) { meta = data[0]->getEntry((TiffTag)0x8c); // Fall back } try { NikonDecompressor decompressor(mFile, mRaw); ByteStream* metastream; if (getHostEndianness() == data[0]->endian) metastream = new ByteStream(meta->getData(), meta->count); else metastream = new ByteStreamSwap(meta->getData(), meta->count); decompressor.DecompressNikon(metastream, width, height, bitPerPixel, offsets->getInt(), counts->getInt()); delete metastream; } catch (IOException &e) { mRaw->setError(e.what()); // Let's ignore it, it may have delivered somewhat useful data. } return mRaw; }