static void entry_getdata_aux (lua_State *L, ExifEntry *entry, unsigned int n) {
ExifFormat format = entry->format;
size_t formatsize = (size_t)exif_format_get_size(format);
const unsigned char *ptr = entry->data+formatsize*n;
ExifByteOrder order = exif_data_get_byte_order(entry->parent->parent);
switch (format) {
case EXIF_FORMAT_BYTE: lua_pushinteger(L, (ExifByte)*ptr); break;
case EXIF_FORMAT_SBYTE: lua_pushinteger(L, (ExifSByte)*ptr); break;
case EXIF_FORMAT_SHORT: lua_pushinteger(L, exif_get_short(ptr, order)); break;
case EXIF_FORMAT_SSHORT: lua_pushinteger(L, exif_get_sshort(ptr, order)); break;
case EXIF_FORMAT_LONG: lua_pushnumber(L, exif_get_long(ptr, order)); break;
case EXIF_FORMAT_SLONG: lua_pushinteger(L, exif_get_slong(ptr, order)); break;
case EXIF_FORMAT_RATIONAL: {
ExifRational rat = exif_get_rational(ptr, order);
pushrational(L, rat.numerator, rat.denominator);
break;
}
case EXIF_FORMAT_SRATIONAL: {
ExifSRational rat = exif_get_srational(ptr, order);
pushrational(L, rat.numerator, rat.denominator);
break;
}
case EXIF_FORMAT_ASCII: lua_pushinteger(L, *ptr); break;
default:
lua_pushnil(L);
break;
}
}
qint64 ImageSlideInfo::readExifIntValue(ExifData* pExifData, ExifTag exifTag)
{
qint64 exifValue = 0;
if (!pExifData)
return exifValue;
ExifByteOrder exifByteOrder = exif_data_get_byte_order(pExifData);
ExifEntry* pExifEntry = exif_data_get_entry(pExifData, exifTag);
if (pExifEntry) {
// paranoic a bit
if (pExifEntry->size <= sizeof(qint64)) {
if (pExifEntry->format == EXIF_FORMAT_SBYTE)
exifValue = static_cast<qint64>(*pExifEntry->data);
if (pExifEntry->format == EXIF_FORMAT_SSHORT)
exifValue = static_cast<qint64>(exif_get_sshort(pExifEntry->data, exifByteOrder));
if (pExifEntry->format == EXIF_FORMAT_SLONG)
exifValue = static_cast<qint64>(exif_get_slong(pExifEntry->data, exifByteOrder));
}
}
return exifValue;
}
static double exifDouble(ExifEntry *entry, ExifByteOrder byte_order) {
switch (entry->format) {
case EXIF_FORMAT_BYTE:
return double(entry->data[0]);
case EXIF_FORMAT_SHORT:
return double(exif_get_short(entry->data, byte_order));
case EXIF_FORMAT_LONG:
return double(exif_get_long(entry->data, byte_order));
case EXIF_FORMAT_RATIONAL: {
ExifRational r = exif_get_rational(entry->data, byte_order);
return double(r.numerator)/double(r.denominator);
}
case EXIF_FORMAT_SBYTE:
return double(*(signed char *)entry->data);
case EXIF_FORMAT_SSHORT:
return double(exif_get_sshort(entry->data, byte_order));
case EXIF_FORMAT_SLONG:
return double(exif_get_slong(entry->data, byte_order));
case EXIF_FORMAT_SRATIONAL: {
ExifSRational r = exif_get_srational(entry->data, byte_order);
return double(r.numerator)/double(r.denominator);
}
case EXIF_FORMAT_FLOAT:
return double(((float *)entry->data)[0]);
case EXIF_FORMAT_DOUBLE:
return ((double *)entry->data)[0];
default:
return nan(0);
}
}
static int getDouble(ExifData *ed, ExifByteOrder bo, ExifTag t, double *d) {
ExifEntry * e = exif_data_get_entry(ed, t);
if (!e)
return 0;
char *b = e->data;
switch (e->format) {
case EXIF_FORMAT_SHORT:
*d = (double) exif_get_short(b, bo);
return 1;
case EXIF_FORMAT_SSHORT:
*d = (double) exif_get_sshort(b, bo);
return 1;
case EXIF_FORMAT_LONG:
*d = (double) exif_get_long(b, bo);
return 1;
case EXIF_FORMAT_SLONG:
*d = (double) exif_get_slong(b, bo);
return 1;
case EXIF_FORMAT_RATIONAL:
{
ExifRational r = exif_get_rational(b, bo);
*d = (double) r.numerator / (double) r.denominator;
return 1;
}
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational r = exif_get_srational(b, bo);
*d = (double) r.numerator / (double) r.denominator;
return 1;
}
default:
return 0;
}
}
static long get_int(ExifData *ed, ExifEntry *ee)
{
ExifByteOrder o = exif_data_get_byte_order(ed);
long value;
switch (ee->format) {
case EXIF_FORMAT_SHORT:
value = exif_get_short (ee->data, o);
break;
case EXIF_FORMAT_LONG:
value = exif_get_long (ee->data, o);
break;
case EXIF_FORMAT_SLONG:
value = exif_get_slong (ee->data, o);
break;
default:
fprintf(stderr,"get_int oops\n");
exit(1);
}
return value;
}
static int
vips_exif_get_int( ExifData *ed,
ExifEntry *entry, unsigned long component, int *out )
{
ExifByteOrder bo = exif_data_get_byte_order( ed );
size_t sizeof_component = entry->size / entry->components;
size_t offset = component * sizeof_component;
if( entry->format == EXIF_FORMAT_SHORT )
*out = exif_get_short( entry->data + offset, bo );
else if( entry->format == EXIF_FORMAT_SSHORT )
*out = exif_get_sshort( entry->data + offset, bo );
else if( entry->format == EXIF_FORMAT_LONG )
/* This won't work for huge values, but who cares.
*/
*out = (int) exif_get_long( entry->data + offset, bo );
else if( entry->format == EXIF_FORMAT_SLONG )
*out = exif_get_slong( entry->data + offset, bo );
else
return( -1 );
return( 0 );
}
void imFileFormatJPEG::iReadExifAttrib(unsigned char* data, int data_length, imAttribTable* attrib_table)
{
ExifData* exif = exif_data_new_from_data(data, data_length);
if (!exif)
return;
void* value = NULL;
int c, value_size = 0;
ExifByteOrder byte_order = exif_data_get_byte_order(exif);
for (int ifd = 0; ifd < EXIF_IFD_COUNT; ifd++)
{
if (ifd == EXIF_IFD_1 || ifd == EXIF_IFD_INTEROPERABILITY) // Skip thumbnail and interoperability
continue;
ExifContent *content = exif->ifd[ifd];
if (content && content->count)
{
for (int j = 0; j < (int)content->count; j++)
{
ExifEntry *entry = content->entries[j];
int type = 0;
const char* name = exif_tag_get_name_in_ifd(entry->tag, (ExifIfd)ifd);
if (!name)
continue;
if (value_size < (int)entry->size)
{
value = realloc(value, entry->size);
value_size = entry->size;
}
int format_size = exif_format_get_size(entry->format);
if (entry->tag == EXIF_TAG_RESOLUTION_UNIT)
{
int res_unit = (int)exif_get_short (entry->data, byte_order);
if (res_unit == 2)
attrib_table->Set("ResolutionUnit", IM_BYTE, -1, "DPI");
else if (res_unit == 3)
attrib_table->Set("ResolutionUnit", IM_BYTE, -1, "DPC");
continue;
}
switch (entry->format)
{
case EXIF_FORMAT_UNDEFINED:
case EXIF_FORMAT_ASCII:
case EXIF_FORMAT_SBYTE:
case EXIF_FORMAT_BYTE:
{
type = IM_BYTE;
imbyte *bvalue = (imbyte*)value;
for (c = 0; c < (int)entry->components; c++)
bvalue[c] = entry->data[c];
}
break;
case EXIF_FORMAT_SSHORT:
{
type = IM_SHORT;
short *svalue = (short*)value;
for (c = 0; c < (int)entry->components; c++)
svalue[c] = exif_get_short(entry->data + format_size * c, byte_order);
}
break;
case EXIF_FORMAT_SHORT:
{
type = IM_USHORT;
imushort *usvalue = (imushort*)value;
for (c = 0; c < (int)entry->components; c++)
usvalue[c] = exif_get_short(entry->data + format_size * c, byte_order);
}
break;
case EXIF_FORMAT_LONG:
{
type = IM_INT;
int *ivalue = (int*)value;
for (c = 0; c < (int)entry->components; c++)
ivalue[c] = (int)exif_get_long(entry->data + format_size * c, byte_order);
}
break;
case EXIF_FORMAT_SLONG:
{
type = IM_INT;
int *ivalue = (int*)value;
for (c = 0; c < (int)entry->components; c++)
ivalue[c] = (int)exif_get_slong(entry->data + format_size * c, byte_order);
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational v_rat;
type = IM_FLOAT;
float *fvalue = (float*)value;
for (c = 0; c < (int)entry->components; c++)
{
v_rat = exif_get_rational(entry->data + format_size * c, byte_order);
fvalue[c] = (float)v_rat.numerator / (float)v_rat.denominator;
}
}
break;
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational v_srat;
type = IM_FLOAT;
float *fvalue = (float*)value;
for (c = 0; c < (int)entry->components; c++)
{
v_srat = exif_get_srational(entry->data + format_size * c, byte_order);
fvalue[c] = (float)v_srat.numerator / (float)v_srat.denominator;
}
}
break;
case EXIF_FORMAT_FLOAT: // defined but unsupported in libEXIF
case EXIF_FORMAT_DOUBLE: // defined but unsupported in libEXIF
break;
}
attrib_table->Set(name, type, entry->components, value);
}
}
}
if (value) free(value);
exif_data_free(exif);
}
static void foreach_exif_entry( ExifEntry * entry , void * _closure )
{
if ( ! entry )
{
return;
}
//.........................................................................
// Bail out of types we don't handle
switch( entry->format )
{
case EXIF_FORMAT_UNDEFINED:
case EXIF_FORMAT_FLOAT:
case EXIF_FORMAT_DOUBLE:
return;
default:
break;
}
//.........................................................................
unsigned char component_size = exif_format_get_size( entry->format );
ExifIfd ifd = exif_content_get_ifd( entry->parent );
const char * tag_name = exif_tag_get_name_in_ifd( entry->tag , ifd );
if ( ! tag_name || ! entry->data || ! entry->size || ! component_size || ! entry->components )
{
return;
}
//.........................................................................
// Add a prefix based on the IFD
String name( tag_name );
switch( ifd )
{
case EXIF_IFD_0:
name = "IMAGE/" + name;
break;
case EXIF_IFD_1:
name = "THUMBNAIL/" + name;
break;
case EXIF_IFD_EXIF:
name = "EXIF/" + name;
break;
case EXIF_IFD_GPS:
name = "GPS/" + name;
break;
case EXIF_IFD_INTEROPERABILITY:
name = "INTEROP/" + name;
break;
default:
return;
}
ExifClosure * closure = ( ExifClosure * ) _closure;
JSON::Object * tags = closure->tags;
//.........................................................................
// ASCII ones are easy
if ( entry->format == EXIF_FORMAT_ASCII )
{
(*tags)[ name ] = String( ( const char * ) entry->data , entry->size );
return;
}
//.........................................................................
if ( ( entry->components * component_size ) != entry->size )
{
return;
}
ExifByteOrder byte_order = exif_data_get_byte_order( closure->exif_data );
const unsigned char * data = entry->data;
JSON::Array array;
for ( unsigned long i = 0; i < entry->components; ++i )
{
switch( entry->format )
{
case EXIF_FORMAT_BYTE:
array.append( JSON::Value( int( * data ) ) );
break;
case EXIF_FORMAT_SHORT:
array.append( JSON::Value( int( exif_get_short( data , byte_order ) ) ) );
break;
case EXIF_FORMAT_LONG:
array.append( JSON::Value( int( exif_get_long( data , byte_order ) ) ) );
break;
case EXIF_FORMAT_SBYTE:
array.append( JSON::Value( int( * ( ( const char * ) data ) ) ) );
break;
case EXIF_FORMAT_SSHORT:
array.append( JSON::Value( exif_get_sshort( data , byte_order ) ) );
break;
case EXIF_FORMAT_SLONG:
array.append( JSON::Value( exif_get_slong( data , byte_order ) ) );
break;
// TODO: I don't like representing a rational number as a string with a slash,
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational r = exif_get_srational( data , byte_order );
array.append( Util::format("%ld/%ld" , r.numerator , r.denominator ) );
break;
}
case EXIF_FORMAT_RATIONAL:
{
ExifRational r = exif_get_rational( data , byte_order );
array.append( Util::format("%lu/%lu" , r.numerator , r.denominator ) );
break;
}
default:
break;
}
data += component_size;
}
if ( array.size() == 1 )
{
(*tags)[ name ] = array[ 0 ];
}
else if ( array.size() > 1 )
{
(*tags)[ name ] = array;
}
}
