2 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * SECTION:element-videorate
23 * This element takes an incoming stream of timestamped video frames.
24 * It will produce a perfect stream that matches the source pad's framerate.
26 * The correction is performed by dropping and duplicating frames, no fancy
27 * algorithm is used to interpolate frames (yet).
29 * By default the element will simply negotiate the same framerate on its
30 * source and sink pad.
32 * This operation is useful to link to elements that require a perfect stream.
33 * Typical examples are formats that do not store timestamps for video frames,
34 * but only store a framerate, like Ogg and AVI.
36 * A conversion to a specific framerate can be forced by using filtered caps on
39 * The properties #GstVideoRate:in, #GstVideoRate:out, #GstVideoRate:duplicate
40 * and #GstVideoRate:drop can be read to obtain information about number of
41 * input frames, output frames, dropped frames (i.e. the number of unused input
42 * frames) and duplicated frames (i.e. the number of times an input frame was
43 * duplicated, beside being used normally).
45 * An input stream that needs no adjustments will thus never have dropped or
48 * When the #GstVideoRate:silent property is set to FALSE, a GObject property
49 * notification will be emitted whenever one of the #GstVideoRate:duplicate or
50 * #GstVideoRate:drop values changes.
51 * This can potentially cause performance degradation.
52 * Note that property notification will happen from the streaming thread, so
53 * applications should be prepared for this.
56 * <title>Example pipelines</title>
58 * gst-launch -v filesrc location=videotestsrc.ogg ! oggdemux ! theoradec ! videorate ! video/x-raw-yuv,framerate=15/1 ! xvimagesink
59 * ]| Decode an Ogg/Theora file and adjust the framerate to 15 fps before playing.
60 * To create the test Ogg/Theora file refer to the documentation of theoraenc.
62 * gst-launch -v v4lsrc ! videorate ! video/x-raw-yuv,framerate=25/2 ! theoraenc ! oggmux ! filesink location=v4l.ogg
63 * ]| Capture video from a V4L device, and adjust the stream to 12.5 fps before
64 * encoding to Ogg/Theora.
67 * Last reviewed on 2006-09-02 (0.10.11)
74 #include "gstvideorate.h"
76 GST_DEBUG_CATEGORY_STATIC (video_rate_debug);
77 #define GST_CAT_DEFAULT video_rate_debug
79 /* GstVideoRate signals and args */
86 #define DEFAULT_SILENT TRUE
87 #define DEFAULT_NEW_PREF 1.0
88 #define DEFAULT_SKIP_TO_FIRST FALSE
103 static GstStaticPadTemplate gst_video_rate_src_template =
104 GST_STATIC_PAD_TEMPLATE ("src",
107 GST_STATIC_CAPS ("video/x-raw-yuv;"
108 "video/x-raw-rgb;" "video/x-raw-gray;" "image/jpeg;" "image/png")
111 static GstStaticPadTemplate gst_video_rate_sink_template =
112 GST_STATIC_PAD_TEMPLATE ("sink",
115 GST_STATIC_CAPS ("video/x-raw-yuv;"
116 "video/x-raw-rgb;" "video/x-raw-gray;" "image/jpeg;" "image/png")
119 static void gst_video_rate_swap_prev (GstVideoRate * videorate,
120 GstBuffer * buffer, gint64 time);
121 static gboolean gst_video_rate_event (GstPad * pad, GstEvent * event);
122 static gboolean gst_video_rate_query (GstPad * pad, GstQuery * query);
123 static GstFlowReturn gst_video_rate_chain (GstPad * pad, GstBuffer * buffer);
125 static void gst_video_rate_set_property (GObject * object,
126 guint prop_id, const GValue * value, GParamSpec * pspec);
127 static void gst_video_rate_get_property (GObject * object,
128 guint prop_id, GValue * value, GParamSpec * pspec);
130 static GstStateChangeReturn gst_video_rate_change_state (GstElement * element,
131 GstStateChange transition);
133 /*static guint gst_video_rate_signals[LAST_SIGNAL] = { 0 }; */
135 static GParamSpec *pspec_drop = NULL;
136 static GParamSpec *pspec_duplicate = NULL;
138 GST_BOILERPLATE (GstVideoRate, gst_video_rate, GstElement, GST_TYPE_ELEMENT);
141 gst_video_rate_base_init (gpointer g_class)
143 GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
145 gst_element_class_set_details_simple (element_class,
146 "Video rate adjuster", "Filter/Effect/Video",
147 "Drops/duplicates/adjusts timestamps on video frames to make a perfect stream",
148 "Wim Taymans <wim@fluendo.com>");
150 gst_element_class_add_pad_template (element_class,
151 gst_static_pad_template_get (&gst_video_rate_sink_template));
152 gst_element_class_add_pad_template (element_class,
153 gst_static_pad_template_get (&gst_video_rate_src_template));
157 gst_video_rate_class_init (GstVideoRateClass * klass)
159 GObjectClass *object_class = G_OBJECT_CLASS (klass);
160 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
162 parent_class = g_type_class_peek_parent (klass);
164 object_class->set_property = gst_video_rate_set_property;
165 object_class->get_property = gst_video_rate_get_property;
167 g_object_class_install_property (object_class, ARG_IN,
168 g_param_spec_uint64 ("in", "In",
169 "Number of input frames", 0, G_MAXUINT64, 0,
170 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
171 g_object_class_install_property (object_class, ARG_OUT,
172 g_param_spec_uint64 ("out", "Out", "Number of output frames", 0,
173 G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
174 pspec_duplicate = g_param_spec_uint64 ("duplicate", "Duplicate",
175 "Number of duplicated frames", 0, G_MAXUINT64, 0,
176 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
177 g_object_class_install_property (object_class, ARG_DUP, pspec_duplicate);
178 pspec_drop = g_param_spec_uint64 ("drop", "Drop", "Number of dropped frames",
179 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
180 g_object_class_install_property (object_class, ARG_DROP, pspec_drop);
181 g_object_class_install_property (object_class, ARG_SILENT,
182 g_param_spec_boolean ("silent", "silent",
183 "Don't emit notify for dropped and duplicated frames", DEFAULT_SILENT,
184 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
185 g_object_class_install_property (object_class, ARG_NEW_PREF,
186 g_param_spec_double ("new-pref", "New Pref",
187 "Value indicating how much to prefer new frames (unused)", 0.0, 1.0,
188 DEFAULT_NEW_PREF, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
191 * GstVideoRate:skip-to-first:
193 * Don't produce buffers before the first one we receive.
197 g_object_class_install_property (object_class, ARG_SKIP_TO_FIRST,
198 g_param_spec_boolean ("skip-to-first", "Skip to first buffer",
199 "Don't produce buffers before the first one we receive",
200 DEFAULT_SKIP_TO_FIRST, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
202 element_class->change_state = GST_DEBUG_FUNCPTR (gst_video_rate_change_state);
205 /* return the caps that can be used on out_pad given in_caps on in_pad */
207 gst_video_rate_transformcaps (GstPad * in_pad, GstCaps * in_caps,
208 GstPad * out_pad, GstCaps ** out_caps)
211 const GstCaps *in_templ;
213 GSList *extra_structures = NULL;
216 in_templ = gst_pad_get_pad_template_caps (in_pad);
217 intersect = gst_caps_intersect (in_caps, in_templ);
219 /* all possible framerates are allowed */
220 for (i = 0; i < gst_caps_get_size (intersect); i++) {
221 GstStructure *structure;
223 structure = gst_caps_get_structure (intersect, i);
225 if (gst_structure_has_field (structure, "framerate")) {
226 GstStructure *copy_structure;
228 copy_structure = gst_structure_copy (structure);
229 gst_structure_set (copy_structure,
230 "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
231 extra_structures = g_slist_append (extra_structures, copy_structure);
235 /* append the extra structures */
236 for (iter = extra_structures; iter != NULL; iter = g_slist_next (iter)) {
237 gst_caps_append_structure (intersect, (GstStructure *) iter->data);
239 g_slist_free (extra_structures);
241 *out_caps = intersect;
247 gst_video_rate_getcaps (GstPad * pad)
249 GstVideoRate *videorate;
253 videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));
255 otherpad = (pad == videorate->srcpad) ? videorate->sinkpad :
258 /* we can do what the peer can */
259 caps = gst_pad_peer_get_caps (otherpad);
263 gst_video_rate_transformcaps (otherpad, caps, pad, &transform);
264 gst_caps_unref (caps);
267 /* no peer, our padtemplate is enough then */
268 caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
275 gst_video_rate_setcaps (GstPad * pad, GstCaps * caps)
277 GstVideoRate *videorate;
278 GstStructure *structure;
280 GstPad *otherpad, *opeer;
281 gint rate_numerator, rate_denominator;
283 videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
285 GST_DEBUG_OBJECT (pad, "setcaps called %" GST_PTR_FORMAT, caps);
287 structure = gst_caps_get_structure (caps, 0);
288 if (!gst_structure_get_fraction (structure, "framerate",
289 &rate_numerator, &rate_denominator))
292 if (pad == videorate->srcpad) {
293 /* out_frame_count is scaled by the frame rate caps when calculating next_ts.
294 * when the frame rate caps change, we must update base_ts and reset
296 if (videorate->to_rate_numerator) {
297 videorate->base_ts +=
298 gst_util_uint64_scale (videorate->out_frame_count,
299 videorate->to_rate_denominator * GST_SECOND,
300 videorate->to_rate_numerator);
302 videorate->out_frame_count = 0;
303 videorate->to_rate_numerator = rate_numerator;
304 videorate->to_rate_denominator = rate_denominator;
305 otherpad = videorate->sinkpad;
307 videorate->from_rate_numerator = rate_numerator;
308 videorate->from_rate_denominator = rate_denominator;
309 otherpad = videorate->srcpad;
312 /* now try to find something for the peer */
313 opeer = gst_pad_get_peer (otherpad);
315 if (gst_pad_accept_caps (opeer, caps)) {
316 /* the peer accepts the caps as they are */
317 gst_pad_set_caps (otherpad, caps);
322 GstCaps *transform = NULL;
326 /* see how we can transform the input caps */
327 if (!gst_video_rate_transformcaps (pad, caps, otherpad, &transform))
330 /* see what the peer can do */
331 peercaps = gst_pad_get_caps (opeer);
333 GST_DEBUG_OBJECT (opeer, "icaps %" GST_PTR_FORMAT, peercaps);
334 GST_DEBUG_OBJECT (videorate, "transform %" GST_PTR_FORMAT, transform);
336 /* filter against our possibilities */
337 caps = gst_caps_intersect (peercaps, transform);
338 gst_caps_unref (peercaps);
339 gst_caps_unref (transform);
341 GST_DEBUG_OBJECT (videorate, "intersect %" GST_PTR_FORMAT, caps);
343 /* could turn up empty, due to e.g. colorspace etc */
344 if (gst_caps_get_size (caps) == 0) {
345 gst_caps_unref (caps);
349 /* take first possibility */
350 gst_caps_truncate (caps);
351 structure = gst_caps_get_structure (caps, 0);
354 gst_structure_fixate_field_nearest_fraction (structure, "framerate",
355 rate_numerator, rate_denominator);
357 gst_structure_get_fraction (structure, "framerate",
358 &rate_numerator, &rate_denominator);
360 if (otherpad == videorate->srcpad) {
361 videorate->to_rate_numerator = rate_numerator;
362 videorate->to_rate_denominator = rate_denominator;
364 videorate->from_rate_numerator = rate_numerator;
365 videorate->from_rate_denominator = rate_denominator;
368 if (gst_structure_has_field (structure, "interlaced"))
369 gst_structure_fixate_field_boolean (structure, "interlaced", FALSE);
370 if (gst_structure_has_field (structure, "color-matrix"))
371 gst_structure_fixate_field_string (structure, "color-matrix", "sdtv");
372 if (gst_structure_has_field (structure, "chroma-site"))
373 gst_structure_fixate_field_string (structure, "chroma-site", "mpeg2");
374 if (gst_structure_has_field (structure, "pixel-aspect-ratio"))
375 gst_structure_fixate_field_nearest_fraction (structure,
376 "pixel-aspect-ratio", 1, 1);
378 gst_pad_set_caps (otherpad, caps);
379 gst_caps_unref (caps);
382 gst_object_unref (opeer);
385 /* After a setcaps, our caps may have changed. In that case, we can't use
386 * the old buffer, if there was one (it might have different dimensions) */
387 GST_DEBUG_OBJECT (videorate, "swapping old buffers");
388 gst_video_rate_swap_prev (videorate, NULL, GST_CLOCK_TIME_NONE);
390 gst_object_unref (videorate);
395 GST_DEBUG_OBJECT (videorate, "no framerate specified");
400 GST_DEBUG_OBJECT (videorate, "no framerate transform possible");
407 gst_video_rate_reset (GstVideoRate * videorate)
409 GST_DEBUG_OBJECT (videorate, "resetting internal variables");
413 videorate->base_ts = 0;
414 videorate->out_frame_count = 0;
417 videorate->next_ts = GST_CLOCK_TIME_NONE;
418 videorate->last_ts = GST_CLOCK_TIME_NONE;
419 videorate->discont = TRUE;
420 gst_video_rate_swap_prev (videorate, NULL, 0);
422 gst_segment_init (&videorate->segment, GST_FORMAT_TIME);
426 gst_video_rate_init (GstVideoRate * videorate, GstVideoRateClass * klass)
429 gst_pad_new_from_static_template (&gst_video_rate_sink_template, "sink");
430 gst_pad_set_event_function (videorate->sinkpad,
431 GST_DEBUG_FUNCPTR (gst_video_rate_event));
432 gst_pad_set_chain_function (videorate->sinkpad,
433 GST_DEBUG_FUNCPTR (gst_video_rate_chain));
434 gst_pad_set_getcaps_function (videorate->sinkpad,
435 GST_DEBUG_FUNCPTR (gst_video_rate_getcaps));
436 gst_pad_set_setcaps_function (videorate->sinkpad,
437 GST_DEBUG_FUNCPTR (gst_video_rate_setcaps));
438 gst_element_add_pad (GST_ELEMENT (videorate), videorate->sinkpad);
441 gst_pad_new_from_static_template (&gst_video_rate_src_template, "src");
442 gst_pad_set_query_function (videorate->srcpad,
443 GST_DEBUG_FUNCPTR (gst_video_rate_query));
444 gst_pad_set_getcaps_function (videorate->srcpad,
445 GST_DEBUG_FUNCPTR (gst_video_rate_getcaps));
446 gst_pad_set_setcaps_function (videorate->srcpad,
447 GST_DEBUG_FUNCPTR (gst_video_rate_setcaps));
448 gst_element_add_pad (GST_ELEMENT (videorate), videorate->srcpad);
450 gst_video_rate_reset (videorate);
451 videorate->silent = DEFAULT_SILENT;
452 videorate->new_pref = DEFAULT_NEW_PREF;
454 videorate->from_rate_numerator = 0;
455 videorate->from_rate_denominator = 0;
456 videorate->to_rate_numerator = 0;
457 videorate->to_rate_denominator = 0;
460 /* flush the oldest buffer */
462 gst_video_rate_flush_prev (GstVideoRate * videorate, gboolean duplicate)
466 GstClockTime push_ts;
468 if (!videorate->prevbuf)
469 goto eos_before_buffers;
471 /* make sure we can write to the metadata */
472 outbuf = gst_buffer_make_writable (gst_buffer_ref (videorate->prevbuf));
474 GST_BUFFER_OFFSET (outbuf) = videorate->out;
475 GST_BUFFER_OFFSET_END (outbuf) = videorate->out + 1;
477 if (videorate->discont) {
478 GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
479 videorate->discont = FALSE;
481 GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DISCONT);
484 GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_GAP);
486 GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_GAP);
488 /* this is the timestamp we put on the buffer */
489 push_ts = videorate->next_ts;
492 videorate->out_frame_count++;
493 if (videorate->to_rate_numerator) {
494 /* interpolate next expected timestamp in the segment */
496 videorate->segment.accum + videorate->segment.start +
497 videorate->base_ts + gst_util_uint64_scale (videorate->out_frame_count,
498 videorate->to_rate_denominator * GST_SECOND,
499 videorate->to_rate_numerator);
500 GST_BUFFER_DURATION (outbuf) = videorate->next_ts - push_ts;
503 /* adapt for looping, bring back to time in current segment. */
504 GST_BUFFER_TIMESTAMP (outbuf) = push_ts - videorate->segment.accum;
506 gst_buffer_set_caps (outbuf, GST_PAD_CAPS (videorate->srcpad));
508 GST_LOG_OBJECT (videorate,
509 "old is best, dup, pushing buffer outgoing ts %" GST_TIME_FORMAT,
510 GST_TIME_ARGS (push_ts));
512 res = gst_pad_push (videorate->srcpad, outbuf);
519 GST_INFO_OBJECT (videorate, "got EOS before any buffer was received");
525 gst_video_rate_swap_prev (GstVideoRate * videorate, GstBuffer * buffer,
528 GST_LOG_OBJECT (videorate, "swap_prev: storing buffer %p in prev", buffer);
529 if (videorate->prevbuf)
530 gst_buffer_unref (videorate->prevbuf);
531 videorate->prevbuf = buffer;
532 videorate->prev_ts = time;
536 gst_video_rate_notify_drop (GstVideoRate * videorate)
538 #if !GLIB_CHECK_VERSION(2,26,0)
539 g_object_notify ((GObject *) videorate, "drop");
541 g_object_notify_by_pspec ((GObject *) videorate, pspec_drop);
546 gst_video_rate_notify_duplicate (GstVideoRate * videorate)
548 #if !GLIB_CHECK_VERSION(2,26,0)
549 g_object_notify ((GObject *) videorate, "duplicate");
551 g_object_notify_by_pspec ((GObject *) videorate, pspec_duplicate);
555 #define MAGIC_LIMIT 25
557 gst_video_rate_event (GstPad * pad, GstEvent * event)
559 GstVideoRate *videorate;
562 videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
564 switch (GST_EVENT_TYPE (event)) {
565 case GST_EVENT_NEWSEGMENT:
567 gint64 start, stop, time;
572 gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
573 &start, &stop, &time);
575 if (format != GST_FORMAT_TIME)
578 GST_DEBUG_OBJECT (videorate, "handle NEWSEGMENT");
580 /* close up the previous segment, if appropriate */
581 if (!update && videorate->prevbuf) {
586 /* fill up to the end of current segment,
587 * or only send out the stored buffer if there is no specific stop.
588 * regardless, prevent going loopy in strange cases */
589 while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
590 ((GST_CLOCK_TIME_IS_VALID (videorate->segment.stop) &&
591 videorate->next_ts - videorate->segment.accum
592 < videorate->segment.stop)
594 res = gst_video_rate_flush_prev (videorate, count > 0);
598 videorate->dup += count - 1;
599 if (!videorate->silent)
600 gst_video_rate_notify_duplicate (videorate);
601 } else if (count == 0) {
603 if (!videorate->silent)
604 gst_video_rate_notify_drop (videorate);
606 /* clean up for the new one; _chain will resume from the new start */
607 videorate->base_ts = 0;
608 videorate->out_frame_count = 0;
609 gst_video_rate_swap_prev (videorate, NULL, 0);
610 videorate->next_ts = GST_CLOCK_TIME_NONE;
613 /* We just want to update the accumulated stream_time */
614 gst_segment_set_newsegment_full (&videorate->segment, update, rate, arate,
615 format, start, stop, time);
617 GST_DEBUG_OBJECT (videorate, "updated segment: %" GST_SEGMENT_FORMAT,
618 &videorate->segment);
623 GstFlowReturn res = GST_FLOW_OK;
625 GST_DEBUG_OBJECT (videorate, "Got EOS");
627 /* If the segment has a stop position, fill the segment */
628 if (GST_CLOCK_TIME_IS_VALID (videorate->segment.stop)) {
629 /* fill up to the end of current segment,
630 * or only send out the stored buffer if there is no specific stop.
631 * regardless, prevent going loopy in strange cases */
632 while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
633 ((videorate->next_ts - videorate->segment.accum <
634 videorate->segment.stop)
636 res = gst_video_rate_flush_prev (videorate, count > 0);
639 } else if (videorate->prevbuf) {
640 /* Output at least one frame but if the buffer duration is valid, output
641 * enough frames to use the complete buffer duration */
642 if (GST_BUFFER_DURATION_IS_VALID (videorate->prevbuf)) {
643 GstClockTime end_ts =
644 videorate->next_ts + GST_BUFFER_DURATION (videorate->prevbuf);
646 while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
647 ((videorate->next_ts - videorate->segment.accum < end_ts)
649 res = gst_video_rate_flush_prev (videorate, count > 0);
653 res = gst_video_rate_flush_prev (videorate, FALSE);
659 videorate->dup += count - 1;
660 if (!videorate->silent)
661 gst_video_rate_notify_duplicate (videorate);
662 } else if (count == 0) {
664 if (!videorate->silent)
665 gst_video_rate_notify_drop (videorate);
670 case GST_EVENT_FLUSH_STOP:
671 /* also resets the segment */
672 GST_DEBUG_OBJECT (videorate, "Got FLUSH_STOP");
673 gst_video_rate_reset (videorate);
679 ret = gst_pad_push_event (videorate->srcpad, event);
682 gst_object_unref (videorate);
689 GST_WARNING_OBJECT (videorate,
690 "Got segment but doesn't have GST_FORMAT_TIME value");
691 gst_event_unref (event);
698 gst_video_rate_query (GstPad * pad, GstQuery * query)
700 GstVideoRate *videorate;
701 gboolean res = FALSE;
703 videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
705 switch (GST_QUERY_TYPE (query)) {
706 case GST_QUERY_LATENCY:
708 GstClockTime min, max;
713 if ((peer = gst_pad_get_peer (videorate->sinkpad))) {
714 if ((res = gst_pad_query (peer, query))) {
715 gst_query_parse_latency (query, &live, &min, &max);
717 GST_DEBUG_OBJECT (videorate, "Peer latency: min %"
718 GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
719 GST_TIME_ARGS (min), GST_TIME_ARGS (max));
721 if (videorate->from_rate_numerator != 0) {
722 /* add latency. We don't really know since we hold on to the frames
723 * until we get a next frame, which can be anything. We assume
724 * however that this will take from_rate time. */
725 latency = gst_util_uint64_scale (GST_SECOND,
726 videorate->from_rate_denominator,
727 videorate->from_rate_numerator);
729 /* no input framerate, we don't know */
733 GST_DEBUG_OBJECT (videorate, "Our latency: %"
734 GST_TIME_FORMAT, GST_TIME_ARGS (latency));
740 GST_DEBUG_OBJECT (videorate, "Calculated total latency : min %"
741 GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
742 GST_TIME_ARGS (min), GST_TIME_ARGS (max));
744 gst_query_set_latency (query, live, min, max);
746 gst_object_unref (peer);
751 res = gst_pad_query_default (pad, query);
754 gst_object_unref (videorate);
760 gst_video_rate_chain (GstPad * pad, GstBuffer * buffer)
762 GstVideoRate *videorate;
763 GstFlowReturn res = GST_FLOW_OK;
764 GstClockTime intime, in_ts, in_dur;
766 videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));
768 /* make sure the denominators are not 0 */
769 if (videorate->from_rate_denominator == 0 ||
770 videorate->to_rate_denominator == 0)
773 in_ts = GST_BUFFER_TIMESTAMP (buffer);
774 in_dur = GST_BUFFER_DURATION (buffer);
776 if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE)) {
777 in_ts = videorate->last_ts;
778 if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE))
782 /* get the time of the next expected buffer timestamp, we use this when the
783 * next buffer has -1 as a timestamp */
784 videorate->last_ts = in_ts;
785 if (in_dur != GST_CLOCK_TIME_NONE)
786 videorate->last_ts += in_dur;
788 GST_DEBUG_OBJECT (videorate, "got buffer with timestamp %" GST_TIME_FORMAT,
789 GST_TIME_ARGS (in_ts));
791 /* the input time is the time in the segment + all previously accumulated
793 intime = in_ts + videorate->segment.accum;
795 /* we need to have two buffers to compare */
796 if (videorate->prevbuf == NULL) {
797 gst_video_rate_swap_prev (videorate, buffer, intime);
799 if (!GST_CLOCK_TIME_IS_VALID (videorate->next_ts)) {
800 /* new buffer, we expect to output a buffer that matches the first
801 * timestamp in the segment */
802 if (videorate->skip_to_first) {
803 videorate->next_ts = intime;
804 videorate->base_ts = in_ts - videorate->segment.start;
805 videorate->out_frame_count = 0;
808 videorate->segment.start + videorate->segment.accum;
812 GstClockTime prevtime;
816 prevtime = videorate->prev_ts;
818 GST_LOG_OBJECT (videorate,
819 "BEGINNING prev buf %" GST_TIME_FORMAT " new buf %" GST_TIME_FORMAT
820 " outgoing ts %" GST_TIME_FORMAT, GST_TIME_ARGS (prevtime),
821 GST_TIME_ARGS (intime), GST_TIME_ARGS (videorate->next_ts));
825 /* drop new buffer if it's before previous one */
826 if (intime < prevtime) {
827 GST_DEBUG_OBJECT (videorate,
828 "The new buffer (%" GST_TIME_FORMAT
829 ") is before the previous buffer (%"
830 GST_TIME_FORMAT "). Dropping new buffer.",
831 GST_TIME_ARGS (intime), GST_TIME_ARGS (prevtime));
833 if (!videorate->silent)
834 gst_video_rate_notify_drop (videorate);
835 gst_buffer_unref (buffer);
839 /* got 2 buffers, see which one is the best */
842 diff1 = prevtime - videorate->next_ts;
843 diff2 = intime - videorate->next_ts;
845 /* take absolute values, beware: abs and ABS don't work for gint64 */
851 GST_LOG_OBJECT (videorate,
852 "diff with prev %" GST_TIME_FORMAT " diff with new %"
853 GST_TIME_FORMAT " outgoing ts %" GST_TIME_FORMAT,
854 GST_TIME_ARGS (diff1), GST_TIME_ARGS (diff2),
855 GST_TIME_ARGS (videorate->next_ts));
857 /* output first one when its the best */
858 if (diff1 <= diff2) {
861 /* on error the _flush function posted a warning already */
863 gst_video_rate_flush_prev (videorate,
864 count > 1)) != GST_FLOW_OK) {
865 gst_buffer_unref (buffer);
869 /* continue while the first one was the best, if they were equal avoid
870 * going into an infinite loop */
872 while (diff1 < diff2);
874 /* if we outputed the first buffer more then once, we have dups */
876 videorate->dup += count - 1;
877 if (!videorate->silent)
878 gst_video_rate_notify_duplicate (videorate);
880 /* if we didn't output the first buffer, we have a drop */
881 else if (count == 0) {
884 if (!videorate->silent)
885 gst_video_rate_notify_drop (videorate);
887 GST_LOG_OBJECT (videorate,
888 "new is best, old never used, drop, outgoing ts %"
889 GST_TIME_FORMAT, GST_TIME_ARGS (videorate->next_ts));
891 GST_LOG_OBJECT (videorate,
892 "END, putting new in old, diff1 %" GST_TIME_FORMAT
893 ", diff2 %" GST_TIME_FORMAT ", next_ts %" GST_TIME_FORMAT
894 ", in %" G_GUINT64_FORMAT ", out %" G_GUINT64_FORMAT ", drop %"
895 G_GUINT64_FORMAT ", dup %" G_GUINT64_FORMAT, GST_TIME_ARGS (diff1),
896 GST_TIME_ARGS (diff2), GST_TIME_ARGS (videorate->next_ts),
897 videorate->in, videorate->out, videorate->drop, videorate->dup);
899 /* swap in new one when it's the best */
900 gst_video_rate_swap_prev (videorate, buffer, intime);
908 GST_WARNING_OBJECT (videorate, "no framerate negotiated");
909 gst_buffer_unref (buffer);
910 res = GST_FLOW_NOT_NEGOTIATED;
916 GST_WARNING_OBJECT (videorate,
917 "Got buffer with GST_CLOCK_TIME_NONE timestamp, discarding it");
918 gst_buffer_unref (buffer);
924 gst_video_rate_set_property (GObject * object,
925 guint prop_id, const GValue * value, GParamSpec * pspec)
927 GstVideoRate *videorate = GST_VIDEO_RATE (object);
931 videorate->silent = g_value_get_boolean (value);
934 videorate->new_pref = g_value_get_double (value);
936 case ARG_SKIP_TO_FIRST:
937 videorate->skip_to_first = g_value_get_boolean (value);
940 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
946 gst_video_rate_get_property (GObject * object,
947 guint prop_id, GValue * value, GParamSpec * pspec)
949 GstVideoRate *videorate = GST_VIDEO_RATE (object);
953 g_value_set_uint64 (value, videorate->in);
956 g_value_set_uint64 (value, videorate->out);
959 g_value_set_uint64 (value, videorate->dup);
962 g_value_set_uint64 (value, videorate->drop);
965 g_value_set_boolean (value, videorate->silent);
968 g_value_set_double (value, videorate->new_pref);
970 case ARG_SKIP_TO_FIRST:
971 g_value_set_boolean (value, videorate->skip_to_first);
974 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
979 static GstStateChangeReturn
980 gst_video_rate_change_state (GstElement * element, GstStateChange transition)
982 GstStateChangeReturn ret;
983 GstVideoRate *videorate;
985 videorate = GST_VIDEO_RATE (element);
987 switch (transition) {
988 case GST_STATE_CHANGE_READY_TO_PAUSED:
989 videorate->discont = TRUE;
990 videorate->last_ts = -1;
996 ret = parent_class->change_state (element, transition);
998 switch (transition) {
999 case GST_STATE_CHANGE_PAUSED_TO_READY:
1000 gst_video_rate_reset (videorate);
1010 plugin_init (GstPlugin * plugin)
1012 GST_DEBUG_CATEGORY_INIT (video_rate_debug, "videorate", 0,
1013 "VideoRate stream fixer");
1015 return gst_element_register (plugin, "videorate", GST_RANK_NONE,
1016 GST_TYPE_VIDEO_RATE);
1019 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1022 "Adjusts video frames",
1023 plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)