45382c3a22784e2854a79c0d8bd5aaa1a721956e
[platform/upstream/gstreamer.git] / gst / videorate / gstvideorate.c
1 /* GStreamer
2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3  *
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.
8  *
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.
13  *
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.
18  */
19
20 /**
21  * SECTION:element-videorate
22  *
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.
25  *
26  * The correction is performed by dropping and duplicating frames, no fancy
27  * algorithm is used to interpolate frames (yet).
28  *
29  * By default the element will simply negotiate the same framerate on its
30  * source and sink pad.
31  *
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.
35  *
36  * A conversion to a specific framerate can be forced by using filtered caps on
37  * the source pad.
38  *
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).
44  *
45  * An input stream that needs no adjustments will thus never have dropped or
46  * duplicated frames.
47  *
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.
54  *
55  * <refsect2>
56  * <title>Example pipelines</title>
57  * |[
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.
61  * |[
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.
65  * </refsect2>
66  *
67  * Last reviewed on 2006-09-02 (0.10.11)
68  */
69
70 #ifdef HAVE_CONFIG_H
71 #include "config.h"
72 #endif
73
74 #include "gstvideorate.h"
75
76 GST_DEBUG_CATEGORY_STATIC (video_rate_debug);
77 #define GST_CAT_DEFAULT video_rate_debug
78
79 /* GstVideoRate signals and args */
80 enum
81 {
82   /* FILL ME */
83   LAST_SIGNAL
84 };
85
86 #define DEFAULT_SILENT          TRUE
87 #define DEFAULT_NEW_PREF        1.0
88 #define DEFAULT_SKIP_TO_FIRST   FALSE
89 #define DEFAULT_DROP_ONLY       FALSE
90 #define DEFAULT_AVERAGE_PERIOD  0
91
92 enum
93 {
94   ARG_0,
95   ARG_IN,
96   ARG_OUT,
97   ARG_DUP,
98   ARG_DROP,
99   ARG_SILENT,
100   ARG_NEW_PREF,
101   ARG_SKIP_TO_FIRST,
102   ARG_DROP_ONLY,
103   ARG_AVERAGE_PERIOD
104       /* FILL ME */
105 };
106
107 static GstStaticPadTemplate gst_video_rate_src_template =
108     GST_STATIC_PAD_TEMPLATE ("src",
109     GST_PAD_SRC,
110     GST_PAD_ALWAYS,
111     GST_STATIC_CAPS ("video/x-raw-yuv;"
112         "video/x-raw-rgb;" "video/x-raw-gray;" "image/jpeg;" "image/png")
113     );
114
115 static GstStaticPadTemplate gst_video_rate_sink_template =
116     GST_STATIC_PAD_TEMPLATE ("sink",
117     GST_PAD_SINK,
118     GST_PAD_ALWAYS,
119     GST_STATIC_CAPS ("video/x-raw-yuv;"
120         "video/x-raw-rgb;" "video/x-raw-gray;" "image/jpeg;" "image/png")
121     );
122
123 static void gst_video_rate_swap_prev (GstVideoRate * videorate,
124     GstBuffer * buffer, gint64 time);
125 static gboolean gst_video_rate_event (GstPad * pad, GstEvent * event);
126 static gboolean gst_video_rate_query (GstPad * pad, GstQuery * query);
127 static GstFlowReturn gst_video_rate_chain (GstPad * pad, GstBuffer * buffer);
128
129 static void gst_video_rate_set_property (GObject * object,
130     guint prop_id, const GValue * value, GParamSpec * pspec);
131 static void gst_video_rate_get_property (GObject * object,
132     guint prop_id, GValue * value, GParamSpec * pspec);
133
134 static GstStateChangeReturn gst_video_rate_change_state (GstElement * element,
135     GstStateChange transition);
136
137 /*static guint gst_video_rate_signals[LAST_SIGNAL] = { 0 }; */
138
139 static GParamSpec *pspec_drop = NULL;
140 static GParamSpec *pspec_duplicate = NULL;
141
142 #define gst_video_rate_parent_class parent_class
143 G_DEFINE_TYPE (GstVideoRate, gst_video_rate, GST_TYPE_ELEMENT);
144
145 static void
146 gst_video_rate_class_init (GstVideoRateClass * klass)
147 {
148   GObjectClass *object_class = G_OBJECT_CLASS (klass);
149   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
150
151   parent_class = g_type_class_peek_parent (klass);
152
153   object_class->set_property = gst_video_rate_set_property;
154   object_class->get_property = gst_video_rate_get_property;
155
156   g_object_class_install_property (object_class, ARG_IN,
157       g_param_spec_uint64 ("in", "In",
158           "Number of input frames", 0, G_MAXUINT64, 0,
159           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
160   g_object_class_install_property (object_class, ARG_OUT,
161       g_param_spec_uint64 ("out", "Out", "Number of output frames", 0,
162           G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
163   pspec_duplicate = g_param_spec_uint64 ("duplicate", "Duplicate",
164       "Number of duplicated frames", 0, G_MAXUINT64, 0,
165       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
166   g_object_class_install_property (object_class, ARG_DUP, pspec_duplicate);
167   pspec_drop = g_param_spec_uint64 ("drop", "Drop", "Number of dropped frames",
168       0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
169   g_object_class_install_property (object_class, ARG_DROP, pspec_drop);
170   g_object_class_install_property (object_class, ARG_SILENT,
171       g_param_spec_boolean ("silent", "silent",
172           "Don't emit notify for dropped and duplicated frames", DEFAULT_SILENT,
173           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
174   g_object_class_install_property (object_class, ARG_NEW_PREF,
175       g_param_spec_double ("new-pref", "New Pref",
176           "Value indicating how much to prefer new frames (unused)", 0.0, 1.0,
177           DEFAULT_NEW_PREF, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
178
179   /**
180    * GstVideoRate:skip-to-first:
181    * 
182    * Don't produce buffers before the first one we receive.
183    *
184    * Since: 0.10.25
185    */
186   g_object_class_install_property (object_class, ARG_SKIP_TO_FIRST,
187       g_param_spec_boolean ("skip-to-first", "Skip to first buffer",
188           "Don't produce buffers before the first one we receive",
189           DEFAULT_SKIP_TO_FIRST, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
190
191   gst_element_class_set_details_simple (element_class,
192       "Video rate adjuster", "Filter/Effect/Video",
193       "Drops/duplicates/adjusts timestamps on video frames to make a perfect stream",
194       "Wim Taymans <wim@fluendo.com>");
195
196   gst_element_class_add_pad_template (element_class,
197       gst_static_pad_template_get (&gst_video_rate_sink_template));
198   gst_element_class_add_pad_template (element_class,
199       gst_static_pad_template_get (&gst_video_rate_src_template));
200
201   /**
202    * GstVideoRate:drop-only:
203    *
204    * Only drop frames, no duplicates are produced.
205    *
206    * Since: 0.10.34
207    */
208   g_object_class_install_property (object_class, ARG_DROP_ONLY,
209       g_param_spec_boolean ("drop-only", "Only Drop",
210           "Only drop frames, no duplicates are produced",
211           DEFAULT_DROP_ONLY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
212
213   /**
214    * GstVideoRate:average-period:
215    *
216    * Arrange for maximum framerate by dropping frames beyond a certain framerate,
217    * where the framerate is calculated using a moving average over the
218    * configured.
219    *
220    * Since: 0.10.34
221    */
222   g_object_class_install_property (object_class, ARG_AVERAGE_PERIOD,
223       g_param_spec_uint64 ("average-period", "Period over which to average",
224           "Period over which to average the framerate (in ns) (0 = disabled)",
225           0, G_MAXINT64, DEFAULT_AVERAGE_PERIOD,
226           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
227
228   element_class->change_state = GST_DEBUG_FUNCPTR (gst_video_rate_change_state);
229 }
230
231 /* return the caps that can be used on out_pad given in_caps on in_pad */
232 static gboolean
233 gst_video_rate_transformcaps (GstPad * in_pad, GstCaps * in_caps,
234     GstPad * out_pad, GstCaps ** out_caps, GstCaps * filter)
235 {
236   GstCaps *intersect, *in_templ;
237   gint i;
238   GSList *extra_structures = NULL;
239   GSList *iter;
240
241   in_templ = gst_pad_get_pad_template_caps (in_pad);
242   intersect =
243       gst_caps_intersect_full (in_caps, in_templ, GST_CAPS_INTERSECT_FIRST);
244   gst_caps_unref (in_templ);
245
246   /* all possible framerates are allowed */
247   for (i = 0; i < gst_caps_get_size (intersect); i++) {
248     GstStructure *structure;
249
250     structure = gst_caps_get_structure (intersect, i);
251
252     if (gst_structure_has_field (structure, "framerate")) {
253       GstStructure *copy_structure;
254
255       copy_structure = gst_structure_copy (structure);
256       gst_structure_set (copy_structure,
257           "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
258       extra_structures = g_slist_append (extra_structures, copy_structure);
259     }
260   }
261
262   /* append the extra structures */
263   for (iter = extra_structures; iter != NULL; iter = g_slist_next (iter)) {
264     gst_caps_append_structure (intersect, (GstStructure *) iter->data);
265   }
266   g_slist_free (extra_structures);
267
268   if (filter) {
269     GstCaps *tmp;
270
271     tmp = gst_caps_intersect_full (filter, intersect, GST_CAPS_INTERSECT_FIRST);
272     gst_caps_unref (intersect);
273     intersect = tmp;
274   }
275
276   *out_caps = intersect;
277
278   return TRUE;
279 }
280
281 static GstCaps *
282 gst_video_rate_getcaps (GstPad * pad, GstCaps * filter)
283 {
284   GstVideoRate *videorate;
285   GstPad *otherpad;
286   GstCaps *caps;
287
288   videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));
289
290   otherpad = (pad == videorate->srcpad) ? videorate->sinkpad :
291       videorate->srcpad;
292
293   /* we can do what the peer can */
294   caps = gst_pad_peer_get_caps (otherpad, filter);
295   if (caps) {
296     GstCaps *transform, *intersect;
297
298     gst_video_rate_transformcaps (otherpad, caps, pad, &transform, filter);
299
300     /* Now prefer the downstream caps if possible */
301     intersect =
302         gst_caps_intersect_full (caps, transform, GST_CAPS_INTERSECT_FIRST);
303     if (!gst_caps_is_empty (intersect)) {
304       gst_caps_append (intersect, transform);
305       gst_caps_unref (caps);
306       caps = intersect;
307     } else {
308       gst_caps_unref (intersect);
309       caps = transform;
310     }
311   } else {
312     /* no peer, our padtemplate is enough then */
313     caps = gst_pad_get_pad_template_caps (pad);
314     if (filter) {
315       GstCaps *intersection;
316       intersection =
317           gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
318       gst_caps_unref (caps);
319       caps = intersection;
320     }
321   }
322
323   return caps;
324 }
325
326 static gboolean
327 gst_video_rate_setcaps (GstPad * pad, GstCaps * caps)
328 {
329   GstVideoRate *videorate;
330   GstStructure *structure;
331   gboolean ret = TRUE;
332   GstPad *otherpad, *opeer;
333   gint rate_numerator, rate_denominator;
334
335   videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
336
337   GST_DEBUG_OBJECT (pad, "setcaps called %" GST_PTR_FORMAT, caps);
338
339   structure = gst_caps_get_structure (caps, 0);
340   if (!gst_structure_get_fraction (structure, "framerate",
341           &rate_numerator, &rate_denominator))
342     goto no_framerate;
343
344   if (pad == videorate->srcpad) {
345     /* out_frame_count is scaled by the frame rate caps when calculating next_ts.
346      * when the frame rate caps change, we must update base_ts and reset
347      * out_frame_count */
348     if (videorate->to_rate_numerator) {
349       videorate->base_ts +=
350           gst_util_uint64_scale (videorate->out_frame_count,
351           videorate->to_rate_denominator * GST_SECOND,
352           videorate->to_rate_numerator);
353     }
354     videorate->out_frame_count = 0;
355     videorate->to_rate_numerator = rate_numerator;
356     videorate->to_rate_denominator = rate_denominator;
357     videorate->wanted_diff = gst_util_uint64_scale_int (GST_SECOND,
358         rate_denominator, rate_numerator);
359     otherpad = videorate->sinkpad;
360   } else {
361     videorate->from_rate_numerator = rate_numerator;
362     videorate->from_rate_denominator = rate_denominator;
363     otherpad = videorate->srcpad;
364   }
365
366   /* now try to find something for the peer */
367   opeer = gst_pad_get_peer (otherpad);
368   if (opeer) {
369     if (gst_pad_accept_caps (opeer, caps)) {
370       /* the peer accepts the caps as they are */
371       gst_pad_set_caps (otherpad, caps);
372
373       ret = TRUE;
374     } else {
375       GstCaps *transform = NULL;
376
377       ret = FALSE;
378
379       /* see how we can transform the input caps */
380       if (!gst_video_rate_transformcaps (pad, caps, otherpad, &transform, NULL))
381         goto no_transform;
382
383       GST_DEBUG_OBJECT (videorate, "transform %" GST_PTR_FORMAT, transform);
384
385       /* see what the peer can do */
386       caps = gst_pad_get_caps (opeer, transform);
387
388       GST_DEBUG_OBJECT (opeer, "icaps %" GST_PTR_FORMAT, caps);
389
390       /* could turn up empty, due to e.g. colorspace etc */
391       if (gst_caps_get_size (caps) == 0) {
392         gst_caps_unref (caps);
393         goto no_transform;
394       }
395
396       /* take first possibility */
397       caps = gst_caps_make_writable (caps);
398       gst_caps_truncate (caps);
399       structure = gst_caps_get_structure (caps, 0);
400
401       /* and fixate */
402       gst_structure_fixate_field_nearest_fraction (structure, "framerate",
403           rate_numerator, rate_denominator);
404
405       gst_structure_get_fraction (structure, "framerate",
406           &rate_numerator, &rate_denominator);
407
408       if (otherpad == videorate->srcpad) {
409         videorate->to_rate_numerator = rate_numerator;
410         videorate->to_rate_denominator = rate_denominator;
411       } else {
412         videorate->from_rate_numerator = rate_numerator;
413         videorate->from_rate_denominator = rate_denominator;
414       }
415
416       if (gst_structure_has_field (structure, "interlaced"))
417         gst_structure_fixate_field_boolean (structure, "interlaced", FALSE);
418       if (gst_structure_has_field (structure, "color-matrix"))
419         gst_structure_fixate_field_string (structure, "color-matrix", "sdtv");
420       if (gst_structure_has_field (structure, "chroma-site"))
421         gst_structure_fixate_field_string (structure, "chroma-site", "mpeg2");
422       if (gst_structure_has_field (structure, "pixel-aspect-ratio"))
423         gst_structure_fixate_field_nearest_fraction (structure,
424             "pixel-aspect-ratio", 1, 1);
425
426       gst_pad_set_caps (otherpad, caps);
427       gst_caps_unref (caps);
428       ret = TRUE;
429     }
430     gst_object_unref (opeer);
431   }
432 done:
433   /* After a setcaps, our caps may have changed. In that case, we can't use
434    * the old buffer, if there was one (it might have different dimensions) */
435   GST_DEBUG_OBJECT (videorate, "swapping old buffers");
436   gst_video_rate_swap_prev (videorate, NULL, GST_CLOCK_TIME_NONE);
437
438   gst_object_unref (videorate);
439   return ret;
440
441 no_framerate:
442   {
443     GST_DEBUG_OBJECT (videorate, "no framerate specified");
444     goto done;
445   }
446 no_transform:
447   {
448     GST_DEBUG_OBJECT (videorate, "no framerate transform possible");
449     ret = FALSE;
450     goto done;
451   }
452 }
453
454 static void
455 gst_video_rate_reset (GstVideoRate * videorate)
456 {
457   GST_DEBUG_OBJECT (videorate, "resetting internal variables");
458
459   videorate->in = 0;
460   videorate->out = 0;
461   videorate->base_ts = 0;
462   videorate->out_frame_count = 0;
463   videorate->drop = 0;
464   videorate->dup = 0;
465   videorate->next_ts = GST_CLOCK_TIME_NONE;
466   videorate->last_ts = GST_CLOCK_TIME_NONE;
467   videorate->discont = TRUE;
468   videorate->average = 0;
469   gst_video_rate_swap_prev (videorate, NULL, 0);
470
471   gst_segment_init (&videorate->segment, GST_FORMAT_TIME);
472 }
473
474 static void
475 gst_video_rate_init (GstVideoRate * videorate)
476 {
477   videorate->sinkpad =
478       gst_pad_new_from_static_template (&gst_video_rate_sink_template, "sink");
479   gst_pad_set_event_function (videorate->sinkpad,
480       GST_DEBUG_FUNCPTR (gst_video_rate_event));
481   gst_pad_set_chain_function (videorate->sinkpad,
482       GST_DEBUG_FUNCPTR (gst_video_rate_chain));
483   gst_pad_set_getcaps_function (videorate->sinkpad,
484       GST_DEBUG_FUNCPTR (gst_video_rate_getcaps));
485   gst_pad_set_setcaps_function (videorate->sinkpad,
486       GST_DEBUG_FUNCPTR (gst_video_rate_setcaps));
487   gst_element_add_pad (GST_ELEMENT (videorate), videorate->sinkpad);
488
489   videorate->srcpad =
490       gst_pad_new_from_static_template (&gst_video_rate_src_template, "src");
491   gst_pad_set_query_function (videorate->srcpad,
492       GST_DEBUG_FUNCPTR (gst_video_rate_query));
493   gst_pad_set_getcaps_function (videorate->srcpad,
494       GST_DEBUG_FUNCPTR (gst_video_rate_getcaps));
495   gst_pad_set_setcaps_function (videorate->srcpad,
496       GST_DEBUG_FUNCPTR (gst_video_rate_setcaps));
497   gst_element_add_pad (GST_ELEMENT (videorate), videorate->srcpad);
498
499   gst_video_rate_reset (videorate);
500   videorate->silent = DEFAULT_SILENT;
501   videorate->new_pref = DEFAULT_NEW_PREF;
502   videorate->drop_only = DEFAULT_DROP_ONLY;
503   videorate->average_period = DEFAULT_AVERAGE_PERIOD;
504
505   videorate->from_rate_numerator = 0;
506   videorate->from_rate_denominator = 0;
507   videorate->to_rate_numerator = 0;
508   videorate->to_rate_denominator = 0;
509 }
510
511 /* flush the oldest buffer */
512 static GstFlowReturn
513 gst_video_rate_flush_prev (GstVideoRate * videorate, gboolean duplicate)
514 {
515   GstFlowReturn res;
516   GstBuffer *outbuf;
517   GstClockTime push_ts;
518
519   if (!videorate->prevbuf)
520     goto eos_before_buffers;
521
522   /* make sure we can write to the metadata */
523   outbuf = gst_buffer_make_writable (gst_buffer_ref (videorate->prevbuf));
524
525   GST_BUFFER_OFFSET (outbuf) = videorate->out;
526   GST_BUFFER_OFFSET_END (outbuf) = videorate->out + 1;
527
528   if (videorate->discont) {
529     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
530     videorate->discont = FALSE;
531   } else
532     GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DISCONT);
533
534   if (duplicate)
535     GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_GAP);
536   else
537     GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_GAP);
538
539   /* this is the timestamp we put on the buffer */
540   push_ts = videorate->next_ts;
541
542   videorate->out++;
543   videorate->out_frame_count++;
544   if (videorate->to_rate_numerator) {
545     /* interpolate next expected timestamp in the segment */
546     videorate->next_ts =
547         videorate->segment.base + videorate->segment.start +
548         videorate->base_ts + gst_util_uint64_scale (videorate->out_frame_count,
549         videorate->to_rate_denominator * GST_SECOND,
550         videorate->to_rate_numerator);
551     GST_BUFFER_DURATION (outbuf) = videorate->next_ts - push_ts;
552   }
553
554   /* We do not need to update time in VFR (variable frame rate) mode */
555   if (!videorate->drop_only) {
556     /* adapt for looping, bring back to time in current segment. */
557     GST_BUFFER_TIMESTAMP (outbuf) = push_ts - videorate->segment.base;
558   }
559
560   GST_LOG_OBJECT (videorate,
561       "old is best, dup, pushing buffer outgoing ts %" GST_TIME_FORMAT,
562       GST_TIME_ARGS (push_ts));
563
564   res = gst_pad_push (videorate->srcpad, outbuf);
565
566   return res;
567
568   /* WARNINGS */
569 eos_before_buffers:
570   {
571     GST_INFO_OBJECT (videorate, "got EOS before any buffer was received");
572     return GST_FLOW_OK;
573   }
574 }
575
576 static void
577 gst_video_rate_swap_prev (GstVideoRate * videorate, GstBuffer * buffer,
578     gint64 time)
579 {
580   GST_LOG_OBJECT (videorate, "swap_prev: storing buffer %p in prev", buffer);
581   if (videorate->prevbuf)
582     gst_buffer_unref (videorate->prevbuf);
583   videorate->prevbuf = buffer;
584   videorate->prev_ts = time;
585 }
586
587 static void
588 gst_video_rate_notify_drop (GstVideoRate * videorate)
589 {
590 #if !GLIB_CHECK_VERSION(2,26,0)
591   g_object_notify ((GObject *) videorate, "drop");
592 #else
593   g_object_notify_by_pspec ((GObject *) videorate, pspec_drop);
594 #endif
595 }
596
597 static void
598 gst_video_rate_notify_duplicate (GstVideoRate * videorate)
599 {
600 #if !GLIB_CHECK_VERSION(2,26,0)
601   g_object_notify ((GObject *) videorate, "duplicate");
602 #else
603   g_object_notify_by_pspec ((GObject *) videorate, pspec_duplicate);
604 #endif
605 }
606
607 #define MAGIC_LIMIT  25
608 static gboolean
609 gst_video_rate_event (GstPad * pad, GstEvent * event)
610 {
611   GstVideoRate *videorate;
612   gboolean ret;
613
614   videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
615
616   switch (GST_EVENT_TYPE (event)) {
617     case GST_EVENT_SEGMENT:
618     {
619       const GstSegment *segment;
620
621       gst_event_parse_segment (event, &segment);
622
623       if (segment->format != GST_FORMAT_TIME)
624         goto format_error;
625
626       GST_DEBUG_OBJECT (videorate, "handle NEWSEGMENT");
627
628       /* close up the previous segment, if appropriate */
629       if (videorate->prevbuf) {
630         gint count = 0;
631         GstFlowReturn res;
632
633         res = GST_FLOW_OK;
634         /* fill up to the end of current segment,
635          * or only send out the stored buffer if there is no specific stop.
636          * regardless, prevent going loopy in strange cases */
637         while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
638             ((GST_CLOCK_TIME_IS_VALID (videorate->segment.stop) &&
639                     videorate->next_ts - videorate->segment.base
640                     < videorate->segment.stop)
641                 || count < 1)) {
642           res = gst_video_rate_flush_prev (videorate, count > 0);
643           count++;
644         }
645         if (count > 1) {
646           videorate->dup += count - 1;
647           if (!videorate->silent)
648             gst_video_rate_notify_duplicate (videorate);
649         } else if (count == 0) {
650           videorate->drop++;
651           if (!videorate->silent)
652             gst_video_rate_notify_drop (videorate);
653         }
654         /* clean up for the new one; _chain will resume from the new start */
655         videorate->base_ts = 0;
656         videorate->out_frame_count = 0;
657         gst_video_rate_swap_prev (videorate, NULL, 0);
658         videorate->next_ts = GST_CLOCK_TIME_NONE;
659       }
660
661       /* We just want to update the accumulated stream_time  */
662       gst_segment_copy_into (segment, &videorate->segment);
663
664       GST_DEBUG_OBJECT (videorate, "updated segment: %" GST_SEGMENT_FORMAT,
665           &videorate->segment);
666       break;
667     }
668     case GST_EVENT_EOS:{
669       gint count = 0;
670       GstFlowReturn res = GST_FLOW_OK;
671
672       GST_DEBUG_OBJECT (videorate, "Got EOS");
673
674       /* If the segment has a stop position, fill the segment */
675       if (GST_CLOCK_TIME_IS_VALID (videorate->segment.stop)) {
676         /* fill up to the end of current segment,
677          * or only send out the stored buffer if there is no specific stop.
678          * regardless, prevent going loopy in strange cases */
679         while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
680             ((videorate->next_ts - videorate->segment.base <
681                     videorate->segment.stop)
682                 || count < 1)) {
683           res = gst_video_rate_flush_prev (videorate, count > 0);
684           count++;
685         }
686       } else if (videorate->prevbuf) {
687         /* Output at least one frame but if the buffer duration is valid, output
688          * enough frames to use the complete buffer duration */
689         if (GST_BUFFER_DURATION_IS_VALID (videorate->prevbuf)) {
690           GstClockTime end_ts =
691               videorate->next_ts + GST_BUFFER_DURATION (videorate->prevbuf);
692
693           while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
694               ((videorate->next_ts - videorate->segment.base < end_ts)
695                   || count < 1)) {
696             res = gst_video_rate_flush_prev (videorate, count > 0);
697             count++;
698           }
699         } else {
700           res = gst_video_rate_flush_prev (videorate, FALSE);
701           count = 1;
702         }
703       }
704
705       if (count > 1) {
706         videorate->dup += count - 1;
707         if (!videorate->silent)
708           gst_video_rate_notify_duplicate (videorate);
709       } else if (count == 0) {
710         videorate->drop++;
711         if (!videorate->silent)
712           gst_video_rate_notify_drop (videorate);
713       }
714
715       break;
716     }
717     case GST_EVENT_FLUSH_STOP:
718       /* also resets the segment */
719       GST_DEBUG_OBJECT (videorate, "Got FLUSH_STOP");
720       gst_video_rate_reset (videorate);
721       break;
722     default:
723       break;
724   }
725
726   ret = gst_pad_push_event (videorate->srcpad, event);
727
728 done:
729   gst_object_unref (videorate);
730
731   return ret;
732
733   /* ERRORS */
734 format_error:
735   {
736     GST_WARNING_OBJECT (videorate,
737         "Got segment but doesn't have GST_FORMAT_TIME value");
738     gst_event_unref (event);
739     ret = FALSE;
740     goto done;
741   }
742 }
743
744 static gboolean
745 gst_video_rate_query (GstPad * pad, GstQuery * query)
746 {
747   GstVideoRate *videorate;
748   gboolean res = FALSE;
749
750   videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
751
752   switch (GST_QUERY_TYPE (query)) {
753     case GST_QUERY_LATENCY:
754     {
755       GstClockTime min, max;
756       gboolean live;
757       guint64 latency;
758       GstPad *peer;
759
760       if ((peer = gst_pad_get_peer (videorate->sinkpad))) {
761         if ((res = gst_pad_query (peer, query))) {
762           gst_query_parse_latency (query, &live, &min, &max);
763
764           GST_DEBUG_OBJECT (videorate, "Peer latency: min %"
765               GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
766               GST_TIME_ARGS (min), GST_TIME_ARGS (max));
767
768           if (videorate->from_rate_numerator != 0) {
769             /* add latency. We don't really know since we hold on to the frames
770              * until we get a next frame, which can be anything. We assume
771              * however that this will take from_rate time. */
772             latency = gst_util_uint64_scale (GST_SECOND,
773                 videorate->from_rate_denominator,
774                 videorate->from_rate_numerator);
775           } else {
776             /* no input framerate, we don't know */
777             latency = 0;
778           }
779
780           GST_DEBUG_OBJECT (videorate, "Our latency: %"
781               GST_TIME_FORMAT, GST_TIME_ARGS (latency));
782
783           min += latency;
784           if (max != -1)
785             max += latency;
786
787           GST_DEBUG_OBJECT (videorate, "Calculated total latency : min %"
788               GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
789               GST_TIME_ARGS (min), GST_TIME_ARGS (max));
790
791           gst_query_set_latency (query, live, min, max);
792         }
793         gst_object_unref (peer);
794       }
795       break;
796     }
797     default:
798       res = gst_pad_query_default (pad, query);
799       break;
800   }
801   gst_object_unref (videorate);
802
803   return res;
804 }
805
806 static GstFlowReturn
807 gst_video_rate_chain_max_avg (GstVideoRate * videorate, GstBuffer * buf)
808 {
809   GstClockTime ts = GST_BUFFER_TIMESTAMP (buf);
810
811   videorate->in++;
812
813   if (!GST_CLOCK_TIME_IS_VALID (ts) || videorate->wanted_diff == 0)
814     goto push;
815
816   /* drop frames if they exceed our output rate */
817   if (GST_CLOCK_TIME_IS_VALID (videorate->last_ts)) {
818     GstClockTimeDiff diff = ts - videorate->last_ts;
819
820     /* Drop buffer if its early compared to the desired frame rate and
821      * the current average is higher than the desired average
822      */
823     if (diff < videorate->wanted_diff &&
824         videorate->average < videorate->wanted_diff)
825       goto drop;
826
827     /* Update average */
828     if (videorate->average) {
829       GstClockTimeDiff wanted_diff;
830
831       if (G_LIKELY (videorate->average_period > videorate->wanted_diff))
832         wanted_diff = videorate->wanted_diff;
833       else
834         wanted_diff = videorate->average_period * 10;
835
836       videorate->average =
837           gst_util_uint64_scale_round (videorate->average,
838           videorate->average_period - wanted_diff,
839           videorate->average_period) +
840           gst_util_uint64_scale_round (diff, wanted_diff,
841           videorate->average_period);
842     } else {
843       videorate->average = diff;
844     }
845   }
846
847   videorate->last_ts = ts;
848
849 push:
850   videorate->out++;
851
852   return gst_pad_push (videorate->srcpad, buf);
853
854 drop:
855   gst_buffer_unref (buf);
856   if (!videorate->silent)
857     gst_video_rate_notify_drop (videorate);
858   return GST_FLOW_OK;
859 }
860
861 static GstFlowReturn
862 gst_video_rate_chain (GstPad * pad, GstBuffer * buffer)
863 {
864   GstVideoRate *videorate;
865   GstFlowReturn res = GST_FLOW_OK;
866   GstClockTime intime, in_ts, in_dur;
867   GstClockTime avg_period;
868   gboolean skip = FALSE;
869
870   videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));
871
872   /* make sure the denominators are not 0 */
873   if (videorate->from_rate_denominator == 0 ||
874       videorate->to_rate_denominator == 0)
875     goto not_negotiated;
876
877   GST_OBJECT_LOCK (videorate);
878   avg_period = videorate->average_period_set;
879   GST_OBJECT_UNLOCK (videorate);
880
881   /* MT-safe switching between modes */
882   if (G_UNLIKELY (avg_period != videorate->average_period)) {
883     videorate->average_period = avg_period;
884     videorate->last_ts = GST_CLOCK_TIME_NONE;
885     if (avg_period && !videorate->average) {
886       /* enabling average mode */
887       videorate->average = 0;
888     } else {
889       /* enable regular mode */
890       gst_video_rate_swap_prev (videorate, NULL, 0);
891       /* arrange for skip-to-first behaviour */
892       videorate->next_ts = GST_CLOCK_TIME_NONE;
893       skip = TRUE;
894     }
895   }
896
897   if (videorate->average_period > 0)
898     return gst_video_rate_chain_max_avg (videorate, buffer);
899
900   in_ts = GST_BUFFER_TIMESTAMP (buffer);
901   in_dur = GST_BUFFER_DURATION (buffer);
902
903   if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE)) {
904     in_ts = videorate->last_ts;
905     if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE))
906       goto invalid_buffer;
907   }
908
909   /* get the time of the next expected buffer timestamp, we use this when the
910    * next buffer has -1 as a timestamp */
911   videorate->last_ts = in_ts;
912   if (in_dur != GST_CLOCK_TIME_NONE)
913     videorate->last_ts += in_dur;
914
915   GST_DEBUG_OBJECT (videorate, "got buffer with timestamp %" GST_TIME_FORMAT,
916       GST_TIME_ARGS (in_ts));
917
918   /* the input time is the time in the segment + all previously accumulated
919    * segments */
920   intime = in_ts + videorate->segment.base;
921
922   /* we need to have two buffers to compare */
923   if (videorate->prevbuf == NULL) {
924     gst_video_rate_swap_prev (videorate, buffer, intime);
925     videorate->in++;
926     if (!GST_CLOCK_TIME_IS_VALID (videorate->next_ts)) {
927       /* new buffer, we expect to output a buffer that matches the first
928        * timestamp in the segment */
929       if (videorate->skip_to_first || skip) {
930         videorate->next_ts = intime;
931         videorate->base_ts = in_ts - videorate->segment.start;
932         videorate->out_frame_count = 0;
933       } else {
934         videorate->next_ts = videorate->segment.start + videorate->segment.base;
935       }
936     }
937   } else {
938     GstClockTime prevtime;
939     gint count = 0;
940     gint64 diff1, diff2;
941
942     prevtime = videorate->prev_ts;
943
944     GST_LOG_OBJECT (videorate,
945         "BEGINNING prev buf %" GST_TIME_FORMAT " new buf %" GST_TIME_FORMAT
946         " outgoing ts %" GST_TIME_FORMAT, GST_TIME_ARGS (prevtime),
947         GST_TIME_ARGS (intime), GST_TIME_ARGS (videorate->next_ts));
948
949     videorate->in++;
950
951     /* drop new buffer if it's before previous one */
952     if (intime < prevtime) {
953       GST_DEBUG_OBJECT (videorate,
954           "The new buffer (%" GST_TIME_FORMAT
955           ") is before the previous buffer (%"
956           GST_TIME_FORMAT "). Dropping new buffer.",
957           GST_TIME_ARGS (intime), GST_TIME_ARGS (prevtime));
958       videorate->drop++;
959       if (!videorate->silent)
960         gst_video_rate_notify_drop (videorate);
961       gst_buffer_unref (buffer);
962       goto done;
963     }
964
965     /* got 2 buffers, see which one is the best */
966     do {
967
968       diff1 = prevtime - videorate->next_ts;
969       diff2 = intime - videorate->next_ts;
970
971       /* take absolute values, beware: abs and ABS don't work for gint64 */
972       if (diff1 < 0)
973         diff1 = -diff1;
974       if (diff2 < 0)
975         diff2 = -diff2;
976
977       GST_LOG_OBJECT (videorate,
978           "diff with prev %" GST_TIME_FORMAT " diff with new %"
979           GST_TIME_FORMAT " outgoing ts %" GST_TIME_FORMAT,
980           GST_TIME_ARGS (diff1), GST_TIME_ARGS (diff2),
981           GST_TIME_ARGS (videorate->next_ts));
982
983       /* output first one when its the best */
984       if (diff1 <= diff2) {
985         count++;
986
987         /* on error the _flush function posted a warning already */
988         if ((res =
989                 gst_video_rate_flush_prev (videorate,
990                     count > 1)) != GST_FLOW_OK) {
991           gst_buffer_unref (buffer);
992           goto done;
993         }
994       }
995
996       /* Do not produce any dups. We can exit loop now */
997       if (videorate->drop_only)
998         break;
999       /* continue while the first one was the best, if they were equal avoid
1000        * going into an infinite loop */
1001     }
1002     while (diff1 < diff2);
1003
1004     /* if we outputed the first buffer more then once, we have dups */
1005     if (count > 1) {
1006       videorate->dup += count - 1;
1007       if (!videorate->silent)
1008         gst_video_rate_notify_duplicate (videorate);
1009     }
1010     /* if we didn't output the first buffer, we have a drop */
1011     else if (count == 0) {
1012       videorate->drop++;
1013
1014       if (!videorate->silent)
1015         gst_video_rate_notify_drop (videorate);
1016
1017       GST_LOG_OBJECT (videorate,
1018           "new is best, old never used, drop, outgoing ts %"
1019           GST_TIME_FORMAT, GST_TIME_ARGS (videorate->next_ts));
1020     }
1021     GST_LOG_OBJECT (videorate,
1022         "END, putting new in old, diff1 %" GST_TIME_FORMAT
1023         ", diff2 %" GST_TIME_FORMAT ", next_ts %" GST_TIME_FORMAT
1024         ", in %" G_GUINT64_FORMAT ", out %" G_GUINT64_FORMAT ", drop %"
1025         G_GUINT64_FORMAT ", dup %" G_GUINT64_FORMAT, GST_TIME_ARGS (diff1),
1026         GST_TIME_ARGS (diff2), GST_TIME_ARGS (videorate->next_ts),
1027         videorate->in, videorate->out, videorate->drop, videorate->dup);
1028
1029     /* swap in new one when it's the best */
1030     gst_video_rate_swap_prev (videorate, buffer, intime);
1031   }
1032 done:
1033   return res;
1034
1035   /* ERRORS */
1036 not_negotiated:
1037   {
1038     GST_WARNING_OBJECT (videorate, "no framerate negotiated");
1039     gst_buffer_unref (buffer);
1040     res = GST_FLOW_NOT_NEGOTIATED;
1041     goto done;
1042   }
1043
1044 invalid_buffer:
1045   {
1046     GST_WARNING_OBJECT (videorate,
1047         "Got buffer with GST_CLOCK_TIME_NONE timestamp, discarding it");
1048     gst_buffer_unref (buffer);
1049     goto done;
1050   }
1051 }
1052
1053 static void
1054 gst_video_rate_set_property (GObject * object,
1055     guint prop_id, const GValue * value, GParamSpec * pspec)
1056 {
1057   GstVideoRate *videorate = GST_VIDEO_RATE (object);
1058
1059   GST_OBJECT_LOCK (videorate);
1060   switch (prop_id) {
1061     case ARG_SILENT:
1062       videorate->silent = g_value_get_boolean (value);
1063       break;
1064     case ARG_NEW_PREF:
1065       videorate->new_pref = g_value_get_double (value);
1066       break;
1067     case ARG_SKIP_TO_FIRST:
1068       videorate->skip_to_first = g_value_get_boolean (value);
1069       break;
1070     case ARG_DROP_ONLY:
1071       videorate->drop_only = g_value_get_boolean (value);
1072       break;
1073     case ARG_AVERAGE_PERIOD:
1074       videorate->average_period = g_value_get_uint64 (value);
1075       break;
1076     default:
1077       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1078       break;
1079   }
1080   GST_OBJECT_UNLOCK (videorate);
1081 }
1082
1083 static void
1084 gst_video_rate_get_property (GObject * object,
1085     guint prop_id, GValue * value, GParamSpec * pspec)
1086 {
1087   GstVideoRate *videorate = GST_VIDEO_RATE (object);
1088
1089   GST_OBJECT_LOCK (videorate);
1090   switch (prop_id) {
1091     case ARG_IN:
1092       g_value_set_uint64 (value, videorate->in);
1093       break;
1094     case ARG_OUT:
1095       g_value_set_uint64 (value, videorate->out);
1096       break;
1097     case ARG_DUP:
1098       g_value_set_uint64 (value, videorate->dup);
1099       break;
1100     case ARG_DROP:
1101       g_value_set_uint64 (value, videorate->drop);
1102       break;
1103     case ARG_SILENT:
1104       g_value_set_boolean (value, videorate->silent);
1105       break;
1106     case ARG_NEW_PREF:
1107       g_value_set_double (value, videorate->new_pref);
1108       break;
1109     case ARG_SKIP_TO_FIRST:
1110       g_value_set_boolean (value, videorate->skip_to_first);
1111       break;
1112     case ARG_DROP_ONLY:
1113       g_value_set_boolean (value, videorate->drop_only);
1114       break;
1115     case ARG_AVERAGE_PERIOD:
1116       g_value_set_uint64 (value, videorate->average_period);
1117       break;
1118     default:
1119       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1120       break;
1121   }
1122   GST_OBJECT_UNLOCK (videorate);
1123 }
1124
1125 static GstStateChangeReturn
1126 gst_video_rate_change_state (GstElement * element, GstStateChange transition)
1127 {
1128   GstStateChangeReturn ret;
1129   GstVideoRate *videorate;
1130
1131   videorate = GST_VIDEO_RATE (element);
1132
1133   switch (transition) {
1134     case GST_STATE_CHANGE_READY_TO_PAUSED:
1135       videorate->discont = TRUE;
1136       videorate->last_ts = -1;
1137       break;
1138     default:
1139       break;
1140   }
1141
1142   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1143
1144   switch (transition) {
1145     case GST_STATE_CHANGE_PAUSED_TO_READY:
1146       gst_video_rate_reset (videorate);
1147       break;
1148     default:
1149       break;
1150   }
1151
1152   return ret;
1153 }
1154
1155 static gboolean
1156 plugin_init (GstPlugin * plugin)
1157 {
1158   GST_DEBUG_CATEGORY_INIT (video_rate_debug, "videorate", 0,
1159       "VideoRate stream fixer");
1160
1161   return gst_element_register (plugin, "videorate", GST_RANK_NONE,
1162       GST_TYPE_VIDEO_RATE);
1163 }
1164
1165 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1166     GST_VERSION_MINOR,
1167     "videorate",
1168     "Adjusts video frames",
1169     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)