liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rawTherapee/rtexif/rtexif.cc

2425 lines
85 KiB
C++
Raw Blame History

/*
* This file is part of RawTherapee.
*
* Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
* Some parts of the source code (e.g. ciff support) are taken from dcraw
* that is copyrighted by Dave Coffin
*
* RawTherapee is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* RawTherapee is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <sstream>
#include <stdint.h>
#include "../rtgui/cacheimagedata.h"
#include "rtexif.h"
#include "../rtengine/safegtk.h"
#include "../rtgui/version.h"
#include "../rtgui/ppversion.h"
using namespace std;
namespace rtexif {
Interpreter stdInterpreter;
//--------------- class TagDirectory ------------------------------------------
// this class is a collection (an array) of tags
//-----------------------------------------------------------------------------
#define TAG_SUBFILETYPE 0x00fe
TagDirectory::TagDirectory ()
: attribs(ifdAttribs), order(HOSTORDER), parent(NULL) {}
TagDirectory::TagDirectory (TagDirectory* p, const TagAttrib* ta, ByteOrder border)
: attribs(ta), order(border), parent(p) {}
TagDirectory::TagDirectory (TagDirectory* p, FILE* f, int base, const TagAttrib* ta, ByteOrder border, bool skipIgnored)
: attribs(ta), order(border), parent(p)
{
int numOfTags = get2 (f, order);
if (numOfTags<=0 || numOfTags>1000) // KodakIfd has lots of tags, thus 1000 as the limit
return;
bool thumbdescr = false;
for (int i=0; i<numOfTags; i++) {
Tag* newTag = new Tag (this, f, base);
// filter out tags with unknown type
if ((int)newTag->getType()==0) {
delete newTag;
continue;
}
if (skipIgnored) {
int id = newTag->getID();
// detect and possibly ignore tags of directories belonging to the embedded thumbnail image
if (attribs==ifdAttribs && id==TAG_SUBFILETYPE && newTag->toInt()!=0)
thumbdescr = true;
const TagAttrib* attrib = getAttrib (id);
if (!attrib || attrib->ignore==1 || (thumbdescr && attrib->ignore==2))
delete newTag;
else
addTag (newTag);
} else addTag (newTag);
}
}
TagDirectory::~TagDirectory () {
for (size_t i=0; i<tags.size(); i++)
delete tags[i];
}
class CompareTags {
public:
int operator() (Tag* const& a, Tag* const& b) const {
return a->getID() < b->getID();
}
};
void TagDirectory::sort () {
std::sort (tags.begin(), tags.end(), CompareTags());
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->isDirectory())
for (int j=0; tags[i]->getDirectory(j); j++)
tags[i]->getDirectory(j)->sort ();
}
TagDirectory* TagDirectory::getRoot()
{
if(parent) return parent->getRoot();
else return this;
}
const TagAttrib* TagDirectory::getAttrib (int id) {
if (attribs)
for (int i=0; attribs[i].ignore!=-1; i++)
if (attribs[i].ID==id)
return &attribs[i];
return NULL;
}
const TagAttrib* TagDirectory::getAttrib (const char* name) {
if (attribs)
for (int i=0; attribs[i].ignore!=-1; i++)
if (!strcmp (attribs[i].name, name))
return &attribs[i];
return NULL;
}
const TagAttrib* TagDirectory::getAttribP (const char* name) {
if (attribs)
for (int i=0; attribs[i].ignore!=-1; i++) {
// Yeah, self made comparison!
const char *n = name;
const char *a = attribs[i].name;
while (*n && *a && *n==*a) { n++; a++; };
if (!*a && (!*n || *n=='/')) {
// we reached the end of the subpart of name and the end of attribs->name, so they match
if (*n=='/') {
Tag* tag = getTag (attribs[i].ID);
TagDirectory *tagDir;
if (attribs[i].subdirAttribs && tag && (tagDir=tag->getDirectory()))
return tagDir->getAttribP(n+1);
else
return NULL;
}
else
return &attribs[i];
}
}
return NULL;
}
void TagDirectory::printAll (unsigned int level) const {
// set the spacer prefix string
char prefixStr[level*4+1];
unsigned int i;
for (i=0; i<level*4; i++)
prefixStr[i] = ' ';
prefixStr[i] = '\0';
// recursively iterate over the tag list
for (size_t i=0; i<tags.size(); i++) {
std::string name = tags[i]->nameToString ();
if (tags[i]->isDirectory())
for (int j=0; tags[i]->getDirectory(j); j++) {
printf ("%s+-- DIRECTORY %s[%d]:\n", prefixStr, name.c_str(), j);
tags[i]->getDirectory(j)->printAll (level+1);
}
else
std::string value = tags[i]->valueToString ();
}
}
/** @brief Dump the TagDirectory and its sub-directories to the file 'fname'
*
* This method has been created to dump the metadata for the Custom Profile Builders.
* It contains an [RT General] section to communicate some parameters, then the TagDirectory follows.
*
* The key is composed as follow: "010F_Make", i.e. "tag number or ID _ tag name"
* Entries like:
*
* 927C_MakerNotesSony=$subdir
*
* indicates that this tag refer to a sub-directory. RT's Keywords begins with $, where & is the first char of the value.
* $subdir is the only keyword so far.
*
* You'll have then to check for the [EXIF/927C_MakerNotesSony] section, given that the root section
* is named [EXIF].
*
* WARNING: Some string will be sanitized, i.e. the new line char will be replaced by "\n". You'll
* have to check for this escape string if you want a correct display of the value, but your KeyFile module
* will most likely handle that automatically for you.
*
* @param commFNname Absolute path of the temporary communication file's name
* @param commFNname Absolute path of the image's file name
* @param commFNname Absolute path of the output profiles's file name
* @param defaultPParams absolute or relative path (to the application's folder) of the default ProcParams to use
* @param cfs pointer to a CacheImageData object that will contain common values
* @param flagMode will tell whether the Custom Profile Builder is called for on flagging event or for real development
* @param keyfile The KeyFile object to dump to. Has to be NULL (default value) on first call!
* @param tagDirName Name of the current TagDirectory (full path, i.e. "EXIF/MakerNotes/LensInfo"). Can be empty on first call, "EXIF" will then be used
*
* @return True if everything went fine, false otherwise
*/
bool TagDirectory::CPBDump (const Glib::ustring &commFName, const Glib::ustring &imageFName, const Glib::ustring &profileFName, const Glib::ustring &defaultPParams, const CacheImageData* cfs, const bool flagMode,
rtengine::SafeKeyFile *keyFile, Glib::ustring tagDirName) const
{
rtengine::SafeKeyFile *kf;
if (!keyFile)
kf = new rtengine::SafeKeyFile();
else
kf = keyFile;
if (!kf)
return false;
if (!keyFile || tagDirName.empty())
tagDirName = "EXIF";
std::vector<const TagDirectory *> tagDirList;
std::vector<Glib::ustring> tagDirPaths;
FILE *f = NULL;
if (!keyFile) {
// open the file in write mode
f = safe_g_fopen (commFName, "wt");
if (f==NULL) {
printf("TagDirectory::keyFileDump(\"%s\") >>> Error: unable to open file with write access!\n", commFName.c_str());
delete kf;
return false;
}
kf->set_string ("RT General", "CachePath", options.cacheBaseDir);
kf->set_string ("RT General", "AppVersion", VERSION);
kf->set_integer("RT General", "ProcParamsVersion", PPVERSION);
kf->set_string ("RT General", "ImageFileName", imageFName);
kf->set_string ("RT General", "OutputProfileFileName", profileFName);
kf->set_string ("RT General", "DefaultProcParams", defaultPParams);
kf->set_boolean("RT General", "FlaggingMode", flagMode);
kf->set_double ("Common Data", "FNumber", cfs->fnumber);
kf->set_double ("Common Data", "Shutter", cfs->shutter);
kf->set_double ("Common Data", "FocalLength", cfs->focalLen);
kf->set_integer("Common Data", "ISO", cfs->iso);
kf->set_string ("Common Data", "Lens", cfs->lens);
kf->set_string ("Common Data", "Make", cfs->camMake);
kf->set_string ("Common Data", "Model", cfs->camModel);
}
// recursively iterate over the tag list
for (size_t i=0; i<tags.size(); i++) {
std::string tagName = tags[i]->nameToString ();
if (tags[i]->isDirectory())
for (int j=0; tags[i]->getDirectory(j); j++) {
// Accumulating the TagDirectories to dump later
tagDirPaths.push_back( Glib::ustring( tagDirName + "/" + getDumpKey(tags[i]->getID(), tagName) ) );
tagDirList.push_back(tags[i]->getDirectory(j));
kf->set_string (tagDirName, getDumpKey(tags[i]->getID(), tagName), "$subdir");
}
else {
kf->set_string (tagDirName, getDumpKey(tags[i]->getID(), tagName), tags[i]->valueToString());
}
}
// dumping the sub-directories
for (size_t i=0; i< tagDirList.size(); i++)
tagDirList.at(i)->CPBDump(commFName, imageFName, profileFName, defaultPParams, cfs, flagMode, kf, tagDirPaths.at(i));
if (!keyFile) {
fprintf (f, "%s", kf->to_data().c_str());
fclose (f);
delete kf;
}
return true;
}
Glib::ustring TagDirectory::getDumpKey (int tagID, const Glib::ustring tagName) {
Glib::ustring key;
if (options.CPBKeys == CPBKT_TID || options.CPBKeys == CPBKT_TID_NAME)
key = Glib::ustring(Glib::ustring::format(std::fixed, std::hex, std::setfill(L'0'), std::setw(4), tagID));
if (options.CPBKeys == CPBKT_TID_NAME)
key += Glib::ustring("_");
if (options.CPBKeys == CPBKT_TID_NAME || options.CPBKeys == CPBKT_NAME)
key += Glib::ustring(tagName);
return key;
}
void TagDirectory::addTag (Tag* tag) {
// look up if it already exists:
if (getTag (tag->getID()))
delete tag;
else
tags.push_back (tag);
}
void TagDirectory::addTagFront (Tag* tag) {
// look up if it already exists:
if (getTag (tag->getID()))
delete tag;
else
tags.insert (tags.begin(), tag);
}
void TagDirectory::replaceTag (Tag* tag) {
// look up if it already exists:
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->getID()==tag->getID()) {
delete tags[i];
tags[i] = tag;
return;
}
tags.push_back (tag);
}
Tag* TagDirectory::getTag (int ID) const {
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->getID()==ID)
return tags[i];
return NULL;
}
Tag* TagDirectory::getTag (const char* name) const {
if (attribs) {
for (int i=0; attribs[i].ignore!=-1; i++)
if (!strcmp (attribs[i].name, name))
return getTag (attribs[i].ID);
}
return NULL;
}
Tag* TagDirectory::getTagP (const char* name) const {
if (attribs)
for (int i=0; attribs[i].ignore!=-1; i++) {
// Yeah, self made comparison!
const char *n = name;
const char *a = attribs[i].name;
while (*n && *a && *n==*a) { n++; a++; };
if (!*a && (!*n || *n=='/')) {
// we reached the end of the subpart of name and the end of attribs->name, so they match
if (*n=='/') {
Tag* tag = getTag (attribs[i].ID);
TagDirectory *tagDir;
if (attribs[i].subdirAttribs && tag && (tagDir=tag->getDirectory()))
return tagDir->getTagP(n+1);
else
return NULL;
}
else
return getTag (attribs[i].ID);
}
}
return NULL;
}
Tag* TagDirectory::findTag (const char* name) const {
if (attribs) {
for (int i=0; attribs[i].ignore!=-1; i++)
if (!strcmp (attribs[i].name, name)){
Tag* t= getTag (attribs[i].ID);
if(t) return t;
else break;
}
}
for (size_t i=0; i<tags.size(); i++)
if(tags[i]->isDirectory()){
TagDirectory *dir = tags[i]->getDirectory();
Tag* t=dir->findTag(name);
if(t) return t;
}
return NULL;
}
// Searches a simple value, as either attribute or element
// only for simple values, not for entries with special chars or free text
bool TagDirectory::getXMPTagValue(const char* name, char* value) const {
*value=0;
if (!getTag("ApplicationNotes")) return false;
char *sXMP = (char*)getTag("ApplicationNotes")->getValue();
// Check for full word
char *pos=sXMP;
bool found=false;
do {
pos=strstr(pos,name);
if (pos) {
char nextChar=*(pos+strlen(name));
if (nextChar==' ' || nextChar=='>' || nextChar=='=')
found=true;
else
pos+=strlen(name);
}
} while (pos && !found);
if (!found) return false;
char *posTag =strchr(pos,'>');
char *posAttr=strchr(pos,'"');
if (!posTag && !posAttr) return false;
if (posTag && (!posAttr || posTag<posAttr)) {
// Tag
pos=strchr(posTag+1,'<');
strncpy(value,posTag+1,pos-posTag-1);
value[pos-posTag-1]=0;
return true;
} else
if (posAttr && (!posTag || posAttr<posTag)) {
// Attribute
pos=strchr(posAttr+1,'"');
strncpy(value,posAttr+1,pos-posAttr-1);
value[pos-posAttr-1]=0;
return true;
} else return false;
}
void TagDirectory::keepTag (int ID) {
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->getID()==ID) tags[i]->setKeep(true);
}
int TagDirectory::calculateSize () {
int size = 2; // space to store the number of tags
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->getKeep())
size += 12 + tags[i]->calculateSize ();
size += 4; // next ifd pointer
return size;
}
TagDirectory* TagDirectory::clone (TagDirectory* parent) {
TagDirectory* td = new TagDirectory (parent, attribs, order);
for (size_t i=0; i<tags.size(); i++)
td->tags.push_back (tags[i]->clone (td));
return td;
}
int TagDirectory::write (int start, unsigned char* buffer) {
int size = calculateSize ();
int tagnum = 0;
int nondirspace = 0;
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->getKeep()) {
tagnum++;
if (!tags[i]->isDirectory())
nondirspace += tags[i]->calculateSize();
}
int nextValOffs = start + 2 + tagnum * 12 + 4;
int nextDirOffs = nextValOffs + nondirspace;
int pos = start;
sset2 (tagnum, buffer+start, order);
pos += 2;
int maxPos = start + size;
for (size_t i=0; i<tags.size(); i++) {
if (tags[i]->getKeep()) {
if (!tags[i]->isDirectory())
nextValOffs = tags[i]->write (pos, nextValOffs, buffer); // pos: where to put the tag, dataoffset: the place where the value can be put. return: next data offset
else
nextDirOffs = tags[i]->write (pos, nextDirOffs, buffer); // pos: where to put the tag, dataoffset: the place where the value can be put. return: next data offset
pos += 12;
}
}
sset4 (0, buffer+pos, order);
return maxPos;
}
void TagDirectory::applyChange (std::string name, std::string value) {
std::string::size_type dp = name.find_first_of ('.');
std::string fseg = name.substr (0,dp);
// this is a final segment: apply change
if (dp==std::string::npos) {
Tag* t = NULL;
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->nameToString()==fseg) {
t = tags[i];
break;
}
if (value=="#keep" && t)
t->setKeep (true);
else if (value=="#delete" && t)
t->setKeep (false);
else if (t && !t->isDirectory())
t->valueFromString (value);
else {
const TagAttrib* attrib = NULL;
for (int i=0; attribs[i].ignore!=-1; i++)
if (!strcmp (attribs[i].name, fseg.c_str())) {
attrib = &attribs[i];
break;
}
if (attrib) {
Tag* nt = new Tag (this, attrib);
nt->initString (value.c_str());
addTag (nt);
}
}
}
// this is a subdirectory
else {
// try to find it
std::string::size_type dp1 = fseg.find_first_of ('[');
std::string basename = fseg.substr (0,dp1);
Tag* t = NULL;
int dirnum = -1;
for (size_t i=0; i<tags.size(); i++)
if (tags[i]->isDirectory()) {
for (int j=0; tags[i]->getDirectory(j); j++) {
if (tags[i]->nameToString(j) == fseg) {
t = tags[i];
dirnum = j;
break;
}
}
if (!t && tags[i]->nameToString() == basename) { // found it, but that directory index does not exist
t = tags[i];
dirnum = -1;
}
}
if (!t && value!="#keep" && value!="#delete") {
const TagAttrib* attrib = NULL;
for (int i=0; attribs[i].ignore!=-1; i++)
if (!strcmp (attribs[i].name, fseg.c_str())) {
attrib = &attribs[i];
break;
}
if (attrib && attrib->subdirAttribs) {
t = new Tag (this, attrib);
t->initSubDir ();
addTag (t);
}
dirnum = 0;
}
if (t && dirnum>=0)
t->getDirectory(dirnum)->applyChange (name.substr (dp+1, std::string::npos), value);
}
}
TagDirectoryTable::TagDirectoryTable ()
:zeroOffset(0),valuesSize(0)
{
}
TagDirectoryTable::TagDirectoryTable (TagDirectory* p, unsigned char *v,int memsize,int offs, TagType type, const TagAttrib* ta, ByteOrder border)
:TagDirectory(p,ta,border),zeroOffset(offs),valuesSize(memsize),defaultType( type )
{
values = new unsigned char[valuesSize];
memcpy(values,v,valuesSize);
// Security ; will avoid to read above the buffer limit if the RT's tagDirectoryTable is longer that what's in the file
int count = valuesSize/getTypeSize(type);
for(const TagAttrib* tattr = ta; tattr->ignore != -1 && tattr->ID<count; ++tattr){
Tag* newTag = new Tag (this, tattr, (values + zeroOffset+ tattr->ID*getTypeSize(type)), tattr->type == AUTO ? type : tattr->type);
tags.push_back(newTag); // Here we can insert more tag in the same offset because of bitfield meaning
}
}
TagDirectoryTable::TagDirectoryTable (TagDirectory* p, FILE* f, int memsize,int offs, TagType type, const TagAttrib* ta, ByteOrder border)
:TagDirectory(p,ta,border),zeroOffset(offs),valuesSize(memsize),defaultType( type )
{
values = new unsigned char[valuesSize];
fread (values, 1, valuesSize, f);
// Security ; will avoid to read above the buffer limit if the RT's tagDirectoryTable is longer that what's in the file
int count = valuesSize/getTypeSize(type);
for(const TagAttrib* tattr = ta; tattr->ignore != -1 && tattr->ID<count; ++tattr){
Tag* newTag = new Tag (this, tattr, (values + zeroOffset+ tattr->ID*getTypeSize(type)), tattr->type == AUTO ? type : tattr->type);
tags.push_back(newTag); // Here we can insert more tag in the same offset because of bitfield meaning
}
}
TagDirectory* TagDirectoryTable::clone (TagDirectory* parent) {
TagDirectory* td = new TagDirectoryTable (parent,values,valuesSize,zeroOffset,defaultType, attribs, order);
return td;
}
TagDirectoryTable::~TagDirectoryTable()
{
if(values)
delete [] values;
}
int TagDirectoryTable::calculateSize ()
{
return valuesSize;
}
int TagDirectoryTable::write (int start, unsigned char* buffer) {
if( values && valuesSize){
memcpy(buffer+start,values,valuesSize);
return start+valuesSize;
}else
return start;
}
//--------------- class Tag ---------------------------------------------------
// this class represents a tag stored in the directory
//-----------------------------------------------------------------------------
Tag::Tag (TagDirectory* p, FILE* f, int base)
: type(INVALID), count(0), value(NULL), allocOwnMemory(true), attrib(NULL), parent(p), directory(NULL) {
ByteOrder order = getOrder();
tag = get2 (f, order);
type = (TagType)get2 (f, order);
count = get4 (f, order);
if (!count) count = 1;
makerNoteKind = NOMK;
keep = false;
// filter out invalid tags
// note the large count is to be able to pass LeafData ASCII tag which can be up to almost 10 megabytes,
// (only a small part of it will actually be parsed though)
if ((int)type<1 || (int)type>14 || count>10*1024*1024) {
type = INVALID;
return;
}
// store next Tag's position in file
int save = ftell(f) + 4;
// load value field (possibly seek before)
valuesize = count * getTypeSize(type);
if (valuesize > 4)
fseek (f, get4(f, getOrder()) + base, SEEK_SET);
attrib = parent->getAttrib (tag);
if (attrib && (attrib->action==AC_WRITE || attrib->action==AC_NEW))
keep = true;
if( tag == 0xc634 ){ // DNGPrivateData
int currPos = ftell(f);
const int buffersize = 32;
char buffer[buffersize],*p=buffer;
while( fread (p, 1, 1, f ) && *p != 0 && p-buffer<buffersize-1 )p++;
*p=0;
if( !strncmp(buffer,"Adobe",5) ){
fread (buffer, 1, 14, f );
if( !strncmp( buffer,"MakN",4) ){
ByteOrder bom = ((buffer[8]=='M' && buffer[9]=='M')?MOTOROLA:INTEL) ;
Tag* tmake = parent->getRoot()->findTag("Make");
std::string make( tmake ? tmake->valueToString():"");
int save = ftell(f);
int originalOffset = sget4( (unsigned char*)&buffer[10], ( make.find("SONY") != std::string::npos ) || ( make.find("Canon") != std::string::npos ) || ( make.find("OLYMPUS") != std::string::npos ) ?MOTOROLA:bom );
if( !parseMakerNote(f, save - originalOffset , bom ))
type = INVALID;
}
}else if( !strncmp(buffer,"PENTAX",6) ){
makerNoteKind = HEADERIFD;
fread (buffer, 1, 2, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, currPos, pentaxAttribs, strncmp(buffer,"MM",2)? INTEL:MOTOROLA);
directory[1] = NULL;
}else
/* SONY uses this tag to write hidden info and pointer to private encrypted tags
{
unsigned offset =sget4((unsigned char*)buffer, order);
fseek(f,offset,SEEK_SET);
makerNoteKind = TABLESUBDIR;
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, sonyDNGMakerNote, order);
directory[1] = NULL;
fseek (f, save, SEEK_SET);
return;
}*/
type = INVALID;
}
// if this tag is the makernote, it needs special treatment (brand specific parsing)
if (tag==0x927C && attrib && !strcmp (attrib->name, "MakerNote") ) {
if( !parseMakerNote(f,base,order )){
type = INVALID;
fseek (f, save, SEEK_SET);
return;
}
}
else if (attrib && attrib->subdirAttribs) {
// Some subdirs are specific of maker and model
char make[128], model[128];
make[0]=0;
model[0]=0;
Tag* tmake = parent->getRoot()->getTag ("Make");
if (tmake) tmake->toString (make);
Tag* tmodel = parent->getRoot()->getTag ("Model");
if (tmodel) tmodel->toString (model);
if (!strncmp(make, "SONY", 4)) {
switch( tag ){
case 0x0010:
directory = new TagDirectory*[2];
directory[1] = NULL;
if (count == 15360)
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , sonyCameraInfoAttribs, order);
else
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , sonyCameraInfo2Attribs, order);
break;
case 0x0114:
directory = new TagDirectory*[2];
directory[1] = NULL;
if (count == 280 || count == 364)
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,SHORT , sonyCameraSettingsAttribs, MOTOROLA);
else if (count == 332)
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,SHORT , sonyCameraSettingsAttribs2, MOTOROLA);
else if(count == 1536 || count == 2048)
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , sonyCameraSettingsAttribs3, INTEL);
else {
// Unknown CameraSettings
delete [] directory;
directory = NULL;
type = INVALID;
}
makerNoteKind = directory ? TABLESUBDIR : NOMK;
break;
case 0x9405:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,SHORT , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
default:
goto defsubdirs;
}
}else if ((!strncmp(make, "PENTAX", 6)) || (!strncmp(make, "RICOH", 5) && !strncmp(model, "PENTAX", 6))) { // Either the former Pentax brand or the RICOH brand + PENTAX model"
switch( tag ){
case 0x007d:
case 0x0205:
case 0x0208:
case 0x0216:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
case 0x0215:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,LONG , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
case 0x005c:
directory = new TagDirectory*[2];
directory[1] = NULL;
if (count == 4) // SRInfo
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , pentaxSRInfoAttribs, order);
else if (count == 2) // SRInfo2
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , pentaxSRInfo2Attribs, order);
else {
// Unknown SRInfo
delete [] directory;
directory = NULL;
type = INVALID;
}
makerNoteKind = directory ? TABLESUBDIR : NOMK;
break;
case 0x0206:
directory = new TagDirectory*[2];
directory[1] = NULL;
if (count == 21) // AEInfo2
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , pentaxAEInfo2Attribs, order);
else if (count == 48) // AEInfo3
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , pentaxAEInfo3Attribs, order);
else if (count <= 25) // AEInfo
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , pentaxAEInfoAttribs, order);
else {
// Unknown AEInfo
delete [] directory;
directory = NULL;
type = INVALID;
}
makerNoteKind = directory ? TABLESUBDIR : NOMK;
break;
case 0x0207:
{ // There are 2 format pentaxLensDataAttribs
int offsetFirst = 4; // LensInfo2
if( strstr(model, "*ist") || strstr(model, "GX-1") || strstr(model, "K100D") || strstr(model, "K110D") )
offsetFirst = 3; // LensInfo
else if( strstr(model, "645D") )
offsetFirst = 13; // LensInfo3
else if( strstr(model, "K-01") || strstr(model, "K-30") || strstr(model, "K-50"))
offsetFirst = 15; // LensInfo5
else if( strstr(model, "K-5") || strstr(model, "K-r") )
offsetFirst = 12; // LensInfo4
else if(!strncmp(make, "RICOH", 5)) { // all PENTAX camera model produced under the RICOH era uses LensInfo5, for now...
offsetFirst = 15; // LensInfo5 too
}
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,offsetFirst,BYTE , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
}
break;
case 0x0239:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
default:
goto defsubdirs;
}
}else if (!strncmp(make, "Canon", 5)) {
switch( tag ){
case 0x0001:
case 0x0002:
case 0x0004:
case 0x0005:
case 0x0093:
case 0x0098:
case 0x00a0:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,SSHORT , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
case 0x009a:
case 0x4013:
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,LONG , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
default:
goto defsubdirs;
}
}else if (!strncmp(make, "NIKON", 5)) {
switch (tag) {
case 0x0025: {
directory = new TagDirectory*[2];
directory[1] = NULL;
directory[0] = new TagDirectoryTable (parent, f, valuesize,0,BYTE , attrib->subdirAttribs, order);
makerNoteKind = TABLESUBDIR;
break;
}
default:
goto defsubdirs;
}
}else if(type==UNDEFINED){
count = 1;
type = LONG;
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, attrib->subdirAttribs, order);
directory[1] = NULL;
}else
goto defsubdirs;
}
else {
// read value
value = new unsigned char [valuesize+1];
fread (value, 1, valuesize, f);
value[valuesize] = '\0';
}
// seek back to the saved position
fseek (f, save, SEEK_SET);
return;
defsubdirs:
// read value
value = new unsigned char [valuesize];
fread (value, 1, valuesize, f);
int pos = ftell (f);
// count the number of valid subdirs
int sdcount = count;
if (sdcount>0) {
if (parent->getAttribTable()==olympusAttribs)
sdcount = 1;
// allocate space
directory = new TagDirectory*[sdcount+1];
// load directories
for (size_t j=0,i=0; j<count; j++,i++) {
int newpos = base + toInt(j*4, LONG);
fseek (f, newpos, SEEK_SET);
directory[i] = new TagDirectory (parent, f, base, attrib->subdirAttribs, order);
fseek (f, pos, SEEK_SET);
}
// set the terminating NULL
directory[sdcount] = NULL;
}
else
type = INVALID;
// seek back to the saved position
fseek (f, save, SEEK_SET);
return;
}
bool Tag::parseMakerNote(FILE* f, int base, ByteOrder bom )
{
value = NULL;
Tag* tmake = parent->getRoot()->findTag("Make");
std::string make( tmake ? tmake->valueToString():"");
Tag* tmodel = parent->getRoot()->findTag ("Model");
std::string model( tmodel ? tmodel->valueToString():"");
if ( make.find( "NIKON" ) != std::string::npos ) {
if ( model.find("NIKON E700")!= std::string::npos ||
model.find("NIKON E800")!= std::string::npos ||
model.find("NIKON E900")!= std::string::npos ||
model.find("NIKON E900S")!= std::string::npos ||
model.find("NIKON E910")!= std::string::npos ||
model.find("NIKON E950")!= std::string::npos ) {
makerNoteKind = HEADERIFD;
valuesize = 8;
value = new unsigned char[8];
fread (value, 1, 8, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, nikon2Attribs, bom);
directory[1] = NULL;
} else if ( model.find("NIKON E990")!= std::string::npos ||
(model.find("NIKON D1")!= std::string::npos && model.size()>8 && model.at(8)!='0')) {
makerNoteKind = IFD;
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, nikon3Attribs, bom);
directory[1] = NULL;
} else {
// needs refinement! (embedded tiff header parsing)
makerNoteKind = NIKON3;
valuesize = 18;
value = new unsigned char[18];
int basepos = ftell (f);
fread (value, 1, 18, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, basepos+10, nikon3Attribs, bom);
directory[1] = NULL;
}
} else if ( make.find( "Canon" ) != std::string::npos ) {
makerNoteKind = IFD;
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, canonAttribs, bom);
directory[1] = NULL;
} else if ( make.find( "PENTAX" ) != std::string::npos ) {
makerNoteKind = HEADERIFD;
valuesize = 6;
value = new unsigned char[6];
fread (value, 1, 6, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, pentaxAttribs, bom);
directory[1] = NULL;
} else if ( (make.find( "RICOH" ) != std::string::npos ) && (model.find("PENTAX") != std::string::npos) ) {
makerNoteKind = HEADERIFD;
valuesize = 10;
value = new unsigned char[10];
fread (value, 1, 10, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, ftell (f)-10, pentaxAttribs, bom);
directory[1] = NULL;
} else if ( make.find( "FUJIFILM" ) != std::string::npos ) {
makerNoteKind = FUJI;
valuesize = 12;
value = new unsigned char[12];
fread (value, 1, 12, f);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, ftell(f)-12, fujiAttribs, INTEL);
directory[1] = NULL;
} else if ( make.find( "KONICA MINOLTA" ) != std::string::npos || make.find( "Minolta" ) != std::string::npos ) {
makerNoteKind = IFD;
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, minoltaAttribs, bom);
directory[1] = NULL;
} else if ( make.find( "SONY" ) != std::string::npos ) {
valuesize = 12;
value = new unsigned char[12];
fread (value, 1, 12, f);
if (!strncmp((char*)value, "SONY DSC", 8))
makerNoteKind = HEADERIFD;
else {
makerNoteKind = IFD;
fseek (f, -12, SEEK_CUR);
}
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, f, base, sonyAttribs, bom );
directory[1] = NULL;
} else if ( make.find( "OLYMPUS" ) != std::string::npos ) {
makerNoteKind = HEADERIFD;
valuesize = 8;
value = new unsigned char[12];
fread (value, 1, 8, f);
directory = new TagDirectory*[2];
directory[1] = NULL;
if (!strncmp((char*)value, "OLYMPUS", 7)) {
makerNoteKind = OLYMPUS2;
fread (value+8, 1, 4, f);
valuesize = 12;
directory[0] = new TagDirectory (parent, f, ftell(f)-12, olympusAttribs, value[8]=='I' ? INTEL : MOTOROLA);
} else
directory[0] = new TagDirectory (parent, f, base, olympusAttribs, bom);
} else
return false;
return true;
}
Tag* Tag::clone (TagDirectory* parent) {
Tag* t = new Tag (parent, attrib);
t->tag = tag;
t->type = type;
t->count = count;
t->keep = keep;
t->valuesize = valuesize;
if (value) {
t->value = new unsigned char [valuesize];
memcpy (t->value, value, valuesize);
}
else
value = NULL;
t->makerNoteKind = makerNoteKind;
if (directory) {
int ds = 0;
for (; directory[ds]; ds++);
t->directory = new TagDirectory*[ds+1];
for (int i=0; i<ds; i++)
t->directory[i] = directory[i]->clone (parent);
t->directory[ds] = NULL;
}
else
t->directory = NULL;
return t;
}
Tag::~Tag () {
// delete value
if (value && allocOwnMemory)
delete [] value;
// if there are directories behind the tag, delete them
int i = 0;
if (directory) {
while (directory[i])
delete directory[i++];
delete [] directory;
}
}
void Tag::setInt (int v, int ofs, TagType astype) {
if (astype==SHORT)
sset2 (v, value+ofs, getOrder());
else if (astype==RATIONAL) {
sset4 (v, value+ofs, getOrder());
sset4 (1, value+ofs+4, getOrder());
}
else
sset4 (v, value+ofs, getOrder());
}
void Tag::fromInt (int v) {
if (type==SHORT)
sset2 (v, value, getOrder());
else
sset4 (v, value, getOrder());
}
void Tag::fromString (const char* v, int size) {
if( value && allocOwnMemory)
delete [] value;
if (size<0)
valuesize = strlen (v) + 1;
else
valuesize = size;
count = valuesize;
if( allocOwnMemory )
value = new unsigned char [valuesize];
memcpy ((char*)value, v, valuesize);
}
int Tag::toInt (int ofs, TagType astype) {
if (attrib)
return attrib->interpreter->toInt(this, ofs, astype);
int a;
if (astype == INVALID)
astype = type;
switch (astype) {
//case SBYTE: return (signed char)(value[ofs]);
case SBYTE: return int((reinterpret_cast<signed char*>(value))[ofs]);
case BYTE: return value[ofs];
case ASCII: return 0;
case SSHORT:return (int)int2_to_signed(sget2 (value+ofs, getOrder()));
case SHORT: return (int)sget2 (value+ofs, getOrder());
case SLONG:
case LONG: return (int)sget4 (value+ofs, getOrder());
case SRATIONAL:
case RATIONAL: a = (int)sget4 (value+ofs+4, getOrder()); return a==0 ? 0 : (int)sget4 (value+ofs, getOrder()) / a;
case FLOAT: return (int)toDouble(ofs);
case UNDEFINED: return 0;
default: return 0; // Quick fix for missing cases (INVALID, DOUBLE, OLYUNDEF, SUBDIR)
}
return 0;
}
double Tag::toDouble (int ofs) {
if (attrib)
return attrib->interpreter->toDouble(this, ofs);
union IntFloat { uint32_t i; float f; } conv;
double ud, dd;
switch (type) {
case SBYTE: return (double)(int((reinterpret_cast<signed char*>(value))[ofs]));
case BYTE: return (double)((int)value[ofs]);
case ASCII: return 0.0;
case SSHORT:return (double)int2_to_signed(sget2 (value+ofs, getOrder()));
case SHORT: return (double)((int)sget2 (value+ofs, getOrder()));
case SLONG:
case LONG: return (double)((int)sget4 (value+ofs, getOrder()));
case SRATIONAL:
case RATIONAL: ud = (int)sget4 (value+ofs, getOrder()); dd = (int)sget4 (value+ofs+4, getOrder()); return dd==0. ? 0. : (double)ud / (double)dd;
case FLOAT:
conv.i=sget4 (value+ofs, getOrder());
return conv.f; // IEEE FLOATs are already C format, they just need a recast
case UNDEFINED: return 0.;
default: return 0.; // Quick fix for missing cases (INVALID, DOUBLE, OLYUNDEF, SUBDIR)
}
return 0.;
}
/**
* @brief Create an array of the elements
*/
double *Tag::toDoubleArray(int ofs) {
double *values = new double[count];
for (unsigned int i=0; i<count; ++i) {
values[i] = toDouble(ofs+i*getTypeSize(type));
}
return values;
}
void Tag::toRational (int& num, int& denom, int ofs) {
switch (type) {
case BYTE: num = (int)value[ofs]; denom = 1; break;
case ASCII: num = 0; denom = 0; break;
case SSHORT:
case SHORT: num = (int)sget2 (value+ofs, getOrder()); denom = 1; break;
case SLONG:
case LONG: num = (int)sget4 (value+ofs, getOrder()); denom = 1; break;
case SRATIONAL:
case RATIONAL: num = (int)sget4 (value+ofs, getOrder()); denom = (int)sget4 (value+ofs+4, getOrder()); break;
case FLOAT: num = 0; denom = 0; break;
case UNDEFINED: num = 0; denom = 0; break;
default: num = 0; denom = 0; break; // Quick fix for missing cases (INVALID, DOUBLE, OLYUNDEF, SUBDIR)
}
}
void Tag::toString (char* buffer, int ofs) {
if (type==UNDEFINED && !directory) {
bool isstring = true;
unsigned int i=0;
for (i=0; i+ofs<count && i<64 && value[i+ofs]; i++)
if (value[i+ofs]<32 || value[i+ofs]>126)
isstring = false;
if (isstring) {
int j = 0;
for (i=0; i+ofs<count && i<64 && value[i+ofs]; i++) {
if (value[i+ofs]=='<' || value[i+ofs]=='>')
buffer[j++] = '\\';
buffer[j++] = value[i+ofs];
}
buffer[j++] = 0;
return;
}
}
else if (type==ASCII) {
sprintf (buffer, "%.64s", value+ofs);
return;
}
size_t maxcount = 4;
if (count<4)
maxcount = count;
strcpy (buffer, "");
for (size_t i=0; i<maxcount; i++) {
if (i>0)
strcat (buffer, ", ");
char* b = buffer + strlen(buffer);
switch (type) {
case UNDEFINED:
case BYTE: sprintf (b, "%d", value[i+ofs]); break;
case SSHORT: sprintf (b, "%d", toInt(2*i+ofs)); break;
case SHORT: sprintf (b, "%u", toInt(2*i+ofs)); break;
case SLONG: sprintf (b, "%ld", (long)toInt(4*i+ofs)); break;
case LONG: sprintf (b, "%lu", (unsigned long)toInt(4*i+ofs)); break;
case SRATIONAL:
case RATIONAL: sprintf (b, "%d/%d", (int)sget4 (value+8*i+ofs, getOrder()), (int)sget4 (value+8*i+ofs+4, getOrder())); break;
case FLOAT: sprintf (b, "%g", toDouble(8*i+ofs)); break;
default: break;
}
}
if (count > maxcount)
strcat (buffer, "...");
}
std::string Tag::nameToString (int i) {
char buffer[1024];
if (attrib)
strcpy (buffer, attrib->name);
else
sprintf (buffer, "0x%x", tag);
if (i>0)
sprintf (buffer+strlen(buffer)-1, "[%d]", i);
return buffer;
}
std::string Tag::valueToString () {
char buffer[1024];
if (attrib && attrib->interpreter)
return attrib->interpreter->toString (this);
else {
toString (buffer);
return buffer;
}
}
void Tag::valueFromString (const std::string& value) {
if (attrib && attrib->interpreter)
attrib->interpreter->fromString (this, value);
}
int Tag::calculateSize () {
int size = 0;
if (directory) {
int j;
for (j=0; directory[j]; j++)
size += directory[j]->calculateSize ();
if (j>1)
size += 4*j;
}
else if (valuesize > 4)
size += valuesize + (valuesize%2); // we align tags to even byte positions
if (makerNoteKind!=NOMK)
count = directory[0]->calculateSize () / getTypeSize(type);
if (makerNoteKind==NIKON3 || makerNoteKind==OLYMPUS2 || makerNoteKind==FUJI)
size += valuesize;
else if (makerNoteKind==HEADERIFD)
size += valuesize;
return size;
}
int Tag::write (int offs, int dataOffs, unsigned char* buffer) {
if ((int)type==0 || offs>65500)
return dataOffs;
sset2 (tag, buffer+offs, parent->getOrder());
offs += 2;
unsigned short typ = type;
sset2 (typ, buffer+offs, parent->getOrder());
offs += 2;
sset4 (count, buffer+offs, parent->getOrder());
offs += 4;
if (!directory) {
if (valuesize>4) {
sset4 (dataOffs, buffer+offs, parent->getOrder());
memcpy (buffer+dataOffs, value, valuesize);
if (valuesize%2)
buffer[dataOffs+valuesize] = 0; // zero padding required by the exif standard
return dataOffs + valuesize + (valuesize%2);
}
else {
memcpy (buffer+offs, value, valuesize);
return dataOffs;
}
}
else {
if (makerNoteKind==NIKON3) {
sset4 (dataOffs, buffer+offs, parent->getOrder());
memcpy (buffer+dataOffs, value, 18);
dataOffs += 10;
dataOffs += directory[0]->write (8, buffer+dataOffs);
return dataOffs;
}
else if (makerNoteKind==OLYMPUS2 || makerNoteKind==FUJI) {
sset4 (dataOffs, buffer+offs, parent->getOrder());
memcpy (buffer+dataOffs, value, valuesize);
dataOffs += valuesize + directory[0]->write (valuesize, buffer+dataOffs);
return dataOffs;
}
else if (makerNoteKind==HEADERIFD) {
sset4 (dataOffs, buffer+offs, parent->getOrder());
memcpy (buffer+dataOffs, value, valuesize);
dataOffs += valuesize;
dataOffs += directory[0]->write (dataOffs, buffer);
return dataOffs;
}
else if( makerNoteKind==TABLESUBDIR){
sset4 (dataOffs, buffer+offs, parent->getOrder());
dataOffs = directory[0]->write (dataOffs, buffer);
return dataOffs;
}
else if (!directory[1]) {
sset4 (dataOffs, buffer+offs, parent->getOrder());
return directory[0]->write (dataOffs, buffer);
}
else {
sset4 (dataOffs, buffer+offs, parent->getOrder());
int linkOffs = dataOffs;
for (int i=0; directory[i]; i++)
dataOffs += 4;
for (int i=0; directory[i]; i++) {
sset4 (dataOffs, buffer+linkOffs, parent->getOrder());
linkOffs += 4;
dataOffs = directory[i]->write (dataOffs, buffer);
}
return dataOffs;
}
}
}
Tag::Tag (TagDirectory* p, const TagAttrib* attr)
: tag(attr ? attr->ID : -1), type(INVALID), count(0), value(NULL), valuesize(0), keep(true), allocOwnMemory(true), attrib(attr), parent(p), directory(NULL), makerNoteKind (NOMK) {
}
Tag::Tag (TagDirectory* p, const TagAttrib* attr, int data, TagType t)
: tag(attr ? attr->ID : -1), type(t), count(1), value(NULL), valuesize(0), keep(true), allocOwnMemory(true), attrib(attr), parent(p), directory(NULL), makerNoteKind (NOMK) {
initInt (data, t);
}
Tag::Tag (TagDirectory* p, const TagAttrib* attr, unsigned char *data, TagType t)
: tag(attr ? attr->ID : -1), type(t), count(1), value(NULL), valuesize(0), keep(true), allocOwnMemory(false), attrib(attr), parent(p), directory(NULL), makerNoteKind (NOMK) {
initType (data, t);
}
Tag::Tag (TagDirectory* p, const TagAttrib* attr, const char* text)
: tag(attr ? attr->ID : -1), type(ASCII), count(1), value(NULL), valuesize(0), keep(true), allocOwnMemory(true), attrib(attr), parent(p), directory(NULL), makerNoteKind (NOMK) {
initString (text);
}
void Tag::initType (unsigned char *data, TagType type)
{
valuesize = getTypeSize(type);
if( allocOwnMemory ){
value = new unsigned char[valuesize];
memcpy ((char*)value, data, valuesize);
}else
value = data;
}
void Tag::initInt (int data, TagType t, int cnt) {
type = t;
if (t==LONG)
valuesize = 4;
else if (t==SHORT)
valuesize = 2;
else if (t==BYTE)
valuesize = 1;
else if (t==RATIONAL)
valuesize = 8;
count = cnt;
valuesize *= count;
value = new unsigned char[valuesize];
setInt (data, 0, t);
}
void Tag::initString (const char* text) {
type = ASCII;
count = strlen(text)+1;
valuesize = count;
value = new unsigned char[valuesize];
strcpy ((char*)value, text);
}
void Tag::initSubDir () {
type = LONG;
valuesize = 4;
count = 1;
value = new unsigned char[4];
setInt (0);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, attrib ? attrib->subdirAttribs : NULL, parent->getOrder());
directory[1] = NULL;
}
void Tag::initSubDir (TagDirectory* dir) {
type = LONG;
valuesize = 4;
count = 1;
value = new unsigned char[4];
setInt (0);
directory = new TagDirectory*[2];
directory[0] = dir;
directory[1] = NULL;
}
void Tag::initMakerNote (MNKind mnk, const TagAttrib* ta) {
type = UNDEFINED;
valuesize = 4;
count = 1;
value = new unsigned char[4];
setInt (0);
directory = new TagDirectory*[2];
directory[0] = new TagDirectory (parent, ta, parent->getOrder());
directory[1] = NULL;
makerNoteKind = mnk;
}
void Tag::initUndefArray (const char* data, int len) {
type = UNDEFINED;
count = valuesize = len;
value = new unsigned char[valuesize];
memcpy (value, data, len);
}
void Tag::initLongArray (const char* data, int len) {
type = LONG;
count = (len+3)/4;
valuesize = count * 4;
value = new unsigned char[valuesize];
memcpy (value, data, len);
}
void Tag::initRational (int num, int den) {
count = 1;
valuesize = 8;
value = new unsigned char[8];
type = RATIONAL;
setInt (num, 0);
setInt (den, 4);
}
//--------------- class IFDParser ---------------------------------------------
// static functions to read tag directories from different kinds of files
//-----------------------------------------------------------------------------
const TagAttrib* lookupAttrib (const TagAttrib* dir, const char* field) {
for (int i=0; dir[i].ignore!=-1; i++)
if (!strcmp (dir[i].name, field))
return &dir[i];
return 0;
}
TagDirectory* ExifManager::parseCIFF (FILE* f, int base, int length) {
TagDirectory* root = new TagDirectory (NULL, ifdAttribs, INTEL);
Tag* exif = new Tag (root, lookupAttrib(ifdAttribs,"Exif"));
exif->initSubDir ();
Tag* mn = new Tag (exif->getDirectory(), lookupAttrib(exifAttribs,"MakerNote"));
mn->initMakerNote (IFD, canonAttribs);
root->addTag (exif);
exif->getDirectory()->addTag (mn);
parseCIFF (f, base, length, root);
root->sort ();
return root;
}
Tag* ExifManager::saveCIFFMNTag (FILE* f, TagDirectory* root, int len, const char* name) {
int s = ftell (f);
char* data = new char [len];
fread (data, len, 1, f);
TagDirectory* mn = root->getTag ("Exif")->getDirectory()->getTag("MakerNote")->getDirectory();
Tag* cs = new Tag (mn, lookupAttrib(canonAttribs, name));
cs->initUndefArray (data, len);
mn->addTag (cs);
fseek (f, s, SEEK_SET);
return cs;
}
void ExifManager::parseCIFF (FILE* f, int base, int length, TagDirectory* root) {
char buffer[1024];
Tag* t;
fseek (f, base+length-4, SEEK_SET);
int dirStart = get4 (f, INTEL) + base;
fseek (f, dirStart, SEEK_SET);
int numOfTags = get2 (f, INTEL);
if (numOfTags > 100) return;
float exptime, shutter, aperture, fnumber, ev;
exptime = fnumber = shutter = aperture = ev = -1000.f;
int focal_len, iso;
focal_len = iso = -1;
TagDirectory* exif = root->getTag("Exif")->getDirectory();
time_t timestamp = time (NULL);
for (int i=0; i<numOfTags; i++) {
int type = get2 (f, INTEL);
int len = get4 (f, INTEL);
int nextPos = ftell (f) + 4;
// seek to the location of the value
fseek (f, base + get4 (f, INTEL), SEEK_SET);
if ((((type >> 8) + 8) | 8) == 0x38)
parseCIFF (f, ftell(f), len, root); // Parse a sub-table
if (type == 0x0810) {
fread (buffer, 64, 1, f);
t = new Tag (root, lookupAttrib(ifdAttribs,"Artist"));
t->initString (buffer);
root->addTag (t);
}
if (type == 0x080a) {
fread (buffer, 64, 1, f);
t = new Tag (root, lookupAttrib(ifdAttribs,"Make"));
t->initString (buffer);
root->addTag (t);
fseek (f, strlen(buffer) - 63, SEEK_CUR);
fread (buffer, 64, 1, f);
t = new Tag (root, lookupAttrib(ifdAttribs,"Model"));
t->initString (buffer);
root->addTag (t);
}
if (type == 0x1818) {
ev = int_to_float(get4(f, INTEL));
shutter = int_to_float(get4(f, INTEL));
exptime = pow (2, -shutter);
aperture = int_to_float(get4(f, INTEL));
fnumber = pow (2, aperture/2);
}
if (type == 0x102d) {
Tag* t = saveCIFFMNTag (f, root, len, "CanonCameraSettings");
int mm = t->toInt (34, SHORT);
Tag* nt = new Tag (exif, lookupAttrib(exifAttribs,"MeteringMode"));
switch (mm) {
case 0: nt->initInt (5, SHORT); break;
case 1: nt->initInt (3, SHORT); break;
case 2: nt->initInt (1, SHORT); break;
case 3: nt->initInt (5, SHORT); break;
case 4: nt->initInt (6, SHORT); break;
case 5: nt->initInt (2, SHORT); break;
}
exif->addTag (nt);
nt = new Tag (exif, lookupAttrib(exifAttribs,"MaxApertureValue"));
nt->initRational (t->toInt(52,SHORT), 32);
exif->addTag (nt);
int em = t->toInt(40,SHORT);
nt = new Tag (exif, lookupAttrib(exifAttribs,"ExposureProgram"));
switch (em) {
case 0: nt->initInt (2, SHORT); break;
case 1: nt->initInt (2, SHORT); break;
case 2: nt->initInt (4, SHORT); break;
case 3: nt->initInt (3, SHORT); break;
case 4: nt->initInt (1, SHORT); break;
default: nt->initInt (0, SHORT); break;
}
exif->addTag (nt);
nt = new Tag (exif, lookupAttrib(exifAttribs,"Flash"));
if (t->toInt(8,SHORT)==0)
nt->initInt (0, SHORT);
else
nt->initInt (1, SHORT);
exif->addTag (nt);
nt = new Tag (exif, lookupAttrib(exifAttribs,"MaxApertureValue"));
nt->initRational (t->toInt(52,SHORT), 32);
exif->addTag (nt);
}
if (type == 0x1029)
saveCIFFMNTag (f, root, len, "CanonFocalLength");
if (type == 0x1031)
saveCIFFMNTag (f, root, len, "SensorInfo");
if (type == 0x1033)
saveCIFFMNTag (f, root, len, "CustomFunctions");
if (type == 0x1038)
saveCIFFMNTag (f, root, len, "CanonAFInfo");
if (type == 0x1093)
saveCIFFMNTag (f, root, len, "CanonFileInfo");
if (type == 0x10a9)
saveCIFFMNTag (f, root, len, "ColorBalance");
if (type == 0x102a) {
saveCIFFMNTag (f, root, len, "CanonShotInfo");
iso = pow (2, (get4(f, INTEL),get2(f, INTEL))/32.0 - 4) * 50;
aperture = (get2(f, INTEL),(short)get2(f, INTEL))/32.0f;
fnumber = pow (2, aperture/2);
shutter = ((short)get2(f, INTEL))/32.0f;
ev = ((short)get2(f, INTEL))/32.0f;
fseek (f, 34, SEEK_CUR);
if (shutter > 1e6) shutter = get2 (f, INTEL) / 10.0f;
exptime = pow (2,-shutter);
}
if (type == 0x5029) {
focal_len = len >> 16;
if ((len & 0xffff) == 2) focal_len /= 32;
}
// if (type == 0x5813) flash_used = int_to_float(len);
if (type == 0x580e) timestamp = len;
if (type == 0x180e) timestamp = get4 (f, INTEL);
if ((type | 0x4000) == 0x580e)
timestamp = mktime (gmtime (&timestamp));
fseek (f, nextPos, SEEK_SET);
}
if (shutter>-999) {
t = new Tag (exif, lookupAttrib(exifAttribs,"ShutterSpeedValue"));
t->initRational ((int)(shutter*10000), 10000);
exif->addTag (t);
}
if (exptime>-999) {
t = new Tag (exif, lookupAttrib(exifAttribs,"ExposureTime"));
t->initRational ((int)(exptime*10000), 10000);
exif->addTag (t);
}
if (aperture>-999) {
t = new Tag (exif, lookupAttrib(exifAttribs,"ApertureValue"));
t->initRational ((int)(aperture*10), 10);
exif->addTag (t);
}
if (fnumber>-999) {
t = new Tag (exif, lookupAttrib(exifAttribs,"FNumber"));
t->initRational ((int)(fnumber*10), 10);
exif->addTag (t);
}
if (ev>-999) {
t = new Tag (exif, lookupAttrib(exifAttribs,"ExposureBiasValue"));
t->initRational ((int)(ev*1000), 1000);
exif->addTag (t);
}
if (iso>0) {
t = new Tag (exif, lookupAttrib(exifAttribs,"ISOSpeedRatings"));
t->initInt (iso, LONG);
exif->addTag (t);
}
if (focal_len>0) {
t = new Tag (exif, lookupAttrib(exifAttribs,"FocalLength"));
t->initRational (focal_len*32, 32);
exif->addTag (t);
}
if (timestamp!=time(NULL)) {
struct tm* tim = localtime (&timestamp);
strftime (buffer, 20, "%Y:%m:%d %H:%M:%S", tim);
t = new Tag (exif, lookupAttrib(exifAttribs,"DateTimeOriginal"));
t->initString (buffer);
exif->addTag (t);
t = new Tag (exif, lookupAttrib(exifAttribs,"DateTimeDigitized"));
t->initString (buffer);
exif->addTag (t);
t = new Tag (root, lookupAttrib(ifdAttribs,"DateTime"));
t->initString (buffer);
root->addTag (t);
}
}
static void
parse_leafdata(TagDirectory* root, ByteOrder order) {
Tag *leafdata = root->getTag("LeafData");
if (!leafdata) {
return;
}
unsigned char *value = leafdata->getValue();
int valuesize = leafdata->getValueSize();
// parse LeafData tag, a tag specific to Leaf digital backs, and has a custom
// format with 52 byte tag headers starting with "PKTS"
const char *PKTS_tag = (order == MOTOROLA) ? "PKTS" : "STKP";
char *hdr;
int pos = 0;
// There are lots of sub-tags in here, but for now we only care about those directly
// useful to RT, which is ISO and rotation. Shutter speed and aperture is not
// available here.
int iso_speed = 0;
int rotation_angle = 0;
int found_count = 0;
while (pos + (int)sizeof(hdr) <= valuesize && found_count < 2) {
hdr = (char *)&value[pos];
if (strncmp(hdr, PKTS_tag, 4) != 0) {
// in a few cases the header can be offset a few bytes, don't know why
// it does not seem to be some sort of alignment, it appears random,
// this check takes care of it, restart if we find an offset match.
int offset = 1;
for (; offset <= 3; offset++) {
if (strncmp(&hdr[offset], PKTS_tag, 4) == 0) {
pos += offset;
break;
}
}
if (offset <= 3) {
continue;
}
break;
}
int size = sget4((unsigned char *)&hdr[48], order);
if (pos + size > valuesize) {
break;
}
pos += 52;
char *val = (char *)&value[pos];
if (strncmp(&hdr[8], "CameraObj_ISO_speed", 19) == 0) {
iso_speed = 25 * (1 << (atoi(val) - 1));
found_count++;
} else if (strncmp(&hdr[8], "ImgProf_rotation_angle", 22) == 0) {
rotation_angle = atoi(val);
found_count++;
} else {
// check if this is a sub-directory, include test for that strange offset of next header
if (size >= 8 &&
(strncmp(val, PKTS_tag, 4) == 0 ||
strncmp(&val[1], PKTS_tag, 4) == 0 ||
strncmp(&val[2], PKTS_tag, 4) == 0 ||
strncmp(&val[3], PKTS_tag, 4) == 0))
{
// start of next hdr, this is a sub-directory, we skip those for now.
size = 0;
}
}
pos += size;
}
// create standard tags from the custom Leaf tags
Tag* exif = root->getTag ("Exif");
if (!exif) {
exif = new Tag (root, root->getAttrib ("Exif"));
exif->initSubDir();
root->addTagFront (exif);
}
if (!exif->getDirectory()->getTag("ISOSpeedRatings")) {
Tag *t = new Tag (exif->getDirectory(), exif->getDirectory()->getAttrib ("ISOSpeedRatings"));
t->initInt (iso_speed, LONG);
exif->getDirectory()->addTagFront (t);
}
if (!root->getTag("Orientation")) {
int orientation;
switch (rotation_angle) {
case 0: orientation = 1; break;
case 90: orientation = 6; break;
case 180: orientation = 3; break;
case 270: orientation = 8; break;
default: orientation = 1; break;
}
Tag *t = new Tag (root, root->getAttrib ("Orientation"));
t->initInt (orientation, SHORT);
root->addTagFront (t);
}
// now look in ApplicationNotes tag for additional information
Tag *appnotes = root->getTag("ApplicationNotes");
if (!appnotes) {
return;
}
char *xmp = (char *)appnotes->getValue();
char *end, *p;
// Quick-and-dirty value extractor, no real xml parsing.
// We could make it more generic, but we just get most important
// values we know use to be in there.
if ((p = strstr(xmp, "xmlns:tiff")) != NULL &&
(end = strstr(p, "</rdf:Description>")) != NULL)
{
*end = '\0';
while ((p = strstr(p, "<tiff:")) != NULL) {
char *tag = &p[6], *tagend;
if ((tagend = strchr(tag, '>')) == NULL) {
break;
}
*tagend = '\0';
char *val = &tagend[1];
if ((p = strstr(val, "</tiff:")) == NULL) {
*tagend = '>';
break;
}
*p = '\0';
if (root->getAttrib (tag) && !root->getTag (tag)) {
Tag *t = new Tag (root, root->getAttrib (tag));
if (strcmp(tag, "Make") == 0 ||
strcmp(tag, "Model") == 0)
{
if (strcmp(tag, "Model") == 0) {
// Leaf adds back serial number and camera model to the 'Model'
// tag, we strip that away here so the back can be recognized
// and matched against DCP profile
char *p1 = strchr(val, '(');
if (p1 != NULL) {
*p1 = '\0';
}
// Model name also contains a leading "Leaf " which we already
// have in the Make name, remove that.
if (strstr(val, "Leaf ") == val) {
t->initString (&val[5]);
} else {
t->initString (val);
}
if (p1 != NULL) {
*p1 = '(';
}
} else {
t->initString (val);
}
root->addTagFront (t);
} else {
delete t;
}
}
*p = '<';
*tagend = '>';
}
*end = '<';
}
if ((p = strstr(xmp, "xmlns:exif")) != NULL &&
(end = strstr(p, "</rdf:Description>")) != NULL)
{
*end = '\0';
while ((p = strstr(p, "<exif:")) != NULL) {
char *tag = &p[6], *tagend;
if ((tagend = strchr(tag, '>')) == NULL) {
break;
}
*tagend = '\0';
char *val = &tagend[1];
if ((p = strstr(val, "</exif:")) == NULL) {
*tagend = '>';
break;
}
*p = '\0';
if (exif->getDirectory()->getAttrib (tag) && !exif->getDirectory()->getTag (tag)) {
Tag *t = new Tag (exif->getDirectory(), exif->getDirectory()->getAttrib (tag));
int num, denom;
struct tm tm;
if (strcmp(tag, "ApertureValue") == 0 && sscanf(val, "%d/%d", &num, &denom) == 2) {
t->initRational (num, denom);
exif->getDirectory()->addTagFront (t);
// we also make an "FNumber" tag since many tools don't interpret ApertureValue
// according to Exif standard
t = new Tag (exif->getDirectory(), lookupAttrib(exifAttribs,"FNumber"));
double f = pow(sqrt(2.0), ((double)num / denom));
if (f > 10.0) {
t->initRational ((int)floor(f), 1);
} else {
t->initRational ((int)floor(f * 10.0), 10);
}
exif->getDirectory()->addTagFront (t);
} else if (strcmp(tag, "ShutterSpeedValue") == 0 && sscanf(val, "%d/%d", &num, &denom) == 2) {
t->initRational (num, denom);
exif->getDirectory()->addTagFront (t);
// we also make an "ExposureTime" tag since many tools don't interpret ShutterSpeedValue
// according to Exif standard
t = new Tag (exif->getDirectory(), lookupAttrib(exifAttribs,"ExposureTime"));
double f = 1.0 / pow(2.0, ((double)num / denom));
if (f > 10.0) {
t->initRational ((int)floor(f), 1);
} else if (f > 1.0) {
t->initRational ((int)floor(f * 10.0), 10);
} else if (f == 1.0) {
t->initRational (1, 1);
} else {
f = 1.0 / f;
static const double etimes[] = {
10000, 8000, 6400, 6000, 5000,
4000, 3200, 3000, 2500,
2000, 1600, 1500, 1250,
1000, 800, 750, 640,
500, 400, 350, 320,
250, 200, 180, 160,
125, 100, 90, 80,
60, 50, 45, 40,
30, 25, 22, 20,
15, 13, 11, 10,
8, 6, 5,
4, 3, 2.5,
2, 1.6, 1.5, 1.3,
1, -1 };
double diff = etimes[0];
int idx = -1;
for (int i = 1; etimes[i] > 0; i++) {
if (abs(etimes[i] - f) < diff) {
idx = i;
diff = abs(etimes[i] - f);
}
}
if (idx != -1 && f < etimes[0]) {
f = etimes[idx];
}
if (f < 2) {
t->initRational (10, (int)(10 * f));
} else {
t->initRational (1, (int)f);
}
}
exif->getDirectory()->addTagFront (t);
} else if (strcmp(tag, "FocalLength") == 0 && sscanf(val, "%d/%d", &num, &denom) == 2) {
t->initRational (num, denom);
exif->getDirectory()->addTagFront (t);
} else if (strcmp(tag, "ISOSpeedRatings") == 0) {
char *p1 = val;
while (*p1 != '\0' && !isdigit(*p1)) p1++;
if (*p1 != '\0') {
t->initInt (atoi(p1), LONG);
exif->getDirectory()->addTagFront (t);
}
} else if (strcmp(tag, "DateTimeOriginal") == 0 &&
sscanf(val, "%d-%d-%dT%d:%d:%dZ",
&tm.tm_year, &tm.tm_mon,
&tm.tm_mday, &tm.tm_hour,
&tm.tm_min, &tm.tm_sec) == 6)
{
char tstr[64];
sprintf(tstr, "%04d:%02d:%02d %02d:%02d:%02d", tm.tm_year, tm.tm_mon,
tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
t->initString (tstr);
exif->getDirectory()->addTagFront (t);
} else {
delete t;
}
}
*p = '<';
*tagend = '>';
}
*end = '<';
}
}
TagDirectory* ExifManager::parse (FILE* f, int base, bool skipIgnored) {
setlocale(LC_NUMERIC, "C"); // to set decimal point in sscanf
// read tiff header
fseek (f, base, SEEK_SET);
unsigned short bo;
fread (&bo, 1, 2, f);
ByteOrder order = (ByteOrder)((int)bo);
get2 (f, order);
int firstifd = get4 (f, order);
// seek to IFD0
fseek (f, base+firstifd, SEEK_SET);
// first read the IFD directory
TagDirectory* root = new TagDirectory (NULL, f, base, ifdAttribs, order, skipIgnored);
// fix ISO issue with nikon and panasonic cameras
Tag* make = root->getTag ("Make");
Tag* exif = root->getTag ("Exif");
if (exif && !exif->getDirectory()->getTag("ISOSpeedRatings")) {
if (make && !strncmp((char*)make->getValue(), "NIKON", 5)) {
Tag* mn = exif->getDirectory()->getTag("MakerNote");
if (mn) {
Tag* iso = mn->getDirectory()->getTag("ISOSpeed");
if (iso) {
std::string isov = iso->valueToString ();
Tag* niso = new Tag (exif->getDirectory(), exif->getDirectory()->getAttrib ("ISOSpeedRatings"));
niso->initInt (atoi(isov.c_str()), SHORT);
exif->getDirectory()->addTagFront (niso);
}
}
}
else if (make && (!strncmp((char*)make->getValue(), "Panasonic", 9) || !strncmp((char*)make->getValue(), "LEICA", 5))) {
Tag* iso = root->getTag("PanaISO");
if (iso) {
std::string isov = iso->valueToString ();
Tag* niso = new Tag (exif->getDirectory(), exif->getDirectory()->getAttrib ("ISOSpeedRatings"));
niso->initInt (atoi(isov.c_str()), SHORT);
exif->getDirectory()->addTagFront (niso);
}
}
}
if (make && !strncmp((char*)make->getValue(), "Kodak", 5)) {
if (!exif) {
// old Kodak cameras may have exif tags in IFD0, reparse and create an exif subdir
fseek (f, base+firstifd, SEEK_SET);
TagDirectory* exifdir = new TagDirectory (NULL, f, base, exifAttribs, order, true);
exif = new Tag (root, root->getAttrib ("Exif"));
exif->initSubDir(exifdir);
root->addTagFront (exif);
if (!exif->getDirectory()->getTag("ISOSpeedRatings") && exif->getDirectory()->getTag ("ExposureIndex")) {
Tag* niso = new Tag (exif->getDirectory(), exif->getDirectory()->getAttrib ("ISOSpeedRatings"));
niso->initInt (exif->getDirectory()->getTag ("ExposureIndex")->toInt(), SHORT);
exif->getDirectory()->addTagFront (niso);
}
}
Tag *kodakIFD = root->getTag("KodakIFD");
if (kodakIFD && kodakIFD->getDirectory()->getTag("TextualInfo")) {
parseKodakIfdTextualInfo(kodakIFD->getDirectory()->getTag("TextualInfo"), exif);
}
}
parse_leafdata(root, order);
if (make && !strncmp((char*)make->getValue(), "Hasselblad", 10)) {
/*
Figuring out the Hasselblad model is a mess. Hasselblad raw data comes in four slightly
different containers, 3FR (directly from CF card), FFF (same as 3FR but filtered through
Phocus, calibration data applied and a bit different tags), Adobe-generated DNGs and
Phocus-generated DNGs.
FFF usually has a sane model name in Model (and is used as reference for what we shall
call the different Hasselblad models), but 3FR only says like "Hasselblad H3D" for
all H3D models, or "Flash Sync" if the back has been used on a mechanical camera body.
V-mount backs may have the model name of the V body instead of the back model. Etc...
as said it's a mess.
This code is supposed to handle all raw containers and end up with the same model
regardless of container.
We don't differ between single shot and multi-shot models, and probably there's no use
of doing so. You need Hasselblad's own software to shoot multi-shot and can only do that
tethered. In single-shot mode they should be exactly the same as the single-shot models.
*/
Tag *subd = root->getTag(0x14a);
Tag *iw = (subd) ? subd->getDirectory()->getTag("ImageWidth") : 0;
int sensorWidth = (iw) ? iw->toInt() : 0;
Tag* tmodel = root->getTag ("Model");
const char *model = (tmodel) ? (const char *)tmodel->getValue() : "";
if (strstr(model, "Hasselblad ") == model) {
model += 11;
} else {
// if HxD is used in flash sync mode for example, we need to fetch model from this tag
Tag* tmodel3 = root->getTag("UniqueCameraModel");
const char *model3 = (tmodel3) ? (const char *)tmodel3->getValue() : "";
if (strstr(model3, "Hasselblad ") == model3) {
model = model3 + 11;
}
}
// FIXME: due to lack of test files this Hasselblad model identification is not 100% complete
// This needs checking out: CFV-39/CFV-50 3FR, H3DII vs H3D, old CF/CFH models
if (!strcmp(model, "H3D")) {
// We can't differ between H3D and H3DII for the 22, 31 and 39 models. There's was no H3D-50 so we know that is a
// H3DII-50. At the time of writing I have no test files for the H3D vs H3DII models, so there still may be a chance
// to differ between them. AFAIK Adobe's DNG converter don't differ between them, and actually call the H3DII-50
// H3D-50 although Hasselblad never released such a model.
switch (sensorWidth) {
case 4096: tmodel->initString("H3D-22"); break;
case 6542: tmodel->initString("H3D-31"); break;
case 7262: tmodel->initString("H3D-39"); break;
case 8282: tmodel->initString("H3DII-50"); break;
}
} else if (!strcmp(model, "H4D")) {
switch (sensorWidth) {
case 6542: tmodel->initString("H4D-31"); break;
case 7410: tmodel->initString("H4D-40"); break;
case 8282: tmodel->initString("H4D-50"); break;
case 9044: tmodel->initString("H4D-60"); break;
}
} else if (!strcmp(model, "H5D")) {
switch (sensorWidth) {
case 7410: tmodel->initString("H5D-40"); break;
case 8282: tmodel->initString("H5D-50"); break;
case 8374: tmodel->initString("H5D-50c"); break;
case 9044: tmodel->initString("H5D-60"); break;
}
} else if (!strcmp(model, "CFV")) {
switch (sensorWidth) {
case 7262: tmodel->initString("CFV-39"); break;
case 8282: tmodel->initString("CFV-50"); break;
case 8374: tmodel->initString("CFV-50c"); break;
}
}
// and a few special cases
Tag* tmodel3 = root->getTag("UniqueCameraModel");
const char *model3 = (tmodel3) ? (const char *)tmodel3->getValue() : "";
if (strstr(model3, "Hasselblad ") == model3) {
model3 = model3 + 11;
}
if (!strcmp(model3, "ixpressCF132")) {
tmodel->initString("CF-22");
} else if (!strcmp(model3, "Hasselblad96")) {
tmodel->initString("CFV"); // popularly called CFV-16, but the official name is CFV
} else if (!strcmp(model3, "Hasselblad234")) {
tmodel->initString("CFV-39");
} else if (sensorWidth == 4090) {
tmodel->initString("V96C");
}
// and yet some, this is for Adobe-generated DNG files
Tag* tmodel4 = root->getTag("LocalizedCameraModel");
if (tmodel4) {
const char *model4 = (tmodel4) ? (const char *)tmodel4->getValue() : "";
if (strstr(model4, "Hasselblad ") == model4) {
model4 = model4 + 11;
}
if (!strcmp(model4, "ixpressCF132-22")) {
tmodel->initString("CF-22");
} else if (!strcmp(model4, "Hasselblad96-16")) {
tmodel->initString("CFV");
} else if (!strcmp(model4, "Hasselblad234-39")) {
tmodel->initString("CFV-39");
} else if (!strcmp(model4, "H3D-50")) {
// Adobe names H3DII-50 incorrectly as H3D-50
tmodel->initString("H3DII-50");
} else if (strstr(model4, "H3D-") == model4 || strstr(model4, "H4D-") == model4 || strstr(model4, "H5D-") == model4) {
tmodel->initString(model4);
}
}
}
if (!root->getTag("Orientation")) {
if (make && !strncmp((char*)make->getValue(), "Phase One", 9)) {
int orientation = 0;
Tag *iw = root->getTag("ImageWidth");
if (iw) {
// from dcraw, derive orientation from image width
orientation = "0653"[iw->toInt()&3]-'0';
}
Tag *t = new Tag (root, root->getAttrib ("Orientation"));
t->initInt (orientation, SHORT);
root->addTagFront (t);
}
}
// root->printAll ();
return root;
}
TagDirectory* ExifManager::parseJPEG (FILE* f) {
fseek (f, 0, SEEK_SET);
unsigned char markerl = 0xff;
unsigned char c;
fread (&c, 1, 1, f);
const char exifid[] = "Exif\0\0";
char idbuff[8];
int tiffbase = -1;
while (fread (&c, 1, 1, f)) {
if (c!=markerl) continue;
if (fread (&c, 1, 1, f) && c==0xe1) { // APP1 marker found
if (fread (idbuff, 1, 8, f)<8)
return NULL;
if (!memcmp(idbuff+2, exifid, 6)) { // Exif info found
tiffbase = ftell (f);
return parse (f, tiffbase);
}
}
}
return NULL;
}
TagDirectory* ExifManager::parseTIFF (FILE* f, bool skipIgnored) {
return parse (f, 0, skipIgnored);
}
std::vector<Tag*> ExifManager::defTags;
// forthis: the byte order will be taken from directory "forthis"
const std::vector<Tag*>& ExifManager::getDefaultTIFFTags (TagDirectory* forthis) {
for (size_t i=0; i<defTags.size(); i++)
delete defTags[i];
defTags.clear ();
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"ImageWidth"), 0, LONG));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"ImageHeight"), 0, LONG));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"XResolution"), 300, RATIONAL));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"YResolution"), 300, RATIONAL));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"ResolutionUnit"), 2, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"Software"), "RawTherapee"));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"Orientation"), 1, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"SamplesPerPixel"), 3, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"BitsPerSample"), 8, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"PlanarConfiguration"), 1, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"PhotometricInterpretation"), 2, SHORT));
defTags.push_back (new Tag (forthis, lookupAttrib(ifdAttribs,"Compression"), 1, SHORT));
return defTags;
}
int ExifManager::createJPEGMarker (const TagDirectory* root, const rtengine::procparams::ExifPairs& changeList, int W, int H, unsigned char* buffer) {
// write tiff header
int offs = 6;
memcpy (buffer, "Exif\0\0", 6);
ByteOrder order = INTEL;
if (root)
order = root->getOrder ();
sset2 ((unsigned short)order, buffer+offs, order); offs += 2;
sset2 (42, buffer+offs, order); offs += 2;
sset4 (8, buffer+offs, order); offs += 4;
TagDirectory* cl;
if (root)
cl = (const_cast<TagDirectory*>(root))->clone (NULL);
else
cl = new TagDirectory (NULL, ifdAttribs, INTEL);
for (rtengine::procparams::ExifPairs::const_iterator i=changeList.begin(); i!=changeList.end(); i++)
cl->applyChange (i->first, i->second);
getDefaultTIFFTags (cl);
defTags[0]->setInt (W, 0, LONG);
defTags[1]->setInt (H, 0, LONG);
defTags[8]->setInt (8, 0, SHORT);
for (int i=defTags.size()-1; i>=0; i--)
cl->replaceTag (defTags[i]->clone (cl));
cl->sort ();
int size = cl->write (8, buffer+6);
delete cl;
return size + 6;
}
int ExifManager::createTIFFHeader (const TagDirectory* root, const rtengine::procparams::ExifPairs& changeList, int W, int H, int bps, const char* profiledata, int profilelen, const char* iptcdata, int iptclen, unsigned char* buffer) {
// write tiff header
int offs = 0;
ByteOrder order = HOSTORDER;
if (root)
order = root->getOrder ();
sset2 ((unsigned short)order, buffer+offs, order); offs += 2;
sset2 (42, buffer+offs, order); offs += 2;
sset4 (8, buffer+offs, order); offs += 4;
TagDirectory* cl;
if (root)
cl = (const_cast<TagDirectory*>(root))->clone (NULL);
else
cl = new TagDirectory (NULL, ifdAttribs, HOSTORDER);
// add tiff strip data
int rps = 8;
int strips = ceil((double)H/rps);
cl->replaceTag (new Tag (cl, lookupAttrib(ifdAttribs,"RowsPerStrip"), rps, LONG));
Tag* stripBC = new Tag (cl, lookupAttrib(ifdAttribs,"StripByteCounts"));
stripBC->initInt (0, LONG, strips);
cl->replaceTag (stripBC);
Tag* stripOffs = new Tag (cl, lookupAttrib(ifdAttribs,"StripOffsets"));
stripOffs->initInt (0, LONG, strips);
cl->replaceTag (stripOffs);
for (int i=0; i<strips-1; i++)
stripBC->setInt (rps*W*3*bps/8, i*4);
int remaining = (H-rps*floor((double)H/rps))*W*3*bps/8;
if (remaining)
stripBC->setInt (remaining, (strips-1)*4);
else
stripBC->setInt (rps*W*3*bps/8, (strips-1)*4);
if (profiledata) {
Tag* icc = new Tag (cl, lookupAttrib(ifdAttribs,"ICCProfile"));
icc->initUndefArray (profiledata, profilelen);
cl->replaceTag (icc);
}
if (iptcdata) {
Tag* iptc = new Tag (cl, lookupAttrib(ifdAttribs,"IPTCData"));
iptc->initLongArray (iptcdata, iptclen);
cl->replaceTag (iptc);
}
// apply list of changes
for (rtengine::procparams::ExifPairs::const_iterator i=changeList.begin(); i!=changeList.end(); i++)
cl->applyChange (i->first, i->second);
// append default properties
getDefaultTIFFTags (cl);
defTags[0]->setInt (W, 0, LONG);
defTags[1]->setInt (H, 0, LONG);
defTags[8]->initInt(0, SHORT, 3);
for (int i=0;i<3;i++) defTags[8]->setInt(bps, i*2, SHORT);
for (int i=defTags.size()-1; i>=0; i--)
cl->replaceTag (defTags[i]->clone (cl));
// calculate strip offsets
int size = cl->calculateSize ();
int byps = bps / 8;
for (int i=0; i<strips; i++)
stripOffs->setInt (size + 8 + i*rps*W*3*byps, i*4);
cl->sort ();
int endOffs = cl->write (8, buffer);
// cl->printAll();
delete cl;
return endOffs;
}
//-----------------------------------------------------------------------------
// global functions to read byteorder dependent data
//-----------------------------------------------------------------------------
unsigned short sget2 (unsigned char *s, rtexif::ByteOrder order) {
if (order == rtexif::INTEL) return s[0] | s[1] << 8;
else return s[0] << 8 | s[1];
}
int sget4 (unsigned char *s, rtexif::ByteOrder order) {
if (order == rtexif::INTEL) return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
else return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
}
inline unsigned short get2 (FILE* f, rtexif::ByteOrder order) {
unsigned char str[2] = { 0xff,0xff };
fread (str, 1, 2, f);
return rtexif::sget2 (str, order);
}
int get4 (FILE* f, rtexif::ByteOrder order) {
unsigned char str[4] = { 0xff,0xff,0xff,0xff };
fread (str, 1, 4, f);
return rtexif::sget4 (str, order);
}
void sset2 (unsigned short v, unsigned char *s, rtexif::ByteOrder order) {
if (order == rtexif::INTEL) {
s[0] = v & 0xff; v >>= 8;
s[1] = v;
}
else {
s[1] = v & 0xff; v >>= 8;
s[0] = v;
}
}
void sset4 (int v, unsigned char *s, rtexif::ByteOrder order) {
if (order == rtexif::INTEL) {
s[0] = v & 0xff; v >>= 8;
s[1] = v & 0xff; v >>= 8;
s[2] = v & 0xff; v >>= 8;
s[3] = v;
}
else {
s[3] = v & 0xff; v >>= 8;
s[2] = v & 0xff; v >>= 8;
s[1] = v & 0xff; v >>= 8;
s[0] = v;
}
}
float int_to_float (int i) {
union { int i; float f; } u;
u.i = i;
return u.f;
}
short int int2_to_signed (short unsigned int i) {
union { short unsigned int i; short int s; } u;
u.i = i;
return u.s;
}
/* Function to parse and extract focal length and aperture information from description
* @fullname must conform to the following formats
* <focal>mm f/<aperture>
* <focal>-<focal>mm f/<aperture>
* <focal>-<focal>mm f/<aperture>-<aperture>
* NB: no space between separator '-'; no space between focal length and 'mm'
*/
bool extractLensInfo(std::string &fullname,double &minFocal, double &maxFocal, double &maxApertureAtMinFocal, double &maxApertureAtMaxFocal)
{
minFocal=0.0;
maxFocal=0.0;
maxApertureAtMinFocal=0.0;
maxApertureAtMaxFocal=0.0;
char buffer[1024];
strcpy(buffer,fullname.c_str());
char *pF = strstr(buffer,"f/" );
if( pF ){
sscanf(pF+2,"%lf-%lf",&maxApertureAtMinFocal,&maxApertureAtMaxFocal);
if(maxApertureAtMinFocal >0. && maxApertureAtMaxFocal==0.)
maxApertureAtMaxFocal= maxApertureAtMinFocal;
char *pMM = pF-3;
while( pMM[0]!= 'm' && pMM[1]!= 'm' && pMM>buffer) pMM--;
if( pMM[0]== 'm' && pMM[1]== 'm' ){
char *sp=pMM;
while( *sp != ' ' && sp > buffer )sp--;
sscanf(sp+1,"%lf-%lf",&minFocal,&maxFocal);
if(maxFocal==0.) {
maxFocal = minFocal;
}
return true;
}
}
return false;
}
}
Reference in New Issue View Git Blame Copy Permalink