diff --git a/ChangeLog b/ChangeLog
index f6c4a0f..3501525 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,9 +1,535 @@
-=== release 1.10.2 ===
+=== release 1.10.3 ===
 
-2016-11-29  Sebastian Dröge <slomo@coaxion.net>
+2017-01-30  Sebastian Dröge <slomo@coaxion.net>
 
 	* configure.ac:
-	  releasing 1.10.2
+	  releasing 1.10.3
+
+2017-01-30 13:33:23 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* po/el.po:
+	  po: Update translations
+
+2017-01-27 16:14:16 +0200  Vivia Nikolaidou <vivia@toolsonair.com>
+
+	* gst/isomp4/atoms.c:
+	  qtmux: Timecode track fixes for STSD entry
+	  The n_frames field (frames per second) should follow the nominal frame
+	  rate for drop-frame timecodes.
+	  Also, the trak's timescale (and duration, accordingly) should follow the
+	  STSD entry's timescale and frame duration (fps_n and fps_d accordingly),
+	  not the other way around.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777832
+
+2017-01-19 11:08:11 +0100  Arnaud Vrac <avrac@freebox.fr>
+
+	* ext/soup/gstsouphttpsrc.c:
+	  souphttpsrc: retry request on early termination from the server
+	  Fix a regression introduced by commit 183695c61a54f1 (refactor to use
+	  Soup's sync API). The code previously attempted to reconnect when the
+	  server closed the connection early, for example when the stream was put
+	  in pause for some time.
+	  Reintroduce this feature by checking if EOS is received before the
+	  expected content size is downloaded. In this case, do the request
+	  starting at the previous read position.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776720
+
+2017-01-10 09:40:56 -0700  Matt Staples <staples255@gmail.com>
+
+	* gst/rtsp/gstrtspsrc.c:
+	  rtspsrc: find_stream_by_channel should ignore unconfigured streams
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777101
+
+2017-01-25 18:43:00 +0000  Brendan Shanks <brendan.shanks@teradek.com>
+
+	* gst/isomp4/gstqtmux.c:
+	  qtmux: Fix debug typo and remove misleading warning
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777362
+
+2017-01-26 13:54:14 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/autodetect/gstautodetect.c:
+	  Revert "autodetect: bring the element state down after success"
+	  This reverts commit 67f6d3358e4620319335065db25edaaba1f5ae0a.
+	  It causes problems in certain scenarios and needs further investigation
+	  https://bugzilla.gnome.org/show_bug.cgi?id=764947#c9
+
+2017-01-09 11:32:35 +0530  Rahul Bedarkar <rahul.bedarkar@imgtec.com>
+
+	* gst/wavparse/gstwavparse.c:
+	  wavparse: check for not NULL before clearing adapter
+	  In case wavparse receives a manually injected FLUSH_STOP event
+	  while operating in pull mode we get criticals because we'd try
+	  to clear a NULL adapter.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777123
+
+2017-01-20 17:16:10 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/avi/gstavidemux.c:
+	  avidemux: Stop reading a ncdt sub-tag if it goes behind the surrounding tag
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777532
+
+2017-01-20 07:58:26 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/avi/gstavidemux.c:
+	  avidemux: Fix various out of bounds reads when parsing ncdt tags
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777500
+
+2017-01-19 13:46:58 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Increment current stts index whenever we finished one stts entry
+	  Otherwise we could read more chunks than there are available, doing an
+	  out of bounds read and potentially crash.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777469
+
+2017-01-19 13:25:53 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  Revert "qtdemux: Increment current stts index in all code paths after reading one chunk"
+	  This reverts commit 99d5d7570d0b53dad3bc8eb653b1320ee422aace. It broke
+	  playback of various valid files.
+
+2017-01-19 07:52:33 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Increment current stts index in all code paths after reading one chunk
+	  Otherwise we could read more chunks than there are available, doing an
+	  out of bounds read and potentially crash.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777469
+
+2017-01-13 16:40:43 +0100  Arnaud Vrac <avrac@freebox.fr>
+
+	* ext/soup/gstsouphttpsrc.c:
+	  souphttpsrc: properly track redirections
+	  The current code configures libsoup to handle redirections
+	  transparently, without informing the caller, thus preventing the element
+	  to record the redirect code and location uri.
+	  Fix this by always setting the SOUP_MESSAGE_NO_REDIRECT, preventing
+	  libsoup from handling the redirection. When we receive a redirection
+	  request and libsoup can safely handle it, return a custom error which
+	  triggers a retry with the new URI.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777222
+
+2017-01-13 00:01:06 +1100  Jan Schmidt <jan@centricular.com>
+
+	* gst/isomp4/gstqtmux.c:
+	  qtmux: Don't reset request pad numbering across uses
+	  When reset, don't restart request pad numberings, as
+	  request pads can survive across state changes. Only
+	  restart at 0 if all request pads are handed back first.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777174
+
+2017-01-11 17:53:32 -0800  Andre McCurdy <armccurdy@gmail.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: free seqh after calling qtdemux_parse_svq3_stsd_data()
+	  The seqh buffer allocated in qtdemux_parse_svq3_stsd_data() needs to
+	  be freed by the caller after use.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777157
+	  Signed-off-by: Andre McCurdy <armccurdy@gmail.com>
+
+2017-01-16 15:17:15 +0100  Jean-Christophe Trotin <jean-christophe.trotin@st.com>
+
+	* sys/v4l2/gstv4l2allocator.c:
+	  v4l2allocator: fix memory type in allocator probe
+	  The buffer memory type provided to the VIDIOC_CREATE_BUFS ioctl shall
+	  be set with the value ("memory") given as input parameter of the
+	  gst_v4l2_allocator_probe() function.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777327
+
+2016-11-11 14:31:03 +1100  Matthew Waters <matthew@centricular.com>
+
+	* gst/autodetect/gstautodetect.c:
+	  autodetect: bring the element state down after success
+	  Otherwise some messages that are emitted by the element on NULL->READY
+	  will not reach the application.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=764947
+
+2016-04-24 21:38:51 +0900  Seungha Yang <sh.yang@lge.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Fix key_time in gst_qtdemux_adjust_seek()
+	  time in segment should be PTS based (not DTS).
+	  https://bugzilla.gnome.org/show_bug.cgi?id=765498
+
+2017-01-07 23:55:42 +1100  Jan Schmidt <jan@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Don't reset output timestamps when no tfdt
+	  If a fragmented stream doesn't have a tfdt, don't
+	  reset the output timestamps at each fragment boundary
+	  by erroneously using the default value of 0. Introduced
+	  by commit 69fc48
+	  https://bugzilla.gnome.org/show_bug.cgi?id=754230
+
+2016-12-14 21:45:15 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Check if we have enough data available when parsing edit lists
+	  Also consume the data entry by entry to get complicated indexing out of
+	  the code.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776107
+
+2016-12-14 10:15:10 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Check that the XiTh size is big enough
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775794
+
+2016-12-09 20:27:53 +0900  Heekyoung Seo <heekyoung.seo@lge.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Check node length of video sample description
+	  Add check for node length of video sample description and its fields and
+	  for the XiTh atom.
+	  Also unify the code a bit.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775794
+
+2016-12-11 13:27:27 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/audiofx/gstscaletempo.c:
+	  scaletempo: Ensure to reinit buffers whenever they were not allocated yet
+	  That is, whenever we go through start/stop we have to ensure that on the
+	  next opportunity the buffers are reallocated again. Otherwise the
+	  buffers might be NULL because the element was reused with the same
+	  configuration as before (i.e. set_caps() wouldn't have reinited the
+	  buffers).
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775898
+
+2016-12-09 17:55:39 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/flx/gstflxdec.c:
+	* gst/flx/gstflxdec.h:
+	  flxdec: Only send SEGMENT events after CAPS
+	  I.e., don't just forward the event but delay it if we don't have caps on
+	  the srcpad yet.
+
+2016-12-09 17:49:40 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/flx/gstflxdec.c:
+	  flxdec: Unref and unmap buffers in all code paths as needed
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775888
+
+2016-12-06 07:48:47 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/flx/gstflxdec.c:
+	  flxdec: Allocate 0-initialized memory for the decoded frame
+	  Otherwise we might leak arbitrary information from the uninitialized
+	  memory if not every pixel is written.
+	  https://scarybeastsecurity.blogspot.gr/2016/12/1days-0days-pocs-more-gstreamer-flic.html
+
+2016-12-05 07:57:19 -0700  Matt Staples <staples255@gmail.com>
+
+	* gst/rtsp/gstrtspsrc.c:
+	  rtspsrc: Fix session cleanup when handling redirect on PLAY
+	  Redirect on PLAY wasn't doing the necessary session cleanup. Fixed by
+	  removing code from gst_rtspsrc_send that changed the state varable upon
+	  encountering a redirect. Better to let the redirect handlers in
+	  gst_rtspsrc_retrieve_sdp and gst_rtspsrc_play do their own
+	  state-dependent cleanup.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775543
+
+2016-12-01 17:08:09 +0100  Edward Hervey <bilboed@bilboed.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* gst/rtpmanager/rtpjitterbuffer.c:
+	  jitterbuffer: Don't leak duplicate items
+	  When providing items with a seqnum, there is a (very small) probability
+	  that an element with the same seqnum already exists. Don't forget
+	  to free that item if it wasn't inserted.
+	  And avoid returning undefined values when dealing with duplicate items
+
+2016-11-03 15:03:59 +0100  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: fix timer-reuse bug
+	  When doing rtx, the jitterbuffer will always add an rtx-timer for the next
+	  sequence number.
+	  In the case of the packet corresponding to that sequence number arriving,
+	  that same timer will be reused, and simply moved on to wait for the
+	  following sequence number etc.
+	  Once an rtx-timer expires (after all retries), it will be rescheduled as
+	  a lost-timer instead for the same sequence number.
+	  Now, if this particular sequence-number now arrives (after the timer has
+	  become a lost-timer), the reuse mechanism *should* now set a new
+	  rtx-timer for the next sequence number, but the bug is that it does
+	  not change the timer-type, and hence schedules a lost-timer for that
+	  following sequence number, with the result that you will have a very
+	  early lost-event for a packet that might still arrive, and you will
+	  never be able to send any rtx for this packet.
+	  Found by Erlend Graff - erlend@pexip.com
+	  https://bugzilla.gnome.org/show_bug.cgi?id=773891
+
+2016-10-09 15:59:05 +0200  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* gst/rtpmanager/rtpjitterbuffer.c:
+	* gst/rtpmanager/rtpjitterbuffer.h:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: fix lost-event using dts instead of pts
+	  The lost-event was using a different time-domain (dts) than the outgoing
+	  buffers (pts). Given certain network-conditions these two would become
+	  sufficiently different and the lost-event contained timestamp/duration
+	  that was really wrong. As an example GstAudioDecoder could produce
+	  a stream that jumps back and forth in time after receiving a lost-event.
+	  The previous behavior calculated the pts (based on the rtptime) inside the
+	  rtp_jitter_buffer_insert function, but now this functionality has been
+	  refactored into a new function rtp_jitter_buffer_calculate_pts that is
+	  called much earlier in the _chain function to make pts available to
+	  various calculations that wrongly used dts previously
+	  (like the lost-event).
+	  There are however two calculations where using dts is the right thing to
+	  do: calculating the receive-jitter and the rtx-round-trip-time, where the
+	  arrival time of the buffer from the network is the right metric
+	  (and is what dts in fact is today).
+	  The patch also adds two tests regarding B-frames or the
+	  “rtptime-going-backwards”-scenario, as there were some concerns that this
+	  patch might break this behavior (which the tests shows it does not).
+
+2016-11-03 16:33:53 +0100  Havard Graff <havard.graff@gmail.com>
+
+	* gst/rtpmanager/gstrtpjitterbuffer.c:
+	* tests/check/elements/rtpjitterbuffer.c:
+	  rtpjitterbuffer: fix bug in reschedule_timer
+	  The new timeout is always going to be (timeout + delay), however, the
+	  old behavior compared the current timeout to just (timeout), basically
+	  being (delay) off.
+	  This would happen if rtx-delay == rtx-retry-timeout, with the result that
+	  a second rtx attempt for any buffers would be scheduled immediately instead
+	  of after rtx-delay ms.
+	  Simply calculate (new_timeout = timeout + delay) and then use that instead.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=773905
+
+2016-12-01 15:06:06 +0530  Garima Gaur <garima.g@samsung.com>
+
+	* gst/rtp/gstrtph264depay.c:
+	* gst/rtp/gstrtpsbcdepay.c:
+	  rtp: Fix some memory leaks in usage of gst_pad_get_current_caps()
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775071
+
+2016-12-01 11:23:02 +0100  Edward Hervey <edward@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Sanitize unknown codec caps
+	  We might have non-printable characters in the unknown fourcc, replace
+	  them with '_', in the same way we do it for unknown tags.
+
+2016-12-01 20:04:28 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/avi/gstavidemux.c:
+	  avidemux: Free vprp chunk also if it existed but we made no use of it
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775479
+
+2016-12-01 17:38:33 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/matroska/matroska-read-common.c:
+	  matroskademux: Fix memory leak when parsing attachments
+	  gst_tag_image_data_to_image_sample() does not take ownership of the
+	  passed memory, so don't set it to NULL to allow us to free it later.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775472
+
+2016-12-01 14:56:18 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/matroska/matroska-read-common.c:
+	  matroskademux: Unify zlib/bzip2 decompress loops with the ones from qtdemux
+	  Especially, simplify the code a bit.
+
+2016-12-01 14:41:48 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Increase inflate buffer in bigger steps
+	  1024 bytes is quite small, let's do 4096 bytes (or one page).
+	  Also remove redundant if, we're always in that case when getting here.
+
+2016-12-01 14:30:49 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Ensure that size of the pasp atom is as much as we need
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775455
+
+2016-12-01 14:27:55 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Fix zlib inflate loop
+	  Handle errors cleanly, deallocate all memory and return the actual size
+	  of the inflated data.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775455
+
+2016-12-01 14:30:10 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Free compressed moov node and it's corresponding decompressed data
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775455
+
+2016-12-01 14:29:21 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Check size of compressed MOOV header against available data
+	  And actually read the size of the cmvd atom from the right position.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775455
+
+2016-12-01 13:38:16 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/audioparsers/gstaacparse.c:
+	  aacparse: Make sure we have enough data in the codec_data to be able to parse it
+	  Also error out cleanly if mapping the buffer failed.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775450
+
+2016-12-01 13:32:22 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Fix out of bounds read in tag parsing code
+	  We can't simply assume that the length of the tag value as given
+	  inside the stream is correct but should also check against the amount of
+	  data we have actually available.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775451
+
+2016-10-26 13:21:29 +0200  Alejandro G. Castro <alex@igalia.com>
+
+	* gst/rtpmanager/gstrtpsession.c:
+	* gst/rtpmanager/rtpsession.c:
+	* gst/rtpmanager/rtpsession.h:
+	  rtpbin: pipeline gets an EOS when any rtpsources byes
+	  Instead of sending EOS when a source byes we have to wait for
+	  all the sources to be gone, which means they already sent BYE and
+	  were removed from the session. We now handle the EOS in the rtcp
+	  loop checking the amount of sources in the session.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=773218
+
+2016-10-24 16:56:31 +0000  Enrique Ocaña González <eocanha@igalia.com>
+
+	* gst/isomp4/qtdemux.c:
+	  qtdemux: Use the tfdt decode time on byte streams when it's significantly different than the time in the last sample
+	  We consider there's a sifnificant difference when it's larger than on second
+	  or than half the duration of the last processed fragment in case the latter is
+	  larger.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=754230
+
+=== release 1.10.2 ===
+
+2016-11-29 16:21:19 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ChangeLog:
+	* NEWS:
+	* RELEASE:
+	* configure.ac:
+	* docs/plugins/gst-plugins-good-plugins.args:
+	* 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.10.2
+
+2016-11-29 15:34:11 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* po/af.po:
+	* po/az.po:
+	* po/bg.po:
+	* po/ca.po:
+	* po/cs.po:
+	* po/da.po:
+	* po/de.po:
+	* po/el.po:
+	* po/en_GB.po:
+	* po/eo.po:
+	* po/es.po:
+	* po/eu.po:
+	* po/fi.po:
+	* po/fr.po:
+	* po/gl.po:
+	* po/hr.po:
+	* po/hu.po:
+	* po/id.po:
+	* po/it.po:
+	* po/ja.po:
+	* po/lt.po:
+	* po/lv.po:
+	* po/mt.po:
+	* po/nb.po:
+	* po/nl.po:
+	* po/or.po:
+	* po/pl.po:
+	* po/pt_BR.po:
+	* po/ro.po:
+	* po/ru.po:
+	* po/sk.po:
+	* po/sl.po:
+	* po/sq.po:
+	* po/sr.po:
+	* po/sv.po:
+	* po/tr.po:
+	* po/uk.po:
+	* po/vi.po:
+	* po/zh_CN.po:
+	* po/zh_HK.po:
+	* po/zh_TW.po:
+	  Update .po files
 
 2016-11-29 14:09:44 +0200  Sebastian Dröge <sebastian@centricular.com>
 
diff --git a/Makefile.in b/Makefile.in
index 729bca0..a3ce7c4 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -209,7 +209,7 @@
 	$(top_srcdir)/common/release.mak \
 	$(top_srcdir)/common/win32.mak ABOUT-NLS AUTHORS COPYING \
 	ChangeLog INSTALL NEWS README compile config.guess \
-	config.rpath config.sub depcomp install-sh ltmain.sh missing
+	config.rpath config.sub install-sh ltmain.sh missing
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
diff --git a/NEWS b/NEWS
index 815dee3..c8f4d44 100644
--- a/NEWS
+++ b/NEWS
@@ -1,8 +1,8 @@
 # GStreamer 1.10 Release Notes
 
 GStreamer 1.10.0 was originally released on 1st November 2016.
-The latest bug-fix release in the 1.10 series is [1.10.2](#1.10.2) and was
-released on 29 November 2016.
+The latest bug-fix release in the 1.10 series is [1.10.3](#1.10.3) and was
+released on 30 January 2017.
 
 The GStreamer team is proud to announce a new major feature release in the
 stable 1.x API series of your favourite cross-platform multimedia framework!
@@ -13,7 +13,7 @@
 See [https://gstreamer.freedesktop.org/releases/1.10/][latest] for the latest
 version of this document.
 
-*Last updated: Tuesday 29 Nov 2016, 12:30 UTC [(log)][gitlog]*
+*Last updated: Monday 30 Jan 2017, 12:00 UTC [(log)][gitlog]*
 
 [latest]: https://gstreamer.freedesktop.org/releases/1.10/
 [gitlog]: https://cgit.freedesktop.org/gstreamer/www/log/src/htdocs/releases/1.10/release-notes-1.10.md
@@ -1103,7 +1103,7 @@
 
 ### 1.10.2
 
-The first 1.10 bug-fix release (1.10.2) was released on 29 November 2016.
+The second 1.10 bug-fix release (1.10.2) was released on 29 November 2016.
 This release only contains bugfixes and it should be safe to update from 1.10.x.
 
 #### Major bugfixes in 1.10.2
@@ -1111,7 +1111,9 @@
  - Security-relevant bugfix in the FLI/FLX/FLC decoder (CVE-2016-9634,
    CVE-2016-9635, CVE-2016-9636)
  - Various fixes for crashes, assertions and other failures on fuzzed input
-   files (among others, thanks to Hanno Böck for testing and reporting)
+   files. Among others, thanks to Hanno Böck for testing and reporting
+   (CVE-2016-9807, CVE-2016-9808, CVE-2016-9809, CVE-2016-9810, CVE-2016-9811,
+   CVE-2016-9812, CVE-2016-9813).
  - SAVP/SAVPF profile in gst-rtsp-server works for live streams again, and the
    correct MIKEY policy message is generated
  - Further OpenGL related bugfixes
@@ -1124,6 +1126,32 @@
 
 [buglist-1.10.2]: https://bugzilla.gnome.org/buglist.cgi?bug_status=RESOLVED&bug_status=VERIFIED&classification=Platform&limit=0&list_id=168172&order=bug_id&product=GStreamer&query_format=advanced&resolution=FIXED&target_milestone=1.10.2
 
+<a name="1.10.3"></a>
+
+### 1.10.3
+
+The third 1.10 bug-fix release (1.10.3) was released on 30 January 2017.
+This release only contains bugfixes and it should be safe to update from 1.10.x.
+
+#### Major bugfixes in 1.10.3
+
+ - Various fixes for crashes, assertions, deadlocks and memory leaks on fuzzed
+   input files and in other situations
+ - Regression fixes for souphttpsrc with redirection tracking and retrying
+ - Regression fix for gst-rtsp-server not handling TCP-only medias anymore
+ - Various other bugfixes the RTP/RTSP codebase
+ - vp8enc works again on 32 bit Windows
+ - Fixes to Opus PLC handling in the decoder
+ - Fix for stream corruption in multihandlesink when removing clients
+ - gst-libav was updated to ffmpeg 3.2.2
+ - ... and many, many more!
+
+For a full list of bugfixes see [Bugzilla][buglist-1.10.3]. Note that this is
+not the full list of changes. For the full list of changes please refer to the
+GIT logs or ChangeLogs of the particular modules.
+
+[buglist-1.10.3]: https://bugzilla.gnome.org/buglist.cgi?bug_status=RESOLVED&bug_status=VERIFIED&classification=Platform&limit=0&list_id=187054&order=bug_id&product=GStreamer&query_format=advanced&resolution=FIXED&target_milestone=1.10.3
+
 ## Known Issues
 
 - iOS builds with iOS 6 SDK and old C++ STL. You need to select iOS 6 instead
@@ -1134,8 +1162,6 @@
 - Building applications with Android NDK r13 on Windows does not work. Other
   platforms and earlier/later versions of the NDK are not affected.
   [Bug #772842](https://bugzilla.gnome.org/show_bug.cgi?id=772842)
-- vp8enc crashes on 32 bit Windows, but was working fine in 1.6. 64 bit Windows is unaffected.
-  [Bug #763663](https://bugzilla.gnome.org/show_bug.cgi?id=763663)
 
 ## Schedule for 1.12
 
@@ -1144,9 +1170,9 @@
 of 1.11/1.12 will happen in the git master branch.
 
 The plan for the 1.12 development cycle is yet to be confirmed, but it is
-expected that feature freeze will be around early/mid-January,
+expected that feature freeze will be around early/mid-February,
 followed by several 1.11 pre-releases and the new 1.12 stable release
-in March.
+in April.
 
 1.12 will be backwards-compatible to the stable 1.10, 1.8, 1.6, 1.4, 1.2 and
 1.0 release series.
diff --git a/RELEASE b/RELEASE
index 8999b5d..a9b5f38 100644
--- a/RELEASE
+++ b/RELEASE
@@ -1,7 +1,7 @@
 
-Release notes for GStreamer Good Plugins 1.10.2
+Release notes for GStreamer Good Plugins 1.10.3
 
-The GStreamer team is proud to announce the second bugfix release in the stable
+The GStreamer team is proud to announce the third bugfix release in the stable
 1.10 release series of your favourite cross-platform multimedia framework!
 
 
@@ -55,12 +55,35 @@
 
 Bugs fixed in this release
      
-      * 757292 : gdkpixbufoverlay: relative-x/y properties
-      * 774428 : qtdemux: Outputting unaligned raw audio/video buffers
-      * 774834 : flic decoder: Buffer overflow in flx_decode_delta_fli
-      * 774859 : flic decoder: Invalid memory read in flx_decode_chunks
-      * 774897 : flxdec: Unreferences itself one time too many on invalid files
-      * 775219 : avidemux: Ensure that tags are valid UTF-8 before adding them to the taglist
+      * 775898 : scaletempo: crash in Totem when doing Slow - > Fast - > Slow playback
+      * 754230 : qtdemux: support sparse time ranges in qtdemux without needing a seek for MSE
+      * 765498 : qtdemux: Fix key_time in gst_qtdemux_adjust_seek()
+      * 772646 : rtpjitterbuffer: fix lost-event using dts instead of pts
+      * 773218 : rtpbin: pipeline gets an EOS when any rtpsources byes
+      * 773891 : rtpjitterbuffer: fix timer-reuse bug
+      * 773905 : rtpjitterbuffer: fix bug in reschedule_timer
+      * 775071 : memory leak in usage of gst_pad_get_current_caps() API
+      * 775450 : aacparse: invalid memory read in gst_aac_parse_sink_setcaps
+      * 775451 : qtdemux: out of bounds read in qtdemux_tag_add_str_full
+      * 775455 : qtdemux: memory leaks in qtdemux_inflate
+      * 775472 : matroskademux: memory leak in matroska parser / gst_ebml_read_binary
+      * 775479 : avidemux: memory leak in gst_avi_demux_riff_parse_vprp
+      * 775543 : rtspsrc: redirect-on-play skips stream cleanup and TEARDOWN
+      * 775794 : qtdemux: can not play xvid/mp2 quicktime format
+      * 775888 : flxdec: memory leaks in gst_flxdec_chain
+      * 776107 : qtdemux: Crashes when parsing edit lists due to missing size checks
+      * 776720 : souphttpsrc: no request retry on early server termination
+      * 777101 : rtspsrc: tcp interleaved data dropped if first sub-streams are skipped during SETUP
+      * 777123 : wavparse: CRITICAL warning with injected flush stop event in pull mode
+      * 777157 : qtdemux: seqh buffer not freed after calling qtdemux_parse_svq3_stsd_data()
+      * 777174 : qtmux resets request pad counters on PAUSED- > READY
+      * 777222 : souphttpsrc: redirect uri is never set
+      * 777327 : v4l2allocator: memory type not correctly set in allocator probe
+      * 777362 : qtmux: Error always printed after writing moov recovery file, regardless of success/failure
+      * 777469 : qtdemux: out of bounds heap read in qtdemux_parse_samples
+      * 777500 : avidemux: gst_avi_demux_parse_ncdt heap out of bounds read
+      * 777532 : avidemux: invalid memory read in gst_avi_demux_parse_ncdt
+      * 777832 : qtmux: Timecode track fixes for STSD entry
 
 ==== Download ====
 
@@ -97,9 +120,21 @@
         
 Contributors to this release
     
-      * Jagadish
+      * Alejandro G. Castro
+      * Andre McCurdy
+      * Arnaud Vrac
+      * Brendan Shanks
+      * Edward Hervey
+      * Enrique Ocaña González
+      * Garima Gaur
+      * Havard Graff
+      * Heekyoung Seo
+      * Jan Schmidt
+      * Jean-Christophe Trotin
+      * Matt Staples
       * Matthew Waters
-      * Philipp Zabel
+      * Rahul Bedarkar
       * Sebastian Dröge
-      * Tim-Philipp Müller
+      * Seungha Yang
+      * Vivia Nikolaidou
  
\ No newline at end of file
diff --git a/configure b/configure
index 2ca53bf..1e8db0c 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.10.2.
+# Generated by GNU Autoconf 2.69 for GStreamer Good Plug-ins 1.10.3.
 #
 # 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.10.2'
-PACKAGE_STRING='GStreamer Good Plug-ins 1.10.2'
+PACKAGE_VERSION='1.10.3'
+PACKAGE_STRING='GStreamer Good Plug-ins 1.10.3'
 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.10.2 to adapt to many kinds of systems.
+\`configure' configures GStreamer Good Plug-ins 1.10.3 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.10.2:";;
+     short | recursive ) echo "Configuration of GStreamer Good Plug-ins 1.10.3:";;
    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.10.2
+GStreamer Good Plug-ins configure 1.10.3
 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.10.2, which was
+It was created by GStreamer Good Plug-ins $as_me 1.10.3, 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.10.2'
+ VERSION='1.10.3'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -4422,9 +4422,9 @@
 
 
 
-  PACKAGE_VERSION_MAJOR=$(echo 1.10.2 | cut -d'.' -f1)
-  PACKAGE_VERSION_MINOR=$(echo 1.10.2 | cut -d'.' -f2)
-  PACKAGE_VERSION_MICRO=$(echo 1.10.2 | cut -d'.' -f3)
+  PACKAGE_VERSION_MAJOR=$(echo 1.10.3 | cut -d'.' -f1)
+  PACKAGE_VERSION_MINOR=$(echo 1.10.3 | cut -d'.' -f2)
+  PACKAGE_VERSION_MICRO=$(echo 1.10.3 | 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.10.2 | cut -d'.' -f4)
+  NANO=$(echo 1.10.3 | 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=1002
+  GST_CURRENT=1003
   GST_REVISION=0
-  GST_AGE=1002
-  GST_LIBVERSION=1002:0:1002
+  GST_AGE=1003
+  GST_LIBVERSION=1003:0:1003
 
 
 
@@ -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.10.2, which was
+This file was extended by GStreamer Good Plug-ins $as_me 1.10.3, 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.10.2
+GStreamer Good Plug-ins config.status 1.10.3
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git a/configure.ac b/configure.ac
index 4c1a63d..9234f7f 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.10.2],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-good])
+AC_INIT([GStreamer Good Plug-ins],[1.10.3],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-good])
 
 AG_GST_INIT
 
@@ -43,7 +43,7 @@
   [GStreamer API Version])
 
 AG_GST_LIBTOOL_PREPARE
-AS_LIBTOOL(GST, 1002, 0, 1002)
+AS_LIBTOOL(GST, 1003, 0, 1003)
 
 dnl *** required versions of GStreamer stuff ***
 GST_REQ=1.10.0
diff --git a/docs/plugins/gst-plugins-good-plugins.args b/docs/plugins/gst-plugins-good-plugins.args
index cbc301a..a22ef97 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.10.2"</DEFAULT>
+<DEFAULT>"GStreamer/1.10.3"</DEFAULT>
 </ARG>
 
 <ARG>
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 6cb85d3..0f6776e 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.10.2</td>
+<td>1.10.3</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 4b904eb..314a338 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.10.2</td>
+<td>1.10.3</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 3b97b2e..f713ea8 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.10.2</td>
+<td>1.10.3</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 14ca072..e78f7fb 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.10.2</td>
+<td>1.10.3</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 e0c7049..53dc41d 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.10.2</td>
+<td>1.10.3</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 689f747..d2421d0 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.10.2</td>
+<td>1.10.3</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 64947da..8d76691 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.10.2</td>
+<td>1.10.3</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 5478df6..be68590 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.10.2</td>
+<td>1.10.3</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 e70c29f..3b2272c 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.10.2</td>
+<td>1.10.3</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 ca5d1da..ada1a10 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.10.2</td>
+<td>1.10.3</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 6decf94..e2d442a 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.10.2</td>
+<td>1.10.3</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 401346e..c21b1be 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.10.2</td>
+<td>1.10.3</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 5270861..6cfc9f1 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.10.2</td>
+<td>1.10.3</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 221fb32..60d2c57 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.10.2</td>
+<td>1.10.3</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 9d8714a..8b1c58c 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.10.2</td>
+<td>1.10.3</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 c24bd5d..aa3a5b9 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.10.2</td>
+<td>1.10.3</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 ccf10fe..1fa2ca4 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.10.2</td>
+<td>1.10.3</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 4a5998e..d4548ef 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.10.2</td>
+<td>1.10.3</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 c40ea66..7488aa0 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.10.2</td>
+<td>1.10.3</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 4b84c4c..c17655a 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.10.2</td>
+<td>1.10.3</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 07b96d3..4501bbe 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.10.2</td>
+<td>1.10.3</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 4d444ba..44ac82c 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.10.2</td>
+<td>1.10.3</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 9f9f974..781c998 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.10.2</td>
+<td>1.10.3</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 297d130..9859ef5 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.10.2</td>
+<td>1.10.3</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 fe3bf35..b2ce41e 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.10.2</td>
+<td>1.10.3</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 a020ee2..5499080 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.10.2</td>
+<td>1.10.3</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 9d971fe..81022df 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.10.2</td>
+<td>1.10.3</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 c323a95..702296a 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.10.2</td>
+<td>1.10.3</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 fde10b3..dde26df 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.10.2</td>
+<td>1.10.3</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 5c154bf..b86ef71 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.10.2</td>
+<td>1.10.3</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 c68d176..40077b5 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.10.2</td>
+<td>1.10.3</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 8b5248d..8da14be 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.10.2</td>
+<td>1.10.3</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 cbf8037..9d42a5e 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.10.2</td>
+<td>1.10.3</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 fd058af..8101048 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.10.2</td>
+<td>1.10.3</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 fa9bafc..aa0849d 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.10.2</td>
+<td>1.10.3</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 f88b309..d837f07 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.10.2</td>
+<td>1.10.3</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 400af89..b1a9b9b 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.10.2</td>
+<td>1.10.3</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 5664b2b..56969f6 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.10.2</td>
+<td>1.10.3</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 f6a6c81..dd9a133 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.10.2</td>
+<td>1.10.3</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 1277594..1edcd41 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.10.2</td>
+<td>1.10.3</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 8724773..e31d66c 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.10.2</td>
+<td>1.10.3</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 93b43cf..248790f 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.10.2</td>
+<td>1.10.3</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 3781051..9a9650d 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.10.2</td>
+<td>1.10.3</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 28617b6..9752012 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.10.2</td>
+<td>1.10.3</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 3db9e24..f3813fe 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.10.2</td>
+<td>1.10.3</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 5793f0f..5d3d193 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.10.2</td>
+<td>1.10.3</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 34f7a88..1894ca5 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.10.2</td>
+<td>1.10.3</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 14c2cc5..d23193e 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.10.2</td>
+<td>1.10.3</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 d075859..4ec8c58 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.10.2</td>
+<td>1.10.3</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 5a3a53b..1f4184f 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.10.2</td>
+<td>1.10.3</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 8fc8171..5616dad 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.10.2</td>
+<td>1.10.3</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 45b214b..5e76c5f 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.10.2</td>
+<td>1.10.3</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 9ba9c7f..2b83291 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.10.2</td>
+<td>1.10.3</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 84d25e1..b70b174 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.10.2</td>
+<td>1.10.3</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 88422b3..57b8e9e 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.10.2</td>
+<td>1.10.3</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 947c66e..ae2d676 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.10.2</td>
+<td>1.10.3</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 0c74a83..d2a3deb 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.10.2</td>
+<td>1.10.3</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 c2d6597..0ad9271 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.10.2</td>
+<td>1.10.3</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 c56f5e3..f923a53 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.10.2</td>
+<td>1.10.3</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 a707809..00cbb2f 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.10.2</td>
+<td>1.10.3</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 ce3f0ed..94773f6 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.10.2</td>
+<td>1.10.3</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 784c967..0385e7e 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.10.2</td>
+<td>1.10.3</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 30685a8..6878130 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.10.2</td>
+<td>1.10.3</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 8ec302e..85cb532 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.10.2</td>
+<td>1.10.3</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 b3629eb..e0ece68 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.10.2</td>
+<td>1.10.3</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 e1a5cf4..6ea7bd3 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.10.2</td>
+<td>1.10.3</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
diff --git a/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html b/docs/plugins/html/gst-plugins-good-plugins-rtspsrc.html
index 813a890..fa2113d 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.10.2"</p>
+<p>Default value: "GStreamer/1.10.3"</p>
 </div>
 <hr>
 <div class="refsect2">
diff --git a/docs/plugins/html/index.html b/docs/plugins/html/index.html
index 9edc1a3..064da87 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.10.2)
+      for GStreamer Good Plugins 1.0 (1.10.3)
       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 9a84f1f..3380280 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.10.2</version>
+  <version>1.10.3</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 06a6481..63da44e 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.10.2</version>
+  <version>1.10.3</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 c4d5b3b..f745f07 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.10.2</version>
+  <version>1.10.3</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 ab63fdc..5228e74 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.10.2</version>
+  <version>1.10.3</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 9cae28d..40c4fa0 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.10.2</version>
+  <version>1.10.3</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 b1ebbd4..1f8f148 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.10.2</version>
+  <version>1.10.3</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 c7829f9..7cdc27c 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.10.2</version>
+  <version>1.10.3</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 8b73ae1..003f3bf 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.10.2</version>
+  <version>1.10.3</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 b1d277a..9d56ceb 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.10.2</version>
+  <version>1.10.3</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 f485452..12c84b5 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.10.2</version>
+  <version>1.10.3</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 070a9ce..62bff80 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.10.2</version>
+  <version>1.10.3</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 38a9dde..be9c9bc 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.10.2</version>
+  <version>1.10.3</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 dfab84c..1a1a9c4 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.10.2</version>
+  <version>1.10.3</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 83f9e3b..cd34e11 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.10.2</version>
+  <version>1.10.3</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 c84867d..1400031 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.10.2</version>
+  <version>1.10.3</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 ce05bcf..661a1c2 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.10.2</version>
+  <version>1.10.3</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 b34c1a3..5877be1 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.10.2</version>
+  <version>1.10.3</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 1707dd1..cca77c8 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.10.2</version>
+  <version>1.10.3</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 b3f8863..2db9d67 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.10.2</version>
+  <version>1.10.3</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 807793c..f3a6390 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.10.2</version>
+  <version>1.10.3</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 533e92e..29a8751 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.10.2</version>
+  <version>1.10.3</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 3baa5be..1fb5862 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.10.2</version>
+  <version>1.10.3</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 ff263a4..9d4db45 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.10.2</version>
+  <version>1.10.3</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 0c57762..96e962f 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.10.2</version>
+  <version>1.10.3</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 14193ab..ed068de 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.10.2</version>
+  <version>1.10.3</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 2372ac3..c0bf786 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.10.2</version>
+  <version>1.10.3</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 63a5dd1..7716881 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.10.2</version>
+  <version>1.10.3</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 c1c2cf6..b0d0505 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.10.2</version>
+  <version>1.10.3</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 ec8b234..bcea506 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.10.2</version>
+  <version>1.10.3</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 f8c9952..6cb2352 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.10.2</version>
+  <version>1.10.3</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 4edc030..057a7e7 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.10.2</version>
+  <version>1.10.3</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 90b106f..1e484f3 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.10.2</version>
+  <version>1.10.3</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 9af2ae6..0480dc0 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.10.2</version>
+  <version>1.10.3</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 1f7330b..e634306 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.10.2</version>
+  <version>1.10.3</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 7fbe36f..140e426 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.10.2</version>
+  <version>1.10.3</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 5f0295c..e323d81 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.10.2</version>
+  <version>1.10.3</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 d1a161b..1823697 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.10.2</version>
+  <version>1.10.3</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 6c776e0..e34247b 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.10.2</version>
+  <version>1.10.3</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 1527614..869110b 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.10.2</version>
+  <version>1.10.3</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 daa0b35..874e0e0 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.10.2</version>
+  <version>1.10.3</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 76c0a87..6dded63 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.10.2</version>
+  <version>1.10.3</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 9683ac8..366b25b 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.10.2</version>
+  <version>1.10.3</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 ccaeb33..7cdb749 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.10.2</version>
+  <version>1.10.3</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 b77516d..5b7c85d 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.10.2</version>
+  <version>1.10.3</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 8f52745..f153ca3 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.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rtpmanager.xml b/docs/plugins/inspect/plugin-rtpmanager.xml
index bd1e101..73ab93b 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.10.2</version>
+  <version>1.10.3</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 9266120..58591c4 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.10.2</version>
+  <version>1.10.3</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 835fe83..cc2c4fc 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.10.2</version>
+  <version>1.10.3</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 193fe2c..230aff1 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.10.2</version>
+  <version>1.10.3</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 58f0f72..4562e52 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.10.2</version>
+  <version>1.10.3</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 d3afa28..f7ffb66 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.10.2</version>
+  <version>1.10.3</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 059d390..d3a01a2 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.10.2</version>
+  <version>1.10.3</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 2d39cef..e3001b3 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.10.2</version>
+  <version>1.10.3</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 a446fa7..212423c 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.10.2</version>
+  <version>1.10.3</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 5570211..c6c0640 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.10.2</version>
+  <version>1.10.3</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 52632bd..42ca81d 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.10.2</version>
+  <version>1.10.3</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 2484090..1e71e66 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.10.2</version>
+  <version>1.10.3</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 17d3804..4754dc4 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.10.2</version>
+  <version>1.10.3</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 f43b0b3..586489b 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.10.2</version>
+  <version>1.10.3</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 4ea6f6d..8be37a7 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.10.2</version>
+  <version>1.10.3</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 93eb059..ab4774d 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.10.2</version>
+  <version>1.10.3</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 8e7dc2f..e304149 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.10.2</version>
+  <version>1.10.3</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 9ef0349..383323e 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.10.2</version>
+  <version>1.10.3</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 10025ab..9458f6c 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.10.2</version>
+  <version>1.10.3</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 635fc5f..ff1cdb6 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.10.2</version>
+  <version>1.10.3</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 ffabbef..345d5d5 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.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-good</source>
   <package>GStreamer Good Plug-ins source release</package>
diff --git a/ext/soup/gstsouphttpsrc.c b/ext/soup/gstsouphttpsrc.c
index fc7cba7..f78a072 100644
--- a/ext/soup/gstsouphttpsrc.c
+++ b/ext/soup/gstsouphttpsrc.c
@@ -1037,31 +1037,19 @@
       src->proxy_id && src->proxy_pw)
     return;
 
-  if (src->automatic_redirect && SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
-    const gchar *location;
+  if (src->automatic_redirect &&
+      soup_session_would_redirect (src->session, msg) &&
+      soup_session_redirect_message (src->session, msg)) {
+    src->redirection_uri =
+        soup_uri_to_string (soup_message_get_uri (msg), FALSE);
+    src->redirection_permanent =
+        (msg->status_code == SOUP_STATUS_MOVED_PERMANENTLY);
+    GST_DEBUG_OBJECT (src, "%u redirect to \"%s\" (permanent %d)",
+        msg->status_code, src->redirection_uri, src->redirection_permanent);
 
-    location = soup_message_headers_get_one (msg->response_headers, "Location");
-
-    if (location) {
-      if (!g_utf8_validate (location, -1, NULL)) {
-        GST_ELEMENT_ERROR_WITH_DETAILS (src, RESOURCE, SEEK,
-            (_("Corrupted HTTP response.")),
-            ("Location header is not valid UTF-8"),
-            ("http-status-code", G_TYPE_UINT, msg->status_code,
-                "http-redirection-uri", G_TYPE_STRING,
-                GST_STR_NULL (src->redirection_uri), NULL));
-        src->ret = GST_FLOW_ERROR;
-        return;
-      }
-
-      src->redirection_uri = g_strdup (location);
-
-      src->redirection_permanent =
-          (msg->status_code == SOUP_STATUS_MOVED_PERMANENTLY);
-      GST_DEBUG_OBJECT (src, "%u redirect to \"%s\" (permanent %d)",
-          msg->status_code, src->redirection_uri, src->redirection_permanent);
-      return;
-    }
+    /* force a retry with the updated message */
+    src->ret = GST_FLOW_CUSTOM_ERROR;
+    return;
   }
 
   if (msg->status_code == SOUP_STATUS_UNAUTHORIZED) {
@@ -1434,7 +1422,7 @@
   }
 
   soup_message_set_flags (src->msg, SOUP_MESSAGE_OVERWRITE_CHUNKS |
-      (src->automatic_redirect ? 0 : SOUP_MESSAGE_NO_REDIRECT));
+      SOUP_MESSAGE_NO_REDIRECT);
   gst_soup_http_src_add_range_header (src, src->request_position,
       src->stop_position);
 
@@ -1455,6 +1443,8 @@
   if (g_cancellable_is_cancelled (src->cancellable))
     return GST_FLOW_FLUSHING;
 
+  src->ret = GST_FLOW_OK;
+
   gst_soup_http_src_got_headers (src, src->msg);
   if (src->ret != GST_FLOW_OK) {
     return src->ret;
@@ -1492,7 +1482,7 @@
   GST_LOG_OBJECT (src, "Running request for method: %s", method);
 
   /* Update the position if we are retrying */
-  if (src->msg && (src->request_position != src->read_position)) {
+  if (src->msg && src->request_position > 0) {
     gst_soup_http_src_add_range_header (src, src->request_position,
         src->stop_position);
   }
@@ -1649,7 +1639,8 @@
     }
   } else {
     gst_buffer_unref (*outbuf);
-    if (read_bytes < 0) {
+    if (read_bytes < 0 ||
+        (src->have_size && src->read_position < src->content_size)) {
       /* Maybe the server disconnected, retry */
       ret = GST_FLOW_CUSTOM_ERROR;
     } else {
@@ -1724,8 +1715,10 @@
       src->input_stream = NULL;
     }
     g_mutex_unlock (&src->mutex);
-    if (ret == GST_FLOW_CUSTOM_ERROR)
+    if (ret == GST_FLOW_CUSTOM_ERROR) {
+      ret = GST_FLOW_OK;
       goto retry;
+    }
   }
   return ret;
 }
diff --git a/gst-plugins-good.doap b/gst-plugins-good.doap
index 603f141..35c7960 100644
--- a/gst-plugins-good.doap
+++ b/gst-plugins-good.doap
@@ -34,6 +34,16 @@
 
  <release>
   <Version>
+   <revision>1.10.3</revision>
+   <branch>1.10</branch>
+   <name></name>
+   <created>2017-01-30</created>
+   <file-release rdf:resource="http://gstreamer.freedesktop.org/src/gst-plugins-good/gst-plugins-good-1.10.3.tar.xz" />
+  </Version>
+ </release>
+
+ <release>
+  <Version>
    <revision>1.10.2</revision>
    <branch>1.10</branch>
    <name></name>
diff --git a/gst-plugins-good.spec b/gst-plugins-good.spec
index add6fca..05900b5 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.10.2
+Version: 	1.10.3
 Release: 	1.gst
 Summary: 	GStreamer plug-ins with good code and licensing
 
diff --git a/gst/audiofx/gstscaletempo.c b/gst/audiofx/gstscaletempo.c
index 2f14d6b..04f08e7 100644
--- a/gst/audiofx/gstscaletempo.c
+++ b/gst/audiofx/gstscaletempo.c
@@ -699,6 +699,7 @@
 
   gst_segment_init (&scaletempo->in_segment, GST_FORMAT_UNDEFINED);
   gst_segment_init (&scaletempo->out_segment, GST_FORMAT_UNDEFINED);
+  scaletempo->reinit_buffers = TRUE;
 
   return TRUE;
 }
@@ -718,6 +719,7 @@
   scaletempo->buf_pre_corr = NULL;
   g_free (scaletempo->table_window);
   scaletempo->table_window = NULL;
+  scaletempo->reinit_buffers = TRUE;
 
   return TRUE;
 }
diff --git a/gst/audioparsers/gstaacparse.c b/gst/audioparsers/gstaacparse.c
index 34ba80a..7c5616a 100644
--- a/gst/audioparsers/gstaacparse.c
+++ b/gst/audioparsers/gstaacparse.c
@@ -306,11 +306,12 @@
   if (value) {
     GstBuffer *buf = gst_value_get_buffer (value);
 
-    if (buf) {
+    if (buf && gst_buffer_get_size (buf) >= 2) {
       GstMapInfo map;
       guint sr_idx;
 
-      gst_buffer_map (buf, &map, GST_MAP_READ);
+      if (!gst_buffer_map (buf, &map, GST_MAP_READ))
+        return FALSE;
 
       sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
       aacparse->object_type = (map.data[0] & 0xf8) >> 3;
diff --git a/gst/avi/gstavidemux.c b/gst/avi/gstavidemux.c
index 343009a..768630c 100644
--- a/gst/avi/gstavidemux.c
+++ b/gst/avi/gstavidemux.c
@@ -2308,9 +2308,6 @@
           if (n && d)
             gst_caps_set_simple (caps, "pixel-aspect-ratio", GST_TYPE_FRACTION,
                 n, d, NULL);
-          /* very local, not needed elsewhere */
-          g_free (vprp);
-          vprp = NULL;
         }
         caps = gst_avi_demux_check_caps (avi, stream, caps);
         tag_name = GST_TAG_VIDEO_CODEC;
@@ -2457,6 +2454,8 @@
     gst_tag_list_add (stream->taglist, GST_TAG_MERGE_APPEND, tag_name,
         codec_name, NULL);
   }
+
+  g_free (vprp);
   g_free (codec_name);
   gst_buffer_unref (buf);
 
@@ -3898,6 +3897,10 @@
 
           tsize -= 4;
           ptr += 4;
+          left -= 4;
+
+          if (sub_size > tsize)
+            break;
 
           GST_DEBUG_OBJECT (avi, "sub-tag %u, size %u", sub_tag, sub_size);
           /* http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html#NCTG
@@ -3916,10 +3919,12 @@
               break;
             case 0x13:         /* CreationDate */
               type = GST_TAG_DATE_TIME;
-              if (ptr[4] == ':')
-                ptr[4] = '-';
-              if (ptr[7] == ':')
-                ptr[7] = '-';
+              if (left > 7) {
+                if (ptr[4] == ':')
+                  ptr[4] = '-';
+                if (ptr[7] == ':')
+                  ptr[7] = '-';
+              }
               break;
             default:
               type = NULL;
@@ -3933,6 +3938,7 @@
 
           ptr += sub_size;
           tsize -= sub_size;
+          left -= sub_size;
         }
         break;
       default:
diff --git a/gst/flx/gstflxdec.c b/gst/flx/gstflxdec.c
index aa1bed5..37d552a 100644
--- a/gst/flx/gstflxdec.c
+++ b/gst/flx/gstflxdec.c
@@ -190,17 +190,27 @@
   switch (GST_EVENT_TYPE (event)) {
     case GST_EVENT_SEGMENT:
     {
-      GstSegment segment;
-
-      gst_event_copy_segment (event, &segment);
-      if (segment.format != GST_FORMAT_TIME) {
+      gst_event_copy_segment (event, &flxdec->segment);
+      if (flxdec->segment.format != GST_FORMAT_TIME) {
         GST_DEBUG_OBJECT (flxdec, "generating TIME segment");
-        gst_segment_init (&segment, GST_FORMAT_TIME);
+        gst_segment_init (&flxdec->segment, GST_FORMAT_TIME);
         gst_event_unref (event);
-        event = gst_event_new_segment (&segment);
+        event = gst_event_new_segment (&flxdec->segment);
       }
-      /* fall-through */
+
+      if (gst_pad_has_current_caps (flxdec->srcpad)) {
+        ret = gst_pad_event_default (pad, parent, event);
+      } else {
+        flxdec->need_segment = TRUE;
+        gst_event_unref (event);
+        ret = TRUE;
+      }
+      break;
     }
+    case GST_EVENT_FLUSH_STOP:
+      gst_segment_init (&flxdec->segment, GST_FORMAT_UNDEFINED);
+      ret = gst_pad_event_default (pad, parent, event);
+      break;
     default:
       ret = gst_pad_event_default (pad, parent, event);
       break;
@@ -784,6 +794,12 @@
       gst_pad_set_caps (flxdec->srcpad, caps);
       gst_caps_unref (caps);
 
+      if (flxdec->need_segment) {
+        gst_pad_push_event (flxdec->srcpad,
+            gst_event_new_segment (&flxdec->segment));
+        flxdec->need_segment = FALSE;
+      }
+
       /* zero means 8 */
       if (flxh->depth == 0)
         flxh->depth = 8;
@@ -812,8 +828,8 @@
       }
 
       /* create delta and output frame */
-      flxdec->frame_data = g_malloc (flxdec->size);
-      flxdec->delta_data = g_malloc (flxdec->size);
+      flxdec->frame_data = g_malloc0 (flxdec->size);
+      flxdec->delta_data = g_malloc0 (flxdec->size);
 
       flxdec->state = GST_FLXDEC_PLAYING;
     }
@@ -902,10 +918,9 @@
     }
   }
 
+need_more_data:
   gst_buffer_unmap (input, &map_info);
   gst_buffer_unref (input);
-
-need_more_data:
   return res;
 
   /* ERRORS */
@@ -914,8 +929,8 @@
       ("%s", "Failed to parse stream"), (NULL));
 unmap_input_error:
   gst_buffer_unmap (input, &map_info);
-  gst_buffer_unref (input);
 error:
+  gst_buffer_unref (input);
   return GST_FLOW_ERROR;
 }
 
@@ -933,6 +948,8 @@
     case GST_STATE_CHANGE_READY_TO_PAUSED:
       gst_adapter_clear (flxdec->adapter);
       flxdec->state = GST_FLXDEC_READ_HEADER;
+      gst_segment_init (&flxdec->segment, GST_FORMAT_UNDEFINED);
+      flxdec->need_segment = TRUE;
       break;
     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
       break;
diff --git a/gst/flx/gstflxdec.h b/gst/flx/gstflxdec.h
index 4fd8dfd..c6486a0 100644
--- a/gst/flx/gstflxdec.h
+++ b/gst/flx/gstflxdec.h
@@ -41,7 +41,10 @@
 struct _GstFlxDec {
   GstElement element;
 
-  GstPad *sinkpad,*srcpad;
+  GstPad *sinkpad, *srcpad;
+
+  GstSegment segment;
+  gboolean need_segment;
 
   gboolean active, new_meta;
 
diff --git a/gst/isomp4/atoms.c b/gst/isomp4/atoms.c
index f53004e..5445543 100644
--- a/gst/isomp4/atoms.c
+++ b/gst/isomp4/atoms.c
@@ -3132,23 +3132,24 @@
   g_assert (trak->mdia.minf.gmhd != NULL);
   g_assert (atom_array_get_len (&trak->mdia.minf.stbl.stts.entries) == 1);
 
-  trak->tkhd.duration = duration;
-  trak->mdia.mdhd.time_info.duration = duration;
-  trak->mdia.mdhd.time_info.timescale = timescale;
-
-  entry = &atom_array_index (&trak->mdia.minf.stbl.stts.entries, 0);
-  entry->sample_delta = duration;
-
   for (iter = trak->mdia.minf.stbl.stsd.entries; iter;
       iter = g_list_next (iter)) {
     SampleTableEntry *entry = iter->data;
     if (entry->kind == TIMECODE) {
       SampleTableEntryTMCD *tmcd = (SampleTableEntryTMCD *) entry;
 
-      tmcd->frame_duration = tmcd->frame_duration * timescale / tmcd->timescale;
-      tmcd->timescale = timescale;
+      duration = duration * tmcd->timescale / timescale;
+      timescale = tmcd->timescale;
+      break;
     }
   }
+
+  trak->tkhd.duration = duration;
+  trak->mdia.mdhd.time_info.duration = duration;
+  trak->mdia.mdhd.time_info.timescale = timescale;
+
+  entry = &atom_array_index (&trak->mdia.minf.stbl.stts.entries, 0);
+  entry->sample_delta = duration;
 }
 
 static guint32
@@ -3719,7 +3720,10 @@
   tmcd->name.name = g_strdup ("Tape");
   tmcd->timescale = tc->config.fps_n;
   tmcd->frame_duration = tc->config.fps_d;
-  tmcd->n_frames = tc->config.fps_n / tc->config.fps_d;
+  if (tc->config.fps_d == 1001)
+    tmcd->n_frames = tc->config.fps_n / 1000;
+  else
+    tmcd->n_frames = tc->config.fps_n / tc->config.fps_d;
 
   stsd->entries = g_list_prepend (stsd->entries, tmcd);
   stsd->n_entries++;
diff --git a/gst/isomp4/gstqtmux.c b/gst/isomp4/gstqtmux.c
index 27f9090..6e3ce16 100644
--- a/gst/isomp4/gstqtmux.c
+++ b/gst/isomp4/gstqtmux.c
@@ -543,8 +543,6 @@
   qtmux->moov_pos = 0;
   qtmux->mdat_pos = 0;
   qtmux->longest_chunk = GST_CLOCK_TIME_NONE;
-  qtmux->video_pads = 0;
-  qtmux->audio_pads = 0;
   qtmux->fragment_sequence = 0;
 
   if (qtmux->ftyp) {
@@ -2026,7 +2024,7 @@
   AtomFTYP *ftyp = NULL;
   GstBuffer *prefix = NULL;
 
-  GST_DEBUG_OBJECT (qtmux, "Openning moov recovery file: %s",
+  GST_DEBUG_OBJECT (qtmux, "Opening moov recovery file: %s",
       qtmux->moov_recov_file_path);
 
   qtmux->moov_recov_file = g_fopen (qtmux->moov_recov_file_path, "wb+");
@@ -2064,8 +2062,6 @@
   /* cleanup */
   fclose (qtmux->moov_recov_file);
   qtmux->moov_recov_file = NULL;
-  GST_WARNING_OBJECT (qtmux, "An error was detected while writing to "
-      "recover file, moov recovery won't work");
 }
 
 static GstFlowReturn
@@ -4447,6 +4443,13 @@
   }
 
   gst_collect_pads_remove_pad (mux->collect, pad);
+
+  if (mux->sinkpads == NULL) {
+    /* No more outstanding request pads, reset our counters */
+    mux->video_pads = 0;
+    mux->audio_pads = 0;
+    mux->subtitle_pads = 0;
+  }
 }
 
 static GstPad *
diff --git a/gst/isomp4/qtdemux.c b/gst/isomp4/qtdemux.c
index 13b3620..f2c4a42 100644
--- a/gst/isomp4/qtdemux.c
+++ b/gst/isomp4/qtdemux.c
@@ -95,6 +95,8 @@
 
 #define STREAM_IS_EOS(s) (s->time_position == GST_CLOCK_TIME_NONE)
 
+#define ABSDIFF(x, y) ( (x) > (y) ? ((x) - (y)) : ((y) - (x)) )
+
 GST_DEBUG_CATEGORY (qtdemux_debug);
 
 typedef struct _QtDemuxSegment QtDemuxSegment;
@@ -251,6 +253,7 @@
   guint32 n_samples_moof;       /* sample count in a moof */
   guint64 duration_moof;        /* duration in timescale of a moof, used for figure out
                                  * the framerate of fragmented format stream */
+  guint64 duration_last_moof;
 
   guint32 offset_in_sample;     /* Offset in the current sample, used for
                                  * streams which have got exceedingly big
@@ -1324,7 +1327,7 @@
         index = kindex;
 
         /* get timestamp of keyframe */
-        media_time = QTSAMPLE_DTS (str, &str->samples[kindex]);
+        media_time = QTSAMPLE_PTS (str, &str->samples[kindex]);
         GST_DEBUG_OBJECT (qtdemux,
             "keyframe at %u with time %" GST_TIME_FORMAT " at offset %"
             G_GUINT64_FORMAT, kindex, GST_TIME_ARGS (media_time),
@@ -1845,6 +1848,7 @@
   stream->n_samples_moof = 0;
   stream->duration_moof = 0;
   stream->alignment = 1;
+  stream->duration_last_moof = 0;
   g_queue_init (&stream->protection_scheme_event_queue);
   return stream;
 }
@@ -1957,10 +1961,15 @@
       gst_buffer_unref (qtdemux->comp_brands);
     qtdemux->comp_brands = NULL;
     qtdemux->last_moov_offset = -1;
+    if (qtdemux->moov_node_compressed) {
+      g_node_destroy (qtdemux->moov_node_compressed);
+      if (qtdemux->moov_node)
+        g_free (qtdemux->moov_node->data);
+    }
+    qtdemux->moov_node_compressed = NULL;
     if (qtdemux->moov_node)
       g_node_destroy (qtdemux->moov_node);
     qtdemux->moov_node = NULL;
-    qtdemux->moov_node_compressed = NULL;
     if (qtdemux->tag_list)
       gst_mini_object_unref (GST_MINI_OBJECT_CAST (qtdemux->tag_list));
     qtdemux->tag_list = NULL;
@@ -2377,6 +2386,7 @@
 
   stream->n_samples_moof = 0;
   stream->duration_moof = 0;
+  stream->duration_last_moof = 0;
 }
 
 static void
@@ -3122,6 +3132,25 @@
           stream->samples[stream->n_samples - 1].timestamp +
           stream->samples[stream->n_samples - 1].duration;
 
+      /* If this is a GST_FORMAT_BYTES stream and there's a significant
+       * difference (1 sec.) between decode_ts and timestamp, prefer the
+       * former */
+      if (decode_ts != 0 && !qtdemux->upstream_format_is_time
+          && ABSDIFF (decode_ts, timestamp) >
+          MAX (stream->duration_last_moof / 2,
+              GSTTIME_TO_QTSTREAMTIME (stream, GST_SECOND))) {
+        GST_INFO_OBJECT (qtdemux,
+            "decode_ts (%" GST_TIME_FORMAT ") and timestamp (%" GST_TIME_FORMAT
+            ") are significantly different (more than %" GST_TIME_FORMAT
+            "), using decode_ts",
+            GST_TIME_ARGS (QTSTREAMTIME_TO_GSTTIME (stream, decode_ts)),
+            GST_TIME_ARGS (QTSTREAMTIME_TO_GSTTIME (stream, timestamp)),
+            GST_TIME_ARGS (QTSTREAMTIME_TO_GSTTIME (stream,
+                    MAX (stream->duration_last_moof / 2,
+                        GSTTIME_TO_QTSTREAMTIME (stream, GST_SECOND)))));
+        timestamp = decode_ts;
+      }
+
       gst_ts = QTSTREAMTIME_TO_GSTTIME (stream, timestamp);
       GST_INFO_OBJECT (qtdemux, "first sample ts %" GST_TIME_FORMAT
           " (extends previous samples)", GST_TIME_ARGS (gst_ts));
@@ -3788,6 +3817,7 @@
 
     /* initialise moof sample data */
     stream->n_samples_moof = 0;
+    stream->duration_last_moof = stream->duration_moof;
     stream->duration_moof = 0;
 
     /* Track Run node */
@@ -4189,10 +4219,15 @@
       qtdemux_node_dump (qtdemux, qtdemux->moov_node);
 
       qtdemux_parse_tree (qtdemux);
+      if (qtdemux->moov_node_compressed) {
+        g_node_destroy (qtdemux->moov_node_compressed);
+        g_free (qtdemux->moov_node->data);
+      }
+      qtdemux->moov_node_compressed = NULL;
       g_node_destroy (qtdemux->moov_node);
+      qtdemux->moov_node = NULL;
       gst_buffer_unmap (moov, &map);
       gst_buffer_unref (moov);
-      qtdemux->moov_node = NULL;
       qtdemux->got_moov = TRUE;
 
       break;
@@ -6318,10 +6353,15 @@
             if (demux->got_moov && demux->fragmented) {
               GST_DEBUG_OBJECT (demux,
                   "Got a second moov, clean up data from old one");
+              if (demux->moov_node_compressed) {
+                g_node_destroy (demux->moov_node_compressed);
+                if (demux->moov_node)
+                  g_free (demux->moov_node->data);
+              }
+              demux->moov_node_compressed = NULL;
               if (demux->moov_node)
                 g_node_destroy (demux->moov_node);
               demux->moov_node = NULL;
-              demux->moov_node_compressed = NULL;
             } else {
               /* prepare newsegment to send when streaming actually starts */
               if (!demux->pending_newsegment) {
@@ -6361,6 +6401,11 @@
               }
             }
 
+            if (demux->moov_node_compressed) {
+              g_node_destroy (demux->moov_node_compressed);
+              g_free (demux->moov_node->data);
+            }
+            demux->moov_node_compressed = NULL;
             g_node_destroy (demux->moov_node);
             demux->moov_node = NULL;
             GST_DEBUG_OBJECT (demux, "Finished parsing the header");
@@ -6833,50 +6878,53 @@
 
 #ifdef HAVE_ZLIB
 static void *
-qtdemux_zalloc (void *opaque, unsigned int items, unsigned int size)
-{
-  return g_malloc (items * size);
-}
-
-static void
-qtdemux_zfree (void *opaque, void *addr)
-{
-  g_free (addr);
-}
-
-static void *
-qtdemux_inflate (void *z_buffer, guint z_length, guint length)
+qtdemux_inflate (void *z_buffer, guint z_length, guint * length)
 {
   guint8 *buffer;
-  z_stream *z;
+  z_stream z;
   int ret;
 
-  z = g_new0 (z_stream, 1);
-  z->zalloc = qtdemux_zalloc;
-  z->zfree = qtdemux_zfree;
-  z->opaque = NULL;
+  memset (&z, 0, sizeof (z));
+  z.zalloc = NULL;
+  z.zfree = NULL;
+  z.opaque = NULL;
 
-  z->next_in = z_buffer;
-  z->avail_in = z_length;
+  if ((ret = inflateInit (&z)) != Z_OK) {
+    GST_ERROR ("inflateInit() returned %d", ret);
+    return NULL;
+  }
 
-  buffer = (guint8 *) g_malloc (length);
-  ret = inflateInit (z);
-  while (z->avail_in > 0) {
-    if (z->avail_out == 0) {
-      length += 1024;
-      buffer = (guint8 *) g_realloc (buffer, length);
-      z->next_out = buffer + z->total_out;
-      z->avail_out = 1024;
-    }
-    ret = inflate (z, Z_SYNC_FLUSH);
-    if (ret != Z_OK)
+  z.next_in = z_buffer;
+  z.avail_in = z_length;
+
+  buffer = (guint8 *) g_malloc (*length);
+  z.avail_out = *length;
+  z.next_out = (Bytef *) buffer;
+  do {
+    ret = inflate (&z, Z_NO_FLUSH);
+    if (ret == Z_STREAM_END) {
       break;
-  }
+    } else if (ret != Z_OK) {
+      GST_WARNING ("inflate() returned %d", ret);
+      break;
+    }
+
+    *length += 4096;
+    buffer = (guint8 *) g_realloc (buffer, *length);
+    z.next_out = (Bytef *) (buffer + z.total_out);
+    z.avail_out += 4096;
+  } while (z.avail_in > 0);
+
   if (ret != Z_STREAM_END) {
-    g_warning ("inflate() returned %d", ret);
+    g_free (buffer);
+    buffer = NULL;
+    *length = 0;
+  } else {
+    *length = z.total_out;
   }
 
-  g_free (z);
+  inflateEnd (&z);
+
   return buffer;
 }
 #endif /* HAVE_ZLIB */
@@ -6899,12 +6947,17 @@
     guint32 method;
     GNode *dcom;
     GNode *cmvd;
+    guint32 dcom_len;
 
     dcom = qtdemux_tree_get_child_by_type (cmov, FOURCC_dcom);
     cmvd = qtdemux_tree_get_child_by_type (cmov, FOURCC_cmvd);
     if (dcom == NULL || cmvd == NULL)
       goto invalid_compression;
 
+    dcom_len = QT_UINT32 (dcom->data);
+    if (dcom_len < 12)
+      goto invalid_compression;
+
     method = QT_FOURCC ((guint8 *) dcom->data + 8);
     switch (method) {
 #ifdef HAVE_ZLIB
@@ -6912,20 +6965,27 @@
         guint uncompressed_length;
         guint compressed_length;
         guint8 *buf;
+        guint32 cmvd_len;
+
+        cmvd_len = QT_UINT32 ((guint8 *) cmvd->data);
+        if (cmvd_len < 12)
+          goto invalid_compression;
 
         uncompressed_length = QT_UINT32 ((guint8 *) cmvd->data + 8);
-        compressed_length = QT_UINT32 ((guint8 *) cmvd->data + 4) - 12;
+        compressed_length = cmvd_len - 12;
         GST_LOG ("length = %u", uncompressed_length);
 
         buf =
             (guint8 *) qtdemux_inflate ((guint8 *) cmvd->data + 12,
-            compressed_length, uncompressed_length);
+            compressed_length, &uncompressed_length);
 
-        qtdemux->moov_node_compressed = qtdemux->moov_node;
-        qtdemux->moov_node = g_node_new (buf);
+        if (buf) {
+          qtdemux->moov_node_compressed = qtdemux->moov_node;
+          qtdemux->moov_node = g_node_new (buf);
 
-        qtdemux_parse_node (qtdemux, qtdemux->moov_node, buf,
-            uncompressed_length);
+          qtdemux_parse_node (qtdemux, qtdemux->moov_node, buf,
+              uncompressed_length);
+        }
         break;
       }
 #endif /* HAVE_ZLIB */
@@ -7155,77 +7215,53 @@
       case FOURCC_apcn:
       case FOURCC_apco:
       case FOURCC_ap4h:
+      case FOURCC_H264:
+      case FOURCC_avc1:
+      case FOURCC_avc3:
+      case FOURCC_H265:
+      case FOURCC_hvc1:
+      case FOURCC_hev1:
+      case FOURCC_mjp2:
+      case FOURCC_encv:
       {
-        const guint8 *buf;
         guint32 version;
-        int tlen;
+        guint32 str_len;
 
         /* codec_data is contained inside these atoms, which all have
          * the same format. */
+        /* video sample description size is 86 bytes without extension.
+         * node_length have to be bigger than 86 bytes because video sample
+         * description can include extenstions such as esds, fiel, glbl, etc. */
+        if (node_length < 86) {
+          GST_WARNING_OBJECT (qtdemux, "%" GST_FOURCC_FORMAT
+              " sample description length too short (%u < 86)",
+              GST_FOURCC_ARGS (fourcc), node_length);
+          break;
+        }
 
         GST_DEBUG_OBJECT (qtdemux, "parsing in %" GST_FOURCC_FORMAT,
             GST_FOURCC_ARGS (fourcc));
+
+        /* version (2 bytes) : this is set to 0, unless a compressor has changed
+         *              its data format.
+         * revision level (2 bytes) : must be set to 0. */
         version = QT_UINT32 (buffer + 16);
         GST_DEBUG_OBJECT (qtdemux, "version %08x", version);
-        if (1 || version == 0x00000000) {
-          buf = buffer + 0x32;
 
-          /* FIXME Quicktime uses PASCAL string while
-           * the iso format uses C strings. Check the file
-           * type before attempting to parse the string here. */
-          tlen = QT_UINT8 (buf);
-          GST_DEBUG_OBJECT (qtdemux, "tlen = %d", tlen);
-          buf++;
-          GST_DEBUG_OBJECT (qtdemux, "string = %.*s", tlen, (char *) buf);
-          /* the string has a reserved space of 32 bytes so skip
-           * the remaining 31 */
-          buf += 31;
-          buf += 4;             /* and 4 bytes reserved */
+        /* compressor name : PASCAL string and informative purposes
+         * first byte : the number of bytes to be displayed.
+         *              it has to be less than 32 because it is reserved
+         *              space of 32 bytes total including itself. */
+        str_len = QT_UINT8 (buffer + 50);
+        if (str_len < 32)
+          GST_DEBUG_OBJECT (qtdemux, "compressorname = %.*s", str_len,
+              (char *) buffer + 51);
+        else
+          GST_WARNING_OBJECT (qtdemux,
+              "compressorname length too big (%u > 31)", str_len);
 
-          GST_MEMDUMP_OBJECT (qtdemux, "mp4v", buf, end - buf);
-
-          qtdemux_parse_container (qtdemux, node, buf, end);
-        }
-        break;
-      }
-      case FOURCC_H264:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "H264", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_avc1:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "avc1", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_avc3:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "avc3", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_H265:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "H265", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_hvc1:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "hvc1", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_hev1:
-      {
-        GST_MEMDUMP_OBJECT (qtdemux, "hev1", buffer, end - buffer);
-        qtdemux_parse_container (qtdemux, node, buffer + 0x56, end);
-        break;
-      }
-      case FOURCC_mjp2:
-      {
+        GST_MEMDUMP_OBJECT (qtdemux, "video sample description", buffer,
+            end - buffer);
         qtdemux_parse_container (qtdemux, node, buffer + 86, end);
         break;
       }
@@ -7247,6 +7283,12 @@
         guint32 version;
         guint32 offset;
 
+        if (length < 16) {
+          GST_LOG_OBJECT (qtdemux, "skipping small %" GST_FOURCC_FORMAT " box",
+              GST_FOURCC_ARGS (fourcc));
+          break;
+        }
+
         version = QT_UINT32 (buffer + 12);
         GST_DEBUG_OBJECT (qtdemux, "parsing XiTh atom version 0x%08x", version);
 
@@ -7259,8 +7301,15 @@
             offset = 0;
             break;
         }
-        if (offset)
+        if (offset) {
+          if (length < offset) {
+            GST_WARNING_OBJECT (qtdemux,
+                "skipping too small %" GST_FOURCC_FORMAT " box",
+                GST_FOURCC_ARGS (fourcc));
+            break;
+          }
           qtdemux_parse_container (qtdemux, node, buffer + offset, end);
+        }
         break;
       }
       case FOURCC_in24:
@@ -7273,11 +7322,6 @@
         qtdemux_parse_uuid (qtdemux, buffer, end - buffer);
         break;
       }
-      case FOURCC_encv:
-      {
-        qtdemux_parse_container (qtdemux, node, buffer + 86, end);
-        break;
-      }
       case FOURCC_enca:
       {
         qtdemux_parse_container (qtdemux, node, buffer + 36, end);
@@ -8403,6 +8447,8 @@
           /* save values */
           stream->stts_time = stts_time;
           stream->stts_sample_index = j + 1;
+          if (stream->stts_sample_index >= stream->stts_samples)
+            stream->stts_index++;
           goto done3;
         }
       }
@@ -8601,8 +8647,9 @@
     gint i, count, entry_size;
     guint64 time;
     GstClockTime stime;
-    guint8 *buffer;
+    const guint8 *buffer;
     guint8 version;
+    guint32 size;
 
     GST_DEBUG_OBJECT (qtdemux, "looking for edit list");
     if (!(elst = qtdemux_tree_get_child_by_type (edts, FOURCC_elst)))
@@ -8610,11 +8657,22 @@
 
     buffer = elst->data;
 
+    size = QT_UINT32 (buffer);
+    /* version, flags, n_segments */
+    if (size < 16) {
+      GST_WARNING_OBJECT (qtdemux, "Invalid edit list");
+      goto done;
+    }
     version = QT_UINT8 (buffer + 8);
     entry_size = (version == 1) ? 20 : 12;
 
     n_segments = QT_UINT32 (buffer + 12);
 
+    if (size < 16 + n_segments * entry_size) {
+      GST_WARNING_OBJECT (qtdemux, "Invalid edit list");
+      goto done;
+    }
+
     /* we might allocate a bit too much, at least allocate 1 segment */
     stream->segments = g_new (QtDemuxSegment, MAX (n_segments, 1));
 
@@ -8622,6 +8680,7 @@
     time = 0;
     stime = 0;
     count = 0;
+    buffer += 16;
     for (i = 0; i < n_segments; i++) {
       guint64 duration;
       guint64 media_time;
@@ -8631,13 +8690,13 @@
       GstClockTime media_start = GST_CLOCK_TIME_NONE;
 
       if (version == 1) {
-        media_time = QT_UINT64 (buffer + 24 + i * entry_size);
-        duration = QT_UINT64 (buffer + 16 + i * entry_size);
+        media_time = QT_UINT64 (buffer + 8);
+        duration = QT_UINT64 (buffer);
         if (media_time == G_MAXUINT64)
           time_valid = FALSE;
       } else {
-        media_time = QT_UINT32 (buffer + 20 + i * entry_size);
-        duration = QT_UINT32 (buffer + 16 + i * entry_size);
+        media_time = QT_UINT32 (buffer + 4);
+        duration = QT_UINT32 (buffer);
         if (media_time == G_MAXUINT32)
           time_valid = FALSE;
       }
@@ -8677,8 +8736,7 @@
         segment->media_start = GST_CLOCK_TIME_NONE;
         segment->media_stop = GST_CLOCK_TIME_NONE;
       }
-      rate_int =
-          QT_UINT32 (buffer + ((version == 1) ? 32 : 24) + i * entry_size);
+      rate_int = QT_UINT32 (buffer + ((version == 1) ? 16 : 8));
 
       if (rate_int <= 1) {
         /* 0 is not allowed, some programs write 1 instead of the floating point
@@ -8708,6 +8766,8 @@
             GST_TIME_ARGS (qtdemux->segment.stop));
         qtdemux->segment.stop = segment->stop_time;
       }
+
+      buffer += entry_size;
     }
     GST_DEBUG_OBJECT (qtdemux, "found %d segments", count);
     stream->n_segments = count;
@@ -9656,9 +9716,15 @@
 
     if (pasp) {
       const guint8 *pasp_data = (const guint8 *) pasp->data;
+      gint len = QT_UINT32 (pasp_data);
 
-      stream->par_w = QT_UINT32 (pasp_data + 8);
-      stream->par_h = QT_UINT32 (pasp_data + 12);
+      if (len == 16) {
+        stream->par_w = QT_UINT32 (pasp_data + 8);
+        stream->par_h = QT_UINT32 (pasp_data + 12);
+      } else {
+        stream->par_w = 0;
+        stream->par_h = 0;
+      }
     } else {
       stream->par_w = 0;
       stream->par_h = 0;
@@ -10061,6 +10127,7 @@
              * than its own fourcc */
             gst_caps_set_simple (stream->caps, "seqh", GST_TYPE_BUFFER, seqh,
                 NULL);
+            gst_buffer_unref (seqh);
           }
 
           GST_DEBUG_OBJECT (qtdemux, "found codec_data in stsd");
@@ -11444,7 +11511,7 @@
   } else {
     len = QT_UINT32 (node->data);
     type = QT_UINT32 ((guint8 *) node->data + 4);
-    if ((type >> 24) == 0xa9) {
+    if ((type >> 24) == 0xa9 && len > 8 + 4) {
       gint str_len;
       gint lang_code;
 
@@ -11463,7 +11530,7 @@
       }
 
       offset = 12;
-      len = str_len + 8 + 4;    /* remove trailing strings that we don't use */
+      len = MIN (len, str_len + 8 + 4); /* remove trailing strings that we don't use */
       GST_DEBUG_OBJECT (qtdemux, "found international text tag");
 
       if (lang_code < 0x800) {  /* MAC encoded string */
@@ -12851,6 +12918,24 @@
 
 }
 
+static inline GstCaps *
+_get_unknown_codec_name (const gchar * type, guint32 fourcc)
+{
+  GstCaps *caps;
+  guint i;
+  char *s, fourstr[5];
+
+  g_snprintf (fourstr, 5, "%" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
+  for (i = 0; i < 4; i++) {
+    if (!g_ascii_isalnum (fourstr[i]))
+      fourstr[i] = '_';
+  }
+  s = g_strdup_printf ("%s/x-gst-fourcc-%s", type, g_strstrip (fourstr));
+  caps = gst_caps_new_empty_simple (s);
+  g_free (s);
+  return caps;
+}
+
 #define _codec(name) \
   do { \
     if (codec_name) { \
@@ -13247,12 +13332,7 @@
     case GST_MAKE_FOURCC ('k', 'p', 'c', 'd'):
     default:
     {
-      char *s, fourstr[5];
-
-      g_snprintf (fourstr, 5, "%" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
-      s = g_strdup_printf ("video/x-gst-fourcc-%s", g_strstrip (fourstr));
-      caps = gst_caps_new_empty_simple (s);
-      g_free (s);
+      caps = _get_unknown_codec_name ("video", fourcc);
       break;
     }
   }
@@ -13563,12 +13643,7 @@
       /* ? */
     default:
     {
-      char *s, fourstr[5];
-
-      g_snprintf (fourstr, 5, "%" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
-      s = g_strdup_printf ("audio/x-gst-fourcc-%s", g_strstrip (fourstr));
-      caps = gst_caps_new_empty_simple (s);
-      g_free (s);
+      caps = _get_unknown_codec_name ("audio", fourcc);
       break;
     }
   }
@@ -13624,12 +13699,7 @@
       break;
     default:
     {
-      char *s, fourstr[5];
-
-      g_snprintf (fourstr, 5, "%" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
-      s = g_strdup_printf ("text/x-gst-fourcc-%s", g_strstrip (fourstr));
-      caps = gst_caps_new_empty_simple (s);
-      g_free (s);
+      caps = _get_unknown_codec_name ("text", fourcc);
       break;
     }
   }
diff --git a/gst/matroska/matroska-read-common.c b/gst/matroska/matroska-read-common.c
index 558c1ce..4b35129 100644
--- a/gst/matroska/matroska-read-common.c
+++ b/gst/matroska/matroska-read-common.c
@@ -106,25 +106,27 @@
 
     do {
       result = inflate (&zstream, Z_NO_FLUSH);
-      if (result != Z_OK && result != Z_STREAM_END) {
-        GST_WARNING ("zlib decompression failed.");
-        g_free (new_data);
-        inflateEnd (&zstream);
+      if (result == Z_STREAM_END) {
+        break;
+      } else if (result != Z_OK) {
+        GST_WARNING ("inflate() returned %d", result);
         break;
       }
-      new_size += 4000;
+
+      new_size += 4096;
       new_data = g_realloc (new_data, new_size);
       zstream.next_out = (Bytef *) (new_data + zstream.total_out);
-      zstream.avail_out += 4000;
-    } while (zstream.avail_in != 0 && result != Z_STREAM_END);
+      zstream.avail_out += 4096;
+    } while (zstream.avail_in > 0);
 
     if (result != Z_STREAM_END) {
       ret = FALSE;
-      goto out;
+      g_free (new_data);
     } else {
       new_size = zstream.total_out;
-      inflateEnd (&zstream);
     }
+    inflateEnd (&zstream);
+
 #else
     GST_WARNING ("zlib encoded tracks not supported.");
     ret = FALSE;
@@ -157,25 +159,27 @@
 
     do {
       result = BZ2_bzDecompress (&bzstream);
-      if (result != BZ_OK && result != BZ_STREAM_END) {
-        GST_WARNING ("bzip2 decompression failed.");
-        g_free (new_data);
-        BZ2_bzDecompressEnd (&bzstream);
+      if (result == BZ_STREAM_END) {
+        break;
+      } else if (result != BZ_OK) {
+        GST_WARNING ("BZ2_bzDecompress() returned %d", result);
         break;
       }
-      new_size += 4000;
+
+      new_size += 4096;
       new_data = g_realloc (new_data, new_size);
       bzstream.next_out = (char *) (new_data + bzstream.total_out_lo32);
-      bzstream.avail_out += 4000;
-    } while (bzstream.avail_in != 0 && result != BZ_STREAM_END);
+      bzstream.avail_out += 4096;
+    } while (bzstream.avail_in > 0);
 
     if (result != BZ_STREAM_END) {
       ret = FALSE;
-      goto out;
+      g_free (new_data);
     } else {
       new_size = bzstream.total_out_lo32;
-      BZ2_bzDecompressEnd (&bzstream);
     }
+    BZ2_bzDecompressEnd (&bzstream);
+
 #else
     GST_WARNING ("bzip2 encoded tracks not supported.");
     ret = FALSE;
@@ -198,7 +202,7 @@
       result = lzo1x_decode (new_data, &out_size, data, &orig_size);
 
       if (orig_size > 0) {
-        new_size += 4000;
+        new_size += 4096;
         new_data = g_realloc (new_data, new_size);
       }
     } while (orig_size > 0 && result == LZO_OUTPUT_FULL);
@@ -621,10 +625,9 @@
       tagsample =
           gst_tag_image_data_to_image_sample (data, datalen, image_type);
 
-      if (!tagsample)
+      if (!tagsample) {
         image_type = GST_TAG_IMAGE_TYPE_NONE;
-      else {
-        data = NULL;
+      } else {
         tagbuffer = gst_buffer_ref (gst_sample_get_buffer (tagsample));
         caps = gst_caps_ref (gst_sample_get_caps (tagsample));
         info = gst_structure_copy (gst_sample_get_info (tagsample));
diff --git a/gst/rtp/gstrtph264depay.c b/gst/rtp/gstrtph264depay.c
index 056724c..ff5415c 100644
--- a/gst/rtp/gstrtph264depay.c
+++ b/gst/rtp/gstrtph264depay.c
@@ -432,6 +432,7 @@
 
       gst_caps_unref (tmp_caps);
     }
+    gst_caps_unref (old_caps);
   } else {
     res =
         gst_pad_set_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (rtph264depay),
diff --git a/gst/rtp/gstrtpsbcdepay.c b/gst/rtp/gstrtpsbcdepay.c
index 7f8ba39..353b403 100644
--- a/gst/rtp/gstrtpsbcdepay.c
+++ b/gst/rtp/gstrtpsbcdepay.c
@@ -181,6 +181,8 @@
   }
 
   gst_caps_unref (outcaps);
+  if (oldcaps)
+     gst_caps_unref (oldcaps);
 
   return TRUE;
 
diff --git a/gst/rtpmanager/gstrtpjitterbuffer.c b/gst/rtpmanager/gstrtpjitterbuffer.c
index e1c315c..2ca9fe7 100644
--- a/gst/rtpmanager/gstrtpjitterbuffer.c
+++ b/gst/rtpmanager/gstrtpjitterbuffer.c
@@ -304,7 +304,7 @@
   /* last output time */
   GstClockTime last_out_time;
   /* last valid input timestamp and rtptime pair */
-  GstClockTime ips_dts;
+  GstClockTime ips_pts;
   guint64 ips_rtptime;
   GstClockTime packet_spacing;
   gint equidistant;
@@ -312,7 +312,7 @@
   GQueue gap_packets;
 
   /* the next expected seqnum we receive */
-  GstClockTime last_in_dts;
+  GstClockTime last_in_pts;
   guint32 next_in_seqnum;
 
   GArray *timers;
@@ -1298,7 +1298,7 @@
   }
   if ((item = rtp_jitter_buffer_peek (priv->jbuf))) {
     /* head buffer timestamp and offset gives our output time */
-    last_out = item->dts + priv->ts_offset;
+    last_out = item->pts + priv->ts_offset;
   } else {
     /* use last known time when the buffer is empty */
     last_out = priv->last_out_time;
@@ -1554,7 +1554,7 @@
   priv->next_seqnum = -1;
   priv->seqnum_base = -1;
   priv->ips_rtptime = -1;
-  priv->ips_dts = GST_CLOCK_TIME_NONE;
+  priv->ips_pts = GST_CLOCK_TIME_NONE;
   priv->packet_spacing = 0;
   priv->next_in_seqnum = -1;
   priv->clock_rate = -1;
@@ -1566,7 +1566,7 @@
   priv->avg_jitter = 0;
   priv->last_dts = -1;
   priv->last_rtptime = -1;
-  priv->last_in_dts = 0;
+  priv->last_in_pts = 0;
   priv->equidistant = 0;
   GST_DEBUG_OBJECT (jitterbuffer, "flush and reset jitterbuffer");
   rtp_jitter_buffer_flush (priv->jbuf, (GFunc) free_item, NULL);
@@ -1782,7 +1782,7 @@
 
   GST_DEBUG_OBJECT (jitterbuffer, "adding event");
   item = alloc_item (event, ITEM_TYPE_EVENT, -1, -1, -1, 0, -1);
-  rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL, -1);
+  rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL);
   if (head)
     JBUF_SIGNAL_EVENT (priv);
 
@@ -2156,21 +2156,26 @@
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
   gboolean seqchange, timechange;
   guint16 oldseq;
-
-  seqchange = timer->seqnum != seqnum;
-  timechange = timer->timeout != timeout;
-
-  if (!seqchange && !timechange)
-    return;
+  GstClockTime new_timeout;
 
   oldseq = timer->seqnum;
+  new_timeout = timeout + delay;
+  seqchange = oldseq != seqnum;
+  timechange = timer->timeout != new_timeout;
+
+  if (!seqchange && !timechange) {
+    GST_DEBUG_OBJECT (jitterbuffer,
+        "No changes in seqnum (%d) and timeout (%" GST_TIME_FORMAT
+        "), skipping", oldseq, GST_TIME_ARGS (timer->timeout));
+    return;
+  }
 
   GST_DEBUG_OBJECT (jitterbuffer,
       "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));
+      GST_TIME_ARGS (timer->timeout), GST_TIME_ARGS (new_timeout));
 
-  timer->timeout = timeout + delay;
+  timer->timeout = new_timeout;
   timer->seqnum = seqnum;
   if (reset) {
     GST_DEBUG_OBJECT (jitterbuffer, "reset rtx delay %" GST_TIME_FORMAT
@@ -2299,8 +2304,8 @@
  */
 static void
 update_timers (GstRtpJitterBuffer * jitterbuffer, guint16 seqnum,
-    GstClockTime dts, gboolean do_next_seqnum, gboolean is_rtx,
-    TimerData * timer)
+    GstClockTime dts, GstClockTime pts, gboolean do_next_seqnum,
+    gboolean is_rtx, TimerData * timer)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
 
@@ -2346,16 +2351,16 @@
          * 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);
+            pts + priv->rtx_stats_timeout * GST_MSECOND, FALSE);
       }
     }
   }
 
-  if (do_next_seqnum && dts != GST_CLOCK_TIME_NONE) {
+  if (do_next_seqnum && pts != GST_CLOCK_TIME_NONE) {
     GstClockTime expected, delay;
 
     /* calculate expected arrival time of the next seqnum */
-    expected = dts + priv->packet_spacing;
+    expected = pts + priv->packet_spacing;
 
     delay = get_rtx_delay (priv);
 
@@ -2367,6 +2372,7 @@
         GST_TIME_ARGS (priv->packet_spacing), GST_TIME_ARGS (priv->avg_jitter));
 
     if (timer) {
+      timer->type = TIMER_TYPE_EXPECTED;
       reschedule_timer (jitterbuffer, timer, priv->next_in_seqnum, expected,
           delay, TRUE);
     } else {
@@ -2382,16 +2388,16 @@
 
 static void
 calculate_packet_spacing (GstRtpJitterBuffer * jitterbuffer, guint32 rtptime,
-    GstClockTime dts)
+    GstClockTime pts)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
 
   /* we need consecutive seqnums with a different
    * rtptime to estimate the packet spacing. */
   if (priv->ips_rtptime != rtptime) {
-    /* rtptime changed, check dts diff */
-    if (priv->ips_dts != -1 && dts != -1 && dts > priv->ips_dts) {
-      GstClockTime new_packet_spacing = dts - priv->ips_dts;
+    /* rtptime changed, check pts diff */
+    if (priv->ips_pts != -1 && pts != -1 && pts > priv->ips_pts) {
+      GstClockTime new_packet_spacing = pts - priv->ips_pts;
       GstClockTime old_packet_spacing = priv->packet_spacing;
 
       /* Biased towards bigger packet spacings to prevent
@@ -2416,33 +2422,33 @@
           GST_TIME_ARGS (priv->packet_spacing));
     }
     priv->ips_rtptime = rtptime;
-    priv->ips_dts = dts;
+    priv->ips_pts = pts;
   }
 }
 
 static void
 calculate_expected (GstRtpJitterBuffer * jitterbuffer, guint32 expected,
-    guint16 seqnum, GstClockTime dts, gint gap)
+    guint16 seqnum, GstClockTime pts, gint gap)
 {
   GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
-  GstClockTime duration, expected_dts, delay;
+  GstClockTime duration, expected_pts, delay;
   TimerType type;
   gboolean equidistant = priv->equidistant > 0;
 
   GST_DEBUG_OBJECT (jitterbuffer,
-      "dts %" GST_TIME_FORMAT ", last %" GST_TIME_FORMAT,
-      GST_TIME_ARGS (dts), GST_TIME_ARGS (priv->last_in_dts));
+      "pts %" GST_TIME_FORMAT ", last %" GST_TIME_FORMAT,
+      GST_TIME_ARGS (pts), GST_TIME_ARGS (priv->last_in_pts));
 
-  if (dts == GST_CLOCK_TIME_NONE) {
-    GST_WARNING_OBJECT (jitterbuffer, "Have no DTS");
+  if (pts == GST_CLOCK_TIME_NONE) {
+    GST_WARNING_OBJECT (jitterbuffer, "Have no PTS");
     return;
   }
 
   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;
+    if (pts >= priv->last_in_pts)
+      total_duration = pts - priv->last_in_pts;
     else
       total_duration = 0;
 
@@ -2483,19 +2489,19 @@
        * the timer thread */
       if (lost_packets > 0) {
         add_timer (jitterbuffer, TIMER_TYPE_LOST, expected, lost_packets,
-            priv->last_in_dts + duration, 0, gap_time);
+            priv->last_in_pts + duration, 0, gap_time);
         expected += lost_packets;
-        priv->last_in_dts += gap_time;
+        priv->last_in_pts += gap_time;
       }
     }
 
-    expected_dts = priv->last_in_dts + duration;
+    expected_pts = priv->last_in_pts + 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. */
+     * for sure is that the missing packets have expected pts not later than
+     * the last received pts. */
     duration = 0;
-    expected_dts = dts;
+    expected_pts = pts;
   }
 
   delay = 0;
@@ -2511,20 +2517,20 @@
       GstClockTime timeout = timer->timeout;
 
       timer->duration = duration;
-      if (timeout > (expected_dts + delay) && timer->num_rtx_retry == 0) {
-        reschedule_timer (jitterbuffer, timer, timer->seqnum, expected_dts,
+      if (timeout > (expected_pts + delay) && timer->num_rtx_retry == 0) {
+        reschedule_timer (jitterbuffer, timer, timer->seqnum, expected_pts,
             delay, TRUE);
       }
       expected++;
-      expected_dts += duration;
+      expected_pts += duration;
     }
   } else {
     type = TIMER_TYPE_LOST;
   }
 
   while (gst_rtp_buffer_compare_seqnum (expected, seqnum) > 0) {
-    add_timer (jitterbuffer, type, expected, 0, expected_dts, delay, duration);
-    expected_dts += duration;
+    add_timer (jitterbuffer, type, expected, 0, expected_pts, delay, duration);
+    expected_pts += duration;
     expected++;
   }
 }
@@ -2612,13 +2618,13 @@
 }
 
 static gboolean
-handle_big_gap_buffer (GstRtpJitterBuffer * jitterbuffer, gboolean future,
-    GstBuffer * buffer, guint8 pt, guint16 seqnum, gint gap, guint max_dropout,
-    guint max_misorder)
+handle_big_gap_buffer (GstRtpJitterBuffer * jitterbuffer, GstBuffer * buffer,
+    guint8 pt, guint16 seqnum, gint gap, guint max_dropout, guint max_misorder)
 {
   GstRtpJitterBufferPrivate *priv;
   guint gap_packets_length;
   gboolean reset = FALSE;
+  gboolean future = gap > 0;
 
   priv = jitterbuffer->priv;
 
@@ -2707,6 +2713,78 @@
 }
 
 static GstFlowReturn
+gst_rtp_jitter_buffer_reset (GstRtpJitterBuffer * jitterbuffer,
+    GstPad * pad, GstObject * parent, guint16 seqnum)
+{
+  GstRtpJitterBufferPrivate *priv = jitterbuffer->priv;
+  GstFlowReturn ret = GST_FLOW_OK;
+  GList *events = NULL, *l;
+  GList *buffers;
+  gboolean head;
+
+  GST_DEBUG_OBJECT (jitterbuffer, "flush and reset jitterbuffer");
+  rtp_jitter_buffer_flush (priv->jbuf,
+      (GFunc) free_item_and_retain_events, &events);
+  rtp_jitter_buffer_reset_skew (priv->jbuf);
+  remove_all_timers (jitterbuffer);
+  priv->discont = TRUE;
+  priv->last_popped_seqnum = -1;
+
+  if (priv->gap_packets.head) {
+    GstBuffer *gap_buffer = priv->gap_packets.head->data;
+    GstRTPBuffer gap_rtp = GST_RTP_BUFFER_INIT;
+
+    gst_rtp_buffer_map (gap_buffer, GST_MAP_READ, &gap_rtp);
+    priv->next_seqnum = gst_rtp_buffer_get_seq (&gap_rtp);
+    gst_rtp_buffer_unmap (&gap_rtp);
+  } else {
+    priv->next_seqnum = seqnum;
+  }
+
+  priv->last_in_pts = -1;
+  priv->next_in_seqnum = -1;
+
+  /* Insert all sticky events again in order, otherwise we would
+   * potentially loose STREAM_START, CAPS or SEGMENT events
+   */
+  events = g_list_reverse (events);
+  for (l = events; l; l = l->next) {
+    RTPJitterBufferItem *item;
+
+    item = alloc_item (l->data, ITEM_TYPE_EVENT, -1, -1, -1, 0, -1);
+    rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL);
+  }
+  g_list_free (events);
+
+  JBUF_SIGNAL_EVENT (priv);
+
+  /* reset spacing estimation when gap */
+  priv->ips_rtptime = -1;
+  priv->ips_pts = GST_CLOCK_TIME_NONE;
+
+  buffers = g_list_copy (priv->gap_packets.head);
+  g_queue_clear (&priv->gap_packets);
+
+  priv->ips_rtptime = -1;
+  priv->ips_pts = GST_CLOCK_TIME_NONE;
+  JBUF_UNLOCK (jitterbuffer->priv);
+
+  for (l = buffers; l; l = l->next) {
+    ret = gst_rtp_jitter_buffer_chain (pad, parent, l->data);
+    l->data = NULL;
+    if (ret != GST_FLOW_OK) {
+      l = l->next;
+      break;
+    }
+  }
+  for (; l; l = l->next)
+    gst_buffer_unref (l->data);
+  g_list_free (buffers);
+
+  return ret;
+}
+
+static GstFlowReturn
 gst_rtp_jitter_buffer_chain (GstPad * pad, GstObject * parent,
     GstBuffer * buffer)
 {
@@ -2725,7 +2803,7 @@
   RTPJitterBufferItem *item;
   GstMessage *msg = NULL;
   gboolean estimated_dts = FALSE;
-  guint32 packet_rate, max_dropout, max_misorder;
+  gint32 packet_rate, max_dropout, max_misorder;
   TimerData *timer = NULL;
 
   jitterbuffer = GST_RTP_JITTER_BUFFER_CAST (parent);
@@ -2823,7 +2901,6 @@
           "packet seqnum #%d before seqnum-base #%d", seqnum,
           priv->seqnum_base);
       gst_buffer_unref (buffer);
-      ret = GST_FLOW_OK;
       goto finished;
     } else if (gap > 16384) {
       /* From now on don't compare against the seqnum base anymore as
@@ -2848,156 +2925,90 @@
       max_dropout, max_misorder);
 
   /* now check against our expected seqnum */
-  if (G_LIKELY (expected != -1)) {
-    gint gap;
-
-    /* now calculate gap */
-    gap = gst_rtp_buffer_compare_seqnum (expected, seqnum);
-
-    GST_DEBUG_OBJECT (jitterbuffer, "expected #%d, got #%d, gap of %d",
-        expected, seqnum, gap);
-
-    if (G_LIKELY (gap == 0)) {
-      /* packet is expected */
-      calculate_packet_spacing (jitterbuffer, rtptime, dts);
-      do_next_seqnum = TRUE;
-    } else {
-      gboolean reset = FALSE;
-
-      if (gap < 0) {
-        /* we received an old packet */
-        if (G_UNLIKELY (gap != -1 && gap < -max_misorder)) {
-          reset =
-              handle_big_gap_buffer (jitterbuffer, FALSE, buffer, pt, seqnum,
-              gap, max_dropout, max_misorder);
-          buffer = NULL;
-        } else {
-          GST_DEBUG_OBJECT (jitterbuffer, "old packet received");
-        }
-      } else {
-        /* new packet, we are missing some packets */
-        if (G_UNLIKELY (priv->timers->len >= max_dropout)) {
-          /* If we have timers for more than RTP_MAX_DROPOUT packets
-           * pending this means that we have a huge gap overall. We can
-           * reset the jitterbuffer at this point because there's
-           * just too much data missing to be able to do anything
-           * sensible with the past data. Just try again from the
-           * next packet */
-          GST_WARNING_OBJECT (jitterbuffer,
-              "%d pending timers > %d - resetting", priv->timers->len,
-              max_dropout);
-          reset = TRUE;
-          gst_buffer_unref (buffer);
-          buffer = NULL;
-        } else if (G_UNLIKELY (gap >= max_dropout)) {
-          reset =
-              handle_big_gap_buffer (jitterbuffer, TRUE, buffer, pt, seqnum,
-              gap, max_dropout, max_misorder);
-          buffer = NULL;
-        } else {
-          GST_DEBUG_OBJECT (jitterbuffer, "%d missing packets", gap);
-          /* fill in the gap with EXPECTED timers */
-          calculate_expected (jitterbuffer, expected, seqnum, dts, gap);
-
-          do_next_seqnum = TRUE;
-        }
-      }
-      if (G_UNLIKELY (reset)) {
-        GList *events = NULL, *l;
-        GList *buffers;
-
-        GST_DEBUG_OBJECT (jitterbuffer, "flush and reset jitterbuffer");
-        rtp_jitter_buffer_flush (priv->jbuf,
-            (GFunc) free_item_and_retain_events, &events);
-        rtp_jitter_buffer_reset_skew (priv->jbuf);
-        remove_all_timers (jitterbuffer);
-        priv->discont = TRUE;
-        priv->last_popped_seqnum = -1;
-
-        if (priv->gap_packets.head) {
-          GstBuffer *gap_buffer = priv->gap_packets.head->data;
-          GstRTPBuffer gap_rtp = GST_RTP_BUFFER_INIT;
-
-          gst_rtp_buffer_map (gap_buffer, GST_MAP_READ, &gap_rtp);
-          priv->next_seqnum = gst_rtp_buffer_get_seq (&gap_rtp);
-          gst_rtp_buffer_unmap (&gap_rtp);
-        } else {
-          priv->next_seqnum = seqnum;
-        }
-
-        priv->last_in_dts = -1;
-        priv->next_in_seqnum = -1;
-
-        /* Insert all sticky events again in order, otherwise we would
-         * potentially loose STREAM_START, CAPS or SEGMENT events
-         */
-        events = g_list_reverse (events);
-        for (l = events; l; l = l->next) {
-          RTPJitterBufferItem *item;
-
-          item = alloc_item (l->data, ITEM_TYPE_EVENT, -1, -1, -1, 0, -1);
-          rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL, -1);
-        }
-        g_list_free (events);
-
-        JBUF_SIGNAL_EVENT (priv);
-
-        /* reset spacing estimation when gap */
-        priv->ips_rtptime = -1;
-        priv->ips_dts = GST_CLOCK_TIME_NONE;
-
-        buffers = g_list_copy (priv->gap_packets.head);
-        g_queue_clear (&priv->gap_packets);
-
-        priv->ips_rtptime = -1;
-        priv->ips_dts = GST_CLOCK_TIME_NONE;
-        JBUF_UNLOCK (jitterbuffer->priv);
-
-        for (l = buffers; l; l = l->next) {
-          ret = gst_rtp_jitter_buffer_chain (pad, parent, l->data);
-          l->data = NULL;
-          if (ret != GST_FLOW_OK) {
-            l = l->next;
-            break;
-          }
-        }
-        for (; l; l = l->next)
-          gst_buffer_unref (l->data);
-        g_list_free (buffers);
-
-        return ret;
-      }
-      /* reset spacing estimation when gap */
-      priv->ips_rtptime = -1;
-      priv->ips_dts = GST_CLOCK_TIME_NONE;
-    }
-  } else {
+  if (G_UNLIKELY (expected == -1)) {
     GST_DEBUG_OBJECT (jitterbuffer, "First buffer #%d", seqnum);
 
+    /* calculate a pts based on rtptime and arrival time (dts) */
+    pts = rtp_jitter_buffer_calculate_pts (priv->jbuf, dts, rtptime,
+        gst_element_get_base_time (GST_ELEMENT_CAST (jitterbuffer)));
+
     /* we don't know what the next_in_seqnum should be, wait for the last
      * possible moment to push this buffer, maybe we get an earlier seqnum
      * while we wait */
-    set_timer (jitterbuffer, TIMER_TYPE_DEADLINE, seqnum, dts);
-    do_next_seqnum = TRUE;
-    /* take rtptime and dts to calculate packet spacing */
-    priv->ips_rtptime = rtptime;
-    priv->ips_dts = dts;
-  }
+    set_timer (jitterbuffer, TIMER_TYPE_DEADLINE, seqnum, pts);
 
-  /* We had no huge gap, let's drop all the gap packets */
-  if (buffer != NULL) {
+    do_next_seqnum = TRUE;
+    /* take rtptime and pts to calculate packet spacing */
+    priv->ips_rtptime = rtptime;
+    priv->ips_pts = pts;
+
+  } else {
+    gint gap;
+    /* now calculate gap */
+    gap = gst_rtp_buffer_compare_seqnum (expected, seqnum);
+    GST_DEBUG_OBJECT (jitterbuffer, "expected #%d, got #%d, gap of %d",
+        expected, seqnum, gap);
+
+    if (G_UNLIKELY (gap > 0 && priv->timers->len >= max_dropout)) {
+      /* If we have timers for more than RTP_MAX_DROPOUT packets
+       * pending this means that we have a huge gap overall. We can
+       * reset the jitterbuffer at this point because there's
+       * just too much data missing to be able to do anything
+       * sensible with the past data. Just try again from the
+       * next packet */
+      GST_WARNING_OBJECT (jitterbuffer, "%d pending timers > %d - resetting",
+          priv->timers->len, max_dropout);
+      gst_buffer_unref (buffer);
+      return gst_rtp_jitter_buffer_reset (jitterbuffer, pad, parent, seqnum);
+    }
+
+    /* Special handling of large gaps */
+    if ((gap != -1 && gap < -max_misorder) || (gap >= max_dropout)) {
+      gboolean reset = handle_big_gap_buffer (jitterbuffer, buffer, pt, seqnum,
+          gap, max_dropout, max_misorder);
+      if (reset) {
+        return gst_rtp_jitter_buffer_reset (jitterbuffer, pad, parent, seqnum);
+      } else {
+        GST_DEBUG_OBJECT (jitterbuffer,
+            "Had big gap, waiting for more consecutive packets");
+        goto finished;
+      }
+    }
+
+    /* We had no huge gap, let's drop all the gap packets */
     GST_DEBUG_OBJECT (jitterbuffer, "Clearing gap packets");
     g_queue_foreach (&priv->gap_packets, (GFunc) gst_buffer_unref, NULL);
     g_queue_clear (&priv->gap_packets);
-  } else {
-    GST_DEBUG_OBJECT (jitterbuffer,
-        "Had big gap, waiting for more consecutive packets");
-    JBUF_UNLOCK (jitterbuffer->priv);
-    return GST_FLOW_OK;
+
+    /* calculate a pts based on rtptime and arrival time (dts) */
+    pts = rtp_jitter_buffer_calculate_pts (priv->jbuf, dts, rtptime,
+        gst_element_get_base_time (GST_ELEMENT_CAST (jitterbuffer)));
+
+    if (G_LIKELY (gap == 0)) {
+      /* packet is expected */
+      calculate_packet_spacing (jitterbuffer, rtptime, pts);
+      do_next_seqnum = TRUE;
+    } else {
+
+      /* we have a gap */
+      if (gap > 0) {
+        GST_DEBUG_OBJECT (jitterbuffer, "%d missing packets", gap);
+        /* fill in the gap with EXPECTED timers */
+        calculate_expected (jitterbuffer, expected, seqnum, pts, gap);
+        do_next_seqnum = TRUE;
+      } else {
+        GST_DEBUG_OBJECT (jitterbuffer, "old packet received");
+        do_next_seqnum = FALSE;
+      }
+
+      /* reset spacing estimation when gap */
+      priv->ips_rtptime = -1;
+      priv->ips_pts = GST_CLOCK_TIME_NONE;
+    }
   }
 
   if (do_next_seqnum) {
-    priv->last_in_dts = dts;
+    priv->last_in_pts = pts;
     priv->next_in_seqnum = (seqnum + 1) & 0xffff;
   }
 
@@ -3068,23 +3079,22 @@
   if (estimated_dts)
     item =
         alloc_item (buffer, ITEM_TYPE_BUFFER, GST_CLOCK_TIME_NONE,
-        GST_CLOCK_TIME_NONE, seqnum, 1, rtptime);
+        pts, seqnum, 1, rtptime);
   else
     item = alloc_item (buffer, ITEM_TYPE_BUFFER, dts, pts, seqnum, 1, rtptime);
 
   /* now insert the packet into the queue in sorted order. This function returns
    * FALSE if a packet with the same seqnum was already in the queue, meaning we
    * have a duplicate. */
-  if (G_UNLIKELY (!rtp_jitter_buffer_insert (priv->jbuf, item,
-              &head, &percent,
-              gst_element_get_base_time (GST_ELEMENT_CAST (jitterbuffer))))) {
+  if (G_UNLIKELY (!rtp_jitter_buffer_insert (priv->jbuf, item, &head,
+              &percent))) {
     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, pts, do_next_seqnum,
       GST_BUFFER_IS_RETRANSMISSION (buffer), timer);
 
   /* we had an unhandled SR, handle it now */
@@ -3253,7 +3263,7 @@
   }
 
   /* this is the current time as running-time */
-  out_time = item->dts;
+  out_time = item->pts;
 
   if (elapsed > 0)
     estimated = gst_util_uint64_scale (out_time, total, elapsed);
@@ -3726,7 +3736,7 @@
   /* we now only accept seqnum bigger than this */
   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);
+    priv->last_in_pts = apply_offset (jitterbuffer, timer->timeout);
   }
 
   /* Avoid creating events if we don't need it. Note that we still need to create
@@ -3747,7 +3757,9 @@
             "retry", G_TYPE_UINT, num_rtx_retry, NULL));
   }
   item = alloc_item (event, ITEM_TYPE_LOST, -1, -1, seqnum, lost_packets, -1);
-  rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL, -1);
+  if (!rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL))
+    /* Duplicate */
+    free_item (item);
 
   if (GST_CLOCK_TIME_IS_VALID (timer->rtx_last)) {
     /* Store info to update stats if the packet arrives too late */
@@ -4245,7 +4257,7 @@
             RTP_JITTER_BUFFER_MODE_BUFFER) {
           GST_DEBUG_OBJECT (jitterbuffer, "adding serialized query");
           item = alloc_item (query, ITEM_TYPE_QUERY, -1, -1, -1, 0, -1);
-          rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL, -1);
+          rtp_jitter_buffer_insert (priv->jbuf, item, &head, NULL);
           if (head)
             JBUF_SIGNAL_EVENT (priv);
           JBUF_WAIT_QUERY (priv, out_flushing);
diff --git a/gst/rtpmanager/gstrtpsession.c b/gst/rtpmanager/gstrtpsession.c
index 3688e85..fd1f2b1 100644
--- a/gst/rtpmanager/gstrtpsession.c
+++ b/gst/rtpmanager/gstrtpsession.c
@@ -293,7 +293,7 @@
 static GstFlowReturn gst_rtp_session_send_rtp (RTPSession * sess,
     RTPSource * src, gpointer data, gpointer user_data);
 static GstFlowReturn gst_rtp_session_send_rtcp (RTPSession * sess,
-    RTPSource * src, GstBuffer * buffer, gboolean eos, gpointer user_data);
+    RTPSource * src, GstBuffer * buffer, gpointer user_data);
 static GstFlowReturn gst_rtp_session_sync_rtcp (RTPSession * sess,
     GstBuffer * buffer, gpointer user_data);
 static gint gst_rtp_session_clock_rate (RTPSession * sess, guint8 payload,
@@ -1156,6 +1156,22 @@
     GST_RTP_SESSION_UNLOCK (rtpsession);
     rtp_session_on_timeout (session, current_time, ntpnstime, running_time);
     GST_RTP_SESSION_LOCK (rtpsession);
+
+    if (!rtp_session_get_num_sources (session)) {
+      /* when no sources left in the session, all of the them have went
+       * BYE at some point and removed, we can send EOS to the
+       * pipeline. */
+      GstPad *rtcp_src = rtpsession->send_rtcp_src;
+
+      if (rtcp_src) {
+        gst_object_ref (rtcp_src);
+        GST_LOG_OBJECT (rtpsession, "sending EOS");
+        GST_RTP_SESSION_UNLOCK (rtpsession);
+        gst_pad_push_event (rtpsession->send_rtcp_src, gst_event_new_eos ());
+        GST_RTP_SESSION_LOCK (rtpsession);
+        gst_object_unref (rtcp_src);
+      }
+    }
   }
   /* mark the thread as stopped now */
   rtpsession->priv->thread_stopped = TRUE;
@@ -1413,11 +1429,10 @@
 }
 
 /* called when the session manager has an RTCP packet ready for further
- * sending. The eos flag is set when an EOS event should be sent downstream as
- * well. */
+ * sending. */
 static GstFlowReturn
 gst_rtp_session_send_rtcp (RTPSession * sess, RTPSource * src,
-    GstBuffer * buffer, gboolean eos, gpointer user_data)
+    GstBuffer * buffer, gpointer user_data)
 {
   GstFlowReturn result;
   GstRtpSession *rtpsession;
@@ -1440,11 +1455,6 @@
     GST_LOG_OBJECT (rtpsession, "sending RTCP");
     result = gst_pad_push (rtcp_src, buffer);
 
-    /* we have to send EOS after this packet */
-    if (eos) {
-      GST_LOG_OBJECT (rtpsession, "sending EOS");
-      gst_pad_push_event (rtcp_src, gst_event_new_eos ());
-    }
     gst_object_unref (rtcp_src);
   } else {
     GST_RTP_SESSION_UNLOCK (rtpsession);
@@ -2056,7 +2066,6 @@
   return ret;
 }
 
-
 static gboolean
 gst_rtp_session_event_send_rtp_sink (GstPad * pad, GstObject * parent,
     GstEvent * event)
diff --git a/gst/rtpmanager/rtpjitterbuffer.c b/gst/rtpmanager/rtpjitterbuffer.c
index 0ffbe54..03b7ebc 100644
--- a/gst/rtpmanager/rtpjitterbuffer.c
+++ b/gst/rtpmanager/rtpjitterbuffer.c
@@ -688,92 +688,16 @@
   queue->length++;
 }
 
-/**
- * rtp_jitter_buffer_insert:
- * @jbuf: an #RTPJitterBuffer
- * @item: an #RTPJitterBufferItem to insert
- * @head: TRUE when the head element changed.
- * @percent: the buffering percent after insertion
- * @base_time: base time of the pipeline
- *
- * Inserts @item into the packet queue of @jbuf. The sequence number of the
- * packet will be used to sort the packets. This function takes ownerhip of
- * @buf when the function returns %TRUE.
- *
- * When @head is %TRUE, the new packet was added at the head of the queue and
- * will be available with the next call to rtp_jitter_buffer_pop() and
- * rtp_jitter_buffer_peek().
- *
- * Returns: %FALSE if a packet with the same number already existed.
- */
-gboolean
-rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, RTPJitterBufferItem * item,
-    gboolean * head, gint * percent, GstClockTime base_time)
+GstClockTime
+rtp_jitter_buffer_calculate_pts (RTPJitterBuffer * jbuf, GstClockTime dts,
+      guint32 rtptime, GstClockTime base_time)
 {
-  GList *list, *event = NULL;
-  guint32 rtptime;
   guint64 ext_rtptime;
-  guint16 seqnum;
-  GstClockTime gstrtptime, dts;
+  GstClockTime gstrtptime, pts;
   GstClock *media_clock, *pipeline_clock;
   guint64 media_clock_offset;
   gboolean rfc7273_mode;
 
-  g_return_val_if_fail (jbuf != NULL, FALSE);
-  g_return_val_if_fail (item != NULL, FALSE);
-
-  list = jbuf->packets->tail;
-
-  /* no seqnum, simply append then */
-  if (item->seqnum == -1)
-    goto append;
-
-  seqnum = item->seqnum;
-
-  /* loop the list to skip strictly larger seqnum buffers */
-  for (; list; list = g_list_previous (list)) {
-    guint16 qseq;
-    gint gap;
-    RTPJitterBufferItem *qitem = (RTPJitterBufferItem *) list;
-
-    if (qitem->seqnum == -1) {
-      /* keep a pointer to the first consecutive event if not already
-       * set. we will insert the packet after the event if we can't find
-       * a packet with lower sequence number before the event. */
-      if (event == NULL)
-        event = list;
-      continue;
-    }
-
-    qseq = qitem->seqnum;
-
-    /* compare the new seqnum to the one in the buffer */
-    gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq);
-
-    /* we hit a packet with the same seqnum, notify a duplicate */
-    if (G_UNLIKELY (gap == 0))
-      goto duplicate;
-
-    /* seqnum > qseq, we can stop looking */
-    if (G_LIKELY (gap < 0))
-      break;
-
-    /* if we've found a packet with greater sequence number, cleanup the
-     * event pointer as the packet will be inserted before the event */
-    event = NULL;
-  }
-
-  /* if event is set it means that packets before the event had smaller
-   * sequence number, so we will insert our packet after the event */
-  if (event)
-    list = event;
-
-  dts = item->dts;
-  if (item->rtptime == -1)
-    goto append;
-
-  rtptime = item->rtptime;
-
   /* rtp time jumps are checked for during skew calculation, but bypassed
    * in other mode, so mind those here and reset jb if needed.
    * Only reset if valid input time, which is likely for UDP input
@@ -797,8 +721,7 @@
   /* Return the last time if we got the same RTP timestamp again */
   ext_rtptime = gst_rtp_buffer_ext_timestamp (&jbuf->ext_rtptime, rtptime);
   if (jbuf->last_rtptime != -1 && ext_rtptime == jbuf->last_rtptime) {
-    item->pts = jbuf->prev_out_time;
-    goto append;
+    return jbuf->prev_out_time;
   }
 
   /* keep track of the last extended rtptime */
@@ -906,12 +829,12 @@
         external, rate_num, rate_denom);
 
     if (rtpsystime > base_time)
-      item->pts = rtpsystime - base_time;
+      pts = rtpsystime - base_time;
     else
-      item->pts = 0;
+      pts = 0;
 
     GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
-        GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (item->pts));
+        GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
   } else if (rfc7273_mode && (jbuf->mode == RTP_JITTER_BUFFER_MODE_SLAVE
           || jbuf->mode == RTP_JITTER_BUFFER_MODE_SYNCED)
       && media_clock_offset != -1 && jbuf->rfc7273_sync) {
@@ -960,12 +883,12 @@
     /* All this assumes that the pipeline has enough additional
      * latency to cover for the network delay */
     if (rtpsystime > base_time)
-      item->pts = rtpsystime - base_time;
+      pts = rtpsystime - base_time;
     else
-      item->pts = 0;
+      pts = 0;
 
     GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
-        GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (item->pts));
+        GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
   } else {
     /* If we used the RFC7273 clock before and not anymore,
      * we need to resync it later again */
@@ -973,39 +896,40 @@
 
     /* do skew calculation by measuring the difference between rtptime and the
      * receive dts, this function will return the skew corrected rtptime. */
-    item->pts = calculate_skew (jbuf, ext_rtptime, gstrtptime, dts);
+    pts = calculate_skew (jbuf, ext_rtptime, gstrtptime, dts);
   }
 
   /* check if timestamps are not going backwards, we can only check this if we
    * have a previous out time and a previous send_diff */
-  if (G_LIKELY (item->pts != -1 && jbuf->prev_out_time != -1
+  if (G_LIKELY (pts != -1 && jbuf->prev_out_time != -1
           && jbuf->prev_send_diff != -1)) {
     /* now check for backwards timestamps */
     if (G_UNLIKELY (
             /* if the server timestamps went up and the out_time backwards */
             (gstrtptime - jbuf->base_rtptime > jbuf->prev_send_diff
-                && item->pts < jbuf->prev_out_time) ||
+                && pts < jbuf->prev_out_time) ||
             /* if the server timestamps went backwards and the out_time forwards */
             (gstrtptime - jbuf->base_rtptime < jbuf->prev_send_diff
-                && item->pts > jbuf->prev_out_time) ||
+                && pts > jbuf->prev_out_time) ||
             /* if the server timestamps did not change */
             gstrtptime - jbuf->base_rtptime == jbuf->prev_send_diff)) {
       GST_DEBUG ("backwards timestamps, using previous time");
-      item->pts = jbuf->prev_out_time;
+      pts = jbuf->prev_out_time;
     }
   }
-  if (dts != -1 && item->pts + jbuf->delay < dts) {
+
+  if (dts != -1 && pts + jbuf->delay < dts) {
     /* if we are going to produce a timestamp that is later than the input
      * timestamp, we need to reset the jitterbuffer. Likely the server paused
      * temporarily */
     GST_DEBUG ("out %" GST_TIME_FORMAT " + %" G_GUINT64_FORMAT " < time %"
-        GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (item->pts),
+        GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (pts),
         jbuf->delay, GST_TIME_ARGS (dts));
     rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, TRUE);
-    item->pts = dts;
+    pts = dts;
   }
 
-  jbuf->prev_out_time = item->pts;
+  jbuf->prev_out_time = pts;
   jbuf->prev_send_diff = gstrtptime - jbuf->base_rtptime;
 
   if (media_clock)
@@ -1013,6 +937,83 @@
   if (pipeline_clock)
     gst_object_unref (pipeline_clock);
 
+  return pts;
+}
+
+
+/**
+ * rtp_jitter_buffer_insert:
+ * @jbuf: an #RTPJitterBuffer
+ * @item: an #RTPJitterBufferItem to insert
+ * @head: TRUE when the head element changed.
+ * @percent: the buffering percent after insertion
+ *
+ * Inserts @item into the packet queue of @jbuf. The sequence number of the
+ * packet will be used to sort the packets. This function takes ownerhip of
+ * @buf when the function returns %TRUE.
+ *
+ * When @head is %TRUE, the new packet was added at the head of the queue and
+ * will be available with the next call to rtp_jitter_buffer_pop() and
+ * rtp_jitter_buffer_peek().
+ *
+ * Returns: %FALSE if a packet with the same number already existed.
+ */
+gboolean
+rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, RTPJitterBufferItem * item,
+    gboolean * head, gint * percent)
+{
+  GList *list, *event = NULL;
+  guint16 seqnum;
+
+  g_return_val_if_fail (jbuf != NULL, FALSE);
+  g_return_val_if_fail (item != NULL, FALSE);
+
+  list = jbuf->packets->tail;
+
+  /* no seqnum, simply append then */
+  if (item->seqnum == -1)
+    goto append;
+
+  seqnum = item->seqnum;
+
+  /* loop the list to skip strictly larger seqnum buffers */
+  for (; list; list = g_list_previous (list)) {
+    guint16 qseq;
+    gint gap;
+    RTPJitterBufferItem *qitem = (RTPJitterBufferItem *) list;
+
+    if (qitem->seqnum == -1) {
+      /* keep a pointer to the first consecutive event if not already
+       * set. we will insert the packet after the event if we can't find
+       * a packet with lower sequence number before the event. */
+      if (event == NULL)
+        event = list;
+      continue;
+    }
+
+    qseq = qitem->seqnum;
+
+    /* compare the new seqnum to the one in the buffer */
+    gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq);
+
+    /* we hit a packet with the same seqnum, notify a duplicate */
+    if (G_UNLIKELY (gap == 0))
+      goto duplicate;
+
+    /* seqnum > qseq, we can stop looking */
+    if (G_LIKELY (gap < 0))
+      break;
+
+    /* if we've found a packet with greater sequence number, cleanup the
+     * event pointer as the packet will be inserted before the event */
+    event = NULL;
+  }
+
+  /* if event is set it means that packets before the event had smaller
+   * sequence number, so we will insert our packet after the event */
+  if (event)
+    list = event;
+
 append:
   queue_do_insert (jbuf, list, (GList *) item);
 
@@ -1033,6 +1034,8 @@
 duplicate:
   {
     GST_DEBUG ("duplicate packet %d found", (gint) seqnum);
+    if (G_LIKELY (head))
+      *head = FALSE;
     return FALSE;
   }
 }
diff --git a/gst/rtpmanager/rtpjitterbuffer.h b/gst/rtpmanager/rtpjitterbuffer.h
index 08ce169..d04b5fd 100644
--- a/gst/rtpmanager/rtpjitterbuffer.h
+++ b/gst/rtpmanager/rtpjitterbuffer.h
@@ -168,8 +168,7 @@
 
 gboolean              rtp_jitter_buffer_insert           (RTPJitterBuffer *jbuf,
                                                           RTPJitterBufferItem *item,
-                                                          gboolean *head, gint *percent,
-                                                          GstClockTime base_time);
+                                                          gboolean *head, gint *percent);
 
 void                  rtp_jitter_buffer_disable_buffering (RTPJitterBuffer *jbuf, gboolean disabled);
 
@@ -190,4 +189,7 @@
                                                           guint64 *timestamp, guint32 *clock_rate,
                                                           guint64 *last_rtptime);
 
+GstClockTime          rtp_jitter_buffer_calculate_pts    (RTPJitterBuffer * jbuf, GstClockTime dts,
+                                                          guint32 rtptime, GstClockTime base_time);
+
 #endif /* __RTP_JITTER_BUFFER_H__ */
diff --git a/gst/rtpmanager/rtpsession.c b/gst/rtpmanager/rtpsession.c
index cf12127..7db89e0 100644
--- a/gst/rtpmanager/rtpsession.c
+++ b/gst/rtpmanager/rtpsession.c
@@ -3263,7 +3263,6 @@
 typedef struct
 {
   RTPSource *source;
-  gboolean is_bye;
   GstBuffer *buffer;
 } ReportOutput;
 
@@ -3874,7 +3873,6 @@
 generate_rtcp (const gchar * key, RTPSource * source, ReportData * data)
 {
   RTPSession *sess = data->sess;
-  gboolean is_bye = FALSE;
   ReportOutput *output;
 
   /* only generate RTCP for active internal sources */
@@ -3893,7 +3891,6 @@
   if (source->marked_bye) {
     /* send BYE */
     make_source_bye (sess, source, data);
-    is_bye = TRUE;
   } else if (!data->is_early) {
     /* loop over all known sources and add report blocks. If we are early, we
      * just make a minimal RTCP packet and skip this step */
@@ -3918,7 +3915,6 @@
 
   output = g_slice_new (ReportOutput);
   output->source = g_object_ref (source);
-  output->is_bye = is_bye;
   output->buffer = data->rtcp;
   /* queue the RTCP packet to push later */
   g_queue_push_tail (&data->output, output);
@@ -4102,7 +4098,7 @@
       GST_DEBUG ("%p, sending RTCP packet, avg size %u, %u", &sess->stats,
           sess->stats.avg_rtcp_packet_size, packet_size);
       result =
-          sess->callbacks.send_rtcp (sess, source, buffer, output->is_bye,
+          sess->callbacks.send_rtcp (sess, source, buffer,
           sess->send_rtcp_user_data);
 
       RTP_SESSION_LOCK (sess);
diff --git a/gst/rtpmanager/rtpsession.h b/gst/rtpmanager/rtpsession.h
index 9fa9327..c25981a 100644
--- a/gst/rtpmanager/rtpsession.h
+++ b/gst/rtpmanager/rtpsession.h
@@ -71,7 +71,6 @@
  * @sess: an #RTPSession
  * @src: the #RTPSource
  * @buffer: the RTCP buffer ready for sending
- * @eos: if an EOS event should be pushed
  * @user_data: user data specified when registering
  *
  * This callback will be called when @sess has @buffer ready for sending to
@@ -80,7 +79,7 @@
  * Returns: a #GstFlowReturn.
  */
 typedef GstFlowReturn (*RTPSessionSendRTCP) (RTPSession *sess, RTPSource *src, GstBuffer *buffer,
-    gboolean eos, gpointer user_data);
+    gpointer user_data);
 
 /**
  * RTPSessionSyncRTCP:
diff --git a/gst/rtsp/gstrtspsrc.c b/gst/rtsp/gstrtspsrc.c
index 2880ffc..1393fed 100644
--- a/gst/rtsp/gstrtspsrc.c
+++ b/gst/rtsp/gstrtspsrc.c
@@ -1339,7 +1339,10 @@
 static gint
 find_stream_by_channel (GstRTSPStream * stream, gint * channel)
 {
-  if (stream->channel[0] == *channel || stream->channel[1] == *channel)
+  /* ignore unconfigured channels here (e.g., those that
+   * were explicitly skipped during SETUP) */
+  if ((stream->channelpad[0] != NULL) &&
+      (stream->channel[0] == *channel || stream->channel[1] == *channel))
     return 0;
 
   return -1;
@@ -5671,7 +5674,6 @@
           src->conninfo.url->transports = transports;
 
         src->need_redirect = TRUE;
-        src->state = GST_RTSP_STATE_INIT;
         res = GST_RTSP_OK;
         break;
       }
diff --git a/gst/wavparse/gstwavparse.c b/gst/wavparse/gstwavparse.c
index 9ee11fc..bafd4a7 100644
--- a/gst/wavparse/gstwavparse.c
+++ b/gst/wavparse/gstwavparse.c
@@ -2445,7 +2445,8 @@
     {
       GstClockTime dur;
 
-      gst_adapter_clear (wav->adapter);
+      if (wav->adapter)
+        gst_adapter_clear (wav->adapter);
       wav->discont = TRUE;
       dur = wav->segment.duration;
       gst_segment_init (&wav->segment, wav->segment.format);
diff --git a/po/af.gmo b/po/af.gmo
index a7b835c..ce594a8 100644
--- a/po/af.gmo
+++ b/po/af.gmo
Binary files differ
diff --git a/po/af.po b/po/af.po
index 4bf5e81..753621a 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -34,9 +34,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/az.gmo b/po/az.gmo
index b406885..4fd99af 100644
--- a/po/az.gmo
+++ b/po/az.gmo
Binary files differ
diff --git a/po/az.po b/po/az.po
index 53feac2..d47d37c 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/bg.gmo b/po/bg.gmo
index 3895686..73d4f3d 100644
--- a/po/bg.gmo
+++ b/po/bg.gmo
Binary files differ
diff --git a/po/bg.po b/po/bg.po
index 8de6f71..089c0a8 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr "Не е зададен адрес."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Сървърът не поддържа търсене."
 
diff --git a/po/ca.gmo b/po/ca.gmo
index cf0827d..e18f9ac 100644
--- a/po/ca.gmo
+++ b/po/ca.gmo
Binary files differ
diff --git a/po/ca.po b/po/ca.po
index 45b9874..e4a2e86 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "No s'ha indicat cap URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "El servidor no ademet les cerques."
 
diff --git a/po/cs.gmo b/po/cs.gmo
index 675a7cc..e99574a 100644
--- a/po/cs.gmo
+++ b/po/cs.gmo
Binary files differ
diff --git a/po/cs.po b/po/cs.po
index a3e2fb7..c9461ce 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "Není nastavena žádná adresa URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Server nepodporuje přeskakování."
 
diff --git a/po/da.gmo b/po/da.gmo
index d3bd71f..32ae345 100644
--- a/po/da.gmo
+++ b/po/da.gmo
Binary files differ
diff --git a/po/da.po b/po/da.po
index 775e570..07012d8 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -37,9 +37,6 @@
 msgid "No URL set."
 msgstr "Ingen adresse angivet."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Server understøtter ikke søgning."
 
diff --git a/po/de.gmo b/po/de.gmo
index d47ec68..7e1f6e6 100644
--- a/po/de.gmo
+++ b/po/de.gmo
Binary files differ
diff --git a/po/de.po b/po/de.po
index 38f9139..db1a003 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -42,9 +42,6 @@
 msgid "No URL set."
 msgstr "Keine Adresse festgelegt."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Suchlauf wird nicht vom Server unterstützt."
 
diff --git a/po/el.gmo b/po/el.gmo
index 9e81419..7cf7444 100644
--- a/po/el.gmo
+++ b/po/el.gmo
Binary files differ
diff --git a/po/el.po b/po/el.po
index 0697fe3..e1c35e7 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -37,9 +37,6 @@
 msgid "No URL set."
 msgstr "Δεν ορίσθηκε URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Ο διακομιστής δεν υποστηρίζει αναζήτηση."
 
diff --git a/po/en_GB.gmo b/po/en_GB.gmo
index ce188b3..6b5ace7 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 667db3d..7700680 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -33,9 +33,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 #, fuzzy
 msgid "Server does not support seeking."
 msgstr "Your oss device could not be probed correctly"
diff --git a/po/eo.gmo b/po/eo.gmo
index 18e17e8..f0a4e8c 100644
--- a/po/eo.gmo
+++ b/po/eo.gmo
Binary files differ
diff --git a/po/eo.po b/po/eo.po
index e413a5c..518f5e0 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -34,9 +34,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/es.gmo b/po/es.gmo
index 6af26ec..b3f8751 100644
--- a/po/es.gmo
+++ b/po/es.gmo
Binary files differ
diff --git a/po/es.po b/po/es.po
index 434f133..5ae8a5f 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr "No existe un URL establecido."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "El servidor no soporta la búsqueda."
 
diff --git a/po/eu.gmo b/po/eu.gmo
index 607e6ce..1743e99 100644
--- a/po/eu.gmo
+++ b/po/eu.gmo
Binary files differ
diff --git a/po/eu.po b/po/eu.po
index b8920ae..22fe2f3 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/fi.gmo b/po/fi.gmo
index 358da35..7f60678 100644
--- a/po/fi.gmo
+++ b/po/fi.gmo
Binary files differ
diff --git a/po/fi.po b/po/fi.po
index 84e5291..fb444b8 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "Ei URL:ää asetettuna."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Pavelin ei tue kelausta."
 
diff --git a/po/fr.gmo b/po/fr.gmo
index 5f55a27..6abb7ba 100644
--- a/po/fr.gmo
+++ b/po/fr.gmo
Binary files differ
diff --git a/po/fr.po b/po/fr.po
index 433918e..fd653d7 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "Aucun URL défini."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Le serveur ne gère pas la recherche."
 
diff --git a/po/gl.gmo b/po/gl.gmo
index a1535f6..402b9ea 100644
--- a/po/gl.gmo
+++ b/po/gl.gmo
Binary files differ
diff --git a/po/gl.po b/po/gl.po
index 32f6f88..d11ca77 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "No existe un URL estabelecido."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "O servidor non admite a busca."
 
diff --git a/po/gst-plugins-good-1.0.pot b/po/gst-plugins-good-1.0.pot
index fc745eb..32907ee 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.10.2\n"
+"Project-Id-Version: gst-plugins-good 1.10.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -41,32 +41,28 @@
 msgid "No URL set."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1048
-msgid "Corrupted HTTP response."
-msgstr ""
-
-#: ext/soup/gstsouphttpsrc.c:1261
+#: ext/soup/gstsouphttpsrc.c:1249
 msgid "Server does not support seeking."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1315
+#: ext/soup/gstsouphttpsrc.c:1303
 msgid "Could not resolve server name."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1321
+#: ext/soup/gstsouphttpsrc.c:1309
 msgid "Could not establish connection to server."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1326
+#: ext/soup/gstsouphttpsrc.c:1314
 msgid "Secure connection setup failed."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1334
+#: ext/soup/gstsouphttpsrc.c:1322
 msgid ""
 "A network error occurred, or the server closed the connection unexpectedly."
 msgstr ""
 
-#: ext/soup/gstsouphttpsrc.c:1341
+#: ext/soup/gstsouphttpsrc.c:1329
 msgid "Server sent bad data."
 msgstr ""
 
@@ -74,50 +70,50 @@
 msgid "No or invalid input audio, AVI stream will be corrupt."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:666 gst/isomp4/qtdemux.c:670
+#: gst/isomp4/qtdemux.c:669 gst/isomp4/qtdemux.c:673
 msgid "This file contains no playable streams."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:716 gst/isomp4/qtdemux.c:6211 gst/isomp4/qtdemux.c:6278
-#: gst/isomp4/qtdemux.c:6567
+#: gst/isomp4/qtdemux.c:719 gst/isomp4/qtdemux.c:6246 gst/isomp4/qtdemux.c:6313
+#: gst/isomp4/qtdemux.c:6612
 msgid "This file is invalid and cannot be played."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:2740
+#: gst/isomp4/qtdemux.c:2750
 msgid "Cannot play stream because it is encrypted with PlayReady DRM."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:3857 gst/isomp4/qtdemux.c:7300
-#: gst/isomp4/qtdemux.c:7307 gst/isomp4/qtdemux.c:8141
-#: gst/isomp4/qtdemux.c:8570 gst/isomp4/qtdemux.c:8577
-#: gst/isomp4/qtdemux.c:10942
+#: gst/isomp4/qtdemux.c:3887 gst/isomp4/qtdemux.c:7344
+#: gst/isomp4/qtdemux.c:7351 gst/isomp4/qtdemux.c:8185
+#: gst/isomp4/qtdemux.c:8616 gst/isomp4/qtdemux.c:8623
+#: gst/isomp4/qtdemux.c:11009
 msgid "This file is corrupt and cannot be played."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:4099
+#: gst/isomp4/qtdemux.c:4129
 msgid "Invalid atom size."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:4177
+#: gst/isomp4/qtdemux.c:4207
 msgid "This file is incomplete and cannot be played."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:9551
+#: gst/isomp4/qtdemux.c:9611
 msgid "The video in this file might not play correctly."
 msgstr ""
 
-#: gst/isomp4/qtdemux.c:10983
+#: gst/isomp4/qtdemux.c:11050
 #, c-format
 msgid "This file contains too many streams. Only playing first %d"
 msgstr ""
 
-#: gst/rtsp/gstrtspsrc.c:6435
+#: gst/rtsp/gstrtspsrc.c:6437
 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:6440
+#: gst/rtsp/gstrtspsrc.c:6442
 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 01d2ce7..1b7041a 100644
--- a/po/hr.gmo
+++ b/po/hr.gmo
Binary files differ
diff --git a/po/hr.po b/po/hr.po
index a45fd35..06801f3 100644
--- a/po/hr.po
+++ b/po/hr.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good-1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\n"
 "PO-Revision-Date: 2016-11-19 10:22-0800\n"
 "Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
@@ -37,9 +37,6 @@
 msgid "No URL set."
 msgstr "URL adresa nije imenovana."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Poslužitelj ne podržava traženje."
 
diff --git a/po/hu.gmo b/po/hu.gmo
index 86ae899..c1d1ff4 100644
--- a/po/hu.gmo
+++ b/po/hu.gmo
Binary files differ
diff --git a/po/hu.po b/po/hu.po
index fe4e21b..a3a8117 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -39,9 +39,6 @@
 msgid "No URL set."
 msgstr "Nincs beállítva URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "A kiszolgáló nem támogatja a tekerést."
 
diff --git a/po/id.gmo b/po/id.gmo
index c74bd1e..57bf739 100644
--- a/po/id.gmo
+++ b/po/id.gmo
Binary files differ
diff --git a/po/id.po b/po/id.po
index 033f7c2..524d07a 100644
--- a/po/id.po
+++ b/po/id.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\n"
 "PO-Revision-Date: 2016-11-10 22:06+0700\n"
 "Last-Translator: Andhika Padmawan <andhika.padmawan@gmail.com>\n"
 "Language-Team: Indonesian <translation-team-id@lists.sourceforge.net>\n"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "Tak ada URL yang ditentukan."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Server tidak mendukung pencarian."
 
diff --git a/po/it.gmo b/po/it.gmo
index aa0ca2c..5380380 100644
--- a/po/it.gmo
+++ b/po/it.gmo
Binary files differ
diff --git a/po/it.po b/po/it.po
index 7bf414c..5ebb8c0 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -33,9 +33,6 @@
 msgid "No URL set."
 msgstr "Nessun URL impostato."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Il server non supporta il posizionamento."
 
diff --git a/po/ja.gmo b/po/ja.gmo
index 175fb09..1d72518 100644
--- a/po/ja.gmo
+++ b/po/ja.gmo
Binary files differ
diff --git a/po/ja.po b/po/ja.po
index e119169..b51d128 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "URLが指定されていません。"
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "サーバーはシークをサポートしていません。"
 
diff --git a/po/lt.gmo b/po/lt.gmo
index 3c88cc9..95bca10 100644
--- a/po/lt.gmo
+++ b/po/lt.gmo
Binary files differ
diff --git a/po/lt.po b/po/lt.po
index 9ba677d..d7ab943 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/lv.gmo b/po/lv.gmo
index 318f339..2a781f7 100644
--- a/po/lv.gmo
+++ b/po/lv.gmo
Binary files differ
diff --git a/po/lv.po b/po/lv.po
index c6b32e4..0875831 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "URL nav iestatīts."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Serveris neatbalsta meklēšanu."
 
diff --git a/po/mt.gmo b/po/mt.gmo
index 18dfa5f..07e5e60 100644
--- a/po/mt.gmo
+++ b/po/mt.gmo
Binary files differ
diff --git a/po/mt.po b/po/mt.po
index 86d7a64..4699cd1 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -33,9 +33,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 #, fuzzy
 msgid "Server does not support seeking."
 msgstr "Appart '%s' ma jagħmilx video capture"
diff --git a/po/nb.gmo b/po/nb.gmo
index a1009c6..8d1a5d2 100644
--- a/po/nb.gmo
+++ b/po/nb.gmo
Binary files differ
diff --git a/po/nb.po b/po/nb.po
index 69be38d..a6ebb36 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr "Ingen URL satt."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Tjener støtter ikke søking."
 
diff --git a/po/nl.gmo b/po/nl.gmo
index 6d79d2f..cd6e8a3 100644
--- a/po/nl.gmo
+++ b/po/nl.gmo
Binary files differ
diff --git a/po/nl.po b/po/nl.po
index 80cd6b7..181198c 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -34,9 +34,6 @@
 msgid "No URL set."
 msgstr "Geen URL ingesteld."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Zoeken wordt door de server niet ondersteund."
 
diff --git a/po/or.gmo b/po/or.gmo
index 260991e..6a8b5fa 100644
--- a/po/or.gmo
+++ b/po/or.gmo
Binary files differ
diff --git a/po/or.po b/po/or.po
index ac1b63b..604ffbc 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 #, fuzzy
 msgid "Server does not support seeking."
 msgstr "\"%s\" ଯନ୍ତ୍ର ଗୋଟିଏ ଅନୁଲିପିକାର ନୁହେଁ."
diff --git a/po/pl.gmo b/po/pl.gmo
index 1eddbe7..3c1014f 100644
--- a/po/pl.gmo
+++ b/po/pl.gmo
Binary files differ
diff --git a/po/pl.po b/po/pl.po
index 5032a8e..4b41bea 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -32,9 +32,6 @@
 msgid "No URL set."
 msgstr "Nie ustawiono URL-a."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Serwer nie obsługuje przewijania."
 
diff --git a/po/pt_BR.gmo b/po/pt_BR.gmo
index e71c839..cbbc1ce 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 8c15ec0..8e6edfc 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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."
@@ -41,9 +41,6 @@
 msgid "No URL set."
 msgstr "Nenhum URL definido."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Nâo há suporte a busca pelo servidor."
 
diff --git a/po/ro.gmo b/po/ro.gmo
index 3040b73..4b5a8a9 100644
--- a/po/ro.gmo
+++ b/po/ro.gmo
Binary files differ
diff --git a/po/ro.po b/po/ro.po
index 95a1600..5360c6b 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/ru.gmo b/po/ru.gmo
index 187e511..b7cf940 100644
--- a/po/ru.gmo
+++ b/po/ru.gmo
Binary files differ
diff --git a/po/ru.po b/po/ru.po
index 560d6f1..27a1807 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "URL не задан."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Сервер не поддерживает поиск."
 
diff --git a/po/sk.gmo b/po/sk.gmo
index 2a3b801..5182636 100644
--- a/po/sk.gmo
+++ b/po/sk.gmo
Binary files differ
diff --git a/po/sk.po b/po/sk.po
index 649aed1..1e31724 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -34,9 +34,6 @@
 msgid "No URL set."
 msgstr "Nebolo nastavené URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Server nepodporuje zmenu pozície"
 
diff --git a/po/sl.gmo b/po/sl.gmo
index 14dc8e1..ec2e14c 100644
--- a/po/sl.gmo
+++ b/po/sl.gmo
Binary files differ
diff --git a/po/sl.po b/po/sl.po
index 5d2ef0d..f7e4231 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "Ni nastavljenega naslova URL."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Strežnik ne podpira iskanja."
 
diff --git a/po/sq.gmo b/po/sq.gmo
index c56b30b..5745b09 100644
--- a/po/sq.gmo
+++ b/po/sq.gmo
Binary files differ
diff --git a/po/sq.po b/po/sq.po
index 352dad2..31ad82e 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -33,9 +33,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 #, fuzzy
 msgid "Server does not support seeking."
 msgstr "Dispozitivi juaj OSS mund të mos provohet korrektësisht"
diff --git a/po/sr.gmo b/po/sr.gmo
index 282931a..6c38c60 100644
--- a/po/sr.gmo
+++ b/po/sr.gmo
Binary files differ
diff --git a/po/sr.po b/po/sr.po
index 6def6ab..cd3263f 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\n"
 "PO-Revision-Date: 2016-03-05 09:52+0200\n"
 "Last-Translator: Мирослав Николић <miroslavnikolic@rocketmail.com>\n"
 "Language-Team: Serbian <(nothing)>\n"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr "Није подешена адреса."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Сервер не подржава позиционирање."
 
diff --git a/po/sv.gmo b/po/sv.gmo
index 9abdab9..6d311af 100644
--- a/po/sv.gmo
+++ b/po/sv.gmo
Binary files differ
diff --git a/po/sv.po b/po/sv.po
index a0a2852..d0eb4f8 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "Ingen URL inställd."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Servern stöder inte sökning/spolning."
 
diff --git a/po/tr.gmo b/po/tr.gmo
index f1fe2b2..1805c98 100644
--- a/po/tr.gmo
+++ b/po/tr.gmo
Binary files differ
diff --git a/po/tr.po b/po/tr.po
index 9f285fe..41e4b3e 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "Hiç bir URL ayarlanmamış."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Sunucu aramayı desteklemiyor."
 
diff --git a/po/uk.gmo b/po/uk.gmo
index ac1a229..b53d746 100644
--- a/po/uk.gmo
+++ b/po/uk.gmo
Binary files differ
diff --git a/po/uk.po b/po/uk.po
index bddcae2..db23f83 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -36,9 +36,6 @@
 msgid "No URL set."
 msgstr "Не вказано адресу"
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Сервером не підтримується позиціювання."
 
diff --git a/po/vi.gmo b/po/vi.gmo
index 191cd70..c785e6c 100644
--- a/po/vi.gmo
+++ b/po/vi.gmo
Binary files differ
diff --git a/po/vi.po b/po/vi.po
index 7c9ca94..c755b44 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -38,9 +38,6 @@
 msgid "No URL set."
 msgstr "Không có URL nào được đặt."
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "Máy phục vụ không hỗ trợ di chuyển vị trí đọc."
 
diff --git a/po/zh_CN.gmo b/po/zh_CN.gmo
index 7c60f29..3233ffe 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 bba9c50..9b2b0a9 100644
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-good 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\n"
 "PO-Revision-Date: 2016-11-02 13:39+0800\n"
 "Last-Translator: Tianze Wang <zwpwjwtz@126.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
@@ -35,9 +35,6 @@
 msgid "No URL set."
 msgstr "未设置URL。"
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr "设备不支持定位。"
 
diff --git a/po/zh_HK.gmo b/po/zh_HK.gmo
index 6acdee4..7029fc6 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 b38d94c..1440355 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -32,9 +32,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/po/zh_TW.gmo b/po/zh_TW.gmo
index 0b33d92..e73cf26 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 dfffb47..cf561fe 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-11-29 15:32+0200\n"
+"POT-Creation-Date: 2017-01-30 15:32+0200\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"
@@ -32,9 +32,6 @@
 msgid "No URL set."
 msgstr ""
 
-msgid "Corrupted HTTP response."
-msgstr ""
-
 msgid "Server does not support seeking."
 msgstr ""
 
diff --git a/sys/v4l2/gstv4l2allocator.c b/sys/v4l2/gstv4l2allocator.c
index 655c2ca..7d9b1ec 100644
--- a/sys/v4l2/gstv4l2allocator.c
+++ b/sys/v4l2/gstv4l2allocator.c
@@ -489,7 +489,7 @@
 
     flags |= breq_flag;
 
-    bcreate.memory = allocator->type;
+    bcreate.memory = memory;
     bcreate.format = allocator->format;
 
     if ((v4l2_ioctl (allocator->video_fd, VIDIOC_CREATE_BUFS, &bcreate) == 0))
diff --git a/tests/check/elements/rtpjitterbuffer.c b/tests/check/elements/rtpjitterbuffer.c
index 1a9d0e6..095fb16 100644
--- a/tests/check/elements/rtpjitterbuffer.c
+++ b/tests/check/elements/rtpjitterbuffer.c
@@ -860,6 +860,148 @@
 
 GST_END_TEST;
 
+GST_START_TEST (test_lost_event_uses_pts)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstEvent *out_event;
+  GstClockTime now;
+  gint jb_latency_ms = 100;
+  gint i;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-lost", TRUE, "latency", jb_latency_ms, NULL);
+
+  /* push the first buffer through */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (0)));
+  fail_unless (gst_harness_crank_single_clock_wait (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* push some buffers arriving in perfect time! */
+  for (i = 1; i <= 2; i++) {
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+
+  /* hop over 1 packets (seqnum 3) and make another one (gap of 1), but due to
+     network delays, this packets is also grossly late */
+  i = 4;
+
+  /* advance the clock to the latest possible time buffer 4 could arrive */
+  now = i * PCMU_BUF_DURATION + jb_latency_ms * GST_MSECOND;
+  gst_harness_set_time (h, now);
+  gst_harness_push (h, generate_test_buffer_full (now, FALSE, i, i * PCMU_RTP_TS_DURATION));
+
+  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+  for (int i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  /* we should now have received a packet-lost-event for buffer 3 */
+  out_event = gst_harness_pull_event (h);
+  verify_lost_event (out_event, 3, 3 * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
+
+  /* and pull out packet 4 */
+  gst_buffer_unref (gst_harness_pull (h));
+
+  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) 1, NULL)));
+
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_lost_event_with_backwards_rtptime)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstEvent *out_event;
+  gint jb_latency_ms = 100;
+  gint i;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element, "do-lost", TRUE, "latency", jb_latency_ms, NULL);
+
+  /* push the first buffer through */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (0)));
+  fail_unless (gst_harness_crank_single_clock_wait (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* push some buffers arriving in perfect time! */
+  for (i = 1; i <= 2; i++) {
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+
+  /*
+     For video using B-frames, an expected sequence
+     could be like this:
+     (I = I-frame, P = P-frame, B = B-frame)
+               ___   ___   ___   ___   ___
+          ... | 3 | | 4 | | 5 | | 6 | | 7 |
+               –––   –––   –––   –––   –––
+    rtptime:   3(I)  5(P)  5(P)  4(B)  6(P)
+arrival(dts):  3     5     5     5     6
+
+     Notice here that packet 6 (the B frame) make
+     the rtptime go backwards.
+
+     But we get this:
+               ___   ___   _ _   ___   ___
+          ... | 3 | | 4 | |   | | 6 | | 7 |
+               –––   –––   - -   –––   –––
+     rtptime:  3(I)  5(P)        4(B)  6(P)
+arrival(dts):  3     5           5     6
+
+  */
+
+  /* seqnum 3 */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (3)));
+  gst_buffer_unref (gst_harness_pull (h));
+
+   /* seqnum 4, arriving at time 5 with rtptime 5 */
+   gst_harness_push (h, generate_test_buffer_full (
+      5 * PCMU_BUF_DURATION, FALSE, 4, 5 * PCMU_RTP_TS_DURATION));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* seqnum 6, arriving at time 5 with rtptime 4,
+     making a gap for missing seqnum 5 */
+  gst_harness_push (h, generate_test_buffer_full (
+      5 * PCMU_BUF_DURATION, FALSE, 6, 4 * PCMU_RTP_TS_DURATION));
+
+  /* seqnum 7, arriving at time 6 with rtptime 6 */
+  gst_harness_push (h, generate_test_buffer_full (
+      6 * PCMU_BUF_DURATION, FALSE, 7, 6 * PCMU_RTP_TS_DURATION));
+
+  /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
+  for (int i = 0; i < 3; i++)
+    gst_event_unref (gst_harness_pull_event (h));
+
+  /* we should now have received a packet-lost-event for seqnum 5,
+     with time 5 and 0 duration */
+  gst_harness_crank_single_clock_wait (h);
+  out_event = gst_harness_pull_event (h);
+  verify_lost_event (out_event, 5, 5 * PCMU_BUF_DURATION, 0);
+
+  /* and pull out 6 and 7 */
+  gst_buffer_unref (gst_harness_pull (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 7,
+              "num-lost", 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");
@@ -1228,110 +1370,6 @@
 
 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_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 <= 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));
-
-  /*
-     The expected sequence of buffers is this:
-     ___   ___   ___   ___   ___
-     | 0 | | 1 | | 2 | | 3 | | 4 |
-     –––   –––   –––   –––   –––
-     0ms  20ms  40ms  60ms  80ms
-
-     But instead we get this:
-     ___   ___   _ _   _ _   ___
-     | 0 | | 1 | |   | |   | | 4 |
-     –––   –––   – –   – –   –––
-     0ms  20ms              41ms
-
-   */
-
-  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)));
-
-  /*
-
-     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
-
-     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
-
-     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);
-}
-
-GST_END_TEST;
-
 GST_START_TEST (test_rtx_packet_delay)
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
@@ -1365,9 +1403,10 @@
    * the estimate for 2 could be refined now to 20ms. also packet 2, 3 and 4
    * are exceeding the max allowed reorder distance and should request a
    * retransmission right away */
+  gst_harness_set_time (h, 1 * PCMU_BUF_DURATION);
   fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer_full (20 * GST_MSECOND, TRUE, 8,
-              8 * PCMU_RTP_TS_DURATION)));
+      gst_harness_push (h, generate_test_buffer_full (1 * PCMU_BUF_DURATION, TRUE, 8,
+              1 * PCMU_RTP_TS_DURATION)));
 
   /* drop reconfigure event */
   gst_event_unref (gst_harness_pull_upstream_event (h));
@@ -1377,23 +1416,23 @@
 
   /* 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, 17, PCMU_BUF_DURATION);
+  verify_rtx_event (out_event, 2, 20 * GST_MSECOND, 10, 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, 17, PCMU_BUF_DURATION);
+    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 10, PCMU_BUF_DURATION);
   }
   fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
 
   /* push 9, this should immediately request retransmission of 5 */
   fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer_full (20 * GST_MSECOND, TRUE, 9,
-              9 * PCMU_RTP_TS_DURATION)));
+      gst_harness_push (h, generate_test_buffer_full (1 * PCMU_BUF_DURATION, TRUE, 9,
+              1 * PCMU_RTP_TS_DURATION)));
 
   /* 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, 17, PCMU_BUF_DURATION);
+  verify_rtx_event (out_event, 5, 20 * GST_MSECOND, 10, PCMU_BUF_DURATION);
 
   /* wait for timeout for rtx 6 -> 7 */
   gst_test_clock_set_time_and_process (testclock, 60 * GST_MSECOND);
@@ -1401,7 +1440,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, 17, PCMU_BUF_DURATION);
+    verify_rtx_event (out_event, i, 20 * GST_MSECOND, 10, PCMU_BUF_DURATION);
   }
 
   /* churn through 7 sync_times until the new buffer gets pushed out */
@@ -1644,6 +1683,11 @@
   fail_unless_equals_int (6, get_rtp_seq_num (buffer));
   gst_buffer_unref (buffer);
 
+  /* due to the advance in time, we will now also have sent
+     an rtx-request for 7 */
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      7, 7 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
   /* 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",
@@ -1651,7 +1695,7 @@
               "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-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)));
@@ -1667,7 +1711,7 @@
               "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-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 - last_rtx_request),
@@ -2069,6 +2113,203 @@
 
 GST_END_TEST;
 
+GST_START_TEST (test_rtx_same_delay_and_retry_timeout)
+{
+  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 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", 3, "rtx-delay", 20, "rtx-retry-timeout", 20, 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, 20, PCMU_BUF_DURATION);
+  /* first rtx for seqnum 6 should arrive at 140ms */
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 140 * GST_MSECOND);
+
+  /* verify we have pulled out all rtx-events */
+  fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
+
+  /* now crank to get the second attempt at seqnum 6 */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      6, 6 * PCMU_BUF_DURATION, 40, PCMU_BUF_DURATION);
+  /* second rtx for seqnum 6 should arrive at 140 + 20ms */
+  last_rtx_request = gst_clock_get_time (GST_CLOCK (testclock));
+  fail_unless_equals_int64 (last_rtx_request, 160 * GST_MSECOND);
+
+  /* verify we have pulled out all rtx-events */
+  fail_unless_equals_int (0, gst_harness_upstream_events_in_queue (h));
+
+  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,
+              "rtx-count", G_TYPE_UINT64, (guint64) 2, NULL)));
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+
+GST_START_TEST (test_rtx_with_backwards_rtptime)
+{
+  GstHarness *h = gst_harness_new ("rtpjitterbuffer");
+  GstEvent *event;
+  gint jb_latency_ms = 40;
+  gint i;
+
+  gst_harness_set_src_caps (h, generate_caps ());
+  g_object_set (h->element,
+      "do-retransmission", TRUE,
+      "latency", jb_latency_ms,
+      NULL);
+
+  /* push the first buffer through */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (0)));
+  fail_unless (gst_harness_crank_single_clock_wait (h));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* push some buffers arriving in perfect time! */
+  for (i = 1; i <= 2; i++) {
+    fail_unless_equals_int (GST_FLOW_OK,
+        gst_harness_push (h, generate_test_buffer (i)));
+    gst_buffer_unref (gst_harness_pull (h));
+  }
+
+  /*
+     For video using B-frames, an expected sequence
+     could be like this:
+     (I = I-frame, P = P-frame, B = B-frame)
+               ___   ___   ___
+          ... | 3 | | 4 | | 5 |
+               –––   –––   –––
+    rtptime:   3(I)  5(P)  4(B)
+arrival(dts):  3     5     5
+
+     Notice here that packet 5 (the B frame) make
+     the rtptime go backwards.
+  */
+
+  /* seqnum 3, arriving at time 3 with rtptime 3 */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (3)));
+  gst_buffer_unref (gst_harness_pull (h));
+
+   /* seqnum 4, arriving at time 5 with rtptime 5 */
+   gst_harness_push (h, generate_test_buffer_full (
+      5 * PCMU_BUF_DURATION, FALSE, 4, 5 * PCMU_RTP_TS_DURATION));
+  gst_buffer_unref (gst_harness_pull (h));
+
+  /* seqnum 5, arriving at time 5 with rtptime 4 */
+  gst_harness_push (h, generate_test_buffer_full (
+      5 * PCMU_BUF_DURATION, FALSE, 5, 4 * PCMU_RTP_TS_DURATION));
+
+  /* drop reconfigure event */
+  gst_event_unref (gst_harness_pull_upstream_event (h));
+
+  /* crank to time-out the rtx-request for seqnum 6, the point here
+     being that the backwards rtptime did not mess up the timeout for
+     the rtx event */
+  gst_harness_crank_single_clock_wait (h);
+  event = gst_harness_pull_upstream_event (h);
+  verify_rtx_event (event, 6, 5 * PCMU_BUF_DURATION + 15 * GST_MSECOND,
+      17, 35 * GST_MSECOND);
+
+  fail_unless (verify_jb_stats (h->element,
+          gst_structure_new ("application/x-rtp-jitterbuffer-stats",
+              "num-pushed", G_TYPE_UINT64, (guint64) 6,
+              "rtx-count", G_TYPE_UINT64, (guint64) 1,
+              "num-lost", G_TYPE_UINT64, (guint64) 0, NULL)));
+
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_rtx_timer_reuse)
+{
+  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;
+
+  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));
+
+  /* crank to timeout the only rtx-request, and the timer will
+   * now reschedule as a lost-timer internally */
+  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);
+
+  /* but now buffer 6 arrives, and this should now reuse the lost-timer
+   * for 6, as an expected-timer for 7 */
+  fail_unless_equals_int (GST_FLOW_OK,
+      gst_harness_push (h, generate_test_buffer (6)));
+
+  /* now crank to timeout the expected-timer for 7 and verify */
+  gst_harness_crank_single_clock_wait (h);
+  verify_rtx_event (gst_harness_pull_upstream_event (h),
+      7, 7 * PCMU_BUF_DURATION, 10, PCMU_BUF_DURATION);
+
+  gst_object_unref (testclock);
+  gst_harness_teardown (h);
+}
+
+GST_END_TEST;
+
 GST_START_TEST (test_gap_exceeds_latency)
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
@@ -2257,13 +2498,12 @@
 
 GST_END_TEST;
 
-GST_START_TEST (test_dts_gap_larger_than_latency)
+GST_START_TEST (test_gap_larger_than_latency)
 {
   GstHarness *h = gst_harness_new ("rtpjitterbuffer");
   GstTestClock *testclock;
   GstEvent *out_event;
   gint jb_latency_ms = 100;
-  GstClockTime dts_after_gap = (jb_latency_ms + 1) * GST_MSECOND;
 
   gst_harness_set_src_caps (h, generate_caps ());
   testclock = gst_harness_get_testclock (h);
@@ -2275,26 +2515,34 @@
   fail_unless (gst_harness_crank_single_clock_wait (h));
   gst_buffer_unref (gst_harness_pull (h));
 
-  /* Push packet with DTS larger than latency */
+  /* we have 100ms latency, so drop 6 packets (120ms) */
+  gst_harness_set_time (h, 7 * PCMU_BUF_DURATION);
   fail_unless_equals_int (GST_FLOW_OK,
-      gst_harness_push (h, generate_test_buffer_full (dts_after_gap,
-              TRUE, 5, 5 * PCMU_RTP_TS_DURATION)));
+      gst_harness_push (h, generate_test_buffer (7)));
 
   /* drop GstEventStreamStart & GstEventCaps & GstEventSegment */
   for (int i = 0; i < 3; i++)
     gst_event_unref (gst_harness_pull_event (h));
 
-  /* Time out and verify lost events */
-  for (gint i = 1; i < 5; i++) {
-    GstClockTime dur = dts_after_gap / 5;
+  /* Packet 1 and 2 are already lost at this point */
+  for (gint i = 1; i <= 2; i++) {
+    out_event = gst_harness_pull_event (h);
+    verify_lost_event (out_event, i, i * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
+  }
+
+  /* Packets 3-6 have to be timed out */
+  for (gint i = 3; i <= 6; i++) {
     fail_unless (gst_harness_crank_single_clock_wait (h));
     out_event = gst_harness_pull_event (h);
-    verify_lost_event (out_event, i, i * dur, dur);
+    verify_lost_event (out_event, i, i * PCMU_BUF_DURATION, PCMU_BUF_DURATION);
   }
 
+  /* and finally pull out buffer 7 */
+  gst_buffer_unref (gst_harness_pull (h));
+
   fail_unless (verify_jb_stats (h->element,
           gst_structure_new ("application/x-rtp-jitterbuffer-stats",
-              "num-lost", G_TYPE_UINT64, (guint64) 4, NULL)));
+              "num-lost", G_TYPE_UINT64, (guint64) 6, NULL)));
 
   gst_object_unref (testclock);
   gst_harness_teardown (h);
@@ -2487,6 +2735,9 @@
   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_lost_event_uses_pts);
+  tcase_add_test (tc_chain, test_lost_event_with_backwards_rtptime);
+
   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);
@@ -2496,7 +2747,6 @@
 
   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);
@@ -2506,10 +2756,13 @@
       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_rtx_same_delay_and_retry_timeout);
+  tcase_add_test (tc_chain, test_rtx_with_backwards_rtptime);
+  tcase_add_test (tc_chain, test_rtx_timer_reuse);
 
   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);
+  tcase_add_test (tc_chain, test_gap_larger_than_latency);
   tcase_add_test (tc_chain, test_push_big_gap);
 
   tcase_add_loop_test (tc_chain,
diff --git a/win32/common/config.h b/win32/common/config.h
index 2c188eb..a4d0f3e 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-11-29"
+#define GST_PACKAGE_RELEASE_DATETIME "2017-01-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.10.2"
+#define PACKAGE_STRING "GStreamer Good Plug-ins 1.10.3"
 
 /* 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.10.2"
+#define PACKAGE_VERSION "1.10.3"
 
 /* directory where plugins are located */
 #ifdef _DEBUG
@@ -445,7 +445,7 @@
 #undef TARGET_CPU
 
 /* Version number of package */
-#define VERSION "1.10.2"
+#define VERSION "1.10.3"
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
