xref: /external/dng_sdk/source/dng_date_time.cpp

/*****************************************************************************/
// 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;

	}

/*****************************************************************************/