manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/wrap/Exif/include/Exif/exif.h

915 lines
34 KiB
C++
Raw Blame History

#ifndef EXIF_H
#define EXIF_H
#include <vcg/math/camera.h>
#include <vector>
using namespace std;
template <class T>
class Exif{
public:
Exif(){
sections.resize(0);
motorolaOrder = false;
}
bool readJPEG(const char *filename){
FILE *fp = fopen(filename, "rb"); // Unix ignores 'b', windows needs it.
//parse the marker stream until SOS or EOI is seen
if(!fp || !readJpegSections(fp)) return false;
fclose(fp);
return true;
}
//Compute the CCD width, in millimeters
// Note: With some cameras, its not possible to compute this correctly because
// they don't adjust the indicated focal plane resolution units when using less
// than maximum resolution, so the CCDWidth value comes out too small. Nothing
// that Jhad can do about it - its a camera problem.
T CCDwidthMm() const {
if(!FocalplaneXRes) return -1;
return T(ExifImageWidth * FocalplaneUnits / FocalplaneXRes);
}
// Compute 35 mm equivalent focal length based on sensor geometry if we haven't
// already got it explicitly from a tag.
T FocalLength35mmEquiv() const {
if( intrinsics.FocalMm && !FocalLength35mmEquiv )
FocalLength35mmEquiv = T(ImageInfo.FocalLength/ImageInfo.CCDWidth*36 + 0.5);
return FocalLength35mmEquiv;
}
vcg::Camera<T> vcgCamera() const {
vcg::Camera<T> intrinsics;
return intrinsics;
}
private:
// JPEG markers consist of one or more 0xFF bytes, followed by a marker
// code byte (which is not an FF). Here are the marker codes of interest
// in this program.
#define M_SOF0 0xC0 // Start Of Frame N
#define M_SOF1 0xC1 // N indicates which compression process
#define M_SOF2 0xC2 // Only SOF0-SOF2 are now in common use
#define M_SOF3 0xC3
#define M_SOF5 0xC5 // NB: codes C4 and CC are NOT SOF markers
#define M_SOF6 0xC6
#define M_SOF7 0xC7
#define M_SOF9 0xC9
#define M_SOF10 0xCA
#define M_SOF11 0xCB
#define M_SOF13 0xCD
#define M_SOF14 0xCE
#define M_SOF15 0xCF
#define M_SOI 0xD8 // Start Of Image (beginning of datastream)
#define M_EOI 0xD9 // End Of Image (end of datastream)
#define M_SOS 0xDA // Start Of Scan (begins compressed data)
#define M_JFIF 0xE0 // Jfif marker
#define M_EXIF 0xE1 // Exif marker. Also used for XMP data!
#define M_XMP 0x10E1 // Not a real tag (same value in file as Exif!)
#define M_COM 0xFE // COMment
#define M_DQT 0xDB
#define M_DHT 0xC4
#define M_DRI 0xDD
#define M_IPTC 0xED // IPTC marker
// Exif format descriptor stuff
#define MAX_DATE_COPIES 10
#ifdef _WIN32
#define PATH_MAX _MAX_PATH
#define SLASH '\\'
#else
#define SLASH '/'
#endif
const int *BytesPerFormat;
#define NUM_FORMATS 12
#define FMT_BYTE 1
#define FMT_STRING 2
#define FMT_USHORT 3
#define FMT_ULONG 4
#define FMT_URATIONAL 5
#define FMT_SBYTE 6
#define FMT_UNDEFINED 7
#define FMT_SSHORT 8
#define FMT_SLONG 9
#define FMT_SRATIONAL 10
#define FMT_SINGLE 11
#define FMT_DOUBLE 12
// Describes tag values
#define TAG_INTEROP_INDEX 0x0001
#define TAG_INTEROP_VERSION 0x0002
#define TAG_IMAGE_WIDTH 0x0100
#define TAG_IMAGE_LENGTH 0x0101
#define TAG_BITS_PER_SAMPLE 0x0102
#define TAG_COMPRESSION 0x0103
#define TAG_PHOTOMETRIC_INTERP 0x0106
#define TAG_FILL_ORDER 0x010A
#define TAG_DOCUMENT_NAME 0x010D
#define TAG_IMAGE_DESCRIPTION 0x010E
#define TAG_MAKE 0x010F
#define TAG_MODEL 0x0110
#define TAG_SRIP_OFFSET 0x0111
#define TAG_ORIENTATION 0x0112
#define TAG_SAMPLES_PER_PIXEL 0x0115
#define TAG_ROWS_PER_STRIP 0x0116
#define TAG_STRIP_BYTE_COUNTS 0x0117
#define TAG_X_RESOLUTION 0x011A
#define TAG_Y_RESOLUTION 0x011B
#define TAG_PLANAR_CONFIGURATION 0x011C
#define TAG_RESOLUTION_UNIT 0x0128
#define TAG_TRANSFER_FUNCTION 0x012D
#define TAG_SOFTWARE 0x0131
#define TAG_DATETIME 0x0132
#define TAG_ARTIST 0x013B
#define TAG_WHITE_POINT 0x013E
#define TAG_PRIMARY_CHROMATICITIES 0x013F
#define TAG_TRANSFER_RANGE 0x0156
#define TAG_JPEG_PROC 0x0200
#define TAG_THUMBNAIL_OFFSET 0x0201
#define TAG_THUMBNAIL_LENGTH 0x0202
#define TAG_Y_CB_CR_COEFFICIENTS 0x0211
#define TAG_Y_CB_CR_SUB_SAMPLING 0x0212
#define TAG_Y_CB_CR_POSITIONING 0x0213
#define TAG_REFERENCE_BLACK_WHITE 0x0214
#define TAG_RELATED_IMAGE_WIDTH 0x1001
#define TAG_RELATED_IMAGE_LENGTH 0x1002
#define TAG_CFA_REPEAT_PATTERN_DIM 0x828D
#define TAG_CFA_PATTERN1 0x828E
#define TAG_BATTERY_LEVEL 0x828F
#define TAG_COPYRIGHT 0x8298
#define TAG_EXPOSURETIME 0x829A
#define TAG_FNUMBER 0x829D
#define TAG_IPTC_NAA 0x83BB
#define TAG_EXIF_OFFSET 0x8769
#define TAG_INTER_COLOR_PROFILE 0x8773
#define TAG_EXPOSURE_PROGRAM 0x8822
#define TAG_SPECTRAL_SENSITIVITY 0x8824
#define TAG_GPSINFO 0x8825
#define TAG_ISO_EQUIVALENT 0x8827
#define TAG_OECF 0x8828
#define TAG_EXIF_VERSION 0x9000
#define TAG_DATETIME_ORIGINAL 0x9003
#define TAG_DATETIME_DIGITIZED 0x9004
#define TAG_COMPONENTS_CONFIG 0x9101
#define TAG_CPRS_BITS_PER_PIXEL 0x9102
#define TAG_SHUTTERSPEED 0x9201
#define TAG_APERTURE 0x9202
#define TAG_BRIGHTNESS_VALUE 0x9203
#define TAG_EXPOSURE_BIAS 0x9204
#define TAG_MAXAPERTURE 0x9205
#define TAG_SUBJECT_DISTANCE 0x9206
#define TAG_METERING_MODE 0x9207
#define TAG_LIGHT_SOURCE 0x9208
#define TAG_FLASH 0x9209
#define TAG_FOCALLENGTH 0x920A
#define TAG_MAKER_NOTE 0x927C
#define TAG_USERCOMMENT 0x9286
#define TAG_SUBSEC_TIME 0x9290
#define TAG_SUBSEC_TIME_ORIG 0x9291
#define TAG_SUBSEC_TIME_DIG 0x9292
#define TAG_WINXP_TITLE 0x9c9b // Windows XP - not part of exif standard.
#define TAG_WINXP_COMMENT 0x9c9c // Windows XP - not part of exif standard.
#define TAG_WINXP_AUTHOR 0x9c9d // Windows XP - not part of exif standard.
#define TAG_WINXP_KEYWORDS 0x9c9e // Windows XP - not part of exif standard.
#define TAG_WINXP_SUBJECT 0x9c9f // Windows XP - not part of exif standard.
#define TAG_FLASH_PIX_VERSION 0xA000
#define TAG_COLOR_SPACE 0xA001
#define TAG_EXIF_IMAGEWIDTH 0xA002
#define TAG_EXIF_IMAGELENGTH 0xA003
#define TAG_RELATED_AUDIO_FILE 0xA004
#define TAG_INTEROP_OFFSET 0xA005
#define TAG_FLASH_ENERGY 0xA20B
#define TAG_SPATIAL_FREQ_RESP 0xA20C
#define TAG_FOCAL_PLANE_XRES 0xA20E
#define TAG_FOCAL_PLANE_YRES 0xA20F
#define TAG_FOCAL_PLANE_UNITS 0xA210
#define TAG_SUBJECT_LOCATION 0xA214
#define TAG_EXPOSURE_INDEX 0xA215
#define TAG_SENSING_METHOD 0xA217
#define TAG_FILE_SOURCE 0xA300
#define TAG_SCENE_TYPE 0xA301
#define TAG_CFA_PATTERN 0xA302
#define TAG_CUSTOM_RENDERED 0xA401
#define TAG_EXPOSURE_MODE 0xA402
#define TAG_WHITEBALANCE 0xA403
#define TAG_DIGITALZOOMRATIO 0xA404
#define TAG_FOCALLENGTH_35MM 0xA405
#define TAG_SCENE_CAPTURE_TYPE 0xA406
#define TAG_GAIN_CONTROL 0xA407
#define TAG_CONTRAST 0xA408
#define TAG_SATURATION 0xA409
#define TAG_SHARPNESS 0xA40A
#define TAG_DISTANCE_RANGE 0xA40C
typedef unsigned int uint;
typedef unsigned char uchar;
static const uint MAX_COMMENT_SIZE = 2000;
typedef struct Section{
int type;
uint size;
uchar *data;
}Section;
vector<Section> sections;
bool motorolaOrder;
// This structure stores Exif header image elements in a simple manner
// Used to store camera data as extracted from the various ways that it can be
// stored in an exif header
typedef struct {
char FileName [PATH_MAX+1];
time_t FileDateTime;
unsigned FileSize;
char CameraMake [32];
char CameraModel [40];
char DateTime [20];
int Height, Width;
int Orientation;
int IsColor;
int Process;
int FlashUsed;
float FocalLength;
float ExposureTime;
float ApertureFNumber;
float Distance;
float CCDWidth;
float ExposureBias;
float DigitalZoomRatio;
int FocalLength35mmEquiv; // Exif 2.2 tag - usually not present.
int Whitebalance;
int MeteringMode;
int ExposureProgram;
int ExposureMode;
int ISOequivalent;
int LightSource;
int DistanceRange;
char Comments[MAX_COMMENT_SIZE];
int CommentWidchars; // If nonzer, widechar comment, indicates number of chars.
unsigned ThumbnailOffset; // Exif offset to thumbnail
unsigned ThumbnailSize; // Size of thumbnail.
unsigned LargestExifOffset; // Last exif data referenced (to check if thumbnail is at end)
char ThumbnailAtEnd; // Exif header ends with the thumbnail
// (we can only modify the thumbnail if its at the end)
int ThumbnailSizeOffset;
int DateTimeOffsets[MAX_DATE_COPIES];
int numDateTimeTags;
int GpsInfoPresent;
char GpsLat[31];
char GpsLong[31];
char GpsAlt[20];
}ImageInfo_t;
ImageInfo_t ImageInfo;
uchar *DirWithThumbnailPtrs;
T FocalplaneXRes;
T FocalplaneUnits;
int ExifImageWidth;
void * OrientationPtr[2];
int OrientationNumFormat[2];
int NumOrientations;
// Get 16 bits motorola order (always) for jpeg header stuff.
int Get16m(const void *Short){ return (((uchar*)Short)[0] << 8) | ((uchar*)Short)[1]; }
// Convert a 16 bit unsigned value from file's native byte order
int Get16u(void *Short){
return (motorolaOrder)?
(((uchar *)Short)[0] << 8) | ((uchar *)Short)[1] :
(((uchar *)Short)[1] << 8) | ((uchar *)Short)[0] ;
}
// Convert a 32 bit unsigned value from file's native byte order
unsigned Get32u(void *Long){ return (unsigned)Get32s(Long) & 0xffffffff; }
// Convert a 32 bit signed value from file's native byte order
int Get32s(void * Long){
return (motorolaOrder)?
((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16) | (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 ) :
((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16) | (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 ) ;
}
// Evaluate number, be it int, rational, or float from directory.
double ConvertAnyFormat(void * ValuePtr, int Format){
double Value = 0;
switch(Format){
case FMT_SBYTE: Value = *(signed char *)ValuePtr; break;
case FMT_BYTE: Value = *(uchar *)ValuePtr; break;
case FMT_USHORT: Value = Get16u(ValuePtr); break;
case FMT_ULONG: Value = Get32u(ValuePtr); break;
case FMT_URATIONAL:
case FMT_SRATIONAL:{
int Num = Get32s(ValuePtr);
int Den = Get32s(4+(char *)ValuePtr);
Value = (Den == 0)? 0 : double(Num/Den);
break;
}
case FMT_SSHORT: Value = (signed short)Get16u(ValuePtr); break;
case FMT_SLONG: Value = Get32s(ValuePtr); break;
// Not sure if this is correct (never seen float used in Exif format)
case FMT_SINGLE: Value = (double)*(float *)ValuePtr; break;
case FMT_DOUBLE: Value = *(double *)ValuePtr; break;
default:
fprintf(stderr, "Illegal format code %d", Format);
}
return Value;
}
bool readJpegSections(FILE *fp){
//parse the marker stream until SOS or EOI is seen
if(fgetc(fp) != 0xff) return false;
if(fgetc(fp) != M_SOI) return false;
uint status = 0;
while(!status){
Section sec;
int marker = 0;
for(int i=0 ; i<=16 ; i++){
marker = fgetc(fp);
if(marker) break;
}
if(!marker){
fprintf(stderr,"too many padding bytes\n");
status = 1;
continue;
}
/*
for(int a=0;a<=16;a++){
marker = fgetc(fp);
if(marker != 0xff) break;
if(a >= 16){
fprintf(stderr, "too many padding bytes\n");
status = 1;
continue;
}
}
*/
sec.type = marker;
//read the length of the section
int lh = fgetc(fp);
int ll = fgetc(fp);
int itemlen = (lh << 8) | ll;
if(itemlen < 2){
fprintf(stderr, "invalid marker\n");
status = 1;
continue;
}
sec.size = itemlen;
sec.data = (uchar*)malloc(itemlen);
//store first two pre-read bytes
sec.data[0] = (uchar)lh;
sec.data[1] = (uchar)ll;
int got = fread(sec.data+2, 1, itemlen-2, fp);
if(itemlen-2 != got){ //read the whole section
fprintf(stderr, "Premature end of file?\n");
status = 1;
continue;
}
switch(marker){
case M_SOS: //stop before hitting compressed data
status = 2;
continue;
case M_EOI: //in case it's a tables-only JPEG stream
fprintf(stderr, "No image in jpeg!\n");
status = 1;
continue;
case M_COM: //comment section
//process_COM(data, itemlen);
break;
case M_JFIF:
// Regular jpegs always have this tag, exif images have the exif
// marker instead, althogh ACDsee will write images with both markers.
// This program will re-create this marker on absence of exif marker,
// hence no need to keep the copy from the file.
free(sec.data);
sec.data = NULL;
break;
case M_EXIF:
// There can be different section using the same marker. Ignore all but "Exif" one
if(memcmp(sec.data+2, "Exif", 4) == 0){
if( !process_EXIF(sec.data, itemlen) ) status = 1;
}else // Oterwise, discard this section
free(sec.data);
sec.data = NULL;
break;
case M_IPTC:
case M_SOF0:
case M_SOF1:
case M_SOF2:
case M_SOF3:
case M_SOF5:
case M_SOF6:
case M_SOF7:
case M_SOF9:
case M_SOF10:
case M_SOF11:
case M_SOF13:
case M_SOF14:
case M_SOF15:
process_SOFn(sec.data, marker);
break;
default: // Skip any other sections
break;
}
}
return (status==2);
}
/*
Process a COM marker.
we must guard against random junk and varying newline representations.
*/
/* UNUSED
void process_COM(const uchar *data, uint length){
char Comment[MAX_COMMENT_SIZE+1];
int nch = 0;
length = max(length, MAX_COMMENT_SIZE); //truncate if it won't fit in our structure
for(int a=2 ; a<length ; a++){
uchar ch = data[a];
if( (ch=='\r') && (data[a+1]=='\n') ) continue; //remove cr followed by lf
Comment[nch++] = ( (ch>=32) || (ch=='\n') || (ch=='\t') )? char(ch) : '?';
}
Comment[nch] = '\0'; //null terminate
}
*/
// Process exif format directory, as used by Cannon maker note
void ProcessCanonMakerNoteDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength){
int NumDirEntries;
NumDirEntries = Get16u(DirStart);
#define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
uchar *DirEnd;
DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
if(DirEnd > (OffsetBase+ExifLength)){
fprintf(stderr, "Illegally sized exif makernote subdir (%d entries)", NumDirEntries);
return;
}
for(int de=0 ; de<NumDirEntries ; de++){
int Tag, Format, Components;
uchar *ValuePtr;
int ByteCount;
uchar *DirEntry;
DirEntry = DIR_ENTRY_ADDR(DirStart, de);
Tag = Get16u(DirEntry);
Format = Get16u(DirEntry+2);
Components = Get32u(DirEntry+4);
if((Format-1) >= NUM_FORMATS){
// (-1) catches illegal zero case as unsigned underflows to positive large.
fprintf(stderr, "Illegal number format %d for tag %04x", Format, Tag);
continue;
}
if((unsigned)Components > 0x10000){
fprintf(stderr, "Illegal number of components %d for tag %04x", Components, Tag);
continue;
}
ByteCount = Components * BytesPerFormat[Format];
if (ByteCount > 4){
unsigned OffsetVal;
OffsetVal = Get32u(DirEntry+8);
// If its bigger than 4 bytes, the dir entry contains an offset.
if (OffsetVal+ByteCount > ExifLength){
// Bogus pointer offset and / or bytecount value
fprintf(stderr, "Illegal value pointer for tag %04x", Tag);
continue;
}
ValuePtr = OffsetBase+OffsetVal;
}else{
// 4 bytes or less and value is in the dir entry itself
ValuePtr = DirEntry+8;
}
if( (Tag == 1) && (Components > 16) ){
int IsoCode = Get16u(ValuePtr + 16*sizeof(unsigned short));
if( (IsoCode >= 16) && (IsoCode <= 24) )
ImageInfo.ISOequivalent = 50 << (IsoCode-16);
}
if( (Tag == 4) && (Format == FMT_USHORT) ){
if(Components > 7){
int WhiteBalance = Get16u(ValuePtr + 7*sizeof(unsigned short));
switch(WhiteBalance){
// 0=Auto, 6=Custom
case 1: ImageInfo.LightSource = 1; break; // Sunny
case 2: ImageInfo.LightSource = 1; break; // Cloudy
case 3: ImageInfo.LightSource = 3; break; // Thungsten
case 4: ImageInfo.LightSource = 2; break; // Fourescent
case 5: ImageInfo.LightSource = 4; break; // Flash
}
}
if( (Components > 19) && (ImageInfo.Distance <= 0) ){
// Indicates the distance the autofocus camera is focused to.
// Tends to be less accurate as distance increases.
int temp_dist = Get16u(ValuePtr + 19*sizeof(unsigned short));
ImageInfo.Distance = (temp_dist != 65535)? (float)temp_dist/100 : -1;
}
}
}
}
// Process maker note - to the limited extent that its supported.
void ProcessMakerNote(unsigned char * ValuePtr, unsigned char * OffsetBase, unsigned ExifLength){
if(strstr(ImageInfo.CameraMake, "Canon"))
ProcessCanonMakerNoteDir(ValuePtr, OffsetBase, ExifLength);
}
/*
Process a SOFn marker. This is useful for the image dimensions
JPEG image is data[7] color components, data[2] bits per sample
*/
void process_SOFn(const uchar *data, int marker){
//data[2] contains the data precision value
ImageInfo.Height = Get16m(data+3);
ImageInfo.Width = Get16m(data+5);
int num_components = data[7];
ImageInfo.IsColor = (num_components == 3);
ImageInfo.Process = marker;
}
/*
Process a EXIF marker.
Describes all the drivel that most digital cameras include...
*/
bool process_EXIF(uchar *ExifSection, uint length){
FocalplaneXRes = 0;
FocalplaneUnits = 0;
ExifImageWidth = 0;
NumOrientations = 0;
// Check the EXIF header component
static char *ExifHeader = "Exif\0\0";
if(memcmp(ExifSection+2, ExifHeader,6)){
fprintf(stderr, "Incorrect Exif header");
return false;
}
if(memcmp(ExifSection+8,"II",2) == 0) motorolaOrder = false; //Exif section in Intel order
else if(memcmp(ExifSection+8,"MM",2) == 0) motorolaOrder = true; //Exif section in Motorola order
else{
fprintf(stderr, "Invalid Exif alignment marker");
return false;
}
// Check the next value for correctness
if(Get16u(ExifSection+10) != 0x2a){
fprintf(stderr, "Invalid Exif start (1)");
return false;
}
const uint FirstOffset = Get32u(ExifSection+12);
if(FirstOffset < 8 || FirstOffset > 16){
// Usually set to 8, but other values valid too
fprintf(stderr, "Suspicious offset of first IFD value");
return false;
}
DirWithThumbnailPtrs = NULL;
// First directory starts 16 bytes in. All offset are relative to 8 bytes in.
if( !ProcessExifDir(ExifSection+8+FirstOffset, ExifSection+8, length-8, 0) ) return false;
ImageInfo.ThumbnailAtEnd = (ImageInfo.ThumbnailOffset >= ImageInfo.LargestExifOffset);
return true;
}
// Process one of the nested EXIF directories.
bool ProcessExifDir(uchar *DirStart, uchar *OffsetBase, unsigned ExifLength, int NestingLevel){
int NumDirEntries;
unsigned ThumbnailOffset = 0;
unsigned ThumbnailSize = 0;
char IndentString[25];
if(NestingLevel > 4){
fprintf(stderr, "Maximum directory nesting exceeded (corrupt exif header)");
return false;
}
memset(IndentString, ' ', 25);
IndentString[NestingLevel * 4] = '\0';
NumDirEntries = Get16u(DirStart);
#define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
uchar *DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
if(DirEnd+4 > (OffsetBase+ExifLength)){
if(DirEnd+2 == OffsetBase+ExifLength || DirEnd == OffsetBase+ExifLength){
// Version 1.3 of jhead would truncate a bit too much.
// This also caught later on as well.
}else{
fprintf(stderr, "Illegally sized exif subdirectory (%d entries)", NumDirEntries);
return false;
}
}
for(int de=0 ; de<NumDirEntries ; de++){
int Tag, Format, Components;
uchar *DirEntry;
DirEntry = DIR_ENTRY_ADDR(DirStart, de);
Tag = Get16u(DirEntry);
Format = Get16u(DirEntry+2);
Components = Get32u(DirEntry+4);
if((Format-1) >= NUM_FORMATS){
// (-1) catches illegal zero case as unsigned underflows to positive large.
fprintf(stderr, "Illegal number format %d for tag %04x", Format, Tag);
continue;
}
if ((unsigned)Components > 0x10000){
fprintf(stderr, "Illegal number of components %d for tag %04x", Components, Tag);
continue;
}
int ByteCount = Components * BytesPerFormat[Format];
uchar *ValuePtr;
if(ByteCount > 4){
unsigned OffsetVal;
OffsetVal = Get32u(DirEntry+8);
// If its bigger than 4 bytes, the dir entry contains an offset.
if(OffsetVal+ByteCount > ExifLength){
// Bogus pointer offset and / or bytecount value
fprintf(stderr, "Illegal value pointer for tag %04x", Tag,0);
continue;
}
ValuePtr = OffsetBase+OffsetVal;
if(OffsetVal > ImageInfo.LargestExifOffset) ImageInfo.LargestExifOffset = OffsetVal;
}else{
// 4 bytes or less and value is in the dir entry itself
ValuePtr = DirEntry+8;
}
if(Tag == TAG_MAKER_NOTE){
ProcessMakerNote(ValuePtr, OffsetBase, ExifLength);
continue;
}
// Extract useful components of tag
switch(Tag){
case TAG_MAKE:
strncpy(ImageInfo.CameraMake, (char*)ValuePtr, ByteCount < 31 ? ByteCount : 31);
break;
case TAG_MODEL:
strncpy(ImageInfo.CameraModel, (char*)ValuePtr, ByteCount < 39 ? ByteCount : 39);
break;
case TAG_DATETIME_ORIGINAL:
// If we get a DATETIME_ORIGINAL, we use that one.
strncpy(ImageInfo.DateTime, (char*)ValuePtr, 19);
// Fallthru...
case TAG_DATETIME_DIGITIZED:
case TAG_DATETIME:
// If we don't already have a DATETIME_ORIGINAL, use whatever time fields we may have.
if(!isdigit(ImageInfo.DateTime[0])) strncpy(ImageInfo.DateTime, (char*)ValuePtr, 19);
if(ImageInfo.numDateTimeTags >= MAX_DATE_COPIES)
fprintf(stderr, "More than %d date fields! This is nuts", MAX_DATE_COPIES, 0);
else
ImageInfo.DateTimeOffsets[ImageInfo.numDateTimeTags++] = (char*)ValuePtr - (char*)OffsetBase;
break;
case TAG_WINXP_COMMENT:
// We already have a jpeg comment (probably windows comment), skip this one.
if(ImageInfo.Comments[0]) break;
if(ByteCount > 1){
if(ByteCount > MAX_COMMENT_SIZE) ByteCount = MAX_COMMENT_SIZE;
memcpy(ImageInfo.Comments, ValuePtr, ByteCount);
ImageInfo.CommentWidchars = ByteCount/2;
}
break;
case TAG_USERCOMMENT:{
// We already have a jpeg comment (probably windows comment), skip this one.
if(ImageInfo.Comments[0]) break;
// Comment is often padded with trailing spaces. Remove these first.
int a = ByteCount-1;
while( a && ((ValuePtr)[a]==' ') ) (ValuePtr)[a--] = '\0';
// Copy the comment
if(memcmp(ValuePtr, "ASCII",5) == 0){
for(a=5 ; a<10 ; a++){
uchar c = (ValuePtr)[a];
if( (c!='\0') && (c!=' ') ){
strncpy(ImageInfo.Comments, (char *)ValuePtr+a, 199);
break;
}
}
}else{
strncpy(ImageInfo.Comments, (char *)ValuePtr, MAX_COMMENT_SIZE-1);
}
break;
}
case TAG_FNUMBER:
// Simplest way of expressing aperture, so I trust it the most.
// (overwrite previously computd value if there is one)
ImageInfo.ApertureFNumber = T(ConvertAnyFormat(ValuePtr, Format));
break;
case TAG_APERTURE:
case TAG_MAXAPERTURE:
// More relevant info always comes earlier, so only use this field if we don't
// have appropriate aperture information yet.
if(ImageInfo.ApertureFNumber == 0)
ImageInfo.ApertureFNumber = T(exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)*0.5));
break;
case TAG_FOCALLENGTH:
// Nice digital cameras actually save the focal length as a function
// of how farthey are zoomed in.
ImageInfo.FocalLength = T(ConvertAnyFormat(ValuePtr, Format));
break;
case TAG_SUBJECT_DISTANCE:
// Inidcates the distacne the autofocus camera is focused to.
// Tends to be less accurate as distance increases.
ImageInfo.Distance = T(ConvertAnyFormat(ValuePtr, Format));
break;
case TAG_EXPOSURETIME:
// Simplest way of expressing exposure time, so I trust it most.
// (overwrite previously computd value if there is one)
ImageInfo.ExposureTime = T(ConvertAnyFormat(ValuePtr, Format));
break;
case TAG_SHUTTERSPEED:
// More complicated way of expressing exposure time, so only use
// this value if we don't already have it from somewhere else.
if(ImageInfo.ExposureTime == 0)
ImageInfo.ExposureTime = T(1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)));
break;
case TAG_FLASH:
ImageInfo.FlashUsed=(int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_ORIENTATION:
if(NumOrientations >= 2){
// Can have another orientation tag for the thumbnail, but if there's a third one, things are stringae.
fprintf(stderr, "More than two orientation tags!");
break;
}
OrientationPtr[NumOrientations] = ValuePtr;
OrientationNumFormat[NumOrientations] = Format;
if(NumOrientations == 0)
ImageInfo.Orientation = (int)ConvertAnyFormat(ValuePtr, Format);
if(ImageInfo.Orientation < 0 || ImageInfo.Orientation > 8){
fprintf(stderr, "Undefined rotation value %d", ImageInfo.Orientation);
ImageInfo.Orientation = 0;
}
NumOrientations += 1;
break;
case TAG_EXIF_IMAGELENGTH:
case TAG_EXIF_IMAGEWIDTH:{
// Use largest of height and width to deal with images that have been
// rotated to portrait format.
int a = (int)ConvertAnyFormat(ValuePtr, Format);
if (ExifImageWidth < a) ExifImageWidth = a;
break;
}
case TAG_FOCAL_PLANE_XRES:
FocalplaneXRes = ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_FOCAL_PLANE_UNITS:
switch((int)ConvertAnyFormat(ValuePtr, Format)){
case 1: FocalplaneUnits = 25.4; break; // inch
case 2:
// According to the information I was using, 2 means meters.
// But looking at the Cannon powershot's files, inches is the only
// sensible value.
FocalplaneUnits = 25.4;
break;
case 3: FocalplaneUnits = 10; break; // centimeter
case 4: FocalplaneUnits = 1; break; // millimeter
case 5: FocalplaneUnits = .001; break; // micrometer
}
break;
case TAG_EXPOSURE_BIAS:
ImageInfo.ExposureBias = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_WHITEBALANCE:
ImageInfo.Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_LIGHT_SOURCE:
ImageInfo.LightSource = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_METERING_MODE:
ImageInfo.MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_PROGRAM:
ImageInfo.ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_INDEX:
if(ImageInfo.ISOequivalent == 0){
// Exposure index and ISO equivalent are often used interchangeably,
// so we will do the same in jhead.
// http://photography.about.com/library/glossary/bldef_ei.htm
ImageInfo.ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
}
break;
case TAG_EXPOSURE_MODE:
ImageInfo.ExposureMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_ISO_EQUIVALENT:
ImageInfo.ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
// Fixes strange encoding on some older digicams.
if( ImageInfo.ISOequivalent < 50 ) ImageInfo.ISOequivalent *= 200;
break;
case TAG_DIGITALZOOMRATIO:
ImageInfo.DigitalZoomRatio = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_THUMBNAIL_OFFSET:
ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
DirWithThumbnailPtrs = DirStart;
break;
case TAG_THUMBNAIL_LENGTH:
ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
ImageInfo.ThumbnailSizeOffset = ValuePtr-OffsetBase;
break;
case TAG_EXIF_OFFSET:
case TAG_INTEROP_OFFSET:{
uchar *SubdirStart = OffsetBase + Get32u(ValuePtr);
if(SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
fprintf(stderr, "Illegal exif or interop offset directory link");
else
ProcessExifDir(SubdirStart, OffsetBase, ExifLength, NestingLevel+1);
break;
}
case TAG_GPSINFO:{
uchar *SubdirStart = OffsetBase + Get32u(ValuePtr);
if(SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
fprintf(stderr, "Illegal GPS directory link");
else
;//ProcessGpsInfo(SubdirStart, ByteCount, OffsetBase, ExifLength);
break;
}
case TAG_FOCALLENGTH_35MM:
// The focal length equivalent 35 mm is a 2.2 tag (defined as of April 2002)
// if its present, use it to compute equivalent focal length instead of
// computing it from sensor geometry and actual focal length.
ImageInfo.FocalLength35mmEquiv = (unsigned)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_DISTANCE_RANGE:
// Three possible standard values:
// 1 = macro, 2 = close, 3 = distant
ImageInfo.DistanceRange = (int)ConvertAnyFormat(ValuePtr, Format);
break;
}
}
// In addition to linking to subdirectories via exif tags,
// there's also a potential link to another directory at the end of each
// directory. this has got to be the result of a committee!
unsigned char * SubdirStart;
unsigned Offset;
if(DIR_ENTRY_ADDR(DirStart, NumDirEntries) + 4 <= OffsetBase+ExifLength){
Offset = Get32u(DirStart+2+12*NumDirEntries);
if (Offset){
SubdirStart = OffsetBase + Offset;
if(SubdirStart > OffsetBase+ExifLength || SubdirStart < OffsetBase){
if (SubdirStart > OffsetBase && SubdirStart < OffsetBase+ExifLength+20){
// Jhead 1.3 or earlier would crop the whole directory!
// As Jhead produces this form of format incorrectness,
// I'll just let it pass silently
}else{
fprintf(stderr, "Illegal subdirectory link");
}
}else{
if(SubdirStart <= OffsetBase+ExifLength)
ProcessExifDir(SubdirStart, OffsetBase, ExifLength, NestingLevel+1);
}
if(Offset > ImageInfo.LargestExifOffset){
ImageInfo.LargestExifOffset = Offset;
}
}
}else{
// The exif header ends before the last next directory pointer.
}
if(ThumbnailOffset){
ImageInfo.ThumbnailAtEnd = false;
if(ThumbnailOffset <= ExifLength){
if(ThumbnailSize > ExifLength-ThumbnailOffset){
// If thumbnail extends past exif header, only save the part that
// actually exists. Canon's EOS viewer utility will do this - the
// thumbnail extracts ok with this hack.
ThumbnailSize = ExifLength-ThumbnailOffset;
}
// The thumbnail pointer appears to be valid. Store it.
ImageInfo.ThumbnailOffset = ThumbnailOffset;
ImageInfo.ThumbnailSize = ThumbnailSize;
}
}
}
};
#endif
Reference in New Issue View Git Blame Copy Permalink