X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fgstdatetime.c;h=083b5daf5e21fb99b0e248dc9138fa9edacbcdc2;hb=e10266e3f3cf9b05b69198b1ac6faa9a62840e30;hp=ec982937fc921f7942f56bbd6fb7cc5e27858eaa;hpb=bfe1cf99261529620457ad7edf6f043115ee4636;p=platform%2Fupstream%2Fgstreamer.git diff --git a/gst/gstdatetime.c b/gst/gstdatetime.c index ec98293..083b5da 100644 --- a/gst/gstdatetime.c +++ b/gst/gstdatetime.c @@ -13,19 +13,21 @@ * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include "glib-compat-private.h" #include "gst_private.h" +#include "glib-compat-private.h" #include "gstdatetime.h" +#include "gstvalue.h" #include #include +#include /** * SECTION:gstdatetime @@ -38,26 +40,40 @@ * Date information is handled using the proleptic Gregorian calendar. * * Provides basic creation functions and accessor functions to its fields. - * - * Since: 0.10.31 */ -#define GST_DATE_TIME_SEC_PER_DAY (G_GINT64_CONSTANT (86400)) -#define GST_DATE_TIME_USEC_PER_DAY (G_GINT64_CONSTANT (86400000000)) -#define GST_DATE_TIME_USEC_PER_HOUR (G_GINT64_CONSTANT (3600000000)) -#define GST_DATE_TIME_USEC_PER_MINUTE (G_GINT64_CONSTANT (60000000)) -#define GST_DATE_TIME_USEC_PER_SECOND (G_GINT64_CONSTANT (1000000)) -#define GST_DATE_TIME_USEC_PER_MILLISECOND (G_GINT64_CONSTANT (1000)) +typedef enum +{ + GST_DATE_TIME_FIELDS_INVALID = 0, + GST_DATE_TIME_FIELDS_Y, /* have year */ + GST_DATE_TIME_FIELDS_YM, /* have year and month */ + GST_DATE_TIME_FIELDS_YMD, /* have year, month and day */ + GST_DATE_TIME_FIELDS_YMD_HM, + GST_DATE_TIME_FIELDS_YMD_HMS + /* Note: if we ever add more granularity here, e.g. for microsecs, + * the compare function will need updating */ +} GstDateTimeFields; struct _GstDateTime { GDateTime *datetime; + GstDateTimeFields fields; volatile gint ref_count; }; -static GstDateTime * -gst_date_time_new_from_gdatetime (GDateTime * dt) +/** + * gst_date_time_new_from_g_date_time: + * @dt: (transfer full): the #GDateTime. The new #GstDateTime takes ownership. + * + * Creates a new #GstDateTime from a #GDateTime object. + * + * Free-function: gst_date_time_unref + * + * Returns: (transfer full): a newly created #GstDateTime, or %NULL on error + */ +GstDateTime * +gst_date_time_new_from_g_date_time (GDateTime * dt) { GstDateTime *gst_dt; @@ -66,22 +82,118 @@ gst_date_time_new_from_gdatetime (GDateTime * dt) gst_dt = g_slice_new (GstDateTime); gst_dt->datetime = dt; + gst_dt->fields = GST_DATE_TIME_FIELDS_YMD_HMS; gst_dt->ref_count = 1; return gst_dt; } /** + * gst_date_time_to_g_date_time: + * @datetime: GstDateTime. + * + * Creates a new #GDateTime from a fully defined #GstDateTime object. + * + * Free-function: g_date_time_unref + * + * Returns: (transfer full): a newly created #GDateTime, or %NULL on error + */ +GDateTime * +gst_date_time_to_g_date_time (GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, NULL); + + if (datetime->fields != GST_DATE_TIME_FIELDS_YMD_HMS) + return NULL; + + return g_date_time_add (datetime->datetime, 0); +} + +/** + * gst_date_time_has_year: + * @datetime: a #GstDateTime + * + * Returns: %TRUE if @datetime's year field is set (which should always + * be the case), otherwise %FALSE + */ +gboolean +gst_date_time_has_year (const GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, FALSE); + + return (datetime->fields >= GST_DATE_TIME_FIELDS_Y); +} + +/** + * gst_date_time_has_month: + * @datetime: a #GstDateTime + * + * Returns: %TRUE if @datetime's month field is set, otherwise %FALSE + */ +gboolean +gst_date_time_has_month (const GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, FALSE); + + return (datetime->fields >= GST_DATE_TIME_FIELDS_YM); +} + +/** + * gst_date_time_has_day: + * @datetime: a #GstDateTime + * + * Returns: %TRUE if @datetime's day field is set, otherwise %FALSE + */ +gboolean +gst_date_time_has_day (const GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, FALSE); + + return (datetime->fields >= GST_DATE_TIME_FIELDS_YMD); +} + +/** + * gst_date_time_has_time: + * @datetime: a #GstDateTime + * + * Returns: %TRUE if @datetime's hour and minute fields are set, + * otherwise %FALSE + */ +gboolean +gst_date_time_has_time (const GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, FALSE); + + return (datetime->fields >= GST_DATE_TIME_FIELDS_YMD_HM); +} + +/** + * gst_date_time_has_second: + * @datetime: a #GstDateTime + * + * Returns: %TRUE if @datetime's second field is set, otherwise %FALSE + */ +gboolean +gst_date_time_has_second (const GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, FALSE); + + return (datetime->fields >= GST_DATE_TIME_FIELDS_YMD_HMS); +} + +/** * gst_date_time_get_year: * @datetime: a #GstDateTime * * Returns the year of this #GstDateTime + * Call gst_date_time_has_year before, to avoid warnings. * * Return value: The year of this #GstDateTime - * Since: 0.10.31 */ gint gst_date_time_get_year (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + return g_date_time_get_year (datetime->datetime); } @@ -90,13 +202,16 @@ gst_date_time_get_year (const GstDateTime * datetime) * @datetime: a #GstDateTime * * Returns the month of this #GstDateTime. January is 1, February is 2, etc.. + * Call gst_date_time_has_month before, to avoid warnings. * * Return value: The month of this #GstDateTime - * Since: 0.10.31 */ gint gst_date_time_get_month (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_month (datetime), 0); + return g_date_time_get_month (datetime->datetime); } @@ -104,14 +219,17 @@ gst_date_time_get_month (const GstDateTime * datetime) * gst_date_time_get_day: * @datetime: a #GstDateTime * - * Returns the day of this #GstDateTime. + * Returns the day of the month of this #GstDateTime. + * Call gst_date_time_has_day before, to avoid warnings. * * Return value: The day of this #GstDateTime - * Since: 0.10.31 */ gint gst_date_time_get_day (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_day (datetime), 0); + return g_date_time_get_day_of_month (datetime->datetime); } @@ -121,14 +239,16 @@ gst_date_time_get_day (const GstDateTime * datetime) * * Retrieves the hour of the day represented by @datetime in the gregorian * calendar. The return is in the range of 0 to 23. + * Call gst_date_time_has_haur before, to avoid warnings. * * Return value: the hour of the day - * - * Since: 0.10.31 */ gint gst_date_time_get_hour (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_time (datetime), 0); + return g_date_time_get_hour (datetime->datetime); } @@ -138,14 +258,16 @@ gst_date_time_get_hour (const GstDateTime * datetime) * * Retrieves the minute of the hour represented by @datetime in the gregorian * calendar. + * Call gst_date_time_has_minute before, to avoid warnings. * * Return value: the minute of the hour - * - * Since: 0.10.31 */ gint gst_date_time_get_minute (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_time (datetime), 0); + return g_date_time_get_minute (datetime->datetime); } @@ -155,14 +277,16 @@ gst_date_time_get_minute (const GstDateTime * datetime) * * Retrieves the second of the minute represented by @datetime in the gregorian * calendar. + * Call gst_date_time_has_second before, to avoid warnings. * * Return value: the second represented by @datetime - * - * Since: 0.10.31 */ gint gst_date_time_get_second (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_second (datetime), 0); + return g_date_time_get_second (datetime->datetime); } @@ -174,12 +298,13 @@ gst_date_time_get_second (const GstDateTime * datetime) * @datetime in the gregorian calendar. * * Return value: the microsecond of the second - * - * Since: 0.10.31 */ gint gst_date_time_get_microsecond (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0); + g_return_val_if_fail (gst_date_time_has_second (datetime), 0); + return g_date_time_get_microsecond (datetime->datetime); } @@ -193,16 +318,87 @@ gst_date_time_get_microsecond (const GstDateTime * datetime) * If @datetime represents UTC time, then the offset is zero. * * Return value: the offset from UTC in hours - * Since: 0.10.31 */ gfloat gst_date_time_get_time_zone_offset (const GstDateTime * datetime) { + g_return_val_if_fail (datetime != NULL, 0.0); + g_return_val_if_fail (gst_date_time_has_time (datetime), 0.0); + return (g_date_time_get_utc_offset (datetime->datetime) / G_USEC_PER_SEC) / 3600.0; } /** + * gst_date_time_new_y: + * @year: the gregorian year + * + * Creates a new #GstDateTime using the date and times in the gregorian calendar + * in the local timezone. + * + * @year should be from 1 to 9999. + * + * Free-function: gst_date_time_unref + * + * Return value: (transfer full): the newly created #GstDateTime + */ +GstDateTime * +gst_date_time_new_y (gint year) +{ + return gst_date_time_new (0.0, year, -1, -1, -1, -1, -1); +} + +/** + * gst_date_time_new_ym: + * @year: the gregorian year + * @month: the gregorian month + * + * Creates a new #GstDateTime using the date and times in the gregorian calendar + * in the local timezone. + * + * @year should be from 1 to 9999, @month should be from 1 to 12. + * + * If value is -1 then all over value will be ignored. For example + * if @month == -1, then #GstDateTime will created only for @year. + * + * Free-function: gst_date_time_unref + * + * Return value: (transfer full): the newly created #GstDateTime + */ +GstDateTime * +gst_date_time_new_ym (gint year, gint month) +{ + return gst_date_time_new (0.0, year, month, -1, -1, -1, -1); +} + +/** + * gst_date_time_new_ymd: + * @year: the gregorian year + * @month: the gregorian month + * @day: the day of the gregorian month + * + * Creates a new #GstDateTime using the date and times in the gregorian calendar + * in the local timezone. + * + * @year should be from 1 to 9999, @month should be from 1 to 12, @day from + * 1 to 31. + * + * If value is -1 then all over value will be ignored. For example + * if @month == -1, then #GstDateTime will created only for @year. If + * @day == -1, then #GstDateTime will created for @year and @month and + * so on. + * + * Free-function: gst_date_time_unref + * + * Return value: (transfer full): the newly created #GstDateTime + */ +GstDateTime * +gst_date_time_new_ymd (gint year, gint month, gint day) +{ + return gst_date_time_new (0.0, year, month, day, -1, -1, -1); +} + +/** * gst_date_time_new_from_unix_epoch_local_time: * @secs: seconds from the Unix epoch * @@ -212,14 +408,14 @@ gst_date_time_get_time_zone_offset (const GstDateTime * datetime) * Free-function: gst_date_time_unref * * Return value: (transfer full): the newly created #GstDateTime - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new_from_unix_epoch_local_time (gint64 secs) { - return - gst_date_time_new_from_gdatetime (g_date_time_new_from_unix_local (secs)); + GDateTime *datetime; + + datetime = g_date_time_new_from_unix_local (secs); + return gst_date_time_new_from_g_date_time (datetime); } /** @@ -232,24 +428,46 @@ gst_date_time_new_from_unix_epoch_local_time (gint64 secs) * Free-function: gst_date_time_unref * * Return value: (transfer full): the newly created #GstDateTime - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new_from_unix_epoch_utc (gint64 secs) { - return - gst_date_time_new_from_gdatetime (g_date_time_new_from_unix_utc (secs)); + GstDateTime *datetime; + datetime = + gst_date_time_new_from_g_date_time (g_date_time_new_from_unix_utc (secs)); + return datetime; +} + +static GstDateTimeFields +gst_date_time_check_fields (gint * year, gint * month, gint * day, + gint * hour, gint * minute, gdouble * seconds) +{ + if (*month == -1) { + *month = *day = 1; + *hour = *minute = *seconds = 0; + return GST_DATE_TIME_FIELDS_Y; + } else if (*day == -1) { + *day = 1; + *hour = *minute = *seconds = 0; + return GST_DATE_TIME_FIELDS_YM; + } else if (*hour == -1) { + *hour = *minute = *seconds = 0; + return GST_DATE_TIME_FIELDS_YMD; + } else if (*seconds == -1) { + *seconds = 0; + return GST_DATE_TIME_FIELDS_YMD_HM; + } else + return GST_DATE_TIME_FIELDS_YMD_HMS; } /** * gst_date_time_new_local_time: * @year: the gregorian year - * @month: the gregorian month - * @day: the day of the gregorian month - * @hour: the hour of the day - * @minute: the minute of the hour - * @seconds: the second of the minute + * @month: the gregorian month, or -1 + * @day: the day of the gregorian month, or -1 + * @hour: the hour of the day, or -1 + * @minute: the minute of the hour, or -1 + * @seconds: the second of the minute, or -1 * * Creates a new #GstDateTime using the date and times in the gregorian calendar * in the local timezone. @@ -257,18 +475,42 @@ gst_date_time_new_from_unix_epoch_utc (gint64 secs) * @year should be from 1 to 9999, @month should be from 1 to 12, @day from * 1 to 31, @hour from 0 to 23, @minutes and @seconds from 0 to 59. * + * If @month is -1, then the #GstDateTime created will only contain @year, + * and all other fields will be considered not set. + * + * If @day is -1, then the #GstDateTime created will only contain @year and + * @month and all other fields will be considered not set. + * + * If @hour is -1, then the #GstDateTime created will only contain @year and + * @month and @day, and the time fields will be considered not set. In this + * case @minute and @seconds should also be -1. + * * Free-function: gst_date_time_unref * * Return value: (transfer full): the newly created #GstDateTime - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new_local_time (gint year, gint month, gint day, gint hour, gint minute, gdouble seconds) { - return gst_date_time_new_from_gdatetime (g_date_time_new_local (year, month, - day, hour, minute, seconds)); + GstDateTimeFields fields; + GstDateTime *datetime; + + g_return_val_if_fail (year > 0 && year <= 9999, NULL); + g_return_val_if_fail ((month > 0 && month <= 12) || month == -1, NULL); + g_return_val_if_fail ((day > 0 && day <= 31) || day == -1, NULL); + g_return_val_if_fail ((hour >= 0 && hour < 24) || hour == -1, NULL); + g_return_val_if_fail ((minute >= 0 && minute < 60) || minute == -1, NULL); + g_return_val_if_fail ((seconds >= 0 && seconds < 60) || seconds == -1, NULL); + + fields = gst_date_time_check_fields (&year, &month, &day, + &hour, &minute, &seconds); + + datetime = gst_date_time_new_from_g_date_time (g_date_time_new_local (year, + month, day, hour, minute, seconds)); + + datetime->fields = fields; + return datetime; } /** @@ -280,13 +522,11 @@ gst_date_time_new_local_time (gint year, gint month, gint day, gint hour, * * Return value: (transfer full): the newly created #GstDateTime which should * be freed with gst_date_time_unref(). - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new_now_local_time (void) { - return gst_date_time_new_from_gdatetime (g_date_time_new_now_local ()); + return gst_date_time_new_from_g_date_time (g_date_time_new_now_local ()); } /** @@ -299,21 +539,34 @@ gst_date_time_new_now_local_time (void) * * Return value: (transfer full): the newly created #GstDateTime which should * be freed with gst_date_time_unref(). - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new_now_utc (void) { - return gst_date_time_new_from_gdatetime (g_date_time_new_now_utc ()); + return gst_date_time_new_from_g_date_time (g_date_time_new_now_utc ()); } gint -priv_gst_date_time_compare (gconstpointer dt1, gconstpointer dt2) +__gst_date_time_compare (const GstDateTime * dt1, const GstDateTime * dt2) { - const GstDateTime *datetime1 = dt1; - const GstDateTime *datetime2 = dt2; - return g_date_time_compare (datetime1->datetime, datetime2->datetime); + gint64 diff; + + /* we assume here that GST_DATE_TIME_FIELDS_YMD_HMS is the highest + * resolution, and ignore microsecond differences on purpose for now */ + if (dt1->fields != dt2->fields) + return GST_VALUE_UNORDERED; + + /* This will round down to nearest second, which is what we want. We're + * not comparing microseconds on purpose here, since we're not + * serialising them when doing new_utc_now() + to_string() */ + diff = + g_date_time_to_unix (dt1->datetime) - g_date_time_to_unix (dt2->datetime); + if (diff < 0) + return GST_VALUE_LESS_THAN; + else if (diff > 0) + return GST_VALUE_GREATER_THAN; + else + return GST_VALUE_EQUAL; } /** @@ -334,23 +587,38 @@ priv_gst_date_time_compare (gconstpointer dt1, gconstpointer dt2) * * Note that @tzoffset is a float and was chosen so for being able to handle * some fractional timezones, while it still keeps the readability of - * represeting it in hours for most timezones. + * representing it in hours for most timezones. + * + * If value is -1 then all over value will be ignored. For example + * if @month == -1, then #GstDateTime will created only for @year. If + * @day == -1, then #GstDateTime will created for @year and @month and + * so on. * * Free-function: gst_date_time_unref * * Return value: (transfer full): the newly created #GstDateTime - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_new (gfloat tzoffset, gint year, gint month, gint day, gint hour, gint minute, gdouble seconds) { + GstDateTimeFields fields; gchar buf[6]; GTimeZone *tz; GDateTime *dt; + GstDateTime *datetime; gint tzhour, tzminute; + g_return_val_if_fail (year > 0 && year <= 9999, NULL); + g_return_val_if_fail ((month > 0 && month <= 12) || month == -1, NULL); + g_return_val_if_fail ((day > 0 && day <= 31) || day == -1, NULL); + g_return_val_if_fail ((hour >= 0 && hour < 24) || hour == -1, NULL); + g_return_val_if_fail ((minute >= 0 && minute < 60) || minute == -1, NULL); + g_return_val_if_fail ((seconds >= 0 && seconds < 60) || seconds == -1, NULL); + g_return_val_if_fail (tzoffset >= -12.0 && tzoffset <= 12.0, NULL); + g_return_val_if_fail ((hour >= 0 && minute >= 0) || + (hour == -1 && minute == -1 && seconds == -1 && tzoffset == 0.0), NULL); + tzhour = (gint) ABS (tzoffset); tzminute = (gint) ((ABS (tzoffset) - tzhour) * 60); @@ -359,11 +627,248 @@ gst_date_time_new (gfloat tzoffset, gint year, gint month, gint day, gint hour, tz = g_time_zone_new (buf); + fields = gst_date_time_check_fields (&year, &month, &day, + &hour, &minute, &seconds); + dt = g_date_time_new (tz, year, month, day, hour, minute, seconds); g_time_zone_unref (tz); - return gst_date_time_new_from_gdatetime (dt); + + datetime = gst_date_time_new_from_g_date_time (dt); + datetime->fields = fields; + + return datetime; } +gchar * +__gst_date_time_serialize (GstDateTime * datetime, gboolean serialize_usecs) +{ + GString *s; + gfloat gmt_offset; + guint msecs; + + /* we always have at least the year */ + s = g_string_new (NULL); + g_string_append_printf (s, "%04u", gst_date_time_get_year (datetime)); + + if (datetime->fields == GST_DATE_TIME_FIELDS_Y) + goto done; + + /* add month */ + g_string_append_printf (s, "-%02u", gst_date_time_get_month (datetime)); + + if (datetime->fields == GST_DATE_TIME_FIELDS_YM) + goto done; + + /* add day of month */ + g_string_append_printf (s, "-%02u", gst_date_time_get_day (datetime)); + + if (datetime->fields == GST_DATE_TIME_FIELDS_YMD) + goto done; + + /* add time */ + g_string_append_printf (s, "T%02u:%02u", gst_date_time_get_hour (datetime), + gst_date_time_get_minute (datetime)); + + if (datetime->fields == GST_DATE_TIME_FIELDS_YMD_HM) + goto add_timezone; + + /* add seconds */ + g_string_append_printf (s, ":%02u", gst_date_time_get_second (datetime)); + + /* add microseconds */ + if (serialize_usecs) { + msecs = gst_date_time_get_microsecond (datetime); + if (msecs != 0) { + g_string_append_printf (s, ".%06u", msecs); + /* trim trailing 0s */ + while (s->str[s->len - 1] == '0') + g_string_truncate (s, s->len - 1); + } + } + + /* add timezone */ + +add_timezone: + + gmt_offset = gst_date_time_get_time_zone_offset (datetime); + if (gmt_offset == 0) { + g_string_append_c (s, 'Z'); + } else { + guint tzhour, tzminute; + + tzhour = (guint) ABS (gmt_offset); + tzminute = (guint) ((ABS (gmt_offset) - tzhour) * 60); + + g_string_append_c (s, (gmt_offset >= 0) ? '+' : '-'); + g_string_append_printf (s, "%02u%02u", tzhour, tzminute); + } + +done: + + return g_string_free (s, FALSE); +} + +/** + * gst_date_time_to_iso8601_string: + * @datetime: GstDateTime. + * + * Create a minimal string compatible with ISO-8601. Possible output formats + * are (for example): 2012, 2012-06, 2012-06-23, 2012-06-23T23:30Z, + * 2012-06-23T23:30+0100, 2012-06-23T23:30:59Z, 2012-06-23T23:30:59+0100 + * + * Returns: a newly allocated string formatted according to ISO 8601 and + * only including the datetime fields that are valid, or %NULL in case + * there was an error. The string should be freed with g_free(). + */ +gchar * +gst_date_time_to_iso8601_string (GstDateTime * datetime) +{ + g_return_val_if_fail (datetime != NULL, NULL); + + if (datetime->fields == GST_DATE_TIME_FIELDS_INVALID) + return NULL; + + return __gst_date_time_serialize (datetime, FALSE); +} + +/** + * gst_date_time_new_from_iso8601_string: + * @string: ISO 8601-formatted datetime string. + * + * Tries to parse common variants of ISO-8601 datetime strings into a + * #GstDateTime. + * + * Free-function: gst_date_time_unref + * + * Returns: (transfer full): a newly created #GstDateTime, or %NULL on error + */ +GstDateTime * +gst_date_time_new_from_iso8601_string (const gchar * string) +{ + gint year = -1, month = -1, day = -1, hour = -1, minute = -1; + gdouble second = -1.0; + gfloat tzoffset = 0.0; + guint64 usecs; + gint len, ret; + + g_return_val_if_fail (string != NULL, NULL); + + GST_DEBUG ("Parsing '%s' into a datetime", string); + + len = strlen (string); + + if (len < 4 || !g_ascii_isdigit (string[0]) || !g_ascii_isdigit (string[1]) + || !g_ascii_isdigit (string[2]) || !g_ascii_isdigit (string[3])) + return NULL; + + ret = sscanf (string, "%04d-%02d-%02d", &year, &month, &day); + + if (ret == 0) + return NULL; + + if (ret == 3 && day <= 0) { + ret = 2; + day = -1; + } + + if (ret >= 2 && month <= 0) { + ret = 1; + month = day = -1; + } + + if (ret >= 1 && year <= 0) + return NULL; + + else if (ret >= 1 && len < 16) + /* YMD is 10 chars. XMD + HM will be 16 chars. if it is less, + * it make no sense to continue. We will stay with YMD. */ + goto ymd; + + string += 10; + /* Exit if there is no expeceted value on this stage */ + if (!(*string == 'T' || *string == '-' || *string == ' ')) + goto ymd; + + /* if hour or minute fails, then we will use onlly ymd. */ + hour = g_ascii_strtoull (string + 1, (gchar **) & string, 10); + if (hour > 24 || *string != ':') + goto ymd; + + /* minute */ + minute = g_ascii_strtoull (string + 1, (gchar **) & string, 10); + if (minute > 59) + goto ymd; + + /* second */ + if (*string == ':') { + second = g_ascii_strtoull (string + 1, (gchar **) & string, 10); + /* if we fail here, we still can reuse hour and minute. We + * will still attempt to parse any timezone information */ + if (second > 59) { + second = -1.0; + } else { + /* microseconds */ + if (*string == '.' || *string == ',') { + const gchar *usec_start = string + 1; + guint digits; + + usecs = g_ascii_strtoull (string + 1, (gchar **) & string, 10); + if (usecs != G_MAXUINT64 && string > usec_start) { + digits = (guint) (string - usec_start); + second += (gdouble) usecs / pow (10.0, digits); + } + } + } + } + + if (*string == 'Z') + goto ymd_hms; + else { + /* reuse some code from gst-plugins-base/gst-libs/gst/tag/gstxmptag.c */ + gint gmt_offset_hour = -1, gmt_offset_min = -1, gmt_offset = -1; + gchar *plus_pos = NULL; + gchar *neg_pos = NULL; + gchar *pos = NULL; + + GST_LOG ("Checking for timezone information"); + + /* check if there is timezone info */ + plus_pos = strrchr (string, '+'); + neg_pos = strrchr (string, '-'); + if (plus_pos) + pos = plus_pos + 1; + else if (neg_pos) + pos = neg_pos + 1; + + if (pos) { + gint ret_tz; + if (pos[2] == ':') + ret_tz = sscanf (pos, "%d:%d", &gmt_offset_hour, &gmt_offset_min); + else + ret_tz = sscanf (pos, "%02d%02d", &gmt_offset_hour, &gmt_offset_min); + + GST_DEBUG ("Parsing timezone: %s", pos); + + if (ret_tz == 2) { + gmt_offset = gmt_offset_hour * 60 + gmt_offset_min; + if (neg_pos != NULL && neg_pos + 1 == pos) + gmt_offset *= -1; + + tzoffset = gmt_offset / 60.0; + + GST_LOG ("Timezone offset: %f (%d minutes)", tzoffset, gmt_offset); + } else + GST_WARNING ("Failed to parse timezone information"); + } + } + +ymd_hms: + return gst_date_time_new (tzoffset, year, month, day, hour, minute, second); +ymd: + return gst_date_time_new_ymd (year, month, day); +} + + static void gst_date_time_free (GstDateTime * datetime) { @@ -378,8 +883,6 @@ gst_date_time_free (GstDateTime * datetime) * Atomically increments the reference count of @datetime by one. * * Return value: (transfer full): the reference @datetime - * - * Since: 0.10.31 */ GstDateTime * gst_date_time_ref (GstDateTime * datetime) @@ -396,8 +899,6 @@ gst_date_time_ref (GstDateTime * datetime) * * Atomically decrements the reference count of @datetime by one. When the * reference count reaches zero, the structure is freed. - * - * Since: 0.10.31 */ void gst_date_time_unref (GstDateTime * datetime)