manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removed external lib "Exif"

This commit is contained in:
Paolo Cignoni 2012-04-04 10:47:27 +00:00
parent 5aed57a364
commit 2e924c6c24
12 changed files with 0 additions and 6053 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
wrap/Exif/Readme.txt
View File

@ -1,13 +0,0 @@
How to read exif metadata from a jpg file.
= = = = = = = = = = = = = = = = = = = = =
1- In your .pro file, define the EXIF_DIR variable which locates the Exif directory in your system, and include the exif.pri file
e.g.
EXIF_DIR = ./yourSandboxPath/Exif
include($$EXIF_DIR/exif.pri)
2- In your source file (where you need the exif reader), add:
#include "jhead.h"
Then, invoke:
::ProcessFile(filename);
and get the available exif information from the "ImageInfo" global variable of type ImageInfo_t, defined in jhead.h.

16
wrap/Exif/exif.pri
View File

@ -1,16 +0,0 @@
#Please define the EXIF_DIR variable which locates the glUtils directory in your system.
#eg. EXIF_DIR = ../vcglib/wrap/Exif
!contains(DEFINES, EXIF_DIR){
DEFINES += EXIF_DIR
INCLUDEPATH += $$EXIF_DIR/include
SOURCES += $$EXIF_DIR/src/exif.cpp
SOURCES += $$EXIF_DIR/src/gpsinfo.cpp
SOURCES += $$EXIF_DIR/src/iptc.cpp
SOURCES += $$EXIF_DIR/src/jhead.cpp
SOURCES += $$EXIF_DIR/src/jpgfile.cpp
SOURCES += $$EXIF_DIR/src/makernote.cpp
win32:SOURCES += $$EXIF_DIR/src/myglob.cpp
SOURCES += $$EXIF_DIR/src/paths.cpp
}

915
wrap/Exif/include/Exif/exif.h
View File

@ -1,915 +0,0 @@
#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

244
wrap/Exif/include/Exif/jhead.h
View File

@ -1,244 +0,0 @@
//--------------------------------------------------------------------------
// Include file for jhead program.
//
// This include file only defines stuff that goes across modules.
// I like to keep the definitions for macros and structures as close to
// where they get used as possible, so include files only get stuff that
// gets used in more than one file.
//--------------------------------------------------------------------------
#define _CRT_SECURE_NO_DEPRECATE 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ctype.h>
//--------------------------------------------------------------------------
#ifdef _WIN32
#include <sys/utime.h>
#else
#include <utime.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#endif
typedef unsigned char uchar;
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
#define MAX_COMMENT_SIZE 2000
#ifdef _WIN32
#define PATH_MAX _MAX_PATH
#define SLASH '\\'
#else
#define SLASH '/'
#endif
//--------------------------------------------------------------------------
// This structure is used to store jpeg file sections in memory.
typedef struct {
uchar * Data;
int Type;
unsigned Size;
}Section_t;
extern int ExifSectionIndex;
extern int DumpExifMap;
#define MAX_DATE_COPIES 10
//--------------------------------------------------------------------------
// 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;
double FocalplaneXRes;
double FocalplaneUnits;
int ExifImageWidth;
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;
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
// jpgfile.c functions
//typedef
enum {
READ_METADATA = 1,
READ_IMAGE = 2,
READ_ALL = 3
};//ReadMode_t;
typedef int ReadMode_t;
// prototypes for jhead.c functions
void ErrFatal(const char * msg);
void ErrNonfatal(const char * msg, int a1, int a2);
void FileTimeAsString(char * TimeStr);
void ProcessFile(const char * FileName);
// Prototypes for exif.c functions.
int Exif2tm(struct tm * timeptr, char * ExifTime);
void process_EXIF (unsigned char * CharBuf, unsigned int length);
int RemoveThumbnail(unsigned char * ExifSection);
void ShowImageInfo(int ShowFileInfo);
void ShowConciseImageInfo(void);
const char * ClearOrientation(void);
void PrintFormatNumber(void * ValuePtr, int Format, int ByteCount);
double ConvertAnyFormat(void * ValuePtr, int Format);
int Get16u(void * Short);
unsigned Get32u(void * Long);
int Get32s(void * Long);
void Put32u(void * Value, unsigned PutValue);
void create_EXIF(void);
//--------------------------------------------------------------------------
// Exif format descriptor stuff
extern 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
// makernote.c prototypes
extern void ProcessMakerNote(unsigned char * DirStart, int ByteCount,
unsigned char * OffsetBase, unsigned ExifLength);
// gpsinfo.c prototypes
void ProcessGpsInfo(unsigned char * ValuePtr, int ByteCount,
unsigned char * OffsetBase, unsigned ExifLength);
// iptc.c prototpyes
void show_IPTC (unsigned char * CharBuf, unsigned int length);
void ShowXmp(Section_t XmpSection);
// Prototypes for myglob.c module
#ifdef _WIN32
void MyGlob(const char * Pattern , void (*FileFuncParm)(const char * FileName));
void SlashToNative(char * Path);
#endif
// Prototypes for paths.c module
int EnsurePathExists(const char * FileName);
void CatPath(char * BasePath, const char * FilePath);
// Prototypes from jpgfile.c
int ReadJpegSections (FILE * infile, ReadMode_t ReadMode);
void DiscardData(void);
void DiscardAllButExif(void);
int ReadJpegFile(const char * FileName, ReadMode_t ReadMode);
int ReplaceThumbnail(const char * ThumbFileName);
int SaveThumbnail(char * ThumbFileName);
int RemoveSectionType(int SectionType);
int RemoveUnknownSections(void);
void WriteJpegFile(const char * FileName);
Section_t * FindSection(int SectionType);
Section_t * CreateSection(int SectionType, unsigned char * Data, int size);
void ResetJpgfile(void);
// Variables from jhead.c used by exif.c
extern ImageInfo_t ImageInfo;
extern int ShowTags;
//--------------------------------------------------------------------------
// 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. (See jdmarker.c for a more complete list.)
//--------------------------------------------------------------------------
#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

1586
wrap/Exif/src/exif.cpp
View File

File diff suppressed because it is too large Load Diff

217
wrap/Exif/src/gpsinfo.cpp
View File

@ -1,217 +0,0 @@
//--------------------------------------------------------------------------
// Parsing of GPS info from exif header.
//
// Matthias Wandel, Dec 1999 - Dec 2002
//--------------------------------------------------------------------------
#include "../include/Exif/jhead.h"
#define MAX_GPS_TAG 0x1e
#define TAG_GPS_LAT_REF 1
#define TAG_GPS_LAT 2
#define TAG_GPS_LONG_REF 3
#define TAG_GPS_LONG 4
#define TAG_GPS_ALT_REF 5
#define TAG_GPS_ALT 6
static const char * GpsTags[MAX_GPS_TAG+1]= {
"VersionID ",//0x00
"LatitudeRef ",//0x01
"Latitude ",//0x02
"LongitudeRef ",//0x03
"Longitude ",//0x04
"AltitudeRef ",//0x05
"Altitude ",//0x06
"TimeStamp ",//0x07
"Satellites ",//0x08
"Status ",//0x09
"MeasureMode ",//0x0A
"DOP ",//0x0B
"SpeedRef ",//0x0C
"Speed ",//0x0D
"TrackRef ",//0x0E
"Track ",//0x0F
"ImgDirectionRef ",//0x10
"ImgDirection ",//0x11
"MapDatum ",//0x12
"DestLatitudeRef ",//0x13
"DestLatitude ",//0x14
"DestLongitudeRef",//0x15
"DestLongitude ",//0x16
"DestBearingRef ",//0x17
"DestBearing ",//0x18
"DestDistanceRef ",//0x19
"DestDistance ",//0x1A
"ProcessingMethod",//0x1B
"AreaInformation ",//0x1C
"DateStamp ",//0x1D
"Differential ",//0x1E
};
//--------------------------------------------------------------------------
// Process GPS info directory
//--------------------------------------------------------------------------
void ProcessGpsInfo(unsigned char * DirStart, int ByteCountUnused, unsigned char * OffsetBase, unsigned ExifLength)
{
int de;
unsigned a;
int NumDirEntries;
NumDirEntries = Get16u(DirStart);
#define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
if (ShowTags){
printf("(dir has %d entries)\n",NumDirEntries);
}
ImageInfo.GpsInfoPresent = TRUE;
strcpy(ImageInfo.GpsLat, "? ?");
strcpy(ImageInfo.GpsLong, "? ?");
ImageInfo.GpsAlt[0] = 0;
for (de=0;de<NumDirEntries;de++){
unsigned Tag, Format, Components;
unsigned char * ValuePtr;
int ComponentSize;
unsigned ByteCount;
unsigned char * DirEntry;
DirEntry = DIR_ENTRY_ADDR(DirStart, de);
if (DirEntry+12 > OffsetBase+ExifLength){
ErrNonfatal("GPS info directory goes past end of exif",0,0);
return;
}
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.
ErrNonfatal("Illegal number format %d for tag %04x", Format, Tag);
continue;
}
ComponentSize = BytesPerFormat[Format];
ByteCount = Components * ComponentSize;
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
ErrNonfatal("Illegal value pointer for tag %04x", Tag,0);
continue;
}
ValuePtr = OffsetBase+OffsetVal;
}else{
// 4 bytes or less and value is in the dir entry itself
ValuePtr = DirEntry+8;
}
switch(Tag){
char FmtString[21];
char TempString[50];
double Values[3];
case TAG_GPS_LAT_REF:
ImageInfo.GpsLat[0] = ValuePtr[0];
break;
case TAG_GPS_LONG_REF:
ImageInfo.GpsLong[0] = ValuePtr[0];
break;
case TAG_GPS_LAT:
case TAG_GPS_LONG:
if (Format != FMT_URATIONAL){
ErrNonfatal("Inappropriate format (%d) for GPS coordinates!", Format, 0);
}
strcpy(FmtString, "%0.0fd %0.0fm %0.0fs");
for (a=0;a<3;a++){
int den, digits;
den = Get32s(ValuePtr+4+a*ComponentSize);
digits = 0;
while (den > 1 && digits <= 6){
den = den / 10;
digits += 1;
}
if (digits > 6) digits = 6;
FmtString[1+a*7] = (char)('2'+digits+(digits ? 1 : 0));
FmtString[3+a*7] = (char)('0'+digits);
Values[a] = ConvertAnyFormat(ValuePtr+a*ComponentSize, Format);
}
sprintf(TempString, FmtString, Values[0], Values[1], Values[2]);
if (Tag == TAG_GPS_LAT){
strncpy(ImageInfo.GpsLat+2, TempString, 29);
}else{
strncpy(ImageInfo.GpsLong+2, TempString, 29);
}
break;
case TAG_GPS_ALT_REF:
ImageInfo.GpsAlt[0] = (char)(ValuePtr[0] ? '-' : ' ');
break;
case TAG_GPS_ALT:
sprintf(ImageInfo.GpsAlt + 1, "%.2fm",
ConvertAnyFormat(ValuePtr, Format));
break;
}
if (ShowTags){
// Show tag value.
if (Tag < MAX_GPS_TAG){
printf(" GPS%s =", GpsTags[Tag]);
}else{
// Show unknown tag
printf(" Illegal GPS tag %04x=", Tag);
}
switch(Format){
case FMT_UNDEFINED:
// Undefined is typically an ascii string.
case FMT_STRING:
// String arrays printed without function call (different from int arrays)
{
printf("\"");
for (a=0;a<ByteCount;a++){
int ZeroSkipped = 0;
if (ValuePtr[a] >= 32){
if (ZeroSkipped){
printf("?");
ZeroSkipped = 0;
}
putchar(ValuePtr[a]);
}else{
if (ValuePtr[a] == 0){
ZeroSkipped = 1;
}
}
}
printf("\"\n");
}
break;
default:
// Handle arrays of numbers later (will there ever be?)
for (a=0;;){
PrintFormatNumber(ValuePtr+a*ComponentSize, Format, ByteCount);
if (++a >= Components) break;
printf(", ");
}
printf("\n");
}
}
}
}

205
wrap/Exif/src/iptc.cpp
View File

@ -1,205 +0,0 @@
//--------------------------------------------------------------------------
// Process IPTC data and XMP data.
//--------------------------------------------------------------------------
#include "../include/Exif/jhead.h"
// IPTC entry types known to Jhead (there's many more defined)
#define IPTC_RECORD_VERSION 0x00
#define IPTC_SUPLEMENTAL_CATEGORIES 0x14
#define IPTC_KEYWORDS 0x19
#define IPTC_CAPTION 0x78
#define IPTC_AUTHOR 0x7A
#define IPTC_HEADLINE 0x69
#define IPTC_SPECIAL_INSTRUCTIONS 0x28
#define IPTC_CATEGORY 0x0F
#define IPTC_BYLINE 0x50
#define IPTC_BYLINE_TITLE 0x55
#define IPTC_CREDIT 0x6E
#define IPTC_SOURCE 0x73
#define IPTC_COPYRIGHT_NOTICE 0x74
#define IPTC_OBJECT_NAME 0x05
#define IPTC_CITY 0x5A
#define IPTC_STATE 0x5F
#define IPTC_COUNTRY 0x65
#define IPTC_TRANSMISSION_REFERENCE 0x67
#define IPTC_DATE 0x37
#define IPTC_COPYRIGHT 0x0A
#define IPTC_COUNTRY_CODE 0x64
#define IPTC_REFERENCE_SERVICE 0x2D
#define IPTC_TIME_CREATED 0x3C
#define IPTC_SUB_LOCATION 0x5C
#define IPTC_IMAGE_TYPE 0x82
//--------------------------------------------------------------------------
// Process and display IPTC marker.
//
// IPTC block consists of:
// - Marker: 1 byte (0xED)
// - Block length: 2 bytes
// - IPTC Signature: 14 bytes ("Photoshop 3.0\0")
// - 8BIM Signature 4 bytes ("8BIM")
// - IPTC Block start 2 bytes (0x04, 0x04)
// - IPTC Header length 1 byte
// - IPTC header Header is padded to even length, counting the length byte
// - Length 4 bytes
// - IPTC Data which consists of a number of entries, each of which has the following format:
// - Signature 2 bytes (0x1C02)
// - Entry type 1 byte (for defined entry types, see #defines above)
// - entry length 2 bytes
// - entry data 'entry length' bytes
//
//--------------------------------------------------------------------------
void show_IPTC (unsigned char* Data, unsigned int itemlen)
{
const char IptcSig1[] = "Photoshop 3.0";
const char IptcSig2[] = "8BIM";
const char IptcSig3[] = {0x04, 0x04};
unsigned char * pos = Data + sizeof(short); // position data pointer after length field
unsigned char * maxpos = Data+itemlen;
char headerLen = 0;
if (itemlen < 25) goto corrupt;
// Check IPTC signatures
if (memcmp(pos, IptcSig1, sizeof(IptcSig1)-1) != 0) goto badsig;
pos += sizeof(IptcSig1); // move data pointer to the next field
if (memcmp(pos, IptcSig2, sizeof(IptcSig2)-1) != 0) goto badsig;
pos += sizeof(IptcSig2)-1; // move data pointer to the next field
if (memcmp(pos, IptcSig3, sizeof(IptcSig3)) != 0){
badsig:
if (ShowTags){
ErrNonfatal("IPTC type signature mismatch\n",0,0);
}
return;
}
pos += sizeof(IptcSig3); // move data pointer to the next field
if (pos >= maxpos) goto corrupt;
// IPTC section found
// Skip header
headerLen = *pos++; // get header length and move data pointer to the next field
pos += headerLen + 1 - (headerLen % 2); // move data pointer to the next field (Header is padded to even length, counting the length byte)
if (pos+4 >= maxpos) goto corrupt;
// Get length (from motorola format)
//length = (*pos << 24) | (*(pos+1) << 16) | (*(pos+2) << 8) | *(pos+3);
pos += 4; // move data pointer to the next field
printf("======= IPTC data: =======\n");
// Now read IPTC data
while (pos < (Data + itemlen-5)) {
short signature;
unsigned char type = 0;
short length = 0;
char * description = NULL;
if (pos+5 > maxpos) goto corrupt;
signature = (*pos << 8) + (*(pos+1));
pos += 2;
if (signature != 0x1C02){
break;
}
type = *pos++;
length = (*pos << 8) + (*(pos+1));
pos += 2; // Skip tag length
if (pos+length > maxpos) goto corrupt;
// Process tag here
switch (type) {
case IPTC_RECORD_VERSION:
printf("Record vers. : %d\n", (*pos << 8) + (*(pos+1)));
break;
case IPTC_SUPLEMENTAL_CATEGORIES: description = (char*)"SuplementalCategories"; break;
case IPTC_KEYWORDS: description = (char*)"Keywords"; break;
case IPTC_CAPTION: description = (char*)"Caption"; break;
case IPTC_AUTHOR: description = (char*)"Author"; break;
case IPTC_HEADLINE: description = (char*)"Headline"; break;
case IPTC_SPECIAL_INSTRUCTIONS: description = (char*)"Spec. Instr."; break;
case IPTC_CATEGORY: description = (char*)"Category"; break;
case IPTC_BYLINE: description = (char*)"Byline"; break;
case IPTC_BYLINE_TITLE: description = (char*)"Byline Title"; break;
case IPTC_CREDIT: description = (char*)"Credit"; break;
case IPTC_SOURCE: description = (char*)"Source"; break;
case IPTC_COPYRIGHT_NOTICE: description = (char*)"(C)Notice"; break;
case IPTC_OBJECT_NAME: description = (char*)"Object Name"; break;
case IPTC_CITY: description = (char*)"City"; break;
case IPTC_STATE: description = (char*)"State"; break;
case IPTC_COUNTRY: description = (char*)"Country"; break;
case IPTC_TRANSMISSION_REFERENCE: description = (char*)"OriginalTransmissionReference"; break;
case IPTC_DATE: description = (char*)"DateCreated"; break;
case IPTC_COPYRIGHT: description = (char*)"(C)Flag"; break;
case IPTC_REFERENCE_SERVICE: description = (char*)"Country Code"; break;
case IPTC_COUNTRY_CODE: description = (char*)"Ref. Service"; break;
case IPTC_TIME_CREATED: description = (char*)"Time Created"; break;
case IPTC_SUB_LOCATION: description = (char*)"Sub Location"; break;
case IPTC_IMAGE_TYPE: description = (char*)"Image type"; break;
default:
if (ShowTags){
printf("Unrecognised IPTC tag: %d\n", type );
}
break;
}
if (description != NULL) {
char TempBuf[32];
memset(TempBuf, 0, sizeof(TempBuf));
memset(TempBuf, ' ', 14);
memcpy(TempBuf, description, strlen(description));
strcat(TempBuf, ":");
printf("%s %*.*s\n", TempBuf, length, length, pos);
}
pos += length;
}
return;
corrupt:
ErrNonfatal("Pointer corruption in IPTC\n",0,0);
}
//--------------------------------------------------------------------------
// Dump contents of XMP section
//--------------------------------------------------------------------------
void ShowXmp(Section_t XmpSection)
{
unsigned char * Data;
char OutLine[101];
int OutLineChars;
int NonBlank;
unsigned a;
NonBlank = 0;
Data = XmpSection.Data;
OutLineChars = 0;
for (a=0;a<XmpSection.Size;a++){
if (Data[a] >= 32 && Data[a] < 128){
OutLine[OutLineChars++] = Data[a];
if (Data[a] != ' ') NonBlank |= 1;
}else{
if (Data[a] != '\n'){
OutLine[OutLineChars++] = '?';
}
}
if (Data[a] == '\n' || OutLineChars >= 100){
OutLine[OutLineChars] = 0;
if (NonBlank){
puts(OutLine);
}
NonBlank = (NonBlank & 1) << 1;
OutLineChars = 0;
}
}
}

1558
wrap/Exif/src/jhead.cpp
View File

File diff suppressed because it is too large Load Diff

669
wrap/Exif/src/jpgfile.cpp
View File

@ -1,669 +0,0 @@
//--------------------------------------------------------------------------
// Program to pull the information out of various types of EXIF digital
// camera files and show it in a reasonably consistent way
//
// This module handles basic Jpeg file handling
//
// Matthias Wandel
//--------------------------------------------------------------------------
#include "../include/Exif/jhead.h"
// Storage for simplified info extracted from file.
ImageInfo_t ImageInfo;
static Section_t * Sections = NULL;
static int SectionsAllocated;
static int SectionsRead;
static int HaveAll;
#define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
//--------------------------------------------------------------------------
// Get 16 bits motorola order (always) for jpeg header stuff.
//--------------------------------------------------------------------------
static int Get16m(const void * Short)
{
return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
}
//--------------------------------------------------------------------------
// Process a COM marker.
// We want to print out the marker contents as legible text;
// we must guard against random junk and varying newline representations.
//--------------------------------------------------------------------------
static void process_COM (const uchar * Data, int length)
{
int ch;
char Comment[MAX_COMMENT_SIZE+1];
int nch;
int a;
nch = 0;
if (length > MAX_COMMENT_SIZE) length = MAX_COMMENT_SIZE; // Truncate if it won't fit in our structure.
for (a=2;a<length;a++){
ch = Data[a];
if (ch == '\r' && Data[a+1] == '\n') continue; // Remove cr followed by lf.
if (ch >= 32 || ch == '\n' || ch == '\t'){
Comment[nch++] = (char)ch;
}else{
Comment[nch++] = '?';
}
}
Comment[nch] = '\0'; // Null terminate
if (ShowTags){
printf("COM marker comment: %s\n",Comment);
}
strcpy(ImageInfo.Comments,Comment);
ImageInfo.CommentWidchars = 0;
}
//--------------------------------------------------------------------------
// Process a SOFn marker. This is useful for the image dimensions
//--------------------------------------------------------------------------
static void process_SOFn (const uchar * Data, int marker)
{
int data_precision, num_components;
data_precision = Data[2];
ImageInfo.Height = Get16m(Data+3);
ImageInfo.Width = Get16m(Data+5);
num_components = Data[7];
if (num_components == 3){
ImageInfo.IsColor = 1;
}else{
ImageInfo.IsColor = 0;
}
ImageInfo.Process = marker;
if (ShowTags){
printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
ImageInfo.Width, ImageInfo.Height, num_components, data_precision);
}
}
//--------------------------------------------------------------------------
// Check sections array to see if it needs to be increased in size.
//--------------------------------------------------------------------------
void CheckSectionsAllocated(void)
{
if (SectionsRead > SectionsAllocated){
ErrFatal("allocation screwup");
}
if (SectionsRead >= SectionsAllocated){
SectionsAllocated += SectionsAllocated/2;
Sections = (Section_t *)realloc(Sections, sizeof(Section_t)*SectionsAllocated);
if (Sections == NULL){
ErrFatal("could not allocate data for entire image");
}
}
}
//--------------------------------------------------------------------------
// Parse the marker stream until SOS or EOI is seen;
//--------------------------------------------------------------------------
int ReadJpegSections (FILE * infile, ReadMode_t ReadMode)
{
int a;
int HaveCom = FALSE;
a = fgetc(infile);
if (a != 0xff || fgetc(infile) != M_SOI){
return FALSE;
}
for(;;){
int itemlen;
int marker = 0;
int ll,lh, got;
uchar * Data;
CheckSectionsAllocated();
for (a=0;a<=16;a++){
marker = fgetc(infile);
if (marker != 0xff) break;
if (a >= 16){
fprintf(stderr,"too many padding bytes\n");
return FALSE;
}
}
Sections[SectionsRead].Type = marker;
// Read the length of the section.
lh = fgetc(infile);
ll = fgetc(infile);
itemlen = (lh << 8) | ll;
if (itemlen < 2){
ErrFatal("invalid marker");
}
Sections[SectionsRead].Size = itemlen;
Data = (uchar *)malloc(itemlen);
if (Data == NULL){
ErrFatal("Could not allocate memory");
}
Sections[SectionsRead].Data = Data;
// Store first two pre-read bytes.
Data[0] = (uchar)lh;
Data[1] = (uchar)ll;
got = fread(Data+2, 1, itemlen-2, infile); // Read the whole section.
if (got != itemlen-2){
ErrFatal("Premature end of file?");
}
SectionsRead += 1;
switch(marker){
case M_SOS: // stop before hitting compressed data
// If reading entire image is requested, read the rest of the data.
if (ReadMode & READ_IMAGE){
int cp, ep, size;
// Determine how much file is left.
cp = ftell(infile);
fseek(infile, 0, SEEK_END);
ep = ftell(infile);
fseek(infile, cp, SEEK_SET);
size = ep-cp;
Data = (uchar *)malloc(size);
if (Data == NULL){
ErrFatal("could not allocate data for entire image");
}
got = fread(Data, 1, size, infile);
if (got != size){
ErrFatal("could not read the rest of the image");
}
CheckSectionsAllocated();
Sections[SectionsRead].Data = Data;
Sections[SectionsRead].Size = size;
Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
SectionsRead ++;
HaveAll = 1;
}
return TRUE;
case M_EOI: // in case it's a tables-only JPEG stream
fprintf(stderr,"No image in jpeg!\n");
return FALSE;
case M_COM: // Comment section
if (HaveCom || ((ReadMode & READ_METADATA) == 0)){
// Discard this section.
free(Sections[--SectionsRead].Data);
}else{
process_COM(Data, itemlen);
HaveCom = TRUE;
}
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(Sections[--SectionsRead].Data);
break;
case M_EXIF:
// There can be different section using the same marker.
if (ReadMode & READ_METADATA){
if (memcmp(Data+2, "Exif", 4) == 0){
process_EXIF(Data, itemlen);
break;
}else if (memcmp(Data+2, "http:", 5) == 0){
Sections[SectionsRead-1].Type = M_XMP; // Change tag for internal purposes.
if (ShowTags){
printf("Image cotains XMP section, %d bytes long\n", itemlen);
if (ShowTags){
ShowXmp(Sections[SectionsRead-1]);
}
}
break;
}
}
// Oterwise, discard this section.
free(Sections[--SectionsRead].Data);
break;
case M_IPTC:
if (ReadMode & READ_METADATA){
if (ShowTags){
printf("Image cotains IPTC section, %d bytes long\n", itemlen);
}
// Note: We just store the IPTC section. Its relatively straightforward
// and we don't act on any part of it, so just display it at parse time.
}else{
free(Sections[--SectionsRead].Data);
}
break;
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(Data, marker);
break;
default:
// Skip any other sections.
if (ShowTags){
printf("Jpeg section marker 0x%02x size %d\n",marker, itemlen);
}
break;
}
}
return TRUE;
}
//--------------------------------------------------------------------------
// Discard read data.
//--------------------------------------------------------------------------
void DiscardData(void)
{
int a;
for (a=0;a<SectionsRead;a++){
free(Sections[a].Data);
}
memset(&ImageInfo, 0, sizeof(ImageInfo));
SectionsRead = 0;
HaveAll = 0;
}
//--------------------------------------------------------------------------
// Read image data.
//--------------------------------------------------------------------------
int ReadJpegFile(const char * FileName, ReadMode_t ReadMode)
{
FILE * infile;
int ret;
infile = fopen(FileName, "rb"); // Unix ignores 'b', windows needs it.
if (infile == NULL) {
fprintf(stderr, "can't open '%s'\n", FileName);
return FALSE;
}
// Scan the JPEG headers.
ret = ReadJpegSections(infile, ReadMode);
if (!ret){
fprintf(stderr,"Not JPEG: %s\n",FileName);
}
fclose(infile);
if (ret == FALSE){
DiscardData();
}
return ret;
}
//--------------------------------------------------------------------------
// Replace or remove exif thumbnail
//--------------------------------------------------------------------------
int SaveThumbnail(char * ThumbFileName)
{
FILE * ThumbnailFile;
if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailSize == 0){
fprintf(stderr,"Image contains no thumbnail\n");
return FALSE;
}
if (strcmp(ThumbFileName, "-") == 0){
// A filename of '-' indicates thumbnail goes to stdout.
// This doesn't make much sense under Windows, so this feature is unix only.
ThumbnailFile = stdout;
}else{
ThumbnailFile = fopen(ThumbFileName,"wb");
}
if (ThumbnailFile){
uchar * ThumbnailPointer;
Section_t * ExifSection;
ExifSection = FindSection(M_EXIF);
ThumbnailPointer = ExifSection->Data+ImageInfo.ThumbnailOffset+8;
fwrite(ThumbnailPointer, ImageInfo.ThumbnailSize ,1, ThumbnailFile);
fclose(ThumbnailFile);
return TRUE;
}else{
ErrFatal("Could not write thumbnail file");
return FALSE;
}
}
//--------------------------------------------------------------------------
// Replace or remove exif thumbnail
//--------------------------------------------------------------------------
int ReplaceThumbnail(const char * ThumbFileName)
{
FILE * ThumbnailFile;
int ThumbLen, NewExifSize;
Section_t * ExifSection;
uchar * ThumbnailPointer;
if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailAtEnd == FALSE){
if (ThumbFileName == NULL){
// Delete of nonexistent thumbnail (not even pointers present)
// No action, no error.
return FALSE;
}
// Adding or removing of thumbnail is not possible - that would require rearranging
// of the exif header, which is risky, and jhad doesn't know how to do.
fprintf(stderr,"Image contains no thumbnail to replace - add is not possible\n");
return FALSE;
}
if (ThumbFileName){
ThumbnailFile = fopen(ThumbFileName,"rb");
if (ThumbnailFile == NULL){
ErrFatal("Could not read thumbnail file");
return FALSE;
}
// get length
fseek(ThumbnailFile, 0, SEEK_END);
ThumbLen = ftell(ThumbnailFile);
fseek(ThumbnailFile, 0, SEEK_SET);
if (ThumbLen + ImageInfo.ThumbnailOffset > 0x10000-20){
ErrFatal("Thumbnail is too large to insert into exif header");
}
}else{
if (ImageInfo.ThumbnailSize == 0){
return FALSE;
}
ThumbLen = 0;
ThumbnailFile = NULL;
}
ExifSection = FindSection(M_EXIF);
NewExifSize = ImageInfo.ThumbnailOffset+8+ThumbLen;
ExifSection->Data = (uchar *)realloc(ExifSection->Data, NewExifSize);
ThumbnailPointer = ExifSection->Data+ImageInfo.ThumbnailOffset+8;
if (ThumbnailFile){
fread(ThumbnailPointer, ThumbLen, 1, ThumbnailFile);
fclose(ThumbnailFile);
}
ImageInfo.ThumbnailSize = ThumbLen;
Put32u(ExifSection->Data+ImageInfo.ThumbnailSizeOffset+8, ThumbLen);
ExifSection->Data[0] = (uchar)(NewExifSize >> 8);
ExifSection->Data[1] = (uchar)NewExifSize;
ExifSection->Size = NewExifSize;
return TRUE;
}
//--------------------------------------------------------------------------
// Discard everything but the exif and comment sections.
//--------------------------------------------------------------------------
void DiscardAllButExif(void)
{
Section_t ExifKeeper;
Section_t CommentKeeper;
Section_t IptcKeeper;
Section_t XmpKeeper;
int a;
memset(&ExifKeeper, 0, sizeof(ExifKeeper));
memset(&CommentKeeper, 0, sizeof(CommentKeeper));
memset(&IptcKeeper, 0, sizeof(IptcKeeper));
memset(&XmpKeeper, 0, sizeof(IptcKeeper));
for (a=0;a<SectionsRead;a++){
if (Sections[a].Type == M_EXIF && ExifKeeper.Type == 0){
ExifKeeper = Sections[a];
}else if (Sections[a].Type == M_XMP && XmpKeeper.Type == 0){
XmpKeeper = Sections[a];
}else if (Sections[a].Type == M_COM && CommentKeeper.Type == 0){
CommentKeeper = Sections[a];
}else if (Sections[a].Type == M_IPTC && IptcKeeper.Type == 0){
IptcKeeper = Sections[a];
}else{
free(Sections[a].Data);
}
}
SectionsRead = 0;
if (ExifKeeper.Type){
CheckSectionsAllocated();
Sections[SectionsRead++] = ExifKeeper;
}
if (CommentKeeper.Type){
CheckSectionsAllocated();
Sections[SectionsRead++] = CommentKeeper;
}
if (IptcKeeper.Type){
CheckSectionsAllocated();
Sections[SectionsRead++] = IptcKeeper;
}
if (XmpKeeper.Type){
CheckSectionsAllocated();
Sections[SectionsRead++] = XmpKeeper;
}
}
//--------------------------------------------------------------------------
// Write image data back to disk.
//--------------------------------------------------------------------------
void WriteJpegFile(const char * FileName)
{
FILE * outfile;
int a;
if (!HaveAll){
ErrFatal("Can't write back - didn't read all");
}
outfile = fopen(FileName,"wb");
if (outfile == NULL){
ErrFatal("Could not open file for write");
}
// Initial static jpeg marker.
fputc(0xff,outfile);
fputc(0xd8,outfile);
if (Sections[0].Type != M_EXIF && Sections[0].Type != M_JFIF){
// The image must start with an exif or jfif marker. If we threw those away, create one.
static uchar JfifHead[18] = {
0xff, M_JFIF,
0x00, 0x10, 'J' , 'F' , 'I' , 'F' , 0x00, 0x01,
0x01, 0x01, 0x01, 0x2C, 0x01, 0x2C, 0x00, 0x00
};
fwrite(JfifHead, 18, 1, outfile);
}
// Write all the misc sections
for (a=0;a<SectionsRead-1;a++){
fputc(0xff,outfile);
fputc((unsigned char)Sections[a].Type, outfile);
fwrite(Sections[a].Data, Sections[a].Size, 1, outfile);
}
// Write the remaining image data.
fwrite(Sections[a].Data, Sections[a].Size, 1, outfile);
fclose(outfile);
}
//--------------------------------------------------------------------------
// Check if image has exif header.
//--------------------------------------------------------------------------
Section_t * FindSection(int SectionType)
{
int a;
for (a=0;a<SectionsRead;a++){
if (Sections[a].Type == SectionType){
return &Sections[a];
}
}
// Could not be found.
return NULL;
}
//--------------------------------------------------------------------------
// Remove a certain type of section.
//--------------------------------------------------------------------------
int RemoveSectionType(int SectionType)
{
int a;
for (a=0;a<SectionsRead-1;a++){
if (Sections[a].Type == SectionType){
// Free up this section
free (Sections[a].Data);
// Move succeding sections back by one to close space in array.
memmove(Sections+a, Sections+a+1, sizeof(Section_t) * (SectionsRead-a));
SectionsRead -= 1;
return TRUE;
}
}
return FALSE;
}
//--------------------------------------------------------------------------
// Remove sectons not part of image and not exif or comment sections.
//--------------------------------------------------------------------------
int RemoveUnknownSections(void)
{
int a;
int Modified = FALSE;
for (a=0;a<SectionsRead-1;){
switch(Sections[a].Type){
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:
case M_SOI:
case M_EOI:
case M_SOS:
case M_JFIF:
case M_EXIF:
case M_XMP:
case M_COM:
case M_DQT:
case M_DHT:
case M_DRI:
case M_IPTC:
// keep.
a++;
break;
default:
// Unknown. Delete.
free (Sections[a].Data);
// Move succeding sections back by one to close space in array.
memmove(Sections+a, Sections+a+1, sizeof(Section_t) * (SectionsRead-a));
SectionsRead -= 1;
Modified = TRUE;
}
}
return Modified;
}
//--------------------------------------------------------------------------
// Add a section (assume it doesn't already exist) - used for
// adding comment sections and exif sections
//--------------------------------------------------------------------------
Section_t * CreateSection(int SectionType, unsigned char * Data, int Size)
{
Section_t * NewSection;
int a;
int NewIndex;
NewIndex = 2;
if (SectionType == M_EXIF) NewIndex = 0; // Exif alwas goes first!
// Insert it in third position - seems like a safe place to put
// things like comments.
if (SectionsRead < NewIndex){
ErrFatal("Too few sections!");
}
CheckSectionsAllocated();
for (a=SectionsRead;a>NewIndex;a--){
Sections[a] = Sections[a-1];
}
SectionsRead += 1;
NewSection = Sections+NewIndex;
NewSection->Type = SectionType;
NewSection->Size = Size;
NewSection->Data = Data;
return NewSection;
}
//--------------------------------------------------------------------------
// Initialisation.
//--------------------------------------------------------------------------
void ResetJpgfile(void)
{
if (Sections == NULL){
Sections = (Section_t *)malloc(sizeof(Section_t)*5);
SectionsAllocated = 5;
}
SectionsRead = 0;
HaveAll = 0;
}

184
wrap/Exif/src/makernote.cpp
View File

@ -1,184 +0,0 @@
//--------------------------------------------------------------------------
// Parse some maker specific onformation.
// (Very limited right now - add maker specific stuff to this module)
//--------------------------------------------------------------------------
#include "../include/Exif/jhead.h"
//--------------------------------------------------------------------------
// Process exif format directory, as used by Cannon maker note
//--------------------------------------------------------------------------
void ProcessCanonMakerNoteDir(unsigned char * DirStart, unsigned char * OffsetBase,
unsigned ExifLength)
{
int de;
int a;
int NumDirEntries;
NumDirEntries = Get16u(DirStart);
#define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
{
unsigned char * DirEnd;
DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
if (DirEnd > (OffsetBase+ExifLength)){
ErrNonfatal("Illegally sized exif makernote subdir (%d entries)",NumDirEntries,0);
return;
}
if (DumpExifMap){
printf("Map: %05d-%05d: Directory (makernote)\n",(int)(DirStart-OffsetBase), (int)(DirEnd-OffsetBase));
}
}
if (ShowTags){
printf("(dir has %d entries)\n",NumDirEntries);
}
for (de=0;de<NumDirEntries;de++){
int Tag, Format, Components;
unsigned char * ValuePtr;
int ByteCount;
unsigned char * 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.
ErrNonfatal("Illegal number format %d for tag %04x", Format, Tag);
continue;
}
if ((unsigned)Components > 0x10000){
ErrNonfatal("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
ErrNonfatal("Illegal value pointer for tag %04x", Tag,0);
continue;
}
ValuePtr = OffsetBase+OffsetVal;
if (DumpExifMap){
printf("Map: %05d-%05d: Data for makernote tag %04x\n",OffsetVal, OffsetVal+ByteCount, Tag);
}
}else{
// 4 bytes or less and value is in the dir entry itself
ValuePtr = DirEntry+8;
}
if (ShowTags){
// Show tag name
printf(" Canon maker tag %04x Value = ", Tag);
}
// Show tag value.
switch(Format){
case FMT_UNDEFINED:
// Undefined is typically an ascii string.
case FMT_STRING:
// String arrays printed without function call (different from int arrays)
if (ShowTags){
printf("\"");
for (a=0;a<ByteCount;a++){
int ZeroSkipped = 0;
if (ValuePtr[a] >= 32){
if (ZeroSkipped){
printf("?");
ZeroSkipped = 0;
}
putchar(ValuePtr[a]);
}else{
if (ValuePtr[a] == 0){
ZeroSkipped = 1;
}
}
}
printf("\"\n");
}
break;
default:
if (ShowTags){
PrintFormatNumber(ValuePtr, Format, ByteCount);
printf("\n");
}
}
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));
if (temp_dist != 65535){
ImageInfo.Distance = (float)temp_dist/100;
}else{
ImageInfo.Distance = -1 /* infinity */;
}
}
}
}
}
//--------------------------------------------------------------------------
// Show generic maker note - just hex bytes.
//--------------------------------------------------------------------------
void ShowMakerNoteGeneric(unsigned char * ValuePtr, int ByteCount)
{
int a;
for (a=0;a<ByteCount;a++){
if (a > 10){
printf("...");
break;
}
printf(" %02x",ValuePtr[a]);
}
printf(" (%d bytes)", ByteCount);
printf("\n");
}
//--------------------------------------------------------------------------
// Process maker note - to the limited extent that its supported.
//--------------------------------------------------------------------------
void ProcessMakerNote(unsigned char * ValuePtr, int ByteCount,
unsigned char * OffsetBase, unsigned ExifLength)
{
if (strstr(ImageInfo.CameraMake, "Canon")){
ProcessCanonMakerNoteDir(ValuePtr, OffsetBase, ExifLength);
}else{
if (ShowTags){
ShowMakerNoteGeneric(ValuePtr, ByteCount);
}
}
}

305
wrap/Exif/src/myglob.cpp
View File

@ -1,305 +0,0 @@
//--------------------------------------------------------------------------------
// Module to do recursive directory file matching under windows.
//
// Tries to do pattern matching to produce similar results as Unix, but using
// the Windows _findfirst to do all the pattern matching.
//
// Also hadles recursive directories - "**" path component expands into
// any levels of subdirectores (ie c:\**\*.c matches ALL .c files on drive c:)
//
// Matthias Wandel Nov 5 2000
//--------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <io.h>
#include "../include/Exif/jhead.h"
#define TRUE 1
#define FALSE 0
//#define DEBUGGING
typedef struct {
char * Name;
int attrib;
}FileEntry;
#ifdef DEBUGGING
//--------------------------------------------------------------------------------
// Dummy function to show operation.
//--------------------------------------------------------------------------------
void ShowName(const char * FileName)
{
printf(" %s\n",FileName);
}
#endif
//--------------------------------------------------------------------------------
// Simple path splicing (assumes no '\' in either part)
//--------------------------------------------------------------------------------
static void SplicePath(char * dest, const char * p1, const char * p2)
{
int l;
l = strlen(p1);
if (!l){
strcpy(dest, p2);
}else{
if (l+strlen(p2) > _MAX_PATH-2){
fprintf(stderr,"Path too long\n");
exit(-1);
}
memcpy(dest, p1, l+1);
if (dest[l-1] != '\\' && dest[l-1] != ':'){
dest[l++] = '\\';
}
strcpy(dest+l, p2);
}
}
//--------------------------------------------------------------------------------
// Qsort compare function
//--------------------------------------------------------------------------------
int CompareFunc(const void * f1, const void * f2)
{
return strcmp(((FileEntry *)f1)->Name,((FileEntry *)f2)->Name);
}
//--------------------------------------------------------------------------------
// Decide how a particular pattern should be handled, and call function for each.
//--------------------------------------------------------------------------------
void MyGlob(const char * Pattern , void (*FileFuncParm)(const char * FileName))
{
char BasePattern[_MAX_PATH];
char MatchPattern[_MAX_PATH];
char PatCopy[_MAX_PATH*2+1];
int a;
int MatchFiles, MatchDirs;
int BaseEnd, PatternEnd;
int SawPat;
int RecurseAt;
strcpy(PatCopy, Pattern);
#ifdef DEBUGGING
printf("Called with '%s'\n",Pattern);
#endif
DoRecursion:
MatchFiles = FALSE;
MatchDirs = TRUE;
BaseEnd = 0;
PatternEnd = 0;
SawPat = FALSE;
RecurseAt = -1;
// Split the path into base path and pattern to match against using findfirst.
for (a=0;;a++){
if (PatCopy[a] == '*' || PatCopy[a] == '?'){
SawPat = TRUE;
}
if (PatCopy[a] == '*' && PatCopy[a+1] == '*'){
if (a == 0 || PatCopy[a-1] == '\\' || PatCopy[a-1] == ':'){
if (PatCopy[a+2] == '\\' || PatCopy[a+2] == '\0'){
// x\**\y ---> x\y x\*\**\y
RecurseAt = a;
if (PatCopy[a+2]){
memcpy(PatCopy+a, PatCopy+a+3, strlen(PatCopy)-a-1);
}else{
PatCopy[a+1] = '\0';
}
}
}
}
if (PatCopy[a] == '\\' || (PatCopy[a] == ':' && PatCopy[a+1] != '\\')){
PatternEnd = a;
if (SawPat) break; // Findfirst can only match one level of wildcard at a time.
BaseEnd = a+1;
}
if (PatCopy[a] == '\0'){
PatternEnd = a;
MatchFiles = TRUE;
MatchDirs = FALSE;
break;
}
}
if (!SawPat){
// No pattern. This should refer to a file.
FileFuncParm(PatCopy);
return;
}
strncpy(BasePattern, PatCopy, BaseEnd);
BasePattern[BaseEnd] = 0;
strncpy(MatchPattern, PatCopy, PatternEnd);
MatchPattern[PatternEnd] = 0;
#ifdef DEBUGGING
printf("Base:%s Pattern:%s Files:%d dirs:%d\n",BasePattern, MatchPattern, MatchFiles, MatchDirs);
#endif
{
FileEntry * FileList = NULL;
int NumAllocated = 0;
int NumHave = 0;
struct _finddata_t finddata;
long find_handle;
find_handle = _findfirst(MatchPattern, &finddata);
for (;;){
if (find_handle == -1) break;
// Eliminate the obvious patterns.
if (!memcmp(finddata.name, ".",2)) goto next_file;
if (!memcmp(finddata.name, "..",3)) goto next_file;
if (finddata.attrib & _A_SUBDIR){
if (!MatchDirs) goto next_file;
}else{
if (!MatchFiles) goto next_file;
}
// Add it to the list.
if (NumAllocated <= NumHave){
NumAllocated = NumAllocated+10+NumAllocated/2;
FileList = (FileEntry*)realloc(FileList, NumAllocated * sizeof(FileEntry));
if (FileList == NULL) goto nomem;
}
a = strlen(finddata.name);
FileList[NumHave].Name = (char*)malloc(a+1);
if (FileList[NumHave].Name == NULL){
nomem:
printf("malloc failure\n");
exit(-1);
}
memcpy(FileList[NumHave].Name, finddata.name, a+1);
FileList[NumHave].attrib = finddata.attrib;
NumHave++;
next_file:
if (_findnext(find_handle, &finddata) != 0) break;
}
_findclose(find_handle);
// Sort the list...
qsort(FileList, NumHave, sizeof(FileEntry), CompareFunc);
// Use the list.
for (a=0;a<NumHave;a++){
char CombinedName[_MAX_PATH*2+1];
if (FileList[a].attrib & _A_SUBDIR){
if (MatchDirs){
// Need more directories.
SplicePath(CombinedName, BasePattern, FileList[a].Name);
strncat(CombinedName, PatCopy+PatternEnd, _MAX_PATH*2-strlen(CombinedName));
MyGlob(CombinedName,FileFuncParm);
}
}else{
if (MatchFiles){
// We need files at this level.
SplicePath(CombinedName, BasePattern, FileList[a].Name);
FileFuncParm(CombinedName);
}
}
free(FileList[a].Name);
}
free(FileList);
}
if(RecurseAt >= 0){
strcpy(MatchPattern, PatCopy+RecurseAt);
PatCopy[RecurseAt] = 0;
strncpy(PatCopy+RecurseAt, "*\\**\\", _MAX_PATH*2-RecurseAt);
strncat(PatCopy, MatchPattern, _MAX_PATH*2-strlen(PatCopy));
#ifdef DEBUGGING
printf("Recurse with '%s'\n",PatCopy);
#endif
// As this function context is no longer needed, we can just goto back
// to the top of it to avoid adding another context on the stack.
goto DoRecursion;
}
}
//--------------------------------------------------------------------------------
// Flip slashes to native OS representation (for Windows)
//--------------------------------------------------------------------------------
void SlashToNative(char * Path)
{
int a;
for (a=0;Path[a];a++){
if (Path[a] == '/') Path[a] = SLASH;
}
}
#ifdef DEBUGGING
//--------------------------------------------------------------------------------
// The main program.
//--------------------------------------------------------------------------------
int main (int argc, char **argv)
{
int argn;
char * arg;
int Subdirs = 0;
for (argn=1;argn<argc;argn++){
arg = argv[argn];
if (arg[0] != '-') break; // Filenames from here on.
if (!strcmp(arg,"-r")){
printf("do recursive\n");
Subdirs = 1;
}else{
fprintf(stderr, "Argument '%s' not understood\n",arg);
}
}
if (argn == argc){
fprintf(stderr,"Error: Must supply a file name\n");
}
for (;argn<argc;argn++){
MyGlob(argv[argn], ShowName);
}
return EXIT_SUCCESS;
}
#endif
/*
non-recursive test cases:
e:\make*\*
\make*\*
e:*\*.c
\*\*.c
\*
c:*.c
c:\*
..\*.c
recursive test cases:
**
**\*.c
c:\**\*.c
c:**\*.c
.\**
..\**
*/

141
wrap/Exif/src/paths.cpp
View File

@ -1,141 +0,0 @@
//--------------------------------------------------------------------------------
// Module to do path manipulation for file moving of jhead.
//
// Matthias Wandel Feb 2 2009
//--------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <ctype.h>
#include <sys/stat.h>
#ifdef _WIN32
#include <direct.h> // for mkdir under windows.
#define mkdir(dir,mode) mkdir(dir)
#undef S_ISDIR
#define S_ISDIR(a) (a & _S_IFDIR)
#endif
#include "../include/Exif/jhead.h"
//--------------------------------------------------------------------------------
// Ensure that a path exists
//--------------------------------------------------------------------------------
int EnsurePathExists(const char * FileName)
{
char NewPath[PATH_MAX*2];
int a;
int LastSlash = 0;
//printf("\nEnsure exists:%s\n",FileName);
// Extract the path component of the file name.
strcpy(NewPath, FileName);
a = strlen(NewPath);
for (;;){
a--;
if (a == 0){
NewPath[0] = 0;
break;
}
if (NewPath[a] == SLASH){
struct stat dummy;
NewPath[a] = 0;
if (stat(NewPath, &dummy) == 0){
if (S_ISDIR(dummy.st_mode)){
// Break out of loop, and go forward along path making
// the directories.
if (LastSlash == 0){
// Full path exists. No need to create any directories.
return 1;
}
break;
}else{
// Its a file.
fprintf(stderr,"Can't create path '%s' due to file conflict\n",NewPath);
return 0;
}
}
if (LastSlash == 0) LastSlash = a;
}
}
// Now work forward.
//printf("Existing First dir: '%s' a = %d\n",NewPath,a);
for(;FileName[a];a++){
if (FileName[a] == SLASH || a == 0){
if (a == LastSlash) break;
NewPath[a] = FileName[a];
//printf("make dir '%s'\n",NewPath);
#ifdef _WIN32
if (NewPath[1] == ':' && strlen(NewPath) == 2) continue;
#endif
if (mkdir(NewPath,0777)){
fprintf(stderr,"Could not create directory '%s'\n",NewPath);
// Failed to create directory.
return 0;
}
}
}
return 1;
}
//--------------------------------------------------------------------------------
// Make a new path out of a base path, and a filename.
// Basepath is the base path, and FilePath is a filename, or path + filename.
//--------------------------------------------------------------------------------
void CatPath(char * BasePath, const char * FilePath)
{
int l;
l = strlen(BasePath);
if (FilePath[1] == ':'){
// Its a windows absolute path.
l = 0;
}
if (FilePath[0] == SLASH || FilePath[0] == '.' || l == 0){
// Its an absolute path, or there was no base path.
strcpy(BasePath, FilePath);
return;
}
if (BasePath[l-1] != SLASH){
BasePath[l++] = SLASH;
BasePath[l] = 0;
}
strcat(BasePath, FilePath);
// Note that the combined path may contains things like "foo/../bar". We assume
// that the filesystem will take care of these.
}
/*
char Path1[] = "ztest\\cdir\\foo.jpg";
char Path2[] = "zxtest\\cdir\\foo.jpg";
char Path3[] = "\\tzest\\cdir\\foo.jpg";
char BasePath[100];
main()
{
EnsurePathExists(Path1);
EnsurePathExists(Path2);
EnsurePathExists(Path3);
CatPath(BasePath, "hello.txt");
CatPath(BasePath, "world\\hello.txt");
CatPath(BasePath, "\\hello.txt");
CatPath(BasePath, "c:\\hello.txt");
CatPath(BasePath, "c:\\world\\hello.txt");
CatPath(BasePath, "c:\\abresl\\hello.txt");
}
*/