mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-06 17:39:47 +00:00
332 lines
11 KiB
C
332 lines
11 KiB
C
/* GStreamer
|
|
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
|
|
* Library <2002> Ronald Bultje <rbultje@ronald.bitfreak.net>
|
|
* Copyright (C) 2007 David A. Schleef <ds@schleef.org>
|
|
*
|
|
* 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 "video-event.h"
|
|
|
|
#define GST_VIDEO_EVENT_STILL_STATE_NAME "GstEventStillFrame"
|
|
|
|
/**
|
|
* gst_video_event_new_still_frame:
|
|
* @in_still: boolean value for the still-frame state of the event.
|
|
*
|
|
* Creates a new Still Frame event. If @in_still is %TRUE, then the event
|
|
* represents the start of a still frame sequence. If it is %FALSE, then
|
|
* the event ends a still frame sequence.
|
|
*
|
|
* To parse an event created by gst_video_event_new_still_frame() use
|
|
* gst_video_event_parse_still_frame().
|
|
*
|
|
* Returns: The new GstEvent
|
|
*/
|
|
GstEvent *
|
|
gst_video_event_new_still_frame (gboolean in_still)
|
|
{
|
|
GstEvent *still_event;
|
|
GstStructure *s;
|
|
|
|
s = gst_structure_new (GST_VIDEO_EVENT_STILL_STATE_NAME,
|
|
"still-state", G_TYPE_BOOLEAN, in_still, NULL);
|
|
still_event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
|
|
|
|
return still_event;
|
|
}
|
|
|
|
/**
|
|
* gst_video_event_parse_still_frame:
|
|
* @event: A #GstEvent to parse
|
|
* @in_still: (out):
|
|
* A boolean to receive the still-frame status from the event, or NULL
|
|
*
|
|
* Parse a #GstEvent, identify if it is a Still Frame event, and
|
|
* return the still-frame state from the event if it is.
|
|
* If the event represents the start of a still frame, the in_still
|
|
* variable will be set to TRUE, otherwise FALSE. It is OK to pass NULL for the
|
|
* in_still variable order to just check whether the event is a valid still-frame
|
|
* event.
|
|
*
|
|
* Create a still frame event using gst_video_event_new_still_frame()
|
|
*
|
|
* Returns: %TRUE if the event is a valid still-frame event. %FALSE if not
|
|
*/
|
|
gboolean
|
|
gst_video_event_parse_still_frame (GstEvent * event, gboolean * in_still)
|
|
{
|
|
const GstStructure *s;
|
|
gboolean ev_still_state;
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_DOWNSTREAM)
|
|
return FALSE; /* Not a still frame event */
|
|
|
|
s = gst_event_get_structure (event);
|
|
if (s == NULL
|
|
|| !gst_structure_has_name (s, GST_VIDEO_EVENT_STILL_STATE_NAME))
|
|
return FALSE; /* Not a still frame event */
|
|
if (!gst_structure_get_boolean (s, "still-state", &ev_still_state))
|
|
return FALSE; /* Not a still frame event */
|
|
if (in_still)
|
|
*in_still = ev_still_state;
|
|
return TRUE;
|
|
}
|
|
|
|
#define GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME "GstForceKeyUnit"
|
|
|
|
/**
|
|
* gst_video_event_new_downstream_force_key_unit:
|
|
* @timestamp: the timestamp of the buffer that starts a new key unit
|
|
* @stream_time: the stream_time of the buffer that starts a new key unit
|
|
* @running_time: the running_time of the buffer that starts a new key unit
|
|
* @all_headers: %TRUE to produce headers when starting a new key unit
|
|
* @count: integer that can be used to number key units
|
|
*
|
|
* Creates a new downstream force key unit event. A downstream force key unit
|
|
* event can be sent down the pipeline to request downstream elements to produce
|
|
* a key unit. A downstream force key unit event must also be sent when handling
|
|
* an upstream force key unit event to notify downstream that the latter has been
|
|
* handled.
|
|
*
|
|
* To parse an event created by gst_video_event_new_downstream_force_key_unit() use
|
|
* gst_video_event_parse_downstream_force_key_unit().
|
|
*
|
|
* Returns: The new GstEvent
|
|
*/
|
|
GstEvent *
|
|
gst_video_event_new_downstream_force_key_unit (GstClockTime timestamp,
|
|
GstClockTime stream_time, GstClockTime running_time, gboolean all_headers,
|
|
guint count)
|
|
{
|
|
GstEvent *force_key_unit_event;
|
|
GstStructure *s;
|
|
|
|
s = gst_structure_new (GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME,
|
|
"timestamp", G_TYPE_UINT64, timestamp,
|
|
"stream-time", G_TYPE_UINT64, stream_time,
|
|
"running-time", G_TYPE_UINT64, running_time,
|
|
"all-headers", G_TYPE_BOOLEAN, all_headers,
|
|
"count", G_TYPE_UINT, count, NULL);
|
|
force_key_unit_event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
|
|
|
|
return force_key_unit_event;
|
|
}
|
|
|
|
/**
|
|
* gst_video_event_new_upstream_force_key_unit:
|
|
* @running_time: the running_time at which a new key unit should be produced
|
|
* @all_headers: %TRUE to produce headers when starting a new key unit
|
|
* @count: integer that can be used to number key units
|
|
*
|
|
* Creates a new upstream force key unit event. An upstream force key unit event
|
|
* can be sent to request upstream elements to produce a key unit.
|
|
*
|
|
* @running_time can be set to request a new key unit at a specific
|
|
* running_time. If set to GST_CLOCK_TIME_NONE, upstream elements will produce a
|
|
* new key unit as soon as possible.
|
|
*
|
|
* To parse an event created by gst_video_event_new_downstream_force_key_unit() use
|
|
* gst_video_event_parse_downstream_force_key_unit().
|
|
*
|
|
* Returns: The new GstEvent
|
|
*/
|
|
GstEvent *
|
|
gst_video_event_new_upstream_force_key_unit (GstClockTime running_time,
|
|
gboolean all_headers, guint count)
|
|
{
|
|
GstEvent *force_key_unit_event;
|
|
GstStructure *s;
|
|
|
|
s = gst_structure_new (GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME,
|
|
"running-time", GST_TYPE_CLOCK_TIME, running_time,
|
|
"all-headers", G_TYPE_BOOLEAN, all_headers,
|
|
"count", G_TYPE_UINT, count, NULL);
|
|
force_key_unit_event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM, s);
|
|
|
|
return force_key_unit_event;
|
|
}
|
|
|
|
/**
|
|
* gst_video_event_is_force_key_unit:
|
|
* @event: A #GstEvent to check
|
|
*
|
|
* Checks if an event is a force key unit event. Returns true for both upstream
|
|
* and downstream force key unit events.
|
|
*
|
|
* Returns: %TRUE if the event is a valid force key unit event
|
|
*/
|
|
gboolean
|
|
gst_video_event_is_force_key_unit (GstEvent * event)
|
|
{
|
|
const GstStructure *s;
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_DOWNSTREAM &&
|
|
GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_UPSTREAM)
|
|
return FALSE; /* Not a force key unit event */
|
|
|
|
s = gst_event_get_structure (event);
|
|
if (s == NULL
|
|
|| !gst_structure_has_name (s, GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_video_event_parse_downstream_force_key_unit:
|
|
* @event: A #GstEvent to parse
|
|
* @timestamp: (out): A pointer to the timestamp in the event
|
|
* @stream_time: (out): A pointer to the stream-time in the event
|
|
* @running_time: (out): A pointer to the running-time in the event
|
|
* @all_headers: (out): A pointer to the all_headers flag in the event
|
|
* @count: (out): A pointer to the count field of the event
|
|
*
|
|
* Get timestamp, stream-time, running-time, all-headers and count in the force
|
|
* key unit event. See gst_video_event_new_downstream_force_key_unit() for a
|
|
* full description of the downstream force key unit event.
|
|
*
|
|
* @running_time will be adjusted for any pad offsets of pads it was passing through.
|
|
*
|
|
* Returns: %TRUE if the event is a valid downstream force key unit event.
|
|
*/
|
|
gboolean
|
|
gst_video_event_parse_downstream_force_key_unit (GstEvent * event,
|
|
GstClockTime * timestamp, GstClockTime * stream_time,
|
|
GstClockTime * running_time, gboolean * all_headers, guint * count)
|
|
{
|
|
const GstStructure *s;
|
|
GstClockTime ev_timestamp, ev_stream_time, ev_running_time;
|
|
gboolean ev_all_headers;
|
|
guint ev_count;
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_DOWNSTREAM)
|
|
return FALSE; /* Not a force key unit event */
|
|
|
|
s = gst_event_get_structure (event);
|
|
if (s == NULL
|
|
|| !gst_structure_has_name (s, GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME))
|
|
return FALSE;
|
|
|
|
if (!gst_structure_get_clock_time (s, "timestamp", &ev_timestamp))
|
|
ev_timestamp = GST_CLOCK_TIME_NONE;
|
|
if (!gst_structure_get_clock_time (s, "stream-time", &ev_stream_time))
|
|
ev_stream_time = GST_CLOCK_TIME_NONE;
|
|
if (!gst_structure_get_clock_time (s, "running-time", &ev_running_time))
|
|
ev_running_time = GST_CLOCK_TIME_NONE;
|
|
if (!gst_structure_get_boolean (s, "all-headers", &ev_all_headers))
|
|
ev_all_headers = FALSE;
|
|
if (!gst_structure_get_uint (s, "count", &ev_count))
|
|
ev_count = 0;
|
|
|
|
if (timestamp)
|
|
*timestamp = ev_timestamp;
|
|
|
|
if (stream_time)
|
|
*stream_time = ev_stream_time;
|
|
|
|
if (running_time) {
|
|
gint64 offset = gst_event_get_running_time_offset (event);
|
|
|
|
*running_time = ev_running_time;
|
|
/* Catch underflows */
|
|
if (*running_time > -offset)
|
|
*running_time += offset;
|
|
else
|
|
*running_time = 0;
|
|
}
|
|
|
|
if (all_headers)
|
|
*all_headers = ev_all_headers;
|
|
|
|
if (count)
|
|
*count = ev_count;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_video_event_parse_upstream_force_key_unit:
|
|
* @event: A #GstEvent to parse
|
|
* @running_time: (out): A pointer to the running_time in the event
|
|
* @all_headers: (out): A pointer to the all_headers flag in the event
|
|
* @count: (out): A pointer to the count field in the event
|
|
*
|
|
* Get running-time, all-headers and count in the force key unit event. See
|
|
* gst_video_event_new_upstream_force_key_unit() for a full description of the
|
|
* upstream force key unit event.
|
|
*
|
|
* Create an upstream force key unit event using gst_video_event_new_upstream_force_key_unit()
|
|
*
|
|
* @running_time will be adjusted for any pad offsets of pads it was passing through.
|
|
*
|
|
* Returns: %TRUE if the event is a valid upstream force-key-unit event. %FALSE if not
|
|
*/
|
|
gboolean
|
|
gst_video_event_parse_upstream_force_key_unit (GstEvent * event,
|
|
GstClockTime * running_time, gboolean * all_headers, guint * count)
|
|
{
|
|
const GstStructure *s;
|
|
GstClockTime ev_running_time;
|
|
gboolean ev_all_headers;
|
|
guint ev_count;
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (GST_EVENT_TYPE (event) != GST_EVENT_CUSTOM_UPSTREAM)
|
|
return FALSE; /* Not a force key unit event */
|
|
|
|
s = gst_event_get_structure (event);
|
|
if (s == NULL
|
|
|| !gst_structure_has_name (s, GST_VIDEO_EVENT_FORCE_KEY_UNIT_NAME))
|
|
return FALSE;
|
|
|
|
if (!gst_structure_get_clock_time (s, "running-time", &ev_running_time))
|
|
ev_running_time = GST_CLOCK_TIME_NONE;
|
|
if (!gst_structure_get_boolean (s, "all-headers", &ev_all_headers))
|
|
ev_all_headers = FALSE;
|
|
if (!gst_structure_get_uint (s, "count", &ev_count))
|
|
ev_count = 0;
|
|
|
|
|
|
if (running_time) {
|
|
gint64 offset = gst_event_get_running_time_offset (event);
|
|
|
|
*running_time = ev_running_time;
|
|
/* Catch underflows */
|
|
if (*running_time > -offset)
|
|
*running_time += offset;
|
|
else
|
|
*running_time = 0;
|
|
}
|
|
|
|
if (all_headers)
|
|
*all_headers = ev_all_headers;
|
|
|
|
if (count)
|
|
*count = ev_count;
|
|
|
|
return TRUE;
|
|
}
|