diff --git a/ChangeLog b/ChangeLog
index 053b2a3..0eb9a02 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,9 +1,544 @@
-=== release 1.9.2 ===
+=== release 1.9.90 ===
 
-2016-09-01  Sebastian Dröge <slomo@coaxion.net>
+2016-09-30  Sebastian Dröge <slomo@coaxion.net>
 
 	* configure.ac:
-	  releasing 1.9.2
+	  releasing 1.9.90
+
+2016-09-30 11:43:54 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* po/el.po:
+	  po: Update translations
+
+2016-09-30 13:22:32 +0530  Arun Raghavan <arun@osg.samsung.com>
+
+	* tests/check/pipelines/tagschecking.c:
+	  tests: Fix tagschecking failure due to missing PTS
+	  qtmux now needs the PTS (commit a993883b7), so let's make sure we
+	  produce one with our buffers.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=772228
+
+2016-09-28 23:03:58 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/gstqtmux.c:
+	  qtmux: Don't calculate PTS offset and DTS with GST_CLOCK_TIME_NONE
+	  Just error out if there is no valid PTS.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=772143
+
+2016-09-29 17:37:28 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux_types.c:
+	  qtdemux: Add JPEG2000 ihdr atom to the list of known ones
+	  Otherwise qtdemux is always going to complain about it being unknown.
+
+2016-09-29 10:19:56 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/matroska/matroska-mux.c:
+	  matroskamux: Always write the default frame duration for VP8/9 too
+	  The WebM spec allows this now, and it allows us to guess a framerate.
+	  See https://bugzilla.gnome.org/show_bug.cgi?id=772141 and
+	  also https://bugzilla.gnome.org/show_bug.cgi?id=654379
+
+2016-09-27 15:26:19 -0400  Olivier Crête <olivier.crete@collabora.com>
+
+	* gst/rtp/gstrtph264depay.c:
+	* gst/rtp/gstrtph265depay.c:
+	  rtph26[45]depay: Don't handle NALs inside STAP units twice
+	  They've already been handled before pushing them into the adapter.
+
+2016-09-27 12:39:12 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* tests/check/meson.build:
+	  meson: tests: fix vp8 availability checks
+	  Those variables are not defined if vp8 was not found.
+
+2016-09-27 10:23:38 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* gst/multifile/gstmultifilesink.c:
+	  Revert "multifilesink: streamline the file-switch code a bit"
+	  This reverts commit f1ceaab02f3f557e23b77b14771a575788f92bb4.
+	  This broke atomic file writes in "buffer" mode. It did make
+	  sure that any streamheaders are prepended to each file in
+	  buffer mode as well, but that's not really needed in practice,
+	  whereas atomic file writes are, so let's restore the status
+	  quo ante for now since this was primarily a code cleanup anyway,
+	  and if anyone needs to streamheaders in buffer mode too they
+	  can make a patch to implement that differently. Re-implementing
+	  the atomic writes in the element also seems way too much work.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=766990
+
+2016-09-27 10:22:57 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* gst/multifile/gstmultifilesink.c:
+	  Revert "multifilesink: close file on write error with next-file mode is set to buffer"
+	  This reverts commit 84e441d2685cf223d348a95be0c5ba693bbf6624.
+	  This will no longer be needed once we revert f1ceaab02.
+
+2016-09-26 13:22:29 -0300  Thibault Saunier <thibault.saunier@osg.samsung.com>
+
+	* tests/check/meson.build:
+	  meson: Add gst-plugins-base plugins directories to be used by tests
+
+2016-09-26 14:30:00 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* ext/vpx/meson.build:
+	* meson.build:
+	* tests/check/getpluginsdir:
+	* tests/check/meson.build:
+	  meson: add unit tests
+	  Only works properly in an installed setup currently, most
+	  likely won't work with a subprojects setup yet.
+
+2016-09-24 09:36:24 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* meson.build:
+	* po/meson.build:
+	  meson: hook up translations
+
+2016-09-08 17:30:41 +0530  Arun Raghavan <arun@arunraghavan.net>
+
+	* ext/pulse/pulsesrc.c:
+	  pulsesrc: Don't negotiate to less than two segments
+	  GstAudioRingBuffer doesn't needs us to have at least 2 segments. We make
+	  sure that if our buffer parameters are such that the maxlength is not at
+	  least 2x fragsize, we still request the ringbuffer to keep that much
+	  space so it continues to work.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=770446
+
+2016-09-24 23:22:01 +0530  Arun Raghavan <arun@arunraghavan.net>
+
+	* gst/rtp/gstrtpsbcpay.c:
+	* gst/rtp/gstrtpsbcpay.h:
+	  rtpsbcpay: Fix timestamping
+	  We were just picking the timestamp of the last buffer pushed into our
+	  adapter before we had enough data to push out.
+	  This fixes things to figure out how large each frame is and what
+	  duration it covers, so we can set both the timestamp and duration
+	  correctly.
+	  Also adds some DISCONT handling.
+
+2016-07-12 18:14:52 +0200  Georg Lippitsch <glippitsch@toolsonair.com>
+
+	* gst/isomp4/gstqtmux.c:
+	  qtmux: Fix fourcc for ProRes Proxy
+	  This is apco, according to
+	  https://wiki.multimedia.cx/index.php?title=Apple_ProRes
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769048
+
+2016-09-18 20:55:31 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* ext/vpx/meson.build:
+	  meson: fix build with vpx 1.3.x
+	  vpx >= 1.4.0 is optional
+
+2016-09-15 18:19:35 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/rtsp/gstrtspsrc.c:
+	  rtspsrc: Use new bin suppressed flags API for managing the element flags
+
+2016-09-15 09:52:31 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* ext/jack/gstjackaudioclient.c:
+	* gst/rtp/dboolhuff.c:
+	* gst/rtpmanager/rtpsession.c:
+	* gst/videofilter/gstvideoflip.c:
+	  ext, gst: fix indentation
+
+2016-09-15 09:52:17 +0100  Tim-Philipp Müller <tim@centricular.com>
+
+	* tests/check/elements/flvmux.c:
+	* tests/check/elements/rtph263.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	* tests/check/elements/rtpsession.c:
+	* tests/check/elements/rtpvp9.c:
+	  tests: fix indentation
+
+2016-08-11 11:04:22 -0600  Thomas Bluemel <tbluemel@control4.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	  rtpjitterbuffer: Fix calculating next_seqnum when dropping old buffers from a full queue.
+	  Fixes calculating the next sequence number when a ITEM_TYPE_LOST with more than one
+	  definitely lost packets is encountered.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769757
+
+2016-08-11 23:07:44 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: improved rtx-rtt averaging
+	  The basic idea is this:
+	  1. For *larger* rtx-rtt, weigh a new measurement as before
+	  2. For *smaller* rtx-rtt, be a bit more conservative and weigh a bit less
+	  3. For very large measurements, consider them "outliers"
+	  and count them a lot less
+	  The idea being that reducing the rtx-rtt is much more harmful then
+	  increasing it, since we don't want to be underestimating the rtt of the
+	  network, and when using this number to estimate the latency you need for
+	  you jitterbuffer, you would rather want it to be a bit larger then a bit
+	  smaller, potentially losing rtx-packets. The "outlier-detector" is there
+	  to prevent a single skewed measurement to affect the outcome too much.
+	  On wireless networks, these are surprisingly common.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-08-05 12:51:59 +0200  Stian Selnes <stian@pexip.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Detect whether to assume equidistant spacing when loss
+	  Assuming equidistant packet spacing when that's not true leads to more
+	  loss than necessary in the case of reordering and jitter. Typically this
+	  is true for video where one frame often consists of multiple packets
+	  with the same rtp timestamp. In this case it's better to assume that the
+	  missing packets have the same timestamp as the last received packet, so
+	  that the scheduled lost timer does not time out too early causing the
+	  packets to be considered lost even though they may arrive in time.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-07-27 10:39:50 +0200  Stian Selnes <stian@pexip.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Don't request rtx if 'now' is past retry period
+	  There is no need to schedule another EXPECTED timer if we're already
+	  past the retry period. Under normal operation this won't happen, but if
+	  there are more timers than the jitterbuffer is able to process in
+	  real-time, scheduling more timers will just make the situation worse.
+	  Instead, consider this packet as lost and move on. This scenario can
+	  occur with high loss rate, low rtt and high configured latency.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-07-26 18:01:48 +0200  Stian Selnes <stian@pexip.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Fix lost duration when gap after lost timer
+	  This patch fixes an issue with the estimated gap duration when there is
+	  a gap immediately after a lost timer has been processed. Previously
+	  there was a discrepancy beteen the gap in seqnum and gap in dts which
+	  would cause wrong calculated duration. The issue would only be seen with
+	  retranmission enabled since when it's disabled lost timers are only
+	  created when a packet is received and the actual gap length and last dts
+	  is known.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-07-19 01:11:58 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	  rtpjitterbuffer: Expose rtx-deadline as a property
+	  The default -1 gives the old behavior.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-08-11 12:02:19 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Improved expected-timer handling when gap > 0
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-08-11 11:51:50 +0200  Stian Selnes <stian@pexip.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Major improvements for RTX stats
+	  Stats should also be collected for unsuccessful packets.
+	  rtx-rtt is very important for determining the necessary configured
+	  latency on the jitterbuffer. It's especially important to be able to
+	  increase the latency when retransmitted packets arrive too late and are
+	  considered lost. This patch includes these late packets in the
+	  calculation of the various rtx stats, making them more correct and
+	  useful.
+	  Also in the case where the original packet arrives after a NACK is sent,
+	  the received RTX packet should update the stats since it provides useful
+	  information about RTT.
+	  The RTT is only updated if and only if all requested retranmissions are
+	  received. That way the RTT is guaranteed to make sense. If not we don't
+	  know which request the packet is a response to and the RTT may be bogus.
+	  A consequence of this patch is that RTT is not updated for a request
+	  when one of the RTX packets for that seqnum is lost, but that since
+	  measured RTT will be more accurate.
+	  The implementation store the RTX information from the timed out timers
+	  and use this when the retransmitted packet arrives. For performance
+	  these timers are stored separately from the "normal" timers in order to
+	  not impact performance (see attached performance test).
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-08-11 11:02:44 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: Add and expose more stats and increase testing of it
+	  Add num-pushed and num-lost.
+	  Expose num-late, num-duplicates and avg-jitter.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-07-07 10:20:02 +0200  Stian Selnes <stian@pexip.com>
+
+	* gst/rtpmanager/gstrtprtxreceive.c:
+	  rtxreceive: Set buffer flag for retransmitted packets
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-07-09 23:47:41 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	  rtpjitterbuffer: Option to disable rtx-delay-reorder
+	  When disabled we can save some iterations over timers.
+	  There is probably an argument for rtx-delay-reorder to exist, but
+	  for normal operations, handling jitter (reordering) is something a
+	  jitterbuffer should do, and this variable feels like functionality that
+	  is not "in-sync" with what the jitterbuffer is trying to achieve.
+	  Example: You have 50ms jitter on your network, and are receiving
+	  audio packets with 10ms durations. An audio packet should not be
+	  considered late until its rtx-timeout has expired (and hence a rtx-event
+	  is sent), but with rtx-delay-reorder, events will be sent pretty much
+	  all the time due to the jitter on the network.
+	  Point being: The jitterbuffer should adapt its size to the measured network
+	  jitter, and then rtx-delay-reorder needs to adapt as well, or simply
+	  get out of the way and let the other (better) rtx-mechanisms do their job.
+	  Also change find_timer to only use seqnum as an argument, since there
+	  will only ever be one timer per seqnum at any given time. In the
+	  one case where the type matters, the caller simply checks the type.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769768
+
+2016-09-14 09:58:41 -0400  Olivier Crête <olivier.crete@collabora.com>
+
+	* gst/rtp/gstrtph263pay.c:
+	  rtph263pay: Fix double free from coverity
+	  CID #1372887
+
+2016-09-14 09:58:37 -0400  Olivier Crête <olivier.crete@collabora.com>
+
+	* gst/rtp/gstrtph263pay.c:
+	  rtph263pay: Indent as per gst-indent
+
+2016-09-14 11:30:41 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* configure.ac:
+	  configure: Depend on gstreamer 1.9.2.1
+
+2016-09-14 10:17:02 +0900  Wonchul Lee <wonchul.lee@collabora.com>
+
+	* gst/autodetect/gstautodetect.c:
+	  autodetect: Use gst_bin_set_suppressed_flags() API
+	  https://bugzilla.gnome.org/show_bug.cgi?id=771395
+
+2016-09-09 15:36:12 +0200  Thomas Scheuermann <Thomas.Scheuermann@barco.com>
+
+	* ext/jack/gstjackaudioclient.c:
+	  jack: Fix pipeline hang when jack changes sample rate or buffer size
+	  If jackd changes the buffer size or sample rate, jackaudiosink hangs
+	  and can't be stopped. This also happens if jack is configured as slave
+	  and a gstreamer pipeline is started on the slave machine while the jack
+	  master isn't running yet. If the the jack master is started it changes
+	  the buffer size / sample rate and jackaudiosink can't be stopped.
+	  This fix calls jack_shutdown_cb when jack_sample_rate_cb or
+	  jack_buffer_size_cb is called.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=771272
+
+2016-09-12 20:08:36 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/deinterlace/gstdeinterlace.c:
+	  deinterlace: Fix field ordering for reverse playback
+	  And actually calculate the field duration instead of a frame duration so
+	  that we can properly timestamp output frames in fields=all mode.
+	  This is probably still broken for reverse playback in telecine mode.
+
+2016-09-12 09:02:00 +0000  Thomas Klausner <tk@giga.or.at>
+
+	* gst/udp/gstudpsrc.c:
+	  udpsrc: Fix compilation on NetBSD
+	  https://bugzilla.gnome.org/show_bug.cgi?id=771278
+
+2016-09-10 20:51:10 +1000  Jan Schmidt <jan@centricular.com>
+
+	* autogen.sh:
+	* common:
+	  Automatic update of common submodule
+	  From b18d820 to f980fd9
+
+2016-09-09 14:02:25 +0200  Xabier Rodriguez Calvar <calvaris@igalia.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: offset is irrelevant when no crypto info
+	  Cause later it will try to use the crypto info array to get an index and
+	  attach on of the positions as buffer's crypto info.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=770951
+
+2016-09-10 09:53:57 +1000  Jan Schmidt <jan@centricular.com>
+
+	* autogen.sh:
+	* common:
+	  Automatic update of common submodule
+	  From f49c55e to b18d820
+
+2016-09-07 15:33:30 -0400  Nicolas Dufresne <nicolas.dufresne@collabora.com>
+
+	* sys/osxaudio/Makefile.am:
+	  osxaudio: Distribute device provider files
+	  Those where missing the the dev release tarballs for 1.9.2 which
+	  prevented building from tarball on OSX platform
+
+2016-09-06 09:49:39 +0200  Xabier Rodriguez Calvar <calvaris@igalia.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Fix crash with no cenc aux offset
+	  https://bugzilla.gnome.org/show_bug.cgi?id=770951
+
+2016-09-05 09:39:33 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: parse a bit more of the humongous LOAS data
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-09-05 09:39:08 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: make it clear when a potential LOAS frame is not one
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-09-05 09:38:26 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: add a few comments to anchor parsing to the spec
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-09-05 09:37:02 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	* gst/audioparsers/gstaacparse.h:
+	  aacparse: improve channel/rate handling
+	  Keep track of the last parsed channels/rate fields so they can be
+	  used even if the element was not yet configured.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-09-05 09:35:53 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: fix varlength number reading as per spec
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-09-05 09:35:02 +0100  Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: strip uneeded static arrays slack
+	  https://bugzilla.gnome.org/show_bug.cgi?id=769278
+
+2016-07-18 19:18:58 -0400  Olivier Crête <olivier.crete@collabora.com>
+
+	* gst/rtp/gstrtpmp4adepay.c:
+	* gst/rtp/gstrtpmp4adepay.h:
+	  rtpmp4adepay: Only declare a stream to be framed once a marker bit has been seen
+	  This may cause a few packets to be processed by the parser, but it's
+	  better than never pushing out buffers from a slightly broken stream
+	  where no marker bits are set.
+
+2016-09-06 14:25:42 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/dv/gstdvdemux.c:
+	  dvdemux: Fix timestamping in reverse playback mode
+	  This is only supported right now if after a demuxer that supports reverse
+	  playback, e.g. with DV container inside AVI container.
+
+2016-09-05 12:23:54 -0300  Thibault Saunier <thibault.saunier@osg.samsung.com>
+
+	* meson.build:
+	  meson: Bump version to 1.9.2
+
+2015-06-26 20:13:17 +0200  Mathieu Duponchelle <mathieu.duponchelle@opencreed.com>
+
+	* gst/isomp4/GstQTMux.prs:
+	* gst/isomp4/Makefile.am:
+	* gst/isomp4/gstqtmux.c:
+	  qtmux: Implement the preset interface.
+	  + And provide a "youtube" preset, which based on
+	  https://support.google.com/youtube/answer/1722171 sets
+	  faststart to True.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=751559
+
+2016-09-01 12:27:35 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* configure.ac:
+	  Back to development
+
+=== release 1.9.2 ===
+
+2016-09-01 12:27:15 +0300  Sebastian Dröge <sebastian@centricular.com>
+
+	* ChangeLog:
+	* NEWS:
+	* RELEASE:
+	* configure.ac:
+	* docs/plugins/gst-plugins-good-plugins.args:
+	* docs/plugins/gst-plugins-good-plugins.hierarchy:
+	* docs/plugins/gst-plugins-good-plugins.interfaces:
+	* docs/plugins/inspect/plugin-1394.xml:
+	* docs/plugins/inspect/plugin-aasink.xml:
+	* docs/plugins/inspect/plugin-alaw.xml:
+	* docs/plugins/inspect/plugin-alpha.xml:
+	* docs/plugins/inspect/plugin-alphacolor.xml:
+	* docs/plugins/inspect/plugin-apetag.xml:
+	* docs/plugins/inspect/plugin-audiofx.xml:
+	* docs/plugins/inspect/plugin-audioparsers.xml:
+	* docs/plugins/inspect/plugin-auparse.xml:
+	* docs/plugins/inspect/plugin-autodetect.xml:
+	* docs/plugins/inspect/plugin-avi.xml:
+	* docs/plugins/inspect/plugin-cacasink.xml:
+	* docs/plugins/inspect/plugin-cairo.xml:
+	* docs/plugins/inspect/plugin-cutter.xml:
+	* docs/plugins/inspect/plugin-debug.xml:
+	* docs/plugins/inspect/plugin-deinterlace.xml:
+	* docs/plugins/inspect/plugin-dtmf.xml:
+	* docs/plugins/inspect/plugin-dv.xml:
+	* docs/plugins/inspect/plugin-effectv.xml:
+	* docs/plugins/inspect/plugin-equalizer.xml:
+	* docs/plugins/inspect/plugin-flac.xml:
+	* docs/plugins/inspect/plugin-flv.xml:
+	* docs/plugins/inspect/plugin-flxdec.xml:
+	* docs/plugins/inspect/plugin-gdkpixbuf.xml:
+	* docs/plugins/inspect/plugin-goom.xml:
+	* docs/plugins/inspect/plugin-goom2k1.xml:
+	* docs/plugins/inspect/plugin-icydemux.xml:
+	* docs/plugins/inspect/plugin-id3demux.xml:
+	* docs/plugins/inspect/plugin-imagefreeze.xml:
+	* docs/plugins/inspect/plugin-interleave.xml:
+	* docs/plugins/inspect/plugin-isomp4.xml:
+	* docs/plugins/inspect/plugin-jack.xml:
+	* docs/plugins/inspect/plugin-jpeg.xml:
+	* docs/plugins/inspect/plugin-level.xml:
+	* docs/plugins/inspect/plugin-matroska.xml:
+	* docs/plugins/inspect/plugin-mulaw.xml:
+	* docs/plugins/inspect/plugin-multifile.xml:
+	* docs/plugins/inspect/plugin-multipart.xml:
+	* docs/plugins/inspect/plugin-navigationtest.xml:
+	* docs/plugins/inspect/plugin-oss4.xml:
+	* docs/plugins/inspect/plugin-ossaudio.xml:
+	* docs/plugins/inspect/plugin-png.xml:
+	* docs/plugins/inspect/plugin-pulseaudio.xml:
+	* docs/plugins/inspect/plugin-replaygain.xml:
+	* docs/plugins/inspect/plugin-rtp.xml:
+	* docs/plugins/inspect/plugin-rtpmanager.xml:
+	* docs/plugins/inspect/plugin-rtsp.xml:
+	* docs/plugins/inspect/plugin-shapewipe.xml:
+	* docs/plugins/inspect/plugin-shout2send.xml:
+	* docs/plugins/inspect/plugin-smpte.xml:
+	* docs/plugins/inspect/plugin-soup.xml:
+	* docs/plugins/inspect/plugin-spectrum.xml:
+	* docs/plugins/inspect/plugin-speex.xml:
+	* docs/plugins/inspect/plugin-taglib.xml:
+	* docs/plugins/inspect/plugin-udp.xml:
+	* docs/plugins/inspect/plugin-video4linux2.xml:
+	* docs/plugins/inspect/plugin-videobox.xml:
+	* docs/plugins/inspect/plugin-videocrop.xml:
+	* docs/plugins/inspect/plugin-videofilter.xml:
+	* docs/plugins/inspect/plugin-videomixer.xml:
+	* docs/plugins/inspect/plugin-vpx.xml:
+	* docs/plugins/inspect/plugin-wavenc.xml:
+	* docs/plugins/inspect/plugin-wavpack.xml:
+	* docs/plugins/inspect/plugin-wavparse.xml:
+	* docs/plugins/inspect/plugin-ximagesrc.xml:
+	* docs/plugins/inspect/plugin-y4menc.xml:
+	* gst-plugins-good.doap:
+	* win32/common/config.h:
+	  Release 1.9.2
 
 2016-09-01 11:23:33 +0300  Sebastian Dröge <sebastian@centricular.com>
 
diff --git a/Makefile.in b/Makefile.in
index 1220c47..a3ce7c4 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -1180,8 +1180,11 @@
 
 update-exports:
 	make check-exports 2>&1 | patch -p1
-	git add win32/common/libgst*.def
-	git diff --cached -- win32/common/
+	if test -f "$(top_srcdir)/win32/common/libgstgl.def"; then \
+	  git checkout "$(top_srcdir)/win32/common/libgstgl.def";  \
+	fi
+	git add $(top_srcdir)/win32/common/libgst*.def
+	git diff --cached -- $(top_srcdir)/win32/common/
 	echo '^^^--- updated and staged changes above'
 
 # complain about nonportable printf format strings (%lld, %llu, %zu etc.)
diff --git a/NEWS b/NEWS
index 027c018..072b2df 100644
--- a/NEWS
+++ b/NEWS
@@ -1 +1 @@
-This is GStreamer 1.9.2
+This is GStreamer 1.9.90
diff --git a/RELEASE b/RELEASE
index 280533c..e8db314 100644
--- a/RELEASE
+++ b/RELEASE
@@ -1,13 +1,10 @@
 
-Release notes for GStreamer Good Plugins 1.9.2
+Release notes for GStreamer Good Plugins 1.9.90
 
-The GStreamer team is pleased to announce the second release of the unstable
-1.9 release series, which marks the feature freeze for 1.10. The 1.9 release
-series is adding new features on top of the 1.0, 1.2, 1.4, 1.6 and 1.8 series
-and is part of the API and ABI-stable 1.x release series of the GStreamer
-multimedia framework. The unstable 1.9 release series will lead to the stable
-1.10 release series in the next weeks. Any newly added API can still change
-until that point.
+The GStreamer team is pleased to announce the first release candidate of the
+stable 1.10 release series. The 1.10 release series is adding new features on
+top of the 1.0, 1.2, 1.4, 1.6 and 1.8 series and is part of the API and
+ABI-stable 1.x release series of the GStreamer multimedia framework.
 
 
 Binaries for Android, iOS, Mac OS X and Windows will be provided in the next days.
@@ -56,21 +53,17 @@
 
 Bugs fixed in this release
      
-      * 753760 : rtph265: sync against latest spec
-      * 763038 : souphttpsrc: add http error code to element error messages
-      * 767900 : multipartmux is not clearing dts timestamp.
-      * 767950 : qtmux: Add support for writing timecode track
-      * 768440 : flvdemux: Create per-stream tag lists
-      * 768653 : rtph265pay: does not accept array_completeness=1 in codec_data
-      * 768739 : tests: fix bus leaks in -good tests
-      * 768787 : AG_GST_PKG_CONFIG_PATH is not called before using GST_PKG_CONFIG_PATH
-      * 769117 : Regression building master
-      * 769390 : wavparse: Add bitrate and container format tags
-      * 769664 : splitmuxsink: Add option to split at exactly max-size-time
-      * 770285 : rtpbin: fix typo in max-misorder-time property name
-      * 770292 : rtpbin: introduce max-streams property
-      * 770394 : rtph265pay does not set RTP marker bit
-      * 770526 : osxvideo: fatal error: 'QuickTime/QuickTime.h' file not found (macOS Sierra)
+      * 751559 : qtmux: Implement the preset interface.
+      * 766990 : multifilesink: 'buffer'-mode writes no longer atomic (regression)
+      * 769278 : aacparse: a few fixes and improvements for LOAS parsing
+      * 769757 : rtpjitterbuffer: Fix calculating next_seqnum when dropping old buffers from a full queue.
+      * 769768 : rtpjitterbuffer: lots of improvements around RTX
+      * 770951 : qtdemux: Crash with no cenc auxiliary offset available
+      * 771272 : jackaudiosink: hangs when jackd changes sample rate and/or buffer size
+      * 771278 : udpsrc: Compilation error on NetBSD
+      * 771395 : autodetect: Use gst_bin_set_suppressed_flags() API
+      * 772143 : qtmux: Don't calculate PTS offset and DTS with GST_CLOCK_TIME_NONE
+      * 772228 : tagschecking: Unit test fails because it sends untimestamped buffers to qtdemux
 
 ==== Download ====
 
@@ -107,32 +100,21 @@
         
 Contributors to this release
     
-      * Carlos Rafael Giani
-      * Edward Hervey
-      * Guillaume Desmottes
+      * Arun Raghavan
+      * Georg Lippitsch
       * Havard Graff
-      * Jan Alexander Steffens (heftig)
       * Jan Schmidt
-      * Jie Jiang
-      * Jonas Holmberg
-      * Josep Torra
-      * Luis de Bethencourt
-      * Mats Lindestam
-      * Mikhail Fludkov
+      * Mathieu Duponchelle
       * Nicolas Dufresne
-      * Nirbheek Chauhan
       * Olivier Crête
-      * Reynaldo H. Verdejo Pinochet
       * Sebastian Dröge
-      * Stefan Sauer
       * Stian Selnes
-      * Thiago Santos
       * Thibault Saunier
       * Thomas Bluemel
+      * Thomas Klausner
       * Thomas Scheuermann
       * Tim-Philipp Müller
-      * Ting-Wei Lan
       * Vincent Penquerc'h
-      * Vivia Nikolaidou
+      * Wonchul Lee
       * Xabier Rodriguez Calvar
  
\ No newline at end of file
diff --git a/common/win32.mak b/common/win32.mak
index 87cd346..6060532 100644
--- a/common/win32.mak
+++ b/common/win32.mak
@@ -61,8 +61,11 @@
 
 update-exports:
 	make check-exports 2>&1 | patch -p1
-	git add win32/common/libgst*.def
-	git diff --cached -- win32/common/
+	if test -f "$(top_srcdir)/win32/common/libgstgl.def"; then \
+	  git checkout "$(top_srcdir)/win32/common/libgstgl.def";  \
+	fi
+	git add $(top_srcdir)/win32/common/libgst*.def
+	git diff --cached -- $(top_srcdir)/win32/common/
 	echo '^^^--- updated and staged changes above'
 
 # complain about nonportable printf format strings (%lld, %llu, %zu etc.)
diff --git a/configure b/configure
index 23a3393..3b0341c 100755
--- a/configure
+++ b/configure
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for GStreamer Good Plug-ins 1.9.2.
+# Generated by GNU Autoconf 2.69 for GStreamer Good Plug-ins 1.9.90.
 #
 # Report bugs to <http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer>.
 #
@@ -591,8 +591,8 @@
 # Identity of this package.
 PACKAGE_NAME='GStreamer Good Plug-ins'
 PACKAGE_TARNAME='gst-plugins-good'
-PACKAGE_VERSION='1.9.2'
-PACKAGE_STRING='GStreamer Good Plug-ins 1.9.2'
+PACKAGE_VERSION='1.9.90'
+PACKAGE_STRING='GStreamer Good Plug-ins 1.9.90'
 PACKAGE_BUGREPORT='http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer'
 PACKAGE_URL=''
 
@@ -1969,7 +1969,7 @@
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures GStreamer Good Plug-ins 1.9.2 to adapt to many kinds of systems.
+\`configure' configures GStreamer Good Plug-ins 1.9.90 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -2042,7 +2042,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of GStreamer Good Plug-ins 1.9.2:";;
+     short | recursive ) echo "Configuration of GStreamer Good Plug-ins 1.9.90:";;
    esac
   cat <<\_ACEOF
 
@@ -2418,7 +2418,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-GStreamer Good Plug-ins configure 1.9.2
+GStreamer Good Plug-ins configure 1.9.90
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -3229,7 +3229,7 @@
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by GStreamer Good Plug-ins $as_me 1.9.2, which was
+It was created by GStreamer Good Plug-ins $as_me 1.9.90, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -4211,7 +4211,7 @@
 
 # Define the identity of the package.
  PACKAGE='gst-plugins-good'
- VERSION='1.9.2'
+ VERSION='1.9.90'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -4422,9 +4422,9 @@
 
 
 
-  PACKAGE_VERSION_MAJOR=$(echo 1.9.2 | cut -d'.' -f1)
-  PACKAGE_VERSION_MINOR=$(echo 1.9.2 | cut -d'.' -f2)
-  PACKAGE_VERSION_MICRO=$(echo 1.9.2 | cut -d'.' -f3)
+  PACKAGE_VERSION_MAJOR=$(echo 1.9.90 | cut -d'.' -f1)
+  PACKAGE_VERSION_MINOR=$(echo 1.9.90 | cut -d'.' -f2)
+  PACKAGE_VERSION_MICRO=$(echo 1.9.90 | cut -d'.' -f3)
 
 
 
@@ -4435,7 +4435,7 @@
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking nano version" >&5
 $as_echo_n "checking nano version... " >&6; }
 
-  NANO=$(echo 1.9.2 | cut -d'.' -f4)
+  NANO=$(echo 1.9.90 | cut -d'.' -f4)
 
   if test x"$NANO" = x || test "x$NANO" = "x0" ; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: 0 (release)" >&5
@@ -9276,10 +9276,10 @@
 done
 
 
-  GST_CURRENT=902
+  GST_CURRENT=990
   GST_REVISION=0
-  GST_AGE=902
-  GST_LIBVERSION=902:0:902
+  GST_AGE=990
+  GST_LIBVERSION=990:0:990
 
 
 
@@ -13907,8 +13907,8 @@
 
 
 
-GST_REQ=1.9.2
-GSTPB_REQ=1.9.2
+GST_REQ=1.9.90
+GSTPB_REQ=1.9.90
 
 
 
@@ -37545,7 +37545,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by GStreamer Good Plug-ins $as_me 1.9.2, which was
+This file was extended by GStreamer Good Plug-ins $as_me 1.9.90, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -37611,7 +37611,7 @@
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-GStreamer Good Plug-ins config.status 1.9.2
+GStreamer Good Plug-ins config.status 1.9.90
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git a/configure.ac b/configure.ac
index 9c9d043..3f0e7cd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -5,7 +5,7 @@
 dnl initialize autoconf
 dnl releases only do -Wall, git and prerelease does -Werror too
 dnl use a three digit version number for releases, and four for git/pre
-AC_INIT([GStreamer Good Plug-ins],[1.9.2],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-good])
+AC_INIT([GStreamer Good Plug-ins],[1.9.90],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-good])
 
 AG_GST_INIT
 
@@ -43,11 +43,11 @@
   [GStreamer API Version])
 
 AG_GST_LIBTOOL_PREPARE
-AS_LIBTOOL(GST, 902, 0, 902)
+AS_LIBTOOL(GST, 990, 0, 990)
 
 dnl *** required versions of GStreamer stuff ***
-GST_REQ=1.9.2
-GSTPB_REQ=1.9.2
+GST_REQ=1.9.90
+GSTPB_REQ=1.9.90
 
 dnl *** autotools stuff ****
 
diff --git a/docs/plugins/gst-plugins-good-plugins.args b/docs/plugins/gst-plugins-good-plugins.args
index 28c1859..cad472a 100644
--- a/docs/plugins/gst-plugins-good-plugins.args
+++ b/docs/plugins/gst-plugins-good-plugins.args
@@ -1015,7 +1015,7 @@
 <FLAGS>rw</FLAGS>
 <NICK>User Agent</NICK>
 <BLURB>The User-Agent string to send to the server.</BLURB>
-<DEFAULT>"GStreamer/1.9.2"</DEFAULT>
+<DEFAULT>"GStreamer/1.9.90"</DEFAULT>
 </ARG>
 
 <ARG>
@@ -20654,7 +20654,7 @@
 <RANGE>>= G_MAXULONG</RANGE>
 <FLAGS>rw</FLAGS>
 <NICK>RTX Delay Reorder</NICK>
-<BLURB>Sending retransmission event when this much reordering (-1 automatic).</BLURB>
+<BLURB>Sending retransmission event when this much reordering (0 disable, -1 automatic).</BLURB>
 <DEFAULT>3</DEFAULT>
 </ARG>
 
@@ -20769,6 +20769,26 @@
 </ARG>
 
 <ARG>
+<NAME>GstRtpJitterBuffer::rtx-deadline</NAME>
+<TYPE>gint</TYPE>
+<RANGE>>= G_MAXULONG</RANGE>
+<FLAGS>rw</FLAGS>
+<NICK>RTX Deadline (ms)</NICK>
+<BLURB>The deadline for a valid RTX request in milliseconds. (-1 automatic).</BLURB>
+<DEFAULT>-1</DEFAULT>
+</ARG>
+
+<ARG>
+<NAME>GstRtpJitterBuffer::rtx-stats-timeout</NAME>
+<TYPE>guint</TYPE>
+<RANGE></RANGE>
+<FLAGS>rw</FLAGS>
+<NICK>RTX Statistics Timeout</NICK>
+<BLURB>The time to wait for a retransmitted packet after it has been considered lost in order to collect statistics (ms).</BLURB>
+<DEFAULT>1000</DEFAULT>
+</ARG>
+
+<ARG>
 <NAME>GstRtpSession::bandwidth</NAME>
 <TYPE>gdouble</TYPE>
 <RANGE>>= 0</RANGE>
diff --git a/docs/plugins/gst-plugins-good-plugins.interfaces b/docs/plugins/gst-plugins-good-plugins.interfaces
index 8b96cce..14fe6cd 100644
--- a/docs/plugins/gst-plugins-good-plugins.interfaces
+++ b/docs/plugins/gst-plugins-good-plugins.interfaces
@@ -6,6 +6,7 @@
 GdkPixbuf GIcon
 GdkPixbuf GIcon GLoadableIcon
 Gst3GPPMux GstTagSetter GstTagXmpWriter
+Gst3GPPMux GstTagSetter GstTagXmpWriter GstPreset
 GstALawEnc GstPreset
 GstApev2Mux GstTagSetter
 GstAspectRatioCrop GstChildProxy
@@ -35,6 +36,7 @@
 GstHalAudioSink GstChildProxy
 GstHalAudioSrc GstChildProxy
 GstISMLMux GstTagSetter GstTagXmpWriter
+GstISMLMux GstTagSetter GstTagXmpWriter GstPreset
 GstId3v2Mux GstTagSetter
 GstIirEqualizer GstChildProxy
 GstIirEqualizer GstChildProxy GstPreset
@@ -44,7 +46,9 @@
 GstIirEqualizerNBands GstChildProxy GstPreset
 GstJpegEnc GstPreset
 GstMJ2Mux GstTagSetter GstTagXmpWriter
+GstMJ2Mux GstTagSetter GstTagXmpWriter GstPreset
 GstMP4Mux GstTagSetter GstTagXmpWriter
+GstMP4Mux GstTagSetter GstTagXmpWriter GstPreset
 GstMatroskaMux GstTagSetter
 GstMatroskaMux GstTagSetter GstTocSetter
 GstMuLawEnc GstPreset
@@ -68,6 +72,7 @@
 GstPushFileSrc GstChildProxy GstURIHandler
 GstQTMoovRecover GstChildProxy
 GstQTMux GstTagSetter GstTagXmpWriter
+GstQTMux GstTagSetter GstTagXmpWriter GstPreset
 GstRTSPSrc GstChildProxy GstURIHandler
 GstRgVolume GstChildProxy
 GstRtpBin GstChildProxy
diff --git a/docs/plugins/html/gst-plugins-good-plugins-1.0.devhelp2 b/docs/plugins/html/gst-plugins-good-plugins-1.0.devhelp2
index cf8db40..f61e92a 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-1.0.devhelp2
+++ b/docs/plugins/html/gst-plugins-good-plugins-1.0.devhelp2
@@ -982,6 +982,8 @@
     <keyword type="property" name="The “max-misorder-time” property" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--max-misorder-time"/>
     <keyword type="property" name="The “max-rtcp-rtp-time-diff” property" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--max-rtcp-rtp-time-diff"/>
     <keyword type="property" name="The “rfc7273-sync” property" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rfc7273-sync"/>
+    <keyword type="property" name="The “rtx-deadline” property" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rtx-deadline"/>
+    <keyword type="property" name="The “rtx-stats-timeout” property" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rtx-stats-timeout"/>
     <keyword type="signal" name="The “clear-pt-map” signal" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer-clear-pt-map"/>
     <keyword type="signal" name="The “handle-sync” signal" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer-handle-sync"/>
     <keyword type="signal" name="The “on-npt-stop” signal" link="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer-on-npt-stop"/>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-3gppmux.html b/docs/plugins/html/gst-plugins-good-plugins-3gppmux.html
index db47194..bb12f7d 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-3gppmux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-3gppmux.html
@@ -139,7 +139,7 @@
 <a name="gst-plugins-good-plugins-3gppmux.implemented-interfaces"></a><h2>Implemented Interfaces</h2>
 <p>
 Gst3GPPMux implements
- <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a> and  GstTagXmpWriter.</p>
+ <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>,  GstTagXmpWriter and  <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstPreset.html#GstPreset-struct">GstPreset</a>.</p>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-3gppmux.description"></a><h2>Description</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-ismlmux.html b/docs/plugins/html/gst-plugins-good-plugins-ismlmux.html
index 696c55e..21d358f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-ismlmux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-ismlmux.html
@@ -139,7 +139,7 @@
 <a name="gst-plugins-good-plugins-ismlmux.implemented-interfaces"></a><h2>Implemented Interfaces</h2>
 <p>
 GstISMLMux implements
- <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a> and  GstTagXmpWriter.</p>
+ <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>,  GstTagXmpWriter and  <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstPreset.html#GstPreset-struct">GstPreset</a>.</p>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-ismlmux.description"></a><h2>Description</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-mj2mux.html b/docs/plugins/html/gst-plugins-good-plugins-mj2mux.html
index ca1057a..8f2385f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-mj2mux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-mj2mux.html
@@ -139,7 +139,7 @@
 <a name="gst-plugins-good-plugins-mj2mux.implemented-interfaces"></a><h2>Implemented Interfaces</h2>
 <p>
 GstMJ2Mux implements
- <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a> and  GstTagXmpWriter.</p>
+ <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>,  GstTagXmpWriter and  <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstPreset.html#GstPreset-struct">GstPreset</a>.</p>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-mj2mux.description"></a><h2>Description</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-mp4mux.html b/docs/plugins/html/gst-plugins-good-plugins-mp4mux.html
index 3a086aa..5711eab 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-mp4mux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-mp4mux.html
@@ -139,7 +139,7 @@
 <a name="gst-plugins-good-plugins-mp4mux.implemented-interfaces"></a><h2>Implemented Interfaces</h2>
 <p>
 GstMP4Mux implements
- <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a> and  GstTagXmpWriter.</p>
+ <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>,  GstTagXmpWriter and  <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstPreset.html#GstPreset-struct">GstPreset</a>.</p>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-mp4mux.description"></a><h2>Description</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-1394.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-1394.html
index 5a83d4b..3558548 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-1394.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-1394.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-aasink.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-aasink.html
index 3b1e3c3..b191129 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-aasink.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-aasink.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-alaw.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-alaw.html
index 073c67b..1b43b4e 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-alaw.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-alaw.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-alpha.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-alpha.html
index ff6b1cd..48397a0 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-alpha.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-alpha.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-alphacolor.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-alphacolor.html
index 3322980..c544961 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-alphacolor.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-alphacolor.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-apetag.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-apetag.html
index 6c47372..d98e0ca 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-apetag.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-apetag.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-audiofx.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-audiofx.html
index 20caa38..58182f4 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-audiofx.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-audiofx.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-audioparsers.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-audioparsers.html
index 3ecc342..ab0eafb 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-audioparsers.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-audioparsers.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-auparse.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-auparse.html
index 1082d2d..2c9ece3 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-auparse.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-auparse.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-autodetect.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-autodetect.html
index 1ba16f1..6a6a42c 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-autodetect.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-autodetect.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-avi.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-avi.html
index 5b64930..dab8a32 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-avi.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-avi.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-cacasink.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-cacasink.html
index c3af9e4..ff15d2a 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-cacasink.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-cacasink.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-cairo.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-cairo.html
index da063b9..1f67fea 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-cairo.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-cairo.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-cutter.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-cutter.html
index c83682f..6996ce4 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-cutter.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-cutter.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-debug.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-debug.html
index ac8962d..8cabf2d 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-debug.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-debug.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-deinterlace.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-deinterlace.html
index 109e7cc..d84cb19 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-deinterlace.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-deinterlace.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-dtmf.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-dtmf.html
index 55f7555..59a810e 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-dtmf.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-dtmf.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-dv.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-dv.html
index 2943dcb..85ef7f7 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-dv.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-dv.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-effectv.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-effectv.html
index ecc25cc..7f463ac 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-effectv.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-effectv.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-equalizer.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-equalizer.html
index 476b4ac..3572a65 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-equalizer.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-equalizer.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-flac.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-flac.html
index dc0ed5e..8d151bb 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-flac.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-flac.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-flv.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-flv.html
index 3c275ca..bb31ef9 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-flv.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-flv.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-flxdec.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-flxdec.html
index a9dc9f9..74fbc54 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-flxdec.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-flxdec.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-gdkpixbuf.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-gdkpixbuf.html
index 9df8607..984f82d 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-gdkpixbuf.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-gdkpixbuf.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-goom.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-goom.html
index 28e4ecc..5f6f4a5 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-goom.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-goom.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-goom2k1.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-goom2k1.html
index e0d5d8a..b9847f3 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-goom2k1.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-goom2k1.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-icydemux.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-icydemux.html
index 443f39a..4545d25 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-icydemux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-icydemux.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-id3demux.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-id3demux.html
index e1eb976..a84b51f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-id3demux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-id3demux.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-imagefreeze.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-imagefreeze.html
index e66daaa..d377d30 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-imagefreeze.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-imagefreeze.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-interleave.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-interleave.html
index 16d1ffe..9eba158 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-interleave.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-interleave.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-isomp4.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-isomp4.html
index dcc9120..5d2d065 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-isomp4.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-isomp4.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-jack.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-jack.html
index 79f4f82..6a75b69 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-jack.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-jack.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-jpeg.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-jpeg.html
index 3020851..90334b9 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-jpeg.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-jpeg.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-level.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-level.html
index ecd2797..10c54cd 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-level.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-level.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-matroska.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-matroska.html
index 2f5ee33..3eb3bab 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-matroska.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-matroska.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-mulaw.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-mulaw.html
index 73a58dd..0d88404 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-mulaw.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-mulaw.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-multifile.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-multifile.html
index 5f1d9b3..b5697cc 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-multifile.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-multifile.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-multipart.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-multipart.html
index b294df2..aff4d69 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-multipart.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-multipart.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-navigationtest.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-navigationtest.html
index a5b2cdf..167c51c 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-navigationtest.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-navigationtest.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-oss4.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-oss4.html
index 36e5979..c501025 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-oss4.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-oss4.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-ossaudio.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-ossaudio.html
index f617844..6e91ece 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-ossaudio.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-ossaudio.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-png.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-png.html
index 8b784c5..8274a3e 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-png.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-png.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-pulseaudio.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-pulseaudio.html
index 2cabb01..0075c4f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-pulseaudio.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-pulseaudio.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-replaygain.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-replaygain.html
index d716313..e6a49c2 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-replaygain.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-replaygain.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtp.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtp.html
index 04f0720..e091adb 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtp.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtp.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtpmanager.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtpmanager.html
index 1246100..0aec980 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtpmanager.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtpmanager.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtsp.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtsp.html
index b6a8ae9..dc60652 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-rtsp.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-rtsp.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-shapewipe.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-shapewipe.html
index f3fa7ab..19872a1 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-shapewipe.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-shapewipe.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-shout2send.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-shout2send.html
index 0acb0b3..fe27fe4 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-shout2send.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-shout2send.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-smpte.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-smpte.html
index 3cf68af..460266c 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-smpte.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-smpte.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-soup.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-soup.html
index 4054e48..34d572f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-soup.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-soup.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-spectrum.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-spectrum.html
index f97cf3f..d44df4f 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-spectrum.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-spectrum.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-speex.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-speex.html
index 52db47c..5969499 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-speex.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-speex.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-taglib.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-taglib.html
index 927bc96..f32fcef 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-taglib.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-taglib.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-udp.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-udp.html
index d5e9775..5481ed5 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-udp.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-udp.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-video4linux2.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-video4linux2.html
index 6c2625c..f534f92 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-video4linux2.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-video4linux2.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-videobox.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-videobox.html
index 2e22c0e..b86ca50 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-videobox.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-videobox.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-videocrop.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-videocrop.html
index 921794b..c73e404 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-videocrop.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-videocrop.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-videofilter.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-videofilter.html
index 47ae926..b6767bc 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-videofilter.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-videofilter.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-videomixer.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-videomixer.html
index 411b74e..d7e7090 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-videomixer.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-videomixer.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-vpx.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-vpx.html
index 623a4c1..41520c5 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-vpx.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-vpx.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavenc.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavenc.html
index f3c3d3a..c0c178a 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavenc.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavenc.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavpack.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavpack.html
index 85ae4f2..a98319b 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavpack.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavpack.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavparse.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavparse.html
index f10d12c..cd6cf63 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-wavparse.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-wavparse.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-ximagesrc.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-ximagesrc.html
index 327d5b1..38512a0 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-ximagesrc.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-ximagesrc.html
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-plugin-y4menc.html b/docs/plugins/html/gst-plugins-good-plugins-plugin-y4menc.html
index 92718e9..f60486b 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-plugin-y4menc.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-plugin-y4menc.html
@@ -41,7 +41,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.9.2</td>
+<td>1.9.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-qtmux.html b/docs/plugins/html/gst-plugins-good-plugins-qtmux.html
index bc0cc1f..d7a4e41 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-qtmux.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-qtmux.html
@@ -139,7 +139,7 @@
 <a name="gst-plugins-good-plugins-qtmux.implemented-interfaces"></a><h2>Implemented Interfaces</h2>
 <p>
 GstQTMux implements
- <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a> and  GstTagXmpWriter.</p>
+ <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstTagSetter.html#GstTagSetter-struct">GstTagSetter</a>,  GstTagXmpWriter and  <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstPreset.html#GstPreset-struct">GstPreset</a>.</p>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-qtmux.description"></a><h2>Description</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-rtpjitterbuffer.html b/docs/plugins/html/gst-plugins-good-plugins-rtpjitterbuffer.html
index 9bf734d..4715d49 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-rtpjitterbuffer.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-rtpjitterbuffer.html
@@ -144,6 +144,16 @@
 <td class="property_name"><a class="link" href="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rfc7273-sync" title="The “rfc7273-sync” property">rfc7273-sync</a></td>
 <td class="property_flags">Read / Write</td>
 </tr>
+<tr>
+<td class="property_type"><a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#gint"><span class="type">gint</span></a></td>
+<td class="property_name"><a class="link" href="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rtx-deadline" title="The “rtx-deadline” property">rtx-deadline</a></td>
+<td class="property_flags">Read / Write</td>
+</tr>
+<tr>
+<td class="property_type"><a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint"><span class="type">guint</span></a></td>
+<td class="property_name"><a class="link" href="gst-plugins-good-plugins-rtpjitterbuffer.html#GstRtpJitterBuffer--rtx-stats-timeout" title="The “rtx-stats-timeout” property">rtx-stats-timeout</a></td>
+<td class="property_flags">Read / Write</td>
+</tr>
 </tbody>
 </table></div>
 </div>
@@ -472,7 +482,8 @@
 <p>Assume that a retransmission event should be sent when we see
 this much packet reordering.</p>
 <p>When -1 is used, the value will be estimated based on observed packet
-reordering.</p>
+reordering. When 0 is used packet reordering alone will not cause a
+retransmission event (Since 1.10).</p>
 <p>Flags: Read / Write</p>
 <p>Allowed values: &gt;= G_MAXULONG</p>
 <p>Default value: 3</p>
@@ -508,6 +519,26 @@
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem"><p>
   <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint64"><span class="type">guint64</span></a>
+  <code class="classname">"num-pushed"</code>:
+  the number of packets pushed out.
+  </p></li>
+<li class="listitem"><p>
+  <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint64"><span class="type">guint64</span></a>
+  <code class="classname">"num-lost"</code>:
+  the number of packets considered lost.
+  </p></li>
+<li class="listitem"><p>
+  <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint64"><span class="type">guint64</span></a>
+  <code class="classname">"num-late"</code>:
+  the number of packets arriving too late.
+  </p></li>
+<li class="listitem"><p>
+  <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint64"><span class="type">guint64</span></a>
+  <code class="classname">"num-duplicates"</code>:
+  the number of duplicate packets.
+  </p></li>
+<li class="listitem"><p>
+  <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint64"><span class="type">guint64</span></a>
   <code class="classname">"rtx-count"</code>:
   the number of retransmissions requested.
   </p></li>
@@ -610,6 +641,26 @@
 <p>Flags: Read / Write</p>
 <p>Default value: FALSE</p>
 </div>
+<hr>
+<div class="refsect2">
+<a name="GstRtpJitterBuffer--rtx-deadline"></a><h3>The <code class="literal">“rtx-deadline”</code> property</h3>
+<pre class="programlisting">  “rtx-deadline”             <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#gint"><span class="type">gint</span></a></pre>
+<p>The deadline for a valid RTX request in ms.</p>
+<p>How long the RTX RTCP will be valid for.
+When -1 is used, the size of the jitterbuffer will be used.</p>
+<p>Flags: Read / Write</p>
+<p>Allowed values: &gt;= G_MAXULONG</p>
+<p>Default value: -1</p>
+<p class="since">Since: 1.10</p>
+</div>
+<hr>
+<div class="refsect2">
+<a name="GstRtpJitterBuffer--rtx-stats-timeout"></a><h3>The <code class="literal">“rtx-stats-timeout”</code> property</h3>
+<pre class="programlisting">  “rtx-stats-timeout”        <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint"><span class="type">guint</span></a></pre>
+<p>The time to wait for a retransmitted packet after it has been considered lost in order to collect statistics (ms).</p>
+<p>Flags: Read / Write</p>
+<p>Default value: 1000</p>
+</div>
 </div>
 <div class="refsect1">
 <a name="gst-plugins-good-plugins-rtpjitterbuffer.signal-details"></a><h2>Signal Details</h2>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-rtpmp4adepay.html b/docs/plugins/html/gst-plugins-good-plugins-rtpmp4adepay.html
index 2c2f54a..49622bd 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-rtpmp4adepay.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-rtpmp4adepay.html
@@ -131,7 +131,7 @@
 </tr>
 <tr>
 <td><p><span class="term">details</span></p></td>
-<td>audio/mpeg, mpegversion=(int)4, framed=(boolean)true, stream-format=(string)raw</td>
+<td>audio/mpeg, mpegversion=(int)4, framed=(boolean){ false, true }, stream-format=(string)raw</td>
 </tr>
 </tbody>
 </table></div>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html b/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html
index 44decdf..2da55e3 100644
--- a/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html
+++ b/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html
@@ -693,7 +693,7 @@
 <pre class="programlisting">  “user-agent”               <a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#gchar"><span class="type">gchar</span></a> *</pre>
 <p>The User-Agent string to send to the server.</p>
 <p>Flags: Read / Write</p>
-<p>Default value: "GStreamer/1.9.2"</p>
+<p>Default value: "GStreamer/1.9.90"</p>
 </div>
 <hr>
 <div class="refsect2">
diff --git a/docs/plugins/html/index.html b/docs/plugins/html/index.html
index 3e1557d..768fffc 100644
--- a/docs/plugins/html/index.html
+++ b/docs/plugins/html/index.html
@@ -15,7 +15,7 @@
 <div>
 <div><table class="navigation" id="top" width="100%" cellpadding="2" cellspacing="0"><tr><th valign="middle"><p class="title">GStreamer Good Plugins 1.0 Plugins Reference Manual</p></th></tr></table></div>
 <div><p class="releaseinfo">
-      for GStreamer Good Plugins 1.0 (1.9.2)
+      for GStreamer Good Plugins 1.0 (1.9.90)
       The latest version of this documentation can be found on-line at
       <a class="ulink" href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good/html/" target="_top">http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good/html/</a>.
     </p></div>
diff --git a/docs/plugins/inspect/plugin-1394.xml b/docs/plugins/inspect/plugin-1394.xml
index ad9310a..a38faa6 100644
--- a/docs/plugins/inspect/plugin-1394.xml
+++ b/docs/plugins/inspect/plugin-1394.xml
@@ -3,7 +3,7 @@
   <description>Source for video data via IEEE1394 interface</description>
   <filename>../../ext/raw1394/.libs/libgst1394.so</filename>
   <basename>libgst1394.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-aasink.xml b/docs/plugins/inspect/plugin-aasink.xml
index 6f201fb..61d8f92 100644
--- a/docs/plugins/inspect/plugin-aasink.xml
+++ b/docs/plugins/inspect/plugin-aasink.xml
@@ -3,7 +3,7 @@
   <description>ASCII Art video sink</description>
   <filename>../../ext/aalib/.libs/libgstaasink.so</filename>
   <basename>libgstaasink.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-alaw.xml b/docs/plugins/inspect/plugin-alaw.xml
index 601e798..5ec03d2 100644
--- a/docs/plugins/inspect/plugin-alaw.xml
+++ b/docs/plugins/inspect/plugin-alaw.xml
@@ -3,7 +3,7 @@
   <description>ALaw audio conversion routines</description>
   <filename>../../gst/law/.libs/libgstalaw.so</filename>
   <basename>libgstalaw.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-alpha.xml b/docs/plugins/inspect/plugin-alpha.xml
index f48da93..c87b6c1 100644
--- a/docs/plugins/inspect/plugin-alpha.xml
+++ b/docs/plugins/inspect/plugin-alpha.xml
@@ -3,7 +3,7 @@
   <description>adds an alpha channel to video - constant or via chroma-keying</description>
   <filename>../../gst/alpha/.libs/libgstalpha.so</filename>
   <basename>libgstalpha.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-alphacolor.xml b/docs/plugins/inspect/plugin-alphacolor.xml
index 2e3298e..9ef2c4d 100644
--- a/docs/plugins/inspect/plugin-alphacolor.xml
+++ b/docs/plugins/inspect/plugin-alphacolor.xml
@@ -3,7 +3,7 @@
   <description>RGBA from/to AYUV colorspace conversion preserving the alpha channel</description>
   <filename>../../gst/alpha/.libs/libgstalphacolor.so</filename>
   <basename>libgstalphacolor.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-apetag.xml b/docs/plugins/inspect/plugin-apetag.xml
index e3757dc..8d8e548 100644
--- a/docs/plugins/inspect/plugin-apetag.xml
+++ b/docs/plugins/inspect/plugin-apetag.xml
@@ -3,7 +3,7 @@
   <description>APEv1/2 tag reader</description>
   <filename>../../gst/apetag/.libs/libgstapetag.so</filename>
   <basename>libgstapetag.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-audiofx.xml b/docs/plugins/inspect/plugin-audiofx.xml
index 36f2356..8781087 100644
--- a/docs/plugins/inspect/plugin-audiofx.xml
+++ b/docs/plugins/inspect/plugin-audiofx.xml
@@ -3,7 +3,7 @@
   <description>Audio effects plugin</description>
   <filename>../../gst/audiofx/.libs/libgstaudiofx.so</filename>
   <basename>libgstaudiofx.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-audioparsers.xml b/docs/plugins/inspect/plugin-audioparsers.xml
index 313680b..76c14c7 100644
--- a/docs/plugins/inspect/plugin-audioparsers.xml
+++ b/docs/plugins/inspect/plugin-audioparsers.xml
@@ -3,7 +3,7 @@
   <description>Parsers for various audio formats</description>
   <filename>../../gst/audioparsers/.libs/libgstaudioparsers.so</filename>
   <basename>libgstaudioparsers.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-auparse.xml b/docs/plugins/inspect/plugin-auparse.xml
index 553b354..e6cd5fc 100644
--- a/docs/plugins/inspect/plugin-auparse.xml
+++ b/docs/plugins/inspect/plugin-auparse.xml
@@ -3,7 +3,7 @@
   <description>parses au streams</description>
   <filename>../../gst/auparse/.libs/libgstauparse.so</filename>
   <basename>libgstauparse.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-autodetect.xml b/docs/plugins/inspect/plugin-autodetect.xml
index 070d3d4..79b1a68 100644
--- a/docs/plugins/inspect/plugin-autodetect.xml
+++ b/docs/plugins/inspect/plugin-autodetect.xml
@@ -3,7 +3,7 @@
   <description>Plugin contains auto-detection plugins for video/audio in- and outputs</description>
   <filename>../../gst/autodetect/.libs/libgstautodetect.so</filename>
   <basename>libgstautodetect.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-avi.xml b/docs/plugins/inspect/plugin-avi.xml
index c89e071..56b1906 100644
--- a/docs/plugins/inspect/plugin-avi.xml
+++ b/docs/plugins/inspect/plugin-avi.xml
@@ -3,7 +3,7 @@
   <description>AVI stream handling</description>
   <filename>../../gst/avi/.libs/libgstavi.so</filename>
   <basename>libgstavi.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-cacasink.xml b/docs/plugins/inspect/plugin-cacasink.xml
index b60eaca..1a0f4b1 100644
--- a/docs/plugins/inspect/plugin-cacasink.xml
+++ b/docs/plugins/inspect/plugin-cacasink.xml
@@ -3,7 +3,7 @@
   <description>Colored ASCII Art video sink</description>
   <filename>../../ext/libcaca/.libs/libgstcacasink.so</filename>
   <basename>libgstcacasink.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-cairo.xml b/docs/plugins/inspect/plugin-cairo.xml
index 25754f4..82a0457 100644
--- a/docs/plugins/inspect/plugin-cairo.xml
+++ b/docs/plugins/inspect/plugin-cairo.xml
@@ -3,7 +3,7 @@
   <description>Cairo-based elements</description>
   <filename>../../ext/cairo/.libs/libgstcairo.so</filename>
   <basename>libgstcairo.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-cutter.xml b/docs/plugins/inspect/plugin-cutter.xml
index 556cad4..009b669 100644
--- a/docs/plugins/inspect/plugin-cutter.xml
+++ b/docs/plugins/inspect/plugin-cutter.xml
@@ -3,7 +3,7 @@
   <description>Audio Cutter to split audio into non-silent bits</description>
   <filename>../../gst/cutter/.libs/libgstcutter.so</filename>
   <basename>libgstcutter.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-debug.xml b/docs/plugins/inspect/plugin-debug.xml
index 8baf539..a2a7949 100644
--- a/docs/plugins/inspect/plugin-debug.xml
+++ b/docs/plugins/inspect/plugin-debug.xml
@@ -3,7 +3,7 @@
   <description>elements for testing and debugging</description>
   <filename>../../gst/debugutils/.libs/libgstdebug.so</filename>
   <basename>libgstdebug.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-deinterlace.xml b/docs/plugins/inspect/plugin-deinterlace.xml
index 0d98e67..994233c 100644
--- a/docs/plugins/inspect/plugin-deinterlace.xml
+++ b/docs/plugins/inspect/plugin-deinterlace.xml
@@ -3,7 +3,7 @@
   <description>Deinterlacer</description>
   <filename>../../gst/deinterlace/.libs/libgstdeinterlace.so</filename>
   <basename>libgstdeinterlace.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dtmf.xml b/docs/plugins/inspect/plugin-dtmf.xml
index 496f1ae..0c06891 100644
--- a/docs/plugins/inspect/plugin-dtmf.xml
+++ b/docs/plugins/inspect/plugin-dtmf.xml
@@ -3,7 +3,7 @@
   <description>DTMF plugins</description>
   <filename>../../gst/dtmf/.libs/libgstdtmf.so</filename>
   <basename>libgstdtmf.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dv.xml b/docs/plugins/inspect/plugin-dv.xml
index 238bdd0..bea3572 100644
--- a/docs/plugins/inspect/plugin-dv.xml
+++ b/docs/plugins/inspect/plugin-dv.xml
@@ -3,7 +3,7 @@
   <description>DV demuxer and decoder based on libdv (libdv.sf.net)</description>
   <filename>../../ext/dv/.libs/libgstdv.so</filename>
   <basename>libgstdv.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-effectv.xml b/docs/plugins/inspect/plugin-effectv.xml
index 6beb213..bb6b4ac 100644
--- a/docs/plugins/inspect/plugin-effectv.xml
+++ b/docs/plugins/inspect/plugin-effectv.xml
@@ -3,7 +3,7 @@
   <description>effect plugins from the effectv project</description>
   <filename>../../gst/effectv/.libs/libgsteffectv.so</filename>
   <basename>libgsteffectv.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-equalizer.xml b/docs/plugins/inspect/plugin-equalizer.xml
index d240f84..eae17d6 100644
--- a/docs/plugins/inspect/plugin-equalizer.xml
+++ b/docs/plugins/inspect/plugin-equalizer.xml
@@ -3,7 +3,7 @@
   <description>GStreamer audio equalizers</description>
   <filename>../../gst/equalizer/.libs/libgstequalizer.so</filename>
   <basename>libgstequalizer.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-flac.xml b/docs/plugins/inspect/plugin-flac.xml
index 2a20d4a..29c96e7 100644
--- a/docs/plugins/inspect/plugin-flac.xml
+++ b/docs/plugins/inspect/plugin-flac.xml
@@ -3,7 +3,7 @@
   <description>The FLAC Lossless compressor Codec</description>
   <filename>../../ext/flac/.libs/libgstflac.so</filename>
   <basename>libgstflac.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-flv.xml b/docs/plugins/inspect/plugin-flv.xml
index fded088..f7c51b1 100644
--- a/docs/plugins/inspect/plugin-flv.xml
+++ b/docs/plugins/inspect/plugin-flv.xml
@@ -3,7 +3,7 @@
   <description>FLV muxing and demuxing plugin</description>
   <filename>../../gst/flv/.libs/libgstflv.so</filename>
   <basename>libgstflv.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-flxdec.xml b/docs/plugins/inspect/plugin-flxdec.xml
index 54ce679..30dade7 100644
--- a/docs/plugins/inspect/plugin-flxdec.xml
+++ b/docs/plugins/inspect/plugin-flxdec.xml
@@ -3,7 +3,7 @@
   <description>FLC/FLI/FLX video decoder</description>
   <filename>../../gst/flx/.libs/libgstflxdec.so</filename>
   <basename>libgstflxdec.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gdkpixbuf.xml b/docs/plugins/inspect/plugin-gdkpixbuf.xml
index 6913e93..aa42b71 100644
--- a/docs/plugins/inspect/plugin-gdkpixbuf.xml
+++ b/docs/plugins/inspect/plugin-gdkpixbuf.xml
@@ -3,7 +3,7 @@
   <description>GdkPixbuf-based image decoder, overlay and sink</description>
   <filename>../../ext/gdk_pixbuf/.libs/libgstgdkpixbuf.so</filename>
   <basename>libgstgdkpixbuf.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-goom.xml b/docs/plugins/inspect/plugin-goom.xml
index c9a8022..c1e16df 100644
--- a/docs/plugins/inspect/plugin-goom.xml
+++ b/docs/plugins/inspect/plugin-goom.xml
@@ -3,7 +3,7 @@
   <description>GOOM visualization filter</description>
   <filename>../../gst/goom/.libs/libgstgoom.so</filename>
   <basename>libgstgoom.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-goom2k1.xml b/docs/plugins/inspect/plugin-goom2k1.xml
index 1c967ef..fce07e1 100644
--- a/docs/plugins/inspect/plugin-goom2k1.xml
+++ b/docs/plugins/inspect/plugin-goom2k1.xml
@@ -3,7 +3,7 @@
   <description>GOOM 2k1 visualization filter</description>
   <filename>../../gst/goom2k1/.libs/libgstgoom2k1.so</filename>
   <basename>libgstgoom2k1.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-icydemux.xml b/docs/plugins/inspect/plugin-icydemux.xml
index 6d7c380..83a2913 100644
--- a/docs/plugins/inspect/plugin-icydemux.xml
+++ b/docs/plugins/inspect/plugin-icydemux.xml
@@ -3,7 +3,7 @@
   <description>Demux ICY tags from a stream</description>
   <filename>../../gst/icydemux/.libs/libgsticydemux.so</filename>
   <basename>libgsticydemux.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-id3demux.xml b/docs/plugins/inspect/plugin-id3demux.xml
index 15e57b4..eac3219 100644
--- a/docs/plugins/inspect/plugin-id3demux.xml
+++ b/docs/plugins/inspect/plugin-id3demux.xml
@@ -3,7 +3,7 @@
   <description>Demux ID3v1 and ID3v2 tags from a file</description>
   <filename>../../gst/id3demux/.libs/libgstid3demux.so</filename>
   <basename>libgstid3demux.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-imagefreeze.xml b/docs/plugins/inspect/plugin-imagefreeze.xml
index fe70fae..df78953 100644
--- a/docs/plugins/inspect/plugin-imagefreeze.xml
+++ b/docs/plugins/inspect/plugin-imagefreeze.xml
@@ -3,7 +3,7 @@
   <description>Still frame stream generator</description>
   <filename>../../gst/imagefreeze/.libs/libgstimagefreeze.so</filename>
   <basename>libgstimagefreeze.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-interleave.xml b/docs/plugins/inspect/plugin-interleave.xml
index 45b990a..5b22c3c 100644
--- a/docs/plugins/inspect/plugin-interleave.xml
+++ b/docs/plugins/inspect/plugin-interleave.xml
@@ -3,7 +3,7 @@
   <description>Audio interleaver/deinterleaver</description>
   <filename>../../gst/interleave/.libs/libgstinterleave.so</filename>
   <basename>libgstinterleave.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-isomp4.xml b/docs/plugins/inspect/plugin-isomp4.xml
index 9e439e3..98514e0 100644
--- a/docs/plugins/inspect/plugin-isomp4.xml
+++ b/docs/plugins/inspect/plugin-isomp4.xml
@@ -3,7 +3,7 @@
   <description>ISO base media file format support (mp4, 3gpp, qt, mj2)</description>
   <filename>../../gst/isomp4/.libs/libgstisomp4.so</filename>
   <basename>libgstisomp4.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-jack.xml b/docs/plugins/inspect/plugin-jack.xml
index 4367901..0a53c5c 100644
--- a/docs/plugins/inspect/plugin-jack.xml
+++ b/docs/plugins/inspect/plugin-jack.xml
@@ -3,7 +3,7 @@
   <description>JACK audio elements</description>
   <filename>../../ext/jack/.libs/libgstjack.so</filename>
   <basename>libgstjack.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-jpeg.xml b/docs/plugins/inspect/plugin-jpeg.xml
index 1d3c1b5..bd14077 100644
--- a/docs/plugins/inspect/plugin-jpeg.xml
+++ b/docs/plugins/inspect/plugin-jpeg.xml
@@ -3,7 +3,7 @@
   <description>JPeg plugin library</description>
   <filename>../../ext/jpeg/.libs/libgstjpeg.so</filename>
   <basename>libgstjpeg.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-level.xml b/docs/plugins/inspect/plugin-level.xml
index 4ea8902..98b93ef 100644
--- a/docs/plugins/inspect/plugin-level.xml
+++ b/docs/plugins/inspect/plugin-level.xml
@@ -3,7 +3,7 @@
   <description>Audio level plugin</description>
   <filename>../../gst/level/.libs/libgstlevel.so</filename>
   <basename>libgstlevel.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-matroska.xml b/docs/plugins/inspect/plugin-matroska.xml
index f84631b..dacc7c3 100644
--- a/docs/plugins/inspect/plugin-matroska.xml
+++ b/docs/plugins/inspect/plugin-matroska.xml
@@ -3,7 +3,7 @@
   <description>Matroska and WebM stream handling</description>
   <filename>../../gst/matroska/.libs/libgstmatroska.so</filename>
   <basename>libgstmatroska.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mulaw.xml b/docs/plugins/inspect/plugin-mulaw.xml
index 1b494ad..3061052 100644
--- a/docs/plugins/inspect/plugin-mulaw.xml
+++ b/docs/plugins/inspect/plugin-mulaw.xml
@@ -3,7 +3,7 @@
   <description>MuLaw audio conversion routines</description>
   <filename>../../gst/law/.libs/libgstmulaw.so</filename>
   <basename>libgstmulaw.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-multifile.xml b/docs/plugins/inspect/plugin-multifile.xml
index 20935ca..b9300d0 100644
--- a/docs/plugins/inspect/plugin-multifile.xml
+++ b/docs/plugins/inspect/plugin-multifile.xml
@@ -3,7 +3,7 @@
   <description>Reads/Writes buffers from/to sequentially named files</description>
   <filename>../../gst/multifile/.libs/libgstmultifile.so</filename>
   <basename>libgstmultifile.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-multipart.xml b/docs/plugins/inspect/plugin-multipart.xml
index f17c511..c20ecb6 100644
--- a/docs/plugins/inspect/plugin-multipart.xml
+++ b/docs/plugins/inspect/plugin-multipart.xml
@@ -3,7 +3,7 @@
   <description>multipart stream manipulation</description>
   <filename>../../gst/multipart/.libs/libgstmultipart.so</filename>
   <basename>libgstmultipart.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-navigationtest.xml b/docs/plugins/inspect/plugin-navigationtest.xml
index 394a3f7..e913106 100644
--- a/docs/plugins/inspect/plugin-navigationtest.xml
+++ b/docs/plugins/inspect/plugin-navigationtest.xml
@@ -3,7 +3,7 @@
   <description>Template for a video filter</description>
   <filename>../../gst/debugutils/.libs/libgstnavigationtest.so</filename>
   <basename>libgstnavigationtest.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-oss4.xml b/docs/plugins/inspect/plugin-oss4.xml
index 983a341..095ab09 100644
--- a/docs/plugins/inspect/plugin-oss4.xml
+++ b/docs/plugins/inspect/plugin-oss4.xml
@@ -3,7 +3,7 @@
   <description>Open Sound System (OSS) version 4 support for GStreamer</description>
   <filename>../../sys/oss4/.libs/libgstoss4audio.so</filename>
   <basename>libgstoss4audio.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ossaudio.xml b/docs/plugins/inspect/plugin-ossaudio.xml
index cf2dcd4..72ed2eb 100644
--- a/docs/plugins/inspect/plugin-ossaudio.xml
+++ b/docs/plugins/inspect/plugin-ossaudio.xml
@@ -3,7 +3,7 @@
   <description>OSS (Open Sound System) support for GStreamer</description>
   <filename>../../sys/oss/.libs/libgstossaudio.so</filename>
   <basename>libgstossaudio.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-png.xml b/docs/plugins/inspect/plugin-png.xml
index cd449c5..43eb33a 100644
--- a/docs/plugins/inspect/plugin-png.xml
+++ b/docs/plugins/inspect/plugin-png.xml
@@ -3,7 +3,7 @@
   <description>PNG plugin library</description>
   <filename>../../ext/libpng/.libs/libgstpng.so</filename>
   <basename>libgstpng.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-pulseaudio.xml b/docs/plugins/inspect/plugin-pulseaudio.xml
index b57b394..bf4e6c6 100644
--- a/docs/plugins/inspect/plugin-pulseaudio.xml
+++ b/docs/plugins/inspect/plugin-pulseaudio.xml
@@ -3,7 +3,7 @@
   <description>PulseAudio plugin library</description>
   <filename>../../ext/pulse/.libs/libgstpulse.so</filename>
   <basename>libgstpulse.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-replaygain.xml b/docs/plugins/inspect/plugin-replaygain.xml
index c450ac1..3132a51 100644
--- a/docs/plugins/inspect/plugin-replaygain.xml
+++ b/docs/plugins/inspect/plugin-replaygain.xml
@@ -3,7 +3,7 @@
   <description>ReplayGain volume normalization</description>
   <filename>../../gst/replaygain/.libs/libgstreplaygain.so</filename>
   <basename>libgstreplaygain.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rtp.xml b/docs/plugins/inspect/plugin-rtp.xml
index 18decd7..5d927de 100644
--- a/docs/plugins/inspect/plugin-rtp.xml
+++ b/docs/plugins/inspect/plugin-rtp.xml
@@ -3,7 +3,7 @@
   <description>Real-time protocol plugins</description>
   <filename>../../gst/rtp/.libs/libgstrtp.so</filename>
   <basename>libgstrtp.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
@@ -1034,7 +1034,7 @@
           <name>src</name>
           <direction>source</direction>
           <presence>always</presence>
-          <details>audio/mpeg, mpegversion=(int)4, framed=(boolean)true, stream-format=(string)raw</details>
+          <details>audio/mpeg, mpegversion=(int)4, framed=(boolean){ false, true }, stream-format=(string)raw</details>
         </caps>
       </pads>
     </element>
diff --git a/docs/plugins/inspect/plugin-rtpmanager.xml b/docs/plugins/inspect/plugin-rtpmanager.xml
index b0d6a4f..2e5ebdc 100644
--- a/docs/plugins/inspect/plugin-rtpmanager.xml
+++ b/docs/plugins/inspect/plugin-rtpmanager.xml
@@ -3,7 +3,7 @@
   <description>RTP session management plugin library</description>
   <filename>../../gst/rtpmanager/.libs/libgstrtpmanager.so</filename>
   <basename>libgstrtpmanager.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rtsp.xml b/docs/plugins/inspect/plugin-rtsp.xml
index 04bb648..36a579e 100644
--- a/docs/plugins/inspect/plugin-rtsp.xml
+++ b/docs/plugins/inspect/plugin-rtsp.xml
@@ -3,7 +3,7 @@
   <description>transfer data via RTSP</description>
   <filename>../../gst/rtsp/.libs/libgstrtsp.so</filename>
   <basename>libgstrtsp.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-shapewipe.xml b/docs/plugins/inspect/plugin-shapewipe.xml
index 77e0b2c..aa1da72 100644
--- a/docs/plugins/inspect/plugin-shapewipe.xml
+++ b/docs/plugins/inspect/plugin-shapewipe.xml
@@ -3,7 +3,7 @@
   <description>Shape Wipe transition filter</description>
   <filename>../../gst/shapewipe/.libs/libgstshapewipe.so</filename>
   <basename>libgstshapewipe.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-shout2send.xml b/docs/plugins/inspect/plugin-shout2send.xml
index 8cc7388..fd9d379 100644
--- a/docs/plugins/inspect/plugin-shout2send.xml
+++ b/docs/plugins/inspect/plugin-shout2send.xml
@@ -3,7 +3,7 @@
   <description>Sends data to an icecast server using libshout2</description>
   <filename>../../ext/shout2/.libs/libgstshout2.so</filename>
   <basename>libgstshout2.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>libshout2</package>
diff --git a/docs/plugins/inspect/plugin-smpte.xml b/docs/plugins/inspect/plugin-smpte.xml
index 49e7512..4deda2b 100644
--- a/docs/plugins/inspect/plugin-smpte.xml
+++ b/docs/plugins/inspect/plugin-smpte.xml
@@ -3,7 +3,7 @@
   <description>Apply the standard SMPTE transitions on video images</description>
   <filename>../../gst/smpte/.libs/libgstsmpte.so</filename>
   <basename>libgstsmpte.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-soup.xml b/docs/plugins/inspect/plugin-soup.xml
index 519ad17..04e5b2e 100644
--- a/docs/plugins/inspect/plugin-soup.xml
+++ b/docs/plugins/inspect/plugin-soup.xml
@@ -3,7 +3,7 @@
   <description>libsoup HTTP client src/sink</description>
   <filename>../../ext/soup/.libs/libgstsouphttpsrc.so</filename>
   <basename>libgstsouphttpsrc.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-spectrum.xml b/docs/plugins/inspect/plugin-spectrum.xml
index 4d4ca7d..c6cf452 100644
--- a/docs/plugins/inspect/plugin-spectrum.xml
+++ b/docs/plugins/inspect/plugin-spectrum.xml
@@ -3,7 +3,7 @@
   <description>Run an FFT on the audio signal, output spectrum data</description>
   <filename>../../gst/spectrum/.libs/libgstspectrum.so</filename>
   <basename>libgstspectrum.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-speex.xml b/docs/plugins/inspect/plugin-speex.xml
index 76e3ccd..d3d2351 100644
--- a/docs/plugins/inspect/plugin-speex.xml
+++ b/docs/plugins/inspect/plugin-speex.xml
@@ -3,7 +3,7 @@
   <description>Speex plugin library</description>
   <filename>../../ext/speex/.libs/libgstspeex.so</filename>
   <basename>libgstspeex.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-taglib.xml b/docs/plugins/inspect/plugin-taglib.xml
index 7d0e90e..3182912 100644
--- a/docs/plugins/inspect/plugin-taglib.xml
+++ b/docs/plugins/inspect/plugin-taglib.xml
@@ -3,7 +3,7 @@
   <description>Tag writing plug-in based on taglib</description>
   <filename>../../ext/taglib/.libs/libgsttaglib.so</filename>
   <basename>libgsttaglib.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-udp.xml b/docs/plugins/inspect/plugin-udp.xml
index 7a3dc28..8294a2a 100644
--- a/docs/plugins/inspect/plugin-udp.xml
+++ b/docs/plugins/inspect/plugin-udp.xml
@@ -3,7 +3,7 @@
   <description>transfer data via UDP</description>
   <filename>../../gst/udp/.libs/libgstudp.so</filename>
   <basename>libgstudp.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-video4linux2.xml b/docs/plugins/inspect/plugin-video4linux2.xml
index 0e25e52..2c3af4d 100644
--- a/docs/plugins/inspect/plugin-video4linux2.xml
+++ b/docs/plugins/inspect/plugin-video4linux2.xml
@@ -3,7 +3,7 @@
   <description>elements for Video 4 Linux</description>
   <filename>../../sys/v4l2/.libs/libgstvideo4linux2.so</filename>
   <basename>libgstvideo4linux2.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videobox.xml b/docs/plugins/inspect/plugin-videobox.xml
index 8cbb6e5..9513d24 100644
--- a/docs/plugins/inspect/plugin-videobox.xml
+++ b/docs/plugins/inspect/plugin-videobox.xml
@@ -3,7 +3,7 @@
   <description>resizes a video by adding borders or cropping</description>
   <filename>../../gst/videobox/.libs/libgstvideobox.so</filename>
   <basename>libgstvideobox.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videocrop.xml b/docs/plugins/inspect/plugin-videocrop.xml
index c1281d7..35d6f4f 100644
--- a/docs/plugins/inspect/plugin-videocrop.xml
+++ b/docs/plugins/inspect/plugin-videocrop.xml
@@ -3,7 +3,7 @@
   <description>Crops video into a user-defined region</description>
   <filename>../../gst/videocrop/.libs/libgstvideocrop.so</filename>
   <basename>libgstvideocrop.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videofilter.xml b/docs/plugins/inspect/plugin-videofilter.xml
index 3653d59..d0fb64d 100644
--- a/docs/plugins/inspect/plugin-videofilter.xml
+++ b/docs/plugins/inspect/plugin-videofilter.xml
@@ -3,7 +3,7 @@
   <description>Video filters plugin</description>
   <filename>../../gst/videofilter/.libs/libgstvideofilter.so</filename>
   <basename>libgstvideofilter.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videomixer.xml b/docs/plugins/inspect/plugin-videomixer.xml
index 96e4f2d..937eca6 100644
--- a/docs/plugins/inspect/plugin-videomixer.xml
+++ b/docs/plugins/inspect/plugin-videomixer.xml
@@ -3,7 +3,7 @@
   <description>Video mixer</description>
   <filename>../../gst/videomixer/.libs/libgstvideomixer.so</filename>
   <basename>libgstvideomixer.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-vpx.xml b/docs/plugins/inspect/plugin-vpx.xml
index 6c17a51..d1e4b0e 100644
--- a/docs/plugins/inspect/plugin-vpx.xml
+++ b/docs/plugins/inspect/plugin-vpx.xml
@@ -3,7 +3,7 @@
   <description>VP8 plugin</description>
   <filename>../../ext/vpx/.libs/libgstvpx.so</filename>
   <basename>libgstvpx.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-wavenc.xml b/docs/plugins/inspect/plugin-wavenc.xml
index 93a01e0..83941e0 100644
--- a/docs/plugins/inspect/plugin-wavenc.xml
+++ b/docs/plugins/inspect/plugin-wavenc.xml
@@ -3,7 +3,7 @@
   <description>Encode raw audio into WAV</description>
   <filename>../../gst/wavenc/.libs/libgstwavenc.so</filename>
   <basename>libgstwavenc.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-wavpack.xml b/docs/plugins/inspect/plugin-wavpack.xml
index 6ab1f1e..28f3ce3 100644
--- a/docs/plugins/inspect/plugin-wavpack.xml
+++ b/docs/plugins/inspect/plugin-wavpack.xml
@@ -3,7 +3,7 @@
   <description>Wavpack lossless/lossy audio format handling</description>
   <filename>../../ext/wavpack/.libs/libgstwavpack.so</filename>
   <basename>libgstwavpack.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-wavparse.xml b/docs/plugins/inspect/plugin-wavparse.xml
index 1c55615..54e03e5 100644
--- a/docs/plugins/inspect/plugin-wavparse.xml
+++ b/docs/plugins/inspect/plugin-wavparse.xml
@@ -3,7 +3,7 @@
   <description>Parse a .wav file into raw audio</description>
   <filename>../../gst/wavparse/.libs/libgstwavparse.so</filename>
   <basename>libgstwavparse.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ximagesrc.xml b/docs/plugins/inspect/plugin-ximagesrc.xml
index 1ec3d79..dd1f1fc 100644
--- a/docs/plugins/inspect/plugin-ximagesrc.xml
+++ b/docs/plugins/inspect/plugin-ximagesrc.xml
@@ -3,7 +3,7 @@
   <description>X11 video input plugin using standard Xlib calls</description>
   <filename>../../sys/ximage/.libs/libgstximagesrc.so</filename>
   <basename>libgstximagesrc.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-y4menc.xml b/docs/plugins/inspect/plugin-y4menc.xml
index 5376ce6..d050e09 100644
--- a/docs/plugins/inspect/plugin-y4menc.xml
+++ b/docs/plugins/inspect/plugin-y4menc.xml
@@ -3,7 +3,7 @@
   <description>Encodes a YUV frame into the yuv4mpeg format (mjpegtools)</description>
   <filename>../../gst/y4m/.libs/libgsty4menc.so</filename>
   <basename>libgsty4menc.so</basename>
-  <version>1.9.2</version>
+  <version>1.9.90</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/ext/dv/gstdvdemux.c b/ext/dv/gstdvdemux.c
index 06e9297..6040270 100644
--- a/ext/dv/gstdvdemux.c
+++ b/ext/dv/gstdvdemux.c
@@ -1533,10 +1533,18 @@
       GST_SMPTE_TIME_CODE_SYSTEM_25 : GST_SMPTE_TIME_CODE_SYSTEM_30,
       &frame_number, &timecode);
 
-  next_ts = gst_util_uint64_scale_int (
-      (dvdemux->frame_offset + 1) * GST_SECOND,
-      dvdemux->framerate_denominator, dvdemux->framerate_numerator);
-  duration = next_ts - dvdemux->time_segment.position;
+  if (dvdemux->time_segment.rate < 0) {
+    next_ts = gst_util_uint64_scale_int (
+        (dvdemux->frame_offset >
+            0 ? dvdemux->frame_offset - 1 : 0) * GST_SECOND,
+        dvdemux->framerate_denominator, dvdemux->framerate_numerator);
+    duration = dvdemux->time_segment.position - next_ts;
+  } else {
+    next_ts = gst_util_uint64_scale_int (
+        (dvdemux->frame_offset + 1) * GST_SECOND,
+        dvdemux->framerate_denominator, dvdemux->framerate_numerator);
+    duration = next_ts - dvdemux->time_segment.position;
+  }
 
   gst_buffer_map (buffer, &map, GST_MAP_READ);
   dv_parse_packs (dvdemux->decoder, map.data);
@@ -1569,10 +1577,22 @@
 
   dvdemux->discont = FALSE;
   dvdemux->time_segment.position = next_ts;
-  dvdemux->frame_offset++;
+
+  if (dvdemux->time_segment.rate < 0) {
+    if (dvdemux->frame_offset > 0)
+      dvdemux->frame_offset--;
+    else
+      GST_WARNING_OBJECT (dvdemux,
+          "Got before frame offset 0 in reverse playback");
+  } else {
+    dvdemux->frame_offset++;
+  }
 
   /* check for the end of the segment */
-  if (dvdemux->time_segment.stop != -1 && next_ts > dvdemux->time_segment.stop)
+  if ((dvdemux->time_segment.rate > 0 && dvdemux->time_segment.stop != -1
+          && next_ts > dvdemux->time_segment.stop)
+      || (dvdemux->time_segment.rate < 0
+          && dvdemux->time_segment.start > next_ts))
     ret = GST_FLOW_EOS;
   else
     ret = GST_FLOW_OK;
diff --git a/ext/jack/gstjackaudioclient.c b/ext/jack/gstjackaudioclient.c
index 9c50a6a..19022c0 100644
--- a/ext/jack/gstjackaudioclient.c
+++ b/ext/jack/gstjackaudioclient.c
@@ -201,20 +201,6 @@
   return res;
 }
 
-/* we error out */
-static int
-jack_sample_rate_cb (jack_nframes_t nframes, void *arg)
-{
-  return 0;
-}
-
-/* we error out */
-static int
-jack_buffer_size_cb (jack_nframes_t nframes, void *arg)
-{
-  return 0;
-}
-
 static void
 jack_shutdown_cb (void *arg)
 {
@@ -244,6 +230,22 @@
   g_mutex_unlock (&conn->lock);
 }
 
+/* we error out */
+static int
+jack_sample_rate_cb (jack_nframes_t nframes, void *arg)
+{
+  jack_shutdown_cb (arg);
+  return 0;
+}
+
+/* we error out */
+static int
+jack_buffer_size_cb (jack_nframes_t nframes, void *arg)
+{
+  jack_shutdown_cb (arg);
+  return 0;
+}
+
 typedef struct
 {
   const gchar *id;
diff --git a/ext/pulse/pulsesrc.c b/ext/pulse/pulsesrc.c
index 6ee2c50..7af74ee 100644
--- a/ext/pulse/pulsesrc.c
+++ b/ext/pulse/pulsesrc.c
@@ -1595,6 +1595,9 @@
 
   /* Fix up the total ringbuffer size based on what we actually got */
   spec->segtotal = actual->maxlength / spec->segsize;
+  /* Don't buffer less than 2 segments as the ringbuffer can't deal with it */
+  if (spec->segtotal < 2)
+    spec->segtotal = 2;
 
   if (!pulsesrc->paused) {
     GST_DEBUG_OBJECT (pulsesrc, "uncorking because we are playing");
diff --git a/gst-plugins-good.doap b/gst-plugins-good.doap
index c86fed0..a5fb63c 100644
--- a/gst-plugins-good.doap
+++ b/gst-plugins-good.doap
@@ -34,6 +34,16 @@
 
  <release>
   <Version>
+   <revision>1.9.90</revision>
+   <branch>master</branch>
+   <name></name>
+   <created>2016-09-30</created>
+   <file-release rdf:resource="http://gstreamer.freedesktop.org/src/gst-plugins-good/gst-plugins-good-1.9.90.tar.xz" />
+  </Version>
+ </release>
+
+ <release>
+  <Version>
    <revision>1.9.2</revision>
    <branch>master</branch>
    <name></name>
diff --git a/gst-plugins-good.spec b/gst-plugins-good.spec
index 89bbb66..cf7f597 100644
--- a/gst-plugins-good.spec
+++ b/gst-plugins-good.spec
@@ -4,7 +4,7 @@
 %define gst_minver   0.11.0
 
 Name: 		%{gstreamer}-plugins-good
-Version: 	1.9.2
+Version: 	1.9.90
 Release: 	1.gst
 Summary: 	GStreamer plug-ins with good code and licensing
 
diff --git a/gst/audioparsers/gstaacparse.c b/gst/audioparsers/gstaacparse.c
index 087b43c..34ba80a 100644
--- a/gst/audioparsers/gstaacparse.c
+++ b/gst/audioparsers/gstaacparse.c
@@ -75,12 +75,12 @@
 
 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
 
-static const gint loas_sample_rate_table[32] = {
+static const gint loas_sample_rate_table[16] = {
   96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
   16000, 12000, 11025, 8000, 7350, 0, 0, 0
 };
 
-static const gint loas_channels_table[32] = {
+static const gint loas_channels_table[16] = {
   0, 1, 2, 3, 4, 5, 6, 8,
   0, 0, 0, 7, 8, 0, 8, 0
 };
@@ -97,7 +97,10 @@
     GstBaseParseFrame * frame, gint * skipsize);
 static GstFlowReturn gst_aac_parse_pre_push_frame (GstBaseParse * parse,
     GstBaseParseFrame * frame);
+static gboolean gst_aac_parse_src_event (GstBaseParse * parse,
+    GstEvent * event);
 
+#define gst_aac_parse_parent_class parent_class
 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
 
 /**
@@ -128,6 +131,7 @@
   parse_class->handle_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_handle_frame);
   parse_class->pre_push_frame =
       GST_DEBUG_FUNCPTR (gst_aac_parse_pre_push_frame);
+  parse_class->src_event = GST_DEBUG_FUNCPTR (gst_aac_parse_src_event);
 }
 
 
@@ -143,6 +147,9 @@
   GST_DEBUG ("initialized");
   GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (aacparse));
   GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (aacparse));
+
+  aacparse->last_parsed_sample_rate = 0;
+  aacparse->last_parsed_channels = 0;
 }
 
 
@@ -251,6 +258,9 @@
   if (allowed)
     gst_caps_unref (allowed);
 
+  aacparse->last_parsed_channels = 0;
+  aacparse->last_parsed_sample_rate = 0;
+
   GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
 
   res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
@@ -347,7 +357,6 @@
       gst_base_parse_set_passthrough (parse, FALSE);
     }
   }
-
   return TRUE;
 }
 
@@ -481,7 +490,7 @@
   *value = 0;
   if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
     return FALSE;
-  for (i = 0; i < bytes; ++i) {
+  for (i = 0; i <= bytes; ++i) {
     *value <<= 8;
     if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
       return FALSE;
@@ -524,6 +533,7 @@
     if (!*sample_rate)
       return FALSE;
   }
+  aacparse->last_parsed_sample_rate = *sample_rate;
   return TRUE;
 }
 
@@ -532,7 +542,10 @@
 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
     GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
 {
-  guint8 audio_object_type, channel_configuration;
+  guint8 audio_object_type;
+  guint8 G_GNUC_UNUSED extension_audio_object_type;
+  guint8 channel_configuration, extension_channel_configuration;
+  gboolean G_GNUC_UNUSED sbr = FALSE, ps = FALSE;
 
   if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
     return FALSE;
@@ -542,16 +555,38 @@
 
   if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
     return FALSE;
-  GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
   *channels = loas_channels_table[channel_configuration];
+  GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
   if (!*channels)
     return FALSE;
 
-  if (audio_object_type == 5) {
+  if (audio_object_type == 5 || audio_object_type == 29) {
+    extension_audio_object_type = 5;
+    sbr = TRUE;
+    if (audio_object_type == 29)
+      ps = TRUE;
+
     GST_LOG_OBJECT (aacparse,
-        "Audio object type 5, so rereading sampling rate...");
+        "Audio object type 5 or 29, so rereading sampling rate...");
     if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
       return FALSE;
+
+    if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
+      return FALSE;
+
+    if (audio_object_type == 22) {
+      /* extension channel configuration */
+      if (!gst_bit_reader_get_bits_uint8 (br, &extension_channel_configuration,
+              4))
+        return FALSE;
+      GST_LOG_OBJECT (aacparse, "extension channel_configuration: %d",
+          extension_channel_configuration);
+      *channels = loas_channels_table[extension_channel_configuration];
+      if (!*channels)
+        return FALSE;
+    }
+  } else {
+    extension_audio_object_type = 0;
   }
 
   GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
@@ -563,6 +598,7 @@
       "Need more code to parse humongous LOAS data, currently ignored");
   if (bits)
     *bits = 0;
+  aacparse->last_parsed_channels = *channels;
   return TRUE;
 }
 
@@ -589,21 +625,23 @@
     return FALSE;
   if (u8) {
     GST_LOG_OBJECT (aacparse, "Frame uses previous config");
-    if (!aacparse->sample_rate || !aacparse->channels) {
+    if (!aacparse->last_parsed_sample_rate || !aacparse->last_parsed_channels) {
       GST_DEBUG_OBJECT (aacparse,
           "No previous config to use. We'll look for more data.");
       return FALSE;
     }
-    *sample_rate = aacparse->sample_rate;
-    *channels = aacparse->channels;
+    *sample_rate = aacparse->last_parsed_sample_rate;
+    *channels = aacparse->last_parsed_channels;
     return TRUE;
   }
 
   GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
 
+  /* audioMuxVersion */
   if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
     return FALSE;
   if (v) {
+    /* audioMuxVersionA */
     if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
       return FALSE;
   } else
@@ -614,6 +652,7 @@
     guint8 same_time, subframes, num_program, prog;
     if (v == 1) {
       guint32 value;
+      /* taraBufferFullness */
       if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
         return FALSE;
     }
@@ -731,7 +770,8 @@
 
   if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
     *framesize = gst_aac_parse_loas_get_frame_len (data);
-    GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
+    GST_DEBUG_OBJECT (aacparse, "Found possible %u byte LOAS frame",
+        *framesize);
 
     /* In EOS mode this is enough. No need to examine the data further.
        We also relax the check when we have sync, on the assumption that
@@ -760,6 +800,8 @@
       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
           nextlen + LOAS_MAX_SIZE);
       return TRUE;
+    } else {
+      GST_DEBUG_OBJECT (aacparse, "That was a false positive");
     }
   }
   return FALSE;
@@ -1439,6 +1481,8 @@
   aacparse->frame_samples = 1024;
   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
   aacparse->sent_codec_tag = FALSE;
+  aacparse->last_parsed_channels = 0;
+  aacparse->last_parsed_sample_rate = 0;
   return TRUE;
 }
 
@@ -1586,3 +1630,16 @@
 
   return res;
 }
+
+static gboolean
+gst_aac_parse_src_event (GstBaseParse * parse, GstEvent * event)
+{
+  GstAacParse *aacparse = GST_AAC_PARSE (parse);
+
+  if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
+    aacparse->last_parsed_channels = 0;
+    aacparse->last_parsed_sample_rate = 0;
+  }
+
+  return GST_BASE_PARSE_CLASS (parent_class)->src_event (parse, event);
+}
diff --git a/gst/audioparsers/gstaacparse.h b/gst/audioparsers/gstaacparse.h
index 1bb7dca..40c96ff 100644
--- a/gst/audioparsers/gstaacparse.h
+++ b/gst/audioparsers/gstaacparse.h
@@ -83,6 +83,9 @@
   GstAacHeaderType output_header_type;
 
   gboolean sent_codec_tag;
+
+  gint last_parsed_sample_rate;
+  gint last_parsed_channels;
 };
 
 /**
diff --git a/gst/autodetect/gstautodetect.c b/gst/autodetect/gstautodetect.c
index 59aab7e..a256e52 100644
--- a/gst/autodetect/gstautodetect.c
+++ b/gst/autodetect/gstautodetect.c
@@ -113,8 +113,6 @@
     gst_element_set_state (self->kid, GST_STATE_NULL);
     gst_bin_remove (GST_BIN (self), self->kid);
     self->kid = NULL;
-    /* Don't lose the element type flag */
-    GST_OBJECT_FLAG_SET (self, self->flag);
   }
 }
 
@@ -204,6 +202,8 @@
 
   /* mark element type */
   GST_OBJECT_FLAG_SET (self, self->flag);
+  gst_bin_set_suppressed_flags (GST_BIN (self),
+      GST_ELEMENT_FLAG_SOURCE | GST_ELEMENT_FLAG_SINK);
 }
 
 static gboolean
diff --git a/gst/deinterlace/gstdeinterlace.c b/gst/deinterlace/gstdeinterlace.c
index 3a1833e..503b75e 100644
--- a/gst/deinterlace/gstdeinterlace.c
+++ b/gst/deinterlace/gstdeinterlace.c
@@ -1081,7 +1081,7 @@
   GstVideoFrame *frame = NULL;
   GstVideoFrame *field1, *field2 = NULL;
   guint fields_to_push;
-  gint field1_flags, field2_flags;
+  guint field1_flags, field2_flags;
   GstVideoInterlaceMode interlacing_mode;
   guint8 buf_state;
 
@@ -1151,6 +1151,13 @@
     field2_flags = PICTURE_INTERLACED_TOP;
   }
 
+  /* Swap for reverse playback */
+  if (self->segment.rate < 0) {
+    field1_flags = field1_flags ^ field2_flags;
+    field2_flags = field1_flags ^ field2_flags;
+    field1_flags = field1_flags ^ field2_flags;
+  }
+
   if (!onefield) {
     GST_DEBUG_OBJECT (self, "Two fields");
     self->field_history[1].frame = field1;
@@ -1283,6 +1290,7 @@
   GstVideoFrame *field3, *field4;
   GstVideoInterlaceMode interlacing_mode;
 
+  /* FIXME: This is broken for rate < 0 */
   if (self->pattern_lock && self->pattern > -1) {
     /* accurate pattern-locked timestamp adjustment */
     if (!self->pattern_count)
@@ -1742,11 +1750,16 @@
     if (!IS_TELECINE (interlacing_mode)) {
       timestamp = GST_BUFFER_TIMESTAMP (buf);
 
-      GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
-      if (self->fields == GST_DEINTERLACE_ALL)
+      if (self->fields == GST_DEINTERLACE_ALL) {
+        if (self->segment.rate < 0)
+          GST_BUFFER_TIMESTAMP (outbuf) = timestamp + self->field_duration;
+        else
+          GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
         GST_BUFFER_DURATION (outbuf) = self->field_duration;
-      else
+      } else {
+        GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
         GST_BUFFER_DURATION (outbuf) = 2 * self->field_duration;
+      }
       GST_DEBUG_OBJECT (self,
           "[ADJUST] ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT ", end %"
           GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
@@ -1884,7 +1897,10 @@
       timestamp = GST_BUFFER_TIMESTAMP (buf);
 
       if (self->fields == GST_DEINTERLACE_ALL) {
-        GST_BUFFER_TIMESTAMP (outbuf) = timestamp + self->field_duration;
+        if (self->segment.rate < 0)
+          GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
+        else
+          GST_BUFFER_TIMESTAMP (outbuf) = timestamp + self->field_duration;
         GST_BUFFER_DURATION (outbuf) = self->field_duration;
       } else {
         GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
@@ -2747,7 +2763,7 @@
   }
 
   if (fps_n != 0) {
-    self->field_duration = gst_util_uint64_scale (GST_SECOND, fps_d, fps_n);
+    self->field_duration = gst_util_uint64_scale (GST_SECOND, fps_d, 2 * fps_n);
   } else {
     self->field_duration = 0;
   }
diff --git a/gst/isomp4/GstQTMux.prs b/gst/isomp4/GstQTMux.prs
new file mode 100644
index 0000000..be1e644
--- /dev/null
+++ b/gst/isomp4/GstQTMux.prs
@@ -0,0 +1,6 @@
+[_presets_]
+version=1.6.0
+element-name=GstQTMux
+
+[Profile YouTube]
+faststart=true
diff --git a/gst/isomp4/Makefile.am b/gst/isomp4/Makefile.am
index 8cfdd15..2e560a2 100644
--- a/gst/isomp4/Makefile.am
+++ b/gst/isomp4/Makefile.am
@@ -18,6 +18,9 @@
 	properties.c gstqtmuxmap.c gstisoff.c
 libgstisomp4_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
 
+presetdir = $(datadir)/gstreamer-$(GST_API_VERSION)/presets
+preset_DATA = GstQTMux.prs
+
 noinst_HEADERS = \
 	qtatomparser.h   \
 	qtdemux.h        \
@@ -38,4 +41,5 @@
 
 EXTRA_DIST = \
 	gstqtmux-doc.c \
-	gstqtmux-doc.h
+	gstqtmux-doc.h \
+	$(preset_DATA)
diff --git a/gst/isomp4/Makefile.in b/gst/isomp4/Makefile.in
index 2e53256..44461b1 100644
--- a/gst/isomp4/Makefile.in
+++ b/gst/isomp4/Makefile.in
@@ -15,6 +15,7 @@
 @SET_MAKE@
 
 
+
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
@@ -160,7 +161,7 @@
     || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
-am__installdirs = "$(DESTDIR)$(plugindir)"
+am__installdirs = "$(DESTDIR)$(plugindir)" "$(DESTDIR)$(presetdir)"
 LTLIBRARIES = $(plugin_LTLIBRARIES)
 am__DEPENDENCIES_1 =
 libgstisomp4_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \
@@ -225,6 +226,7 @@
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
+DATA = $(preset_DATA)
 HEADERS = $(noinst_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 # Read a list of newline-separated strings from the standard input,
@@ -598,6 +600,8 @@
 	properties.c gstqtmuxmap.c gstisoff.c
 
 libgstisomp4_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
+presetdir = $(datadir)/gstreamer-$(GST_API_VERSION)/presets
+preset_DATA = GstQTMux.prs
 noinst_HEADERS = \
 	qtatomparser.h   \
 	qtdemux.h        \
@@ -618,7 +622,8 @@
 
 EXTRA_DIST = \
 	gstqtmux-doc.c \
-	gstqtmux-doc.h
+	gstqtmux-doc.h \
+	$(preset_DATA)
 
 all: all-am
 
@@ -840,6 +845,27 @@
 
 clean-libtool:
 	-rm -rf .libs _libs
+install-presetDATA: $(preset_DATA)
+	@$(NORMAL_INSTALL)
+	@list='$(preset_DATA)'; test -n "$(presetdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(presetdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(presetdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(presetdir)'"; \
+	  $(INSTALL_DATA) $$files "$(DESTDIR)$(presetdir)" || exit $$?; \
+	done
+
+uninstall-presetDATA:
+	@$(NORMAL_UNINSTALL)
+	@list='$(preset_DATA)'; test -n "$(presetdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(presetdir)'; $(am__uninstall_files_from_dir)
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
@@ -925,9 +951,9 @@
 	done
 check-am: all-am
 check: check-am
-all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+all-am: Makefile $(LTLIBRARIES) $(DATA) $(HEADERS)
 installdirs:
-	for dir in "$(DESTDIR)$(plugindir)"; do \
+	for dir in "$(DESTDIR)$(plugindir)" "$(DESTDIR)$(presetdir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
 install: install-am
@@ -983,7 +1009,7 @@
 
 info-am:
 
-install-data-am: install-pluginLTLIBRARIES
+install-data-am: install-pluginLTLIBRARIES install-presetDATA
 
 install-dvi: install-dvi-am
 
@@ -1029,7 +1055,7 @@
 
 ps-am:
 
-uninstall-am: uninstall-pluginLTLIBRARIES
+uninstall-am: uninstall-pluginLTLIBRARIES uninstall-presetDATA
 
 .MAKE: install-am install-strip
 
@@ -1041,12 +1067,12 @@
 	install-data-am install-dvi install-dvi-am install-exec \
 	install-exec-am install-html install-html-am install-info \
 	install-info-am install-man install-pdf install-pdf-am \
-	install-pluginLTLIBRARIES install-ps install-ps-am \
-	install-strip installcheck installcheck-am installdirs \
-	maintainer-clean maintainer-clean-generic mostlyclean \
-	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
-	pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
-	uninstall-pluginLTLIBRARIES
+	install-pluginLTLIBRARIES install-presetDATA install-ps \
+	install-ps-am install-strip installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+	uninstall-am uninstall-pluginLTLIBRARIES uninstall-presetDATA
 
 .PRECIOUS: Makefile
 
diff --git a/gst/isomp4/gstqtmux.c b/gst/isomp4/gstqtmux.c
index cf6633d..27f9090 100644
--- a/gst/isomp4/gstqtmux.c
+++ b/gst/isomp4/gstqtmux.c
@@ -3302,13 +3302,15 @@
     sync = TRUE;
   }
 
-  if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DTS (last_buf))) {
+  if (!GST_BUFFER_PTS_IS_VALID (last_buf))
+    goto no_pts;
+
+  if (GST_BUFFER_DTS_IS_VALID (last_buf)) {
     last_dts = gst_util_uint64_scale_round (GST_BUFFER_DTS (last_buf),
         atom_trak_get_timescale (pad->trak), GST_SECOND);
     pts_offset =
         (gint64) (gst_util_uint64_scale_round (GST_BUFFER_PTS (last_buf),
             atom_trak_get_timescale (pad->trak), GST_SECOND) - last_dts);
-
   } else {
     pts_offset = 0;
     last_dts = gst_util_uint64_scale_round (GST_BUFFER_PTS (last_buf),
@@ -3388,6 +3390,11 @@
         ("Audio buffer contains fragmented sample."));
     goto bail;
   }
+no_pts:
+  {
+    GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL), ("Buffer has no PTS."));
+    goto bail;
+  }
 not_negotiated:
   {
     GST_ELEMENT_ERROR (qtmux, CORE, NEGOTIATION, (NULL),
@@ -4214,7 +4221,7 @@
     else if (!g_strcmp0 (variant, "hq"))
       entry.fourcc = FOURCC_apch;
     else if (!g_strcmp0 (variant, "proxy"))
-      entry.fourcc = FOURCC_ap4h;
+      entry.fourcc = FOURCC_apco;
   }
 
   if (!entry.fourcc)
@@ -4737,6 +4744,9 @@
   static const GInterfaceInfo tag_xmp_writer_info = {
     NULL, NULL, NULL
   };
+  static const GInterfaceInfo preset_info = {
+    NULL, NULL, NULL
+  };
   GType type;
   GstQTMuxFormat format;
   GstQTMuxClassParams *params;
@@ -4775,6 +4785,7 @@
     g_type_add_interface_static (type, GST_TYPE_TAG_SETTER, &tag_setter_info);
     g_type_add_interface_static (type, GST_TYPE_TAG_XMP_WRITER,
         &tag_xmp_writer_info);
+    g_type_add_interface_static (type, GST_TYPE_PRESET, &preset_info);
 
     if (!gst_element_register (plugin, prop->name, prop->rank, type))
       return FALSE;
diff --git a/gst/isomp4/qtdemux.c b/gst/isomp4/qtdemux.c
index 9768cc9..2bcb4ba 100644
--- a/gst/isomp4/qtdemux.c
+++ b/gst/isomp4/qtdemux.c
@@ -5304,7 +5304,7 @@
       gst_pad_push_event (stream->pad, event);
     }
 
-    if (qtdemux->cenc_aux_info_offset > 0 && info->crypto_info == NULL) {
+    if (info->crypto_info == NULL) {
       GST_DEBUG_OBJECT (qtdemux, "cenc metadata hasn't been parsed yet");
       gst_buffer_unref (buf);
       goto exit;
diff --git a/gst/isomp4/qtdemux_types.c b/gst/isomp4/qtdemux_types.c
index dc71228..0208e8b 100644
--- a/gst/isomp4/qtdemux_types.c
+++ b/gst/isomp4/qtdemux_types.c
@@ -84,6 +84,7 @@
   {FOURCC_mhdr, "mhdr", QT_FLAG_CONTAINER,},
   {FOURCC_jp2h, "jp2h", QT_FLAG_CONTAINER,},
   {FOURCC_colr, "colr", 0,},
+  {FOURCC_ihdr, "ihdr", 0,},
   {FOURCC_fiel, "fiel", 0,},
   {FOURCC_jp2x, "jp2x", 0,},
   {FOURCC_alac, "alac", 0,},
diff --git a/gst/matroska/matroska-mux.c b/gst/matroska/matroska-mux.c
index 4922496..f77bd49 100644
--- a/gst/matroska/matroska-mux.c
+++ b/gst/matroska/matroska-mux.c
@@ -357,7 +357,6 @@
  * Start of pad option handler code
  */
 #define DEFAULT_PAD_FRAME_DURATION TRUE
-#define DEFAULT_PAD_FRAME_DURATION_VP8 FALSE
 
 enum
 {
@@ -978,13 +977,6 @@
   videocontext->pixel_width = width;
   videocontext->pixel_height = height;
 
-  /* set vp8 defaults or let user override it */
-  if (GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration_user == FALSE
-      && (!strcmp (mimetype, "video/x-vp8")
-          || !strcmp (mimetype, "video/x-vp9")))
-    GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration =
-        DEFAULT_PAD_FRAME_DURATION_VP8;
-
   if (GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration
       && gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)
       && fps_n > 0) {
diff --git a/gst/multifile/gstmultifilesink.c b/gst/multifile/gstmultifilesink.c
index a12c63f..2b83c0b 100644
--- a/gst/multifile/gstmultifilesink.c
+++ b/gst/multifile/gstmultifilesink.c
@@ -580,8 +580,6 @@
   if (sink->streamheaders == NULL)
     return TRUE;
 
-  GST_DEBUG_OBJECT (sink, "Writing stream headers");
-
   /* we want to write these at the beginning */
   g_assert (sink->cur_file_size == 0);
 
@@ -609,29 +607,29 @@
     GstBuffer * buffer)
 {
   GstMapInfo map;
+  gchar *filename;
   gboolean ret;
+  GError *error = NULL;
   gboolean first_file = TRUE;
 
   gst_buffer_map (buffer, &map, GST_MAP_READ);
 
   switch (multifilesink->next_file) {
     case GST_MULTI_FILE_SINK_NEXT_BUFFER:
-      if (multifilesink->files != NULL)
-        first_file = FALSE;
-      if (!gst_multi_file_sink_open_next_file (multifilesink))
-        goto stdio_write_error;
-      if (first_file == FALSE)
-        gst_multi_file_sink_write_stream_headers (multifilesink);
-      GST_DEBUG_OBJECT (multifilesink,
-          "Writing buffer data (%" G_GSIZE_FORMAT " bytes) to new file",
-          map.size);
-      ret = fwrite (map.data, map.size, 1, multifilesink->file);
-      if (ret != 1) {
-        gst_multi_file_sink_close_file (multifilesink, NULL);
-        goto stdio_write_error;
-      }
+      gst_multi_file_sink_ensure_max_files (multifilesink);
 
-      gst_multi_file_sink_close_file (multifilesink, buffer);
+      filename = g_strdup_printf (multifilesink->filename,
+          multifilesink->index);
+      ret = g_file_set_contents (filename, (char *) map.data, map.size, &error);
+      if (!ret)
+        goto write_error;
+
+      multifilesink->files = g_slist_append (multifilesink->files, filename);
+      multifilesink->n_files += 1;
+
+      gst_multi_file_sink_post_message (multifilesink, buffer, filename);
+      multifilesink->index++;
+
       break;
     case GST_MULTI_FILE_SINK_NEXT_DISCONT:
       if (GST_BUFFER_IS_DISCONT (buffer)) {
@@ -778,6 +776,26 @@
   return GST_FLOW_OK;
 
   /* ERRORS */
+write_error:
+  {
+    switch (error->code) {
+      case G_FILE_ERROR_NOSPC:{
+        GST_ELEMENT_ERROR (multifilesink, RESOURCE, NO_SPACE_LEFT, (NULL),
+            (NULL));
+        break;
+      }
+      default:{
+        GST_ELEMENT_ERROR (multifilesink, RESOURCE, WRITE,
+            ("Error while writing to file \"%s\".", filename),
+            ("%s", g_strerror (errno)));
+      }
+    }
+    g_error_free (error);
+    g_free (filename);
+
+    gst_buffer_unmap (buffer, &map);
+    return GST_FLOW_ERROR;
+  }
 stdio_write_error:
   switch (errno) {
     case ENOSPC:
diff --git a/gst/rtp/dboolhuff.c b/gst/rtp/dboolhuff.c
index 6c94504..3d0fc8f 100644
--- a/gst/rtp/dboolhuff.c
+++ b/gst/rtp/dboolhuff.c
@@ -11,7 +11,8 @@
 #include "dboolhuff.h"
 
 #ifdef _MSC_VER
-__declspec(align(16)) const unsigned char vp8_norm[256] = {
+__declspec (align (16))
+     const unsigned char vp8_norm[256] = {
 #else
 const unsigned char vp8_norm[256] __attribute__ ((aligned (16))) = {
 #endif
diff --git a/gst/rtp/gstrtph263pay.c b/gst/rtp/gstrtph263pay.c
index 6e40700..7ed2d6c 100644
--- a/gst/rtp/gstrtph263pay.c
+++ b/gst/rtp/gstrtph263pay.c
@@ -894,7 +894,8 @@
     guint rest_bits, guint8 ** orig_data, guint8 ** data_end)
 {
 
-  GST_LOG ("Moving window: 0x%08x from: %p for %d bits, rest_bits: %d, data_end %p",
+  GST_LOG
+      ("Moving window: 0x%08x from: %p for %d bits, rest_bits: %d, data_end %p",
       context->window, context->win_end, n, rest_bits, *data_end);
 
   if (n == 0)
@@ -916,13 +917,13 @@
     } else {
       if (n > rest_bits) {
         context->window = (context->window << rest_bits) |
-          (b & (((guint) pow (2.0, (double) rest_bits)) - 1));
+            (b & (((guint) pow (2.0, (double) rest_bits)) - 1));
         n -= rest_bits;
         rest_bits = 0;
       } else {
         context->window = (context->window << n) |
-          ((b & (((guint) pow (2.0, (double) rest_bits)) - 1)) >>
-              (rest_bits - n));
+            ((b & (((guint) pow (2.0, (double) rest_bits)) - 1)) >>
+            (rest_bits - n));
         rest_bits -= n;
         if (rest_bits == 0)
           context->win_end++;
@@ -1411,7 +1412,7 @@
 
 
     /*---------- MODE B MODE FRAGMENTATION ----------*/
-  GstRtpH263PayMB *mac, *mac0;
+  GstRtpH263PayMB *mac;
   guint max_payload_size;
   GstRtpH263PayBoundry boundry;
   guint mb;
@@ -1507,7 +1508,7 @@
 
   // We are on MB layer
 
-  mac = mac0 = gst_rtp_h263_pay_mb_new (&boundry, 0);
+  mac = gst_rtp_h263_pay_mb_new (&boundry, 0);
   for (mb = 0; mb < format_props[context->piclayer->ptype_srcformat][1]; mb++) {
 
     GST_LOG ("================ START MB %d =================", mb);
@@ -1519,11 +1520,9 @@
       GST_LOG ("Error decoding MB - sbit: %d", 8 - ebit);
       GST_ERROR ("Error decoding in GOB");
 
-      gst_rtp_h263_pay_mb_destroy (mac0);
       goto decode_error;
     }
 
-    gst_rtp_h263_pay_mb_destroy (gob->macroblocks[mb]);
     gob->macroblocks[mb] = mac;
 
     //If mb_type == stuffing, don't increment the mb address
@@ -1546,7 +1545,6 @@
         mac->mba, mac->start, mac->end, mac->length, mac->sbit, mac->ebit);
     GST_LOG ("================ END MB %d =================", mb);
   }
-  gst_rtp_h263_pay_mb_destroy (mac0);
 
   mb = 0;
   first = 0;
@@ -1689,8 +1687,8 @@
 
     gst_rtp_h263_pay_boundry_init (&bound, NULL, rtph263pay->data - 1, 0, 0);
     context->gobs =
-        (GstRtpH263PayGob **) g_malloc0 (format_props[context->piclayer->
-            ptype_srcformat][0] * sizeof (GstRtpH263PayGob *));
+        (GstRtpH263PayGob **) g_malloc0 (format_props[context->
+            piclayer->ptype_srcformat][0] * sizeof (GstRtpH263PayGob *));
 
 
     for (i = 0; i < format_props[context->piclayer->ptype_srcformat][0]; i++) {
diff --git a/gst/rtp/gstrtph264depay.c b/gst/rtp/gstrtph264depay.c
index 430650e..056724c 100644
--- a/gst/rtp/gstrtph264depay.c
+++ b/gst/rtp/gstrtph264depay.c
@@ -1055,12 +1055,8 @@
         }
 
         outsize = gst_adapter_available (rtph264depay->adapter);
-        if (outsize > 0) {
+        if (outsize > 0)
           outbuf = gst_adapter_take_buffer (rtph264depay->adapter, outsize);
-          outbuf =
-              gst_rtp_h264_depay_handle_nal (rtph264depay, outbuf, timestamp,
-              marker);
-        }
         break;
       }
       case 26:
diff --git a/gst/rtp/gstrtph265depay.c b/gst/rtp/gstrtph265depay.c
index 97353af..f0dcb4b 100644
--- a/gst/rtp/gstrtph265depay.c
+++ b/gst/rtp/gstrtph265depay.c
@@ -1256,12 +1256,8 @@
         }
 
         outsize = gst_adapter_available (rtph265depay->adapter);
-        if (outsize > 0) {
+        if (outsize > 0)
           outbuf = gst_adapter_take_buffer (rtph265depay->adapter, outsize);
-          outbuf =
-              gst_rtp_h265_depay_handle_nal (rtph265depay, outbuf, timestamp,
-              marker);
-        }
         break;
       }
       case 49:
diff --git a/gst/rtp/gstrtpmp4adepay.c b/gst/rtp/gstrtpmp4adepay.c
index 0f50523..5a5f341 100644
--- a/gst/rtp/gstrtpmp4adepay.c
+++ b/gst/rtp/gstrtpmp4adepay.c
@@ -37,7 +37,7 @@
     GST_PAD_SRC,
     GST_PAD_ALWAYS,
     GST_STATIC_CAPS ("audio/mpeg,"
-        "mpegversion = (int) 4," "framed = (boolean) true, "
+        "mpegversion = (int) 4," "framed = (boolean) { false, true }, "
         "stream-format = (string) raw")
     );
 
@@ -109,6 +109,7 @@
 gst_rtp_mp4a_depay_init (GstRtpMP4ADepay * rtpmp4adepay)
 {
   rtpmp4adepay->adapter = gst_adapter_new ();
+  rtpmp4adepay->framed = FALSE;
 }
 
 static void
@@ -142,6 +143,8 @@
 
   rtpmp4adepay = GST_RTP_MP4A_DEPAY (depayload);
 
+  rtpmp4adepay->framed = FALSE;
+
   structure = gst_caps_get_structure (caps, 0);
 
   if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
@@ -153,7 +156,7 @@
 
   srccaps = gst_caps_new_simple ("audio/mpeg",
       "mpegversion", G_TYPE_INT, 4,
-      "framed", G_TYPE_BOOLEAN, TRUE, "channels", G_TYPE_INT, channels,
+      "framed", G_TYPE_BOOLEAN, FALSE, "channels", G_TYPE_INT, channels,
       "stream-format", G_TYPE_STRING, "raw", NULL);
 
   if ((str = gst_structure_get_string (structure, "config"))) {
@@ -310,6 +313,25 @@
 
   outbuf = gst_rtp_buffer_get_payload_buffer (rtp);
 
+  if (!rtpmp4adepay->framed) {
+    if (gst_rtp_buffer_get_marker (rtp)) {
+      GstCaps *caps;
+
+      rtpmp4adepay->framed = TRUE;
+
+      gst_rtp_base_depayload_push (depayload, outbuf);
+
+      caps = gst_pad_get_current_caps (depayload->srcpad);
+      caps = gst_caps_make_writable (caps);
+      gst_caps_set_simple (caps, "framed", G_TYPE_BOOLEAN, TRUE, NULL);
+      gst_pad_set_caps (depayload->srcpad, caps);
+      gst_caps_unref (caps);
+      return NULL;
+    } else {
+      return outbuf;
+    }
+  }
+
   outbuf = gst_buffer_make_writable (outbuf);
   GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (rtp->buffer);
   gst_adapter_push (rtpmp4adepay->adapter, outbuf);
@@ -422,6 +444,7 @@
       gst_adapter_clear (rtpmp4adepay->adapter);
       rtpmp4adepay->frame_len = 0;
       rtpmp4adepay->numSubFrames = 0;
+      rtpmp4adepay->framed = FALSE;
       break;
     default:
       break;
diff --git a/gst/rtp/gstrtpmp4adepay.h b/gst/rtp/gstrtpmp4adepay.h
index b44349f..31eaf56 100644
--- a/gst/rtp/gstrtpmp4adepay.h
+++ b/gst/rtp/gstrtpmp4adepay.h
@@ -45,6 +45,8 @@
   GstAdapter *adapter;
   guint8 numSubFrames;
   guint frame_len;
+
+  gboolean framed;
 };
 
 struct _GstRtpMP4ADepayClass
diff --git a/gst/rtp/gstrtpsbcpay.c b/gst/rtp/gstrtpsbcpay.c
index dc3d860..794a817 100644
--- a/gst/rtp/gstrtpsbcpay.c
+++ b/gst/rtp/gstrtpsbcpay.c
@@ -157,6 +157,8 @@
       bitpool, channel_mode);
 
   sbcpay->frame_length = frame_len;
+  sbcpay->frame_duration = ((blocks * subbands) * GST_SECOND) / rate;
+  sbcpay->last_timestamp = GST_CLOCK_TIME_NONE;
 
   gst_rtp_base_payload_set_options (payload, "audio", TRUE, "SBC", rate);
 
@@ -214,9 +216,12 @@
       g_quark_from_static_string (GST_META_TAG_AUDIO_STR));
   outbuf = gst_buffer_append (outbuf, paybuf);
 
-  /* FIXME: what about duration? */
-  GST_BUFFER_PTS (outbuf) = sbcpay->timestamp;
-  GST_DEBUG_OBJECT (sbcpay, "Pushing %d bytes", payload_length);
+  GST_BUFFER_PTS (outbuf) = sbcpay->last_timestamp;
+  GST_BUFFER_DURATION (outbuf) = frame_count * sbcpay->frame_duration;
+  GST_DEBUG_OBJECT (sbcpay, "Pushing %d bytes: %" GST_TIME_FORMAT,
+      payload_length, GST_TIME_ARGS (GST_BUFFER_PTS (outbuf)));
+
+  sbcpay->last_timestamp += frame_count * sbcpay->frame_duration;
 
   return gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (sbcpay), outbuf);
 }
@@ -230,7 +235,19 @@
   /* FIXME check for negotiation */
 
   sbcpay = GST_RTP_SBC_PAY (payload);
-  sbcpay->timestamp = GST_BUFFER_PTS (buffer);
+
+  if (GST_BUFFER_IS_DISCONT (buffer)) {
+    /* Try to flush whatever's left */
+    gst_rtp_sbc_pay_flush_buffers (sbcpay);
+    /* Drop the rest */
+    gst_adapter_flush (sbcpay->adapter,
+        gst_adapter_available (sbcpay->adapter));
+    /* Reset timestamps */
+    sbcpay->last_timestamp = GST_CLOCK_TIME_NONE;
+  }
+
+  if (sbcpay->last_timestamp == GST_CLOCK_TIME_NONE)
+    sbcpay->last_timestamp = GST_BUFFER_PTS (buffer);
 
   gst_adapter_push (sbcpay->adapter, buffer);
 
@@ -347,7 +364,7 @@
 {
   self->adapter = gst_adapter_new ();
   self->frame_length = 0;
-  self->timestamp = 0;
+  self->last_timestamp = GST_CLOCK_TIME_NONE;
 
   self->min_frames = DEFAULT_MIN_FRAMES;
 }
diff --git a/gst/rtp/gstrtpsbcpay.h b/gst/rtp/gstrtpsbcpay.h
index 42cf02e..76ee66d 100644
--- a/gst/rtp/gstrtpsbcpay.h
+++ b/gst/rtp/gstrtpsbcpay.h
@@ -46,9 +46,10 @@
 	GstRTPBasePayload base;
 
 	GstAdapter *adapter;
-	GstClockTime timestamp;
+	GstClockTime last_timestamp;
 
 	guint frame_length;
+        GstClockTime frame_duration;
 
 	guint min_frames;
 };
diff --git a/gst/rtpmanager/gstrtpjitterbuffer.c b/gst/rtpmanager/gstrtpjitterbuffer.c
index 1fc313b..e1c315c 100644
--- a/gst/rtpmanager/gstrtpjitterbuffer.c
+++ b/gst/rtpmanager/gstrtpjitterbuffer.c
@@ -7,6 +7,9 @@
  *  Copyright 2007 Wim Taymans <wim.taymans@gmail.com>
  *  Copyright 2015 Kurento (http://kurento.org/)
  *   @author: Miguel París <mparisdiaz@gmail.com>
+ *  Copyright 2016 Pexip AS
+ *   @author: Havard Graff <havard@pexip.com>
+ *   @author: Stian Selnes <stian@pexip.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -140,6 +143,8 @@
 #define DEFAULT_RTX_MIN_RETRY_TIMEOUT   -1
 #define DEFAULT_RTX_RETRY_PERIOD    -1
 #define DEFAULT_RTX_MAX_RETRIES    -1
+#define DEFAULT_RTX_DEADLINE       -1
+#define DEFAULT_RTX_STATS_TIMEOUT   1000
 #define DEFAULT_MAX_RTCP_RTP_TIME_DIFF 1000
 #define DEFAULT_MAX_DROPOUT_TIME    60000
 #define DEFAULT_MAX_MISORDER_TIME   2000
@@ -166,6 +171,8 @@
   PROP_RTX_MIN_RETRY_TIMEOUT,
   PROP_RTX_RETRY_PERIOD,
   PROP_RTX_MAX_RETRIES,
+  PROP_RTX_DEADLINE,
+  PROP_RTX_STATS_TIMEOUT,
   PROP_STATS,
   PROP_MAX_RTCP_RTP_TIME_DIFF,
   PROP_MAX_DROPOUT_TIME,
@@ -236,6 +243,14 @@
   }                                                      \
 } G_STMT_END
 
+#define GST_BUFFER_IS_RETRANSMISSION(buffer) \
+  GST_BUFFER_FLAG_IS_SET (buffer, GST_RTP_BUFFER_FLAG_RETRANSMISSION)
+
+typedef struct TimerQueue
+{
+  GQueue *timers;
+  GHashTable *hashtable;
+} TimerQueue;
 
 struct _GstRtpJitterBufferPrivate
 {
@@ -274,6 +289,8 @@
   gint rtx_min_retry_timeout;
   gint rtx_retry_period;
   gint rtx_max_retries;
+  guint rtx_stats_timeout;
+  gint rtx_deadline_ms;
   gint max_rtcp_rtp_time_diff;
   guint32 max_dropout_time;
   guint32 max_misorder_time;
@@ -290,6 +307,7 @@
   GstClockTime ips_dts;
   guint64 ips_rtptime;
   GstClockTime packet_spacing;
+  gint equidistant;
 
   GQueue gap_packets;
 
@@ -298,6 +316,7 @@
   guint32 next_in_seqnum;
 
   GArray *timers;
+  TimerQueue *rtx_stats_timers;
 
   /* start and stop ranges */
   GstClockTime npt_start;
@@ -333,6 +352,8 @@
   GstBuffer *last_sr;
 
   /* some accounting */
+  guint64 num_pushed;
+  guint64 num_lost;
   guint64 num_late;
   guint64 num_duplicates;
   guint64 num_rtx_requests;
@@ -369,6 +390,7 @@
   GstClockTime rtx_retry;
   GstClockTime rtx_last;
   guint num_rtx_retry;
+  guint num_rtx_received;
 } TimerData;
 
 #define GST_RTP_JITTER_BUFFER_GET_PRIVATE(o) \
@@ -470,6 +492,12 @@
 static GstStructure *gst_rtp_jitter_buffer_create_stats (GstRtpJitterBuffer *
     jitterbuffer);
 
+static void update_rtx_stats (GstRtpJitterBuffer * jitterbuffer,
+    TimerData * timer, GstClockTime dts, gboolean success);
+
+static TimerQueue *timer_queue_new (void);
+static void timer_queue_free (TimerQueue * queue);
+
 static void
 gst_rtp_jitter_buffer_class_init (GstRtpJitterBufferClass * klass)
 {
@@ -614,13 +642,15 @@
    * this much packet reordering.
    *
    * When -1 is used, the value will be estimated based on observed packet
-   * reordering.
+   * reordering. When 0 is used packet reordering alone will not cause a
+   * retransmission event (Since 1.10).
    *
    * Since: 1.2
    */
   g_object_class_install_property (gobject_class, PROP_RTX_DELAY_REORDER,
       g_param_spec_int ("rtx-delay-reorder", "RTX Delay Reorder",
-          "Sending retransmission event when this much reordering (-1 automatic)",
+          "Sending retransmission event when this much reordering "
+          "(0 disable, -1 automatic)",
           -1, G_MAXINT, DEFAULT_RTX_DELAY_REORDER,
           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   /**
@@ -686,6 +716,35 @@
           "The maximum number of retries to request a retransmission. "
           "(-1 not limited)", -1, G_MAXINT, DEFAULT_RTX_MAX_RETRIES,
           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  /**
+   * GstRtpJitterBuffer:rtx-deadline:
+   *
+   * The deadline for a valid RTX request in ms.
+   *
+   * How long the RTX RTCP will be valid for.
+   * When -1 is used, the size of the jitterbuffer will be used.
+   *
+   * Since: 1.10
+   */
+  g_object_class_install_property (gobject_class, PROP_RTX_DEADLINE,
+      g_param_spec_int ("rtx-deadline", "RTX Deadline (ms)",
+          "The deadline for a valid RTX request in milliseconds. "
+          "(-1 automatic)", -1, G_MAXINT, DEFAULT_RTX_DEADLINE,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+/**
+   * GstRtpJitterBuffer::rtx-stats-timeout:
+   *
+   * The time to wait for a retransmitted packet after it has been
+   * considered lost in order to collect RTX statistics.
+   *
+   * Since: 1.10
+   */
+  g_object_class_install_property (gobject_class, PROP_RTX_STATS_TIMEOUT,
+      g_param_spec_uint ("rtx-stats-timeout", "RTX Statistics Timeout",
+          "The time to wait for a retransmitted packet after it has been "
+          "considered lost in order to collect statistics (ms)",
+          0, G_MAXUINT, DEFAULT_RTX_STATS_TIMEOUT,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
   g_object_class_install_property (gobject_class, PROP_MAX_DROPOUT_TIME,
       g_param_spec_uint ("max-dropout-time", "Max dropout time",
@@ -708,6 +767,34 @@
    * <listitem>
    *   <para>
    *   #guint64
+   *   <classname>&quot;num-pushed&quot;</classname>:
+   *   the number of packets pushed out.
+   *   </para>
+   * </listitem>
+   * <listitem>
+   *   <para>
+   *   #guint64
+   *   <classname>&quot;num-lost&quot;</classname>:
+   *   the number of packets considered lost.
+   *   </para>
+   * </listitem>
+   * <listitem>
+   *   <para>
+   *   #guint64
+   *   <classname>&quot;num-late&quot;</classname>:
+   *   the number of packets arriving too late.
+   *   </para>
+   * </listitem>
+   * <listitem>
+   *   <para>
+   *   #guint64
+   *   <classname>&quot;num-duplicates&quot;</classname>:
+   *   the number of duplicate packets.
+   *   </para>
+   * </listitem>
+   * <listitem>
+   *   <para>
+   *   #guint64
    *   <classname>&quot;rtx-count&quot;</classname>:
    *   the number of retransmissions requested.
    *   </para>
@@ -883,6 +970,8 @@
   priv->rtx_min_retry_timeout = DEFAULT_RTX_MIN_RETRY_TIMEOUT;
   priv->rtx_retry_period = DEFAULT_RTX_RETRY_PERIOD;
   priv->rtx_max_retries = DEFAULT_RTX_MAX_RETRIES;
+  priv->rtx_deadline_ms = DEFAULT_RTX_DEADLINE;
+  priv->rtx_stats_timeout = DEFAULT_RTX_STATS_TIMEOUT;
   priv->max_rtcp_rtp_time_diff = DEFAULT_MAX_RTCP_RTP_TIME_DIFF;
   priv->max_dropout_time = DEFAULT_MAX_DROPOUT_TIME;
   priv->max_misorder_time = DEFAULT_MAX_MISORDER_TIME;
@@ -891,6 +980,7 @@
   priv->last_rtptime = -1;
   priv->avg_jitter = 0;
   priv->timers = g_array_new (FALSE, TRUE, sizeof (TimerData));
+  priv->rtx_stats_timers = timer_queue_new ();
   priv->jbuf = rtp_jitter_buffer_new ();
   g_mutex_init (&priv->jbuf_lock);
   g_cond_init (&priv->jbuf_timer);
@@ -994,6 +1084,7 @@
   priv = jitterbuffer->priv;
 
   g_array_free (priv->timers, TRUE);
+  timer_queue_free (priv->rtx_stats_timers);
   g_mutex_clear (&priv->jbuf_lock);
   g_cond_clear (&priv->jbuf_timer);
   g_cond_clear (&priv->jbuf_event);
@@ -1476,6 +1567,7 @@
   priv->last_dts = -1;
   priv->last_rtptime = -1;
   priv->last_in_dts = 0;
+  priv->equidistant = 0;
   GST_DEBUG_OBJECT (jitterbuffer, "flush and reset jitterbuffer");
   rtp_jitter_buffer_flush (priv->jbuf, (GFunc) free_item, NULL);
   rtp_jitter_buffer_disable_buffering (priv->jbuf, FALSE);
@@ -1895,8 +1987,70 @@
   return timestamp;
 }
 
+static TimerQueue *
+timer_queue_new (void)
+{
+  TimerQueue *queue;
+
+  queue = g_slice_new (TimerQueue);
+  queue->timers = g_queue_new ();
+  queue->hashtable = g_hash_table_new (NULL, NULL);
+
+  return queue;
+}
+
+static void
+timer_queue_free (TimerQueue * queue)
+{
+  if (!queue)
+    return;
+
+  g_hash_table_destroy (queue->hashtable);
+  g_queue_free_full (queue->timers, g_free);
+  g_slice_free (TimerQueue, queue);
+}
+
+static void
+timer_queue_append (TimerQueue * queue, const TimerData * timer,
+    GstClockTime timeout, gboolean lost)
+{
+  TimerData *copy;
+
+  copy = g_memdup (timer, sizeof (*timer));
+  copy->timeout = timeout;
+  copy->type = lost ? TIMER_TYPE_LOST : TIMER_TYPE_EXPECTED;
+  copy->idx = -1;
+
+  GST_LOG ("Append rtx-stats timer #%d, %" GST_TIME_FORMAT,
+      copy->seqnum, GST_TIME_ARGS (copy->timeout));
+  g_queue_push_tail (queue->timers, copy);
+  g_hash_table_insert (queue->hashtable, GINT_TO_POINTER (copy->seqnum), copy);
+}
+
+static void
+timer_queue_clear_until (TimerQueue * queue, GstClockTime timeout)
+{
+  TimerData *test;
+
+  test = g_queue_peek_head (queue->timers);
+  while (test && test->timeout < timeout) {
+    GST_LOG ("Pop rtx-stats timer #%d, %" GST_TIME_FORMAT " < %"
+        GST_TIME_FORMAT, test->seqnum, GST_TIME_ARGS (test->timeout),
+        GST_TIME_ARGS (timeout));
+    g_hash_table_remove (queue->hashtable, GINT_TO_POINTER (test->seqnum));
+    g_free (g_queue_pop_head (queue->timers));
+    test = g_queue_peek_head (queue->timers);
+  }
+}
+
 static TimerData *
-find_timer (GstRtpJitterBuffer * jitterbuffer, TimerType type, guint16 seqnum)
+timer_queue_find (TimerQueue * queue, guint16 seqnum)
+{
+  return g_hash_table_lookup (queue->hashtable, GINT_TO_POINTER (seqnum));
+}
+
+static TimerData *
+find_timer (GstRtpJitterBuffer * jitterbuffer, guint16 seqnum)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
   TimerData *timer = NULL;
@@ -1905,7 +2059,7 @@
   len = priv->timers->len;
   for (i = 0; i < len; i++) {
     TimerData *test = &g_array_index (priv->timers, TimerData, i);
-    if (test->seqnum == seqnum && test->type == type) {
+    if (test->seqnum == seqnum) {
       timer = test;
       break;
     }
@@ -1986,7 +2140,9 @@
     timer->rtx_delay = delay;
     timer->rtx_retry = 0;
   }
+  timer->rtx_last = GST_CLOCK_TIME_NONE;
   timer->num_rtx_retry = 0;
+  timer->num_rtx_received = 0;
   recalculate_timer (jitterbuffer, timer);
   JBUF_SIGNAL_TIMER (priv);
 
@@ -2010,18 +2166,24 @@
   oldseq = timer->seqnum;
 
   GST_DEBUG_OBJECT (jitterbuffer,
-      "replace timer for seqnum %d->%d to %" GST_TIME_FORMAT,
-      oldseq, seqnum, GST_TIME_ARGS (timeout + delay));
+      "replace timer %d for seqnum %d->%d timeout %" GST_TIME_FORMAT
+      "->%" GST_TIME_FORMAT, timer->type, oldseq, seqnum,
+      GST_TIME_ARGS (timer->timeout), GST_TIME_ARGS (timeout + delay));
 
   timer->timeout = timeout + delay;
   timer->seqnum = seqnum;
   if (reset) {
+    GST_DEBUG_OBJECT (jitterbuffer, "reset rtx delay %" GST_TIME_FORMAT
+        "->%" GST_TIME_FORMAT, GST_TIME_ARGS (timer->rtx_delay),
+        GST_TIME_ARGS (delay));
     timer->rtx_base = timeout;
     timer->rtx_delay = delay;
     timer->rtx_retry = 0;
   }
-  if (seqchange)
+  if (seqchange) {
     timer->num_rtx_retry = 0;
+    timer->num_rtx_received = 0;
+  }
 
   if (priv->clock_id) {
     /* we changed the seqnum and there is a timer currently waiting with this
@@ -2042,7 +2204,7 @@
   TimerData *timer;
 
   /* find the seqnum timer */
-  timer = find_timer (jitterbuffer, type, seqnum);
+  timer = find_timer (jitterbuffer, seqnum);
   if (timer == NULL) {
     timer = add_timer (jitterbuffer, type, seqnum, 0, timeout, 0, -1);
   } else {
@@ -2057,6 +2219,9 @@
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
   guint idx;
 
+  if (timer->idx == -1)
+    return;
+
   if (priv->clock_id && priv->timer_seqnum == timer->seqnum)
     unschedule_current_timer (jitterbuffer);
 
@@ -2134,37 +2299,30 @@
  */
 static void
 update_timers (GstRtpJitterBuffer * jitterbuffer, guint16 seqnum,
-    GstClockTime dts, gboolean do_next_seqnum)
+    GstClockTime dts, gboolean do_next_seqnum, gboolean is_rtx,
+    TimerData * timer)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
-  TimerData *timer = NULL;
-  gint i, len;
 
-  /* go through all timers and unschedule the ones with a large gap, also find
-   * the timer for the seqnum */
-  len = priv->timers->len;
-  for (i = 0; i < len; i++) {
-    TimerData *test = &g_array_index (priv->timers, TimerData, i);
-    gint gap;
+  /* go through all timers and unschedule the ones with a large gap */
+  if (priv->do_retransmission && priv->rtx_delay_reorder > 0) {
+    gint i, len;
+    len = priv->timers->len;
+    for (i = 0; i < len; i++) {
+      TimerData *test = &g_array_index (priv->timers, TimerData, i);
+      gint gap;
 
-    gap = gst_rtp_buffer_compare_seqnum (test->seqnum, seqnum);
+      gap = gst_rtp_buffer_compare_seqnum (test->seqnum, seqnum);
 
-    GST_DEBUG_OBJECT (jitterbuffer, "%d, %d, #%d<->#%d gap %d", i,
-        test->type, test->seqnum, seqnum, gap);
+      GST_DEBUG_OBJECT (jitterbuffer, "%d, #%d<->#%d gap %d",
+          test->type, test->seqnum, seqnum, gap);
 
-    if (gap == 0) {
-      GST_DEBUG ("found timer for current seqnum");
-      /* the timer for the current seqnum */
-      timer = test;
-      /* when no retransmission, we can stop now, we only need to find the
-       * timer for the current seqnum */
-      if (!priv->do_retransmission)
-        break;
-    } else if (gap > priv->rtx_delay_reorder) {
-      /* max gap, we exceeded the max reorder distance and we don't expect the
-       * missing packet to be this reordered */
-      if (test->num_rtx_retry == 0 && test->type == TIMER_TYPE_EXPECTED)
-        reschedule_timer (jitterbuffer, test, test->seqnum, -1, 0, FALSE);
+      if (gap > priv->rtx_delay_reorder) {
+        /* max gap, we exceeded the max reorder distance and we don't expect the
+         * missing packet to be this reordered */
+        if (test->num_rtx_retry == 0 && test->type == TIMER_TYPE_EXPECTED)
+          reschedule_timer (jitterbuffer, test, test->seqnum, -1, 0, FALSE);
+      }
     }
   }
 
@@ -2173,43 +2331,23 @@
 
   if (timer && timer->type != TIMER_TYPE_DEADLINE) {
     if (timer->num_rtx_retry > 0) {
-      GstClockTime rtx_last, delay;
+      if (is_rtx) {
+        update_rtx_stats (jitterbuffer, timer, dts, TRUE);
+        /* don't try to estimate the next seqnum because this is a retransmitted
+         * packet and it probably did not arrive with the expected packet
+         * spacing. */
+        do_next_seqnum = FALSE;
+      }
 
-      /* we scheduled a retry for this packet and now we have it */
-      priv->num_rtx_success++;
-      /* all the previous retry attempts failed */
-      priv->num_rtx_failed += timer->num_rtx_retry - 1;
-      /* number of retries before receiving the packet */
-      if (priv->avg_rtx_num == 0.0)
-        priv->avg_rtx_num = timer->num_rtx_retry;
-      else
-        priv->avg_rtx_num = (timer->num_rtx_retry + 7 * priv->avg_rtx_num) / 8;
-      /* calculate the delay between retransmission request and receiving this
-       * packet, start with when we scheduled this timeout last */
-      rtx_last = timer->rtx_last;
-      if (dts != GST_CLOCK_TIME_NONE && dts > rtx_last) {
-        /* we have a valid delay if this packet arrived after we scheduled the
-         * request */
-        delay = dts - rtx_last;
-        if (priv->avg_rtx_rtt == 0)
-          priv->avg_rtx_rtt = delay;
-        else
-          priv->avg_rtx_rtt = (delay + 7 * priv->avg_rtx_rtt) / 8;
-      } else
-        delay = 0;
-
-      GST_LOG_OBJECT (jitterbuffer,
-          "RTX success %" G_GUINT64_FORMAT ", failed %" G_GUINT64_FORMAT
-          ", requests %" G_GUINT64_FORMAT ", dups %" G_GUINT64_FORMAT
-          ", avg-num %g, delay %" GST_TIME_FORMAT ", avg-rtt %" GST_TIME_FORMAT,
-          priv->num_rtx_success, priv->num_rtx_failed, priv->num_rtx_requests,
-          priv->num_duplicates, priv->avg_rtx_num, GST_TIME_ARGS (delay),
-          GST_TIME_ARGS (priv->avg_rtx_rtt));
-
-      /* don't try to estimate the next seqnum because this is a retransmitted
-       * packet and it probably did not arrive with the expected packet
-       * spacing. */
-      do_next_seqnum = FALSE;
+      if (!is_rtx || timer->num_rtx_retry > 1) {
+        /* Store timer in order to record stats when/if the retransmitted
+         * packet arrives. We should also store timer information if we've
+         * requested retransmission more than once since we may receive
+         * several retransmitted packets. For accuracy we should update the
+         * stats also when the redundant retransmitted packets arrives. */
+        timer_queue_append (priv->rtx_stats_timers, timer,
+            dts + priv->rtx_stats_timeout * GST_MSECOND, FALSE);
+      }
     }
   }
 
@@ -2222,6 +2360,12 @@
     delay = get_rtx_delay (priv);
 
     /* and update/install timer for next seqnum */
+    GST_DEBUG_OBJECT (jitterbuffer, "Add RTX timer #%d, expected %"
+        GST_TIME_FORMAT ", delay %" GST_TIME_FORMAT ", packet-spacing %"
+        GST_TIME_FORMAT ", jitter %" GST_TIME_FORMAT, priv->next_in_seqnum,
+        GST_TIME_ARGS (expected), GST_TIME_ARGS (delay),
+        GST_TIME_ARGS (priv->packet_spacing), GST_TIME_ARGS (priv->avg_jitter));
+
     if (timer) {
       reschedule_timer (jitterbuffer, timer, priv->next_in_seqnum, expected,
           delay, TRUE);
@@ -2281,8 +2425,9 @@
     guint16 seqnum, GstClockTime dts, gint gap)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
-  GstClockTime total_duration, duration, expected_dts;
+  GstClockTime duration, expected_dts, delay;
   TimerType type;
+  gboolean equidistant = priv->equidistant > 0;
 
   GST_DEBUG_OBJECT (jitterbuffer,
       "dts %" GST_TIME_FORMAT ", last %" GST_TIME_FORMAT,
@@ -2293,68 +2438,80 @@
     return;
   }
 
-  /* the total duration spanned by the missing packets */
-  if (dts >= priv->last_in_dts)
-    total_duration = dts - priv->last_in_dts;
-  else
-    total_duration = 0;
+  if (equidistant) {
+    GstClockTime total_duration;
+    /* the total duration spanned by the missing packets */
+    if (dts >= priv->last_in_dts)
+      total_duration = dts - priv->last_in_dts;
+    else
+      total_duration = 0;
 
-  /* interpolate between the current time and the last time based on
-   * number of packets we are missing, this is the estimated duration
-   * for the missing packet based on equidistant packet spacing. */
-  duration = total_duration / (gap + 1);
+    /* interpolate between the current time and the last time based on
+     * number of packets we are missing, this is the estimated duration
+     * for the missing packet based on equidistant packet spacing. */
+    duration = total_duration / (gap + 1);
 
-  GST_DEBUG_OBJECT (jitterbuffer, "duration %" GST_TIME_FORMAT,
-      GST_TIME_ARGS (duration));
+    GST_DEBUG_OBJECT (jitterbuffer, "duration %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (duration));
 
-  if (total_duration > priv->latency_ns) {
-    GstClockTime gap_time;
-    guint lost_packets;
+    if (total_duration > priv->latency_ns) {
+      GstClockTime gap_time;
+      guint lost_packets;
 
-    if (duration > 0) {
-      GstClockTime gap_dur = gap * duration;
-      if (gap_dur > priv->latency_ns)
-        gap_time = gap_dur - priv->latency_ns;
-      else
-        gap_time = 0;
-      lost_packets = gap_time / duration;
-    } else {
-      gap_time = total_duration - priv->latency_ns;
-      lost_packets = gap;
+      if (duration > 0) {
+        GstClockTime gap_dur = gap * duration;
+        if (gap_dur > priv->latency_ns)
+          gap_time = gap_dur - priv->latency_ns;
+        else
+          gap_time = 0;
+        lost_packets = gap_time / duration;
+      } else {
+        gap_time = total_duration - priv->latency_ns;
+        lost_packets = gap;
+      }
+
+      /* too many lost packets, some of the missing packets are already
+       * too late and we can generate lost packet events for them. */
+      GST_INFO_OBJECT (jitterbuffer,
+          "lost packets (%d, #%d->#%d) duration too large %" GST_TIME_FORMAT
+          " > %" GST_TIME_FORMAT ", consider %u lost (%" GST_TIME_FORMAT ")",
+          gap, expected, seqnum - 1, GST_TIME_ARGS (total_duration),
+          GST_TIME_ARGS (priv->latency_ns), lost_packets,
+          GST_TIME_ARGS (gap_time));
+
+      /* this timer will fire immediately and the lost event will be pushed from
+       * the timer thread */
+      if (lost_packets > 0) {
+        add_timer (jitterbuffer, TIMER_TYPE_LOST, expected, lost_packets,
+            priv->last_in_dts + duration, 0, gap_time);
+        expected += lost_packets;
+        priv->last_in_dts += gap_time;
+      }
     }
 
-    /* too many lost packets, some of the missing packets are already
-     * too late and we can generate lost packet events for them. */
-    GST_DEBUG_OBJECT (jitterbuffer,
-        "lost packets (%d, #%d->#%d) duration too large %" GST_TIME_FORMAT
-        " > %" GST_TIME_FORMAT ", consider %u lost (%" GST_TIME_FORMAT ")",
-        gap, expected, seqnum - 1, GST_TIME_ARGS (total_duration),
-        GST_TIME_ARGS (priv->latency_ns), lost_packets,
-        GST_TIME_ARGS (gap_time));
-
-    /* this timer will fire immediately and the lost event will be pushed from
-     * the timer thread */
-    if (lost_packets > 0) {
-      add_timer (jitterbuffer, TIMER_TYPE_LOST, expected, lost_packets,
-          priv->last_in_dts + duration, 0, gap_time);
-      expected += lost_packets;
-      priv->last_in_dts += gap_time;
-    }
+    expected_dts = priv->last_in_dts + duration;
+  } else {
+    /* If we cannot assume equidistant packet spacing, the only thing we now
+     * for sure is that the missing packets have expected dts not later than
+     * the last received dts. */
+    duration = 0;
+    expected_dts = dts;
   }
 
-  expected_dts = priv->last_in_dts + duration;
+  delay = 0;
 
   if (priv->do_retransmission) {
-    TimerData *timer;
+    TimerData *timer = find_timer (jitterbuffer, expected);
 
     type = TIMER_TYPE_EXPECTED;
+    delay = get_rtx_delay (priv);
+
     /* if we had a timer for the first missing packet, update it. */
-    if ((timer = find_timer (jitterbuffer, type, expected))) {
+    if (timer && timer->type == TIMER_TYPE_EXPECTED) {
       GstClockTime timeout = timer->timeout;
 
       timer->duration = duration;
-      if (timeout > (expected_dts + timer->rtx_retry)) {
-        GstClockTime delay = timeout - expected_dts - timer->rtx_retry;
+      if (timeout > (expected_dts + delay) && timer->num_rtx_retry == 0) {
         reschedule_timer (jitterbuffer, timer, timer->seqnum, expected_dts,
             delay, TRUE);
       }
@@ -2366,7 +2523,7 @@
   }
 
   while (gst_rtp_buffer_compare_seqnum (expected, seqnum) > 0) {
-    add_timer (jitterbuffer, type, expected, 0, expected_dts, 0, duration);
+    add_timer (jitterbuffer, type, expected, 0, expected_dts, delay, duration);
     expected_dts += duration;
     expected++;
   }
@@ -2374,7 +2531,7 @@
 
 static void
 calculate_jitter (GstRtpJitterBuffer * jitterbuffer, GstClockTime dts,
-    guint rtptime)
+    guint32 rtptime)
 {
   gint32 rtpdiff;
   GstClockTimeDiff dtsdiff, rtpdiffns, diff;
@@ -2395,6 +2552,15 @@
   else
     rtpdiff = 0;
 
+  /* Guess whether stream currently uses equidistant packet spacing. If we
+   * often see identical timestamps it means the packets are not
+   * equidistant. */
+  if (rtptime == priv->last_rtptime)
+    priv->equidistant -= 2;
+  else
+    priv->equidistant += 1;
+  priv->equidistant = CLAMP (priv->equidistant, -7, 7);
+
   priv->last_dts = dts;
   priv->last_rtptime = rtptime;
 
@@ -2560,6 +2726,7 @@
   GstMessage *msg = NULL;
   gboolean estimated_dts = FALSE;
   guint32 packet_rate, max_dropout, max_misorder;
+  TimerData *timer = NULL;
 
   jitterbuffer = GST_RTP_JITTER_BUFFER_CAST (parent);
 
@@ -2603,8 +2770,9 @@
   }
 
   GST_DEBUG_OBJECT (jitterbuffer,
-      "Received packet #%d at time %" GST_TIME_FORMAT ", discont %d", seqnum,
-      GST_TIME_ARGS (dts), GST_BUFFER_IS_DISCONT (buffer));
+      "Received packet #%d at time %" GST_TIME_FORMAT ", discont %d, rtx %d",
+      seqnum, GST_TIME_ARGS (dts), GST_BUFFER_IS_DISCONT (buffer),
+      GST_BUFFER_IS_RETRANSMISSION (buffer));
 
   JBUF_LOCK_CHECK (priv, out_flushing);
 
@@ -2642,7 +2810,8 @@
   if (G_UNLIKELY (priv->eos))
     goto have_eos;
 
-  calculate_jitter (jitterbuffer, dts, rtptime);
+  if (!GST_BUFFER_IS_RETRANSMISSION (buffer))
+    calculate_jitter (jitterbuffer, dts, rtptime);
 
   if (priv->seqnum_base != -1) {
     gint gap;
@@ -2832,6 +3001,14 @@
     priv->next_in_seqnum = (seqnum + 1) & 0xffff;
   }
 
+  timer = find_timer (jitterbuffer, seqnum);
+  if (GST_BUFFER_IS_RETRANSMISSION (buffer)) {
+    if (!timer)
+      timer = timer_queue_find (priv->rtx_stats_timers, seqnum);
+    if (timer)
+      timer->num_rtx_received++;
+  }
+
   /* let's check if this buffer is too late, we can only accept packets with
    * bigger seqnum than the one we last pushed. */
   if (G_LIKELY (priv->last_popped_seqnum != -1)) {
@@ -2840,8 +3017,19 @@
     gap = gst_rtp_buffer_compare_seqnum (priv->last_popped_seqnum, seqnum);
 
     /* priv->last_popped_seqnum >= seqnum, we're too late. */
-    if (G_UNLIKELY (gap <= 0))
+    if (G_UNLIKELY (gap <= 0)) {
+      if (priv->do_retransmission) {
+        if (GST_BUFFER_IS_RETRANSMISSION (buffer) && timer) {
+          update_rtx_stats (jitterbuffer, timer, dts, FALSE);
+          /* Only count the retranmitted packet too late if it has been
+           * considered lost. If the original packet arrived before the
+           * retransmitted we just count it as a duplicate. */
+          if (timer->type != TIMER_TYPE_LOST)
+            goto rtx_duplicate;
+        }
+      }
       goto too_late;
+    }
   }
 
   if (already_lost (jitterbuffer, seqnum))
@@ -2864,7 +3052,7 @@
         old_item = rtp_jitter_buffer_pop (priv->jbuf, &percent);
         GST_DEBUG_OBJECT (jitterbuffer, "Queue full, dropping old packet %p",
             old_item);
-        priv->next_seqnum = (old_item->seqnum + 1) & 0xffff;
+        priv->next_seqnum = (old_item->seqnum + old_item->count) & 0xffff;
         free_item (old_item);
       }
       /* we might have removed some head buffers, signal the pushing thread to
@@ -2889,11 +3077,15 @@
    * have a duplicate. */
   if (G_UNLIKELY (!rtp_jitter_buffer_insert (priv->jbuf, item,
               &head, &percent,
-              gst_element_get_base_time (GST_ELEMENT_CAST (jitterbuffer)))))
+              gst_element_get_base_time (GST_ELEMENT_CAST (jitterbuffer))))) {
+    if (GST_BUFFER_IS_RETRANSMISSION (buffer) && timer)
+      update_rtx_stats (jitterbuffer, timer, dts, FALSE);
     goto duplicate;
+  }
 
   /* update timers */
-  update_timers (jitterbuffer, seqnum, dts, do_next_seqnum);
+  update_timers (jitterbuffer, seqnum, dts, do_next_seqnum,
+      GST_BUFFER_IS_RETRANSMISSION (buffer), timer);
 
   /* we had an unhandled SR, handle it now */
   if (priv->last_sr)
@@ -2980,6 +3172,14 @@
     free_item (item);
     goto finished;
   }
+rtx_duplicate:
+  {
+    GST_DEBUG_OBJECT (jitterbuffer,
+        "Duplicate RTX packet #%d detected, dropping", seqnum);
+    priv->num_duplicates++;
+    gst_buffer_unref (buffer);
+    goto finished;
+  }
 }
 
 static GstClockTime
@@ -3163,6 +3363,7 @@
           "Pushing buffer %d, dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT,
           seqnum, GST_TIME_ARGS (GST_BUFFER_DTS (outbuf)),
           GST_TIME_ARGS (GST_BUFFER_PTS (outbuf)));
+      priv->num_pushed++;
       result = gst_pad_push (priv->srcpad, outbuf);
 
       JBUF_LOCK_CHECK (priv, out_flushing);
@@ -3342,6 +3543,78 @@
   return rtx_retry_period;
 }
 
+/*
+  1. For *larger* rtx-rtt, weigh a new measurement as before (1/8th)
+  2. For *smaller* rtx-rtt, be a bit more conservative and weigh a bit less (1/16th)
+  3. For very large measurements (> avg * 2), consider them "outliers"
+     and count them a lot less (1/48th)
+*/
+static void
+update_avg_rtx_rtt (GstRtpJitterBufferPrivate * priv, GstClockTime rtt)
+{
+  gint weight;
+
+  if (priv->avg_rtx_rtt == 0) {
+    priv->avg_rtx_rtt = rtt;
+    return;
+  }
+
+  if (rtt > 2 * priv->avg_rtx_rtt)
+    weight = 48;
+  else if (rtt > priv->avg_rtx_rtt)
+    weight = 8;
+  else
+    weight = 16;
+
+  priv->avg_rtx_rtt = (rtt + (weight - 1) * priv->avg_rtx_rtt) / weight;
+}
+
+static void
+update_rtx_stats (GstRtpJitterBuffer * jitterbuffer, TimerData * timer,
+    GstClockTime dts, gboolean success)
+{
+  GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
+  GstClockTime delay;
+
+  if (success) {
+    /* we scheduled a retry for this packet and now we have it */
+    priv->num_rtx_success++;
+    /* all the previous retry attempts failed */
+    priv->num_rtx_failed += timer->num_rtx_retry - 1;
+  } else {
+    /* All retries failed or was too late */
+    priv->num_rtx_failed += timer->num_rtx_retry;
+  }
+
+  /* number of retries before (hopefully) receiving the packet */
+  if (priv->avg_rtx_num == 0.0)
+    priv->avg_rtx_num = timer->num_rtx_retry;
+  else
+    priv->avg_rtx_num = (timer->num_rtx_retry + 7 * priv->avg_rtx_num) / 8;
+
+  /* Calculate the delay between retransmission request and receiving this
+   * packet. We have a valid delay if and only if this packet is a response to
+   * our last request. If not we don't know if this is a response to an
+   * earlier request and delay could be way off. For RTT is more important
+   * with correct values than to update for every packet. */
+  if (timer->num_rtx_retry == timer->num_rtx_received &&
+      dts != GST_CLOCK_TIME_NONE && dts > timer->rtx_last) {
+    delay = dts - timer->rtx_last;
+    update_avg_rtx_rtt (priv, delay);
+  } else {
+    delay = 0;
+  }
+
+  GST_LOG_OBJECT (jitterbuffer,
+      "RTX #%d, result %d, success %" G_GUINT64_FORMAT ", failed %"
+      G_GUINT64_FORMAT ", requests %" G_GUINT64_FORMAT ", dups %"
+      G_GUINT64_FORMAT ", avg-num %g, delay %" GST_TIME_FORMAT ", avg-rtt %"
+      GST_TIME_FORMAT, timer->seqnum, success, priv->num_rtx_success,
+      priv->num_rtx_failed, priv->num_rtx_requests, priv->num_duplicates,
+      priv->avg_rtx_num, GST_TIME_ARGS (delay),
+      GST_TIME_ARGS (priv->avg_rtx_rtt));
+}
+
 /* the timeout for when we expected a packet expired */
 static gboolean
 do_expected_timeout (GstRtpJitterBuffer * jitterbuffer, TimerData * timer,
@@ -3351,6 +3624,7 @@
   GstEvent *event;
   guint delay, delay_ms, avg_rtx_rtt_ms;
   guint rtx_retry_timeout_ms, rtx_retry_period_ms;
+  guint rtx_deadline_ms;
   GstClockTime rtx_retry_period;
   GstClockTime rtx_retry_timeout;
   GstClock *clock;
@@ -3361,16 +3635,14 @@
   rtx_retry_timeout = get_rtx_retry_timeout (priv);
   rtx_retry_period = get_rtx_retry_period (priv, rtx_retry_timeout);
 
-  GST_DEBUG_OBJECT (jitterbuffer, "timeout %" GST_TIME_FORMAT ", period %"
-      GST_TIME_FORMAT, GST_TIME_ARGS (rtx_retry_timeout),
-      GST_TIME_ARGS (rtx_retry_period));
-
   delay = timer->rtx_delay + timer->rtx_retry;
 
   delay_ms = GST_TIME_AS_MSECONDS (delay);
   rtx_retry_timeout_ms = GST_TIME_AS_MSECONDS (rtx_retry_timeout);
   rtx_retry_period_ms = GST_TIME_AS_MSECONDS (rtx_retry_period);
   avg_rtx_rtt_ms = GST_TIME_AS_MSECONDS (priv->avg_rtx_rtt);
+  rtx_deadline_ms =
+      priv->rtx_deadline_ms != -1 ? priv->rtx_deadline_ms : priv->latency_ms;
 
   event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
       gst_structure_new ("GstRTPRetransmissionRequest",
@@ -3380,9 +3652,10 @@
           "retry", G_TYPE_UINT, timer->num_rtx_retry,
           "frequency", G_TYPE_UINT, rtx_retry_timeout_ms,
           "period", G_TYPE_UINT, rtx_retry_period_ms,
-          "deadline", G_TYPE_UINT, priv->latency_ms,
+          "deadline", G_TYPE_UINT, rtx_deadline_ms,
           "packet-spacing", G_TYPE_UINT64, priv->packet_spacing,
           "avg-rtt", G_TYPE_UINT, avg_rtx_rtt_ms, NULL));
+  GST_DEBUG_OBJECT (jitterbuffer, "Request RTX: %" GST_PTR_FORMAT, event);
 
   priv->num_rtx_requests++;
   timer->num_rtx_retry++;
@@ -3404,7 +3677,8 @@
       GST_TIME_ARGS (timer->rtx_retry), timer->num_rtx_retry);
   if ((priv->rtx_max_retries != -1
           && timer->num_rtx_retry >= priv->rtx_max_retries)
-      || (timer->rtx_retry + timer->rtx_delay > rtx_retry_period)) {
+      || (timer->rtx_retry + timer->rtx_delay > rtx_retry_period)
+      || (timer->rtx_base + rtx_retry_period < now)) {
     GST_DEBUG_OBJECT (jitterbuffer, "reschedule as LOST timer");
     /* too many retransmission request, we now convert the timer
      * to a lost timer, leave the num_rtx_retry as it is for stats */
@@ -3444,14 +3718,16 @@
   else
     GST_DEBUG_OBJECT (jitterbuffer, "Packet #%d lost", seqnum);
 
-  priv->num_late += lost_packets;
+  priv->num_lost += lost_packets;
   priv->num_rtx_failed += num_rtx_retry;
 
   next_in_seqnum = (seqnum + lost_packets) & 0xffff;
 
   /* we now only accept seqnum bigger than this */
-  if (gst_rtp_buffer_compare_seqnum (priv->next_in_seqnum, next_in_seqnum) > 0)
+  if (gst_rtp_buffer_compare_seqnum (priv->next_in_seqnum, next_in_seqnum) > 0) {
     priv->next_in_seqnum = next_in_seqnum;
+    priv->last_in_dts = apply_offset (jitterbuffer, timer->timeout);
+  }
 
   /* Avoid creating events if we don't need it. Note that we still need to create
    * the lost *ITEM* since it will be used to notify the outgoing thread of
@@ -3473,8 +3749,13 @@
   item = alloc_item (event, ITEM_TYPE_LOST, -1, -1, seqnum, lost_packets, -1);
   rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL, -1);
 
-  /* remove timer now */
+  if (GST_CLOCK_TIME_IS_VALID (timer->rtx_last)) {
+    /* Store info to update stats if the packet arrives too late */
+    timer_queue_append (priv->rtx_stats_timers, timer,
+        now + priv->rtx_stats_timeout * GST_MSECOND, TRUE);
+  }
   remove_timer (jitterbuffer, timer);
+
   if (head)
     JBUF_SIGNAL_EVENT (priv);
 
@@ -3575,6 +3856,11 @@
     GST_DEBUG_OBJECT (jitterbuffer, "now %" GST_TIME_FORMAT,
         GST_TIME_ARGS (now));
 
+    /* Clear expired rtx-stats timers */
+    if (priv->do_retransmission)
+      timer_queue_clear_until (priv->rtx_stats_timers, now);
+
+    /* Iterate "normal" timers */
     len = priv->timers->len;
     for (i = 0; i < len;) {
       TimerData *test = &g_array_index (priv->timers, TimerData, i);
@@ -4182,6 +4468,16 @@
       priv->rtx_max_retries = g_value_get_int (value);
       JBUF_UNLOCK (priv);
       break;
+    case PROP_RTX_DEADLINE:
+      JBUF_LOCK (priv);
+      priv->rtx_deadline_ms = g_value_get_int (value);
+      JBUF_UNLOCK (priv);
+      break;
+    case PROP_RTX_STATS_TIMEOUT:
+      JBUF_LOCK (priv);
+      priv->rtx_stats_timeout = g_value_get_uint (value);
+      JBUF_UNLOCK (priv);
+      break;
     case PROP_MAX_RTCP_RTP_TIME_DIFF:
       JBUF_LOCK (priv);
       priv->max_rtcp_rtp_time_diff = g_value_get_int (value);
@@ -4304,6 +4600,16 @@
       g_value_set_int (value, priv->rtx_max_retries);
       JBUF_UNLOCK (priv);
       break;
+    case PROP_RTX_DEADLINE:
+      JBUF_LOCK (priv);
+      g_value_set_int (value, priv->rtx_deadline_ms);
+      JBUF_UNLOCK (priv);
+      break;
+    case PROP_RTX_STATS_TIMEOUT:
+      JBUF_LOCK (priv);
+      g_value_set_uint (value, priv->rtx_stats_timeout);
+      JBUF_UNLOCK (priv);
+      break;
     case PROP_STATS:
       g_value_take_boxed (value,
           gst_rtp_jitter_buffer_create_stats (jitterbuffer));
@@ -4338,15 +4644,21 @@
 static GstStructure *
 gst_rtp_jitter_buffer_create_stats (GstRtpJitterBuffer * jbuf)
 {
+  GstRtpJitterBufferPrivate *priv = jbuf->priv;
   GstStructure *s;
 
-  JBUF_LOCK (jbuf->priv);
+  JBUF_LOCK (priv);
   s = gst_structure_new ("application/x-rtp-jitterbuffer-stats",
-      "rtx-count", G_TYPE_UINT64, jbuf->priv->num_rtx_requests,
-      "rtx-success-count", G_TYPE_UINT64, jbuf->priv->num_rtx_success,
-      "rtx-per-packet", G_TYPE_DOUBLE, jbuf->priv->avg_rtx_num,
-      "rtx-rtt", G_TYPE_UINT64, jbuf->priv->avg_rtx_rtt, NULL);
-  JBUF_UNLOCK (jbuf->priv);
+      "num-pushed", G_TYPE_UINT64, priv->num_pushed,
+      "num-lost", G_TYPE_UINT64, priv->num_lost,
+      "num-late", G_TYPE_UINT64, priv->num_late,
+      "num-duplicates", G_TYPE_UINT64, priv->num_duplicates,
+      "avg-jitter", G_TYPE_UINT64, priv->avg_jitter,
+      "rtx-count", G_TYPE_UINT64, priv->num_rtx_requests,
+      "rtx-success-count", G_TYPE_UINT64, priv->num_rtx_success,
+      "rtx-per-packet", G_TYPE_DOUBLE, priv->avg_rtx_num,
+      "rtx-rtt", G_TYPE_UINT64, priv->avg_rtx_rtt, NULL);
+  JBUF_UNLOCK (priv);
 
   return s;
 }
diff --git a/gst/rtpmanager/gstrtprtxreceive.c b/gst/rtpmanager/gstrtprtxreceive.c
index a667d10..91edda2 100644
--- a/gst/rtpmanager/gstrtprtxreceive.c
+++ b/gst/rtpmanager/gstrtprtxreceive.c
@@ -472,6 +472,7 @@
 
   gst_buffer_copy_into (new_buffer, rtp->buffer,
       GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
+  GST_BUFFER_FLAG_SET (new_buffer, GST_RTP_BUFFER_FLAG_RETRANSMISSION);
 
   return new_buffer;
 }
diff --git a/gst/rtpmanager/rtpsession.c b/gst/rtpmanager/rtpsession.c
index b33e909..8b33b6b 100644
--- a/gst/rtpmanager/rtpsession.c
+++ b/gst/rtpmanager/rtpsession.c
@@ -2575,10 +2575,10 @@
     GstClockTime round_trip_in_ns = gst_util_uint64_scale (round_trip,
         GST_SECOND, 65536);
 
-     /* Sanity check to avoid always ignoring PLI/FIR if we receive RTCP
-      * packets with erroneous values resulting in crazy high RTT. */
-     if (round_trip_in_ns > 5 * GST_SECOND)
-       round_trip_in_ns = GST_SECOND / 2;
+    /* Sanity check to avoid always ignoring PLI/FIR if we receive RTCP
+     * packets with erroneous values resulting in crazy high RTT. */
+    if (round_trip_in_ns > 5 * GST_SECOND)
+      round_trip_in_ns = GST_SECOND / 2;
 
     if (current_time - sess->last_keyframe_request < 2 * round_trip_in_ns) {
       GST_DEBUG ("Ignoring %s request because one was send without one "
diff --git a/gst/rtsp/gstrtspsrc.c b/gst/rtsp/gstrtspsrc.c
index 52fd737..189adc2 100644
--- a/gst/rtsp/gstrtspsrc.c
+++ b/gst/rtsp/gstrtspsrc.c
@@ -906,6 +906,8 @@
   src->state = GST_RTSP_STATE_INVALID;
 
   GST_OBJECT_FLAG_SET (src, GST_ELEMENT_FLAG_SOURCE);
+  gst_bin_set_suppressed_flags (GST_BIN (src),
+      GST_ELEMENT_FLAG_SOURCE | GST_ELEMENT_FLAG_SINK);
 }
 
 static void
@@ -3618,9 +3620,6 @@
     g_object_set (G_OBJECT (stream->fakesrc), "filltype", 3, "num-buffers", 5,
         "sizetype", 2, "sizemax", 200, "silent", TRUE, NULL);
 
-    /* we don't want to consider this a sink */
-    GST_OBJECT_FLAG_UNSET (stream->udpsink[0], GST_ELEMENT_FLAG_SINK);
-
     /* keep everything locked */
     gst_element_set_locked_state (stream->udpsink[0], TRUE);
     gst_element_set_locked_state (stream->fakesrc, TRUE);
@@ -3667,9 +3666,6 @@
       g_object_unref (socket);
     }
 
-    /* we don't want to consider this a sink */
-    GST_OBJECT_FLAG_UNSET (stream->udpsink[1], GST_ELEMENT_FLAG_SINK);
-
     /* we keep this playing always */
     gst_element_set_locked_state (stream->udpsink[1], TRUE);
     gst_element_set_state (stream->udpsink[1], GST_STATE_PLAYING);
diff --git a/gst/udp/gstudpsrc.c b/gst/udp/gstudpsrc.c
index dcd99ba..d60a014 100644
--- a/gst/udp/gstudpsrc.c
+++ b/gst/udp/gstudpsrc.c
@@ -158,8 +158,10 @@
 
   guint ifindex;
 #ifndef G_OS_WIN32
+#ifndef __NetBSD__
   struct in_addr spec_dst;
 #endif
+#endif
   struct in_addr addr;
 };
 
@@ -202,8 +204,10 @@
   message = g_object_new (GST_TYPE_IP_PKTINFO_MESSAGE, NULL);
   message->ifindex = pktinfo->ipi_ifindex;
 #ifndef G_OS_WIN32
+#ifndef __NetBSD__
   message->spec_dst = pktinfo->ipi_spec_dst;
 #endif
+#endif
   message->addr = pktinfo->ipi_addr;
 
   return G_SOCKET_CONTROL_MESSAGE (message);
diff --git a/gst/videofilter/gstvideoflip.c b/gst/videofilter/gstvideoflip.c
index f59f930..c6132f5 100644
--- a/gst/videofilter/gstvideoflip.c
+++ b/gst/videofilter/gstvideoflip.c
@@ -123,7 +123,7 @@
 #define gst_video_flip_parent_class parent_class
 G_DEFINE_TYPE_WITH_CODE (GstVideoFlip, gst_video_flip, GST_TYPE_VIDEO_FILTER,
     G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_DIRECTION,
-        gst_video_flip_video_direction_interface_init))
+        gst_video_flip_video_direction_interface_init));
 
 static GstCaps *
 gst_video_flip_transform_caps (GstBaseTransform * trans,
diff --git a/po/af.gmo b/po/af.gmo
index f1578a6..1282875 100644
--- a/po/af.gmo
+++ b/po/af.gmo
Binary files differ
diff --git a/po/af.po b/po/af.po
index 41d9bdd..acb5b65 100644
--- a/po/af.po
+++ b/po/af.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins 0.7.6\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2004-03-18 14:16+0200\n"
 "Last-Translator: Petri Jooste <rkwjpj@puk.ac.za>\n"
 "Language-Team: Afrikaans <i18n@af.org.za>\n"
diff --git a/po/az.gmo b/po/az.gmo
index 65d4a77..cfaa53c 100644
--- a/po/az.gmo
+++ b/po/az.gmo
Binary files differ
diff --git a/po/az.po b/po/az.po
index 1a2bbc4..877e300 100644
--- a/po/az.po
+++ b/po/az.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-0.8.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2004-03-19 18:29+0200\n"
 "Last-Translator: Metin Amiroff <metin@karegen.com>\n"
 "Language-Team: Azerbaijani <translation-team-az@lists.sourceforge.net>\n"
diff --git a/po/bg.gmo b/po/bg.gmo
index 2610551..7fb39b9 100644
--- a/po/bg.gmo
+++ b/po/bg.gmo
Binary files differ
diff --git a/po/bg.po b/po/bg.po
index e3df66f..66cd2b5 100644
--- a/po/bg.po
+++ b/po/bg.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-21 21:03+0200\n"
 "Last-Translator: Alexander Shopov <ash@kambanaria.org>\n"
 "Language-Team: Bulgarian <dict@ludost.net>\n"
diff --git a/po/ca.gmo b/po/ca.gmo
index c1d6fcc..9113e8c 100644
--- a/po/ca.gmo
+++ b/po/ca.gmo
Binary files differ
diff --git a/po/ca.po b/po/ca.po
index 1d7d7ac..65eb600 100644
--- a/po/ca.po
+++ b/po/ca.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.28.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2012-01-01 14:19+0100\n"
 "Last-Translator: Gil Forcada <gforcada@gnome.org>\n"
 "Language-Team: Catalan <ca@dodds.net>\n"
diff --git a/po/cs.gmo b/po/cs.gmo
index f679647..e9f611d 100644
--- a/po/cs.gmo
+++ b/po/cs.gmo
Binary files differ
diff --git a/po/cs.po b/po/cs.po
index 483bb16..454ac54 100644
--- a/po/cs.po
+++ b/po/cs.po
@@ -10,7 +10,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-27 16:40+0100\n"
 "Last-Translator: Marek Černocký <marek@manet.cz>\n"
 "Language-Team: Czech <translation-team-cs@lists.sourceforge.net>\n"
diff --git a/po/da.gmo b/po/da.gmo
index cace6fd..6c72f2e 100644
--- a/po/da.gmo
+++ b/po/da.gmo
Binary files differ
diff --git a/po/da.po b/po/da.po
index f1bb97c..df8e70a 100644
--- a/po/da.po
+++ b/po/da.po
@@ -11,7 +11,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-03-27 23:54+0200\n"
 "Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
 "Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
diff --git a/po/de.gmo b/po/de.gmo
index 2dba3a0..f6d25c0 100644
--- a/po/de.gmo
+++ b/po/de.gmo
Binary files differ
diff --git a/po/de.po b/po/de.po
index d627439..bd8a643 100644
--- a/po/de.po
+++ b/po/de.po
@@ -14,7 +14,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-22 23:42+0100\n"
 "Last-Translator: Christian Kirbach <christian.kirbach@gmail.com>\n"
 "Language-Team: German <translation-team-de@lists.sourceforge.net>\n"
diff --git a/po/el.gmo b/po/el.gmo
index aa7f41c..9d033c2 100644
--- a/po/el.gmo
+++ b/po/el.gmo
Binary files differ
diff --git a/po/el.po b/po/el.po
index 3cb143a..cf5f53f 100644
--- a/po/el.po
+++ b/po/el.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.28.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2012-05-05 19:05+0100\n"
 "Last-Translator: Savvas Radevic <vicedar@gmail.com>\n"
 "Language-Team: Greek <team@lists.gnome.gr>\n"
@@ -16,6 +16,7 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"X-Bugs: Report translation errors to the Language-Team address.\n"
 "X-Generator: Lokalize 0.3\n"
 "Plural-Forms: nplurals=2; plural=(n != 1);\n"
 
diff --git a/po/en_GB.gmo b/po/en_GB.gmo
index d9cd4a5..4487c55 100644
--- a/po/en_GB.gmo
+++ b/po/en_GB.gmo
Binary files differ
diff --git a/po/en_GB.po b/po/en_GB.po
index 15ae1e5..57df2ec 100644
--- a/po/en_GB.po
+++ b/po/en_GB.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins 0.8.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2004-04-26 10:41-0400\n"
 "Last-Translator: Gareth Owen <gowen72@yahoo.com>\n"
 "Language-Team: English (British) <en_gb@li.org>\n"
diff --git a/po/eo.gmo b/po/eo.gmo
index 89ddba6..85bf32c 100644
--- a/po/eo.gmo
+++ b/po/eo.gmo
Binary files differ
diff --git a/po/eo.po b/po/eo.po
index e3f8381..a2bc1ff 100644
--- a/po/eo.po
+++ b/po/eo.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.28.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2011-06-04 21:48+0100\n"
 "Last-Translator: Kristjan SCHMIDT <kristjan.schmidt@googlemail.com>\n"
 "Language-Team: Esperanto <translation-team-eo@lists.sourceforge.net>\n"
diff --git a/po/es.gmo b/po/es.gmo
index 35c5cfc..a435580 100644
--- a/po/es.gmo
+++ b/po/es.gmo
Binary files differ
diff --git a/po/es.po b/po/es.po
index f3edfa0..96ec954 100644
--- a/po/es.po
+++ b/po/es.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.26.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2011-02-12 18:30+0100\n"
 "Last-Translator: Jorge González González <aloriel@gmail.com>\n"
 "Language-Team: Spanish <es@li.org>\n"
diff --git a/po/eu.gmo b/po/eu.gmo
index c393772..037886b 100644
--- a/po/eu.gmo
+++ b/po/eu.gmo
Binary files differ
diff --git a/po/eu.po b/po/eu.po
index 3377c78..0a8c118 100644
--- a/po/eu.po
+++ b/po/eu.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-0.10.18.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2010-03-25 12:37+0100\n"
 "Last-Translator: Mikel Olasagasti Uranga <hey_neken@mundurat.net>\n"
 "Language-Team: Basque <translation-team-eu@lists.sourceforge.net>\n"
diff --git a/po/fi.gmo b/po/fi.gmo
index 65da6dc..c3ef98a 100644
--- a/po/fi.gmo
+++ b/po/fi.gmo
Binary files differ
diff --git a/po/fi.po b/po/fi.po
index 9e5339d..8a2ddd9 100644
--- a/po/fi.po
+++ b/po/fi.po
@@ -11,7 +11,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.25.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2010-11-17 23:03+0200\n"
 "Last-Translator: Tommi Vainikainen <Tommi.Vainikainen@iki.fi>\n"
 "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
diff --git a/po/fr.gmo b/po/fr.gmo
index 11f56b7..04becb6 100644
--- a/po/fr.gmo
+++ b/po/fr.gmo
Binary files differ
diff --git a/po/fr.po b/po/fr.po
index e3639f8..02d810e 100644
--- a/po/fr.po
+++ b/po/fr.po
@@ -10,7 +10,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-20 16:27+0100\n"
 "Last-Translator: Stéphane Aulery <lkppo@free.fr>\n"
 "Language-Team: French <traduc@traduc.org>\n"
diff --git a/po/gl.gmo b/po/gl.gmo
index 9af1e42..e3f70f8 100644
--- a/po/gl.gmo
+++ b/po/gl.gmo
Binary files differ
diff --git a/po/gl.po b/po/gl.po
index c6320af..b1ed6e5 100644
--- a/po/gl.po
+++ b/po/gl.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2012-12-15 03:46+0200\n"
 "Last-Translator: Fran Dieguez <frandieguez@ubuntu.com>\n"
 "Language-Team: Galician <proxecto@trasno.net>\n"
diff --git a/po/gst-plugins-good-1.0.pot b/po/gst-plugins-good-1.0.pot
index 21e46de..bdbdc27 100644
--- a/po/gst-plugins-good-1.0.pot
+++ b/po/gst-plugins-good-1.0.pot
@@ -5,9 +5,9 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-good 1.9.2\n"
+"Project-Id-Version: gst-plugins-good 1.9.90\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -107,13 +107,13 @@
 msgid "This file contains too many streams. Only playing first %d"
 msgstr ""
 
-#: gst/rtsp/gstrtspsrc.c:6436
+#: gst/rtsp/gstrtspsrc.c:6432
 msgid ""
 "No supported stream was found. You might need to install a GStreamer RTSP "
 "extension plugin for Real media streams."
 msgstr ""
 
-#: gst/rtsp/gstrtspsrc.c:6441
+#: gst/rtsp/gstrtspsrc.c:6437
 msgid ""
 "No supported stream was found. You might need to allow more transport "
 "protocols or may otherwise be missing the right GStreamer RTSP extension "
diff --git a/po/hr.gmo b/po/hr.gmo
index 6a6514d..4a17795 100644
--- a/po/hr.gmo
+++ b/po/hr.gmo
Binary files differ
diff --git a/po/hr.po b/po/hr.po
index 6fe811c..9907c25 100644
--- a/po/hr.po
+++ b/po/hr.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-05-27 12:47-0700\n"
 "Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
diff --git a/po/hu.gmo b/po/hu.gmo
index 2ffafa0..f8ccda4 100644
--- a/po/hu.gmo
+++ b/po/hu.gmo
Binary files differ
diff --git a/po/hu.po b/po/hu.po
index 13756a3..e36935b 100644
--- a/po/hu.po
+++ b/po/hu.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-03-14 18:35+0100\n"
 "Last-Translator: Gabor Kelemen <kelemeng@gnome.hu>\n"
 "Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
diff --git a/po/id.gmo b/po/id.gmo
index 36c6e03..a73b695 100644
--- a/po/id.gmo
+++ b/po/id.gmo
Binary files differ
diff --git a/po/id.po b/po/id.po
index 3f372da..a1d2a63 100644
--- a/po/id.po
+++ b/po/id.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.3.90\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2014-07-06 21:37+0700\n"
 "Last-Translator: Andhika Padmawan <andhika.padmawan@gmail.com>\n"
 "Language-Team: Indonesian <translation-team-id@lists.sourceforge.net>\n"
diff --git a/po/it.gmo b/po/it.gmo
index b91aac1..bd53af9 100644
--- a/po/it.gmo
+++ b/po/it.gmo
Binary files differ
diff --git a/po/it.po b/po/it.po
index 8fd4c60..799759b 100644
--- a/po/it.po
+++ b/po/it.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.25.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2010-10-25 10:11+0200\n"
 "Last-Translator: Luca Ferretti <elle.uca@infinito.it>\n"
 "Language-Team: Italian <tp@lists.linux.it>\n"
diff --git a/po/ja.gmo b/po/ja.gmo
index 66e3526..d9a6e75 100644
--- a/po/ja.gmo
+++ b/po/ja.gmo
Binary files differ
diff --git a/po/ja.po b/po/ja.po
index 70ee454..6b550dc 100644
--- a/po/ja.po
+++ b/po/ja.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2012-12-22 20:13+0900\n"
 "Last-Translator: Takeshi Hamasaki <hmatrjp@users.sourceforge.jp>\n"
 "Language-Team: Japanese <translation-team-ja@lists.sourceforge.net>\n"
diff --git a/po/lt.gmo b/po/lt.gmo
index 0f14791..8b11df7 100644
--- a/po/lt.gmo
+++ b/po/lt.gmo
Binary files differ
diff --git a/po/lt.po b/po/lt.po
index 76b74e2..15963ed 100644
--- a/po/lt.po
+++ b/po/lt.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.23.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2010-07-16 19:34+0300\n"
 "Last-Translator: Žygimantas Beručka <uid0@akl.lt>\n"
 "Language-Team: Lithuanian <komp_lt@konferencijos.lt>\n"
diff --git a/po/lv.gmo b/po/lv.gmo
index 39abb9f..347368f 100644
--- a/po/lv.gmo
+++ b/po/lv.gmo
Binary files differ
diff --git a/po/lv.po b/po/lv.po
index d1f94b3..9dcfc2c 100644
--- a/po/lv.po
+++ b/po/lv.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.2.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2014-04-20 16:38+0300\n"
 "Last-Translator: Rihards Prieditis <rprieditis@gmail.com>\n"
 "Language-Team: Latvian <translation-team-lv@lists.sourceforge.net>\n"
diff --git a/po/mt.gmo b/po/mt.gmo
index 23ef444..0e34cb4 100644
--- a/po/mt.gmo
+++ b/po/mt.gmo
Binary files differ
diff --git a/po/mt.po b/po/mt.po
index 839c1db..091ca8a 100644
--- a/po/mt.po
+++ b/po/mt.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-0.10.10.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2008-10-26 19:09+0100\n"
 "Last-Translator: Michel Bugeja <michelbugeja@rabatmalta.com>\n"
 "Language-Team: Maltese <translation-team-mt@lists.sourceforge.net>\n"
diff --git a/po/nb.gmo b/po/nb.gmo
index 988aa45..f806a8e 100644
--- a/po/nb.gmo
+++ b/po/nb.gmo
Binary files differ
diff --git a/po/nb.po b/po/nb.po
index ddce766..22171cd 100644
--- a/po/nb.po
+++ b/po/nb.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-08-05 23:47+0200\n"
 "Last-Translator: Johnny A. Solbu <johnny@solbu.net>\n"
 "Language-Team: Norwegian Bokmaal <i18n-nb@lister.ping.uio.no>\n"
diff --git a/po/nl.gmo b/po/nl.gmo
index d0376ca..12fbdf7 100644
--- a/po/nl.gmo
+++ b/po/nl.gmo
Binary files differ
diff --git a/po/nl.po b/po/nl.po
index 30d2cf5..5a273fd 100644
--- a/po/nl.po
+++ b/po/nl.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-20 16:40+0100\n"
 "Last-Translator: Freek de Kruijf <f.de.kruijf@gmail.com>\n"
 "Language-Team: Dutch <vertaling@vrijschrift.org>\n"
diff --git a/po/or.gmo b/po/or.gmo
index 1fac66f..efacd54 100644
--- a/po/or.gmo
+++ b/po/or.gmo
Binary files differ
diff --git a/po/or.po b/po/or.po
index 953edbc..47e1dc6 100644
--- a/po/or.po
+++ b/po/or.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-0.8.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2004-09-27 13:32+0530\n"
 "Last-Translator: Gora Mohanty <gora_mohanty@yahoo.co.in>\n"
 "Language-Team: Oriya <gora_mohanty@yahoo.co.in>\n"
diff --git a/po/pl.gmo b/po/pl.gmo
index 4860f6b..d502dd9 100644
--- a/po/pl.gmo
+++ b/po/pl.gmo
Binary files differ
diff --git a/po/pl.po b/po/pl.po
index be08aef..d974478 100644
--- a/po/pl.po
+++ b/po/pl.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-20 21:43+0100\n"
 "Last-Translator: Jakub Bogusz <qboosh@pld-linux.org>\n"
 "Language-Team: Polish <translation-team-pl@lists.sourceforge.net>\n"
diff --git a/po/pt_BR.gmo b/po/pt_BR.gmo
index c39470d..3c6aa16 100644
--- a/po/pt_BR.gmo
+++ b/po/pt_BR.gmo
Binary files differ
diff --git a/po/pt_BR.po b/po/pt_BR.po
index a6d700a..b8fe44a 100644
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
@@ -13,7 +13,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-05-06 17:49-0300\n"
 "Last-Translator: Fabrício Godoy <skarllot@gmail.com>\n"
 "Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge."
diff --git a/po/ro.gmo b/po/ro.gmo
index 9e13855..97f49ca 100644
--- a/po/ro.gmo
+++ b/po/ro.gmo
Binary files differ
diff --git a/po/ro.po b/po/ro.po
index a8a9c15..9f4ac1a 100644
--- a/po/ro.po
+++ b/po/ro.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 0.10.23.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2010-08-16 03:22+0300\n"
 "Last-Translator: Lucian Adrian Grijincu <lucian.grijincu@gmail.com>\n"
 "Language-Team: Romanian <translation-team-ro@lists.sourceforge.net>\n"
diff --git a/po/ru.gmo b/po/ru.gmo
index 5201165..0176890 100644
--- a/po/ru.gmo
+++ b/po/ru.gmo
Binary files differ
diff --git a/po/ru.po b/po/ru.po
index 84fe0a8..48a619a 100644
--- a/po/ru.po
+++ b/po/ru.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-21 09:55+0300\n"
 "Last-Translator: Yuri Kozlov <yuray@komyakino.ru>\n"
 "Language-Team: Russian <gnu@d07.ru>\n"
diff --git a/po/sk.gmo b/po/sk.gmo
index 255a034..c60ba03 100644
--- a/po/sk.gmo
+++ b/po/sk.gmo
Binary files differ
diff --git a/po/sk.po b/po/sk.po
index f5a8372..8213ce4 100644
--- a/po/sk.po
+++ b/po/sk.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-05-20 12:31+0100\n"
 "Last-Translator: Peter Tuhársky <tuharsky@misbb.sk>\n"
 "Language-Team: Slovak <sk-i18n@lists.linux.sk>\n"
diff --git a/po/sl.gmo b/po/sl.gmo
index 0a394ed..bb0b11b 100644
--- a/po/sl.gmo
+++ b/po/sl.gmo
Binary files differ
diff --git a/po/sl.po b/po/sl.po
index 8c56466..5327073 100644
--- a/po/sl.po
+++ b/po/sl.po
@@ -10,7 +10,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.2.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2014-04-09 22:52+0100\n"
 "Last-Translator: Klemen Košir <klemen913@gmail.com>\n"
 "Language-Team: Slovenian <translation-team-sl@lists.sourceforge.net>\n"
diff --git a/po/sq.gmo b/po/sq.gmo
index 85c42d6..ccc58ea 100644
--- a/po/sq.gmo
+++ b/po/sq.gmo
Binary files differ
diff --git a/po/sq.po b/po/sq.po
index 3cd328c..f755648 100644
--- a/po/sq.po
+++ b/po/sq.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins 0.8.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2004-08-07 20:29+0200\n"
 "Last-Translator: Laurent Dhima <laurenti@alblinux.net>\n"
 "Language-Team: Albanian <begraj@hotmail.com>\n"
diff --git a/po/sr.gmo b/po/sr.gmo
index 4e635cf..ca222f7 100644
--- a/po/sr.gmo
+++ b/po/sr.gmo
Binary files differ
diff --git a/po/sr.po b/po/sr.po
index c2e8706..064499c 100644
--- a/po/sr.po
+++ b/po/sr.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-03-05 09:52+0200\n"
 "Last-Translator: Мирослав Николић <miroslavnikolic@rocketmail.com>\n"
 "Language-Team: Serbian <(nothing)>\n"
diff --git a/po/sv.gmo b/po/sv.gmo
index 1a84481..5e610fa 100644
--- a/po/sv.gmo
+++ b/po/sv.gmo
Binary files differ
diff --git a/po/sv.po b/po/sv.po
index 676b37d..dbdb58b 100644
--- a/po/sv.po
+++ b/po/sv.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-20 16:13+0100\n"
 "Last-Translator: Sebastian Rasmussen <sebras@gmail.com>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
diff --git a/po/tr.gmo b/po/tr.gmo
index 4508878..549629a 100644
--- a/po/tr.gmo
+++ b/po/tr.gmo
Binary files differ
diff --git a/po/tr.po b/po/tr.po
index 0241ae8..ab087f6 100644
--- a/po/tr.po
+++ b/po/tr.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.4.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2015-01-10 21:07+0100\n"
 "Last-Translator: Volkan Gezer <volkangezer@gmail.com>\n"
 "Language-Team: Turkish <gnu-tr-u12a@lists.sourceforge.net>\n"
diff --git a/po/uk.gmo b/po/uk.gmo
index 0d05967..1e8670c 100644
--- a/po/uk.gmo
+++ b/po/uk.gmo
Binary files differ
diff --git a/po/uk.po b/po/uk.po
index a7251ca..fa55884 100644
--- a/po/uk.po
+++ b/po/uk.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-20 17:27+0200\n"
 "Last-Translator: Yuri Chornoivan <yurchor@ukr.net>\n"
 "Language-Team: Ukrainian <translation-team-uk@lists.sourceforge.net>\n"
diff --git a/po/vi.gmo b/po/vi.gmo
index 7f1b079..df24dc2 100644
--- a/po/vi.gmo
+++ b/po/vi.gmo
Binary files differ
diff --git a/po/vi.po b/po/vi.po
index 17fa315..5dfbe7e 100644
--- a/po/vi.po
+++ b/po/vi.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-21 07:25+0700\n"
 "Last-Translator: Trần Ngọc Quân <vnwildman@gmail.com>\n"
 "Language-Team: Vietnamese <translation-team-vi@lists.sourceforge.net>\n"
diff --git a/po/zh_CN.gmo b/po/zh_CN.gmo
index 721a92f..1590b02 100644
--- a/po/zh_CN.gmo
+++ b/po/zh_CN.gmo
Binary files differ
diff --git a/po/zh_CN.po b/po/zh_CN.po
index ae271fa..a8a2c49 100644
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2016-02-21 16:52+0800\n"
 "Last-Translator: Tianze Wang <zwpwjwtz@126.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
diff --git a/po/zh_HK.gmo b/po/zh_HK.gmo
index a5a37ee..7eecb14 100644
--- a/po/zh_HK.gmo
+++ b/po/zh_HK.gmo
Binary files differ
diff --git a/po/zh_HK.po b/po/zh_HK.po
index 537fe66..ce3dc35 100644
--- a/po/zh_HK.po
+++ b/po/zh_HK.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-0.10.2 0.10.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2006-08-29 01:08+0800\n"
 "Last-Translator: Abel Cheung <abelcheung@gmail.com>\n"
 "Language-Team: Chinese (Hong Kong) <community@linuxhall.org>\n"
diff --git a/po/zh_TW.gmo b/po/zh_TW.gmo
index b442619..8aaa25b 100644
--- a/po/zh_TW.gmo
+++ b/po/zh_TW.gmo
Binary files differ
diff --git a/po/zh_TW.po b/po/zh_TW.po
index 5eaecb6..abea9b8 100644
--- a/po/zh_TW.po
+++ b/po/zh_TW.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-0.10.2 0.10.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-09-01 11:23+0300\n"
+"POT-Creation-Date: 2016-09-30 12:16+0300\n"
 "PO-Revision-Date: 2006-08-29 01:08+0800\n"
 "Last-Translator: Abel Cheung <abelcheung@gmail.com>\n"
 "Language-Team: Chinese (traditional) <zh-l10n@linux.org.tw>\n"
diff --git a/sys/osxaudio/Makefile.am b/sys/osxaudio/Makefile.am
index 45c7200..f5f1d9c 100644
--- a/sys/osxaudio/Makefile.am
+++ b/sys/osxaudio/Makefile.am
@@ -17,22 +17,22 @@
     $(GST_LIBS)
 
 libgstosxaudio_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -Wl,-framework,CoreAudio  -Wl,-framework,AudioToolbox
-
-if !HAVE_IOS
-libgstosxaudio_la_SOURCES += gstosxaudiodeviceprovider.c
-libgstosxaudio_la_LDFLAGS += -Wl,-framework,AudioUnit -Wl,-framework,CoreServices
-endif
-
 libgstosxaudio_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS) --tag=CC
 
 noinst_HEADERS = gstosxaudiosink.h	  \
+                 gstosxaudiodeviceprovider.h \
                  gstosxaudioelement.h \
                  gstosxaudioringbuffer.h	  \
                  gstosxaudiosrc.h     \
                  gstosxcoreaudiocommon.h     \
-                 gstosxcoreaudio.h \
-                 gstosxcoreaudiohal.c \
-                 gstosxcoreaudioremoteio.c
+                 gstosxcoreaudio.h
 
+EXTRA_DIST = gstosxcoreaudiohal.c \
+             gstosxcoreaudioremoteio.c
 
-
+if !HAVE_IOS
+libgstosxaudio_la_SOURCES += gstosxaudiodeviceprovider.c
+libgstosxaudio_la_LDFLAGS += -Wl,-framework,AudioUnit -Wl,-framework,CoreServices
+else
+EXTRA_DIST += gstosxaudiodeviceprovider.c
+endif
diff --git a/sys/osxaudio/Makefile.in b/sys/osxaudio/Makefile.in
index 7b93512..9438460 100644
--- a/sys/osxaudio/Makefile.in
+++ b/sys/osxaudio/Makefile.in
@@ -92,6 +92,7 @@
 target_triplet = @target@
 @HAVE_IOS_FALSE@am__append_1 = gstosxaudiodeviceprovider.c
 @HAVE_IOS_FALSE@am__append_2 = -Wl,-framework,AudioUnit -Wl,-framework,CoreServices
+@HAVE_IOS_TRUE@am__append_3 = gstosxaudiodeviceprovider.c
 subdir = sys/osxaudio
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/common/m4/as-ac-expand.m4 \
@@ -603,14 +604,15 @@
 	$(am__append_2)
 libgstosxaudio_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS) --tag=CC
 noinst_HEADERS = gstosxaudiosink.h	  \
+                 gstosxaudiodeviceprovider.h \
                  gstosxaudioelement.h \
                  gstosxaudioringbuffer.h	  \
                  gstosxaudiosrc.h     \
                  gstosxcoreaudiocommon.h     \
-                 gstosxcoreaudio.h \
-                 gstosxcoreaudiohal.c \
-                 gstosxcoreaudioremoteio.c
+                 gstosxcoreaudio.h
 
+EXTRA_DIST = gstosxcoreaudiohal.c gstosxcoreaudioremoteio.c \
+	$(am__append_3)
 all: all-am
 
 .SUFFIXES:
diff --git a/sys/osxaudio/gstosxaudiodeviceprovider.h b/sys/osxaudio/gstosxaudiodeviceprovider.h
new file mode 100644
index 0000000..bd54178
--- /dev/null
+++ b/sys/osxaudio/gstosxaudiodeviceprovider.h
@@ -0,0 +1,91 @@
+/* GStreamer
+ * Copyright (C) 2016 Hyunjun Ko <zzoon@igalia.com>
+ *
+ * gstosxaudiodeviceeprovider.h: OSX audio probing and monitoring
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_OSX_AUDIO_DEIVCE_PROVIDER_H__
+#define __GST_OSX_AUDIO_DEIVCE_PROVIDER_H__
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include "gstosxcoreaudiocommon.h"
+
+G_BEGIN_DECLS
+typedef struct _GstOsxAudioDeviceProvider GstOsxAudioDeviceProvider;
+typedef struct _GstOsxAudioDeviceProviderClass GstOsxAudioDeviceProviderClass;
+
+#define GST_TYPE_OSX_AUDIO_DEVICE_PROVIDER                 (gst_osx_audio_device_provider_get_type())
+#define GST_IS_OSX_AUDIO_DEVICE_PROVIDER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_OSX_AUDIO_DEVICE_PROVIDER))
+#define GST_IS_OSX_AUDIO_DEVICE_PROVIDER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_OSX_AUDIO_DEVICE_PROVIDER))
+#define GST_OSX_AUDIO_DEVICE_PROVIDER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_OSX_AUDIO_DEVICE_PROVIDER, GstOsxAudioDeviceProviderClass))
+#define GST_OSX_AUDIO_DEVICE_PROVIDER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_OSX_AUDIO_DEVICE_PROVIDER, GstOsxAudioDeviceProvider))
+#define GST_OSX_AUDIO_DEVICE_PROVIDER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_DEVICE_PROVIDER, GstOsxAudioDeviceProviderClass))
+#define GST_OSX_AUDIO_DEVICE_PROVIDER_CAST(obj)            ((GstOsxAudioDeviceProvider *)(obj))
+
+struct _GstOsxAudioDeviceProvider
+{
+  GstDeviceProvider parent;
+};
+
+struct _GstOsxAudioDeviceProviderClass
+{
+  GstDeviceProviderClass parent_class;
+};
+
+GType gst_osx_audio_device_provider_get_type (void);
+
+typedef struct _GstOsxAudioDevice GstOsxAudioDevice;
+typedef struct _GstOsxAudioDeviceClass GstOsxAudioDeviceClass;
+
+#define GST_TYPE_OSX_AUDIO_DEVICE                 (gst_osx_audio_device_get_type())
+#define GST_IS_OSX_AUDIO_DEVICE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_OSX_AUDIO_DEVICE))
+#define GST_IS_OSX_AUDIO_DEVICE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_OSX_AUDIO_DEVICE))
+#define GST_OSX_AUDIO_DEVICE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_OSX_AUDIO_DEVICE, GstOsxAudioClass))
+#define GST_OSX_AUDIO_DEVICE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_OSX_AUDIO_DEVICE, GstOsxAudioDevice))
+#define GST_OSX_AUDIO_DEVICE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_DEVICE, GstOsxAudioDeviceClass))
+#define GST_OSX_AUDIO_DEVICE_CAST(obj)            ((GstOsxAudioDevice *)(obj))
+
+typedef enum
+{
+  GST_OSX_AUDIO_DEVICE_TYPE_INVALID = 0,
+  GST_OSX_AUDIO_DEVICE_TYPE_SOURCE,
+  GST_OSX_AUDIO_DEVICE_TYPE_SINK
+} GstOsxAudioDeviceType;
+
+struct _GstOsxAudioDevice
+{
+  GstDevice parent;
+
+  const gchar *element;
+  AudioDeviceID device_id;
+};
+
+struct _GstOsxAudioDeviceClass
+{
+  GstDeviceClass parent_class;
+};
+
+GType gst_osx_audio_device_get_type (void);
+
+G_END_DECLS
+#endif /* __GST_OSX_AUDIO_DEIVCE_PROVIDER_H__ */
diff --git a/tests/check/elements/flvmux.c b/tests/check/elements/flvmux.c
index 8ae17f9..0cf9b99 100644
--- a/tests/check/elements/flvmux.c
+++ b/tests/check/elements/flvmux.c
@@ -336,7 +336,7 @@
 GST_END_TEST;
 
 static void
-check_buf_type_timestamp (GstBuffer *buf, gint packet_type, gint timestamp)
+check_buf_type_timestamp (GstBuffer * buf, gint packet_type, gint timestamp)
 {
   GstMapInfo map = GST_MAP_INFO_INIT;
   gst_buffer_map (buf, &map, GST_MAP_READ);
@@ -346,7 +346,7 @@
   gst_buffer_unref (buf);
 }
 
-GST_START_TEST(test_increasing_timestamp_when_pts_none)
+GST_START_TEST (test_increasing_timestamp_when_pts_none)
 {
   const gint AUDIO = 0x08;
   const gint VIDEO = 0x09;
@@ -376,29 +376,26 @@
   gst_pad_link (video_src, video_sink);
 
   audio_caps = gst_caps_new_simple ("audio/x-speex",
-      "rate", G_TYPE_INT, 16000,
-      "channels", G_TYPE_INT, 1,
-      NULL);
+      "rate", G_TYPE_INT, 16000, "channels", G_TYPE_INT, 1, NULL);
   gst_harness_set_src_caps (audio_q, audio_caps);
   video_caps = gst_caps_new_simple ("video/x-h264",
-      "stream-format", G_TYPE_STRING, "avc",
-      NULL);
+      "stream-format", G_TYPE_STRING, "avc", NULL);
   gst_harness_set_src_caps (video_q, video_caps);
 
   /* Push audio + video + audio with increasing DTS, but PTS for video is
    * GST_CLOCK_TIME_NONE
    */
-  buf = gst_buffer_new();
+  buf = gst_buffer_new ();
   GST_BUFFER_DTS (buf) = timestamp * GST_MSECOND + base_time;
   GST_BUFFER_PTS (buf) = timestamp * GST_MSECOND + base_time;
   gst_harness_push (audio_q, buf);
 
-  buf = gst_buffer_new();
+  buf = gst_buffer_new ();
   GST_BUFFER_DTS (buf) = (timestamp + 1) * GST_MSECOND + base_time;
   GST_BUFFER_PTS (buf) = GST_CLOCK_TIME_NONE;
   gst_harness_push (video_q, buf);
 
-  buf = gst_buffer_new();
+  buf = gst_buffer_new ();
   GST_BUFFER_DTS (buf) = (timestamp + 2) * GST_MSECOND + base_time;
   GST_BUFFER_PTS (buf) = (timestamp + 2) * GST_MSECOND + base_time;
   gst_harness_push (audio_q, buf);
@@ -422,6 +419,7 @@
   gst_harness_teardown (audio_q);
   gst_harness_teardown (video_q);
 }
+
 GST_END_TEST;
 
 static Suite *
diff --git a/tests/check/elements/rtph263.c b/tests/check/elements/rtph263.c
index 64e97f5..ffa3376 100644
--- a/tests/check/elements/rtph263.c
+++ b/tests/check/elements/rtph263.c
@@ -133,9 +133,10 @@
   if (!have_element ("avenc_h263"))
     return;
 
-  h = gst_harness_new_parse (
-      "avenc_h263 rtp-payload-size=1 ! rtph263pay mtu=1350 ");
-  gst_harness_add_src_parse (h, "videotestsrc pattern=snow is-live=1 ! "
+  h = gst_harness_new_parse
+      ("avenc_h263 rtp-payload-size=1 ! rtph263pay mtu=1350 ");
+  gst_harness_add_src_parse (h,
+      "videotestsrc pattern=snow is-live=1 ! "
       "capsfilter caps=\"video/x-raw,format=I420,width=176,height=144\"", TRUE);
 
   for (i = 0; i < frames; i++)
@@ -144,6 +145,7 @@
 
   gst_harness_teardown (h);
 }
+
 GST_END_TEST;
 
 /* gst_rtp_buffer_get_payload() may return a copy of the payload. This test
@@ -155,11 +157,14 @@
   GstBuffer *header_buf, *payload_buf, *buf;
   GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
   guint8 header[] = {
-    0x04, 0x00 };
+    0x04, 0x00
+  };
   guint8 payload[] = {
-    0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4 };
+    0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4
+  };
   guint8 frame[] = {
-    0x00, 0x00, 0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4 };
+    0x00, 0x00, 0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4
+  };
 
   h = gst_harness_new ("rtph263pdepay");
   gst_harness_set_src_caps_str (h, "application/x-rtp, media=video, "
@@ -185,22 +190,26 @@
 
   gst_harness_teardown (h);
 }
+
 GST_END_TEST;
 
 /* gst_rtp_buffer_get_payload() may return a copy of the payload. This test
  * makes sure that the rtph263pdepay also produces the correct output in this
  * case. */
-GST_START_TEST (test_h263pdepay_fragmented_memory_non_writable_buffer_split_frame)
-{
+GST_START_TEST
+    (test_h263pdepay_fragmented_memory_non_writable_buffer_split_frame) {
   GstHarness *h;
   GstBuffer *header_buf, *payload_buf, *buf;
   GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
   guint8 header[] = {
-    0x04, 0x00 };
+    0x04, 0x00
+  };
   guint8 payload[] = {
-    0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4 };
+    0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4
+  };
   guint8 frame[] = {
-    0x00, 0x00, 0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4 };
+    0x00, 0x00, 0x80, 0x02, 0x1c, 0xb8, 0x01, 0x00, 0x11, 0xe0, 0x44, 0xc4
+  };
 
   h = gst_harness_new ("rtph263pdepay");
   gst_harness_set_src_caps_str (h, "application/x-rtp, media=video, "
@@ -244,6 +253,7 @@
 
   gst_harness_teardown (h);
 }
+
 GST_END_TEST;
 
 GST_START_TEST (test_h263pdepay_dont_push_empty_frame)
@@ -271,6 +281,7 @@
 
   gst_harness_teardown (h);
 }
+
 GST_END_TEST;
 
 static Suite *
@@ -288,8 +299,10 @@
   tcase_add_test (tc_chain, test_h263pay_mode_b_snow);
 
   suite_add_tcase (s, (tc_chain = tcase_create ("h263pdepay")));
-  tcase_add_test (tc_chain, test_h263pdepay_fragmented_memory_non_writable_buffer);
-  tcase_add_test (tc_chain, test_h263pdepay_fragmented_memory_non_writable_buffer_split_frame);
+  tcase_add_test (tc_chain,
+      test_h263pdepay_fragmented_memory_non_writable_buffer);
+  tcase_add_test (tc_chain,
+      test_h263pdepay_fragmented_memory_non_writable_buffer_split_frame);
   tcase_add_test (tc_chain, test_h263pdepay_dont_push_empty_frame);
 
   return s;
diff --git a/tests/check/elements/rtpjitterbuffer.c b/tests/check/elements/rtpjitterbuffer.c
index 10810fa..1a9d0e6 100644
--- a/tests/check/elements/rtpjitterbuffer.c
+++ b/tests/check/elements/rtpjitterbuffer.c
@@ -5,7 +5,7 @@
  * Copyright (C) 2012 Cisco Systems, Inc
  *               Authors: Kelley Rogers <kelro@cisco.com>
  *               Havard Graff <hgraff@cisco.com>
- * Copyright (C) 2013-2015 Pexip AS
+ * Copyright (C) 2013-2016 Pexip AS
  *               Stian Selnes <stian@pexip>
  *               Havard Graff <havard@pexip>
  *
@@ -447,6 +447,15 @@
       TRUE, seq_num, seq_num * PCMU_RTP_TS_DURATION);
 }
 
+static GstBuffer *
+generate_test_buffer_rtx (GstClockTime dts, guint seq_num)
+{
+  GstBuffer *buffer = generate_test_buffer_full (dts, TRUE, seq_num,
+      seq_num * PCMU_RTP_TS_DURATION);
+  GST_BUFFER_FLAG_SET (buffer, GST_RTP_BUFFER_FLAG_RETRANSMISSION);
+  return buffer;
+}
+
 static gint
 get_rtp_seq_num (GstBuffer * buf)
 {
@@ -520,6 +529,29 @@
   gst_event_unref (event);
 }
 
+static gboolean
+verify_jb_stats (GstElement * jb, GstStructure * expected)
+{
+  gboolean ret;
+  GstStructure *actual;
+  g_object_get (jb, "stats", &actual, NULL);
+
+  ret = gst_structure_is_subset (actual, expected);
+
+  if (!ret) {
+    gchar *e_str = gst_structure_to_string (expected);
+    gchar *a_str = gst_structure_to_string (actual);
+    fail_unless (ret, "%s is not a subset of %s", e_str, a_str);
+    g_free (e_str);
+    g_free (a_str);
+  }
+
+  gst_structure_free (expected);
+  gst_structure_free (actual);
+
+  return ret;
+}
+
 GST_START_TEST (test_only_one_lost_event_on_large_gaps)
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
@@ -604,6 +636,10 @@
   fail_unless_equals_uint64 (10 * GST_SECOND, GST_BUFFER_PTS (out_buf));
   gst_buffer_unref (out_buf);
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-lost", G_TYPE_UINT64, (guint64) 499, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
@@ -688,6 +724,11 @@
   fail_unless_equals_int (5, get_rtp_seq_num (out_buf));
   gst_buffer_unref (out_buf);
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 5,
+              "num-lost", G_TYPE_UINT64, (guint64) 1, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
@@ -749,12 +790,76 @@
   fail_unless_equals_int (5, get_rtp_seq_num (out_buf));
   gst_buffer_unref (out_buf);
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 4,
+              "num-lost", G_TYPE_UINT64, (guint64) 2, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
 
 GST_END_TEST;
 
+
+GST_START_TEST (test_num_late_when_considered_lost_arrives)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  gboolean do_lost = __i__ != 0;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-lost", do_lost, "latency", 100, NULL);
+
+  /* push the first buffer through */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (0)));
+  /* sync on the first packet */
+  gst_harness_crank_single_clock_wait (h);
+
+  /* gap of 1 */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (2)));
+
+  /* crank to output lost-event */
+  gst_harness_crank_single_clock_wait (h);
+
+  if (do_lost) {
+    /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+    for (gint i = 0; i < 3; i++)
+      gst_event_unref (gst_harness_pull_event (h));
+
+    /* we should now receive packet-lost-events for buffer 1 */
+    verify_lost_event (gst_harness_pull_event (h),
+        1, 1 * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
+  }
+
+  /* pull out buffers to ensure determinism */
+  gst_buffer_unref (gst_harness_pull (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* we have one lost packet in the stats */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 2,
+              "num-lost", G_TYPE_UINT64, (guint64) 1,
+              "num-late", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  /* buffer 1 now arrives (too late) */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (1)));
+
+  /* and this increments num-late */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 2,
+              "num-lost", G_TYPE_UINT64, (guint64) 1,
+              "num-late", G_TYPE_UINT64, (guint64) 1, NULL)));
+
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
 GST_START_TEST (test_all_packets_are_timestamped_zero)
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
@@ -809,12 +914,138 @@
   fail_unless_equals_int (5, get_rtp_seq_num (out_buf));
   gst_buffer_unref (out_buf);
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 4,
+              "num-lost", G_TYPE_UINT64, (guint64) 2, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
 
 GST_END_TEST;
 
+GST_START_TEST (test_reorder_of_non_equidistant_packets)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5;
+  GstClockID pending_id;
+  GstClockTime time;
+  gint seq, frame;
+  gint num_init_frames = 1;
+  const GstClockTime frame_dur = PCMU_BUF_DURATION;
+  const guint32 frame_rtp_ts_dur = PCMU_RTP_TS_DURATION;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  testclock = gst_harness_get_testclock (h);
+  g_object_set (h->element, "do-lost", TRUE, "latency", latency_ms, NULL);
+
+  for (frame = 0, seq = 0; frame < num_init_frames; frame++, seq += 2) {
+    /* Push a couple of packets with identical timestamp, typical for a video
+     * stream where one frame generates multiple packets. */
+    gst_harness_set_time (h, frame * frame_dur);
+    gst_harness_push (h, generate_test_buffer_full (frame * frame_dur, FALSE,
+            seq, frame * frame_rtp_ts_dur));
+    gst_harness_push (h, generate_test_buffer_full (frame * frame_dur, TRUE,
+            seq + 1, frame * frame_rtp_ts_dur));
+
+    if (frame == 0)
+      /* deadline for buffer 0 expires */
+      gst_harness_crank_single_clock_wait (h);
+
+    gst_buffer_unref (gst_harness_pull (h));
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+
+  /* Finally push the last frame reordered */
+  gst_harness_set_time (h, frame * frame_dur);
+  gst_harness_push (h, generate_test_buffer_full (frame * frame_dur, TRUE,
+          seq + 1, frame * frame_rtp_ts_dur));
+
+  /* Check the scheduled lost timer. The expected arrival of this packet
+   * should be assumed to be the same as the last packet received since we
+   * don't know wether the missing packet belonged to this or previous
+   * frame. */
+  gst_test_clock_wait_for_next_pending_id (testclock, &pending_id);
+  time = gst_clock_id_get_time (pending_id);
+  fail_unless_equals_int64 (time, frame * frame_dur + latency_ms * GST_MSECOND);
+  gst_clock_id_unref (pending_id);
+
+  /* And then missing packet arrives just in time */
+  gst_harness_set_time (h, time - 1);
+  gst_harness_push (h, generate_test_buffer_full (time - 1, FALSE, seq,
+          frame * frame_rtp_ts_dur));
+
+  gst_buffer_unref (gst_harness_pull (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_loss_equidistant_spacing_with_parameter_packets)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  GstEvent *event;
+  gint latency_ms = 5;
+  gint seq, frame;
+  gint num_init_frames = 10;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  testclock = gst_harness_get_testclock (h);
+  g_object_set (h->element, "do-lost", TRUE, "latency", latency_ms, NULL);
+
+  /* drop stream-start, caps, segment */
+  for (int i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  for (frame = 0, seq = 0; frame < num_init_frames; frame++, seq++) {
+    gst_harness_set_time (h, frame * PCMU_BUF_DURATION);
+    gst_harness_push (h, generate_test_buffer_full (frame * PCMU_BUF_DURATION,
+            TRUE, seq, frame * PCMU_RTP_TS_DURATION));
+
+    if (frame == 0)
+      /* deadline for buffer 0 expires */
+      gst_harness_crank_single_clock_wait (h);
+
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+
+  /* Push three packets with same rtptime, simulating parameter packets +
+   * frame. This should not disable equidistant mode as it is common for
+   * certain audio codecs. */
+  for (gint i = 0; i < 3; i++) {
+    gst_harness_set_time (h, frame * PCMU_BUF_DURATION);
+    gst_harness_push (h, generate_test_buffer_full (frame * PCMU_BUF_DURATION,
+            i == 2, seq++, frame * PCMU_RTP_TS_DURATION));
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+  frame++;
+
+  /* Finally push the last packet introducing a gap */
+  gst_harness_set_time (h, frame * PCMU_BUF_DURATION);
+  gst_harness_push (h, generate_test_buffer_full (frame * PCMU_BUF_DURATION,
+          TRUE, seq + 1, frame * PCMU_RTP_TS_DURATION));
+
+  /* Check that the lost event has been generated assuming equidistant
+   * spacing. */
+  event = gst_harness_pull_event (h);
+  verify_lost_event (event, seq,
+      frame * PCMU_BUF_DURATION - PCMU_BUF_DURATION / 2, PCMU_BUF_DURATION / 2);
+
+  gst_buffer_unref (gst_harness_pull (h));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+
 static void
 gst_test_clock_set_time_and_process (GstTestClock * testclock,
     GstClockTime time)
@@ -899,128 +1130,201 @@
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
   GstTestClock *testclock;
-  GstBuffer *out_buf;
-  GstEvent *out_event;
-  gint jb_latency_ms = 200;
-  const GstClockTime rtx_retry_timeout = 40 * GST_MSECOND;
-  GstStructure *rtx_stats;
-  const GValue *rtx_stat;
-  gint i;
+  gint latency_ms = 200;
+  gint rtx_delay_ms;
+  GstClockTime last_rtx_request, now;
 
-  gst_harness_set_src_caps (h, generate_caps ());
   testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      NULL);
 
-  g_object_set (h->element, "do-lost", TRUE, NULL);
-  g_object_set (h->element, "do-retransmission", TRUE, NULL);
-  g_object_set (h->element, "latency", jb_latency_ms, NULL);
-  g_object_set (h->element, "rtx-retry-period", 120, NULL);
+  for (gint i = 0; i <= latency_ms / PCMU_BUF_MS; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
 
-  /* push the first buffer in */
-  fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer (0)));
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
 
-  gst_harness_set_time (h, 20 * GST_MSECOND);
-
-  /* put second buffer, the jitterbuffer should now know that the packet
-   * spacing is 20ms and should ask for retransmission of seqnum 2 in
-   * 20ms+10ms because 2*jitter==0 and 0.5*packet_spacing==10ms */
-  fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer (1)));
-
-  /* push buffer 4, 2 and 3 are missing now, we should get
-   * retransmission events for 3 at 100ms*/
-  fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer (4)));
-
-  /* wait for first retransmission request */
-  gst_test_clock_set_time_and_process (testclock, 50 * GST_MSECOND);
+  for (gint i = 0; i <= latency_ms / PCMU_BUF_MS; i++)
+    gst_buffer_unref (gst_harness_pull (h));
 
   /* drop reconfigure event */
   gst_event_unref (gst_harness_pull_upstream_event (h));
-  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
-  for (int i = 0; i < 3; i++)
-    gst_event_unref (gst_harness_pull_event (h));
 
-  /* First event for 2 */
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 2, rtx_retry_timeout, 10, PCMU_BUF_DURATION);
+  /*
+     The expected sequence of buffers is this:
+     ____   ____   ____   ____
+     ... | 10 | | 11 | | 12 | | 13 |
+     ––––   ––––   ––––   ––––
+     200ms  220ms  240ms  260ms
 
-  /* wait for second retransmission request */
-  gst_test_clock_set_time_and_process (testclock, 60 * GST_MSECOND);
+     But instead we get this:
+     ____    _ _    _ _   ____
+     ... | 10 |  |   |  |   | | 13 |
+     ––––    - -    - -   ––––
+     200ms                260ms
 
-  /* Second event for 3 */
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 3, 60 * GST_MSECOND, 0, PCMU_BUF_DURATION);
+     Now it is important to note that the next thing that happens is that
+     the RTX timeout for packet 11 will happen at time 230ms, so we crank
+     the timer thread to advance the time to this: */
+  gst_harness_crank_single_clock_wait (h);
+  rtx_delay_ms = PCMU_BUF_MS / 2;
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      11, 11 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request,
+      11 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+  gst_harness_wait_for_clock_id_waits (h, 1, 60);
 
-  /* now we wait for the next timeout for 2 */
-  gst_test_clock_set_time_and_process (testclock, 90 * GST_MSECOND);
-
-  /* First event for 2 */
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 2, rtx_retry_timeout, 50, PCMU_BUF_DURATION);
-
-  /* now we wait for the next timeout for 3 */
-  gst_test_clock_set_time_and_process (testclock, 100 * GST_MSECOND);
-
-  /* Second event for 3 */
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 3, 60 * GST_MSECOND, 40, PCMU_BUF_DURATION);
-
-  /* make buffer 3 */
+  /* The next scheduled RTX for packet 11 is now at 230 + 40 = 270ms,
+     so the next thing that happens is that buffer 13 arrives in perfect time: */
+  now = 13 * PCMU_BUF_DURATION;
+  gst_harness_set_time (h, now);
   fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer (3)));
+      gst_harness_push (h,
+          generate_test_buffer_full (now, TRUE, 13,
+              13 * PCMU_RTP_TS_DURATION)));
 
-  /* make more buffers */
-  for (i = 5; i < 15; i++) {
+  /*
+
+     This will estimate the dts on the two missing packets to:
+     ____   ____
+     ... | 11 | | 12 | ...
+     ––––   ––––
+     220ms  240ms
+
+     And given their regular interspacing of 20ms, it will schedule two RTX
+     timers for them like so:
+
+     ____   ____
+     ... | 11 | | 12 | ...
+     ––––   ––––
+     230ms  250ms
+
+     There are however two problems, packet 11 we have already sent one RTX for
+     and its timeout is currently at 270ms, so we should not tamper with that,
+     and as for packet 12, 250ms has already expired, so we now expect to see
+     an rtx-event being sent for packet 12 immediately: */
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      12, 12 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+
+  /* and another crank will see the second RTX event being sent for packet 11 */
+  gst_harness_crank_single_clock_wait (h);
+  rtx_delay_ms += 40;
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      11, 11 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request,
+      11 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (text_rtx_two_missing_early)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 30;
+  GstClockTime last_rtx_request, now;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      NULL);
+
+  for (gint i = 0; i <= latency_ms / PCMU_BUF_MS; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
     fail_unless_equals_int (GST_FLOW_OK,
         gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
   }
 
-  gst_test_clock_set_time_and_process (testclock, 130 * GST_MSECOND);
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
 
-  /* now we only get requests for 2 */
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 2, rtx_retry_timeout, 90, PCMU_BUF_DURATION);
+  for (gint i = 0; i <= latency_ms / PCMU_BUF_MS; i++)
+    gst_buffer_unref (gst_harness_pull (h));
 
-  /* this is when buffer 0 deadline expires */
-  gst_test_clock_set_time_and_process (testclock, 200 * GST_MSECOND);
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
 
-  for (i = 0; i < 2; i++) {
-    GST_DEBUG ("popping %d", i);
-    out_buf = gst_harness_pull (h);
-    fail_unless_equals_int (i, get_rtp_seq_num (out_buf));
-    gst_buffer_unref (out_buf);
-  }
+  /*
+     The expected sequence of buffers is this:
+     ___   ___   ___   ___   ___
+     | 0 | | 1 | | 2 | | 3 | | 4 |
+     –––   –––   –––   –––   –––
+     0ms  20ms  40ms  60ms  80ms
 
-  /* this is when 2 is lost */
-  gst_test_clock_set_time_and_process (testclock, 240 * GST_MSECOND);
+     But instead we get this:
+     ___   ___   _ _   _ _   ___
+     | 0 | | 1 | |   | |   | | 4 |
+     –––   –––   – –   – –   –––
+     0ms  20ms              41ms
 
-  /* we should now receive a packet-lost-event for buffer 2 */
-  out_event = gst_harness_pull_event (h);
-  verify_lost_event (out_event, 2, 40 * GST_MSECOND, PCMU_BUF_DURATION);
+   */
 
-  /* verify that buffers made it through! */
-  for (i = 3; i < 15; i++) {
-    GST_DEBUG ("popping %d", i);
-    out_buf = gst_harness_pull (h);
-    fail_unless_equals_int (i, get_rtp_seq_num (out_buf));
-    gst_buffer_unref (out_buf);
-  }
-  /* should still have only seen 1 packet lost events,
-     so no events in the queue */
-  fail_unless_equals_int (0, gst_harness_events_in_queue (h));
+  now = 41 * GST_MSECOND;
+  gst_harness_set_time (h, now);
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h,
+          generate_test_buffer_full (now, TRUE, 4, 4 * PCMU_RTP_TS_DURATION)));
 
-  g_object_get (h->element, "stats", &rtx_stats, NULL);
+  /*
 
-  rtx_stat = gst_structure_get_value (rtx_stats, "rtx-count");
-  fail_unless_equals_uint64 (5, g_value_get_uint64 (rtx_stat));
+     With the now calculated packet-spacing of (41-20) / 3 = 7,
+     giving us these expected times:
+     ___   ___   ___   ___   ___
+     | 0 | | 1 | | 2 | | 3 | | 4 |
+     –––   –––   –––   –––   –––
+     0ms  20ms  27ms  34ms  41ms
 
-  rtx_stat = gst_structure_get_value (rtx_stats, "rtx-success-count");
-  fail_unless_equals_uint64 (1, g_value_get_uint64 (rtx_stat));
+     For RTX, the inital RTX-timeouts for the missing buffers are
+     the expected arrival time + half the packet-spacing time, like this:
+     ___   ___
+     | 2 | | 3 |
+     –––   –––
+     50ms  70ms
 
-  rtx_stat = gst_structure_get_value (rtx_stats, "rtx-rtt");
-  fail_unless_equals_uint64 (0, g_value_get_uint64 (rtx_stat));
-  gst_structure_free (rtx_stats);
+     But since we have re-calculated the estimated arrival-time
+     of these buffers, we have to adjust the RTX timeout as well,
+     and we use the original delay (packet-spacing / 2) = 10ms,
+     and add it on:
+     ___   ___
+     | 2 | | 3 |
+     –––   –––
+     37ms  44ms
+
+     Also note that the first RTX request is now scheduled for a
+     time that is prior to NOW (37ms < 41ms), so it will be sent straight
+     away without us needing to "crank" the timer-thread
+
+   */
+
+  /* The RTX request for packet 2 has timestamp 27ms and delay 10ms */
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      2, 27 * GST_MSECOND, 10, PCMU_BUF_DURATION);
+  /* and is sent immediately after packet 4 arrives (41ms) */
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, now);
+
+  /* crank the timer thread */
+  gst_harness_crank_single_clock_wait (h);
+
+  /* The RTX request for packet 3 has timestamp 34ms and delay 10ms */
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      3, 34 * GST_MSECOND, 10, PCMU_BUF_DURATION);
+  /* and is sent at 44ms */
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 44 * GST_MSECOND);
 
   gst_object_unref (testclock);
   gst_harness_teardown (h);
@@ -1073,12 +1377,12 @@
 
   /* we should now receive retransmission requests for 2 -> 5 */
   out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 2, 20 * GST_MSECOND, 30, PCMU_BUF_DURATION);
+  verify_rtx_event (out_event, 2, 20 * GST_MSECOND, 17, PCMU_BUF_DURATION);
 
   for (i = 3; i < 5; i++) {
     GST_DEBUG ("popping %d", i);
     out_event = gst_harness_pull_upstream_event (h);
-    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 0, PCMU_BUF_DURATION);
+    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 17, PCMU_BUF_DURATION);
   }
   fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
 
@@ -1089,7 +1393,7 @@
 
   /* we should now receive retransmission requests for 5 */
   out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 5, 20 * GST_MSECOND, 0, PCMU_BUF_DURATION);
+  verify_rtx_event (out_event, 5, 20 * GST_MSECOND, 17, PCMU_BUF_DURATION);
 
   /* wait for timeout for rtx 6 -> 7 */
   gst_test_clock_set_time_and_process (testclock, 60 * GST_MSECOND);
@@ -1097,7 +1401,7 @@
   for (i = 6; i < 8; i++) {
     GST_DEBUG ("popping %d", i);
     out_event = gst_harness_pull_upstream_event (h);
-    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 0, PCMU_BUF_DURATION);
+    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 17, PCMU_BUF_DURATION);
   }
 
   /* churn through 7 sync_times until the new buffer gets pushed out */
@@ -1113,9 +1417,6 @@
     gst_buffer_unref (out_buf);
   }
 
-  /* churn through 1 sync_time until the next buffer gets pushed out */
-  gst_harness_crank_single_clock_wait (h);
-
   for (i = 2; i < 8; i++) {
     GST_DEBUG ("popping lost event %d", i);
     out_event = gst_harness_pull_event (h);
@@ -1132,15 +1433,635 @@
     gst_buffer_unref (out_buf);
   }
 
-  GST_DEBUG ("waiting for 240ms");
-  gst_test_clock_set_time_and_process (testclock, 240 * GST_MSECOND);
-
   GST_DEBUG ("popping lost event 10");
   out_event = gst_harness_pull_event (h);
   verify_lost_event (out_event, 10, 40 * GST_MSECOND, PCMU_BUF_DURATION);
 
   fail_unless_equals_int (0, gst_harness_events_in_queue (h));
-  fail_unless_equals_int (20, gst_harness_upstream_events_in_queue (h));
+  fail_unless_equals_int (15, gst_harness_upstream_events_in_queue (h));
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-lost", G_TYPE_UINT64, (guint64) 7,
+              "rtx-count", G_TYPE_UINT64, (guint64) 21,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_buffer_arrives_just_in_time)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5 * PCMU_BUF_MS;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  GstBuffer *buffer;
+  GstClockTime now, last_rtx_request;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      "rtx-max-retries", 1, NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+
+  /* Crank clock to send retransmission events requesting seqnum 6 which has
+   * not arrived yet. */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 130 * GST_MSECOND);
+
+  /* seqnum 6 arrives just before it times out and is considered lost */
+  now = 200 * GST_MSECOND;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+  buffer = gst_harness_pull (h);
+  fail_unless_equals_int (6, get_rtp_seq_num (buffer));
+  gst_buffer_unref (buffer);
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 1,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) (now - last_rtx_request),
+              NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_buffer_arrives_too_late)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5 * PCMU_BUF_MS;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  GstClockTime now, last_rtx_request;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      "do-lost", TRUE, "rtx-max-retries", 1, NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+  for (gint i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  /* Crank clock to send retransmission events requesting seqnum 6 which has
+   * not arrived yet. */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 130 * GST_MSECOND);
+
+  /* seqnum 6 is considered lost */
+  gst_harness_crank_single_clock_wait (h);
+  verify_lost_event (gst_harness_pull_event (h), 6,
+      6 * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
+
+  /* seqnum 6 arrives too late */
+  now = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers,
+              "num-lost", G_TYPE_UINT64, (guint64) 1,
+              "num-late", G_TYPE_UINT64, (guint64) 1,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) (now - last_rtx_request),
+              NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_original_buffer_does_not_update_rtx_stats)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5 * PCMU_BUF_MS;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  GstBuffer *buffer;
+  GstClockTime now, last_rtx_request;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      "rtx-max-retries", 1, NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+
+  /* Crank clock to send retransmission events requesting seqnum 6 which has
+   * not arrived yet. */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 130 * GST_MSECOND);
+
+  /* ORIGINAL seqnum 6 arrives just before it times out and is considered
+   * lost. */
+  now = 200 * GST_MSECOND;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_full (now, TRUE, 6, 6 * PCMU_RTP_TS_DURATION)));
+  buffer = gst_harness_pull (h);
+  fail_unless_equals_int (6, get_rtp_seq_num (buffer));
+  gst_buffer_unref (buffer);
+
+  /* The original buffer does not count in the RTX stats. */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 1,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 0.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  /* Now the retransmitted packet arrives and stats should be updated. Note
+   * that the buffer arrives in time and should not be considered late, but
+   * a duplicate. */
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 1,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 1,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) (now - last_rtx_request),
+              NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_duplicate_packet_updates_rtx_stats)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5 * PCMU_BUF_MS;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  GstClockTime now, rtx_request_6, rtx_request_7;
+  gint rtx_delay_ms;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* Drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+
+  /* Push packet 8 so that 6 and 7 is missing */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (8)));
+
+  /* Wait for NACKs on 6 and 7 */
+  gst_harness_crank_single_clock_wait (h);
+  rtx_delay_ms = 10;
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  rtx_request_6 = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (rtx_request_6,
+      6 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      7, 7 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  rtx_request_7 = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (rtx_request_7,
+      7 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+
+  /* Original packet 7 arrives */
+  now = 150 * GST_MSECOND;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_full (now, TRUE, 7, 7 * PCMU_RTP_TS_DURATION)));
+
+  /* We're still waiting for packet 6, so 7 should not be pushed */
+  gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  fail_unless_equals_int (gst_harness_buffers_in_queue (h), 0);
+
+  /* The original buffer does not count in the RTX stats. */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 0.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  /* Push RTX packet 7. Should be dropped as duplicate but update RTX stats. */
+  now = 160 * GST_MSECOND;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 7)));
+  gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  fail_unless_equals_int (gst_harness_buffers_in_queue (h), 0);
+
+  /* Check RTX stats with updated num-duplicates and rtx-rtt fields */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 1,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) (now - rtx_request_7),
+              NULL)));
+
+  /* RTX packet 6 arrives, both 6, 7 and 8 is ready to be pulled */
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+
+  for (gint i = 6; i <= 8; i++) {
+    GstBuffer *buf = gst_harness_pull (h);
+    fail_unless_equals_int (i, get_rtp_seq_num (buf));
+    gst_buffer_unref (buf);
+  }
+
+  /* RTX stats is updated with success count increased. */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 3,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 1,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64)
+              /* Use the rtx-rtt formula. Can be subject to change though. */
+              ((now - rtx_request_6) + 47 * (now - rtx_request_7)) / 48,
+              NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_buffer_arrives_after_lost_updates_rtx_stats)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 5 * PCMU_BUF_MS;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  GstClockTime now, last_rtx_request;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      "do-lost", TRUE, "rtx-max-retries", 1, NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+  for (gint i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  /* Crank clock to send retransmission events requesting seqnum 6 which has
+   * not arrived yet. */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 130 * GST_MSECOND);
+
+  /* seqnum 6 is considered lost */
+  gst_harness_crank_single_clock_wait (h);
+  verify_lost_event (gst_harness_pull_event (h), 6,
+      6 * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
+
+  /* seqnum 6 arrives too late */
+  now = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers,
+              "num-lost", G_TYPE_UINT64, (guint64) 1,
+              "num-late", G_TYPE_UINT64, (guint64) 1,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-per-packet", G_TYPE_DOUBLE, 1.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) (now - last_rtx_request),
+              NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_rtt_larger_than_retry_timeout)
+{
+  /* When RTT is larger than retry period we will send two or more requests
+   * before receiving any retransmission packets */
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstTestClock *testclock;
+  gint latency_ms = 100;
+  gint num_init_buffers = latency_ms / PCMU_BUF_MS + 1;
+  gint rtx_retry_timeout_ms = 20;
+  gint rtx_delay_ms = 10;
+  gint rtt = rtx_retry_timeout_ms * GST_MSECOND + 1;
+  GstClockTime now, first_request, second_request;
+
+  testclock = gst_harness_get_testclock (h);
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-retransmission", TRUE, "latency", latency_ms,
+      "rtx-retry-timeout", rtx_retry_timeout_ms, NULL);
+
+  /* Push/pull buffers and advance time past buffer 0's timeout (in order to
+   * simplify the test) */
+  for (gint i = 0; i < num_init_buffers; i++) {
+    gst_test_clock_set_time (testclock, i * PCMU_BUF_DURATION);
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_harness_wait_for_clock_id_waits (h, 1, 60);
+  }
+
+  gst_harness_crank_single_clock_wait (h);
+  fail_unless_equals_int64 (latency_ms * GST_MSECOND,
+      gst_clock_get_time (GST_CLOCK (testclock)));
+
+  for (gint i = 0; i < num_init_buffers; i++)
+    gst_buffer_unref (gst_harness_pull (h));
+
+  /* Drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+
+  /* Wait for first NACK on 6 */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  first_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (first_request,
+      6 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+
+  /* Packet 7 arrives in time (so that we avoid its EXPECTED timers to
+   * interfer with our test) */
+  gst_test_clock_set_time (testclock, 7 * PCMU_BUF_DURATION);
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (7)));
+
+  /* Simulating RTT > rtx-retry-timeout, we send a new NACK before receiving
+   * the RTX packet. Wait for second NACK on 6 */
+  gst_harness_crank_single_clock_wait (h);
+  rtx_delay_ms += rtx_retry_timeout_ms;
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, rtx_delay_ms, PCMU_BUF_DURATION);
+  second_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (second_request,
+      6 * PCMU_BUF_DURATION + rtx_delay_ms * GST_MSECOND);
+
+  /* The first retransmitted packet arrives */
+  now = first_request + rtt;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+
+  /* Pull packet 6 and 7 */
+  gst_buffer_unref (gst_harness_pull (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* Stats should be updated. Note that RTT is not updated since we cannot be
+   * sure whether the RTX packet is in response to the first or second NACK. */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 2,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 0,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-per-packet", G_TYPE_DOUBLE, 2.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  /* Packet 8 arrives in time */
+  gst_test_clock_set_time (testclock, 8 * PCMU_BUF_DURATION);
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (8)));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* Now the second retransmitted packet arrives */
+  now = second_request + rtt;
+  gst_test_clock_set_time (testclock, now);
+  fail_unless_equals_int (GST_FLOW_OK, gst_harness_push (h,
+          generate_test_buffer_rtx (now, 6)));
+
+  /* The stats is updated with the correct RTT. */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) num_init_buffers + 3,
+              "num-lost", G_TYPE_UINT64, (guint64) 0,
+              "num-late", G_TYPE_UINT64, (guint64) 0,
+              "num-duplicates", G_TYPE_UINT64, (guint64) 1,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 1,
+              "rtx-per-packet", G_TYPE_DOUBLE, 2.0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) rtt, NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_no_request_if_time_past_retry_period)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  const gint latency_ms = 200;
+  const gint retry_period_ms = 120;
+  GstTestClock *testclock;
+  GstClockID pending_id, processed_id;
+  GstClockTime time;
+  GstEvent *event;
+  gint i;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  testclock = gst_harness_get_testclock (h);
+
+  g_object_set (h->element, "do-lost", TRUE, NULL);
+  g_object_set (h->element, "do-retransmission", TRUE, NULL);
+  g_object_set (h->element, "latency", latency_ms, NULL);
+  g_object_set (h->element, "rtx-retry-period", retry_period_ms, NULL);
+
+  /* push the first couple of buffers */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (0)));
+
+  gst_harness_set_time (h, 1 * PCMU_BUF_DURATION);
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (1)));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+  for (i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  /* Wait for the first EXPECTED timer to be scheduled */
+  gst_test_clock_wait_for_next_pending_id (testclock, &pending_id);
+  time = gst_clock_id_get_time (pending_id);
+  fail_unless_equals_int64 (time, 2 * PCMU_BUF_DURATION + 10 * GST_MSECOND);
+
+  /* Let the first EXPECTED timer time out and be sent. However, set the 'now'
+   * time to be past the retry-period simulating that the jitterbuffer has too
+   * much to do and is not able to process all timers in real-time. In this
+   * case the jitterbuffer should not schedule a new EXPECTED timer as that
+   * would just make matters worse (more unnecessary processing of a request
+   * that is already too late to be valuable). In practice this typically
+   * happens for high loss networks with low RTT. */
+  gst_test_clock_set_time (testclock,
+      2 * PCMU_BUF_DURATION + retry_period_ms * GST_MSECOND + 1);
+  processed_id = gst_test_clock_process_next_clock_id (testclock);
+  fail_unless (pending_id == processed_id);
+  gst_clock_id_unref (pending_id);
+  gst_clock_id_unref (processed_id);
+
+  /* Verify the event. It could be argued that this request is already too
+   * late and unnecessary. However, in order to keep things simple (for now)
+   * we just keep the already scehduled EXPECTED timer, but refrain from
+   * scheduled another EXPECTED timer */
+  event = gst_harness_pull_upstream_event (h);
+  verify_rtx_event (event, 2, 2 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  /* "crank" to reach the DEADLINE for packet 0 */
+  gst_harness_crank_single_clock_wait (h);
+  gst_buffer_unref (gst_harness_pull (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
+  fail_unless_equals_int (0, gst_harness_events_in_queue (h));
+
+  /* "crank" to time out the LOST event */
+  gst_harness_crank_single_clock_wait (h);
+  event = gst_harness_pull_event (h);
+  verify_lost_event (event, 2, 2 * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
 
   gst_object_unref (testclock);
   gst_harness_teardown (h);
@@ -1154,8 +2075,6 @@
   GstTestClock *testclock;
   const gint jb_latency_ms = 200;
 
-  guint32 timestamp_ms = 0;
-  guint32 rtp_ts = 0;
   gint i;
   GstEvent *out_event;
   GstBuffer *out_buf;
@@ -1172,10 +2091,7 @@
   fail_unless_equals_int (GST_FLOW_OK,
       gst_harness_push (h, generate_test_buffer (0)));
 
-  timestamp_ms += 20;
-  rtp_ts += PCMU_RTP_TS_DURATION;
-  gst_harness_set_time (h, timestamp_ms * GST_MSECOND);
-
+  gst_harness_set_time (h, 1 * PCMU_BUF_DURATION);
   fail_unless_equals_int (GST_FLOW_OK,
       gst_harness_push (h, generate_test_buffer (1)));
 
@@ -1210,12 +2126,23 @@
   fail_unless_equals_int (GST_FLOW_OK,
       gst_harness_push (h, generate_test_buffer (16)));
 
-  /* FIXME: something is up with the timestamp here!!?! */
+  /* Manually check the first rtx event */
   out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 6, 119999994, 0, PCMU_BUF_DURATION);
-  /* lost more rtx with weird timestamps... */
-  for (i = 0; i < 13; i++) {
-    gst_event_unref (gst_harness_pull_upstream_event (h));
+  verify_rtx_event (out_event, 6, 6 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+  /* Go throught the rest of rtx events. A bit more relaxed since order is
+   * partly an implentation detail. */
+  for (i = 0; i < 12; i++) {
+    const GstStructure *s;
+    guint seqnum, retry;
+
+    fail_unless (out_event = gst_harness_pull_upstream_event (h));
+    fail_unless (s = gst_event_get_structure (out_event));
+    fail_unless (gst_structure_get_uint (s, "seqnum", &seqnum));
+    fail_unless (gst_structure_get_uint (s, "retry", &retry));
+    fail_unless (seqnum >= 6 && seqnum <= 12);
+
+    verify_rtx_event (out_event, seqnum, seqnum * PCMU_BUF_DURATION,
+        10 + retry * 40, PCMU_BUF_DURATION);
   }
 
   fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
@@ -1227,23 +2154,20 @@
         gst_harness_push (h, generate_test_buffer (i)));
   }
 
-  /* FIXME: wtf is going on with timestamps and durations here??!? */
   gst_harness_crank_single_clock_wait (h);
   out_event = gst_harness_pull_event (h);
-  verify_lost_event (out_event, 3, 41428571, 78571423);
-
-  /* FIXME: and these rtx... */
-  gst_harness_crank_single_clock_wait (h);
-  out_event = gst_harness_pull_upstream_event (h);
-  verify_rtx_event (out_event, 7, 141428565, 120, PCMU_BUF_DURATION);
+  verify_lost_event (out_event, 3, 3 * PCMU_BUF_DURATION,
+      3 * PCMU_BUF_DURATION);
 
   gst_harness_crank_single_clock_wait (h);
   out_event = gst_harness_pull_event (h);
-  verify_lost_event (out_event, 6, 119999994, 21428571);
+  verify_lost_event (out_event, 6, 6 * PCMU_BUF_DURATION,
+      1 * PCMU_BUF_DURATION);
 
   gst_harness_crank_single_clock_wait (h);
   out_event = gst_harness_pull_event (h);
-  verify_lost_event (out_event, 7, 141428565, 21428571);
+  verify_lost_event (out_event, 7, 7 * PCMU_BUF_DURATION,
+      1 * PCMU_BUF_DURATION);
 
   /* 8 */
   for (i = 8; i <= 16; i++) {
@@ -1274,6 +2198,14 @@
   fail_unless_equals_int (0, gst_harness_events_in_queue (h));
   fail_unless_equals_int (0, gst_harness_buffers_in_queue (h));
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 11,
+              "num-lost", G_TYPE_UINT64, (guint64) 7,
+              "rtx-count", G_TYPE_UINT64, (guint64) 19,
+              "rtx-success-count", G_TYPE_UINT64, (guint64) 0,
+              "rtx-rtt", G_TYPE_UINT64, (guint64) 0, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
@@ -1360,6 +2292,10 @@
     verify_lost_event (out_event, i, i * dur, dur);
   }
 
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-lost", G_TYPE_UINT64, (guint64) 4, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
@@ -1488,12 +2424,53 @@
   fail_unless_equals_int ((4 + seq_offset) & 0xffff, get_rtp_seq_num (buffer));
   gst_buffer_unref (buffer);
 
+  /* we have lost 3, and one of them arrived eventually, but too late */
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 2,
+              "num-lost", G_TYPE_UINT64, (guint64) 3,
+              "num-late", G_TYPE_UINT64, (guint64) 1, NULL)));
+
   gst_object_unref (testclock);
   gst_harness_teardown (h);
 }
 
 GST_END_TEST;
 
+GST_START_TEST (test_performance)
+{
+  GstHarness *h =
+      gst_harness_new_parse
+      ("rtpjitterbuffer do-lost=1 do-retransmission=1 latency=1000");
+  GTimer *timer = g_timer_new ();
+  const gdouble test_duration = 2.0;
+  guint buffers_pushed = 0;
+  guint buffers_received;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  gst_harness_use_systemclock (h);
+
+  while (g_timer_elapsed (timer, NULL) < test_duration) {
+    /* Simulate 1ms packets */
+    guint n = buffers_pushed * 2;       // every packet also produces a gap
+    guint16 seqnum = n & 0xffff;
+    guint32 rtp_ts = n * 8;
+    GstClockTime dts = n * GST_MSECOND;
+    gst_harness_push (h, generate_test_buffer_full (dts, TRUE, seqnum, rtp_ts));
+    buffers_pushed++;
+    g_usleep (G_USEC_PER_SEC / 10000);
+  }
+  g_timer_destroy (timer);
+
+  buffers_received = gst_harness_buffers_received (h);
+  GST_INFO ("Pushed %d, received %d (%.1f%%)", buffers_pushed, buffers_received,
+      100.0 * buffers_received / buffers_pushed);
+
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
 static Suite *
 rtpjitterbuffer_suite (void)
 {
@@ -1506,13 +2483,30 @@
   tcase_add_test (tc_chain, test_push_unordered);
   tcase_add_test (tc_chain, test_basetime);
   tcase_add_test (tc_chain, test_clear_pt_map);
+
   tcase_add_test (tc_chain, test_only_one_lost_event_on_large_gaps);
   tcase_add_test (tc_chain, test_two_lost_one_arrives_in_time);
   tcase_add_test (tc_chain, test_late_packets_still_makes_lost_events);
   tcase_add_test (tc_chain, test_all_packets_are_timestamped_zero);
+  tcase_add_loop_test (tc_chain, test_num_late_when_considered_lost_arrives, 0,
+      2);
+  tcase_add_test (tc_chain, test_reorder_of_non_equidistant_packets);
+  tcase_add_test (tc_chain,
+      test_loss_equidistant_spacing_with_parameter_packets);
+
   tcase_add_test (tc_chain, test_rtx_expected_next);
   tcase_add_test (tc_chain, test_rtx_two_missing);
+  tcase_add_test (tc_chain, text_rtx_two_missing_early);
   tcase_add_test (tc_chain, test_rtx_packet_delay);
+  tcase_add_test (tc_chain, test_rtx_buffer_arrives_just_in_time);
+  tcase_add_test (tc_chain, test_rtx_buffer_arrives_too_late);
+  tcase_add_test (tc_chain, test_rtx_original_buffer_does_not_update_rtx_stats);
+  tcase_add_test (tc_chain, test_rtx_duplicate_packet_updates_rtx_stats);
+  tcase_add_test (tc_chain,
+      test_rtx_buffer_arrives_after_lost_updates_rtx_stats);
+  tcase_add_test (tc_chain, test_rtx_rtt_larger_than_retry_timeout);
+  tcase_add_test (tc_chain, test_rtx_no_request_if_time_past_retry_period);
+
   tcase_add_test (tc_chain, test_gap_exceeds_latency);
   tcase_add_test (tc_chain, test_deadline_ts_offset);
   tcase_add_test (tc_chain, test_dts_gap_larger_than_latency);
@@ -1522,6 +2516,8 @@
       test_considered_lost_packet_in_large_gap_arrives, 0,
       G_N_ELEMENTS (test_considered_lost_packet_in_large_gap_arrives_input));
 
+  tcase_add_test (tc_chain, test_performance);
+
   return s;
 }
 
diff --git a/tests/check/elements/rtpsession.c b/tests/check/elements/rtpsession.c
index faeb653..c4d2185 100644
--- a/tests/check/elements/rtpsession.c
+++ b/tests/check/elements/rtpsession.c
@@ -669,25 +669,27 @@
   *cb_called = TRUE;
 
   /* We should be able to get a rtpsession property
-  without introducing the deadlock */
+     without introducing the deadlock */
   g_object_get (object, "num-sources", &num_sources, NULL);
 }
 
 GST_START_TEST (test_dont_lock_on_stats)
 {
-  GstHarness * h_rtcp;
-  GstHarness * h_send;
-  GstClock * clock = gst_test_clock_new ();
-  GstTestClock * testclock = GST_TEST_CLOCK (clock);
+  GstHarness *h_rtcp;
+  GstHarness *h_send;
+  GstClock *clock = gst_test_clock_new ();
+  GstTestClock *testclock = GST_TEST_CLOCK (clock);
   gboolean cb_called = FALSE;
 
   /* use testclock as the systemclock to capture the rtcp thread waits */
   gst_system_clock_set_default (GST_CLOCK (testclock));
 
-  h_rtcp = gst_harness_new_with_padnames (
-      "rtpsession", "recv_rtcp_sink", "send_rtcp_src");
-  h_send = gst_harness_new_with_element (
-      h_rtcp->element, "send_rtp_sink", "send_rtp_src");
+  h_rtcp =
+      gst_harness_new_with_padnames ("rtpsession", "recv_rtcp_sink",
+      "send_rtcp_src");
+  h_send =
+      gst_harness_new_with_element (h_rtcp->element, "send_rtp_sink",
+      "send_rtp_src");
 
   /* connect to the stats-reporting */
   g_signal_connect (h_rtcp->element, "notify::stats",
@@ -702,6 +704,7 @@
   gst_harness_teardown (h_rtcp);
   gst_object_unref (clock);
 }
+
 GST_END_TEST;
 
 static void
diff --git a/tests/check/elements/rtpvp9.c b/tests/check/elements/rtpvp9.c
index 1430c5f..123069e 100644
--- a/tests/check/elements/rtpvp9.c
+++ b/tests/check/elements/rtpvp9.c
@@ -93,6 +93,7 @@
 
   gst_harness_teardown (h);
 }
+
 GST_END_TEST;
 
 
diff --git a/tests/check/pipelines/tagschecking.c b/tests/check/pipelines/tagschecking.c
index 3f1a686..13c72b5 100644
--- a/tests/check/pipelines/tagschecking.c
+++ b/tests/check/pipelines/tagschecking.c
@@ -91,7 +91,8 @@
 
   GST_DEBUG ("testing xmp muxing on : %s", muxer);
 
-  launch_str = g_strdup_printf ("fakesrc num-buffers=1 format=time ! "
+  launch_str =
+      g_strdup_printf ("fakesrc num-buffers=1 format=time datarate=100 ! "
       "%s ! %s name=mux ! filesink location=%s name=sink", caps, muxer, file);
   pipeline = gst_parse_launch (launch_str, NULL);
   g_free (launch_str);
diff --git a/win32/common/config.h b/win32/common/config.h
index 5a46b02..3869d7a 100644
--- a/win32/common/config.h
+++ b/win32/common/config.h
@@ -64,7 +64,7 @@
 #define GST_PACKAGE_ORIGIN "Unknown package origin"
 
 /* GStreamer package release date/time for plugins as YYYY-MM-DD */
-#define GST_PACKAGE_RELEASE_DATETIME "2016-09-01"
+#define GST_PACKAGE_RELEASE_DATETIME "2016-09-30"
 
 /* Define if static plugins should be built */
 #undef GST_PLUGIN_BUILD_STATIC
@@ -401,7 +401,7 @@
 #define PACKAGE_NAME "GStreamer Good Plug-ins"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "GStreamer Good Plug-ins 1.9.2"
+#define PACKAGE_STRING "GStreamer Good Plug-ins 1.9.90"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "gst-plugins-good"
@@ -410,7 +410,7 @@
 #undef PACKAGE_URL
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "1.9.2"
+#define PACKAGE_VERSION "1.9.90"
 
 /* directory where plugins are located */
 #ifdef _DEBUG
@@ -445,7 +445,7 @@
 #undef TARGET_CPU
 
 /* Version number of package */
-#define VERSION "1.9.2"
+#define VERSION "1.9.90"
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
