void Cr2Decoder::checkSupportInternal(CameraMetaData *meta) {
vector<TiffIFD*> data = mRootIFD->getIFDsWithTag(MODEL);
if (data.empty())
ThrowRDE("CR2 Support check: Model name not found");
if (!data[0]->hasEntry(MAKE))
ThrowRDE("CR2 Support: Make name not found");
string make = data[0]->getEntry(MAKE)->getString();
string model = data[0]->getEntry(MODEL)->getString();
// Check for sRaw mode
data = mRootIFD->getIFDsWithTag((TiffTag)0xc5d8);
if (!data.empty()) {
TiffIFD* raw = data[0];
if (raw->hasEntry((TiffTag)0xc6c5)) {
ushort16 ss = raw->getEntry((TiffTag)0xc6c5)->getInt();
if (ss == 4) {
this->checkCameraSupported(meta, make, model, "sRaw1");
return;
}
}
}
this->checkCameraSupported(meta, make, model, "");
}
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;
}
RawImage Cr2Decoder::decodeRawInternal() {
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;
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(mFile, mRaw);
l.getSOF(&sof, slice.offset, slice.count);
slice.w = sof.w * sof.cps;
slice.h = sof.h;
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.");
}
if (slices.empty()) {
ThrowRDE("CR2 Decoder: No Slices found.");
}
mRaw->dim = iPoint2D(slices[0].w, completeH);
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;
}
}
mRaw->createData();
vector<int> s_width;
if (raw->hasEntry(CANONCR2SLICE)) {
const ushort16 *ss = raw->getEntry(CANONCR2SLICE)->getShortArray();
for (int i = 0; i < ss[0]; i++) {
s_width.push_back(ss[1]);
}
s_width.push_back(ss[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(mFile, mRaw);
l.addSlices(s_width);
l.mUseBigtable = true;
l.startDecoder(slice.offset, slice.count, 0, offY);
} catch (RawDecoderException &e) {
if (i == 0)
throw;
// These may just be single slice error - store the error and move on
errors.push_back(_strdup(e.what()));
} catch (IOException &e) {
// Let's try to ignore this - it might be truncated data, so something might be useful.
errors.push_back(_strdup(e.what()));
}
offY += slice.w;
}
if (mRaw->subsampling.x > 1 || mRaw->subsampling.y > 1)
sRawInterpolate();
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;
}
