added exif lib
git-svn-id: https://svn.code.sf.net/p/gphoto/code/trunk/libgphoto2@567 67ed7778-7388-44ab-90cf-0a291f65f57c
This commit is contained in:
@@ -255,7 +255,7 @@ int camera_id (char *id) {
|
||||
|
||||
int camera_abilities (CameraAbilities *abilities, int *count) {
|
||||
|
||||
*count = 2;
|
||||
*count = 3;
|
||||
|
||||
/* What models do we support? */
|
||||
strcpy(abilities[0].model, "Barbie Camera");
|
||||
@@ -278,7 +278,10 @@ int camera_abilities (CameraAbilities *abilities, int *count) {
|
||||
abilities[0].sleep = 1;
|
||||
|
||||
memcpy(&abilities[1], &abilities[0], sizeof(abilities[0]));
|
||||
strcpy(abilities[1].model, "WWF Camera");
|
||||
strcpy(abilities[1].model, "Hot Wheels Camera");
|
||||
|
||||
memcpy(&abilities[2], &abilities[0], sizeof(abilities[0]));
|
||||
strcpy(abilities[2].model, "WWF Camera");
|
||||
|
||||
return (GP_OK);
|
||||
}
|
||||
|
||||
@@ -9,6 +9,7 @@ CFLAGS= @CFLAGS@ \
|
||||
libgphoto2_la_LDFLAGS = -version-info 0:0:0
|
||||
libgphoto2_la_SOURCES = \
|
||||
core.c core.h \
|
||||
exif.c exif.h \
|
||||
file.c file.h \
|
||||
library.c library.h \
|
||||
settings.c settings.h \
|
||||
|
||||
692
libgphoto2/exif.c
Normal file
692
libgphoto2/exif.c
Normal file
@@ -0,0 +1,692 @@
|
||||
#include "exif.h"
|
||||
/*
|
||||
EXIF file library for GPHOTO package
|
||||
Copyright (C) 1999 Matthew G. Martin
|
||||
|
||||
Generic gphoto implementation and extension by Edouard Lafargue.
|
||||
|
||||
Tag descriptions and an ever-increasing number of structural details
|
||||
Taken from "exifdump.py" by Thierry Bousch <bousch@topo.math.u-psud.fr>
|
||||
|
||||
Thanks to Paul Wood <pwood@cs.bris.ac.uk> for sub-ifd parsing.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
/***********
|
||||
* Conventions:
|
||||
*
|
||||
* "tag number" (tagnum) : ID number of a tag (see list just below).
|
||||
* "tag index" (tagind) : index number of a tag inside an EXIF structure
|
||||
* (for example, tag number one if the first tag, etc..)
|
||||
* "tag name" (tagname) : name of the tag as defined in the EXIF standard.
|
||||
*/
|
||||
|
||||
int exif_debug=0;
|
||||
|
||||
/* Size of various tags */
|
||||
static int exif_sizetab[13]={
|
||||
0,1,1,2,4,8,1,1,2,4,8,4,8
|
||||
};
|
||||
|
||||
|
||||
/**************************************************************/
|
||||
/* Utility functions: get fields in little-endian format, */
|
||||
/* initialize data structures, etc. */
|
||||
/**************************************************************/
|
||||
|
||||
/**
|
||||
* Convert to Intel-Endian number.
|
||||
*
|
||||
* data : pointer to the data to convert
|
||||
* size : size of the data to convert
|
||||
*
|
||||
* Returns : the value
|
||||
*/
|
||||
long exif_get_lilend(unsigned char *data, int size){
|
||||
long total;
|
||||
|
||||
total=0;
|
||||
for (--size;size>=0;size--){
|
||||
total<<=8;
|
||||
total+=data[size];
|
||||
};
|
||||
|
||||
return(total);
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert to signed Intel-Endian number
|
||||
*/
|
||||
long exif_get_slilend(unsigned char *data, int size){
|
||||
long total;
|
||||
long unsigned mask=1<<(size*8-1);
|
||||
|
||||
total=0;
|
||||
for (--size;size>=0;size--){
|
||||
total<<=8;
|
||||
total+=data[size];
|
||||
};
|
||||
|
||||
if (total&mask) total-=mask;
|
||||
|
||||
return(total);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Return "value" of directory entry at tagind
|
||||
*/
|
||||
int gpe_theval(unsigned char *data,int tagind){
|
||||
return(exif_get_lilend(data+tagind*12+10,4));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Set the "value" of directory entry at tagind.
|
||||
*/
|
||||
void gpe_setval(unsigned char *data,int tagind,long newval){
|
||||
int i;
|
||||
for (i=0;i<4;i++) data[tagind*12+10+i]=0xff&(newval>>(i*8));
|
||||
if (gpe_getvalue(data,tagind)!=newval)
|
||||
printf("Setptr: error %d inst %ld\n",gpe_theval(data,tagind),newval);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Returns the offset of the next IFD entry after
|
||||
* offset "num".
|
||||
*
|
||||
* exif : exif data
|
||||
* num : start offset
|
||||
*
|
||||
* returns: offset of next IFD.
|
||||
*/
|
||||
long exif_next_ifd(unsigned char *exif,int num){
|
||||
|
||||
int offset=(exif[num]+(exif[num+1]<<8))*12+num+2;
|
||||
if (exif_debug) printf("next_ifd,offset=%d\n",offset);
|
||||
return(exif_get_lilend(exif+offset,4));
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Parse an exif data structure and initialise the "exifparser".
|
||||
*
|
||||
* exifdat : the exif data
|
||||
*
|
||||
* returns : size of the rest of the file.
|
||||
* -1 if failed.
|
||||
*/
|
||||
int exif_parse_data(exifparser *exifdat) {
|
||||
long offset=0;
|
||||
ExifData tagdat;
|
||||
|
||||
exif_debug=1;
|
||||
/* Check that it's not already preparsed */
|
||||
// Doesn't work if we don't initialize this first...
|
||||
// if (exifdat->preparsed) return 0;
|
||||
if (exif_debug) printf("Parsing exif structure\n");
|
||||
|
||||
/* First, verify that we really have an EXIF file */
|
||||
/* Note: maybe we could also generalize to TIFF... */
|
||||
if ((strncmp("Exif",exifdat->header+6,4)) ||
|
||||
strncmp("\377\330\377\341",exifdat->header,4)){
|
||||
fprintf(stderr,"Not exif data\n");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
exifdat->exiflen = exifdat->header[5] + (exifdat->header[4]<<8) - 8;
|
||||
if (exif_debug) printf("Exif length is %ld\n",exifdat->exiflen);
|
||||
|
||||
/* Count the number of IFD's and register their pointers. */
|
||||
exifdat->endian=0;
|
||||
if (exifdat->data[0]!='I') {
|
||||
exifdat->endian=1;
|
||||
printf("%c,Intel-Endian format only supported right now!\n",
|
||||
exifdat->data[0]);
|
||||
return(-1);
|
||||
};
|
||||
|
||||
offset=exif_get_lilend(exifdat->data+4,4); /*Get offset of first IFD */
|
||||
exifdat->ifdcnt=-1;
|
||||
|
||||
/*Step through each IFD */
|
||||
do {
|
||||
exifdat->ifdcnt++;
|
||||
exifdat->ifds[exifdat->ifdcnt] = exifdat->data+offset;
|
||||
exifdat->ifdtags[exifdat->ifdcnt] = exif_get_lilend(exifdat->data+offset,2);
|
||||
} while (offset=exif_next_ifd(exifdat->data,offset));
|
||||
|
||||
exifdat->ifdcnt++;
|
||||
|
||||
/* Look for the EXIF IFD */
|
||||
exifdat->preparsed=1; /* Indicate that our exifparser is initialized */
|
||||
/* Has to be done before calling exif_get_field */
|
||||
if ( ! exif_get_field( EXIF_ExifOffset, 0, exifdat, &tagdat)) {
|
||||
printf("No EXIF information stored in this image\n");
|
||||
} else {
|
||||
if (exif_debug) printf("Offset to the Exif subIFD is %d\n",tagdat.intval);
|
||||
exifdat->ifds[exifdat->ifdcnt] = exifdat->data + tagdat.intval;
|
||||
exifdat->ifdtags[exifdat->ifdcnt] = exif_get_lilend(exifdat->data+tagdat.intval,2);
|
||||
exifdat->ifdcnt++;
|
||||
}
|
||||
|
||||
if (exif_debug) printf("Finished parsing exif structure\n");
|
||||
return exifdat->exiflen;
|
||||
}
|
||||
|
||||
/**************************************************************/
|
||||
/* tag-level functions: get/set tags in the EXIF structure */
|
||||
/**************************************************************/
|
||||
|
||||
/**
|
||||
* Returns the value of a field, identified by its tag and the IFD.
|
||||
*
|
||||
* Specifying an IFD of '-1' will return the first occurence of
|
||||
* the tag in the first IFD where it finds it.
|
||||
*
|
||||
* tag_number: tag that identifies the field
|
||||
* ifd : image file directory where to look for that tag
|
||||
* exifdata : pointer to the EXIF data
|
||||
* tag_data : filled by this function, contains the actual data
|
||||
*
|
||||
* returns : 1 on success, 0 on failure
|
||||
*/
|
||||
int exif_get_field( int tag_number, int ifd, exifparser *exifdata, ExifData *tag_data) {
|
||||
int numtags,i,j,tag, sign;
|
||||
char *ifdp, *offset, *data;
|
||||
|
||||
// Sanity check first:
|
||||
exif_debug=1;
|
||||
if ( !exifdata->preparsed ) {
|
||||
if(exif_parse_data(exifdata) < 0)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ifd == -1) {
|
||||
for (i = 0; i < exifdata->ifdcnt+1; i++){
|
||||
if (exif_debug) printf("Searching in IFD %d\n",i);
|
||||
if ( exif_get_field(tag_number, i, exifdata, tag_data) == 1)
|
||||
return 1;
|
||||
}
|
||||
return 0; // We did not find it.
|
||||
} else {
|
||||
|
||||
// Find tag in a specific IFD
|
||||
ifdp = exifdata->ifds[ifd];
|
||||
numtags=exif_get_lilend(ifdp,2); // How many tags in the IFD
|
||||
if (exif_debug) printf("exif_get_field: %d tags in ifd %d\n",numtags, ifd);
|
||||
i=-1;
|
||||
do {
|
||||
i++;
|
||||
tag = exif_get_lilend(ifdp+i*12+2, 2); // Get the tag ID
|
||||
// if (exif_debug) fprintf(stderr,"Found tag %d \n",tag);
|
||||
} while ((i < numtags) && (tag != tag_number));
|
||||
|
||||
if(tag != tag_number) {
|
||||
if (exif_debug) fprintf(stderr,"Tag %d not found\n",tag_number);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ifdp = ifdp+i*12+2; // Place pointer at TAG type position
|
||||
tag_data->tag = tag;
|
||||
tag_data->type = exif_get_lilend(ifdp+2,2); /* tag type */
|
||||
tag_data->size = exif_sizetab[tag_data->type]*exif_get_lilend(ifdp+4,4);
|
||||
if (exif_debug) printf("(%d bytes) ",tag_data->size);
|
||||
|
||||
ifdp += 8; // place pointer at beginning of the contents of the field
|
||||
|
||||
/* Data types smaller than 4 bytes are stored directly in
|
||||
the IFD field value. Otherwise, that value is an offset
|
||||
to the real data */
|
||||
if (tag_data->size > 4) {
|
||||
ifdp = exifdata->data + exif_get_lilend(ifdp,4);
|
||||
}
|
||||
|
||||
/* Last operation, get the data itself: */
|
||||
/* Allocate memory, and copy the data */
|
||||
data=malloc(tag_data->size);
|
||||
if (data==NULL){
|
||||
fprintf(stderr,"exif_get_field: could not malloc\n");
|
||||
return 0;
|
||||
};
|
||||
|
||||
if (tag_data->type == EXIF_ASCII) {
|
||||
memcpy(data,ifdp,tag_data->size); // Normally, the exif data includes a terminating 0
|
||||
tag_data->data = data;
|
||||
if(exif_debug) printf("\"%s\"",data);
|
||||
} else {
|
||||
for (i = 0; i < tag_data->size; i += exif_sizetab[tag_data->type]) {
|
||||
//if (exif_debug) fprintf(stderr,".");
|
||||
if ( tag_data->type % 5 ) {
|
||||
memcpy(data+i,ifdp+i,exif_sizetab[tag_data->type]);
|
||||
} else { // Fraction
|
||||
tag_data->num =exif_get_lilend(ifdp+i,4);
|
||||
tag_data->den =exif_get_lilend(ifdp+i+4,4);
|
||||
|
||||
if(exif_debug) printf("%d/%d=%.3g ",tag_data->num,
|
||||
tag_data->den,
|
||||
(tag_data->den==0)?0:(1.0*tag_data->num/tag_data->den));
|
||||
}
|
||||
}
|
||||
// If the value can be put into an int, save the trouble and store
|
||||
// it into "intval" right away...
|
||||
if(tag_data->type != EXIF_ASCII && tag_data->type != EXIF_RATIONAL &&
|
||||
tag_data->type != EXIF_UNDEFINED && tag_data->type != EXIF_SRATIONAL) {
|
||||
tag_data->intval = exif_get_lilend(data,exif_sizetab[tag_data->type]);
|
||||
if(exif_debug) printf("'%d'",tag_data->intval);
|
||||
}
|
||||
tag_data->data = data; // Save the data field
|
||||
}
|
||||
if (exif_debug) printf("\n"); /*end of this tag */
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an ASCII tag.
|
||||
*
|
||||
* Specifying an IFD of '-1' will return the first occurence of
|
||||
* the tag in the first IFD where it finds it.
|
||||
*
|
||||
* tag_number: tag that identifies the field
|
||||
* ifd : image file directory where to look for that tag
|
||||
* exifdata : pointer to the EXIF data
|
||||
*
|
||||
* returns : pointer to the tag value.
|
||||
*/
|
||||
char * exif_get_ascii_field( int tag_number, int ifd, exifparser *exifdat) {
|
||||
ExifData tagdat;
|
||||
|
||||
if (exif_parse_data(exifdat)<0) return NULL;
|
||||
|
||||
if ( ! exif_get_field( tag_number, ifd, exifdat, &tagdat)) {
|
||||
if (exif_debug) printf("No comment field in this image\n");
|
||||
return NULL;
|
||||
} else {
|
||||
return tagdat.data;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a numeric tag.
|
||||
*
|
||||
* Specifying an IFD of '-1' will return the first occurence of
|
||||
* the tag in the first IFD where it finds it.
|
||||
*
|
||||
* tag_number: tag that identifies the field
|
||||
* ifd : image file directory where to look for that tag
|
||||
* exifdata : pointer to the EXIF data
|
||||
*
|
||||
* returns : tag value.
|
||||
*/
|
||||
int exif_get_int_field( int tag_number, int ifd, exifparser *exifdat) {
|
||||
ExifData tagdat;
|
||||
int tmp;
|
||||
|
||||
if (exif_parse_data(exifdat)<0) return 0;
|
||||
|
||||
if ( ! exif_get_field( tag_number, ifd, exifdat, &tagdat)) {
|
||||
if (exif_debug) printf("Field not found in this image.\n");
|
||||
return 0;
|
||||
} else {
|
||||
tmp = tagdat.intval;
|
||||
free(tagdat.data); // ???
|
||||
return tmp;
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the name of a given tag number
|
||||
*/
|
||||
char *exif_get_tagname(int tag_number) {
|
||||
int i=-1;
|
||||
do {
|
||||
i++;
|
||||
if (tagnames[i].num == tag_number) return (tagnames[i].desc);
|
||||
} while (tagnames[i].num);
|
||||
return("Unknown");
|
||||
}
|
||||
|
||||
/**************************************************************/
|
||||
/* Higher-level functions: get/set logical entities, such as */
|
||||
/* comments, thumbnail, etc. */
|
||||
/**************************************************************/
|
||||
|
||||
/**
|
||||
* Gets the comment field if it exists.
|
||||
*/
|
||||
int exif_get_comment(exifparser *exifdat, char *comment) {
|
||||
ExifData tagdat;
|
||||
|
||||
if (exif_parse_data(exifdat)<0) return 0;
|
||||
|
||||
/* User Comment is in IFD number 2 */
|
||||
if ( ! exif_get_field( EXIF_UserComment, 2, exifdat, &tagdat)) {
|
||||
if (exif_debug) printf("No comment field in this image\n");
|
||||
return 0;
|
||||
} else {
|
||||
comment = tagdat.data;
|
||||
return tagdat.size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the comment field if it exists.
|
||||
*/
|
||||
int exif_set_comment(exifparser *exifdat, char *comment) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the thumbnail of an EXIF image.
|
||||
*
|
||||
* The returned thumbnail might be in JPEG or TIFF format.
|
||||
*/
|
||||
unsigned char *exif_get_thumbnail(exifparser *exifdat) {
|
||||
char *tmpstr[32];
|
||||
unsigned char *imagedata,*exifimg,*newimg,*curptr;
|
||||
unsigned int exiflen,entry;
|
||||
long dataptr,dsize,tag,datvec,size,tmp;
|
||||
int i,j;
|
||||
|
||||
exif_debug=1;
|
||||
if (exif_parse_data(exifdat)<0) return(NULL);
|
||||
|
||||
newimg=malloc(exifdat->exiflen);
|
||||
if (newimg==NULL){
|
||||
fprintf(stderr,"exif_get_thumbnail: could not malloc\n");
|
||||
return(NULL);
|
||||
};
|
||||
|
||||
/* Copy header*/
|
||||
memcpy(newimg,exifdat->data,8);
|
||||
curptr=newimg+8;
|
||||
|
||||
if (exif_debug) {
|
||||
ExifData owner;
|
||||
char *comment;
|
||||
printf("Decoding EXIF fields in thumbnail\n");
|
||||
exif_get_field( EXIF_Model, -1, exifdat, &owner);
|
||||
printf("Camera model: %s\n",owner.data);
|
||||
printf("Comment for this picture (%d chars)",exif_get_comment( exifdat, comment));
|
||||
//printf(" -> %s\n",comment); Not OK on Linux
|
||||
exif_get_field( EXIF_SubjectDistance, 2, exifdat, &owner);
|
||||
// dump_exif(exifdat);
|
||||
};
|
||||
|
||||
/* Skip to Thumbnail image data */
|
||||
if(exifdat->ifdcnt<2) {
|
||||
if (exif_debug) {
|
||||
fprintf(stderr,"Too few ifds, doesn't look right. Giving up\n");
|
||||
};
|
||||
return(NULL); /* Things don't look right...*/
|
||||
};
|
||||
|
||||
/* Jump to thumbnail image data */
|
||||
exifimg=exifdat->ifds[1];
|
||||
|
||||
/* Copy number of entries */
|
||||
memcpy(curptr,exifimg,2);
|
||||
curptr+=2;
|
||||
|
||||
entry=exif_get_lilend(exifimg,2);
|
||||
|
||||
if (exif_debug) printf("Entry is %d \n",entry);
|
||||
|
||||
/* See if thumb is a JPEG */
|
||||
tmp=gpe_getintval(exifimg,EXIF_JPEGInterchangeFormat); /*imagedata start*/
|
||||
if (tmp>0) { /* jpeg image */
|
||||
if (exif_debug) fprintf(stderr,"Found jpeg thumb data\n");
|
||||
dsize=gpe_getintval(exifimg,EXIF_JPEGInterchangeFormatLength);
|
||||
if (dsize==-1){
|
||||
fprintf(stderr,"No Jpeg size tag for thumbnail, skipping\n");
|
||||
return(NULL);
|
||||
};
|
||||
imagedata=exifdat->data+tmp;
|
||||
memcpy(newimg,imagedata,dsize);
|
||||
return(newimg);
|
||||
};
|
||||
|
||||
/* Try a TIFF */
|
||||
tmp=gpe_getintval(exifimg,EXIF_StripOffsets); /*imagedata start*/
|
||||
if (tmp==-1) {
|
||||
fprintf(stderr,"gpe_get_thumbnail: Tiff or jpeg data not found, skipping\n");
|
||||
return(NULL);
|
||||
};
|
||||
imagedata=exifdat->data+tmp;
|
||||
|
||||
dataptr=gpe_getintval(exifimg,EXIF_StripByteCounts); /* imagedata size */
|
||||
if (dataptr==-1) {
|
||||
printf("Split two\n");
|
||||
return(NULL);
|
||||
};
|
||||
|
||||
if (exif_debug) printf("Imagedata size is %ld bytes\n",dataptr);
|
||||
|
||||
for (i=0;i<entry;i++){
|
||||
dsize=gpe_datsize(exifimg,i);
|
||||
tag=gpe_tagnum(exifimg,i);
|
||||
|
||||
/*
|
||||
if (exif_debug) printf("Datsize %d (tag=%ld) is %ld\n",i,tag,dsize);
|
||||
*/
|
||||
|
||||
if (tag==EXIF_StripOffsets) {
|
||||
gpe_setval(exifimg,i,12*entry+14); /* set to end of directory */
|
||||
memcpy(curptr,exifimg+12*i+2,12);
|
||||
curptr+=12;
|
||||
}
|
||||
else {
|
||||
if (dsize<5){
|
||||
/* Just copy the field if small */
|
||||
memcpy(curptr,exifimg+12*i+2,12);
|
||||
curptr+=12;
|
||||
}
|
||||
else {
|
||||
datvec=gpe_getvalue(exifimg,i);
|
||||
gpe_setval(exifimg,i,dataptr+12*entry+14);
|
||||
for (j=0;j<dsize;j++) imagedata[dataptr++]=exifdat->data[datvec+j];
|
||||
memcpy(curptr,exifimg+12*i+2,12);
|
||||
curptr+=12;
|
||||
};
|
||||
};
|
||||
};
|
||||
memcpy(curptr,exifimg+12*entry+10,4); /* Write 4 zero bytes */
|
||||
curptr+=4;
|
||||
memcpy(curptr,imagedata,dataptr);/* ? */
|
||||
curptr+=dataptr;
|
||||
return newimg;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return tag number of directory entry at tag index
|
||||
*
|
||||
* data : pointer to EXIF data, aligned to the beginning of an IFD
|
||||
* tagind : index of the tag within the IFD
|
||||
*
|
||||
* returns: tag ID number
|
||||
*/
|
||||
int gpe_tagnum( char *data,int tagind){
|
||||
return(exif_get_lilend(data+tagind*12+2,2));
|
||||
};
|
||||
|
||||
/**
|
||||
* Get the value of a tag as an integer.
|
||||
* only works for 4 byte values.
|
||||
*
|
||||
* data : exif data, aligned to the beginning of an IFD.
|
||||
* tagnum : tag number.
|
||||
*
|
||||
* returns: -1 if the tag is not found.
|
||||
*/
|
||||
int gpe_getintval(unsigned char *data, int tagnum) {
|
||||
int numtags,i,tag,tagtype;
|
||||
|
||||
numtags=exif_get_lilend(data,2);
|
||||
|
||||
if (exif_debug) printf("getval:%d tags\n",numtags);
|
||||
|
||||
i=-1;
|
||||
do {
|
||||
i++;
|
||||
tag=exif_get_lilend(data+i*12+2,2);
|
||||
} while ((i<numtags) && (tag!=tagnum));
|
||||
|
||||
if(tag!=tagnum) {
|
||||
if (exif_debug) fprintf(stderr,"Tag %d not found\n",tagnum);
|
||||
return(-1);
|
||||
};
|
||||
|
||||
tagtype=exif_get_lilend(data+i*12+4,2); /* tag type */
|
||||
|
||||
return(exif_get_lilend(data+i*12+10,exif_sizetab[tagtype-1]));
|
||||
};
|
||||
|
||||
/**
|
||||
* Return "value" of directory entry at tagind
|
||||
*
|
||||
* data : exif data
|
||||
* tagind: tag index
|
||||
*/
|
||||
int gpe_getvalue(unsigned char *data,int tagind){
|
||||
return(exif_get_lilend(data+tagind*12+10,4));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Add all tag names and values in an ifd to an array of strings for gphoto
|
||||
*/
|
||||
//int gpe_exif_add_all(exifparser *exifdata,int ifdnum,char **datastrings){
|
||||
// int i;
|
||||
// for (i=0;i<exifdata->ifdtags[ifdnum];i++){
|
||||
// togphotostr(exifdata,ifdnum,i,datastrings+i*2,datastrings+i*2+1);
|
||||
// /* printf("%s = %s\n",datastrings[i*2],datastrings[i*2+1]);*/
|
||||
// };
|
||||
//};
|
||||
|
||||
|
||||
|
||||
int gpe_dump_ifd(int ifdnum,exifparser *exifdata,char **allpars){
|
||||
int i,j,tag,numtags,tagtype,count,typelen, value,tmp1,tmp2;
|
||||
char tmpstr[256];
|
||||
unsigned char* thistag;
|
||||
unsigned char* thedata;
|
||||
unsigned char* thisisd;
|
||||
char tmpdat[200];
|
||||
char** name;
|
||||
|
||||
|
||||
thisisd=exifdata->ifds[ifdnum];
|
||||
numtags=exif_get_lilend(thisisd,2);
|
||||
printf("has %d tags ----------------------\n",numtags);
|
||||
for (i=0;i<numtags;i++){
|
||||
|
||||
thistag=thisisd+i*12+2; /* pointer to data for this tag */
|
||||
|
||||
tag=exif_get_lilend(thistag,2); /* tag identifier */
|
||||
tagtype=exif_get_lilend(thistag+2,2); /* tag type */
|
||||
count = exif_get_lilend(thistag+4, 4); /* how many */
|
||||
typelen=exif_sizetab[tagtype];/* length of this type */
|
||||
|
||||
if (exif_debug) printf("(%dX) ",count);
|
||||
|
||||
thedata=thistag+8;
|
||||
if (count*typelen > 4) /* find it in a data block elsewhere */
|
||||
thedata = exifdata->data+exif_get_lilend(thistag+8, 4);
|
||||
|
||||
printf("Tag 0x%X %s = ",tag,exif_get_tagname(tag));
|
||||
|
||||
if (tagtype==2) {
|
||||
/* Do an ASCII tag */
|
||||
strncpy(tmpstr,thedata,count+1);
|
||||
tmpstr[count+1]='\0';
|
||||
printf("'%s'",tmpstr);
|
||||
}
|
||||
else for (j=0;j<count;j++) {
|
||||
|
||||
if ((tagtype==5)||(tagtype==10)) {/* Fractional */
|
||||
tmp1=exif_get_slilend(thedata+j*typelen,4);
|
||||
tmp2=exif_get_slilend(thedata+4+j*typelen,4);
|
||||
printf("%d/%d=%.3g ",tmp1,tmp2,(tmp2==0)?0:(1.0*tmp1/tmp2));
|
||||
}
|
||||
else {
|
||||
value =exif_get_lilend(thedata+j*typelen,typelen);
|
||||
printf("%d ",value);
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
printf("\n"); /*end of this tag */
|
||||
|
||||
/* Print SubIfd tags */
|
||||
if ( tag == 0x8769 ) {
|
||||
printf("Exif SubIFD at offset %d\n", value );
|
||||
exifdata->ifds[exifdata->ifdcnt] = exifdata->data+value;
|
||||
exifdata->ifds[exifdata->ifdcnt];
|
||||
exifdata->ifdtags[exifdata->ifdcnt]=exif_get_lilend(exifdata->data+value,2);
|
||||
exifdata->ifdcnt++;
|
||||
|
||||
}
|
||||
/***/
|
||||
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Walk through EXIF structure, printing values */
|
||||
int gpe_dump_exif(exifparser *exifdata){
|
||||
int i,tag;
|
||||
unsigned char* thisifd;
|
||||
|
||||
if (!exifdata->preparsed)
|
||||
if (stat_exif(exifdata)) return(-1);
|
||||
|
||||
for (i=0;i<exifdata->ifdcnt;i++){
|
||||
switch (i) {
|
||||
case 0:
|
||||
printf("IFD %d, %s ",i,"Main Image");
|
||||
break;
|
||||
case 1:
|
||||
printf("IFD %d, %s ",i,"Thumbnail");
|
||||
break;
|
||||
case 2:
|
||||
printf("IFD %d, %s ",i,"Sub IFD");
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
|
||||
gpe_dump_ifd(i,exifdata,NULL);
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Return data size of directory entry at tagind
|
||||
*/
|
||||
int gpe_datsize(unsigned char *data,int tagind){
|
||||
return(exif_sizetab[exif_get_lilend(data+tagind*12+4,2)]*exif_get_lilend(data+tagind*12+6,4));
|
||||
};
|
||||
304
libgphoto2/exif.h
Normal file
304
libgphoto2/exif.h
Normal file
@@ -0,0 +1,304 @@
|
||||
#ifndef _gphoto_exif_
|
||||
#define _gphoto_exif_
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/times.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
/**
|
||||
* EXIF file format support library. This API allows to parse, read and
|
||||
* modify EXIF data structures. It provides a low-level API which allows
|
||||
* to manipulate EXIF tags in a generic way, and a higher-level API which
|
||||
* provides more advanced functions such as comment editing, thumbnail
|
||||
* extraction, etc.
|
||||
*
|
||||
* In the future, vendor-proprietary exif extensions might be supported.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Tag data type information.
|
||||
*/
|
||||
typedef enum {
|
||||
EXIF_NOTYPE = 0, /* placeholder */
|
||||
EXIF_BYTE = 1, /* 8-bit unsigned integer */
|
||||
EXIF_ASCII = 2, /* 8-bit bytes w/ last byte null */
|
||||
EXIF_SHORT = 3, /* 16-bit unsigned integer */
|
||||
EXIF_LONG = 4, /* 32-bit unsigned integer */
|
||||
EXIF_RATIONAL = 5, /* 64-bit unsigned fraction */
|
||||
EXIF_SBYTE = 6, /* !8-bit signed integer */
|
||||
EXIF_UNDEFINED = 7, /* !8-bit untyped data */
|
||||
EXIF_SSHORT = 8, /* !16-bit signed integer */
|
||||
EXIF_SLONG = 9, /* !32-bit signed integer */
|
||||
EXIF_SRATIONAL = 10, /* !64-bit signed fraction */
|
||||
EXIF_FLOAT = 11, /* !32-bit IEEE floating point */
|
||||
EXIF_DOUBLE = 12 /* !64-bit IEEE floating point */
|
||||
} EXIFDataType;
|
||||
|
||||
|
||||
typedef struct exif_parser {
|
||||
char *header,*data,*ifds[10];
|
||||
int ifdtags[10]; /* How many tags in each ifd */
|
||||
int ifdcnt; /* Number of IFD's, assumed to be < 10 */
|
||||
unsigned int exiflen;
|
||||
int preparsed,endian;
|
||||
} exifparser;
|
||||
|
||||
typedef struct {
|
||||
int tag; // Tag ID, see exif_tags.h
|
||||
EXIFDataType type; // Tag data type, see exif_tags.h
|
||||
int size; // Length of the data, in bytes.
|
||||
char *data; // The data itself, not an offset
|
||||
int num; // When type is (s)rational, we
|
||||
int den; // store the value here...
|
||||
int intval;
|
||||
} ExifData;
|
||||
|
||||
static struct tagarray{
|
||||
int num;
|
||||
char* desc;
|
||||
} tagnames[]=
|
||||
{
|
||||
{0xFE, "NewSubFileType"},
|
||||
{0x100, "ImageWidth"},
|
||||
{0x101, "ImageLength"},
|
||||
{0x102, "BitsPerSample"},
|
||||
{0x103, "Compression"},
|
||||
{0x106, "PhotometricInterpretation"},
|
||||
{0x10A, "FillOrder"},
|
||||
{0x10D, "DocumentName"},
|
||||
{0x10E, "ImageDescription"},
|
||||
{0x10F, "Make"},
|
||||
{0x110, "Model"},
|
||||
{0x111, "StripOffsets"},
|
||||
{0x112, "Orientation"},
|
||||
{0x115, "SamplesPerPixel"},
|
||||
{0x116, "RowsPerStrip"},
|
||||
{0x117, "StripByteCounts"},
|
||||
{0x11A, "XResolution"},
|
||||
{0x11B, "YResolution"},
|
||||
{0x11C, "PlanarConfiguration"},
|
||||
{0x128, "ResolutionUnit"},
|
||||
{0x12D, "TransferFunction"},
|
||||
{0x131, "Software"},
|
||||
{0x132, "DateTime"},
|
||||
{0x13B, "Artist"},
|
||||
{0x13E, "WhitePoint"},
|
||||
{0x13F, "PrimaryChromaticities"},
|
||||
{0x156, "TransferRange"},
|
||||
{0x200, "JPEGProc"},
|
||||
{0x201, "JPEGInterchangeFormat"},
|
||||
{0x202, "JPEGInterchangeFormatLength"},
|
||||
{0x211, "YCbCrCoefficients"},
|
||||
{0x212, "YCbCrSubSampling"},
|
||||
{0x213, "YCbCrPositioning"},
|
||||
{0x214, "ReferenceBlackWhite"},
|
||||
{0x828D, "CFARepeatPatternDim"},
|
||||
{0x828E, "CFAPattern"},
|
||||
{0x828F, "BatteryLevel"},
|
||||
{0x8298, "Copyright"},
|
||||
{0x829A, "ExposureTime"},
|
||||
{0x829D, "FNumber"},
|
||||
{0x83BB, "IPTC/NAA"},
|
||||
{0x8769, "ExifOffset"},
|
||||
{0x8773, "InterColorProfile"},
|
||||
{0x8822, "ExposureProgram"},
|
||||
{0x8824, "SpectralSensitivity"},
|
||||
{0x8825, "GPSInfo"},
|
||||
{0x8827, "ISOSpeedRatings"},
|
||||
{0x8828, "OECF"},
|
||||
{0x9000, "ExifVersion"},
|
||||
{0x9003, "DateTimeOriginal"},
|
||||
{0x9004, "DateTimeDigitized"},
|
||||
{0x9101, "ComponentsConfiguration"},
|
||||
{0x9102, "CompressedBitsPerPixel"},
|
||||
{0x9201, "ShutterSpeedValue"},
|
||||
{0x9202, "ApertureValue"},
|
||||
{0x9203, "BrightnessValue"},
|
||||
{0x9204, "ExposureBiasValue"},
|
||||
{0x9205, "MaxApertureValue"},
|
||||
{0x9206, "SubjectDistance"},
|
||||
{0x9207, "MeteringMode"},
|
||||
{0x9208, "LightSource"},
|
||||
{0x9209, "Flash"},
|
||||
{0x920A, "FocalLength"},
|
||||
{0x927C, "MakerNote"},
|
||||
{0x9286, "UserComment"},
|
||||
{0x9290, "SubSecTime"},
|
||||
{0x9291, "SubSecTimeOriginal"},
|
||||
{0x9292, "SubSecTimeDigitized"},
|
||||
{0xA000, "FlashPixVersion"},
|
||||
{0xA001, "ColorSpace"},
|
||||
{0xA002, "ExifImageWidth"},
|
||||
{0xA003, "ExifImageLength"},
|
||||
{0xA005, "InteroperabilityOffset"},
|
||||
{0xA20B, "FlashEnergy"},
|
||||
{0xA20C, "SpatialFrequencyResponse"},
|
||||
{0xA20E, "FocalPlaneXResolution"},
|
||||
{0xA20F, "FocalPlaneYResolution"},
|
||||
{0xA210, "FocalPlaneResolutionUnit"},
|
||||
{0xA214, "SubjectLocation"},
|
||||
{0xA215, "ExposureIndex"},
|
||||
{0xA217, "SensingMethod"},
|
||||
{0xA300, "FileSource"},
|
||||
{0xA301, "Scenetype"},
|
||||
{0,"end"}
|
||||
};
|
||||
|
||||
extern int exif_debug; /* Non-zero for debug messages */
|
||||
|
||||
/**
|
||||
* Parse an exif header, return size of the rest of the file.
|
||||
*/
|
||||
int exif_parse_data(exifparser *exifdat);
|
||||
|
||||
/**
|
||||
* Returns the value of a field, identified by its tag and the IFD.
|
||||
*/
|
||||
int exif_get_field( int tag_number, int ifd, exifparser *exifdat, ExifData *tag_data);
|
||||
|
||||
/**
|
||||
* Gets a numeric tag
|
||||
*/
|
||||
int exif_get_int_field( int tag_number, int ifd, exifparser *exifdat);
|
||||
|
||||
/**
|
||||
* Gets an ASCII tag.
|
||||
*/
|
||||
char * exif_get_ascii_field( int tag_number, int ifd, exifparser *exifdat);
|
||||
|
||||
/**
|
||||
* Returns the name of a given tag number
|
||||
*/
|
||||
char *exif_get_tagname(int tag_number);
|
||||
|
||||
/**
|
||||
* Returns a pointer to the thumbnail data if it
|
||||
* exists.
|
||||
*/
|
||||
unsigned char *exif_get_thumbnail(exifparser *exifdat);
|
||||
|
||||
/**
|
||||
* Gets the comment field if it exists.
|
||||
*/
|
||||
int gpe_get_comment(exifparser *exifdat, char *comment);
|
||||
|
||||
/**
|
||||
* Sets the comment field.
|
||||
*/
|
||||
int gpe_set_comment(exifparser *exifdat, char *comment);
|
||||
|
||||
/**************
|
||||
* Now, all the 'defines'
|
||||
*/
|
||||
|
||||
#define EXIF_InteroperabilityIndex 0x1
|
||||
#define EXIF_InteroperabilityVersion 0x2
|
||||
#define EXIF_RelatedImageFileFormat 0x1000
|
||||
#define EXIF_RelatedImageWidth 0x1001
|
||||
#define EXIF_RelatedImageLength 0x1002
|
||||
|
||||
#define EXIF_NewSubFileType 0xFE
|
||||
#define EXIF_ImageWidth 0x100
|
||||
#define EXIF_ImageLength 0x101
|
||||
#define EXIF_BitsPerSample 0x102
|
||||
#define EXIF_Compression 0x103
|
||||
#define EXIF_PhotometricInterpretation 0x106
|
||||
#define EXIF_FillOrder 0x10A
|
||||
#define EXIF_DocumentName 0x10D
|
||||
#define EXIF_ImageDescription 0x10E
|
||||
#define EXIF_Make 0x10F
|
||||
#define EXIF_Model 0x110
|
||||
#define EXIF_StripOffsets 0x111
|
||||
#define EXIF_Orientation 0x112
|
||||
#define EXIF_SamplesPerPixel 0x115
|
||||
#define EXIF_RowsPerStrip 0x116
|
||||
#define EXIF_StripByteCounts 0x117
|
||||
#define EXIF_XResolution 0x11A
|
||||
#define EXIF_YResolution 0x11B
|
||||
#define EXIF_PlanarConfiguration 0x11C
|
||||
#define EXIF_ResolutionUnit 0x128
|
||||
#define EXIF_TransferFunction 0x12D
|
||||
#define EXIF_Software 0x131
|
||||
#define EXIF_DateTime 0x132
|
||||
#define EXIF_Artist 0x13B
|
||||
#define EXIF_WhitePoint 0x13E
|
||||
#define EXIF_PrimaryChromaticities 0x13F
|
||||
#define EXIF_TransferRange 0x156
|
||||
#define EXIF_JPEGProc 0x200
|
||||
#define EXIF_JPEGInterchangeFormat 0x201
|
||||
#define EXIF_JPEGInterchangeFormatLength 0x202
|
||||
#define EXIF_YCbCrCoefficients 0x211
|
||||
#define EXIF_YCbCrSubSampling 0x212
|
||||
#define EXIF_YCbCrPositioning 0x213
|
||||
#define EXIF_ReferenceBlackWhite 0x214
|
||||
#define EXIF_CFARepeatPatternDim 0x828D
|
||||
#define EXIF_CFAPattern 0x828E
|
||||
#define EXIF_BatteryLevel 0x828F
|
||||
#define EXIF_Copyright 0x8298
|
||||
#define EXIF_ExposureTime 0x829A
|
||||
#define EXIF_FNumber 0x829D
|
||||
/* Be careful: the next tag's official name is IPTC/NAA but
|
||||
we can't do a define with a "/" */
|
||||
#define EXIF_IPTC_NAA 0x83BB
|
||||
#define EXIF_ExifOffset 0x8769
|
||||
#define EXIF_InterColorProfile 0x8773
|
||||
#define EXIF_ExposureProgram 0x8822
|
||||
#define EXIF_SpectralSensitivity 0x8824
|
||||
#define EXIF_GPSInfo 0x8825
|
||||
#define EXIF_ISOSpeedRatings 0x8827
|
||||
#define EXIF_OECF 0x8828
|
||||
#define EXIF_ExifVersion 0x9000
|
||||
#define EXIF_DateTimeOriginal 0x9003
|
||||
#define EXIF_DateTimeDigitized 0x9004
|
||||
#define EXIF_ComponentsConfiguration 0x9101
|
||||
#define EXIF_CompressedBitsPerPixel 0x9102
|
||||
#define EXIF_ShutterSpeedValue 0x9201
|
||||
#define EXIF_ApertureValue 0x9202
|
||||
#define EXIF_BrightnessValue 0x9203
|
||||
#define EXIF_ExposureBiasValue 0x9204
|
||||
#define EXIF_MaxApertureValue 0x9205
|
||||
#define EXIF_SubjectDistance 0x9206
|
||||
#define EXIF_MeteringMode 0x9207
|
||||
#define EXIF_LightSource 0x9208
|
||||
#define EXIF_Flash 0x9209
|
||||
#define EXIF_FocalLength 0x920A
|
||||
#define EXIF_MakerNote 0x927C
|
||||
#define EXIF_UserComment 0x9286
|
||||
#define EXIF_SubSecTime 0x9290
|
||||
#define EXIF_SubSecTimeOriginal 0x9291
|
||||
#define EXIF_SubSecTimeDigitized 0x9292
|
||||
#define EXIF_FlashPixVersion 0xA000
|
||||
#define EXIF_ColorSpace 0xA001
|
||||
#define EXIF_ExifImageWidth 0xA002
|
||||
#define EXIF_ExifImageLength 0xA003
|
||||
#define EXIF_InteroperabilityOffset 0xA005
|
||||
#define EXIF_FlashEnergy 0xA20B # 0x920B in TIFF/EP
|
||||
#define EXIF_SpatialFrequencyResponse 0xA20C # 0x920C - -
|
||||
#define EXIF_FocalPlaneXResolution 0xA20E # 0x920E - -
|
||||
#define EXIF_FocalPlaneYResolution 0xA20F # 0x920F - -
|
||||
#define EXIF_FocalPlaneResolutionUnit 0xA210 # 0x9210 - -
|
||||
#define EXIF_SubjectLocation 0xA214 # 0x9214 - -
|
||||
#define EXIF_ExposureIndex 0xA215 # 0x9215 - -
|
||||
#define EXIF_SensingMethod 0xA217 # 0x9217 - -
|
||||
#define EXIF_FileSource 0xA300
|
||||
#define EXIF_SceneType 0xA301
|
||||
|
||||
#endif /* _gphoto_exif_ */
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user