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

}