int set_date(const ExifData& exif, char date[])
{
const ExifData::const_iterator end = exif.end();
ExifData::const_iterator value = exif.findKey(ExifDateTimeCreated);
if(value == end)
value = exif.findKey(ExifDateTimeDigitized);
if(value == end)
return 1;
const std::string dateTime = value->value().toString();
if(!dateTime.empty())
{
//*date = (char*)realloc(*date, (dateTime.length() + 1) * sizeof(char));
strcpy(date, const_cast<char*>(dateTime.c_str()));
// format gets returned as 'YYYY:MM:DD HH:MM:SS' when it
// needs to be 'YYYY-MM-DDTHH:MM:SS' so fix separators
char* dateStr = date;
if(dateTime.length() > 4 && dateStr[4] != '-')
dateStr[4] = '-';
if(dateTime.length() > 6 && dateStr[7] != '-')
dateStr[7] = '-';
if(dateTime.length() > 10 && dateStr[10] != 'T')
dateStr[10] = 'T';
}
return 0;
}
int set_long_value(const ExifData& exif, const ExifKey& key, unsigned int& field)
{
const ExifData::const_iterator end = exif.end();
const ExifData::const_iterator value = exif.findKey(key);
if(value == end)
return -1;
field = value->value().toLong();
return 0;
}
ExifData::const_iterator isoSpeed(const ExifData& ed)
{
static const char* keys[] = {
"Exif.Photo.ISOSpeedRatings",
"Exif.Image.ISOSpeedRatings",
"Exif.CanonSi.ISOSpeed",
"Exif.CanonCs.ISOSpeed",
"Exif.Nikon1.ISOSpeed",
"Exif.Nikon2.ISOSpeed",
"Exif.Nikon3.ISOSpeed",
"Exif.NikonIi.ISO",
"Exif.NikonIi.ISO2",
"Exif.MinoltaCsNew.ISOSetting",
"Exif.MinoltaCsOld.ISOSetting",
"Exif.MinoltaCs5D.ISOSpeed",
"Exif.MinoltaCs7D.ISOSpeed",
"Exif.Sony1Cs.ISOSetting",
"Exif.Sony2Cs.ISOSetting",
"Exif.Sony1Cs2.ISOSetting",
"Exif.Sony2Cs2.ISOSetting",
"Exif.Sony1MltCsA100.ISOSetting",
"Exif.Pentax.ISO",
"Exif.PentaxDng.ISO",
"Exif.Olympus.ISOSpeed",
"Exif.Samsung2.ISO",
"Exif.Casio.ISO",
"Exif.Casio2.ISO",
"Exif.Casio2.ISOSpeed"
};
// Find the first ISO value which is not "0"
const int cnt = EXV_COUNTOF(keys);
ExifData::const_iterator md = ed.end();
for (int idx = 0; idx < cnt; ) {
md = findMetadatum(ed, keys + idx, cnt - idx);
if (md == ed.end()) break;
std::ostringstream os;
md->write(os, &ed);
bool ok = false;
long v = parseLong(os.str(), ok);
if (ok && v != 0) break;
while (strcmp(keys[idx++], md->key().c_str()) != 0 && idx < cnt) {}
md = ed.end();
}
return md;
}
void exifPrint(const ExifData& exifData)
{
ExifData::const_iterator i = exifData.begin();
for (; i != exifData.end(); ++i) {
std::cout << std::setw(44) << std::setfill(' ') << std::left
<< i->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << i->tag() << " "
<< std::setw(9) << std::setfill(' ') << std::left
<< i->typeName() << " "
<< std::dec << std::setw(3)
<< std::setfill(' ') << std::right
<< i->count() << " "
<< std::dec << i->value()
<< "\n";
}
}
WriteMethod Cr2Parser::encode(
BasicIo& io,
const byte* pData,
uint32_t size,
ByteOrder byteOrder,
const ExifData& exifData,
const IptcData& iptcData,
const XmpData& xmpData
)
{
// Copy to be able to modify the Exif data
ExifData ed = exifData;
// Delete IFDs which do not occur in TIFF images
static const IfdId filteredIfds[] = {
panaRawId
};
for (unsigned int i = 0; i < EXV_COUNTOF(filteredIfds); ++i) {
#ifdef DEBUG
std::cerr << "Warning: Exif IFD " << filteredIfds[i] << " not encoded\n";
#endif
ed.erase(std::remove_if(ed.begin(),
ed.end(),
FindExifdatum(filteredIfds[i])),
ed.end());
}
std::auto_ptr<TiffHeaderBase> header(new Cr2Header(byteOrder));
OffsetWriter offsetWriter;
offsetWriter.setOrigin(OffsetWriter::cr2RawIfdOffset, Cr2Header::offset2addr(), byteOrder);
return TiffParserWorker::encode(io,
pData,
size,
ed,
iptcData,
xmpData,
Tag::root,
TiffMapping::findEncoder,
header.get(),
&offsetWriter);
}
void print(const ExifData& exifData)
{
if (exifData.empty()) {
std::string error("No Exif data found in the file");
throw Exiv2::Error(1, error);
}
Exiv2::ExifData::const_iterator end = exifData.end();
for (Exiv2::ExifData::const_iterator i = exifData.begin(); i != end; ++i) {
std::cout << std::setw(44) << std::setfill(' ') << std::left
<< i->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << i->tag() << " "
<< std::setw(9) << std::setfill(' ') << std::left
<< i->typeName() << " "
<< std::dec << std::setw(3)
<< std::setfill(' ') << std::right
<< i->count() << " "
<< std::dec << i->value()
<< "\n";
}
}
void exiv2_dump_tags(const ExifData& exif)
{
cout << "exiv2_dump_tags: " << endl;
Exiv2::ExifData::const_iterator end = exif.end();
for (Exiv2::ExifData::const_iterator i = exif.begin(); i != end; ++i)
{
std::cout << std::setw(44) << std::setfill(' ') << std::left
<< i->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << i->tag() << " "
<< std::setw(9) << std::setfill(' ') << std::left
<< i->typeName() << " "
<< std::dec << std::setw(3)
<< std::setfill(' ') << std::right
<< i->count() << " "
<< std::dec << i->value()
<< "\n";
}
}
uint32_t PsdImage::writeExifData(const ExifData& exifData, BasicIo& out)
{
uint32_t resLength = 0;
byte buf[8];
if (exifData.count() > 0) {
Blob blob;
ByteOrder bo = byteOrder();
if (bo == invalidByteOrder) {
bo = littleEndian;
setByteOrder(bo);
}
ExifParser::encode(blob, bo, exifData);
if (blob.size() > 0) {
#ifdef DEBUG
std::cerr << std::hex << "write: resourceId: " << kPhotoshopResourceID_ExifInfo << "\n";
std::cerr << std::dec << "Writing ExifInfo: size: " << blob.size() << "\n";
#endif
ul2Data(buf, kPhotoshopResourceType, bigEndian);
if (out.write(buf, 4) != 4) throw Error(21);
us2Data(buf, kPhotoshopResourceID_ExifInfo, bigEndian);
if (out.write(buf, 2) != 2) throw Error(21);
us2Data(buf, 0, bigEndian); // NULL resource name
if (out.write(buf, 2) != 2) throw Error(21);
ul2Data(buf, blob.size(), bigEndian);
if (out.write(buf, 4) != 4) throw Error(21);
// Write encoded Exif data
if (out.write(&blob[0], blob.size()) != static_cast<long>(blob.size())) throw Error(21);
resLength += blob.size() + 12;
if (blob.size() & 1) // even padding
{
buf[0] = 0;
if (out.write(buf, 1) != 1) throw Error(21);
resLength++;
}
}
}
return resLength;
} // PsdImage::writeExifData
WriteMethod ExifParser::encode(
Blob& blob,
const byte* pData,
uint32_t size,
ByteOrder byteOrder,
const ExifData& exifData
)
{
ExifData ed = exifData;
// Delete IFD0 tags that are "not recorded" in compressed images
// Reference: Exif 2.2 specs, 4.6.8 Tag Support Levels, section A
static const char* filteredIfd0Tags[] = {
"Exif.Image.PhotometricInterpretation",
"Exif.Image.StripOffsets",
"Exif.Image.RowsPerStrip",
"Exif.Image.StripByteCounts",
"Exif.Image.JPEGInterchangeFormat",
"Exif.Image.JPEGInterchangeFormatLength",
"Exif.Image.SubIFDs"
};
for (unsigned int i = 0; i < EXV_COUNTOF(filteredIfd0Tags); ++i) {
ExifData::iterator pos = ed.findKey(ExifKey(filteredIfd0Tags[i]));
if (pos != ed.end()) {
#ifdef DEBUG
std::cerr << "Warning: Exif tag " << pos->key() << " not encoded\n";
#endif
ed.erase(pos);
}
}
// Delete IFDs which do not occur in JPEGs
static const IfdId filteredIfds[] = {
subImage1Id,
subImage2Id,
subImage3Id,
subImage4Id,
subImage5Id,
subImage6Id,
subImage7Id,
subImage8Id,
subImage9Id,
subThumb1Id,
panaRawId,
ifd2Id,
ifd3Id
};
for (unsigned int i = 0; i < EXV_COUNTOF(filteredIfds); ++i) {
#ifdef DEBUG
std::cerr << "Warning: Exif IFD " << filteredIfds[i] << " not encoded\n";
#endif
eraseIfd(ed, filteredIfds[i]);
}
// IPTC and XMP are stored elsewhere, not in the Exif APP1 segment.
IptcData emptyIptc;
XmpData emptyXmp;
// Encode and check if the result fits into a JPEG Exif APP1 segment
MemIo mio1;
std::auto_ptr<TiffHeaderBase> header(new TiffHeader(byteOrder, 0x00000008, false));
WriteMethod wm = TiffParserWorker::encode(mio1,
pData,
size,
ed,
emptyIptc,
emptyXmp,
Tag::root,
TiffMapping::findEncoder,
header.get(),
0);
if (mio1.size() <= 65527) {
append(blob, mio1.mmap(), mio1.size());
return wm;
}
// If it doesn't fit, remove additional tags
// Delete preview tags if the preview is larger than 32kB.
// Todo: Enhance preview classes to be able to write and delete previews and use that instead.
// Table must be sorted by preview, the first tag in each group is the size
static const PreviewTags filteredPvTags[] = {
{ pttLen, "Exif.Minolta.ThumbnailLength" },
{ pttTag, "Exif.Minolta.ThumbnailOffset" },
{ pttLen, "Exif.Minolta.Thumbnail" },
{ pttLen, "Exif.NikonPreview.JPEGInterchangeFormatLength" },
{ pttIfd, "NikonPreview" },
{ pttLen, "Exif.Olympus.ThumbnailLength" },
{ pttTag, "Exif.Olympus.ThumbnailOffset" },
{ pttLen, "Exif.Olympus.ThumbnailImage" },
{ pttLen, "Exif.Olympus.Thumbnail" },
{ pttLen, "Exif.Olympus2.ThumbnailLength" },
{ pttTag, "Exif.Olympus2.ThumbnailOffset" },
{ pttLen, "Exif.Olympus2.ThumbnailImage" },
{ pttLen, "Exif.Olympus2.Thumbnail" },
{ pttLen, "Exif.OlympusCs.PreviewImageLength" },
{ pttTag, "Exif.OlympusCs.PreviewImageStart" },
{ pttTag, "Exif.OlympusCs.PreviewImageValid" },
{ pttLen, "Exif.Pentax.PreviewLength" },
{ pttTag, "Exif.Pentax.PreviewOffset" },
{ pttTag, "Exif.Pentax.PreviewResolution" },
{ pttLen, "Exif.PentaxDng.PreviewLength" },
{ pttTag, "Exif.PentaxDng.PreviewOffset" },
{ pttTag, "Exif.PentaxDng.PreviewResolution" },
{ pttLen, "Exif.SamsungPreview.JPEGInterchangeFormatLength" },
{ pttIfd, "SamsungPreview" },
{ pttLen, "Exif.Thumbnail.StripByteCounts" },
{ pttIfd, "Thumbnail" },
{ pttLen, "Exif.Thumbnail.JPEGInterchangeFormatLength" },
{ pttIfd, "Thumbnail" }
};
bool delTags = false;
ExifData::iterator pos;
for (unsigned int i = 0; i < EXV_COUNTOF(filteredPvTags); ++i) {
switch (filteredPvTags[i].ptt_) {
case pttLen:
delTags = false;
pos = ed.findKey(ExifKey(filteredPvTags[i].key_));
if (pos != ed.end() && sumToLong(*pos) > 32768) {
delTags = true;
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Exif tag " << pos->key() << " not encoded\n";
#endif
ed.erase(pos);
}
break;
case pttTag:
if (delTags) {
pos = ed.findKey(ExifKey(filteredPvTags[i].key_));
if (pos != ed.end()) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Exif tag " << pos->key() << " not encoded\n";
#endif
ed.erase(pos);
}
}
break;
case pttIfd:
if (delTags) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Exif IFD " << filteredPvTags[i].key_ << " not encoded\n";
#endif
eraseIfd(ed, Internal::groupId(filteredPvTags[i].key_));
}
break;
}
}
// Delete unknown tags larger than 4kB and known tags larger than 40kB.
for (ExifData::iterator pos = ed.begin(); pos != ed.end(); ) {
if ( (pos->size() > 4096 && pos->tagName().substr(0, 2) == "0x")
|| pos->size() > 40960) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Exif tag " << pos->key() << " not encoded\n";
#endif
pos = ed.erase(pos);
}
else {
++pos;
}
}
// Encode the remaining Exif tags again, don't care if it fits this time
MemIo mio2;
wm = TiffParserWorker::encode(mio2,
pData,
size,
ed,
emptyIptc,
emptyXmp,
Tag::root,
TiffMapping::findEncoder,
header.get(),
0);
append(blob, mio2.mmap(), mio2.size());
#ifdef DEBUG
if (wm == wmIntrusive) {
std::cerr << "SIZE OF EXIF DATA IS " << std::dec << mio2.size() << " BYTES\n";
}
else {
std::cerr << "SIZE DOESN'T MATTER, NON-INTRUSIVE WRITING USED\n";
}
#endif
return wm;
} // ExifParser::encode
void Exiv2Lib::setWhiteBalanceCoeffsCanon(ExifData& data, float wb[3])
{
ExifData::const_iterator pos;
if (*mExifInfo.model == "Canon EOS 300D DIGITAL" ||
*mExifInfo.model == "Canon EOS DIGITAL REBEL")
{
pos = data.findKey(ExifKey("Exif.Canon.WhiteBalanceTable"));
if (pos != data.end())
{
qDebug() << "Reading EOS 300D tags";
uint16_t* cdata = new uint16_t[pos->size() / 2];
pos->copy((unsigned char*)cdata, littleEndian);
wb[0] = cdata[1];
wb[1] = (cdata[2] + cdata[3]) / 2;
wb[2] = cdata[4];
float mx = max3(wb[0], wb[1], wb[2]);
wb[0] /= mx;
wb[1] /= mx;
wb[2] /= mx;
delete [] cdata;
return;
}
}
pos = data.findKey(ExifKey("Exif.Canon.ColorData"));
if (pos != data.end())
{
uint8_t* cdata = new uint8_t[pos->size()];
struct Canon_ColorData* colorData;
pos->copy(cdata, littleEndian);
colorData = (struct Canon_ColorData*)cdata;
if (*mExifInfo.model == "Canon EOS 350D DIGITAL") // || EOS 20D
{
// optimize with bitshifts later
// wb[0] = colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[2];
// wb[1] = ((colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[1]+colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[3])/2);
// wb[2] = colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[0];
wb[0] = colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[0];
wb[1] =
((colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[1] +
colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[2]) / 2);
wb[2] = colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[3];
qDebug() << "WB EOS 350D DIGITAL RGGB" << wb[0] << "," << wb[1] <<
"," << wb[2];
}
else if (*mExifInfo.model == "Canon EOS 1D Mark II") // || 1Ds Mark II
{
qDebug() << "Whitebalance info unavailable";
}
else if (*mExifInfo.model == "Canon G10")
{
qDebug() << "Whitebalance info unavailable";
}
else if (*mExifInfo.model == "Canon PowerShot S30")
{
wb[0] = colorData->V5.WhiteBalanceTable[WB_AsShot].GRBG[1];
wb[1] =
(colorData->V5.WhiteBalanceTable[WB_AsShot].GRBG[0] +
colorData->V5.WhiteBalanceTable[WB_AsShot].GRBG[3]) / 2;
wb[2] = colorData->V5.WhiteBalanceTable[WB_AsShot].GRBG[2];
}
else if (*mExifInfo.model == "Canon PowerShot S110")
{
wb[0] = colorData->V3.WhiteBalanceTable[WB_AsShot].RGGB[0];
wb[1] = (colorData->V3.WhiteBalanceTable[WB_AsShot].RGGB[1] +
colorData->V3.WhiteBalanceTable[WB_AsShot].RGGB[2]) / 2;
wb[2] = colorData->V3.WhiteBalanceTable[WB_AsShot].RGGB[3];
}
else // attempt to read at the default position at V4
{
qDebug() <<
"Model unknown, Parsing whitebalance using canon default format";
qDebug() << "Color data version: " << colorData->V7.version;
// optimize with bitshifs later
wb[0] = colorData->V7.WhiteBalanceTable[WB_AsShot].RGGB[0];
wb[1] =
(colorData->V7.WhiteBalanceTable[WB_AsShot].RGGB[1] +
colorData->V7.WhiteBalanceTable[WB_AsShot].RGGB[2]) / 2;
wb[2] = colorData->V7.WhiteBalanceTable[WB_AsShot].RGGB[3];
}
float mx = max3(wb[0], wb[1], wb[2]);
wb[0] /= mx;
wb[1] /= mx;
wb[2] /= mx;
delete [] cdata;
}
else
{
//qDebug() << "no such exif key";
wb[0] = 1.0;
wb[1] = 1.0;
wb[2] = 1.0;
}
// qDebug() << "WB RGGB Multipliers" <<wb[0] <<","<<wb[1]<<","<<wb[2];
}
void Exiv2Lib::setWhiteBalanceCoeffsNikon(ExifData& data, float wb[3])
{
ExifData::const_iterator pos;
/*
* This seems to be unnecessary as the multipliers are also
* available as rational numbers in the WB_RBLevels tag
*/
/*
pos = data.findKey(ExifKey("Exif.Nikon3.Version"));
int makerNoteVersion = -1;
if (pos != data.end())
{
char* buf = new char[pos->size()];
pos->copy((unsigned char*)buf, littleEndian);
QString val(buf);
qDebug() << val;
delete [] buf;
makerNoteVersion = val.toInt();
}
qDebug() << "Nikon makenote version:" << makerNoteVersion;
if (makerNoteVersion >= 200)
{
qDebug() << "Decrypt Nikon Color Balance";
}
*/
pos = data.findKey(ExifKey("Exif.Nikon3.WB_RBLevels"));
if (pos != data.end())
{
if (*mExifInfo.model == "NIKON D300")
{
wb[0] = 1.0f;
wb[1] = 1.0f;
wb[2] = 1.0f;
// wb[0] = colorData->V3.WhiteBalanceTable[WB_AsShot].RGGB[0];
// wb[1] =
// ((colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[1] +
// colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[2]) / 2);
// wb[2] = colorData->V1.WhiteBalanceTable[WB_AsShot].RGGB[3];
qDebug() << "White balance for model Nikon D300";
if (pos != data.end())
{
wb[0] = pos->toFloat(0);
wb[1] = 1.0f;
wb[2] = pos->toFloat(1);
qDebug() << "Nikon: RGB" << wb[0] << "," << wb[1] << "," <<
wb[2];
}
}
float mx = max3(wb[0], wb[1], wb[2]);
wb[0] /= mx;
wb[1] /= mx;
wb[2] /= mx;
}
else
{
qDebug () << "Nikon: Color balance data not available";
wb[0] = 1.0f;
wb[1] = 1.0f;
wb[2] = 1.0f;
}
}
bool ScImgDataLoader_JPEG::loadPicture(const QString& fn, int /*page*/, int res, bool thumbnail)
{
bool isCMYK = false;
bool fromPS = false;
float xres = 72.0, yres = 72.0;
if (!QFile::exists(fn))
return false;
ExifData ExifInf;
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
FILE *infile;
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = my_error_exit;
infile = NULL;
initialize();
m_imageInfoRecord.type = ImageTypeJPG;
m_imageInfoRecord.exifInfo.thumbnail = QImage();
if (setjmp (jerr.setjmp_buffer))
{
jpeg_destroy_decompress (&cinfo);
if (infile)
fclose (infile);
return false;
}
jpeg_create_decompress (&cinfo);
if ((infile = fopen (fn.toLocal8Bit(), "rb")) == NULL)
return false;
jpeg_stdio_src(&cinfo, infile);
jpeg_save_markers(&cinfo, ICC_MARKER, 0xFFFF);
jpeg_save_markers(&cinfo, PHOTOSHOP_MARKER, 0xFFFF);
jpeg_read_header(&cinfo, true);
jpeg_start_decompress(&cinfo);
bool exi = ExifInf.scan(fn);
if ((exi) && (ExifInf.exifDataValid))
{
if (cinfo.output_components == 4)
m_imageInfoRecord.colorspace = ColorSpaceCMYK;
else if (cinfo.output_components == 3)
m_imageInfoRecord.colorspace = ColorSpaceRGB;
else if (cinfo.output_components == 1)
m_imageInfoRecord.colorspace = ColorSpaceGray;
if ((!ExifInf.Thumbnail.isNull()) && thumbnail)
{
m_image = ExifInf.getThumbnail();
m_imageInfoRecord.exifInfo.thumbnail = ExifInf.getThumbnail();
if (cinfo.output_components == 4)
{
QRgb *s;
unsigned char cc, cm, cy, ck;
for( int yit=0; yit < m_image.height(); ++yit )
{
s = (QRgb*)(m_image.scanLine( yit ));
for(int xit=0; xit < m_image.width(); ++xit )
{
cc = 255 - qRed(*s);
cm = 255 - qGreen(*s);
cy = 255 - qBlue(*s);
ck = qMin(qMin(cc, cm), cy);
*s = qRgba(cc-ck,cm-ck,cy-ck,ck);
s++;
}
}
}
}
else
m_imageInfoRecord.exifInfo.thumbnail = QImage();
m_imageInfoRecord.exifInfo.cameraName = ExifInf.getCameraModel();
m_imageInfoRecord.exifInfo.cameraVendor = ExifInf.getCameraMake();
m_imageInfoRecord.exifInfo.comment = ExifInf.getComment();
m_imageInfoRecord.exifInfo.width = ExifInf.getWidth();
m_imageInfoRecord.exifInfo.height = ExifInf.getHeight();
m_imageInfoRecord.exifInfo.userComment = ExifInf.getUserComment();
m_imageInfoRecord.exifInfo.dateTime = ExifInf.getDateTime();
m_imageInfoRecord.exifInfo.ApertureFNumber = ExifInf.getApertureFNumber();
m_imageInfoRecord.exifInfo.ExposureTime = ExifInf.getExposureTime();
m_imageInfoRecord.exifInfo.ISOequivalent = ExifInf.getISOequivalent();
m_imageInfoRecord.exifDataValid = true;
if (cinfo.density_unit == 0)
{
xres = 72;
yres = 72;
}
else if ( cinfo.density_unit == 1 )
{
xres = cinfo.X_density;
yres = cinfo.Y_density;
}
else if ( cinfo.density_unit == 2 )
{
xres = cinfo.X_density * 2.54;
yres = cinfo.Y_density * 2.54;
}
if( xres <= 1.0 || yres <= 1.0 || xres > 3000.0 || yres > 3000.0 )
{
xres = yres = 72.0;
QFileInfo qfi(fn);
m_message = QObject::tr("%1 may be corrupted : missing or wrong resolution tags").arg(qfi.fileName());
m_msgType = warningMsg;
}
m_imageInfoRecord.xres = qRound(xres);
m_imageInfoRecord.yres = qRound(yres);
m_imageInfoRecord.progressive = jpeg_has_multiple_scans(&cinfo);
if ((!ExifInf.Thumbnail.isNull()) && thumbnail)
{
jpeg_destroy_decompress(&cinfo);
fclose(infile);
return true;
}
}
else
m_imageInfoRecord.exifDataValid = false;
m_imageInfoRecord.exifInfo.thumbnail = QImage();
unsigned int EmbedLen = 0;
unsigned char* EmbedBuffer;
if (read_jpeg_marker(ICC_MARKER,&cinfo, &EmbedBuffer, &EmbedLen))
{
QByteArray profArray = QByteArray((const char*) EmbedBuffer, EmbedLen);
ScColorProfile prof = ScColorMgmtEngine::openProfileFromMem(profArray);
m_embeddedProfile = profArray;
m_imageInfoRecord.profileName = prof.productDescription();
m_imageInfoRecord.isEmbedded = true;
free(EmbedBuffer);
}
else
{
m_imageInfoRecord.isEmbedded = false;
m_imageInfoRecord.profileName = "";
}
unsigned int PhotoshopLen = 0;
unsigned char * PhotoshopBuffer;
if (cinfo.density_unit == 0)
{
xres = 72;
yres = 72;
m_image.setDotsPerMeterX(2834);
m_image.setDotsPerMeterY(2834);
}
else if ( cinfo.density_unit == 1 )
{
xres = cinfo.X_density;
yres = cinfo.Y_density;
m_image.setDotsPerMeterX( int(100. * cinfo.X_density / 2.54) );
m_image.setDotsPerMeterY( int(100. * cinfo.Y_density / 2.54) );
}
else if ( cinfo.density_unit == 2 )
{
xres = cinfo.X_density * 2.54;
yres = cinfo.Y_density * 2.54;
m_image.setDotsPerMeterX( int(100. * cinfo.X_density) );
m_image.setDotsPerMeterY( int(100. * cinfo.Y_density) );
}
if( xres <= 1.0 || yres <= 1.0 || xres > 3000.0 || yres > 3000.0 )
{
xres = yres = 72.0;
m_image.setDotsPerMeterX(2834);
m_image.setDotsPerMeterY(2834);
QFileInfo qfi(fn);
m_message = QObject::tr("%1 may be corrupted : missing or wrong resolution tags").arg(qfi.fileName());
m_msgType = warningMsg;
}
m_imageInfoRecord.xres = qRound(xres);
m_imageInfoRecord.yres = qRound(yres);
if (cinfo.output_components == 4)
{
isCMYK = true;
m_imageInfoRecord.colorspace = ColorSpaceCMYK;
}
else if (cinfo.output_components == 3)
m_imageInfoRecord.colorspace = ColorSpaceRGB;
else if (cinfo.output_components == 1)
m_imageInfoRecord.colorspace = ColorSpaceGray;
m_imageInfoRecord.progressive = jpeg_has_multiple_scans(&cinfo);
if (read_jpeg_marker(PHOTOSHOP_MARKER,&cinfo, &PhotoshopBuffer, &PhotoshopLen) )
{
if (PhotoshopLen != 0)
{
bool savEx = m_imageInfoRecord.exifDataValid;
QByteArray arrayPhot(PhotoshopLen, ' ');
arrayPhot = QByteArray::fromRawData((const char*)PhotoshopBuffer,PhotoshopLen);
QDataStream strPhot(&arrayPhot,QIODevice::ReadOnly);
strPhot.setByteOrder( QDataStream::BigEndian );
PSDHeader fakeHeader;
fakeHeader.width = cinfo.output_width;
fakeHeader.height = cinfo.output_height;
if (cinfo.output_components == 4)
m_imageInfoRecord.colorspace = ColorSpaceCMYK;
else if (cinfo.output_components == 3)
m_imageInfoRecord.colorspace = ColorSpaceRGB;
else if (cinfo.output_components == 1)
m_imageInfoRecord.colorspace = ColorSpaceGray;
m_imageInfoRecord.progressive = jpeg_has_multiple_scans(&cinfo);
parseRessourceData(strPhot, fakeHeader, PhotoshopLen);
// Photoshop resolution is more accurate than jpeg header resolution
xres = m_imageInfoRecord.xres;
yres = m_imageInfoRecord.yres;
m_image.setDotsPerMeterX( int(100. * m_imageInfoRecord.xres / 2.54) );
m_image.setDotsPerMeterY( int(100. * m_imageInfoRecord.yres / 2.54) );
if( xres <= 1.0 || yres <= 1.0 || xres > 3000.0 || yres > 3000.0 )
{
xres = yres = 72.0;
m_imageInfoRecord.xres = qRound(xres);
m_imageInfoRecord.yres = qRound(yres);
m_image.setDotsPerMeterX(2834);
m_image.setDotsPerMeterY(2834);
QFileInfo qfi(fn);
m_message = QObject::tr("%1 may be corrupted : missing or wrong resolution tags").arg(qfi.fileName());
m_msgType = warningMsg;
}
if (m_imageInfoRecord.exifDataValid && !m_imageInfoRecord.exifInfo.thumbnail.isNull() && thumbnail)
{
m_image = QImage(m_imageInfoRecord.exifInfo.width, m_imageInfoRecord.exifInfo.height, QImage::Format_ARGB32 );
m_imageInfoRecord.exifInfo.width = cinfo.output_width;
m_imageInfoRecord.exifInfo.height = cinfo.output_height;
if (cinfo.output_components == 4)
{
QRgb *d;
QRgb *s;
unsigned char cc, cm, cy, ck;
for( int yit=0; yit < m_image.height(); ++yit )
{
d = (QRgb*)(m_image.scanLine( yit ));
s = (QRgb*)(m_imageInfoRecord.exifInfo.thumbnail.scanLine( yit ));
for(int xit=0; xit < m_image.width(); ++xit )
{
cc = 255 - qRed(*s);
cm = 255 - qGreen(*s);
cy = 255 - qBlue(*s);
ck = qMin(qMin(cc, cm), cy);
*d = qRgba(cc-ck,cm-ck,cy-ck,ck);
s++;
d++;
}
}
}
else
m_image = m_imageInfoRecord.exifInfo.thumbnail.copy();
}
m_imageInfoRecord.valid = (m_imageInfoRecord.PDSpathData.size())>0?true:false; // The only interest is vectormask
arrayPhot.clear();
free( PhotoshopBuffer );
if (m_imageInfoRecord.exifDataValid && !m_imageInfoRecord.exifInfo.thumbnail.isNull() && thumbnail)
{
jpeg_destroy_decompress(&cinfo);
fclose(infile);
return true;
}
m_imageInfoRecord.exifInfo.thumbnail = QImage();
m_imageInfoRecord.exifDataValid = savEx;
fromPS = true;
}
}
if ( cinfo.output_components == 3 || cinfo.output_components == 4)
m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
else if ( cinfo.output_components == 1 )
{
m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_Indexed8 );
m_image.setNumColors(256);
for (int i=0; i<256; i++)
m_image.setColor(i, qRgb(i,i,i));
}
if (!m_image.isNull())
{
uchar* data = m_image.bits();
int bpl = m_image.bytesPerLine();
while (cinfo.output_scanline < cinfo.output_height)
{
uchar *d = data + cinfo.output_scanline * bpl;
(void) jpeg_read_scanlines(&cinfo, &d, 1);
}
if ( cinfo.output_components == 3 )
{
uchar *in;
QRgb *out;
for (uint j=0; j<cinfo.output_height; j++)
{
in = m_image.scanLine(j) + cinfo.output_width * 3;
out = (QRgb*) m_image.scanLine(j);
for (uint i=cinfo.output_width; i--; )
{
in -= 3;
out[i] = qRgb(in[0], in[1], in[2]);
}
}
}
if ( cinfo.output_components == 4 )
{
int method = 0;
if (cinfo.jpeg_color_space == JCS_YCCK)
method = 1;
else if (fromPS)
{
if ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker) && (cinfo.Adobe_transform == 0))
method = 2;
}
else if ((cinfo.jpeg_color_space == JCS_CMYK) && (cinfo.saw_Adobe_marker))
method = 1;
QRgb *ptr;
unsigned char c, m, y ,k;
unsigned char *p;
for (int i = 0; i < m_image.height(); i++)
{
ptr = (QRgb*) m_image.scanLine(i);
if (method == 1)
{
for (int j = 0; j < m_image.width(); j++)
{
p = (unsigned char *) ptr;
c = p[0];
m = p[1];
y = p[2];
k = p[3];
*ptr = qRgba(255 - c, 255 - m, 255 - y, 255 - k);
ptr++;
}
}
else if (method == 2)
{
for (int j = 0; j < m_image.width(); j++)
{
p = (unsigned char *) ptr;
c = p[0];
m = p[1];
y = p[2];
k = p[3];
*ptr = qRgba(255 - c, 255 - m, 255 - y, k);
ptr++;
}
}
else
{
for (int j = 0; j < m_image.width(); j++)
{
p = (unsigned char *) ptr;
c = p[0];
m = p[1];
y = p[2];
k = p[3];
*ptr = qRgba(y, m, c, k);
ptr++;
}
}
}
isCMYK = true;
}
else
isCMYK = false;
if ( cinfo.output_components == 1 )
{
QImage tmpImg = m_image.convertToFormat(QImage::Format_ARGB32);
m_image = QImage( cinfo.output_width, cinfo.output_height, QImage::Format_ARGB32 );
QRgb *s;
QRgb *d;
for( int yi=0; yi < tmpImg.height(); ++yi )
{
s = (QRgb*)(tmpImg.scanLine( yi ));
d = (QRgb*)(m_image.scanLine( yi ));
for(int xi=0; xi < tmpImg.width(); ++xi )
{
(*d) = (*s);
s++;
d++;
}
}
}
}
(void) jpeg_finish_decompress(&cinfo);
fclose (infile);
jpeg_destroy_decompress (&cinfo);
m_imageInfoRecord.layerInfo.clear();
m_imageInfoRecord.BBoxX = 0;
m_imageInfoRecord.BBoxH = m_image.height();
return (!m_image.isNull());
}
