mirror of
https://github.com/subsurface/subsurface.git
synced 2025-02-19 22:16:15 +00:00
Break picture handling code from C++ to C.
This commit breaks the loading of images that were done in the divelist into smaller bits. A bit of code refactor was done in order to correct the placement of a few methods. ShiftTimesDialog::EpochFromExiv got moved to Exif::epoch dive_add_picture is now used instead of add_event picture_load_exif_data got implemented using the old listview code. dive_set_geodata_from_picture got implemented using the old listview code. Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
This commit is contained in:
Tomaz Canabrava
Dirk Hohndel
parent
13e8aba7da
commit
d95d1735b5
9 changed files with 87 additions and 70 deletions
587
exif.cpp
Normal file
587
exif.cpp
Normal file
|
|
@ -0,0 +1,587 @@
|
|||
#include <stdio.h>
|
||||
/**************************************************************************
|
||||
exif.cpp -- A simple ISO C++ library to parse basic EXIF
|
||||
information from a JPEG file.
|
||||
|
||||
Copyright (c) 2010-2013 Mayank Lahiri
|
||||
mlahiri@gmail.com
|
||||
All rights reserved (BSD License).
|
||||
|
||||
See exif.h for version history.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
-- Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
-- Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS
|
||||
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
||||
NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
||||
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <algorithm>
|
||||
#include "dive.h"
|
||||
#include "exif.h"
|
||||
|
||||
using std::string;
|
||||
|
||||
namespace {
|
||||
// IF Entry
|
||||
struct IFEntry {
|
||||
// Raw fields
|
||||
unsigned short tag;
|
||||
unsigned short format;
|
||||
unsigned data;
|
||||
unsigned length;
|
||||
|
||||
// Parsed fields
|
||||
string val_string;
|
||||
unsigned short val_16;
|
||||
unsigned val_32;
|
||||
double val_rational;
|
||||
unsigned char val_byte;
|
||||
};
|
||||
|
||||
// Helper functions
|
||||
unsigned int parse32(const unsigned char *buf, bool intel)
|
||||
{
|
||||
if (intel)
|
||||
return ((unsigned)buf[3] << 24) |
|
||||
((unsigned)buf[2] << 16) |
|
||||
((unsigned)buf[1] << 8) |
|
||||
buf[0];
|
||||
|
||||
return ((unsigned)buf[0] << 24) |
|
||||
((unsigned)buf[1] << 16) |
|
||||
((unsigned)buf[2] << 8) |
|
||||
buf[3];
|
||||
}
|
||||
|
||||
unsigned short parse16(const unsigned char *buf, bool intel)
|
||||
{
|
||||
if (intel)
|
||||
return ((unsigned)buf[1] << 8) | buf[0];
|
||||
return ((unsigned)buf[0] << 8) | buf[1];
|
||||
}
|
||||
|
||||
string parseEXIFString(const unsigned char *buf,
|
||||
const unsigned num_components,
|
||||
const unsigned data,
|
||||
const unsigned base,
|
||||
const unsigned len)
|
||||
{
|
||||
string value;
|
||||
if (num_components <= 4)
|
||||
value.assign((const char *)&data, num_components);
|
||||
else {
|
||||
if (base + data + num_components <= len)
|
||||
value.assign((const char *)(buf + base + data), num_components);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
double parseEXIFRational(const unsigned char *buf, bool intel)
|
||||
{
|
||||
double numerator = 0;
|
||||
double denominator = 1;
|
||||
|
||||
numerator = (double)parse32(buf, intel);
|
||||
denominator = (double)parse32(buf + 4, intel);
|
||||
if (denominator < 1e-20)
|
||||
return 0;
|
||||
return numerator / denominator;
|
||||
}
|
||||
|
||||
IFEntry parseIFEntry(const unsigned char *buf,
|
||||
const unsigned offs,
|
||||
const bool alignIntel,
|
||||
const unsigned base,
|
||||
const unsigned len)
|
||||
{
|
||||
IFEntry result;
|
||||
|
||||
// Each directory entry is composed of:
|
||||
// 2 bytes: tag number (data field)
|
||||
// 2 bytes: data format
|
||||
// 4 bytes: number of components
|
||||
// 4 bytes: data value or offset to data value
|
||||
result.tag = parse16(buf + offs, alignIntel);
|
||||
result.format = parse16(buf + offs + 2, alignIntel);
|
||||
result.length = parse32(buf + offs + 4, alignIntel);
|
||||
result.data = parse32(buf + offs + 8, alignIntel);
|
||||
|
||||
// Parse value in specified format
|
||||
switch (result.format) {
|
||||
case 1:
|
||||
result.val_byte = (unsigned char)*(buf + offs + 8);
|
||||
break;
|
||||
case 2:
|
||||
result.val_string = parseEXIFString(buf, result.length, result.data, base, len);
|
||||
break;
|
||||
case 3:
|
||||
result.val_16 = parse16((const unsigned char *)buf + offs + 8, alignIntel);
|
||||
break;
|
||||
case 4:
|
||||
result.val_32 = result.data;
|
||||
break;
|
||||
case 5:
|
||||
if (base + result.data + 8 <= len)
|
||||
result.val_rational = parseEXIFRational(buf + base + result.data, alignIntel);
|
||||
break;
|
||||
case 7:
|
||||
case 9:
|
||||
case 10:
|
||||
break;
|
||||
default:
|
||||
result.tag = 0xFF;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Locates the EXIF segment and parses it using parseFromEXIFSegment
|
||||
//
|
||||
int EXIFInfo::parseFrom(const unsigned char *buf, unsigned len)
|
||||
{
|
||||
// Sanity check: all JPEG files start with 0xFFD8 and end with 0xFFD9
|
||||
// This check also ensures that the user has supplied a correct value for len.
|
||||
if (!buf || len < 4)
|
||||
return PARSE_EXIF_ERROR_NO_EXIF;
|
||||
if (buf[0] != 0xFF || buf[1] != 0xD8)
|
||||
return PARSE_EXIF_ERROR_NO_JPEG;
|
||||
if (buf[len - 2] != 0xFF || buf[len - 1] != 0xD9)
|
||||
return PARSE_EXIF_ERROR_NO_JPEG;
|
||||
clear();
|
||||
|
||||
// Scan for EXIF header (bytes 0xFF 0xE1) and do a sanity check by
|
||||
// looking for bytes "Exif\0\0". The marker length data is in Motorola
|
||||
// byte order, which results in the 'false' parameter to parse16().
|
||||
// The marker has to contain at least the TIFF header, otherwise the
|
||||
// EXIF data is corrupt. So the minimum length specified here has to be:
|
||||
// 2 bytes: section size
|
||||
// 6 bytes: "Exif\0\0" string
|
||||
// 2 bytes: TIFF header (either "II" or "MM" string)
|
||||
// 2 bytes: TIFF magic (short 0x2a00 in Motorola byte order)
|
||||
// 4 bytes: Offset to first IFD
|
||||
// =========
|
||||
// 16 bytes
|
||||
unsigned offs = 0; // current offset into buffer
|
||||
for (offs = 0; offs < len - 1; offs++)
|
||||
if (buf[offs] == 0xFF && buf[offs + 1] == 0xE1)
|
||||
break;
|
||||
if (offs + 4 > len)
|
||||
return PARSE_EXIF_ERROR_NO_EXIF;
|
||||
offs += 2;
|
||||
unsigned short section_length = parse16(buf + offs, false);
|
||||
if (offs + section_length > len || section_length < 16)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
offs += 2;
|
||||
|
||||
return parseFromEXIFSegment(buf + offs, len - offs);
|
||||
}
|
||||
|
||||
int EXIFInfo::parseFrom(const string &data)
|
||||
{
|
||||
return parseFrom((const unsigned char *)data.data(), data.length());
|
||||
}
|
||||
|
||||
//
|
||||
// Main parsing function for an EXIF segment.
|
||||
//
|
||||
// PARAM: 'buf' start of the EXIF TIFF, which must be the bytes "Exif\0\0".
|
||||
// PARAM: 'len' length of buffer
|
||||
//
|
||||
int EXIFInfo::parseFromEXIFSegment(const unsigned char *buf, unsigned len)
|
||||
{
|
||||
bool alignIntel = true; // byte alignment (defined in EXIF header)
|
||||
unsigned offs = 0; // current offset into buffer
|
||||
if (!buf || len < 6)
|
||||
return PARSE_EXIF_ERROR_NO_EXIF;
|
||||
|
||||
if (!std::equal(buf, buf + 6, "Exif\0\0"))
|
||||
return PARSE_EXIF_ERROR_NO_EXIF;
|
||||
offs += 6;
|
||||
|
||||
// Now parsing the TIFF header. The first two bytes are either "II" or
|
||||
// "MM" for Intel or Motorola byte alignment. Sanity check by parsing
|
||||
// the unsigned short that follows, making sure it equals 0x2a. The
|
||||
// last 4 bytes are an offset into the first IFD, which are added to
|
||||
// the global offset counter. For this block, we expect the following
|
||||
// minimum size:
|
||||
// 2 bytes: 'II' or 'MM'
|
||||
// 2 bytes: 0x002a
|
||||
// 4 bytes: offset to first IDF
|
||||
// -----------------------------
|
||||
// 8 bytes
|
||||
if (offs + 8 > len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
unsigned tiff_header_start = offs;
|
||||
if (buf[offs] == 'I' && buf[offs + 1] == 'I')
|
||||
alignIntel = true;
|
||||
else {
|
||||
if (buf[offs] == 'M' && buf[offs + 1] == 'M')
|
||||
alignIntel = false;
|
||||
else
|
||||
return PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN;
|
||||
}
|
||||
this->ByteAlign = alignIntel;
|
||||
offs += 2;
|
||||
if (0x2a != parse16(buf + offs, alignIntel))
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
offs += 2;
|
||||
unsigned first_ifd_offset = parse32(buf + offs, alignIntel);
|
||||
offs += first_ifd_offset - 4;
|
||||
if (offs >= len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
|
||||
// Now parsing the first Image File Directory (IFD0, for the main image).
|
||||
// An IFD consists of a variable number of 12-byte directory entries. The
|
||||
// first two bytes of the IFD section contain the number of directory
|
||||
// entries in the section. The last 4 bytes of the IFD contain an offset
|
||||
// to the next IFD, which means this IFD must contain exactly 6 + 12 * num
|
||||
// bytes of data.
|
||||
if (offs + 2 > len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
int num_entries = parse16(buf + offs, alignIntel);
|
||||
if (offs + 6 + 12 * num_entries > len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
offs += 2;
|
||||
unsigned exif_sub_ifd_offset = len;
|
||||
unsigned gps_sub_ifd_offset = len;
|
||||
while (--num_entries >= 0) {
|
||||
IFEntry result = parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
|
||||
offs += 12;
|
||||
switch (result.tag) {
|
||||
case 0x102:
|
||||
// Bits per sample
|
||||
if (result.format == 3)
|
||||
this->BitsPerSample = result.val_16;
|
||||
break;
|
||||
|
||||
case 0x10E:
|
||||
// Image description
|
||||
if (result.format == 2)
|
||||
this->ImageDescription = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x10F:
|
||||
// Digicam make
|
||||
if (result.format == 2)
|
||||
this->Make = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x110:
|
||||
// Digicam model
|
||||
if (result.format == 2)
|
||||
this->Model = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x112:
|
||||
// Orientation of image
|
||||
if (result.format == 3)
|
||||
this->Orientation = result.val_16;
|
||||
break;
|
||||
|
||||
case 0x131:
|
||||
// Software used for image
|
||||
if (result.format == 2)
|
||||
this->Software = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x132:
|
||||
// EXIF/TIFF date/time of image modification
|
||||
if (result.format == 2)
|
||||
this->DateTime = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x8298:
|
||||
// Copyright information
|
||||
if (result.format == 2)
|
||||
this->Copyright = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x8825:
|
||||
// GPS IFS offset
|
||||
gps_sub_ifd_offset = tiff_header_start + result.data;
|
||||
break;
|
||||
|
||||
case 0x8769:
|
||||
// EXIF SubIFD offset
|
||||
exif_sub_ifd_offset = tiff_header_start + result.data;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Jump to the EXIF SubIFD if it exists and parse all the information
|
||||
// there. Note that it's possible that the EXIF SubIFD doesn't exist.
|
||||
// The EXIF SubIFD contains most of the interesting information that a
|
||||
// typical user might want.
|
||||
if (exif_sub_ifd_offset + 4 <= len) {
|
||||
offs = exif_sub_ifd_offset;
|
||||
int num_entries = parse16(buf + offs, alignIntel);
|
||||
if (offs + 6 + 12 * num_entries > len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
offs += 2;
|
||||
while (--num_entries >= 0) {
|
||||
IFEntry result = parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
|
||||
switch (result.tag) {
|
||||
case 0x829a:
|
||||
// Exposure time in seconds
|
||||
if (result.format == 5)
|
||||
this->ExposureTime = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x829d:
|
||||
// FNumber
|
||||
if (result.format == 5)
|
||||
this->FNumber = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x8827:
|
||||
// ISO Speed Rating
|
||||
if (result.format == 3)
|
||||
this->ISOSpeedRatings = result.val_16;
|
||||
break;
|
||||
|
||||
case 0x9003:
|
||||
// Original date and time
|
||||
if (result.format == 2)
|
||||
this->DateTimeOriginal = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x9004:
|
||||
// Digitization date and time
|
||||
if (result.format == 2)
|
||||
this->DateTimeDigitized = result.val_string;
|
||||
break;
|
||||
|
||||
case 0x9201:
|
||||
// Shutter speed value
|
||||
if (result.format == 5)
|
||||
this->ShutterSpeedValue = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x9204:
|
||||
// Exposure bias value
|
||||
if (result.format == 5)
|
||||
this->ExposureBiasValue = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x9206:
|
||||
// Subject distance
|
||||
if (result.format == 5)
|
||||
this->SubjectDistance = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x9209:
|
||||
// Flash used
|
||||
if (result.format == 3)
|
||||
this->Flash = result.data ? 1 : 0;
|
||||
break;
|
||||
|
||||
case 0x920a:
|
||||
// Focal length
|
||||
if (result.format == 5)
|
||||
this->FocalLength = result.val_rational;
|
||||
break;
|
||||
|
||||
case 0x9207:
|
||||
// Metering mode
|
||||
if (result.format == 3)
|
||||
this->MeteringMode = result.val_16;
|
||||
break;
|
||||
|
||||
case 0x9291:
|
||||
// Subsecond original time
|
||||
if (result.format == 2)
|
||||
this->SubSecTimeOriginal = result.val_string;
|
||||
break;
|
||||
|
||||
case 0xa002:
|
||||
// EXIF Image width
|
||||
if (result.format == 4)
|
||||
this->ImageWidth = result.val_32;
|
||||
if (result.format == 3)
|
||||
this->ImageWidth = result.val_16;
|
||||
break;
|
||||
|
||||
case 0xa003:
|
||||
// EXIF Image height
|
||||
if (result.format == 4)
|
||||
this->ImageHeight = result.val_32;
|
||||
if (result.format == 3)
|
||||
this->ImageHeight = result.val_16;
|
||||
break;
|
||||
|
||||
case 0xa405:
|
||||
// Focal length in 35mm film
|
||||
if (result.format == 3)
|
||||
this->FocalLengthIn35mm = result.val_16;
|
||||
break;
|
||||
}
|
||||
offs += 12;
|
||||
}
|
||||
}
|
||||
|
||||
// Jump to the GPS SubIFD if it exists and parse all the information
|
||||
// there. Note that it's possible that the GPS SubIFD doesn't exist.
|
||||
if (gps_sub_ifd_offset + 4 <= len) {
|
||||
offs = gps_sub_ifd_offset;
|
||||
int num_entries = parse16(buf + offs, alignIntel);
|
||||
if (offs + 6 + 12 * num_entries > len)
|
||||
return PARSE_EXIF_ERROR_CORRUPT;
|
||||
offs += 2;
|
||||
while (--num_entries >= 0) {
|
||||
unsigned short tag = parse16(buf + offs, alignIntel);
|
||||
unsigned short format = parse16(buf + offs + 2, alignIntel);
|
||||
unsigned length = parse32(buf + offs + 4, alignIntel);
|
||||
unsigned data = parse32(buf + offs + 8, alignIntel);
|
||||
switch (tag) {
|
||||
case 1:
|
||||
// GPS north or south
|
||||
this->GeoLocation.LatComponents.direction = *(buf + offs + 8);
|
||||
if ('S' == this->GeoLocation.LatComponents.direction)
|
||||
this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
// GPS latitude
|
||||
if (format == 5 && length == 3) {
|
||||
this->GeoLocation.LatComponents.degrees =
|
||||
parseEXIFRational(buf + data + tiff_header_start, alignIntel);
|
||||
this->GeoLocation.LatComponents.minutes =
|
||||
parseEXIFRational(buf + data + tiff_header_start + 8, alignIntel);
|
||||
this->GeoLocation.LatComponents.seconds =
|
||||
parseEXIFRational(buf + data + tiff_header_start + 16, alignIntel);
|
||||
this->GeoLocation.Latitude =
|
||||
this->GeoLocation.LatComponents.degrees +
|
||||
this->GeoLocation.LatComponents.minutes / 60 +
|
||||
this->GeoLocation.LatComponents.seconds / 3600;
|
||||
if ('S' == this->GeoLocation.LatComponents.direction)
|
||||
this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
// GPS east or west
|
||||
this->GeoLocation.LonComponents.direction = *(buf + offs + 8);
|
||||
if ('W' == this->GeoLocation.LonComponents.direction)
|
||||
this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
// GPS longitude
|
||||
if (format == 5 && length == 3) {
|
||||
this->GeoLocation.LonComponents.degrees =
|
||||
parseEXIFRational(buf + data + tiff_header_start, alignIntel);
|
||||
this->GeoLocation.LonComponents.minutes =
|
||||
parseEXIFRational(buf + data + tiff_header_start + 8, alignIntel);
|
||||
this->GeoLocation.LonComponents.seconds =
|
||||
parseEXIFRational(buf + data + tiff_header_start + 16, alignIntel);
|
||||
this->GeoLocation.Longitude =
|
||||
this->GeoLocation.LonComponents.degrees +
|
||||
this->GeoLocation.LonComponents.minutes / 60 +
|
||||
this->GeoLocation.LonComponents.seconds / 3600;
|
||||
if ('W' == this->GeoLocation.LonComponents.direction)
|
||||
this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
|
||||
}
|
||||
break;
|
||||
|
||||
case 5:
|
||||
// GPS altitude reference (below or above sea level)
|
||||
this->GeoLocation.AltitudeRef = *(buf + offs + 8);
|
||||
if (1 == this->GeoLocation.AltitudeRef)
|
||||
this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
|
||||
break;
|
||||
|
||||
case 6:
|
||||
// GPS altitude reference
|
||||
if (format == 5) {
|
||||
this->GeoLocation.Altitude =
|
||||
parseEXIFRational(buf + data + tiff_header_start, alignIntel);
|
||||
if (1 == this->GeoLocation.AltitudeRef)
|
||||
this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
|
||||
}
|
||||
break;
|
||||
}
|
||||
offs += 12;
|
||||
}
|
||||
}
|
||||
|
||||
return PARSE_EXIF_SUCCESS;
|
||||
}
|
||||
|
||||
void EXIFInfo::clear()
|
||||
{
|
||||
// Strings
|
||||
ImageDescription.clear();
|
||||
Make.clear();
|
||||
Model.clear();
|
||||
Software.clear();
|
||||
DateTime.clear();
|
||||
DateTimeOriginal.clear();
|
||||
DateTimeDigitized.clear();
|
||||
SubSecTimeOriginal.clear();
|
||||
Copyright.clear();
|
||||
|
||||
// Shorts / unsigned / double
|
||||
ByteAlign = 0;
|
||||
Orientation = 0;
|
||||
|
||||
BitsPerSample = 0;
|
||||
ExposureTime = 0;
|
||||
FNumber = 0;
|
||||
ISOSpeedRatings = 0;
|
||||
ShutterSpeedValue = 0;
|
||||
ExposureBiasValue = 0;
|
||||
SubjectDistance = 0;
|
||||
FocalLength = 0;
|
||||
FocalLengthIn35mm = 0;
|
||||
Flash = 0;
|
||||
MeteringMode = 0;
|
||||
ImageWidth = 0;
|
||||
ImageHeight = 0;
|
||||
|
||||
// Geolocation
|
||||
GeoLocation.Latitude = 0;
|
||||
GeoLocation.Longitude = 0;
|
||||
GeoLocation.Altitude = 0;
|
||||
GeoLocation.AltitudeRef = 0;
|
||||
GeoLocation.LatComponents.degrees = 0;
|
||||
GeoLocation.LatComponents.minutes = 0;
|
||||
GeoLocation.LatComponents.seconds = 0;
|
||||
GeoLocation.LatComponents.direction = 0;
|
||||
GeoLocation.LonComponents.degrees = 0;
|
||||
GeoLocation.LonComponents.minutes = 0;
|
||||
GeoLocation.LonComponents.seconds = 0;
|
||||
GeoLocation.LonComponents.direction = 0;
|
||||
}
|
||||
|
||||
time_t EXIFInfo::epoch()
|
||||
{
|
||||
struct tm tm;
|
||||
int year, month, day, hour, min, sec;
|
||||
|
||||
if (DateTimeOriginal.size())
|
||||
sscanf(DateTimeOriginal.c_str(), "%d:%d:%d %d:%d:%d", &year, &month, &day, &hour, &min, &sec);
|
||||
else
|
||||
sscanf(DateTime.c_str(), "%d:%d:%d %d:%d:%d", &year, &month, &day, &hour, &min, &sec);
|
||||
tm.tm_year = year;
|
||||
tm.tm_mon = month - 1;
|
||||
tm.tm_mday = day;
|
||||
tm.tm_hour = hour;
|
||||
tm.tm_min = min;
|
||||
tm.tm_sec = sec;
|
||||
return (utc_mktime(&tm));
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue