| /* 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. |
| */ |
| |
| #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; |
| } |