Google Git
Sign in
android / platform / external / dng_sdk / 0a764eee483f07ec2b8d789caba05367d7615d1d / . / source / dng_date_time.cpp
blob: bede131ec60971c74fe5f0287405246321457b58 [file] [log] [blame]
/*****************************************************************************/
// Copyright 2006-2008 Adobe Systems Incorporated
// All Rights Reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in
// accordance with the terms of the Adobe license agreement accompanying it.
/*****************************************************************************/
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_date_time.cpp#2 $ */
/* $DateTime: 2012/06/01 07:28:57 $ */
/* $Change: 832715 $ */
/* $Author: tknoll $ */
/*****************************************************************************/
#include "dng_date_time.h"
#include "dng_exceptions.h"
#include "dng_mutex.h"
#include "dng_stream.h"
#include "dng_string.h"
#include "dng_utils.h"
#include <time.h>
#if qMacOS
#include <TargetConditionals.h>
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#include <MobileCoreServices/MobileCoreServices.h>
#else
#include <CoreServices/CoreServices.h>
#endif // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
#endif // qMacOS
#if qWinOS
#include <windows.h>
#endif
/******************************************************************************/
// MWG says don't use fake time zones in XMP, but there is some
// old software that requires them to work correctly.
bool gDNGUseFakeTimeZonesInXMP = false;
/******************************************************************************/
dng_date_time::dng_date_time ()
: fYear (0)
, fMonth (0)
, fDay (0)
, fHour (0)
, fMinute (0)
, fSecond (0)
{
}
/******************************************************************************/
dng_date_time::dng_date_time (uint32 year,
uint32 month,
uint32 day,
uint32 hour,
uint32 minute,
uint32 second)
: fYear (year)
, fMonth (month)
, fDay (day)
, fHour (hour)
, fMinute (minute)
, fSecond (second)
{
}
/******************************************************************************/
bool dng_date_time::IsValid () const
{
return fYear >= 1 && fYear <= 9999 &&
fMonth >= 1 && fMonth <= 12 &&
fDay >= 1 && fDay <= 31 &&
fHour <= 23 &&
fMinute <= 59 &&
fSecond <= 59;
}
/*****************************************************************************/
void dng_date_time::Clear ()
{
*this = dng_date_time ();
}
/*****************************************************************************/
static uint32 DateTimeParseU32 (const char *&s)
{
uint32 x = 0;
while (*s == ' ' || *s == ':')
s++;
while (*s >= '0' && *s <= '9')
{
x = SafeUint32Mult(x, 10);
x = SafeUint32Add(x, (uint32) (*(s++) - '0'));
}
return x;
}
/*****************************************************************************/
bool dng_date_time::Parse (const char *s)
{
fYear = DateTimeParseU32 (s);
fMonth = DateTimeParseU32 (s);
fDay = DateTimeParseU32 (s);
fHour = DateTimeParseU32 (s);
fMinute = DateTimeParseU32 (s);
fSecond = DateTimeParseU32 (s);
return IsValid ();
}
/*****************************************************************************/
dng_string dng_time_zone::Encode_ISO_8601 () const
{
dng_string result;
if (IsValid ())
{
if (OffsetMinutes () == 0)
{
result.Set ("Z");
}
else
{
char s [64];
int offset = OffsetMinutes ();
if (offset > 0)
{
sprintf (s, "+%02d:%02d", offset / 60, offset % 60);
}
else
{
offset = -offset;
sprintf (s, "-%02d:%02d", offset / 60, offset % 60);
}
result.Set (s);
}
}
return result;
}
/*****************************************************************************/
dng_date_time_info::dng_date_time_info ()
: fDateOnly (true)
, fDateTime ()
, fSubseconds ()
, fTimeZone ()
{
}
/*****************************************************************************/
bool dng_date_time_info::IsValid () const
{
return fDateTime.IsValid ();
}
/*****************************************************************************/
void dng_date_time_info::SetDate (uint32 year,
uint32 month,
uint32 day)
{
fDateTime.fYear = year;
fDateTime.fMonth = month;
fDateTime.fDay = day;
}
/*****************************************************************************/
void dng_date_time_info::SetTime (uint32 hour,
uint32 minute,
uint32 second)
{
fDateOnly = false;
fDateTime.fHour = hour;
fDateTime.fMinute = minute;
fDateTime.fSecond = second;
}
/*****************************************************************************/
void dng_date_time_info::Decode_ISO_8601 (const char *s)
{
Clear ();
uint32 len = (uint32) strlen (s);
if (!len)
{
return;
}
unsigned year = 0;
unsigned month = 0;
unsigned day = 0;
if (sscanf (s,
"%u-%u-%u",
&year,
&month,
&day) != 3)
{
return;
}
SetDate ((uint32) year,
(uint32) month,
(uint32) day);
if (fDateTime.NotValid ())
{
Clear ();
return;
}
for (uint32 j = 0; j < len; j++)
{
if (s [j] == 'T')
{
unsigned hour = 0;
unsigned minute = 0;
unsigned second = 0;
int items = sscanf (s + j + 1,
"%u:%u:%u",
&hour,
&minute,
&second);
if (items >= 2 && items <= 3)
{
SetTime ((uint32) hour,
(uint32) minute,
(uint32) second);
if (fDateTime.NotValid ())
{
Clear ();
return;
}
if (items == 3)
{
for (uint32 k = j + 1; k < len; k++)
{
if (s [k] == '.')
{
while (++k < len && s [k] >= '0' && s [k] <= '9')
{
char ss [2];
ss [0] = s [k];
ss [1] = 0;
fSubseconds.Append (ss);
}
break;
}
}
}
for (uint32 k = j + 1; k < len; k++)
{
if (s [k] == 'Z')
{
fTimeZone.SetOffsetMinutes (0);
break;
}
if (s [k] == '+' || s [k] == '-')
{
int32 sign = (s [k] == '-' ? -1 : 1);
unsigned tzhour = 0;
unsigned tzmin = 0;
if (sscanf (s + k + 1,
"%u:%u",
&tzhour,
&tzmin) > 0)
{
fTimeZone.SetOffsetMinutes (sign * (tzhour * 60 + tzmin));
}
break;
}
}
}
break;
}
}
}
/*****************************************************************************/
dng_string dng_date_time_info::Encode_ISO_8601 () const
{
dng_string result;
if (IsValid ())
{
char s [256];
sprintf (s,
"%04u-%02u-%02u",
(unsigned) fDateTime.fYear,
(unsigned) fDateTime.fMonth,
(unsigned) fDateTime.fDay);
result.Set (s);
if (!fDateOnly)
{
sprintf (s,
"T%02u:%02u:%02u",
(unsigned) fDateTime.fHour,
(unsigned) fDateTime.fMinute,
(unsigned) fDateTime.fSecond);
result.Append (s);
if (fSubseconds.NotEmpty ())
{
bool subsecondsValid = true;
uint32 len = fSubseconds.Length ();
for (uint32 index = 0; index < len; index++)
{
if (fSubseconds.Get () [index] < '0' ||
fSubseconds.Get () [index] > '9')
{
subsecondsValid = false;
break;
}
}
if (subsecondsValid)
{
result.Append (".");
result.Append (fSubseconds.Get ());
}
}
if (gDNGUseFakeTimeZonesInXMP)
{
// Kludge: Early versions of the XMP toolkit assume Zulu time
// if the time zone is missing. It is safer for fill in the
// local time zone.
dng_time_zone tempZone = fTimeZone;
if (tempZone.NotValid ())
{
tempZone = LocalTimeZone (fDateTime);
}
result.Append (tempZone.Encode_ISO_8601 ().Get ());
}
else
{
// MWG: Now we don't fill in the local time zone. So only
// add the time zone if it is known and valid.
if (fTimeZone.IsValid ())
{
result.Append (fTimeZone.Encode_ISO_8601 ().Get ());
}
}
}
}
return result;
}
/*****************************************************************************/
void dng_date_time_info::Decode_IPTC_Date (const char *s)
{
if (strlen (s) == 8)
{
unsigned year = 0;
unsigned month = 0;
unsigned day = 0;
if (sscanf (s,
"%4u%2u%2u",
&year,
&month,
&day) == 3)
{
SetDate ((uint32) year,
(uint32) month,
(uint32) day);
}
}
}
/*****************************************************************************/
dng_string dng_date_time_info::Encode_IPTC_Date () const
{
dng_string result;
if (IsValid ())
{
char s [64];
sprintf (s,
"%04u%02u%02u",
(unsigned) fDateTime.fYear,
(unsigned) fDateTime.fMonth,
(unsigned) fDateTime.fDay);
result.Set (s);
}
return result;
}
/*****************************************************************************/
void dng_date_time_info::Decode_IPTC_Time (const char *s)
{
if (strlen (s) == 11)
{
char time [12];
memcpy (time, s, sizeof (time));
if (time [6] == '+' ||
time [6] == '-')
{
int tzsign = (time [6] == '-') ? -1 : 1;
time [6] = 0;
unsigned hour = 0;
unsigned minute = 0;
unsigned second = 0;
unsigned tzhour = 0;
unsigned tzmin = 0;
if (sscanf (time,
"%2u%2u%2u",
&hour,
&minute,
&second) == 3 &&
sscanf (time + 7,
"%2u%2u",
&tzhour,
&tzmin) == 2)
{
dng_time_zone zone;
zone.SetOffsetMinutes (tzsign * (tzhour * 60 + tzmin));
if (zone.IsValid ())
{
SetTime ((uint32) hour,
(uint32) minute,
(uint32) second);
SetZone (zone);
}
}
}
}
else if (strlen (s) == 6)
{
unsigned hour = 0;
unsigned minute = 0;
unsigned second = 0;
if (sscanf (s,
"%2u%2u%2u",
&hour,
&minute,
&second) == 3)
{
SetTime ((uint32) hour,
(uint32) minute,
(uint32) second);
}
}
else if (strlen (s) == 4)
{
unsigned hour = 0;
unsigned minute = 0;
if (sscanf (s,
"%2u%2u",
&hour,
&minute) == 2)
{
SetTime ((uint32) hour,
(uint32) minute,
0);
}
}
}
/*****************************************************************************/
dng_string dng_date_time_info::Encode_IPTC_Time () const
{
dng_string result;
if (IsValid () && !fDateOnly)
{
char s [64];
if (fTimeZone.IsValid ())
{
sprintf (s,
"%02u%02u%02u%c%02u%02u",
(unsigned) fDateTime.fHour,
(unsigned) fDateTime.fMinute,
(unsigned) fDateTime.fSecond,
(int) (fTimeZone.OffsetMinutes () >= 0 ? '+' : '-'),
(unsigned) (Abs_int32 (fTimeZone.OffsetMinutes ()) / 60),
(unsigned) (Abs_int32 (fTimeZone.OffsetMinutes ()) % 60));
}
else
{
sprintf (s,
"%02u%02u%02u",
(unsigned) fDateTime.fHour,
(unsigned) fDateTime.fMinute,
(unsigned) fDateTime.fSecond);
}
result.Set (s);
}
return result;
}
/*****************************************************************************/
static dng_mutex gDateTimeMutex ("gDateTimeMutex");
/*****************************************************************************/
void CurrentDateTimeAndZone (dng_date_time_info &info)
{
time_t sec;
time (&sec);
tm t;
tm zt;
{
dng_lock_mutex lock (&gDateTimeMutex);
t = *localtime (&sec);
zt = *gmtime (&sec);
}
dng_date_time dt;
dt.fYear = t.tm_year + 1900;
dt.fMonth = t.tm_mon + 1;
dt.fDay = t.tm_mday;
dt.fHour = t.tm_hour;
dt.fMinute = t.tm_min;
dt.fSecond = t.tm_sec;
info.SetDateTime (dt);
int tzHour = t.tm_hour - zt.tm_hour;
int tzMin = t.tm_min - zt.tm_min;
bool zonePositive = (t.tm_year > zt.tm_year) ||
(t.tm_year == zt.tm_year && t.tm_yday > zt.tm_yday) ||
(t.tm_year == zt.tm_year && t.tm_yday == zt.tm_yday && tzHour > 0) ||
(t.tm_year == zt.tm_year && t.tm_yday == zt.tm_yday && tzHour == 0 && tzMin >= 0);
tzMin += tzHour * 60;
if (zonePositive)
{
while (tzMin < 0)
tzMin += 24 * 60;
}
else
{
while (tzMin > 0)
tzMin -= 24 * 60;
}
dng_time_zone zone;
zone.SetOffsetMinutes (tzMin);
info.SetZone (zone);
}
/*****************************************************************************/
void DecodeUnixTime (uint32 unixTime, dng_date_time &dt)
{
time_t sec = (time_t) unixTime;
tm t;
{
dng_lock_mutex lock (&gDateTimeMutex);
#if qMacOS && !defined(__MACH__)
// Macintosh CFM stores time in local time zone.
tm *tp = localtime (&sec);
#else
// Macintosh Mach-O and Windows stores time in Zulu time.
tm *tp = gmtime (&sec);
#endif
if (!tp)
{
dt.Clear ();
return;
}
t = *tp;
}
dt.fYear = t.tm_year + 1900;
dt.fMonth = t.tm_mon + 1;
dt.fDay = t.tm_mday;
dt.fHour = t.tm_hour;
dt.fMinute = t.tm_min;
dt.fSecond = t.tm_sec;
}
/*****************************************************************************/
dng_time_zone LocalTimeZone (const dng_date_time &dt)
{
dng_time_zone result;
if (dt.IsValid ())
{
#if qMacOS
CFTimeZoneRef zoneRef = CFTimeZoneCopyDefault ();
if (zoneRef)
{
CFGregorianDate gregDate;
gregDate.year = dt.fYear;
gregDate.month = (SInt8) dt.fMonth;
gregDate.day = (SInt8) dt.fDay;
gregDate.hour = (SInt8) dt.fHour;
gregDate.minute = (SInt8) dt.fMinute;
gregDate.second = (SInt8) dt.fSecond;
CFAbsoluteTime absTime = CFGregorianDateGetAbsoluteTime (gregDate, zoneRef);
CFTimeInterval secondsDelta = CFTimeZoneGetSecondsFromGMT (zoneRef, absTime);
CFRelease (zoneRef);
result.SetOffsetSeconds (Round_int32 (secondsDelta));
if (result.IsValid ())
{
return result;
}
}
#endif
#if qWinOS
if (GetTimeZoneInformation != NULL &&
SystemTimeToTzSpecificLocalTime != NULL &&
SystemTimeToFileTime != NULL)
{
TIME_ZONE_INFORMATION tzInfo;
DWORD x = GetTimeZoneInformation (&tzInfo);
SYSTEMTIME localST;
memset (&localST, 0, sizeof (localST));
localST.wYear = (WORD) dt.fYear;
localST.wMonth = (WORD) dt.fMonth;
localST.wDay = (WORD) dt.fDay;
localST.wHour = (WORD) dt.fHour;
localST.wMinute = (WORD) dt.fMinute;
localST.wSecond = (WORD) dt.fSecond;
SYSTEMTIME utcST;
if (TzSpecificLocalTimeToSystemTime (&tzInfo, &localST, &utcST))
{
FILETIME localFT;
FILETIME utcFT;
(void) SystemTimeToFileTime (&localST, &localFT);
(void) SystemTimeToFileTime (&utcST , &utcFT );
uint64 time1 = (((uint64) localFT.dwHighDateTime) << 32) + localFT.dwLowDateTime;
uint64 time2 = (((uint64) utcFT .dwHighDateTime) << 32) + utcFT .dwLowDateTime;
// FILETIMEs are in units to 100 ns. Convert to seconds.
int64 time1Sec = time1 / 10000000;
int64 time2Sec = time2 / 10000000;
int32 delta = (int32) (time1Sec - time2Sec);
result.SetOffsetSeconds (delta);
if (result.IsValid ())
{
return result;
}
}
}
#endif
}
// Figure out local time zone.
dng_date_time_info current_info;
CurrentDateTimeAndZone (current_info);
result = current_info.TimeZone ();
return result;
}
/*****************************************************************************/
dng_date_time_storage_info::dng_date_time_storage_info ()
: fOffset (kDNGStreamInvalidOffset )
, fFormat (dng_date_time_format_unknown)
{
}
/*****************************************************************************/
dng_date_time_storage_info::dng_date_time_storage_info (uint64 offset,
dng_date_time_format format)
: fOffset (offset)
, fFormat (format)
{
}
/*****************************************************************************/
bool dng_date_time_storage_info::IsValid () const
{
return fOffset != kDNGStreamInvalidOffset;
}
/*****************************************************************************/
uint64 dng_date_time_storage_info::Offset () const
{
if (!IsValid ())
ThrowProgramError ();
return fOffset;
}
/*****************************************************************************/
dng_date_time_format dng_date_time_storage_info::Format () const
{
if (!IsValid ())
ThrowProgramError ();
return fFormat;
}
/*****************************************************************************/