static void
gst_overlay_loop (GstElement * element)
{
GstOverlay *overlay;
GstBuffer *out;
GstBuffer *in1 = NULL, *in2 = NULL, *in3 = NULL;
int size;
overlay = GST_OVERLAY (element);
in1 = GST_BUFFER (gst_pad_pull (overlay->sinkpad1));
if (GST_IS_EVENT (in1)) {
gst_pad_push (overlay->srcpad, GST_DATA (in1));
/* FIXME */
return;
}
in2 = GST_BUFFER (gst_pad_pull (overlay->sinkpad2));
if (GST_IS_EVENT (in2)) {
gst_pad_push (overlay->srcpad, GST_DATA (in2));
/* FIXME */
return;
}
in3 = GST_BUFFER (gst_pad_pull (overlay->sinkpad3));
if (GST_IS_EVENT (in3)) {
gst_pad_push (overlay->srcpad, GST_DATA (in3));
/* FIXME */
return;
}
g_return_if_fail (in1 != NULL);
g_return_if_fail (in2 != NULL);
g_return_if_fail (in3 != NULL);
size = (overlay->width * overlay->height * 3) / 2;
g_return_if_fail (GST_BUFFER_SIZE (in1) != size);
g_return_if_fail (GST_BUFFER_SIZE (in2) != size);
g_return_if_fail (GST_BUFFER_SIZE (in3) != size);
out = gst_buffer_new_and_alloc (size);
gst_overlay_blend_i420 (GST_BUFFER_DATA (out),
GST_BUFFER_DATA (in1),
GST_BUFFER_DATA (in2),
GST_BUFFER_DATA (in3), overlay->width, overlay->height);
GST_BUFFER_TIMESTAMP (out) = GST_BUFFER_TIMESTAMP (in1);
GST_BUFFER_DURATION (out) = GST_BUFFER_DURATION (in1);
gst_buffer_unref (in1);
gst_buffer_unref (in2);
gst_buffer_unref (in3);
gst_pad_push (overlay->srcpad, GST_DATA (out));
}
static void
gst_sdlvideosink_navigation_send_event (GstNavigation * navigation,
GstStructure * structure)
{
GstSDLVideoSink *sdlvideosink = GST_SDLVIDEOSINK (navigation);
GstEvent *event;
GstVideoRectangle dst = { 0, };
GstVideoRectangle src = { 0, };
GstVideoRectangle result;
double x, y, old_x, old_y;
GstPad *pad = NULL;
src.w = GST_VIDEO_SINK_WIDTH (sdlvideosink);
src.h = GST_VIDEO_SINK_HEIGHT (sdlvideosink);
dst.w = sdlvideosink->width;
dst.h = sdlvideosink->height;
gst_video_sink_center_rect (src, dst, &result, FALSE);
event = gst_event_new_navigation (structure);
/* Our coordinates can be wrong here if we centered the video */
/* Converting pointer coordinates to the non scaled geometry */
if (gst_structure_get_double (structure, "pointer_x", &old_x)) {
x = old_x;
if (x >= result.x && x <= (result.x + result.w)) {
x -= result.x;
x *= sdlvideosink->width;
x /= result.w;
} else {
x = 0;
}
GST_DEBUG_OBJECT (sdlvideosink, "translated navigation event x "
"coordinate from %f to %f", old_x, x);
gst_structure_set (structure, "pointer_x", G_TYPE_DOUBLE, x, NULL);
}
if (gst_structure_get_double (structure, "pointer_y", &old_y)) {
y = old_y;
if (y >= result.y && y <= (result.y + result.h)) {
y -= result.y;
y *= sdlvideosink->height;
y /= result.h;
} else {
y = 0;
}
GST_DEBUG_OBJECT (sdlvideosink, "translated navigation event y "
"coordinate from %f to %f", old_y, y);
gst_structure_set (structure, "pointer_y", G_TYPE_DOUBLE, y, NULL);
}
pad = gst_pad_get_peer (GST_VIDEO_SINK_PAD (sdlvideosink));
if (GST_IS_PAD (pad) && GST_IS_EVENT (event)) {
gst_pad_send_event (pad, event);
gst_object_unref (pad);
}
}
/**
* gst_event_get_structure:
* @event: The #GstEvent.
*
* Access the structure of the event.
*
* Returns: The structure of the event. The structure is still
* owned by the event, which means that you should not free it and
* that the pointer becomes invalid when you free the event.
*
* MT safe.
*/
const GstStructure *
gst_event_get_structure (GstEvent * event)
{
g_return_val_if_fail (GST_IS_EVENT (event), NULL);
return event->structure;
}
/**
* gst_event_get_seqnum:
* @event: A #GstEvent.
*
* Retrieve the sequence number of a event.
*
* Events have ever-incrementing sequence numbers, which may also be set
* explicitly via gst_event_set_seqnum(). Sequence numbers are typically used to
* indicate that a event corresponds to some other set of events or messages,
* for example an EOS event corresponding to a SEEK event. It is considered good
* practice to make this correspondence when possible, though it is not
* required.
*
* Note that events and messages share the same sequence number incrementor;
* two events or messages will never have the same sequence number unless
* that correspondence was made explicitly.
*
* Returns: The event's sequence number.
*
* MT safe.
*/
guint32
gst_event_get_seqnum (GstEvent * event)
{
g_return_val_if_fail (GST_IS_EVENT (event), -1);
return GST_EVENT_SEQNUM (event);
}
/**
* gst_event_get_structure:
* @event: The #GstEvent.
*
* Access the structure of the event.
*
* Returns: The structure of the event. The structure is still
* owned by the event, which means that you should not free it and
* that the pointer becomes invalid when you free the event.
*
* MT safe.
*/
const GstStructure *
gst_event_get_structure (GstEvent * event)
{
g_return_val_if_fail (GST_IS_EVENT (event), NULL);
return GST_EVENT_STRUCTURE (event);
}
gboolean
shmdata_base_reader_reset_time (GstPad *pad,
GstMiniObject * mini_obj,
gpointer user_data)
{
shmdata_base_reader_t *context = (shmdata_base_reader_t *) user_data;
if (GST_IS_EVENT (mini_obj))
{
//g_debug ("EVENT %s", GST_EVENT_TYPE_NAME (GST_EVENT_CAST(mini_obj)));
}
else if (GST_IS_BUFFER (mini_obj))
{
GstBuffer *buffer = GST_BUFFER_CAST (mini_obj);
/* g_debug ("shmdata writer data frame (%p), data size %d, timestamp %llu, caps %s", */
/* GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer), */
/* GST_TIME_AS_MSECONDS (GST_BUFFER_TIMESTAMP (buffer)), */
/* gst_caps_to_string (GST_BUFFER_CAPS (buffer))); */
if (context->timereset_)
{
context->timeshift_ = GST_BUFFER_TIMESTAMP (buffer);
context->timereset_ = FALSE;
}
GST_BUFFER_TIMESTAMP (buffer) =
GST_BUFFER_TIMESTAMP (buffer) - context->timeshift_;
}
else if (GST_IS_MESSAGE (mini_obj))
{
}
return TRUE;
}
/**
* gst_event_parse_step:
* @event: The event to query
* @format: (out) (allow-none): a pointer to store the format in
* @amount: (out) (allow-none): a pointer to store the amount in
* @rate: (out) (allow-none): a pointer to store the rate in
* @flush: (out) (allow-none): a pointer to store the flush boolean in
* @intermediate: (out) (allow-none): a pointer to store the intermediate
* boolean in
*
* Parse the step event.
*/
void
gst_event_parse_step (GstEvent * event, GstFormat * format, guint64 * amount,
gdouble * rate, gboolean * flush, gboolean * intermediate)
{
const GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_STEP);
structure = GST_EVENT_STRUCTURE (event);
if (format)
*format =
(GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,
GST_QUARK (FORMAT)));
if (amount)
*amount = g_value_get_uint64 (gst_structure_id_get_value (structure,
GST_QUARK (AMOUNT)));
if (rate)
*rate = g_value_get_double (gst_structure_id_get_value (structure,
GST_QUARK (RATE)));
if (flush)
*flush = g_value_get_boolean (gst_structure_id_get_value (structure,
GST_QUARK (FLUSH)));
if (intermediate)
*intermediate = g_value_get_boolean (gst_structure_id_get_value (structure,
GST_QUARK (INTERMEDIATE)));
}
/* Data probe cb to drop everything but count buffers and events */
static GstPadProbeReturn
probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
{
gint count = 0;
const gchar *count_type = NULL;
GstMiniObject *obj = GST_PAD_PROBE_INFO_DATA (info);
GST_LOG_OBJECT (pad, "got data");
if (GST_IS_BUFFER (obj)) {
count_type = "buffer_count";
} else if (GST_IS_EVENT (obj)) {
count_type = "event_count";
} else {
g_assert_not_reached ();
}
/* increment and store count */
count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pad), count_type));
count++;
g_object_set_data (G_OBJECT (pad), count_type, GINT_TO_POINTER (count));
/* drop every buffer */
return GST_IS_BUFFER (obj) ? GST_PAD_PROBE_DROP : GST_PAD_PROBE_PASS;
}
/**
* gst_event_parse_qos:
* @event: The event to query
* @type: (out): A pointer to store the QoS type in
* @proportion: (out): A pointer to store the proportion in
* @diff: (out): A pointer to store the diff in
* @timestamp: (out): A pointer to store the timestamp in
*
* Get the type, proportion, diff and timestamp in the qos event. See
* gst_event_new_qos() for more information about the different QoS values.
*/
void
gst_event_parse_qos (GstEvent * event, GstQOSType * type,
gdouble * proportion, GstClockTimeDiff * diff, GstClockTime * timestamp)
{
const GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_QOS);
structure = GST_EVENT_STRUCTURE (event);
if (type)
*type = (GstQOSType)
g_value_get_enum (gst_structure_id_get_value (structure,
GST_QUARK (TYPE)));
if (proportion)
*proportion =
g_value_get_double (gst_structure_id_get_value (structure,
GST_QUARK (PROPORTION)));
if (diff)
*diff =
g_value_get_int64 (gst_structure_id_get_value (structure,
GST_QUARK (DIFF)));
if (timestamp)
*timestamp =
g_value_get_uint64 (gst_structure_id_get_value (structure,
GST_QUARK (TIMESTAMP)));
}
/**
* gst_event_parse_buffer_size:
* @event: The event to query
* @format: (out): A pointer to store the format in
* @minsize: (out): A pointer to store the minsize in
* @maxsize: (out): A pointer to store the maxsize in
* @async: (out): A pointer to store the async-flag in
*
* Get the format, minsize, maxsize and async-flag in the buffersize event.
*/
void
gst_event_parse_buffer_size (GstEvent * event, GstFormat * format,
gint64 * minsize, gint64 * maxsize, gboolean * async)
{
const GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_BUFFERSIZE);
structure = GST_EVENT_STRUCTURE (event);
if (format)
*format = (GstFormat)
g_value_get_enum (gst_structure_id_get_value (structure,
GST_QUARK (FORMAT)));
if (minsize)
*minsize =
g_value_get_int64 (gst_structure_id_get_value (structure,
GST_QUARK (MINSIZE)));
if (maxsize)
*maxsize =
g_value_get_int64 (gst_structure_id_get_value (structure,
GST_QUARK (MAXSIZE)));
if (async)
*async =
g_value_get_boolean (gst_structure_id_get_value (structure,
GST_QUARK (ASYNC)));
}
/**
* gst_event_set_seqnum:
* @event: A #GstEvent.
* @seqnum: A sequence number.
*
* Set the sequence number of a event.
*
* This function might be called by the creator of a event to indicate that the
* event relates to other events or messages. See gst_event_get_seqnum() for
* more information.
*
* MT safe.
*/
void
gst_event_set_seqnum (GstEvent * event, guint32 seqnum)
{
g_return_if_fail (GST_IS_EVENT (event));
GST_EVENT_SEQNUM (event) = seqnum;
}
static GstPadProbeReturn
event_counter (GstObject * pad, GstPadProbeInfo * info, gpointer user_data)
{
GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
fail_unless (event != NULL);
fail_unless (GST_IS_EVENT (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_STREAM_START:
++nb_stream_start_event;
break;
case GST_EVENT_CAPS:
++nb_caps_event;
break;
case GST_EVENT_SEGMENT:
++nb_segment_event;
break;
case GST_EVENT_GAP:
++nb_gap_event;
break;
default:
break;
}
return GST_PAD_PROBE_OK;
}
static void
dxr3videosink_chain (GstPad * pad, GstData * _data)
{
GstBuffer *buf = GST_BUFFER (_data);
Dxr3VideoSink *sink;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (buf != NULL);
sink = DXR3VIDEOSINK (gst_pad_get_parent (pad));
if (GST_IS_EVENT (buf)) {
dxr3videosink_handle_event (pad, GST_EVENT (buf));
return;
}
/* fprintf (stderr, "^^^^^^ Video block\n"); */
if (sink->cur_buf == NULL) {
sink->cur_buf = buf;
} else {
sink->cur_buf = gst_buffer_append (sink->cur_buf, buf);
}
sink->last_ts = GST_BUFFER_TIMESTAMP (buf);
dxr3videosink_parse_data (sink);
}
static void
gst_mikmod_loop (GstElement * element)
{
GstMikMod *mikmod;
GstBuffer *buffer_in;
g_return_if_fail (element != NULL);
g_return_if_fail (GST_IS_MIKMOD (element));
mikmod = GST_MIKMOD (element);
srcpad = mikmod->srcpad;
mikmod->Buffer = NULL;
if (!mikmod->initialized) {
while ((buffer_in = GST_BUFFER (gst_pad_pull (mikmod->sinkpad)))) {
if (GST_IS_EVENT (buffer_in)) {
GstEvent *event = GST_EVENT (buffer_in);
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS)
break;
} else {
if (mikmod->Buffer) {
mikmod->Buffer = gst_buffer_append (mikmod->Buffer, buffer_in);
} else {
mikmod->Buffer = buffer_in;
}
}
}
if (!GST_PAD_CAPS (mikmod->srcpad)) {
if (GST_PAD_LINK_SUCCESSFUL (gst_pad_renegotiate (mikmod->srcpad))) {
GST_ELEMENT_ERROR (mikmod, CORE, NEGOTIATION, (NULL), (NULL));
return;
}
}
MikMod_RegisterDriver (&drv_gst);
MikMod_RegisterAllLoaders ();
MikMod_Init ("");
reader = GST_READER_new (mikmod);
module = Player_LoadGeneric (reader, 64, 0);
gst_buffer_unref (mikmod->Buffer);
if (!Player_Active ())
Player_Start (module);
mikmod->initialized = TRUE;
}
if (Player_Active ()) {
timestamp = (module->sngtime / 1024.0) * GST_SECOND;
drv_gst.Update ();
} else {
gst_element_set_eos (GST_ELEMENT (mikmod));
gst_pad_push (mikmod->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
}
}
static gboolean
handle_queued_objects (APP_STATE_T * state)
{
GstMiniObject *object = NULL;
g_mutex_lock (&state->queue_lock);
if (state->flushing) {
g_cond_broadcast (&state->cond);
goto beach;
} else if (g_async_queue_length (state->queue) == 0) {
goto beach;
}
if ((object = g_async_queue_try_pop (state->queue))) {
if (GST_IS_BUFFER (object)) {
GstBuffer *buffer = GST_BUFFER_CAST (object);
update_image (state, buffer);
render_scene (state);
gst_buffer_unref (buffer);
if (!SYNC_BUFFERS) {
object = NULL;
}
} else if (GST_IS_QUERY (object)) {
GstQuery *query = GST_QUERY_CAST (object);
GstStructure *s = (GstStructure *) gst_query_get_structure (query);
if (gst_structure_has_name (s, "not-used")) {
g_assert_not_reached ();
} else {
g_assert_not_reached ();
}
} else if (GST_IS_EVENT (object)) {
GstEvent *event = GST_EVENT_CAST (object);
g_print ("\nevent %p %s\n", event,
gst_event_type_get_name (GST_EVENT_TYPE (event)));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
flush_internal (state);
break;
default:
break;
}
gst_event_unref (event);
object = NULL;
}
}
if (object) {
state->popped_obj = object;
g_cond_broadcast (&state->cond);
}
beach:
g_mutex_unlock (&state->queue_lock);
return FALSE;
}
/**
* gst_event_parse_tag:
* @event: a tag event
* @taglist: (out) (transfer none): pointer to metadata list
*
* Parses a tag @event and stores the results in the given @taglist location.
* No reference to the taglist will be returned, it remains valid only until
* the @event is freed. Don't modify or free the taglist, make a copy if you
* want to modify it or store it for later use.
*/
void
gst_event_parse_tag (GstEvent * event, GstTagList ** taglist)
{
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TAG);
if (taglist)
*taglist = (GstTagList *) event->structure;
}
static gboolean
event_probe (GstPad * pad, GstEvent * obj, gpointer data)
{
n_event_probes++;
GST_DEBUG ("event probe %d", n_event_probes);
g_assert (GST_IS_EVENT (obj));
g_assert (data == SPECIAL_POINTER (2));
return TRUE;
}
static GstPadProbeReturn
pad_blocked_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
{
GstPlaySinkConvertBin *self = user_data;
GstPad *peer;
GstCaps *caps;
gboolean raw;
if (GST_IS_EVENT (info->data) && !GST_EVENT_IS_SERIALIZED (info->data)) {
GST_DEBUG_OBJECT (self, "Letting non-serialized event %s pass",
GST_EVENT_TYPE_NAME (info->data));
return GST_PAD_PROBE_PASS;
}
GST_PLAY_SINK_CONVERT_BIN_LOCK (self);
GST_DEBUG_OBJECT (self, "Pad blocked");
/* There must be a peer at this point */
peer = gst_pad_get_peer (self->sinkpad);
caps = gst_pad_get_current_caps (peer);
if (!caps)
caps = gst_pad_query_caps (peer, NULL);
gst_object_unref (peer);
raw = is_raw_caps (caps, self->audio);
GST_DEBUG_OBJECT (self, "Caps %" GST_PTR_FORMAT " are raw: %d", caps, raw);
gst_caps_unref (caps);
if (raw == self->raw)
goto unblock;
self->raw = raw;
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->sinkpad), NULL);
gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), NULL);
if (raw) {
GST_DEBUG_OBJECT (self, "Switching to raw conversion pipeline");
if (self->conversion_elements)
g_list_foreach (self->conversion_elements,
(GFunc) gst_play_sink_convert_bin_on_element_added, self);
} else {
GST_DEBUG_OBJECT (self, "Switch to passthrough pipeline");
gst_play_sink_convert_bin_on_element_added (self->identity, self);
}
gst_play_sink_convert_bin_set_targets (self, !raw);
unblock:
self->sink_proxypad_block_id = 0;
GST_PLAY_SINK_CONVERT_BIN_UNLOCK (self);
return GST_PAD_PROBE_REMOVE;
}
static gboolean
event_probe_once (GstPad * pad, GstEvent * obj, guint * data)
{
n_event_probes_once++;
g_assert (GST_IS_EVENT (obj));
gst_pad_remove_event_probe (pad, *data);
return TRUE;
}
/**
* gst_event_has_name:
* @event: The #GstEvent.
* @name: name to check
*
* Checks if @event has the given @name. This function is usually used to
* check the name of a custom event.
*
* Returns: %TRUE if @name matches the name of the event structure.
*/
gboolean
gst_event_has_name (GstEvent * event, const gchar * name)
{
g_return_val_if_fail (GST_IS_EVENT (event), FALSE);
if (GST_EVENT_STRUCTURE (event) == NULL)
return FALSE;
return gst_structure_has_name (GST_EVENT_STRUCTURE (event), name);
}
static gboolean
event_probe (GstPad * pad, GstEvent * obj, gpointer data)
{
n_event_probes++;
GST_DEBUG_OBJECT (pad, "event probe %d [%s]",
n_event_probes, GST_EVENT_TYPE_NAME (obj));
g_assert (GST_IS_EVENT (obj));
g_assert (data == SPECIAL_POINTER (2));
return TRUE;
}
/**
* gst_event_parse_sink_message:
* @event: The event to query
* @msg: (out) (transfer full): a pointer to store the #GstMessage in.
*
* Parse the sink-message event. Unref @msg after usage.
*
* Since: 0.10.26
*/
void
gst_event_parse_sink_message (GstEvent * event, GstMessage ** msg)
{
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SINK_MESSAGE);
if (msg)
*msg =
GST_MESSAGE (gst_value_dup_mini_object (gst_structure_id_get_value
(event->structure, GST_QUARK (MESSAGE))));
}
/**
* gst_event_parse_latency:
* @event: The event to query
* @latency: (out): A pointer to store the latency in.
*
* Get the latency in the latency event.
*/
void
gst_event_parse_latency (GstEvent * event, GstClockTime * latency)
{
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_LATENCY);
if (latency)
*latency =
g_value_get_uint64 (gst_structure_id_get_value (GST_EVENT_STRUCTURE
(event), GST_QUARK (LATENCY)));
}
/* reconfiguration is not supported by all sources and can be disruptive
* we will handle reconfiguration manually
* FIXME: implement source reconfiguration support :) */
static GstPadProbeReturn drop_reconfigure_cb(GstPad *pad, GstPadProbeInfo *info, gpointer user_data)
{
OWR_UNUSED(pad);
OWR_UNUSED(user_data);
if (GST_IS_EVENT(GST_PAD_PROBE_INFO_DATA(info))
&& GST_EVENT_TYPE(GST_PAD_PROBE_INFO_EVENT(info)) == GST_EVENT_RECONFIGURE) {
GST_DEBUG("Dropping reconfigure event");
return GST_PAD_PROBE_DROP;
}
return GST_PAD_PROBE_OK;
}
/**
* gst_event_copy_segment:
* @event: The event to parse
* @segment: a pointer to a #GstSegment
*
* Parses a segment @event and copies the #GstSegment into the location
* given by @segment.
*/
void
gst_event_copy_segment (GstEvent * event, GstSegment * segment)
{
const GstSegment *src;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT);
if (segment) {
gst_event_parse_segment (event, &src);
gst_segment_copy_into (src, segment);
}
}
static gboolean
on_video_sink_data_flow (GstPad * pad, GstMiniObject * mini_obj,
gpointer user_data)
{
GstFPSDisplaySink *self = GST_FPS_DISPLAY_SINK (user_data);
#if 0
if (GST_IS_BUFFER (mini_obj)) {
GstBuffer *buf = GST_BUFFER_CAST (mini_obj);
if (GST_CLOCK_TIME_IS_VALID (self->next_ts)) {
if (GST_BUFFER_TIMESTAMP (buf) <= self->next_ts) {
self->frames_rendered++;
} else {
GST_WARNING_OBJECT (self, "dropping frame : ts %" GST_TIME_FORMAT
" < expected_ts %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
GST_TIME_ARGS (self->next_ts));
self->frames_dropped++;
}
} else {
self->frames_rendered++;
}
} else
#endif
if (GST_IS_EVENT (mini_obj)) {
GstEvent *ev = GST_EVENT_CAST (mini_obj);
if (GST_EVENT_TYPE (ev) == GST_EVENT_QOS) {
GstClockTimeDiff diff;
GstClockTime ts;
gst_event_parse_qos (ev, NULL, &diff, &ts);
if (diff <= 0.0) {
g_atomic_int_inc (&self->frames_rendered);
} else {
g_atomic_int_inc (&self->frames_dropped);
}
ts = gst_util_get_timestamp ();
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (self->start_ts))) {
self->interval_ts = self->last_ts = self->start_ts = ts;
}
if (GST_CLOCK_DIFF (self->interval_ts, ts) > self->fps_update_interval) {
display_current_fps (self);
self->interval_ts = ts;
}
}
}
return TRUE;
}
/**
* gst_event_parse_tag:
* @event: a tag event
* @taglist: (out) (transfer none): pointer to metadata list
*
* Parses a tag @event and stores the results in the given @taglist location.
* No reference to the taglist will be returned, it remains valid only until
* the @event is freed. Don't modify or free the taglist, make a copy if you
* want to modify it or store it for later use.
*/
void
gst_event_parse_tag (GstEvent * event, GstTagList ** taglist)
{
const GValue *val;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TAG);
val = gst_structure_id_get_value (GST_EVENT_STRUCTURE (event),
GST_QUARK (TAGLIST));
if (taglist)
*taglist = (GstTagList *) g_value_get_boxed (val);
}
/**
* gst_event_parse_segment:
* @event: The event to parse
* @segment: (out) (transfer none): a pointer to a #GstSegment
*
* Parses a segment @event and stores the result in the given @segment location.
* @segment remains valid only until the @event is freed. Don't modify the segment
* and make a copy if you want to modify it or store it for later use.
*/
void
gst_event_parse_segment (GstEvent * event, const GstSegment ** segment)
{
GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT);
if (segment) {
structure = GST_EVENT_STRUCTURE (event);
*segment = g_value_get_boxed (gst_structure_id_get_value (structure,
GST_QUARK (SEGMENT)));
}
}
/**
* gst_event_parse_caps:
* @event: The event to parse
* @caps: (out) (transfer none): A pointer to the caps
*
* Get the caps from @event. The caps remains valid as long as @event remains
* valid.
*/
void
gst_event_parse_caps (GstEvent * event, GstCaps ** caps)
{
GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_CAPS);
structure = GST_EVENT_STRUCTURE (event);
if (G_LIKELY (caps))
*caps =
g_value_get_boxed (gst_structure_id_get_value (structure,
GST_QUARK (CAPS)));
}
/**
* gst_event_parse_gap:
* @event: a #GstEvent of type #GST_EVENT_GAP
* @timestamp: (out) (allow-none): location where to store the
* start time (pts) of the gap, or %NULL
* @duration: (out) (allow-none): location where to store the duration of
* the gap, or %NULL
*
* Extract timestamp and duration from a new GAP event.
*/
void
gst_event_parse_gap (GstEvent * event, GstClockTime * timestamp,
GstClockTime * duration)
{
GstStructure *structure;
g_return_if_fail (GST_IS_EVENT (event));
g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_GAP);
structure = GST_EVENT_STRUCTURE (event);
gst_structure_id_get (structure,
GST_QUARK (TIMESTAMP), GST_TYPE_CLOCK_TIME, timestamp,
GST_QUARK (DURATION), GST_TYPE_CLOCK_TIME, duration, NULL);
}
