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;
}
