gstreamer/gst-libs/gst/video/gstvideotimecode.c
Tim-Philipp Müller ca15315565 gst-libs: include config.h in all source files
This will be needed later when we get our export define from config.h
2018-08-13 09:23:34 +01:00

1015 lines
29 KiB
C

/* GStreamer
* Copyright (C) <2016> Vivia Nikolaidou <vivia@toolsonair.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include "gstvideotimecode.h"
static void
gst_video_time_code_gvalue_to_string (const GValue * tc_val, GValue * str_val);
static void
gst_video_time_code_gvalue_from_string (const GValue * str_val,
GValue * tc_val);
static gboolean gst_video_time_code_deserialize (GValue * dest,
const gchar * tc_str);
static gchar *gst_video_time_code_serialize (const GValue * val);
static void
_init (GType type)
{
static GstValueTable table =
{ 0, (GstValueCompareFunc) gst_video_time_code_compare,
(GstValueSerializeFunc) gst_video_time_code_serialize,
(GstValueDeserializeFunc) gst_video_time_code_deserialize
};
table.type = type;
gst_value_register (&table);
g_value_register_transform_func (type, G_TYPE_STRING,
(GValueTransform) gst_video_time_code_gvalue_to_string);
g_value_register_transform_func (G_TYPE_STRING, type,
(GValueTransform) gst_video_time_code_gvalue_from_string);
}
G_DEFINE_BOXED_TYPE_WITH_CODE (GstVideoTimeCode, gst_video_time_code,
(GBoxedCopyFunc) gst_video_time_code_copy,
(GBoxedFreeFunc) gst_video_time_code_free, _init (g_define_type_id));
/**
* gst_video_time_code_is_valid:
* @tc: #GstVideoTimeCode to check
*
* Returns: whether @tc is a valid timecode (supported frame rate,
* hours/minutes/seconds/frames not overflowing)
*
* Since: 1.10
*/
gboolean
gst_video_time_code_is_valid (const GstVideoTimeCode * tc)
{
guint fr;
g_return_val_if_fail (tc != NULL, FALSE);
fr = (tc->config.fps_n + (tc->config.fps_d >> 1)) / tc->config.fps_d;
if (tc->hours >= 24)
return FALSE;
if (tc->minutes >= 60)
return FALSE;
if (tc->seconds >= 60)
return FALSE;
if (tc->config.fps_d == 0)
return FALSE;
if (tc->frames >= fr && (tc->config.fps_n != 0 || tc->config.fps_d != 1))
return FALSE;
if (tc->config.fps_d == 1001) {
if (tc->config.fps_n != 30000 && tc->config.fps_n != 60000 &&
tc->config.fps_n != 24000)
return FALSE;
} else if (tc->config.fps_n % tc->config.fps_d != 0) {
return FALSE;
}
if ((tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME) &&
tc->minutes % 10 && tc->seconds == 0 && tc->frames < fr / 15) {
return FALSE;
}
return TRUE;
}
/**
* gst_video_time_code_to_string:
* @tc: #GstVideoTimeCode to convert
*
* Returns: the SMPTE ST 2059-1:2015 string representation of @tc. That will
* take the form hh:mm:ss:ff . The last separator (between seconds and frames)
* may vary:
*
* ';' for drop-frame, non-interlaced content and for drop-frame interlaced
* field 2
* ',' for drop-frame interlaced field 1
* ':' for non-drop-frame, non-interlaced content and for non-drop-frame
* interlaced field 2
* '.' for non-drop-frame interlaced field 1
*
* Since: 1.10
*/
gchar *
gst_video_time_code_to_string (const GstVideoTimeCode * tc)
{
gchar *ret;
gboolean top_dot_present;
gchar sep;
/* Top dot is present for non-interlaced content, and for field 2 in
* interlaced content */
top_dot_present =
!((tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_INTERLACED) != 0
&& tc->field_count == 1);
if (tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME)
sep = top_dot_present ? ';' : ',';
else
sep = top_dot_present ? ':' : '.';
ret =
g_strdup_printf ("%02d:%02d:%02d%c%02d", tc->hours, tc->minutes,
tc->seconds, sep, tc->frames);
return ret;
}
/**
* gst_video_time_code_to_date_time:
* @tc: A valid #GstVideoTimeCode to convert
*
* The @tc.config->latest_daily_jam is required to be non-NULL.
*
* Returns: the #GDateTime representation of @tc.
*
* Since: 1.10
*/
GDateTime *
gst_video_time_code_to_date_time (const GstVideoTimeCode * tc)
{
GDateTime *ret;
GDateTime *ret2;
gdouble add_us;
g_return_val_if_fail (gst_video_time_code_is_valid (tc), NULL);
g_return_val_if_fail (tc->config.latest_daily_jam != NULL, NULL);
ret = g_date_time_ref (tc->config.latest_daily_jam);
if (ret == NULL) {
gchar *tc_str = gst_video_time_code_to_string (tc);
GST_WARNING
("Asked to convert time code %s to GDateTime, but its latest daily jam is NULL",
tc_str);
g_free (tc_str);
g_date_time_unref (ret);
return NULL;
}
if (tc->config.fps_n == 0 && tc->config.fps_d == 1) {
gchar *tc_str = gst_video_time_code_to_string (tc);
GST_WARNING
("Asked to convert time code %s to GDateTime, but its framerate is unknown",
tc_str);
g_free (tc_str);
g_date_time_unref (ret);
return NULL;
}
gst_util_fraction_to_double (tc->frames * tc->config.fps_d, tc->config.fps_n,
&add_us);
if ((tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_INTERLACED)
&& tc->field_count == 1) {
gdouble sub_us;
gst_util_fraction_to_double (tc->config.fps_d, 2 * tc->config.fps_n,
&sub_us);
add_us -= sub_us;
}
ret2 = g_date_time_add_seconds (ret, add_us + tc->seconds);
g_date_time_unref (ret);
ret = g_date_time_add_minutes (ret2, tc->minutes);
g_date_time_unref (ret2);
ret2 = g_date_time_add_hours (ret, tc->hours);
g_date_time_unref (ret);
return ret2;
}
/**
* gst_video_time_code_init_from_date_time:
* @tc: a #GstVideoTimeCode
* @fps_n: Numerator of the frame rate
* @fps_d: Denominator of the frame rate
* @dt: #GDateTime to convert
* @flags: #GstVideoTimeCodeFlags
* @field_count: Interlaced video field count
*
* The resulting config->latest_daily_jam is set to
* midnight, and timecode is set to the given time.
*
* Since: 1.12
*/
void
gst_video_time_code_init_from_date_time (GstVideoTimeCode * tc,
guint fps_n, guint fps_d,
GDateTime * dt, GstVideoTimeCodeFlags flags, guint field_count)
{
GDateTime *jam;
guint64 frames;
gboolean add_a_frame = FALSE;
jam = g_date_time_new_local (g_date_time_get_year (dt),
g_date_time_get_month (dt), g_date_time_get_day_of_month (dt), 0, 0, 0.0);
/* Note: This might be inaccurate for 1 frame
* in case we have a drop frame timecode */
frames =
gst_util_uint64_scale_round (g_date_time_get_microsecond (dt) *
G_GINT64_CONSTANT (1000), fps_n, fps_d * GST_SECOND);
if (G_UNLIKELY (((frames == fps_n) && (fps_d == 1)) ||
((frames == fps_n / 1000) && (fps_d == 1001)))) {
/* Avoid invalid timecodes */
frames--;
add_a_frame = TRUE;
}
gst_video_time_code_init (tc, fps_n, fps_d, jam, flags,
g_date_time_get_hour (dt), g_date_time_get_minute (dt),
g_date_time_get_second (dt), frames, field_count);
if (tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME) {
guint df = (tc->config.fps_n + (tc->config.fps_d >> 1)) /
(15 * tc->config.fps_d);
if (tc->minutes % 10 && tc->seconds == 0 && tc->frames < df) {
tc->frames = df;
}
}
if (add_a_frame)
gst_video_time_code_increment_frame (tc);
g_date_time_unref (jam);
g_return_if_fail (gst_video_time_code_is_valid (tc));
}
/**
* gst_video_time_code_nsec_since_daily_jam:
* @tc: a valid #GstVideoTimeCode
*
* Returns: how many nsec have passed since the daily jam of @tc .
*
* Since: 1.10
*/
guint64
gst_video_time_code_nsec_since_daily_jam (const GstVideoTimeCode * tc)
{
guint64 frames, nsec;
g_return_val_if_fail (gst_video_time_code_is_valid (tc), -1);
if (tc->config.fps_n == 0 && tc->config.fps_d == 1) {
gchar *tc_str = gst_video_time_code_to_string (tc);
GST_WARNING
("Asked to calculate nsec since daily jam of time code %s, but its framerate is unknown",
tc_str);
g_free (tc_str);
return -1;
}
frames = gst_video_time_code_frames_since_daily_jam (tc);
nsec =
gst_util_uint64_scale (frames, GST_SECOND * tc->config.fps_d,
tc->config.fps_n);
return nsec;
}
/**
* gst_video_time_code_frames_since_daily_jam:
* @tc: a valid #GstVideoTimeCode
*
* Returns: how many frames have passed since the daily jam of @tc .
*
* Since: 1.10
*/
guint64
gst_video_time_code_frames_since_daily_jam (const GstVideoTimeCode * tc)
{
guint ff_nom;
gdouble ff;
g_return_val_if_fail (gst_video_time_code_is_valid (tc), -1);
gst_util_fraction_to_double (tc->config.fps_n, tc->config.fps_d, &ff);
if (tc->config.fps_d == 1001) {
ff_nom = tc->config.fps_n / 1000;
} else {
ff_nom = ff;
}
if (tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME) {
/* these need to be truncated to integer: side effect, code looks cleaner
* */
guint ff_minutes = 60 * ff;
guint ff_hours = 3600 * ff;
/* for 30000/1001 we drop the first 2 frames per minute, for 60000/1001 we
* drop the first 4 : so we use this number */
guint dropframe_multiplier;
if (tc->config.fps_n == 30000) {
dropframe_multiplier = 2;
} else if (tc->config.fps_n == 60000) {
dropframe_multiplier = 4;
} else {
GST_ERROR ("Unsupported drop frame rate %u/%u", tc->config.fps_n,
tc->config.fps_d);
return -1;
}
return tc->frames + (ff_nom * tc->seconds) +
(ff_minutes * tc->minutes) +
dropframe_multiplier * ((gint) (tc->minutes / 10)) +
(ff_hours * tc->hours);
} else {
return tc->frames + (ff_nom * (tc->seconds + (60 * (tc->minutes +
(60 * tc->hours)))));
}
}
/**
* gst_video_time_code_increment_frame:
* @tc: a valid #GstVideoTimeCode
*
* Adds one frame to @tc .
*
* Since: 1.10
*/
void
gst_video_time_code_increment_frame (GstVideoTimeCode * tc)
{
gst_video_time_code_add_frames (tc, 1);
}
/**
* gst_video_time_code_add_frames:
* @tc: a valid #GstVideoTimeCode
* @frames: How many frames to add or subtract
*
* Adds or subtracts @frames amount of frames to @tc. tc needs to
* contain valid data, as verified by #gst_video_time_code_is_valid.
*
* Since: 1.10
*/
void
gst_video_time_code_add_frames (GstVideoTimeCode * tc, gint64 frames)
{
guint64 framecount;
guint64 h_notmod24;
guint64 h_new, min_new, sec_new, frames_new;
gdouble ff;
guint ff_nom;
/* This allows for better readability than putting G_GUINT64_CONSTANT(60)
* into a long calculation line */
const guint64 sixty = 60;
/* formulas found in SMPTE ST 2059-1:2015 section 9.4.3
* and adapted for 60/1.001 as well as 30/1.001 */
g_return_if_fail (gst_video_time_code_is_valid (tc));
gst_util_fraction_to_double (tc->config.fps_n, tc->config.fps_d, &ff);
if (tc->config.fps_d == 1001) {
ff_nom = tc->config.fps_n / 1000;
} else {
ff_nom = ff;
if (tc->config.fps_d != 1)
GST_WARNING ("Unsupported frame rate %u/%u, results may be wrong",
tc->config.fps_n, tc->config.fps_d);
}
if (tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME) {
/* these need to be truncated to integer: side effect, code looks cleaner
* */
guint ff_minutes = 60 * ff;
guint ff_hours = 3600 * ff;
/* a bunch of intermediate variables, to avoid monster code with possible
* integer overflows */
guint64 min_new_tmp1, min_new_tmp2, min_new_tmp3, min_new_denom;
/* for 30000/1001 we drop the first 2 frames per minute, for 60000/1001 we
* drop the first 4 : so we use this number */
guint dropframe_multiplier;
if (tc->config.fps_n == 30000)
dropframe_multiplier = 2;
else if (tc->config.fps_n == 60000)
dropframe_multiplier = 4;
else {
GST_ERROR ("Unsupported drop frame rate %u/%u", tc->config.fps_n,
tc->config.fps_d);
return;
}
framecount =
frames + tc->frames + (ff_nom * tc->seconds) +
(ff_minutes * tc->minutes) +
dropframe_multiplier * ((gint) (tc->minutes / 10)) +
(ff_hours * tc->hours);
h_notmod24 = gst_util_uint64_scale_int (framecount, 1, ff_hours);
min_new_denom = sixty * ff_nom;
min_new_tmp1 = (framecount - (h_notmod24 * ff_hours)) / min_new_denom;
min_new_tmp2 = framecount + dropframe_multiplier * min_new_tmp1;
min_new_tmp1 =
(framecount - (h_notmod24 * ff_hours)) / (sixty * 10 * ff_nom);
min_new_tmp3 =
dropframe_multiplier * min_new_tmp1 + (h_notmod24 * ff_hours);
min_new =
gst_util_uint64_scale_int (min_new_tmp2 - min_new_tmp3, 1,
min_new_denom);
sec_new =
(guint64) ((framecount - (ff_minutes * min_new) -
dropframe_multiplier * ((gint) (min_new / 10)) -
(ff_hours * h_notmod24)) / ff_nom);
frames_new =
framecount - (ff_nom * sec_new) - (ff_minutes * min_new) -
(dropframe_multiplier * ((gint) (min_new / 10))) -
(ff_hours * h_notmod24);
} else {
framecount =
frames + tc->frames + (ff_nom * (tc->seconds + (sixty * (tc->minutes +
(sixty * tc->hours)))));
h_notmod24 =
gst_util_uint64_scale_int (framecount, 1, ff_nom * sixty * sixty);
min_new =
gst_util_uint64_scale_int ((framecount -
(ff_nom * sixty * sixty * h_notmod24)), 1, (ff_nom * sixty));
sec_new =
gst_util_uint64_scale_int ((framecount - (ff_nom * sixty * (min_new +
(sixty * h_notmod24)))), 1, ff_nom);
frames_new =
framecount - (ff_nom * (sec_new + sixty * (min_new +
(sixty * h_notmod24))));
if (frames_new > ff_nom)
frames_new = 0;
}
h_new = h_notmod24 % 24;
g_assert (min_new < 60);
g_assert (sec_new < 60);
g_assert (frames_new < ff_nom);
tc->hours = h_new;
tc->minutes = min_new;
tc->seconds = sec_new;
tc->frames = frames_new;
}
/**
* gst_video_time_code_compare:
* @tc1: a #GstVideoTimeCode
* @tc2: another #GstVideoTimeCode
*
* Compares @tc1 and @tc2 . If both have latest daily jam information, it is
* taken into account. Otherwise, it is assumed that the daily jam of both
* @tc1 and @tc2 was at the same time. Both time codes must be valid.
*
* Returns: 1 if @tc1 is after @tc2, -1 if @tc1 is before @tc2, 0 otherwise.
*
* Since: 1.10
*/
gint
gst_video_time_code_compare (const GstVideoTimeCode * tc1,
const GstVideoTimeCode * tc2)
{
g_return_val_if_fail (gst_video_time_code_is_valid (tc1), -1);
g_return_val_if_fail (gst_video_time_code_is_valid (tc2), -1);
if (tc1->config.latest_daily_jam == NULL
|| tc2->config.latest_daily_jam == NULL) {
guint64 nsec1, nsec2;
#ifndef GST_DISABLE_GST_DEBUG
gchar *str1, *str2;
str1 = gst_video_time_code_to_string (tc1);
str2 = gst_video_time_code_to_string (tc2);
GST_INFO
("Comparing time codes %s and %s, but at least one of them has no "
"latest daily jam information. Assuming they started together",
str1, str2);
g_free (str1);
g_free (str2);
#endif
if (tc1->hours > tc2->hours) {
return 1;
} else if (tc1->hours < tc2->hours) {
return -1;
}
if (tc1->minutes > tc2->minutes) {
return 1;
} else if (tc1->minutes < tc2->minutes) {
return -1;
}
if (tc1->seconds > tc2->seconds) {
return 1;
} else if (tc1->seconds < tc2->seconds) {
return -1;
}
nsec1 =
gst_util_uint64_scale (GST_SECOND,
tc1->frames * tc1->config.fps_n, tc1->config.fps_d);
nsec2 =
gst_util_uint64_scale (GST_SECOND,
tc2->frames * tc2->config.fps_n, tc2->config.fps_d);
if (nsec1 > nsec2) {
return 1;
} else if (nsec1 < nsec2) {
return -1;
}
if (tc1->config.flags & GST_VIDEO_TIME_CODE_FLAGS_INTERLACED) {
if (tc1->field_count > tc2->field_count)
return 1;
else if (tc1->field_count < tc2->field_count)
return -1;
}
return 0;
} else {
GDateTime *dt1, *dt2;
gint ret;
dt1 = gst_video_time_code_to_date_time (tc1);
dt2 = gst_video_time_code_to_date_time (tc2);
ret = g_date_time_compare (dt1, dt2);
g_date_time_unref (dt1);
g_date_time_unref (dt2);
return ret;
}
}
/**
* gst_video_time_code_new:
* @fps_n: Numerator of the frame rate
* @fps_d: Denominator of the frame rate
* @latest_daily_jam: The latest daily jam of the #GstVideoTimeCode
* @flags: #GstVideoTimeCodeFlags
* @hours: the hours field of #GstVideoTimeCode
* @minutes: the minutes field of #GstVideoTimeCode
* @seconds: the seconds field of #GstVideoTimeCode
* @frames: the frames field of #GstVideoTimeCode
* @field_count: Interlaced video field count
*
* @field_count is 0 for progressive, 1 or 2 for interlaced.
* @latest_daiy_jam reference is stolen from caller.
*
* Returns: a new #GstVideoTimeCode with the given values.
* The values are not checked for being in a valid range. To see if your
* timecode actually has valid content, use #gst_video_time_code_is_valid.
*
* Since: 1.10
*/
GstVideoTimeCode *
gst_video_time_code_new (guint fps_n, guint fps_d, GDateTime * latest_daily_jam,
GstVideoTimeCodeFlags flags, guint hours, guint minutes, guint seconds,
guint frames, guint field_count)
{
GstVideoTimeCode *tc;
tc = g_new0 (GstVideoTimeCode, 1);
gst_video_time_code_init (tc, fps_n, fps_d, latest_daily_jam, flags, hours,
minutes, seconds, frames, field_count);
return tc;
}
/**
* gst_video_time_code_new_empty:
*
* Returns: a new empty #GstVideoTimeCode
*
* Since: 1.10
*/
GstVideoTimeCode *
gst_video_time_code_new_empty (void)
{
GstVideoTimeCode *tc;
tc = g_new0 (GstVideoTimeCode, 1);
gst_video_time_code_clear (tc);
return tc;
}
static void
gst_video_time_code_gvalue_from_string (const GValue * str_val, GValue * tc_val)
{
const gchar *tc_str = g_value_get_string (str_val);
GstVideoTimeCode *tc;
tc = gst_video_time_code_new_from_string (tc_str);
g_value_take_boxed (tc_val, tc);
}
static void
gst_video_time_code_gvalue_to_string (const GValue * tc_val, GValue * str_val)
{
const GstVideoTimeCode *tc = g_value_get_boxed (tc_val);
gchar *tc_str;
tc_str = gst_video_time_code_to_string (tc);
g_value_take_string (str_val, tc_str);
}
static gchar *
gst_video_time_code_serialize (const GValue * val)
{
GstVideoTimeCode *tc = g_value_get_boxed (val);
return gst_video_time_code_to_string (tc);
}
static gboolean
gst_video_time_code_deserialize (GValue * dest, const gchar * tc_str)
{
GstVideoTimeCode *tc = gst_video_time_code_new_from_string (tc_str);
if (tc == NULL || !gst_video_time_code_is_valid (tc))
return FALSE;
g_value_take_boxed (dest, tc);
return TRUE;
}
/**
* gst_video_time_code_new_from_string:
* @tc_str: The string that represents the #GstVideoTimeCode
*
* Returns: a new #GstVideoTimeCode from the given string
*
* Since: 1.12
*/
GstVideoTimeCode *
gst_video_time_code_new_from_string (const gchar * tc_str)
{
GstVideoTimeCode *tc;
guint hours, minutes, seconds, frames;
if (sscanf (tc_str, "%02u:%02u:%02u:%02u", &hours, &minutes, &seconds,
&frames)
== 4
|| sscanf (tc_str, "%02u:%02u:%02u;%02u", &hours, &minutes, &seconds,
&frames)
== 4
|| sscanf (tc_str, "%02u:%02u:%02u.%02u", &hours, &minutes, &seconds,
&frames)
== 4
|| sscanf (tc_str, "%02u:%02u:%02u,%02u", &hours, &minutes, &seconds,
&frames)
== 4) {
tc = gst_video_time_code_new (0, 1, NULL, GST_VIDEO_TIME_CODE_FLAGS_NONE,
hours, minutes, seconds, frames, 0);
return tc;
} else {
GST_ERROR ("Warning: Could not parse timecode %s. "
"Please input a timecode in the form 00:00:00:00", tc_str);
return NULL;
}
}
/**
* gst_video_time_code_new_from_date_time:
* @fps_n: Numerator of the frame rate
* @fps_d: Denominator of the frame rate
* @dt: #GDateTime to convert
* @flags: #GstVideoTimeCodeFlags
* @field_count: Interlaced video field count
*
* The resulting config->latest_daily_jam is set to
* midnight, and timecode is set to the given time.
*
* Returns: the #GstVideoTimeCode representation of @dt.
*
* Since: 1.12
*/
GstVideoTimeCode *
gst_video_time_code_new_from_date_time (guint fps_n, guint fps_d,
GDateTime * dt, GstVideoTimeCodeFlags flags, guint field_count)
{
GstVideoTimeCode *tc;
tc = gst_video_time_code_new_empty ();
gst_video_time_code_init_from_date_time (tc, fps_n, fps_d, dt, flags,
field_count);
return tc;
}
/**
* gst_video_time_code_init:
* @tc: a #GstVideoTimeCode
* @fps_n: Numerator of the frame rate
* @fps_d: Denominator of the frame rate
* @latest_daily_jam: The latest daily jam of the #GstVideoTimeCode
* @flags: #GstVideoTimeCodeFlags
* @hours: the hours field of #GstVideoTimeCode
* @minutes: the minutes field of #GstVideoTimeCode
* @seconds: the seconds field of #GstVideoTimeCode
* @frames: the frames field of #GstVideoTimeCode
* @field_count: Interlaced video field count
*
* @field_count is 0 for progressive, 1 or 2 for interlaced.
* @latest_daiy_jam reference is stolen from caller.
*
* Initializes @tc with the given values.
* The values are not checked for being in a valid range. To see if your
* timecode actually has valid content, use #gst_video_time_code_is_valid.
*
* Since: 1.10
*/
void
gst_video_time_code_init (GstVideoTimeCode * tc, guint fps_n, guint fps_d,
GDateTime * latest_daily_jam, GstVideoTimeCodeFlags flags, guint hours,
guint minutes, guint seconds, guint frames, guint field_count)
{
tc->hours = hours;
tc->minutes = minutes;
tc->seconds = seconds;
tc->frames = frames;
tc->field_count = field_count;
tc->config.fps_n = fps_n;
tc->config.fps_d = fps_d;
if (latest_daily_jam != NULL)
tc->config.latest_daily_jam = g_date_time_ref (latest_daily_jam);
else
tc->config.latest_daily_jam = NULL;
tc->config.flags = flags;
}
/**
* gst_video_time_code_clear:
* @tc: a #GstVideoTimeCode
*
* Initializes @tc with empty/zero/NULL values.
*
* Since: 1.10
*/
void
gst_video_time_code_clear (GstVideoTimeCode * tc)
{
tc->hours = 0;
tc->minutes = 0;
tc->seconds = 0;
tc->frames = 0;
tc->field_count = 0;
tc->config.fps_n = 0;
tc->config.fps_d = 1;
if (tc->config.latest_daily_jam != NULL)
g_date_time_unref (tc->config.latest_daily_jam);
tc->config.latest_daily_jam = NULL;
tc->config.flags = 0;
}
/**
* gst_video_time_code_copy:
* @tc: a #GstVideoTimeCode
*
* Returns: a new #GstVideoTimeCode with the same values as @tc .
*
* Since: 1.10
*/
GstVideoTimeCode *
gst_video_time_code_copy (const GstVideoTimeCode * tc)
{
return gst_video_time_code_new (tc->config.fps_n, tc->config.fps_d,
tc->config.latest_daily_jam, tc->config.flags, tc->hours, tc->minutes,
tc->seconds, tc->frames, tc->field_count);
}
/**
* gst_video_time_code_free:
* @tc: a #GstVideoTimeCode
*
* Frees @tc .
*
* Since: 1.10
*/
void
gst_video_time_code_free (GstVideoTimeCode * tc)
{
if (tc->config.latest_daily_jam != NULL)
g_date_time_unref (tc->config.latest_daily_jam);
g_free (tc);
}
/**
* gst_video_time_code_add_interval:
* @tc: The #GstVideoTimeCode where the diff should be added. This
* must contain valid timecode values.
* @tc_inter: The #GstVideoTimeCodeInterval to add to @tc.
* The interval must contain valid values, except that for drop-frame
* timecode, it may also contain timecodes which would normally
* be dropped. These are then corrected to the next reasonable timecode.
*
* This makes a component-wise addition of @tc_inter to @tc. For example,
* adding ("01:02:03:04", "00:01:00:00") will return "01:03:03:04".
* When it comes to drop-frame timecodes,
* adding ("00:00:00;00", "00:01:00:00") will return "00:01:00;02"
* because of drop-frame oddities. However,
* adding ("00:09:00;02", "00:01:00:00") will return "00:10:00;00"
* because this time we can have an exact minute.
*
* Returns: A new #GstVideoTimeCode with @tc_inter added.
*
* Since: 1.12
*/
GstVideoTimeCode *
gst_video_time_code_add_interval (const GstVideoTimeCode * tc,
const GstVideoTimeCodeInterval * tc_inter)
{
GstVideoTimeCode *ret;
guint frames_to_add;
guint df;
gboolean needs_correction;
g_return_val_if_fail (gst_video_time_code_is_valid (tc), NULL);
ret = gst_video_time_code_new (tc->config.fps_n, tc->config.fps_d,
tc->config.latest_daily_jam, tc->config.flags, tc_inter->hours,
tc_inter->minutes, tc_inter->seconds, tc_inter->frames, 0);
df = (tc->config.fps_n + (tc->config.fps_d >> 1)) / (tc->config.fps_d * 15);
/* Drop-frame compensation: Create a valid timecode from the
* interval */
needs_correction = (tc->config.flags & GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME)
&& ret->minutes % 10 && ret->seconds == 0 && ret->frames < df;
if (needs_correction) {
ret->minutes--;
ret->seconds = 59;
ret->frames = df * 14;
}
if (!gst_video_time_code_is_valid (ret)) {
GST_ERROR ("Unsupported time code interval");
gst_video_time_code_free (ret);
return NULL;
}
frames_to_add = gst_video_time_code_frames_since_daily_jam (tc);
/* Drop-frame compensation: 00:01:00;00 is falsely interpreted as
* 00:00:59;28 */
if (needs_correction) {
/* User wants us to split at invalid timecodes */
if (tc->minutes % 10 == 0 && tc->frames <= df) {
/* Apply compensation every 10th minute: before adding the frames,
* but only if we are before the "invalid frame" mark */
frames_to_add += df;
needs_correction = FALSE;
}
}
gst_video_time_code_add_frames (ret, frames_to_add);
if (needs_correction && ret->minutes % 10 == 0 && tc->frames > df) {
gst_video_time_code_add_frames (ret, df);
}
return ret;
}
G_DEFINE_BOXED_TYPE (GstVideoTimeCodeInterval, gst_video_time_code_interval,
(GBoxedCopyFunc) gst_video_time_code_interval_copy,
(GBoxedFreeFunc) gst_video_time_code_interval_free);
/**
* gst_video_time_code_interval_new:
* @hours: the hours field of #GstVideoTimeCodeInterval
* @minutes: the minutes field of #GstVideoTimeCodeInterval
* @seconds: the seconds field of #GstVideoTimeCodeInterval
* @frames: the frames field of #GstVideoTimeCodeInterval
*
* Returns: a new #GstVideoTimeCodeInterval with the given values.
*
* Since: 1.12
*/
GstVideoTimeCodeInterval *
gst_video_time_code_interval_new (guint hours, guint minutes, guint seconds,
guint frames)
{
GstVideoTimeCodeInterval *tc;
tc = g_new0 (GstVideoTimeCodeInterval, 1);
gst_video_time_code_interval_init (tc, hours, minutes, seconds, frames);
return tc;
}
/**
* gst_video_time_code_interval_new_from_string:
* @tc_inter_str: The string that represents the #GstVideoTimeCodeInterval
*
* @tc_inter_str must only have ":" as separators.
*
* Returns: a new #GstVideoTimeCodeInterval from the given string
*
* Since: 1.12
*/
GstVideoTimeCodeInterval *
gst_video_time_code_interval_new_from_string (const gchar * tc_inter_str)
{
GstVideoTimeCodeInterval *tc;
guint hours, minutes, seconds, frames;
if (sscanf (tc_inter_str, "%02u:%02u:%02u:%02u", &hours, &minutes, &seconds,
&frames)
== 4
|| sscanf (tc_inter_str, "%02u:%02u:%02u;%02u", &hours, &minutes,
&seconds, &frames)
== 4
|| sscanf (tc_inter_str, "%02u:%02u:%02u.%02u", &hours, &minutes,
&seconds, &frames)
== 4
|| sscanf (tc_inter_str, "%02u:%02u:%02u,%02u", &hours, &minutes,
&seconds, &frames)
== 4) {
tc = gst_video_time_code_interval_new (hours, minutes, seconds, frames);
return tc;
} else {
GST_ERROR ("Warning: Could not parse timecode %s. "
"Please input a timecode in the form 00:00:00:00", tc_inter_str);
return NULL;
}
}
/**
* gst_video_time_code_interval_init:
* @tc: a #GstVideoTimeCodeInterval
* @hours: the hours field of #GstVideoTimeCodeInterval
* @minutes: the minutes field of #GstVideoTimeCodeInterval
* @seconds: the seconds field of #GstVideoTimeCodeInterval
* @frames: the frames field of #GstVideoTimeCodeInterval
*
* Initializes @tc with the given values.
*
* Since: 1.12
*/
void
gst_video_time_code_interval_init (GstVideoTimeCodeInterval * tc, guint hours,
guint minutes, guint seconds, guint frames)
{
tc->hours = hours;
tc->minutes = minutes;
tc->seconds = seconds;
tc->frames = frames;
}
/**
* gst_video_time_code_interval_clear:
* @tc: a #GstVideoTimeCodeInterval
*
* Initializes @tc with empty/zero/NULL values.
*
* Since: 1.12
*/
void
gst_video_time_code_interval_clear (GstVideoTimeCodeInterval * tc)
{
tc->hours = 0;
tc->minutes = 0;
tc->seconds = 0;
tc->frames = 0;
}
/**
* gst_video_time_code_interval_copy:
* @tc: a #GstVideoTimeCodeInterval
*
* Returns: a new #GstVideoTimeCodeInterval with the same values as @tc .
*
* Since: 1.12
*/
GstVideoTimeCodeInterval *
gst_video_time_code_interval_copy (const GstVideoTimeCodeInterval * tc)
{
return gst_video_time_code_interval_new (tc->hours, tc->minutes,
tc->seconds, tc->frames);
}
/**
* gst_video_time_code_interval_free:
* @tc: a #GstVideoTimeCodeInterval
*
* Frees @tc .
*
* Since: 1.12
*/
void
gst_video_time_code_interval_free (GstVideoTimeCodeInterval * tc)
{
g_free (tc);
}