FCL/sf/mw/gstreamer: comparison gst_plugins_base/gst/videorate/gstvideorate.c

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 * Boston, MA 02111-1307, USA.
 */
 /**
 * SECTION:element-videorate
+* @short_description: retimestamps and drops/duplicates video frames to
+*  match the source pad's framerate and create a perfect stream
 *
+* <refsect2>
+* <para>
 * This element takes an incoming stream of timestamped video frames.
 * It will produce a perfect stream that matches the source pad's framerate.
 *
 * The correction is performed by dropping and duplicating frames, no fancy
 * algorithm is used to interpolate frames (yet).
-*
+* </para>
+* <para>
 * By default the element will simply negotiate the same framerate on its
 * source and sink pad.
-*
+* </para>
+* <para>
 * This operation is useful to link to elements that require a perfect stream.
 * Typical examples are formats that do not store timestamps for video frames,
 * but only store a framerate, like Ogg and AVI.
-*
+* </para>
+* <para>
 * A conversion to a specific framerate can be forced by using filtered caps on
 * the source pad.
-*
+* </para>
-* The properties #GstVideoRate:in, #GstVideoRate:out, #GstVideoRate:duplicate
+* <para>
-* and #GstVideoRate:drop can be read to obtain information about number of
+* The properties "in", "out", "duplicate" and "drop" can be read to obtain
-* input frames, output frames, dropped frames (i.e. the number of unused input
+* information about number of input frames, output frames, dropped frames
-* frames) and duplicated frames (i.e. the number of times an input frame was
+* (i.e. the number of unused input frames) and duplicated frames (i.e. the
-* duplicated, beside being used normally).
+*  number of times an input frame was duplicated, beside being used normally).
 *
 * An input stream that needs no adjustments will thus never have dropped or
 * duplicated frames.
 *
-* When the #GstVideoRate:silent property is set to FALSE, a GObject property
+* When the "silent" property is set to FALSE, a GObject property notification
-* notification will be emitted whenever one of the #GstVideoRate:duplicate or
+* will be emitted whenever one of the "duplicate" or "drop" values changes.
-* #GstVideoRate:drop values changes.
 * This can potentially cause performance degradation.
 * Note that property notification will happen from the streaming thread, so
 * applications should be prepared for this.
-*
+* </para>
-* <refsect2>
 * <title>Example pipelines</title>
-* |[
+* <para>
+* <programlisting>
 * gst-launch -v filesrc location=videotestsrc.ogg ! oggdemux ! theoradec ! videorate ! video/x-raw-yuv,framerate=15/1 ! xvimagesink
-* ]| Decode an Ogg/Theora file and adjust the framerate to 15 fps before playing.
+* </programlisting>
+* Decode an Ogg/Theora file and adjust the framerate to 15 fps before playing.
 * To create the test Ogg/Theora file refer to the documentation of theoraenc.
-* |[
+* </para>
+* <para>
+* <programlisting>
 * gst-launch -v v4lsrc ! videorate ! video/x-raw-yuv,framerate=25/2 ! theoraenc ! oggmux ! filesink location=v4l.ogg
-* ]| Capture video from a V4L device, and adjust the stream to 12.5 fps before
+* </programlisting>
+* Capture video from a V4L device, and adjust the stream to 12.5 fps before
 * encoding to Ogg/Theora.
-* </refsect2>
+* </para>
+* </refsect2>
 *
 * Last reviewed on 2006-09-02 (0.10.11)
 */
 #ifdef HAVE_CONFIG_H
 static GstStaticPadTemplate gst_video_rate_src_template =
 GST_STATIC_PAD_TEMPLATE ("src",
 GST_PAD_SRC,
 GST_PAD_ALWAYS,
-GST_STATIC_CAPS ("video/x-raw-yuv; video/x-raw-rgb; image/jpeg; image/png")
+GST_STATIC_CAPS ("video/x-raw-yuv; video/x-raw-rgb")
 );
 static GstStaticPadTemplate gst_video_rate_sink_template =
 GST_STATIC_PAD_TEMPLATE ("sink",
 GST_PAD_SINK,
 GST_PAD_ALWAYS,
-GST_STATIC_CAPS ("video/x-raw-yuv; video/x-raw-rgb; image/jpeg; image/png")
+GST_STATIC_CAPS ("video/x-raw-yuv; video/x-raw-rgb")
 );
 static void gst_video_rate_swap_prev (GstVideoRate * videorate,
 GstBuffer * buffer, gint64 time);
 static gboolean gst_video_rate_event (GstPad * pad, GstEvent * event);
 gst_element_class_add_pad_template (element_class,
 gst_static_pad_template_get (&gst_video_rate_sink_template));
 gst_element_class_add_pad_template (element_class,
 gst_static_pad_template_get (&gst_video_rate_src_template));
 }
 static void
 gst_video_rate_class_init (GstVideoRateClass * klass)
 {
 GObjectClass *object_class = G_OBJECT_CLASS (klass);
 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 object_class->set_property = gst_video_rate_set_property;
 object_class->get_property = gst_video_rate_get_property;
 g_object_class_install_property (object_class, ARG_IN,
 g_param_spec_uint64 ("in", "In",
-"Number of input frames", 0, G_MAXUINT64, 0,
+"Number of input frames", 0, G_MAXUINT64, 0, G_PARAM_READABLE));
-G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 g_object_class_install_property (object_class, ARG_OUT,
-g_param_spec_uint64 ("out", "Out", "Number of output frames", 0,
+g_param_spec_uint64 ("out", "Out",
-G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+"Number of output frames", 0, G_MAXUINT64, 0, G_PARAM_READABLE));
 g_object_class_install_property (object_class, ARG_DUP,
 g_param_spec_uint64 ("duplicate", "Duplicate",
-"Number of duplicated frames", 0, G_MAXUINT64, 0,
+"Number of duplicated frames", 0, G_MAXUINT64, 0, G_PARAM_READABLE));
-G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 g_object_class_install_property (object_class, ARG_DROP,
-g_param_spec_uint64 ("drop", "Drop", "Number of dropped frames", 0,
+g_param_spec_uint64 ("drop", "Drop",
-G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+"Number of dropped frames", 0, G_MAXUINT64, 0, G_PARAM_READABLE));
 g_object_class_install_property (object_class, ARG_SILENT,
 g_param_spec_boolean ("silent", "silent",
-"Don't emit notify for dropped and duplicated frames", DEFAULT_SILENT,
+"Don't emit notify for dropped and duplicated frames",
-G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+DEFAULT_SILENT, G_PARAM_READWRITE));
 g_object_class_install_property (object_class, ARG_NEW_PREF,
-g_param_spec_double ("new-pref", "New Pref",
+g_param_spec_double ("new_pref", "New Pref",
-"Value indicating how much to prefer new frames (unused)", 0.0, 1.0,
+"Value indicating how much to prefer new frames (unused)",
-DEFAULT_NEW_PREF, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+0.0, 1.0, DEFAULT_NEW_PREF, G_PARAM_READWRITE));
 element_class->change_state = gst_video_rate_change_state;
 }
 /* return the caps that can be used on out_pad given in_caps on in_pad */
 } else {
 videorate->from_rate_numerator = rate_numerator;
 videorate->from_rate_denominator = rate_denominator;
 otherpad = videorate->srcpad;
 }
 /* now try to find something for the peer */
 opeer = gst_pad_get_peer (otherpad);
 if (opeer) {
 if (gst_pad_accept_caps (opeer, caps)) {
 /* the peer accepts the caps as they are */
 {
 GST_DEBUG ("resetting internal variables");
 videorate->in = 0;
 videorate->out = 0;
-videorate->segment_out = 0;
 videorate->drop = 0;
 videorate->dup = 0;
 videorate->next_ts = GST_CLOCK_TIME_NONE;
-videorate->last_ts = GST_CLOCK_TIME_NONE;
-videorate->discont = TRUE;
 gst_video_rate_swap_prev (videorate, NULL, 0);
 gst_segment_init (&videorate->segment, GST_FORMAT_TIME);
 }
 (gst_buffer_ref (videorate->prevbuf));
 GST_BUFFER_OFFSET (outbuf) = videorate->out;
 GST_BUFFER_OFFSET_END (outbuf) = videorate->out + 1;
-if (videorate->discont) {
-GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
-videorate->discont = FALSE;
-} else
-GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DISCONT);
 /* this is the timestamp we put on the buffer */
 push_ts = videorate->next_ts;
 videorate->out++;
-videorate->segment_out++;
 if (videorate->to_rate_numerator) {
 /* interpolate next expected timestamp in the segment */
 videorate->next_ts = videorate->segment.accum + videorate->segment.start +
-gst_util_uint64_scale (videorate->segment_out,
+gst_util_uint64_scale (videorate->out,
 videorate->to_rate_denominator * GST_SECOND,
 videorate->to_rate_numerator);
 GST_BUFFER_DURATION (outbuf) = videorate->next_ts - push_ts;
 }
 gst_buffer_unref (videorate->prevbuf);
 videorate->prevbuf = buffer;
 videorate->prev_ts = time;
 }
-#define MAGIC_LIMIT  25
 static gboolean
 gst_video_rate_event (GstPad * pad, GstEvent * event)
 {
 GstVideoRate *videorate;
 gboolean ret;
 if (format != GST_FORMAT_TIME)
 goto format_error;
 GST_DEBUG_OBJECT (videorate, "handle NEWSEGMENT");
-/* close up the previous segment, if appropriate */
-if (!update && videorate->prevbuf) {
-gint count = 0;
-GstFlowReturn res;
-res = GST_FLOW_OK;
-/* fill up to the end of current segment,
-* or only send out the stored buffer if there is no specific stop.
-* regardless, prevent going loopy in strange cases */
-while (res == GST_FLOW_OK && count <= MAGIC_LIMIT &&
-((GST_CLOCK_TIME_IS_VALID (videorate->segment.stop) &&
-videorate->next_ts - videorate->segment.accum
-< videorate->segment.stop)
-|| count < 1)) {
-gst_video_rate_flush_prev (videorate);
-count++;
-}
-if (count > 1) {
-videorate->dup += count - 1;
-if (!videorate->silent)
-g_object_notify (G_OBJECT (videorate), "duplicate");
-} else if (count == 0) {
-videorate->drop++;
-if (!videorate->silent)
-g_object_notify (G_OBJECT (videorate), "drop");
-}
-/* clean up for the new one; _chain will resume from the new start */
-videorate->segment_out = 0;
-gst_video_rate_swap_prev (videorate, NULL, 0);
-videorate->next_ts = GST_CLOCK_TIME_NONE;
-}
 /* We just want to update the accumulated stream_time  */
 gst_segment_set_newsegment_full (&videorate->segment, update, rate, arate,
 format, start, stop, time);
 GST_DEBUG_OBJECT (videorate, "Peer latency: min %"
 GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
 GST_TIME_ARGS (min), GST_TIME_ARGS (max));
-if (videorate->from_rate_numerator != 0) {
+/* add latency. We don't really know since we hold on to the frames
-/* add latency. We don't really know since we hold on to the frames
+* until we get a next frame, which can be anything. We assume
-* until we get a next frame, which can be anything. We assume
+* however that this will take from_rate time. */
-* however that this will take from_rate time. */
+latency = gst_util_uint64_scale (GST_SECOND,
-latency = gst_util_uint64_scale (GST_SECOND,
+videorate->from_rate_denominator, videorate->from_rate_numerator);
-videorate->from_rate_denominator,
-videorate->from_rate_numerator);
-} else {
-/* no input framerate, we don't know */
-latency = 0;
-}
 GST_DEBUG_OBJECT (videorate, "Our latency: %"
 GST_TIME_FORMAT, GST_TIME_ARGS (latency));
 min += latency;
 static GstFlowReturn
 gst_video_rate_chain (GstPad * pad, GstBuffer * buffer)
 {
 GstVideoRate *videorate;
 GstFlowReturn res = GST_FLOW_OK;
-GstClockTime intime, in_ts, in_dur;
+GstClockTime intime, in_ts;
 videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad));
 /* make sure the denominators are not 0 */
 if (videorate->from_rate_denominator == 0 ||
 videorate->to_rate_denominator == 0)
 goto not_negotiated;
 in_ts = GST_BUFFER_TIMESTAMP (buffer);
-in_dur = GST_BUFFER_DURATION (buffer);
+if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE))
-if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE)) {
+goto invalid_buffer;
-in_ts = videorate->last_ts;
-if (G_UNLIKELY (in_ts == GST_CLOCK_TIME_NONE))
-goto invalid_buffer;
-}
-/* get the time of the next expected buffer timestamp, we use this when the
-* next buffer has -1 as a timestamp */
-videorate->last_ts = in_ts;
-if (in_dur != GST_CLOCK_TIME_NONE)
-videorate->last_ts += in_dur;
 GST_DEBUG_OBJECT (videorate, "got buffer with timestamp %" GST_TIME_FORMAT,
 GST_TIME_ARGS (in_ts));
 /* the input time is the time in the segment + all previously accumulated
 gst_video_rate_swap_prev (videorate, buffer, intime);
 videorate->in++;
 if (!GST_CLOCK_TIME_IS_VALID (videorate->next_ts)) {
 /* new buffer, we expect to output a buffer that matches the first
 * timestamp in the segment */
-videorate->next_ts = videorate->segment.start + videorate->segment.accum;
+videorate->next_ts = videorate->segment.start;
 }
 } else {
 GstClockTime prevtime;
 gint count = 0;
 gint64 diff1, diff2;
 GST_TIME_FORMAT " outgoing ts %" GST_TIME_FORMAT,
 GST_TIME_ARGS (diff1), GST_TIME_ARGS (diff2),
 GST_TIME_ARGS (videorate->next_ts));
 /* output first one when its the best */
-if (diff1 <= diff2) {
+if (diff1 < diff2) {
 count++;
 /* on error the _flush function posted a warning already */
 if ((res = gst_video_rate_flush_prev (videorate)) != GST_FLOW_OK) {
 gst_buffer_unref (buffer);
 goto done;
 }
 }
-/* continue while the first one was the best, if they were equal avoid
+/* continue while the first one was the best */
-* going into an infinite loop */
 }
 while (diff1 < diff2);
 /* if we outputed the first buffer more then once, we have dups */
 if (count > 1) {
 GstVideoRate *videorate;
 videorate = GST_VIDEO_RATE (element);
 switch (transition) {
-case GST_STATE_CHANGE_READY_TO_PAUSED:
-videorate->discont = TRUE;
-videorate->last_ts = -1;
-break;
 default:
 break;
 }
 ret = parent_class->change_state (element, transition);

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3