diff --git a/ChangeLog b/ChangeLog
index 0add868..52b3f65 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,9 +1,444 @@
-=== 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:34:42 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* po/fr.po:
+	* po/ky.po:
+	* po/nb.po:
+	* po/sr.po:
+	* po/sv.po:
+	  po: Update translations
+
+2017-01-30 11:17:53 +0100  Nicola Murino <nicola.murino@gmail.com>
+
+	* ext/opencv/gstmotioncells.cpp:
+	  motioncells: fix mingw build
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777930
+
+2017-01-26 15:35:11 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/applemedia/glcontexthelper.c:
+	  applemedia: Fail cleanly instead of crashing if obtaining a GL display failed
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777742
+
+2017-01-20 14:34:10 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/mpegtsdemux/tsdemux.c:
+	  tsdemux: Don't leak pad name and template for Opus
+	  It's set again (the same way) further below, overwriting the previously
+	  allocated memory without freeing.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777533
+
+2017-01-20 07:51:09 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/mxf/mxfdemux.c:
+	  mxfdemux: Set stream tags to NULL after unreffing
+	  Otherwise we might try to unref them a second time a little bit later.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777503
+
+2017-01-24 23:10:19 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/mpegtsdemux/tsdemux.c:
+	  tsdemux: Set caps/tags in the GstStream object before pushing the stream-start event
+	  Otherwise downstream will get a more or less empty GstStream although we
+	  already know a lot about it at this point.
+
+2017-01-23 15:10:40 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* pkgconfig/gstreamer-bad-audio.pc.in:
+	* pkgconfig/gstreamer-bad-base.pc.in:
+	* pkgconfig/gstreamer-bad-video.pc.in:
+	  pkg-config: Directly link the library with -l instead of the .la file
+	  Which might not exist, like on most modern Linux distributions.
+
+2017-01-18 11:05:21 +1100  Jan Schmidt <jan@centricular.com>
+
+	* gst/dvdspu/gstspu-vobsub-render.c:
+	  dvdspu: Handle vob display rect starting on an odd line
+	  DVDs always have subpictures that start on an even Y
+	  coordinate, but gstspu does more generic vobsubs these
+	  days, so handle ones that start on an odd vertical position.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777400
+
+2017-01-11 10:37:34 -0300  Juan Pablo Ugarte <ugarte@endlessm.com>
+
+	* gst-libs/gst/gl/gstglslstage.c:
+	  glslstage: define GL constants if needed instead of using #ifdef
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777144
+
+2017-01-11 10:32:23 -0300  Juan Pablo Ugarte <ugarte@endlessm.com>
+
+	* tests/examples/gtk/glliveshader.c:
+	  gl/examples/gtk: fixed compilation on systems without GL_GEOMETRY_SHADER
+	  https://bugzilla.gnome.org/show_bug.cgi?id=777143
+
+2016-11-18 01:06:51 +1100  Matthew Waters <matthew@centricular.com>
+
+	* gst-libs/gst/gl/gstglbuffer.h:
+	  gl: remove unneeded gst_gl_buffer_alloc from header file
+	  There's no implementation anymore!
+
+2017-01-10 01:00:12 +1100  Matthew Waters <matthew@centricular.com>
+
+	* gst-libs/gst/gl/egl/gstglcontext_egl.c:
+	  glcontext/egl: don't overwrite set GError
+	  Doing so is an error and will cause a glib warning to be printed.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776722
+
+2017-01-05 15:00:21 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamc.c:
+	  androidmedia: Silently skip COLOR_FormatAndroidOpaque when converting to caps
+	  This is special and handled in the decoder when doing rendering to a
+	  surface. Printing a warning for this is just unnecessary noise
+
+2017-01-02 19:55:34 +0530  Arun Raghavan <arun@arunraghavan.net>
+
+	* sys/uvch264/gstuvch264_src.c:
+	  uvch264src: Fix wrong argument order to force-key-unit event
+	  CID 1373421
+
+2016-12-29 18:56:43 +0000  Ursula Maplehurst <ursula@kangatronix.co.uk>
+
+	* sys/androidmedia/Makefile.am:
+	  androidmedia: some files are missing in the release tarball
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776591
+
+2016-12-24 08:42:51 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* tests/check/elements/dash_isoff.c:
+	  dash: Define debug category used in the isoff code for the test too now
+
+2016-12-24 14:31:12 +0900  Seungha Yang <sh.yang@lge.com>
+
+	* ext/dash/gstisoff.c:
+	  dash: Include debug of gstisoff on dashdemux category
+	  Move debug category of gstisoff from default to dashdemux
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776461
+
+2017-01-05 20:34:14 +0000  Tim-Philipp Müller <tim@centricular.com>
+
+	* sys/decklink/meson.build:
+	* sys/meson.build:
+	  meson: build decklink plugin
+
+2016-12-31 20:57:54 +0100  Fabrice Bellet <fabrice@bellet.info>
+
+	* gst/autoconvert/gstautoconvert.c:
+	  autoconvert: fix a reconfigure event leak
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776726
+
+2016-12-19 11:40:28 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/hls/gsthlsdemux-util.c:
+	* ext/hls/gsthlsdemux.c:
+	* ext/hls/gsthlsdemux.h:
+	  hlsdemux: Extract ID3 tags, strip them from the output and provide them as tags
+	  They often don't only contain the PCR information but also other
+	  metadata, like title. Give this information to the pipeline.
+	  Also strip the tags from the stream as we a) already parsed them now and
+	  b) decoders don't like these tags to happen in the middle of the stream
+	  (i.e. the start of each fragment) and tagdemux only can strip them off
+	  the beginning and end.
+
+2016-12-18 19:18:23 +0000  Graham Leggett <minfrin@sharp.fm>
+
+	* gst/mpegtsdemux/mpegtsbase.c:
+	  tsdemux: Don't leak a taglist if a taglist has already been created
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776244
+
+2016-12-16 13:25:58 +0200  Daniel Shahaf <danielsh@apache.org>
+
+	* gst/geometrictransform/gstmirror.h:
+	  mirror: Fix documentation for the mirror mode
+	  Using the wrong enum there causes it to be randomly mixed with the docs
+	  of the other enums.
+	  https://bugs.debian.org/848297
+
+2016-12-15 14:05:09 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* sys/androidmedia/gstamcaudiodec.c:
+	  amcaudiodec: Set "is-adts" to 1 for ADTS AAC
+	  Otherwise it fails to decode.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=740101
+
+2016-12-14 15:35:42 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst-libs/gst/video/gstvideoaggregator.c:
+	  videoaggregator: Remove unlock() if set_info() fails
+	  There is not mutex locked here that needs to be unlocked.
+
+2016-12-15 00:59:45 +1100  Matthew Waters <matthew@centricular.com>
+
+	* gst-libs/gst/gl/gstglwindow.c:
+	* gst-libs/gst/gl/gstglwindow.h:
+	* gst-libs/gst/gl/wayland/gstglwindow_wayland_egl.c:
+	* gst-libs/gst/gl/win32/gstglwindow_win32.c:
+	  gl/window: remove use of main_context_push/pop_thread_default()
+	  No-one's using/depending on it (it would have criticalled and not worked)
+	  and it's causing more problems than it's solving.  Store the GMainContext
+	  in the public struct instead for subclasses to optionally use instead of
+	  relying on the push/pop state to be correct.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775970
+
+2016-12-07 16:51:27 +0800  Haihua Hu <jared.hu@nxp.com>
+
+	* ext/gl/gstgleffects.c:
+	  gl/effects: use non-PBO GLMemory for internal textures
+	  middle textures in gleffects do not need to use GstGLMemoryPBO as they
+	  aren't transfering data to/from the GPU. This will cost too much DMA
+	  memory and cause performance issue. Change the allocator to use non-PBO
+	  GstGLMemory.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=776072
+
+2016-12-06 15:40:38 -0800  Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>
+
+	* sys/dvb/gstdvbsrc.c:
+	  dvbsrc: add delivery system to missing modulation check message
+	  A tuning operation can spawn multiple checks. Being
+	  able to differentiate between them makes debugging
+	  easier.
+
+2016-12-08 12:07:31 -0800  Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>
+
+	* sys/dvb/gstdvbsrc.c:
+	  dvbsrc: fix unconditional use of FEC 2/5
+	  It is not defined for < v5 minor 7
+
+2016-12-12 15:09:36 +0100  Edward Hervey <edward@centricular.com>
+
+	* gst-libs/gst/adaptivedemux/gstadaptivedemux.c:
+	  adaptivedemux: Avoid using unset GError
+	  gst_uri_handler_set_uri() doesn't guarantee the GError will be set
+	  if it returns FALSE.
+
+2016-12-07 10:26:59 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ext/chromaprint/gstchromaprint.c:
+	  chromaprint: Fix compilation with chromaprint 1.4
+	  It takes const int16_t * as argument now, while before it was void *. To
+	  make this work with both versions without #ifdef, we omit the const.
+
+2016-12-06 07:58:25 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* gst/vmnc/vmncdec.c:
+	  vmncdec: Sanity-check rectangle sizes a bit more thorough
+	  The x/y coordinates could already be bigger than the configured
+	  width/height, and adding the rectangle width/height could cause an
+	  overflow.
+
+2016-12-05 15:56:36 -0800  Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>
+
+	* sys/dvb/gstdvbsrc.c:
+	  dvbsrc: fix unconditional use of SYS_DVBC_ANNEX_C
+	  It is not defined for < v5 minor 6
+
+2016-12-05 15:53:10 -0800  Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>
+
+	* sys/dvb/gstdvbsrc.c:
+	  dvbsrc: fix value for DVB-C annex B field in adapter structure
+
+2016-12-05 18:17:30 +0000  Tim-Philipp Müller <tim@centricular.com>
+
+	* gst/rawparse/gstrawvideoparse.c:
+	  rawvideoparse: fix typos in property description
+
+2016-11-28 15:57:33 -0800  Scott D Phillips <scott.d.phillips@intel.com>
+
+	* ext/dtls/gstdtlsagent.c:
+	  dtls: Set openssl's threadid the 1.0.x way
+	  For pre-1.1.x openssl, a callback to set the thread id needs to be
+	  provided to openssl. In 0.9.x the thread id was an unsigned long. In
+	  1.0.x it was expanded to be able to hold a void*. Here we change to use
+	  the 1.0.x API so that the thread id can always hold a GThread*, even on
+	  platforms like msvc x64 where unsigned long is only 32 bits.
+	  All of this is still #ifdef'd out of existence when building with
+	  openssl 1.1.x or later which changed the thread API again, and does not
+	  need a thread id callback.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775292
+
+2016-11-30 10:40:42 +0530  Garima Gaur <garima.g@samsung.com>
+
+	* gst/mpegpsmux/mpegpsmux.c:
+	* tests/examples/directfb/gstdfb.c:
+	  gst: Fix caps leak
+	  https://bugzilla.gnome.org/show_bug.cgi?id=775072
+
+=== release 1.10.2 ===
+
+2016-11-29 16:21:40 +0200  Sebastian Dröge <sebastian@centricular.com>
+
+	* ChangeLog:
+	* NEWS:
+	* RELEASE:
+	* configure.ac:
+	* docs/plugins/gst-plugins-bad-plugins.hierarchy:
+	* docs/plugins/inspect/plugin-accurip.xml:
+	* docs/plugins/inspect/plugin-adpcmdec.xml:
+	* docs/plugins/inspect/plugin-adpcmenc.xml:
+	* docs/plugins/inspect/plugin-aiff.xml:
+	* docs/plugins/inspect/plugin-asfmux.xml:
+	* docs/plugins/inspect/plugin-assrender.xml:
+	* docs/plugins/inspect/plugin-audiofxbad.xml:
+	* docs/plugins/inspect/plugin-audiomixer.xml:
+	* docs/plugins/inspect/plugin-audiovisualizers.xml:
+	* docs/plugins/inspect/plugin-autoconvert.xml:
+	* docs/plugins/inspect/plugin-bayer.xml:
+	* docs/plugins/inspect/plugin-bluez.xml:
+	* docs/plugins/inspect/plugin-bs2b.xml:
+	* docs/plugins/inspect/plugin-bz2.xml:
+	* docs/plugins/inspect/plugin-camerabin.xml:
+	* docs/plugins/inspect/plugin-chromaprint.xml:
+	* docs/plugins/inspect/plugin-coloreffects.xml:
+	* docs/plugins/inspect/plugin-compositor.xml:
+	* docs/plugins/inspect/plugin-curl.xml:
+	* docs/plugins/inspect/plugin-dashdemux.xml:
+	* docs/plugins/inspect/plugin-dataurisrc.xml:
+	* docs/plugins/inspect/plugin-debugutilsbad.xml:
+	* docs/plugins/inspect/plugin-decklink.xml:
+	* docs/plugins/inspect/plugin-dtls.xml:
+	* docs/plugins/inspect/plugin-dtsdec.xml:
+	* docs/plugins/inspect/plugin-dvb.xml:
+	* docs/plugins/inspect/plugin-dvbsuboverlay.xml:
+	* docs/plugins/inspect/plugin-dvdspu.xml:
+	* docs/plugins/inspect/plugin-faac.xml:
+	* docs/plugins/inspect/plugin-faad.xml:
+	* docs/plugins/inspect/plugin-fbdevsink.xml:
+	* docs/plugins/inspect/plugin-festival.xml:
+	* docs/plugins/inspect/plugin-fieldanalysis.xml:
+	* docs/plugins/inspect/plugin-flite.xml:
+	* docs/plugins/inspect/plugin-fluidsynthmidi.xml:
+	* docs/plugins/inspect/plugin-freeverb.xml:
+	* docs/plugins/inspect/plugin-frei0r.xml:
+	* docs/plugins/inspect/plugin-gaudieffects.xml:
+	* docs/plugins/inspect/plugin-gdp.xml:
+	* docs/plugins/inspect/plugin-geometrictransform.xml:
+	* docs/plugins/inspect/plugin-gmedec.xml:
+	* docs/plugins/inspect/plugin-gsm.xml:
+	* docs/plugins/inspect/plugin-gstgtk.xml:
+	* docs/plugins/inspect/plugin-gstsiren.xml:
+	* docs/plugins/inspect/plugin-hls.xml:
+	* docs/plugins/inspect/plugin-id3tag.xml:
+	* docs/plugins/inspect/plugin-inter.xml:
+	* docs/plugins/inspect/plugin-interlace.xml:
+	* docs/plugins/inspect/plugin-ivfparse.xml:
+	* docs/plugins/inspect/plugin-ivtc.xml:
+	* docs/plugins/inspect/plugin-jp2kdecimator.xml:
+	* docs/plugins/inspect/plugin-jpegformat.xml:
+	* docs/plugins/inspect/plugin-kate.xml:
+	* docs/plugins/inspect/plugin-ladspa.xml:
+	* docs/plugins/inspect/plugin-midi.xml:
+	* docs/plugins/inspect/plugin-mimic.xml:
+	* docs/plugins/inspect/plugin-mms.xml:
+	* docs/plugins/inspect/plugin-modplug.xml:
+	* docs/plugins/inspect/plugin-mpeg2enc.xml:
+	* docs/plugins/inspect/plugin-mpegpsdemux.xml:
+	* docs/plugins/inspect/plugin-mpegpsmux.xml:
+	* docs/plugins/inspect/plugin-mpegtsdemux.xml:
+	* docs/plugins/inspect/plugin-mpegtsmux.xml:
+	* docs/plugins/inspect/plugin-mplex.xml:
+	* docs/plugins/inspect/plugin-mxf.xml:
+	* docs/plugins/inspect/plugin-netsim.xml:
+	* docs/plugins/inspect/plugin-ofa.xml:
+	* docs/plugins/inspect/plugin-openal.xml:
+	* docs/plugins/inspect/plugin-opencv.xml:
+	* docs/plugins/inspect/plugin-openexr.xml:
+	* docs/plugins/inspect/plugin-opengl.xml:
+	* docs/plugins/inspect/plugin-openjpeg.xml:
+	* docs/plugins/inspect/plugin-opusparse.xml:
+	* docs/plugins/inspect/plugin-pcapparse.xml:
+	* docs/plugins/inspect/plugin-pnm.xml:
+	* docs/plugins/inspect/plugin-qt.xml:
+	* docs/plugins/inspect/plugin-rawparse.xml:
+	* docs/plugins/inspect/plugin-removesilence.xml:
+	* docs/plugins/inspect/plugin-resindvd.xml:
+	* docs/plugins/inspect/plugin-rfbsrc.xml:
+	* docs/plugins/inspect/plugin-rsvg.xml:
+	* docs/plugins/inspect/plugin-rtmp.xml:
+	* docs/plugins/inspect/plugin-rtponvif.xml:
+	* docs/plugins/inspect/plugin-schro.xml:
+	* docs/plugins/inspect/plugin-sdp.xml:
+	* docs/plugins/inspect/plugin-segmentclip.xml:
+	* docs/plugins/inspect/plugin-shm.xml:
+	* docs/plugins/inspect/plugin-smooth.xml:
+	* docs/plugins/inspect/plugin-smoothstreaming.xml:
+	* docs/plugins/inspect/plugin-sndfile.xml:
+	* docs/plugins/inspect/plugin-soundtouch.xml:
+	* docs/plugins/inspect/plugin-spandsp.xml:
+	* docs/plugins/inspect/plugin-speed.xml:
+	* docs/plugins/inspect/plugin-srtp.xml:
+	* docs/plugins/inspect/plugin-stereo.xml:
+	* docs/plugins/inspect/plugin-subenc.xml:
+	* docs/plugins/inspect/plugin-teletext.xml:
+	* docs/plugins/inspect/plugin-uvch264.xml:
+	* docs/plugins/inspect/plugin-vcdsrc.xml:
+	* docs/plugins/inspect/plugin-videofiltersbad.xml:
+	* docs/plugins/inspect/plugin-videoframe_audiolevel.xml:
+	* docs/plugins/inspect/plugin-videoparsersbad.xml:
+	* docs/plugins/inspect/plugin-videosignal.xml:
+	* docs/plugins/inspect/plugin-vmnc.xml:
+	* docs/plugins/inspect/plugin-voaacenc.xml:
+	* docs/plugins/inspect/plugin-voamrwbenc.xml:
+	* docs/plugins/inspect/plugin-waylandsink.xml:
+	* docs/plugins/inspect/plugin-webp.xml:
+	* docs/plugins/inspect/plugin-webrtcdsp.xml:
+	* docs/plugins/inspect/plugin-wildmidi.xml:
+	* docs/plugins/inspect/plugin-x265.xml:
+	* docs/plugins/inspect/plugin-y4mdec.xml:
+	* docs/plugins/inspect/plugin-yadif.xml:
+	* docs/plugins/inspect/plugin-zbar.xml:
+	* gst-plugins-bad.doap:
+	* win32/common/config.h:
+	  Release 1.10.2
+
+2016-11-29 15:52:17 +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/ky.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:
+	  Update .po files
 
 2016-11-29 14:10:26 +0200  Sebastian Dröge <sebastian@centricular.com>
 
diff --git a/Makefile.in b/Makefile.in
index ed26e37..d5f9bb8 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -207,7 +207,7 @@
 	$(top_srcdir)/common/release.mak \
 	$(top_srcdir)/common/win32.mak ABOUT-NLS AUTHORS COPYING \
 	COPYING.LIB 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 e2b60d1..fd6e44a 100644
--- a/RELEASE
+++ b/RELEASE
@@ -1,7 +1,7 @@
 
-Release notes for GStreamer Bad Plugins 1.10.2
+Release notes for GStreamer Bad 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!
 
 
@@ -60,14 +60,23 @@
 
 Bugs fixed in this release
      
-      * 774624 : GstGL build error due to not finding GstVideo-1.0.gir
-      * 774702 : dashdemux: Fix leak in gst_dash_demux_stream_free
-      * 774851 : glimagesink segfault when specifying GST_GL_WINDOW to something else than x11
-      * 774896 : h264 parser: Off by one read in gst_h264_parse_set_caps()
-      * 775048 : mpegts decoder: Out of bounds read in gst_mpegts_section_new
-      * 775120 : mpegts parser: null pointer deref in _parse_pat
-      * 775127 : hls_demux.testSeekUpdateStopPosition : The unit test that was always wrong
-      * 775130 : h264 parser: invalid input causes assert
+      * 740101 : amcaudiodec error: 'first buffer should have OMX_BUFFERFLAG_CODECCONFIG set'
+      * 775072 : memory leak in usage of gst_pad_get_current_caps() API
+      * 775292 : dtls: Set openssl's threadid the 1.0.x way
+      * 775970 : glimagesink: hang? on windows
+      * 776072 : gleffects: found performance downgrade in gstreamer 1.10.0 compared with 1.8.1
+      * 776244 : tsdemux: Taglist leak
+      * 776461 : dash: Include debug of gstisoff on dashdemux category
+      * 776591 : gst-plugins-bad-1.10.2 tarball missing some sys/androidmedia sources
+      * 776722 : gl/egl: don't pass a GError to gst_gl_context_egl_choose_config when trying gles2
+      * 776726 : autoconvert: reconfigure event leak
+      * 777143 : tests/examples/gtk/glliveshader.c fails to build on systems without GL_GEOMETRY_SHADER
+      * 777144 : gst-libs/gst/gl/gstglslstage.c: uses #ifdef GL_* constants instead of defining them
+      * 777400 : dvdspu: fix crash when display_rect.bottom isn't even
+      * 777503 : mxfdemux: use after free in gst_mini_object_unref / gst_tag_list_unref / gst_mxf_demux_update_essence_tracks
+      * 777533 : tsdemux: memory leak in create_pad_for_stream / gst_static_pad_template_get
+      * 777742 : avfvideosrc SEGFAULT when using GLMemory
+      * 777930 : motioncells: fix mingw build
 
 ==== Download ====
 
@@ -104,10 +113,21 @@
         
 Contributors to this release
     
-      * David Evans
+      * Arun Raghavan
+      * Daniel Shahaf
       * Edward Hervey
+      * Fabrice Bellet
+      * Garima Gaur
+      * Graham Leggett
+      * Haihua Hu
+      * Jan Schmidt
+      * Juan Pablo Ugarte
       * Matthew Waters
+      * Nicola Murino
+      * Reynaldo H. Verdejo Pinochet
+      * Scott D Phillips
       * Sebastian Dröge
       * Seungha Yang
       * Tim-Philipp Müller
+      * Ursula Maplehurst
  
\ No newline at end of file
diff --git a/configure b/configure
index b5a3f41..aa1165f 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 Bad Plug-ins 1.10.2.
+# Generated by GNU Autoconf 2.69 for GStreamer Bad 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 Bad Plug-ins'
 PACKAGE_TARNAME='gst-plugins-bad'
-PACKAGE_VERSION='1.10.2'
-PACKAGE_STRING='GStreamer Bad Plug-ins 1.10.2'
+PACKAGE_VERSION='1.10.3'
+PACKAGE_STRING='GStreamer Bad Plug-ins 1.10.3'
 PACKAGE_BUGREPORT='http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer'
 PACKAGE_URL=''
 
@@ -2689,7 +2689,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 Bad Plug-ins 1.10.2 to adapt to many kinds of systems.
+\`configure' configures GStreamer Bad Plug-ins 1.10.3 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -2761,7 +2761,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of GStreamer Bad Plug-ins 1.10.2:";;
+     short | recursive ) echo "Configuration of GStreamer Bad Plug-ins 1.10.3:";;
    esac
   cat <<\_ACEOF
 
@@ -3485,7 +3485,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-GStreamer Bad Plug-ins configure 1.10.2
+GStreamer Bad Plug-ins configure 1.10.3
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -4458,7 +4458,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 Bad Plug-ins $as_me 1.10.2, which was
+It was created by GStreamer Bad Plug-ins $as_me 1.10.3, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -5440,7 +5440,7 @@
 
 # Define the identity of the package.
  PACKAGE='gst-plugins-bad'
- VERSION='1.10.2'
+ VERSION='1.10.3'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -5651,9 +5651,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)
 
 
 
@@ -5664,7 +5664,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
@@ -10508,10 +10508,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
 
 
 
@@ -61312,7 +61312,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by GStreamer Bad Plug-ins $as_me 1.10.2, which was
+This file was extended by GStreamer Bad Plug-ins $as_me 1.10.3, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -61378,7 +61378,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 Bad Plug-ins config.status 1.10.2
+GStreamer Bad 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 f9a3051..8aa0cde 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3,7 +3,7 @@
 dnl initialize autoconf
 dnl when going to/from release please set the nano (fourth number) right !
 dnl releases only do Wall, git and prerelease does Werror too
-AC_INIT([GStreamer Bad Plug-ins],[1.10.2],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-bad])
+AC_INIT([GStreamer Bad Plug-ins],[1.10.3],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-bad])
 
 AG_GST_INIT
 
@@ -51,7 +51,7 @@
 dnl - interfaces added -> increment AGE
 dnl - interfaces removed -> AGE = 0
 dnl sets GST_LT_LDFLAGS
-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/libs/html/api-index-full.html b/docs/libs/html/api-index-full.html
index cf24f01..db77c5d 100644
--- a/docs/libs/html/api-index-full.html
+++ b/docs/libs/html/api-index-full.html
@@ -871,10 +871,6 @@
 </dt>
 <dd></dd>
 <dt>
-<a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-alloc" title="gst_gl_buffer_alloc ()">gst_gl_buffer_alloc</a>, function in <a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html" title="GstGLBuffer">GstGLBuffer</a>
-</dt>
-<dd></dd>
-<dt>
 <a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-allocation-params-new" title="gst_gl_buffer_allocation_params_new ()">gst_gl_buffer_allocation_params_new</a>, function in <a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html" title="GstGLBuffer">GstGLBuffer</a>
 </dt>
 <dd></dd>
diff --git a/docs/libs/html/gst-plugins-bad-libs-1.0.devhelp2 b/docs/libs/html/gst-plugins-bad-libs-1.0.devhelp2
index 7f0e29d..7689379 100644
--- a/docs/libs/html/gst-plugins-bad-libs-1.0.devhelp2
+++ b/docs/libs/html/gst-plugins-bad-libs-1.0.devhelp2
@@ -484,7 +484,6 @@
     <keyword type="struct" name="GstGLBaseMemory" link="gst-plugins-bad-libs-gstglbasememory.html#GstGLBaseMemory"/>
     <keyword type="function" name="gst_gl_buffer_init_once ()" link="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-init-once" since="1.8"/>
     <keyword type="function" name="gst_is_gl_buffer ()" link="gst-plugins-bad-libs-GstGLBuffer.html#gst-is-gl-buffer" since="1.8"/>
-    <keyword type="function" name="gst_gl_buffer_alloc ()" link="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-alloc"/>
     <keyword type="function" name="gst_gl_buffer_allocation_params_new ()" link="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-allocation-params-new" since="1.8"/>
     <keyword type="struct" name="GstGLBuffer" link="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBuffer"/>
     <keyword type="struct" name="struct GstGLBufferAllocationParams" link="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBufferAllocationParams"/>
diff --git a/docs/libs/html/gst-plugins-bad-libs-GstGLBuffer.html b/docs/libs/html/gst-plugins-bad-libs-GstGLBuffer.html
index 55e53d3..b6f8222 100644
--- a/docs/libs/html/gst-plugins-bad-libs-GstGLBuffer.html
+++ b/docs/libs/html/gst-plugins-bad-libs-GstGLBuffer.html
@@ -58,14 +58,6 @@
 </tr>
 <tr>
 <td class="function_type">
-<a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBuffer" title="GstGLBuffer"><span class="returnvalue">GstGLBuffer</span></a> *
-</td>
-<td class="function_name">
-<a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#gst-gl-buffer-alloc" title="gst_gl_buffer_alloc ()">gst_gl_buffer_alloc</a> <span class="c_punctuation">()</span>
-</td>
-</tr>
-<tr>
-<td class="function_type">
 <a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBufferAllocationParams" title="struct GstGLBufferAllocationParams"><span class="returnvalue">GstGLBufferAllocationParams</span></a> *
 </td>
 <td class="function_name">
@@ -169,16 +161,6 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="gst-gl-buffer-alloc"></a><h3>gst_gl_buffer_alloc ()</h3>
-<pre class="programlisting"><a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBuffer" title="GstGLBuffer"><span class="returnvalue">GstGLBuffer</span></a> *
-gst_gl_buffer_alloc (<em class="parameter"><code><a class="link" href="GstGLContext.html" title="GstGLContext"><span class="type">GstGLContext</span></a> *context</code></em>,
-                     <em class="parameter"><code><a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint"><span class="type">guint</span></a> gl_target</code></em>,
-                     <em class="parameter"><code><a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#guint"><span class="type">guint</span></a> gl_usage</code></em>,
-                     <em class="parameter"><code><a href="/usr/share/gtk-doc/html/gstreamer-1.0GstAllocator.html#GstAllocationParams-struct"><span class="type">GstAllocationParams</span></a> *params</code></em>,
-                     <em class="parameter"><code><a href="/usr/share/gtk-doc/html/glibglib-Basic-Types.html#gsize"><span class="type">gsize</span></a> maxsize</code></em>);</pre>
-</div>
-<hr>
-<div class="refsect2">
 <a name="gst-gl-buffer-allocation-params-new"></a><h3>gst_gl_buffer_allocation_params_new ()</h3>
 <pre class="programlisting"><a class="link" href="gst-plugins-bad-libs-GstGLBuffer.html#GstGLBufferAllocationParams" title="struct GstGLBufferAllocationParams"><span class="returnvalue">GstGLBufferAllocationParams</span></a> *
 gst_gl_buffer_allocation_params_new (<em class="parameter"><code><a class="link" href="GstGLContext.html" title="GstGLContext"><span class="type">GstGLContext</span></a> *context</code></em>,
diff --git a/docs/libs/html/index.html b/docs/libs/html/index.html
index 041bcc7..fe04f4f 100644
--- a/docs/libs/html/index.html
+++ b/docs/libs/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 Bad Plugins 1.0 Library Reference Manual</p></th></tr></table></div>
 <div><p class="releaseinfo">
-      for GStreamer Bad Library 1.0 (1.10.2)
+      for GStreamer Bad Library 1.0 (1.10.3)
       <a class="ulink" href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-bad-libs/html/" target="_top">http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-bad-libs/html/</a>.
     </p></div>
 </div>
diff --git a/docs/plugins/gst-plugins-bad-plugins.args b/docs/plugins/gst-plugins-bad-plugins.args
index 25b4ac0..6000fa3 100644
--- a/docs/plugins/gst-plugins-bad-plugins.args
+++ b/docs/plugins/gst-plugins-bad-plugins.args
@@ -72426,7 +72426,7 @@
 <RANGE></RANGE>
 <FLAGS>rw</FLAGS>
 <NICK>Plane offsets</NICK>
-<BLURB>Offsets of the planets in bytes.</BLURB>
+<BLURB>Offsets of the planes in bytes.</BLURB>
 <DEFAULT></DEFAULT>
 </ARG>
 
@@ -72436,7 +72436,7 @@
 <RANGE></RANGE>
 <FLAGS>rw</FLAGS>
 <NICK>Plane strides</NICK>
-<BLURB>Strides of the planets in bytes.</BLURB>
+<BLURB>Strides of the planes in bytes.</BLURB>
 <DEFAULT></DEFAULT>
 </ARG>
 
@@ -72550,3 +72550,23 @@
 <DEFAULT>0</DEFAULT>
 </ARG>
 
+<ARG>
+<NAME>GstVulkanSink::force-aspect-ratio</NAME>
+<TYPE>gboolean</TYPE>
+<RANGE></RANGE>
+<FLAGS>rw</FLAGS>
+<NICK>Force aspect ratio</NICK>
+<BLURB>When enabled, scaling will respect original aspect ratio.</BLURB>
+<DEFAULT>TRUE</DEFAULT>
+</ARG>
+
+<ARG>
+<NAME>GstVulkanSink::pixel-aspect-ratio</NAME>
+<TYPE>GstFraction</TYPE>
+<RANGE></RANGE>
+<FLAGS>rw</FLAGS>
+<NICK>Pixel Aspect Ratio</NICK>
+<BLURB>The pixel aspect ratio of the device.</BLURB>
+<DEFAULT></DEFAULT>
+</ARG>
+
diff --git a/docs/plugins/gst-plugins-bad-plugins.hierarchy b/docs/plugins/gst-plugins-bad-plugins.hierarchy
index 913cd8e..4e1f94a 100644
--- a/docs/plugins/gst-plugins-bad-plugins.hierarchy
+++ b/docs/plugins/gst-plugins-bad-plugins.hierarchy
@@ -99,6 +99,7 @@
               GstGtkSink
             GstInterVideoSink
             GstQtSink
+            GstVulkanSink
             GstWaylandSink
         GstBaseSrc
           GstAvdtpSrc
@@ -247,6 +248,7 @@
             GstVideoDiff
             GstZBar
             GstZebraStripe
+          GstVulkanUpload
           GstWatchdog
           GstYadif
         GstBin
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-audiointerleave.html b/docs/plugins/html/gst-plugins-bad-plugins-audiointerleave.html
index a4194f0..d0aa61b 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-audiointerleave.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-audiointerleave.html
@@ -76,7 +76,7 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
                     <span class="lineart">╰──</span> GstAudioAggregator
                         <span class="lineart">╰──</span> GstAudioInterleave
 </pre>
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-audiomixer.html b/docs/plugins/html/gst-plugins-bad-plugins-audiomixer.html
index ce7e6d8..d2bb41c 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-audiomixer.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-audiomixer.html
@@ -91,7 +91,7 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
                     <span class="lineart">╰──</span> GstAudioAggregator
                         <span class="lineart">╰──</span> GstAudioMixer
                             <span class="lineart">╰──</span> GstLiveAdder
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-coloreffects.html b/docs/plugins/html/gst-plugins-bad-plugins-coloreffects.html
index 0cc39c4..d44f544 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-coloreffects.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-coloreffects.html
@@ -192,7 +192,7 @@
 <hr>
 <div class="refsect2">
 <a name="GstColorEffectsPreset"></a><h3>enum GstColorEffectsPreset</h3>
-<p>How to split the video frame and which side reflect</p>
+<p>The lookup table to use to convert input colors</p>
 <div class="refsect3">
 <a name="GstColorEffectsPreset.members"></a><h4>Members</h4>
 <div class="informaltable"><table class="informaltable" width="100%" border="0">
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-compositor.html b/docs/plugins/html/gst-plugins-bad-plugins-compositor.html
index 47d9e71..3183ec0 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-compositor.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-compositor.html
@@ -74,8 +74,8 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
-                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstVideoAggregator.html#GstVideoAggregator">GstVideoAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
+                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstVideoAggregator.html#GstVideoAggregator-struct">GstVideoAggregator</a>
                         <span class="lineart">╰──</span> GstCompositor
 </pre>
 </div>
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-glmosaic.html b/docs/plugins/html/gst-plugins-bad-plugins-glmosaic.html
index eb8ec85..a8a0b36 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-glmosaic.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-glmosaic.html
@@ -52,8 +52,8 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
-                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstVideoAggregator.html#GstVideoAggregator">GstVideoAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
+                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstVideoAggregator.html#GstVideoAggregator-struct">GstVideoAggregator</a>
                         <span class="lineart">╰──</span> GstGLBaseMixer
                             <span class="lineart">╰──</span> GstGLMixer
                                 <span class="lineart">╰──</span> GstGLMosaic
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-glstereomix.html b/docs/plugins/html/gst-plugins-bad-plugins-glstereomix.html
index e95aa30..3525272 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-glstereomix.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-glstereomix.html
@@ -68,8 +68,8 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
-                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstVideoAggregator.html#GstVideoAggregator">GstVideoAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
+                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstVideoAggregator.html#GstVideoAggregator-struct">GstVideoAggregator</a>
                         <span class="lineart">╰──</span> GstGLBaseMixer
                             <span class="lineart">╰──</span> GstGLMixer
                                 <span class="lineart">╰──</span> GstGLStereoMix
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-glvideomixerelement.html b/docs/plugins/html/gst-plugins-bad-plugins-glvideomixerelement.html
index eb8f613..920ca82 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-glvideomixerelement.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-glvideomixerelement.html
@@ -74,8 +74,8 @@
     <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gobjectgobject-The-Base-Object-Type.html#GInitiallyUnowned">GInitiallyUnowned</a>
         <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstObject.html#GstObject-struct">GstObject</a>
             <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gstreamer-1.0GstElement.html#GstElement-struct">GstElement</a>
-                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstAggregator.html#GstAggregator">GstAggregator</a>
-                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0gst-plugins-bad-libs-GstVideoAggregator.html#GstVideoAggregator">GstVideoAggregator</a>
+                <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstAggregator.html#GstAggregator-struct">GstAggregator</a>
+                    <span class="lineart">╰──</span> <a href="/usr/share/gtk-doc/html/gst-plugins-bad-libs-1.0GstVideoAggregator.html#GstVideoAggregator-struct">GstVideoAggregator</a>
                         <span class="lineart">╰──</span> GstGLBaseMixer
                             <span class="lineart">╰──</span> GstGLMixer
                                 <span class="lineart">╰──</span> GstGLVideoMixer
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-mirror.html b/docs/plugins/html/gst-plugins-bad-plugins-mirror.html
index e5d5bf2..8b06287 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-mirror.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-mirror.html
@@ -191,6 +191,7 @@
 <hr>
 <div class="refsect2">
 <a name="GstMirrorMode"></a><h3>enum GstMirrorMode</h3>
+<p>How to split the video frame and which side reflect</p>
 <div class="refsect3">
 <a name="GstMirrorMode.members"></a><h4>Members</h4>
 <div class="informaltable"><table class="informaltable" width="100%" border="0">
@@ -202,23 +203,31 @@
 <tbody>
 <tr>
 <td class="enum_member_name"><p><a name="GST-MIRROR-MODE-LEFT:CAPS"></a>GST_MIRROR_MODE_LEFT</p></td>
-<td> </td>
-<td> </td>
+<td class="enum_member_description">
+<p>Split horizontally and reflect left into right</p>
+</td>
+<td class="enum_member_annotations"> </td>
 </tr>
 <tr>
 <td class="enum_member_name"><p><a name="GST-MIRROR-MODE-RIGHT:CAPS"></a>GST_MIRROR_MODE_RIGHT</p></td>
-<td> </td>
-<td> </td>
+<td class="enum_member_description">
+<p>Split horizontally and reflect right into left</p>
+</td>
+<td class="enum_member_annotations"> </td>
 </tr>
 <tr>
 <td class="enum_member_name"><p><a name="GST-MIRROR-MODE-TOP:CAPS"></a>GST_MIRROR_MODE_TOP</p></td>
-<td> </td>
-<td> </td>
+<td class="enum_member_description">
+<p>Split horizontally and reflect top into bottom</p>
+</td>
+<td class="enum_member_annotations"> </td>
 </tr>
 <tr>
 <td class="enum_member_name"><p><a name="GST-MIRROR-MODE-BOTTOM:CAPS"></a>GST_MIRROR_MODE_BOTTOM</p></td>
-<td> </td>
-<td> </td>
+<td class="enum_member_description">
+<p>Split horizontally and reflect bottom into top</p>
+</td>
+<td class="enum_member_annotations"> </td>
 </tr>
 </tbody>
 </table></div>
diff --git a/docs/plugins/html/gst-plugins-bad-plugins-plugin-aiff.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-aiff.html
index 40f293f..d079cba 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-aiff.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-aiff.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-bad-plugins-plugin-assrender.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-assrender.html
index a6f05d1..52c008b 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-assrender.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-assrender.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-bad-plugins-plugin-audiomixer.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiomixer.html
index 1379d2b..a404ff4 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiomixer.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiomixer.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-bad-plugins-plugin-audiovisualizers.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiovisualizers.html
index ca95a27..47159d4 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiovisualizers.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-audiovisualizers.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-bad-plugins-plugin-autoconvert.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-autoconvert.html
index c72c95f..15ea1fa 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-autoconvert.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-autoconvert.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-bad-plugins-plugin-bayer.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bayer.html
index 0e83165..9ffb3b4 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-bayer.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bayer.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-bad-plugins-plugin-bs2b.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bs2b.html
index fe7e312..65db619 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-bs2b.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bs2b.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-bad-plugins-plugin-bz2.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bz2.html
index df2fbe0..be431ed 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-bz2.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-bz2.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-bad-plugins-plugin-camerabin.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-camerabin.html
index 294b471..804dbdf 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-camerabin.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-camerabin.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-bad-plugins-plugin-coloreffects.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-coloreffects.html
index ae40196..7c6394c 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-coloreffects.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-coloreffects.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-bad-plugins-plugin-curl.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-curl.html
index a4821ac..4c891d6 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-curl.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-curl.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-bad-plugins-plugin-dataurisrc.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dataurisrc.html
index e4c8b88..e50ba56 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-dataurisrc.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dataurisrc.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-bad-plugins-plugin-debugutilsbad.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-debugutilsbad.html
index dc2416f..6f6a983 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-debugutilsbad.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-debugutilsbad.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-bad-plugins-plugin-dtsdec.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dtsdec.html
index 6ec3488..a1b8bfb 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-dtsdec.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dtsdec.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-bad-plugins-plugin-dvb.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvb.html
index 466d2ed..87725da 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvb.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvb.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-bad-plugins-plugin-dvdspu.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvdspu.html
index 3da2ad0..6431525 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvdspu.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-dvdspu.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-bad-plugins-plugin-faac.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-faac.html
index 402ba12..77f6ac1 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-faac.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-faac.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-bad-plugins-plugin-faad.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-faad.html
index f721e21..1ae534a 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-faad.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-faad.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-bad-plugins-plugin-festival.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-festival.html
index a4f270c..2701ba4 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-festival.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-festival.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-bad-plugins-plugin-gaudieffects.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-gaudieffects.html
index 433658a..da46579 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-gaudieffects.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-gaudieffects.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-bad-plugins-plugin-geometrictransform.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-geometrictransform.html
index 29492c5..0b0acad 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-geometrictransform.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-geometrictransform.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-bad-plugins-plugin-gsm.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-gsm.html
index abac403..e7bb6d8 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-gsm.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-gsm.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-bad-plugins-plugin-jpegformat.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-jpegformat.html
index 35298ce..a03687c 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-jpegformat.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-jpegformat.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-bad-plugins-plugin-mimic.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mimic.html
index f0ee560..0592588 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mimic.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mimic.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-bad-plugins-plugin-mms.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mms.html
index 7a3d23a..3627357 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mms.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mms.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-bad-plugins-plugin-modplug.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-modplug.html
index d6f9439..a119ed7 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-modplug.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-modplug.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-bad-plugins-plugin-mpeg2enc.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpeg2enc.html
index 3e5d15e..f786be7 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpeg2enc.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpeg2enc.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-bad-plugins-plugin-mpegpsmux.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegpsmux.html
index be084b3..cd5ed85 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegpsmux.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegpsmux.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-bad-plugins-plugin-mpegtsmux.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegtsmux.html
index 6e171cd..95211ed 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegtsmux.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mpegtsmux.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-bad-plugins-plugin-mplex.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mplex.html
index 85755a3..528e673 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-mplex.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-mplex.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-bad-plugins-plugin-ofa.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-ofa.html
index 902b5c0..85983de 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-ofa.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-ofa.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-bad-plugins-plugin-openal.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-openal.html
index f2a0486..6bf2090 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-openal.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-openal.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-bad-plugins-plugin-opencv.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-opencv.html
index 4cbf28d..57a99c6 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-opencv.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-opencv.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-bad-plugins-plugin-opengl.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-opengl.html
index f9628ef..3f70e2b 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-opengl.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-opengl.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-bad-plugins-plugin-pcapparse.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-pcapparse.html
index 53ac02d..69e5b98 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-pcapparse.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-pcapparse.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-bad-plugins-plugin-rawparse.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rawparse.html
index c72d99a..9f8f0e0 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-rawparse.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rawparse.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-bad-plugins-plugin-rfbsrc.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rfbsrc.html
index f757f71..2573b17 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-rfbsrc.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rfbsrc.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-bad-plugins-plugin-rtmp.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rtmp.html
index 13c3c47..b8c7427 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-rtmp.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-rtmp.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-bad-plugins-plugin-sdp.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-sdp.html
index e2f5228..dc4ed7d 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-sdp.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-sdp.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-bad-plugins-plugin-shm.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-shm.html
index bebac8f..4e85c9d 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-shm.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-shm.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-bad-plugins-plugin-soundtouch.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-soundtouch.html
index 958cd75..8da2796 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-soundtouch.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-soundtouch.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-bad-plugins-plugin-speed.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-speed.html
index 2aa3d39..0d50ae4 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-speed.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-speed.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-bad-plugins-plugin-voaacenc.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-voaacenc.html
index ff86a16..8829e3c 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-voaacenc.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-voaacenc.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-bad-plugins-plugin-voamrwbenc.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-voamrwbenc.html
index dff87f4..de56609 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-voamrwbenc.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-voamrwbenc.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-bad-plugins-plugin-webrtcdsp.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-webrtcdsp.html
index bfe6b0f..088c331 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-webrtcdsp.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-webrtcdsp.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-bad-plugins-plugin-zbar.html b/docs/plugins/html/gst-plugins-bad-plugins-plugin-zbar.html
index 528dd31..e92d1a9 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-plugin-zbar.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-plugin-zbar.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-bad-plugins-rawvideoparse.html b/docs/plugins/html/gst-plugins-bad-plugins-rawvideoparse.html
index 2778cd1..3de222d 100644
--- a/docs/plugins/html/gst-plugins-bad-plugins-rawvideoparse.html
+++ b/docs/plugins/html/gst-plugins-bad-plugins-rawvideoparse.html
@@ -337,14 +337,14 @@
 <div class="refsect2">
 <a name="GstRawVideoParse--plane-offsets"></a><h3>The <code class="literal">“plane-offsets”</code> property</h3>
 <pre class="programlisting">  “plane-offsets”            <a href="/usr/share/gtk-doc/html/gobjectgobject-Value-arrays.html#GValueArray"><span class="type">GValueArray</span></a> *</pre>
-<p>Offsets of the planets in bytes.</p>
+<p>Offsets of the planes in bytes.</p>
 <p>Flags: Read / Write</p>
 </div>
 <hr>
 <div class="refsect2">
 <a name="GstRawVideoParse--plane-strides"></a><h3>The <code class="literal">“plane-strides”</code> property</h3>
 <pre class="programlisting">  “plane-strides”            <a href="/usr/share/gtk-doc/html/gobjectgobject-Value-arrays.html#GValueArray"><span class="type">GValueArray</span></a> *</pre>
-<p>Strides of the planets in bytes.</p>
+<p>Strides of the planes in bytes.</p>
 <p>Flags: Read / Write</p>
 </div>
 <hr>
diff --git a/docs/plugins/html/index.html b/docs/plugins/html/index.html
index feced84..c715329 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 Bad Plugins 1.0 Plugins Reference Manual</p></th></tr></table></div>
 <div><p class="releaseinfo">
-      for GStreamer Bad Plugins 1.0 (1.10.2)
+      for GStreamer Bad 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-bad/html/" target="_top">http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-bad/html/</a>.
     </p></div>
diff --git a/docs/plugins/inspect/plugin-accurip.xml b/docs/plugins/inspect/plugin-accurip.xml
index 47975cb..254fe2d 100644
--- a/docs/plugins/inspect/plugin-accurip.xml
+++ b/docs/plugins/inspect/plugin-accurip.xml
@@ -3,7 +3,7 @@
   <description>Computes an AccurateRip CRC</description>
   <filename>../../gst/accurip/.libs/libgstaccurip.so</filename>
   <basename>libgstaccurip.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-adpcmdec.xml b/docs/plugins/inspect/plugin-adpcmdec.xml
index 300316b..aef6c12 100644
--- a/docs/plugins/inspect/plugin-adpcmdec.xml
+++ b/docs/plugins/inspect/plugin-adpcmdec.xml
@@ -3,7 +3,7 @@
   <description>ADPCM decoder</description>
   <filename>../../gst/adpcmdec/.libs/libgstadpcmdec.so</filename>
   <basename>libgstadpcmdec.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-adpcmenc.xml b/docs/plugins/inspect/plugin-adpcmenc.xml
index 66fe0d2..20f65dd 100644
--- a/docs/plugins/inspect/plugin-adpcmenc.xml
+++ b/docs/plugins/inspect/plugin-adpcmenc.xml
@@ -3,7 +3,7 @@
   <description>ADPCM encoder</description>
   <filename>../../gst/adpcmenc/.libs/libgstadpcmenc.so</filename>
   <basename>libgstadpcmenc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-aiff.xml b/docs/plugins/inspect/plugin-aiff.xml
index c75ecb6..cd953ee 100644
--- a/docs/plugins/inspect/plugin-aiff.xml
+++ b/docs/plugins/inspect/plugin-aiff.xml
@@ -3,7 +3,7 @@
   <description>Create and parse Audio Interchange File Format (AIFF) files</description>
   <filename>../../gst/aiff/.libs/libgstaiff.so</filename>
   <basename>libgstaiff.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-asfmux.xml b/docs/plugins/inspect/plugin-asfmux.xml
index 71e47f1..c50bc85 100644
--- a/docs/plugins/inspect/plugin-asfmux.xml
+++ b/docs/plugins/inspect/plugin-asfmux.xml
@@ -3,7 +3,7 @@
   <description>ASF Muxer Plugin</description>
   <filename>../../gst/asfmux/.libs/libgstasfmux.so</filename>
   <basename>libgstasfmux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-assrender.xml b/docs/plugins/inspect/plugin-assrender.xml
index e58c79c..8e54127 100644
--- a/docs/plugins/inspect/plugin-assrender.xml
+++ b/docs/plugins/inspect/plugin-assrender.xml
@@ -3,7 +3,7 @@
   <description>ASS/SSA subtitle renderer</description>
   <filename>../../ext/assrender/.libs/libgstassrender.so</filename>
   <basename>libgstassrender.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-audiofxbad.xml b/docs/plugins/inspect/plugin-audiofxbad.xml
index 0b307da..7009f02 100644
--- a/docs/plugins/inspect/plugin-audiofxbad.xml
+++ b/docs/plugins/inspect/plugin-audiofxbad.xml
@@ -3,7 +3,7 @@
   <description>Audio filters from gst-plugins-bad</description>
   <filename>../../gst/audiofxbad/.libs/libgstaudiofxbad.so</filename>
   <basename>libgstaudiofxbad.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-audiomixer.xml b/docs/plugins/inspect/plugin-audiomixer.xml
index ac3f2b3..8880536 100644
--- a/docs/plugins/inspect/plugin-audiomixer.xml
+++ b/docs/plugins/inspect/plugin-audiomixer.xml
@@ -3,7 +3,7 @@
   <description>Mixes multiple audio streams</description>
   <filename>../../gst/audiomixer/.libs/libgstaudiomixer.so</filename>
   <basename>libgstaudiomixer.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-audiovisualizers.xml b/docs/plugins/inspect/plugin-audiovisualizers.xml
index 0c10270..225969b 100644
--- a/docs/plugins/inspect/plugin-audiovisualizers.xml
+++ b/docs/plugins/inspect/plugin-audiovisualizers.xml
@@ -3,7 +3,7 @@
   <description>Creates video visualizations of audio input</description>
   <filename>../../gst/audiovisualizers/.libs/libgstaudiovisualizers.so</filename>
   <basename>libgstaudiovisualizers.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-autoconvert.xml b/docs/plugins/inspect/plugin-autoconvert.xml
index 5153926..0eb81c6 100644
--- a/docs/plugins/inspect/plugin-autoconvert.xml
+++ b/docs/plugins/inspect/plugin-autoconvert.xml
@@ -3,7 +3,7 @@
   <description>Selects convertor element based on caps</description>
   <filename>../../gst/autoconvert/.libs/libgstautoconvert.so</filename>
   <basename>libgstautoconvert.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-bayer.xml b/docs/plugins/inspect/plugin-bayer.xml
index 5598043..531e042 100644
--- a/docs/plugins/inspect/plugin-bayer.xml
+++ b/docs/plugins/inspect/plugin-bayer.xml
@@ -3,7 +3,7 @@
   <description>Elements to convert Bayer images</description>
   <filename>../../gst/bayer/.libs/libgstbayer.so</filename>
   <basename>libgstbayer.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-bluez.xml b/docs/plugins/inspect/plugin-bluez.xml
index 4d0e3d1..365c5bc 100644
--- a/docs/plugins/inspect/plugin-bluez.xml
+++ b/docs/plugins/inspect/plugin-bluez.xml
@@ -3,7 +3,7 @@
   <description>Bluez-based bluetooth support</description>
   <filename>../../sys/bluez/.libs/libgstbluez.so</filename>
   <basename>libgstbluez.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-bs2b.xml b/docs/plugins/inspect/plugin-bs2b.xml
index dcec29c..269b658 100644
--- a/docs/plugins/inspect/plugin-bs2b.xml
+++ b/docs/plugins/inspect/plugin-bs2b.xml
@@ -3,7 +3,7 @@
   <description>Improve headphone listening of stereo audio recordsusing the bs2b library.</description>
   <filename>../../ext/bs2b/.libs/libgstbs2b.so</filename>
   <basename>libgstbs2b.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-bz2.xml b/docs/plugins/inspect/plugin-bz2.xml
index 324813b..8813696 100644
--- a/docs/plugins/inspect/plugin-bz2.xml
+++ b/docs/plugins/inspect/plugin-bz2.xml
@@ -3,7 +3,7 @@
   <description>Compress or decompress streams</description>
   <filename>../../ext/bz2/.libs/libgstbz2.so</filename>
   <basename>libgstbz2.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-camerabin.xml b/docs/plugins/inspect/plugin-camerabin.xml
index bee563c..29aa197 100644
--- a/docs/plugins/inspect/plugin-camerabin.xml
+++ b/docs/plugins/inspect/plugin-camerabin.xml
@@ -3,7 +3,7 @@
   <description>Take image snapshots and record movies from camera</description>
   <filename>../../gst/camerabin2/.libs/libgstcamerabin2.so</filename>
   <basename>libgstcamerabin2.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-chromaprint.xml b/docs/plugins/inspect/plugin-chromaprint.xml
index d6c56bd..602cb3a 100644
--- a/docs/plugins/inspect/plugin-chromaprint.xml
+++ b/docs/plugins/inspect/plugin-chromaprint.xml
@@ -3,7 +3,7 @@
   <description>Calculate Chromaprint fingerprint from audio files</description>
   <filename>../../ext/chromaprint/.libs/libgstchromaprint.so</filename>
   <basename>libgstchromaprint.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-coloreffects.xml b/docs/plugins/inspect/plugin-coloreffects.xml
index 4c911bd..3636967 100644
--- a/docs/plugins/inspect/plugin-coloreffects.xml
+++ b/docs/plugins/inspect/plugin-coloreffects.xml
@@ -3,7 +3,7 @@
   <description>Color Look-up Table filters</description>
   <filename>../../gst/coloreffects/.libs/libgstcoloreffects.so</filename>
   <basename>libgstcoloreffects.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-compositor.xml b/docs/plugins/inspect/plugin-compositor.xml
index c276a49..218e984 100644
--- a/docs/plugins/inspect/plugin-compositor.xml
+++ b/docs/plugins/inspect/plugin-compositor.xml
@@ -3,7 +3,7 @@
   <description>Compositor</description>
   <filename>../../gst/compositor/.libs/libgstcompositor.so</filename>
   <basename>libgstcompositor.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-curl.xml b/docs/plugins/inspect/plugin-curl.xml
index fa994fa..cc2b707 100644
--- a/docs/plugins/inspect/plugin-curl.xml
+++ b/docs/plugins/inspect/plugin-curl.xml
@@ -3,7 +3,7 @@
   <description>libcurl-based elements</description>
   <filename>../../ext/curl/.libs/libgstcurl.so</filename>
   <basename>libgstcurl.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dashdemux.xml b/docs/plugins/inspect/plugin-dashdemux.xml
index d13e227..087162d 100644
--- a/docs/plugins/inspect/plugin-dashdemux.xml
+++ b/docs/plugins/inspect/plugin-dashdemux.xml
@@ -3,7 +3,7 @@
   <description>DASH demuxer plugin</description>
   <filename>../../ext/dash/.libs/libgstdashdemux.so</filename>
   <basename>libgstdashdemux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-dataurisrc.xml b/docs/plugins/inspect/plugin-dataurisrc.xml
index 6a86f44..22d5da2 100644
--- a/docs/plugins/inspect/plugin-dataurisrc.xml
+++ b/docs/plugins/inspect/plugin-dataurisrc.xml
@@ -3,7 +3,7 @@
   <description>data: URI source</description>
   <filename>../../gst/dataurisrc/.libs/libgstdataurisrc.so</filename>
   <basename>libgstdataurisrc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dc1394.xml b/docs/plugins/inspect/plugin-dc1394.xml
index 36c9e11..bf64eff 100644
--- a/docs/plugins/inspect/plugin-dc1394.xml
+++ b/docs/plugins/inspect/plugin-dc1394.xml
@@ -3,7 +3,7 @@
   <description>1394 IIDC video source</description>
   <filename>../../ext/dc1394/.libs/libgstdc1394.so</filename>
   <basename>libgstdc1394.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-debugutilsbad.xml b/docs/plugins/inspect/plugin-debugutilsbad.xml
index c295123..ce80e53 100644
--- a/docs/plugins/inspect/plugin-debugutilsbad.xml
+++ b/docs/plugins/inspect/plugin-debugutilsbad.xml
@@ -3,7 +3,7 @@
   <description>Collection of elements that may or may not be useful for debugging</description>
   <filename>../../gst/debugutils/.libs/libgstdebugutilsbad.so</filename>
   <basename>libgstdebugutilsbad.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-decklink.xml b/docs/plugins/inspect/plugin-decklink.xml
index 7250256..7b48a26 100644
--- a/docs/plugins/inspect/plugin-decklink.xml
+++ b/docs/plugins/inspect/plugin-decklink.xml
@@ -3,7 +3,7 @@
   <description>Blackmagic Decklink plugin</description>
   <filename>../../sys/decklink/.libs/libgstdecklink.so</filename>
   <basename>libgstdecklink.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-dfbvideosink.xml b/docs/plugins/inspect/plugin-dfbvideosink.xml
index e7fdfbd..85e0f41 100644
--- a/docs/plugins/inspect/plugin-dfbvideosink.xml
+++ b/docs/plugins/inspect/plugin-dfbvideosink.xml
@@ -3,7 +3,7 @@
   <description>DirectFB video output plugin</description>
   <filename>../../ext/directfb/.libs/libgstdfbvideosink.so</filename>
   <basename>libgstdfbvideosink.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dtls.xml b/docs/plugins/inspect/plugin-dtls.xml
index bb47df5..cafa989 100644
--- a/docs/plugins/inspect/plugin-dtls.xml
+++ b/docs/plugins/inspect/plugin-dtls.xml
@@ -3,7 +3,7 @@
   <description>DTLS decoder and encoder plugins</description>
   <filename>../../ext/dtls/.libs/libgstdtls.so</filename>
   <basename>libgstdtls.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>BSD</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dtsdec.xml b/docs/plugins/inspect/plugin-dtsdec.xml
index 00ac43a..40db49f 100644
--- a/docs/plugins/inspect/plugin-dtsdec.xml
+++ b/docs/plugins/inspect/plugin-dtsdec.xml
@@ -3,7 +3,7 @@
   <description>Decodes DTS audio streams</description>
   <filename>../../ext/dts/.libs/libgstdtsdec.so</filename>
   <basename>libgstdtsdec.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvb.xml b/docs/plugins/inspect/plugin-dvb.xml
index 596889a..206d915 100644
--- a/docs/plugins/inspect/plugin-dvb.xml
+++ b/docs/plugins/inspect/plugin-dvb.xml
@@ -3,7 +3,7 @@
   <description>DVB elements</description>
   <filename>../../sys/dvb/.libs/libgstdvb.so</filename>
   <basename>libgstdvb.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvbsuboverlay.xml b/docs/plugins/inspect/plugin-dvbsuboverlay.xml
index ad48491..3eaad55 100644
--- a/docs/plugins/inspect/plugin-dvbsuboverlay.xml
+++ b/docs/plugins/inspect/plugin-dvbsuboverlay.xml
@@ -3,7 +3,7 @@
   <description>DVB subtitle renderer</description>
   <filename>../../gst/dvbsuboverlay/.libs/libgstdvbsuboverlay.so</filename>
   <basename>libgstdvbsuboverlay.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvdspu.xml b/docs/plugins/inspect/plugin-dvdspu.xml
index 5b8c738..c956045 100644
--- a/docs/plugins/inspect/plugin-dvdspu.xml
+++ b/docs/plugins/inspect/plugin-dvdspu.xml
@@ -3,7 +3,7 @@
   <description>DVD Sub-picture Overlay element</description>
   <filename>../../gst/dvdspu/.libs/libgstdvdspu.so</filename>
   <basename>libgstdvdspu.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-faac.xml b/docs/plugins/inspect/plugin-faac.xml
index 42af9c4..f57d614 100644
--- a/docs/plugins/inspect/plugin-faac.xml
+++ b/docs/plugins/inspect/plugin-faac.xml
@@ -3,7 +3,7 @@
   <description>Free AAC Encoder (FAAC)</description>
   <filename>../../ext/faac/.libs/libgstfaac.so</filename>
   <basename>libgstfaac.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-faad.xml b/docs/plugins/inspect/plugin-faad.xml
index 5e05382..89a0d59 100644
--- a/docs/plugins/inspect/plugin-faad.xml
+++ b/docs/plugins/inspect/plugin-faad.xml
@@ -3,7 +3,7 @@
   <description>Free AAC Decoder (FAAD)</description>
   <filename>../../ext/faad/.libs/libgstfaad.so</filename>
   <basename>libgstfaad.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-fbdevsink.xml b/docs/plugins/inspect/plugin-fbdevsink.xml
index 70a3c9e..f57e38d 100644
--- a/docs/plugins/inspect/plugin-fbdevsink.xml
+++ b/docs/plugins/inspect/plugin-fbdevsink.xml
@@ -3,7 +3,7 @@
   <description>Linux framebuffer video sink</description>
   <filename>../../sys/fbdev/.libs/libgstfbdevsink.so</filename>
   <basename>libgstfbdevsink.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-fdkaac.xml b/docs/plugins/inspect/plugin-fdkaac.xml
index 01c9a0f..0eafc26 100644
--- a/docs/plugins/inspect/plugin-fdkaac.xml
+++ b/docs/plugins/inspect/plugin-fdkaac.xml
@@ -3,7 +3,7 @@
   <description>Fraunhofer FDK AAC Codec plugin</description>
   <filename>../../ext/fdkaac/.libs/libgstfdkaac.so</filename>
   <basename>libgstfdkaac.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-festival.xml b/docs/plugins/inspect/plugin-festival.xml
index c0d83fd..f6e9abf 100644
--- a/docs/plugins/inspect/plugin-festival.xml
+++ b/docs/plugins/inspect/plugin-festival.xml
@@ -3,7 +3,7 @@
   <description>Synthesizes plain text into audio</description>
   <filename>../../gst/festival/.libs/libgstfestival.so</filename>
   <basename>libgstfestival.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-fieldanalysis.xml b/docs/plugins/inspect/plugin-fieldanalysis.xml
index 7cf21a8..058b093 100644
--- a/docs/plugins/inspect/plugin-fieldanalysis.xml
+++ b/docs/plugins/inspect/plugin-fieldanalysis.xml
@@ -3,7 +3,7 @@
   <description>Video field analysis</description>
   <filename>../../gst/fieldanalysis/.libs/libgstfieldanalysis.so</filename>
   <basename>libgstfieldanalysis.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-flite.xml b/docs/plugins/inspect/plugin-flite.xml
index 304fc7c..8200227 100644
--- a/docs/plugins/inspect/plugin-flite.xml
+++ b/docs/plugins/inspect/plugin-flite.xml
@@ -3,7 +3,7 @@
   <description>Flite speech synthesizer plugin</description>
   <filename>../../ext/flite/.libs/libgstflite.so</filename>
   <basename>libgstflite.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-fluidsynthmidi.xml b/docs/plugins/inspect/plugin-fluidsynthmidi.xml
index 31d1920..e3b76ba 100644
--- a/docs/plugins/inspect/plugin-fluidsynthmidi.xml
+++ b/docs/plugins/inspect/plugin-fluidsynthmidi.xml
@@ -3,7 +3,7 @@
   <description>Fluidsynth MIDI Plugin</description>
   <filename>../../ext/fluidsynth/.libs/libgstfluidsynthmidi.so</filename>
   <basename>libgstfluidsynthmidi.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-freeverb.xml b/docs/plugins/inspect/plugin-freeverb.xml
index 2b84485..af1cf11 100644
--- a/docs/plugins/inspect/plugin-freeverb.xml
+++ b/docs/plugins/inspect/plugin-freeverb.xml
@@ -3,7 +3,7 @@
   <description>Reverberation/room effect</description>
   <filename>../../gst/freeverb/.libs/libgstfreeverb.so</filename>
   <basename>libgstfreeverb.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-frei0r.xml b/docs/plugins/inspect/plugin-frei0r.xml
index 7ccd063..dcd9480 100644
--- a/docs/plugins/inspect/plugin-frei0r.xml
+++ b/docs/plugins/inspect/plugin-frei0r.xml
@@ -3,7 +3,7 @@
   <description>frei0r plugin library</description>
   <filename>../../gst/frei0r/.libs/libgstfrei0r.so</filename>
   <basename>libgstfrei0r.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gaudieffects.xml b/docs/plugins/inspect/plugin-gaudieffects.xml
index 0e4e82c..be8a7e6 100644
--- a/docs/plugins/inspect/plugin-gaudieffects.xml
+++ b/docs/plugins/inspect/plugin-gaudieffects.xml
@@ -3,7 +3,7 @@
   <description>Gaudi video effects.</description>
   <filename>../../gst/gaudieffects/.libs/libgstgaudieffects.so</filename>
   <basename>libgstgaudieffects.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-gdp.xml b/docs/plugins/inspect/plugin-gdp.xml
index e812127..30e374f 100644
--- a/docs/plugins/inspect/plugin-gdp.xml
+++ b/docs/plugins/inspect/plugin-gdp.xml
@@ -3,7 +3,7 @@
   <description>Payload/depayload GDP packets</description>
   <filename>../../gst/gdp/.libs/libgstgdp.so</filename>
   <basename>libgstgdp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-geometrictransform.xml b/docs/plugins/inspect/plugin-geometrictransform.xml
index ff76c58..4c2f586 100644
--- a/docs/plugins/inspect/plugin-geometrictransform.xml
+++ b/docs/plugins/inspect/plugin-geometrictransform.xml
@@ -3,7 +3,7 @@
   <description>Various geometric image transform elements</description>
   <filename>../../gst/geometrictransform/.libs/libgstgeometrictransform.so</filename>
   <basename>libgstgeometrictransform.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gmedec.xml b/docs/plugins/inspect/plugin-gmedec.xml
index 7d97f0e..a89225d 100644
--- a/docs/plugins/inspect/plugin-gmedec.xml
+++ b/docs/plugins/inspect/plugin-gmedec.xml
@@ -3,7 +3,7 @@
   <description>GME Audio Decoder</description>
   <filename>../../ext/gme/.libs/libgstgme.so</filename>
   <basename>libgstgme.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gsm.xml b/docs/plugins/inspect/plugin-gsm.xml
index 525b29b..5a8e8c7 100644
--- a/docs/plugins/inspect/plugin-gsm.xml
+++ b/docs/plugins/inspect/plugin-gsm.xml
@@ -3,7 +3,7 @@
   <description>GSM encoder/decoder</description>
   <filename>../../ext/gsm/.libs/libgstgsm.so</filename>
   <basename>libgstgsm.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gstgtk.xml b/docs/plugins/inspect/plugin-gstgtk.xml
index 976b53a..40aae45 100644
--- a/docs/plugins/inspect/plugin-gstgtk.xml
+++ b/docs/plugins/inspect/plugin-gstgtk.xml
@@ -3,7 +3,7 @@
   <description>Gtk+ sink</description>
   <filename>../../ext/gtk/.libs/libgstgtksink.so</filename>
   <basename>libgstgtksink.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-gstsiren.xml b/docs/plugins/inspect/plugin-gstsiren.xml
index cf17d44..bf2fa5d 100644
--- a/docs/plugins/inspect/plugin-gstsiren.xml
+++ b/docs/plugins/inspect/plugin-gstsiren.xml
@@ -3,7 +3,7 @@
   <description>Siren encoder/decoder/payloader/depayloader plugins</description>
   <filename>../../gst/siren/.libs/libgstsiren.so</filename>
   <basename>libgstsiren.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-hls.xml b/docs/plugins/inspect/plugin-hls.xml
index a5ee208..f549c53 100644
--- a/docs/plugins/inspect/plugin-hls.xml
+++ b/docs/plugins/inspect/plugin-hls.xml
@@ -3,7 +3,7 @@
   <description>HTTP Live Streaming (HLS)</description>
   <filename>../../ext/hls/.libs/libgsthls.so</filename>
   <basename>libgsthls.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-id3tag.xml b/docs/plugins/inspect/plugin-id3tag.xml
index cd0582a..c612b96 100644
--- a/docs/plugins/inspect/plugin-id3tag.xml
+++ b/docs/plugins/inspect/plugin-id3tag.xml
@@ -3,7 +3,7 @@
   <description>ID3 v1 and v2 muxing plugin</description>
   <filename>../../gst/id3tag/.libs/libgstid3tag.so</filename>
   <basename>libgstid3tag.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-inter.xml b/docs/plugins/inspect/plugin-inter.xml
index 0607c8a..baf1921 100644
--- a/docs/plugins/inspect/plugin-inter.xml
+++ b/docs/plugins/inspect/plugin-inter.xml
@@ -3,7 +3,7 @@
   <description>plugin for inter-pipeline communication</description>
   <filename>../../gst/inter/.libs/libgstinter.so</filename>
   <basename>libgstinter.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-interlace.xml b/docs/plugins/inspect/plugin-interlace.xml
index d63126c..89a3d72 100644
--- a/docs/plugins/inspect/plugin-interlace.xml
+++ b/docs/plugins/inspect/plugin-interlace.xml
@@ -3,7 +3,7 @@
   <description>Create an interlaced video stream</description>
   <filename>../../gst/interlace/.libs/libgstinterlace.so</filename>
   <basename>libgstinterlace.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ivfparse.xml b/docs/plugins/inspect/plugin-ivfparse.xml
index 04a7ed7..0bc8dfe 100644
--- a/docs/plugins/inspect/plugin-ivfparse.xml
+++ b/docs/plugins/inspect/plugin-ivfparse.xml
@@ -3,7 +3,7 @@
   <description>IVF parser</description>
   <filename>../../gst/ivfparse/.libs/libgstivfparse.so</filename>
   <basename>libgstivfparse.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ivtc.xml b/docs/plugins/inspect/plugin-ivtc.xml
index 9e2eeac..4a24da5 100644
--- a/docs/plugins/inspect/plugin-ivtc.xml
+++ b/docs/plugins/inspect/plugin-ivtc.xml
@@ -3,7 +3,7 @@
   <description>Inverse Telecine</description>
   <filename>../../gst/ivtc/.libs/libgstivtc.so</filename>
   <basename>libgstivtc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-jp2kdecimator.xml b/docs/plugins/inspect/plugin-jp2kdecimator.xml
index c4a04f2..5b7a1bc 100644
--- a/docs/plugins/inspect/plugin-jp2kdecimator.xml
+++ b/docs/plugins/inspect/plugin-jp2kdecimator.xml
@@ -3,7 +3,7 @@
   <description>JPEG2000 decimator</description>
   <filename>../../gst/jp2kdecimator/.libs/libgstjp2kdecimator.so</filename>
   <basename>libgstjp2kdecimator.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-jpegformat.xml b/docs/plugins/inspect/plugin-jpegformat.xml
index 07484d7..1ba6641 100644
--- a/docs/plugins/inspect/plugin-jpegformat.xml
+++ b/docs/plugins/inspect/plugin-jpegformat.xml
@@ -3,7 +3,7 @@
   <description>JPEG interchange format plugin</description>
   <filename>../../gst/jpegformat/.libs/libgstjpegformat.so</filename>
   <basename>libgstjpegformat.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-kate.xml b/docs/plugins/inspect/plugin-kate.xml
index 201be6d..d78ba59 100644
--- a/docs/plugins/inspect/plugin-kate.xml
+++ b/docs/plugins/inspect/plugin-kate.xml
@@ -3,7 +3,7 @@
   <description>Kate plugin</description>
   <filename>../../ext/kate/.libs/libgstkate.so</filename>
   <basename>libgstkate.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ladspa.xml b/docs/plugins/inspect/plugin-ladspa.xml
index 54bdea7..678ba12 100644
--- a/docs/plugins/inspect/plugin-ladspa.xml
+++ b/docs/plugins/inspect/plugin-ladspa.xml
@@ -3,7 +3,7 @@
   <description>LADSPA plugin</description>
   <filename>../../ext/ladspa/.libs/libgstladspa.so</filename>
   <basename>libgstladspa.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-libde265.xml b/docs/plugins/inspect/plugin-libde265.xml
index 6a96df2..7bca2a7 100644
--- a/docs/plugins/inspect/plugin-libde265.xml
+++ b/docs/plugins/inspect/plugin-libde265.xml
@@ -3,7 +3,7 @@
   <description>HEVC/H.265 decoder using libde265</description>
   <filename>../../ext/libde265/.libs/libgstlibde265.so</filename>
   <basename>libgstlibde265.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-midi.xml b/docs/plugins/inspect/plugin-midi.xml
index 616dfaa..562eed5 100644
--- a/docs/plugins/inspect/plugin-midi.xml
+++ b/docs/plugins/inspect/plugin-midi.xml
@@ -3,7 +3,7 @@
   <description>Parse MIDI files</description>
   <filename>../../gst/midi/.libs/libgstmidi.so</filename>
   <basename>libgstmidi.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mimic.xml b/docs/plugins/inspect/plugin-mimic.xml
index 5a7bb65..75112d1 100644
--- a/docs/plugins/inspect/plugin-mimic.xml
+++ b/docs/plugins/inspect/plugin-mimic.xml
@@ -3,7 +3,7 @@
   <description>Mimic codec</description>
   <filename>../../ext/mimic/.libs/libgstmimic.so</filename>
   <basename>libgstmimic.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mms.xml b/docs/plugins/inspect/plugin-mms.xml
index e169b25..d0eff9b 100644
--- a/docs/plugins/inspect/plugin-mms.xml
+++ b/docs/plugins/inspect/plugin-mms.xml
@@ -3,7 +3,7 @@
   <description>Microsoft Multi Media Server streaming protocol support</description>
   <filename>../../ext/libmms/.libs/libgstmms.so</filename>
   <basename>libgstmms.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-modplug.xml b/docs/plugins/inspect/plugin-modplug.xml
index 0306af5..9f9f62f 100644
--- a/docs/plugins/inspect/plugin-modplug.xml
+++ b/docs/plugins/inspect/plugin-modplug.xml
@@ -3,7 +3,7 @@
   <description>.MOD audio decoding</description>
   <filename>../../ext/modplug/.libs/libgstmodplug.so</filename>
   <basename>libgstmodplug.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpeg2enc.xml b/docs/plugins/inspect/plugin-mpeg2enc.xml
index 9090713..41366a0 100644
--- a/docs/plugins/inspect/plugin-mpeg2enc.xml
+++ b/docs/plugins/inspect/plugin-mpeg2enc.xml
@@ -3,7 +3,7 @@
   <description>High-quality MPEG-1/2 video encoder</description>
   <filename>../../ext/mpeg2enc/.libs/libgstmpeg2enc.so</filename>
   <basename>libgstmpeg2enc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpegpsdemux.xml b/docs/plugins/inspect/plugin-mpegpsdemux.xml
index 46e024a..d9609ff 100644
--- a/docs/plugins/inspect/plugin-mpegpsdemux.xml
+++ b/docs/plugins/inspect/plugin-mpegpsdemux.xml
@@ -3,7 +3,7 @@
   <description>MPEG-PS demuxer</description>
   <filename>../../gst/mpegdemux/.libs/libgstmpegpsdemux.so</filename>
   <basename>libgstmpegpsdemux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>unknown</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpegpsmux.xml b/docs/plugins/inspect/plugin-mpegpsmux.xml
index 9b21328..1d1929f 100644
--- a/docs/plugins/inspect/plugin-mpegpsmux.xml
+++ b/docs/plugins/inspect/plugin-mpegpsmux.xml
@@ -3,7 +3,7 @@
   <description>MPEG-PS muxer</description>
   <filename>../../gst/mpegpsmux/.libs/libgstmpegpsmux.so</filename>
   <basename>libgstmpegpsmux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpegtsdemux.xml b/docs/plugins/inspect/plugin-mpegtsdemux.xml
index 9727804..d96e055 100644
--- a/docs/plugins/inspect/plugin-mpegtsdemux.xml
+++ b/docs/plugins/inspect/plugin-mpegtsdemux.xml
@@ -3,7 +3,7 @@
   <description>MPEG TS demuxer</description>
   <filename>../../gst/mpegtsdemux/.libs/libgstmpegtsdemux.so</filename>
   <basename>libgstmpegtsdemux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpegtsmux.xml b/docs/plugins/inspect/plugin-mpegtsmux.xml
index 175e407..0f182c1 100644
--- a/docs/plugins/inspect/plugin-mpegtsmux.xml
+++ b/docs/plugins/inspect/plugin-mpegtsmux.xml
@@ -3,7 +3,7 @@
   <description>MPEG-TS muxer</description>
   <filename>../../gst/mpegtsmux/.libs/libgstmpegtsmux.so</filename>
   <basename>libgstmpegtsmux.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mplex.xml b/docs/plugins/inspect/plugin-mplex.xml
index 54f6abd..44f80d4 100644
--- a/docs/plugins/inspect/plugin-mplex.xml
+++ b/docs/plugins/inspect/plugin-mplex.xml
@@ -3,7 +3,7 @@
   <description>High-quality MPEG/DVD/SVCD/VCD video/audio multiplexer</description>
   <filename>../../ext/mplex/.libs/libgstmplex.so</filename>
   <basename>libgstmplex.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-musepack.xml b/docs/plugins/inspect/plugin-musepack.xml
index 68bf9b2..f2c0195 100644
--- a/docs/plugins/inspect/plugin-musepack.xml
+++ b/docs/plugins/inspect/plugin-musepack.xml
@@ -3,7 +3,7 @@
   <description>Musepack decoder</description>
   <filename>../../ext/musepack/.libs/libgstmusepack.so</filename>
   <basename>libgstmusepack.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mxf.xml b/docs/plugins/inspect/plugin-mxf.xml
index afd22cd..dc2f165 100644
--- a/docs/plugins/inspect/plugin-mxf.xml
+++ b/docs/plugins/inspect/plugin-mxf.xml
@@ -3,7 +3,7 @@
   <description>MXF plugin library</description>
   <filename>../../gst/mxf/.libs/libgstmxf.so</filename>
   <basename>libgstmxf.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-netsim.xml b/docs/plugins/inspect/plugin-netsim.xml
index 4657118..e8add08 100644
--- a/docs/plugins/inspect/plugin-netsim.xml
+++ b/docs/plugins/inspect/plugin-netsim.xml
@@ -3,7 +3,7 @@
   <description>Network Simulator</description>
   <filename>../../gst/netsim/.libs/libgstnetsim.so</filename>
   <basename>libgstnetsim.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-ofa.xml b/docs/plugins/inspect/plugin-ofa.xml
index 1122560..6e5ab6b 100644
--- a/docs/plugins/inspect/plugin-ofa.xml
+++ b/docs/plugins/inspect/plugin-ofa.xml
@@ -3,7 +3,7 @@
   <description>Calculate MusicIP fingerprint from audio files</description>
   <filename>../../ext/ofa/.libs/libgstofa.so</filename>
   <basename>libgstofa.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-openal.xml b/docs/plugins/inspect/plugin-openal.xml
index 6303120..a3d3e8a 100644
--- a/docs/plugins/inspect/plugin-openal.xml
+++ b/docs/plugins/inspect/plugin-openal.xml
@@ -3,7 +3,7 @@
   <description>OpenAL plugin library</description>
   <filename>../../ext/openal/.libs/libgstopenal.so</filename>
   <basename>libgstopenal.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-opencv.xml b/docs/plugins/inspect/plugin-opencv.xml
index 7044368..3c92c91 100644
--- a/docs/plugins/inspect/plugin-opencv.xml
+++ b/docs/plugins/inspect/plugin-opencv.xml
@@ -3,7 +3,7 @@
   <description>GStreamer OpenCV Plugins</description>
   <filename>../../ext/opencv/.libs/libgstopencv.so</filename>
   <basename>libgstopencv.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-openexr.xml b/docs/plugins/inspect/plugin-openexr.xml
index ac58fe0..2bad376 100644
--- a/docs/plugins/inspect/plugin-openexr.xml
+++ b/docs/plugins/inspect/plugin-openexr.xml
@@ -3,7 +3,7 @@
   <description>OpenEXR image plugin</description>
   <filename>../../ext/openexr/.libs/libgstopenexr.so</filename>
   <basename>libgstopenexr.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-opengl.xml b/docs/plugins/inspect/plugin-opengl.xml
index 66a8ce5..810bfec 100644
--- a/docs/plugins/inspect/plugin-opengl.xml
+++ b/docs/plugins/inspect/plugin-opengl.xml
@@ -3,7 +3,7 @@
   <description>OpenGL plugin</description>
   <filename>../../ext/gl/.libs/libgstopengl.so</filename>
   <basename>libgstopengl.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-openh264.xml b/docs/plugins/inspect/plugin-openh264.xml
index 0f5a2cb..b7d8f26 100644
--- a/docs/plugins/inspect/plugin-openh264.xml
+++ b/docs/plugins/inspect/plugin-openh264.xml
@@ -3,7 +3,7 @@
   <description>OpenH264 encoder/decoder plugin</description>
   <filename>../../ext/openh264/.libs/libgstopenh264.so</filename>
   <basename>libgstopenh264.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>BSD</license>
   <source>gst-plugins-bad</source>
   <package>OpenWebRTC GStreamer plugins</package>
diff --git a/docs/plugins/inspect/plugin-openjpeg.xml b/docs/plugins/inspect/plugin-openjpeg.xml
index 8a517b1..fb9a332 100644
--- a/docs/plugins/inspect/plugin-openjpeg.xml
+++ b/docs/plugins/inspect/plugin-openjpeg.xml
@@ -3,7 +3,7 @@
   <description>OpenJPEG-based JPEG2000 image decoder/encoder</description>
   <filename>../../ext/openjpeg/.libs/libgstopenjpeg.so</filename>
   <basename>libgstopenjpeg.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-opusparse.xml b/docs/plugins/inspect/plugin-opusparse.xml
index 117c71f..41c05dd 100644
--- a/docs/plugins/inspect/plugin-opusparse.xml
+++ b/docs/plugins/inspect/plugin-opusparse.xml
@@ -3,7 +3,7 @@
   <description>OPUS parse plugin</description>
   <filename>../../ext/opus/.libs/libgstopusparse.so</filename>
   <basename>libgstopusparse.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-pcapparse.xml b/docs/plugins/inspect/plugin-pcapparse.xml
index d655a44..42dc300 100644
--- a/docs/plugins/inspect/plugin-pcapparse.xml
+++ b/docs/plugins/inspect/plugin-pcapparse.xml
@@ -3,7 +3,7 @@
   <description>Element parsing raw pcap streams</description>
   <filename>../../gst/pcapparse/.libs/libgstpcapparse.so</filename>
   <basename>libgstpcapparse.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-pnm.xml b/docs/plugins/inspect/plugin-pnm.xml
index 5ff5c56..2a92548 100644
--- a/docs/plugins/inspect/plugin-pnm.xml
+++ b/docs/plugins/inspect/plugin-pnm.xml
@@ -3,7 +3,7 @@
   <description>PNM plugin</description>
   <filename>../../gst/pnm/.libs/libgstpnm.so</filename>
   <basename>libgstpnm.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-qt.xml b/docs/plugins/inspect/plugin-qt.xml
index 26265a9..f5f6d32 100644
--- a/docs/plugins/inspect/plugin-qt.xml
+++ b/docs/plugins/inspect/plugin-qt.xml
@@ -3,7 +3,7 @@
   <description>Qt gl plugin</description>
   <filename>../../ext/qt/.libs/libgstqmlgl.so</filename>
   <basename>libgstqmlgl.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rawparse.xml b/docs/plugins/inspect/plugin-rawparse.xml
index 974654f..fb2f0ec 100644
--- a/docs/plugins/inspect/plugin-rawparse.xml
+++ b/docs/plugins/inspect/plugin-rawparse.xml
@@ -3,7 +3,7 @@
   <description>Parses byte streams into raw frames</description>
   <filename>../../gst/rawparse/.libs/libgstrawparse.so</filename>
   <basename>libgstrawparse.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-removesilence.xml b/docs/plugins/inspect/plugin-removesilence.xml
index 79eafd6..bb68899 100644
--- a/docs/plugins/inspect/plugin-removesilence.xml
+++ b/docs/plugins/inspect/plugin-removesilence.xml
@@ -3,7 +3,7 @@
   <description>Removes silence from an audio stream</description>
   <filename>../../gst/removesilence/.libs/libgstremovesilence.so</filename>
   <basename>libgstremovesilence.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-resindvd.xml b/docs/plugins/inspect/plugin-resindvd.xml
index 95d3aa7..51d17df 100644
--- a/docs/plugins/inspect/plugin-resindvd.xml
+++ b/docs/plugins/inspect/plugin-resindvd.xml
@@ -3,7 +3,7 @@
   <description>Resin DVD playback elements</description>
   <filename>../../ext/resindvd/.libs/libgstresindvd.so</filename>
   <basename>libgstresindvd.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-rfbsrc.xml b/docs/plugins/inspect/plugin-rfbsrc.xml
index 43cad1d..81e93be 100644
--- a/docs/plugins/inspect/plugin-rfbsrc.xml
+++ b/docs/plugins/inspect/plugin-rfbsrc.xml
@@ -3,7 +3,7 @@
   <description>Connects to a VNC server and decodes RFB stream</description>
   <filename>../../gst/librfb/.libs/libgstrfbsrc.so</filename>
   <basename>libgstrfbsrc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rsvg.xml b/docs/plugins/inspect/plugin-rsvg.xml
index 0eeb12a..d8e497b 100644
--- a/docs/plugins/inspect/plugin-rsvg.xml
+++ b/docs/plugins/inspect/plugin-rsvg.xml
@@ -3,7 +3,7 @@
   <description>RSVG plugin library</description>
   <filename>../../ext/rsvg/.libs/libgstrsvg.so</filename>
   <basename>libgstrsvg.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rtmp.xml b/docs/plugins/inspect/plugin-rtmp.xml
index 93fa58f..027df0f 100644
--- a/docs/plugins/inspect/plugin-rtmp.xml
+++ b/docs/plugins/inspect/plugin-rtmp.xml
@@ -3,7 +3,7 @@
   <description>RTMP source and sink</description>
   <filename>../../ext/rtmp/.libs/libgstrtmp.so</filename>
   <basename>libgstrtmp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-rtponvif.xml b/docs/plugins/inspect/plugin-rtponvif.xml
index fd4223e..17ddf3a 100644
--- a/docs/plugins/inspect/plugin-rtponvif.xml
+++ b/docs/plugins/inspect/plugin-rtponvif.xml
@@ -3,7 +3,7 @@
   <description>ONVIF Streaming features</description>
   <filename>../../gst/onvif/.libs/libgstrtponvif.so</filename>
   <basename>libgstrtponvif.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>unknown</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-sbc.xml b/docs/plugins/inspect/plugin-sbc.xml
index 4c28baa..88bad82 100644
--- a/docs/plugins/inspect/plugin-sbc.xml
+++ b/docs/plugins/inspect/plugin-sbc.xml
@@ -3,7 +3,7 @@
   <description>SBC bluetooth audio support</description>
   <filename>../../ext/sbc/.libs/libgstsbc.so</filename>
   <basename>libgstsbc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-schro.xml b/docs/plugins/inspect/plugin-schro.xml
index e49a565..2f1740a 100644
--- a/docs/plugins/inspect/plugin-schro.xml
+++ b/docs/plugins/inspect/plugin-schro.xml
@@ -3,7 +3,7 @@
   <description>Schroedinger plugin</description>
   <filename>../../ext/schroedinger/.libs/libgstschro.so</filename>
   <basename>libgstschro.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-sdp.xml b/docs/plugins/inspect/plugin-sdp.xml
index 3f602aa..0cc488f 100644
--- a/docs/plugins/inspect/plugin-sdp.xml
+++ b/docs/plugins/inspect/plugin-sdp.xml
@@ -3,7 +3,7 @@
   <description>configure streaming sessions using SDP</description>
   <filename>../../gst/sdp/.libs/libgstsdpelem.so</filename>
   <basename>libgstsdpelem.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-segmentclip.xml b/docs/plugins/inspect/plugin-segmentclip.xml
index 2448e9f..1a8f3d3 100644
--- a/docs/plugins/inspect/plugin-segmentclip.xml
+++ b/docs/plugins/inspect/plugin-segmentclip.xml
@@ -3,7 +3,7 @@
   <description>Segment clip elements</description>
   <filename>../../gst/segmentclip/.libs/libgstsegmentclip.so</filename>
   <basename>libgstsegmentclip.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-shm.xml b/docs/plugins/inspect/plugin-shm.xml
index 24b640d..7330ca7 100644
--- a/docs/plugins/inspect/plugin-shm.xml
+++ b/docs/plugins/inspect/plugin-shm.xml
@@ -3,7 +3,7 @@
   <description>shared memory sink source</description>
   <filename>../../sys/shm/.libs/libgstshm.so</filename>
   <basename>libgstshm.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-smooth.xml b/docs/plugins/inspect/plugin-smooth.xml
index df344d9..d27e9fc 100644
--- a/docs/plugins/inspect/plugin-smooth.xml
+++ b/docs/plugins/inspect/plugin-smooth.xml
@@ -3,7 +3,7 @@
   <description>Apply a smooth filter to an image</description>
   <filename>../../gst/smooth/.libs/libgstsmooth.so</filename>
   <basename>libgstsmooth.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-smoothstreaming.xml b/docs/plugins/inspect/plugin-smoothstreaming.xml
index a3fe17f..fff0397 100644
--- a/docs/plugins/inspect/plugin-smoothstreaming.xml
+++ b/docs/plugins/inspect/plugin-smoothstreaming.xml
@@ -3,7 +3,7 @@
   <description>Microsoft&apos;s Smooth Streaming format support </description>
   <filename>../../ext/smoothstreaming/.libs/libgstsmoothstreaming.so</filename>
   <basename>libgstsmoothstreaming.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-sndfile.xml b/docs/plugins/inspect/plugin-sndfile.xml
index 72c0131..3cd79aa 100644
--- a/docs/plugins/inspect/plugin-sndfile.xml
+++ b/docs/plugins/inspect/plugin-sndfile.xml
@@ -3,7 +3,7 @@
   <description>use libsndfile to read and write various audio formats</description>
   <filename>../../ext/sndfile/.libs/libgstsndfile.so</filename>
   <basename>libgstsndfile.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-soundtouch.xml b/docs/plugins/inspect/plugin-soundtouch.xml
index c4c33dc..760e2d9 100644
--- a/docs/plugins/inspect/plugin-soundtouch.xml
+++ b/docs/plugins/inspect/plugin-soundtouch.xml
@@ -3,7 +3,7 @@
   <description>Audio Pitch Controller &amp; BPM Detection</description>
   <filename>../../ext/soundtouch/.libs/libgstsoundtouch.so</filename>
   <basename>libgstsoundtouch.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-spandsp.xml b/docs/plugins/inspect/plugin-spandsp.xml
index e347d0c..12c616a 100644
--- a/docs/plugins/inspect/plugin-spandsp.xml
+++ b/docs/plugins/inspect/plugin-spandsp.xml
@@ -3,7 +3,7 @@
   <description>libspandsp plugin</description>
   <filename>../../ext/spandsp/.libs/libgstspandsp.so</filename>
   <basename>libgstspandsp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-speed.xml b/docs/plugins/inspect/plugin-speed.xml
index d543444..25869c8 100644
--- a/docs/plugins/inspect/plugin-speed.xml
+++ b/docs/plugins/inspect/plugin-speed.xml
@@ -3,7 +3,7 @@
   <description>Set speed/pitch on audio/raw streams (resampler)</description>
   <filename>../../gst/speed/.libs/libgstspeed.so</filename>
   <basename>libgstspeed.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-srtp.xml b/docs/plugins/inspect/plugin-srtp.xml
index 424e3af..01dc779 100644
--- a/docs/plugins/inspect/plugin-srtp.xml
+++ b/docs/plugins/inspect/plugin-srtp.xml
@@ -3,7 +3,7 @@
   <description>GStreamer SRTP</description>
   <filename>../../ext/srtp/.libs/libgstsrtp.so</filename>
   <basename>libgstsrtp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-stereo.xml b/docs/plugins/inspect/plugin-stereo.xml
index b88229b..9eb9f16 100644
--- a/docs/plugins/inspect/plugin-stereo.xml
+++ b/docs/plugins/inspect/plugin-stereo.xml
@@ -3,7 +3,7 @@
   <description>Muck with the stereo signal, enhance it&apos;s &apos;stereo-ness&apos;</description>
   <filename>../../gst/stereo/.libs/libgststereo.so</filename>
   <basename>libgststereo.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-subenc.xml b/docs/plugins/inspect/plugin-subenc.xml
index 1af4bc7..fca4948 100644
--- a/docs/plugins/inspect/plugin-subenc.xml
+++ b/docs/plugins/inspect/plugin-subenc.xml
@@ -3,7 +3,7 @@
   <description>subtitle encoders</description>
   <filename>../../gst/subenc/.libs/libgstsubenc.so</filename>
   <basename>libgstsubenc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-teletext.xml b/docs/plugins/inspect/plugin-teletext.xml
index 8b849db..350b21a 100644
--- a/docs/plugins/inspect/plugin-teletext.xml
+++ b/docs/plugins/inspect/plugin-teletext.xml
@@ -3,7 +3,7 @@
   <description>Teletext plugin</description>
   <filename>../../ext/teletextdec/.libs/libgstteletextdec.so</filename>
   <basename>libgstteletextdec.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer</package>
diff --git a/docs/plugins/inspect/plugin-timecode.xml b/docs/plugins/inspect/plugin-timecode.xml
index e05ebc9..50d555a 100644
--- a/docs/plugins/inspect/plugin-timecode.xml
+++ b/docs/plugins/inspect/plugin-timecode.xml
@@ -3,7 +3,7 @@
   <description>Timecode-related elements</description>
   <filename>../../gst/timecode/.libs/libgsttimecode.so</filename>
   <basename>libgsttimecode.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-uvch264.xml b/docs/plugins/inspect/plugin-uvch264.xml
index d0ec4c7..9e2f494 100644
--- a/docs/plugins/inspect/plugin-uvch264.xml
+++ b/docs/plugins/inspect/plugin-uvch264.xml
@@ -3,7 +3,7 @@
   <description>UVC compliant H264 encoding cameras plugin</description>
   <filename>../../sys/uvch264/.libs/libgstuvch264.so</filename>
   <basename>libgstuvch264.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-vcdsrc.xml b/docs/plugins/inspect/plugin-vcdsrc.xml
index 73c14e7..2c8da0d 100644
--- a/docs/plugins/inspect/plugin-vcdsrc.xml
+++ b/docs/plugins/inspect/plugin-vcdsrc.xml
@@ -3,7 +3,7 @@
   <description>Asynchronous read from VCD disk</description>
   <filename>../../sys/vcd/.libs/libgstvcdsrc.so</filename>
   <basename>libgstvcdsrc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videofiltersbad.xml b/docs/plugins/inspect/plugin-videofiltersbad.xml
index 92e5a81..5192d77 100644
--- a/docs/plugins/inspect/plugin-videofiltersbad.xml
+++ b/docs/plugins/inspect/plugin-videofiltersbad.xml
@@ -3,7 +3,7 @@
   <description>Video filters in gst-plugins-bad</description>
   <filename>../../gst/videofilters/.libs/libgstvideofiltersbad.so</filename>
   <basename>libgstvideofiltersbad.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-videoframe_audiolevel.xml b/docs/plugins/inspect/plugin-videoframe_audiolevel.xml
index 1e01dd7..d269e12 100644
--- a/docs/plugins/inspect/plugin-videoframe_audiolevel.xml
+++ b/docs/plugins/inspect/plugin-videoframe_audiolevel.xml
@@ -3,7 +3,7 @@
   <description>Video frame-synchronized audio level</description>
   <filename>../../gst/videoframe_audiolevel/.libs/libgstvideoframe_audiolevel.so</filename>
   <basename>libgstvideoframe_audiolevel.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videoparsersbad.xml b/docs/plugins/inspect/plugin-videoparsersbad.xml
index cb2c42b..047f00a 100644
--- a/docs/plugins/inspect/plugin-videoparsersbad.xml
+++ b/docs/plugins/inspect/plugin-videoparsersbad.xml
@@ -3,7 +3,7 @@
   <description>videoparsers</description>
   <filename>../../gst/videoparsers/.libs/libgstvideoparsersbad.so</filename>
   <basename>libgstvideoparsersbad.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-videosignal.xml b/docs/plugins/inspect/plugin-videosignal.xml
index ac92a0b..f8a86f5 100644
--- a/docs/plugins/inspect/plugin-videosignal.xml
+++ b/docs/plugins/inspect/plugin-videosignal.xml
@@ -3,7 +3,7 @@
   <description>Various video signal analysers</description>
   <filename>../../gst/videosignal/.libs/libgstvideosignal.so</filename>
   <basename>libgstvideosignal.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-vmnc.xml b/docs/plugins/inspect/plugin-vmnc.xml
index a420050..57be2d0 100644
--- a/docs/plugins/inspect/plugin-vmnc.xml
+++ b/docs/plugins/inspect/plugin-vmnc.xml
@@ -3,7 +3,7 @@
   <description>VmWare Video Codec plugins</description>
   <filename>../../gst/vmnc/.libs/libgstvmnc.so</filename>
   <basename>libgstvmnc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-voaacenc.xml b/docs/plugins/inspect/plugin-voaacenc.xml
index af2f4b6..5e4be7f 100644
--- a/docs/plugins/inspect/plugin-voaacenc.xml
+++ b/docs/plugins/inspect/plugin-voaacenc.xml
@@ -3,7 +3,7 @@
   <description>AAC audio encoder</description>
   <filename>../../ext/voaacenc/.libs/libgstvoaacenc.so</filename>
   <basename>libgstvoaacenc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-voamrwbenc.xml b/docs/plugins/inspect/plugin-voamrwbenc.xml
index 0952d4b..4b7efff 100644
--- a/docs/plugins/inspect/plugin-voamrwbenc.xml
+++ b/docs/plugins/inspect/plugin-voamrwbenc.xml
@@ -3,7 +3,7 @@
   <description>Adaptive Multi-Rate Wide-Band Encoder</description>
   <filename>../../ext/voamrwbenc/.libs/libgstvoamrwbenc.so</filename>
   <basename>libgstvoamrwbenc.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>unknown</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-vulkan.xml b/docs/plugins/inspect/plugin-vulkan.xml
new file mode 100644
index 0000000..4770fa4
--- /dev/null
+++ b/docs/plugins/inspect/plugin-vulkan.xml
@@ -0,0 +1,49 @@
+<plugin>
+  <name>vulkan</name>
+  <description>Vulkan plugin</description>
+  <filename>../../ext/vulkan/.libs/libgstvulkan.so</filename>
+  <basename>libgstvulkan.so</basename>
+  <version>1.10.3</version>
+  <license>LGPL</license>
+  <source>gst-plugins-bad</source>
+  <package>GStreamer Bad Plug-ins source release</package>
+  <origin>Unknown package origin</origin>
+  <elements>
+    <element>
+      <name>vulkansink</name>
+      <longname>Vulkan video sink</longname>
+      <class>Sink/Video</class>
+      <description>A videosink based on OpenGL</description>
+      <author>Matthew Waters &lt;matthew@centricular.com&gt;</author>
+      <pads>
+        <caps>
+          <name>sink</name>
+          <direction>sink</direction>
+          <presence>always</presence>
+          <details>video/x-raw(memory:VulkanBuffer), format=(string){ RGBA, BGRA, RGB, BGR }, width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], framerate=(fraction)[ 0/1, 2147483647/1 ]</details>
+        </caps>
+      </pads>
+    </element>
+    <element>
+      <name>vulkanupload</name>
+      <longname>Vulkan Uploader</longname>
+      <class>Filter/Video</class>
+      <description>A Vulkan data uploader</description>
+      <author>Matthew Waters &lt;matthew@centricular.com&gt;</author>
+      <pads>
+        <caps>
+          <name>sink</name>
+          <direction>sink</direction>
+          <presence>always</presence>
+          <details>video/x-raw(memory:VulkanBuffer); video/x-raw</details>
+        </caps>
+        <caps>
+          <name>src</name>
+          <direction>source</direction>
+          <presence>always</presence>
+          <details>video/x-raw(memory:VulkanBuffer)</details>
+        </caps>
+      </pads>
+    </element>
+  </elements>
+</plugin>
\ No newline at end of file
diff --git a/docs/plugins/inspect/plugin-waylandsink.xml b/docs/plugins/inspect/plugin-waylandsink.xml
index 99aef7a..1eb4526 100644
--- a/docs/plugins/inspect/plugin-waylandsink.xml
+++ b/docs/plugins/inspect/plugin-waylandsink.xml
@@ -3,7 +3,7 @@
   <description>Wayland Video Sink</description>
   <filename>../../ext/wayland/.libs/libgstwaylandsink.so</filename>
   <basename>libgstwaylandsink.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-webp.xml b/docs/plugins/inspect/plugin-webp.xml
index bfec6f4..7bb3e3b 100644
--- a/docs/plugins/inspect/plugin-webp.xml
+++ b/docs/plugins/inspect/plugin-webp.xml
@@ -3,7 +3,7 @@
   <description>WebP plugin</description>
   <filename>../../ext/webp/.libs/libgstwebp.so</filename>
   <basename>libgstwebp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-webrtcdsp.xml b/docs/plugins/inspect/plugin-webrtcdsp.xml
index 98e8be9..e977165 100644
--- a/docs/plugins/inspect/plugin-webrtcdsp.xml
+++ b/docs/plugins/inspect/plugin-webrtcdsp.xml
@@ -3,7 +3,7 @@
   <description>Voice pre-processing using WebRTC Audio Processing Library</description>
   <filename>../../ext/webrtcdsp/.libs/libgstwebrtcdsp.so</filename>
   <basename>libgstwebrtcdsp.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>WebRTCDsp</package>
diff --git a/docs/plugins/inspect/plugin-wildmidi.xml b/docs/plugins/inspect/plugin-wildmidi.xml
index e3e4d32..f3c75af 100644
--- a/docs/plugins/inspect/plugin-wildmidi.xml
+++ b/docs/plugins/inspect/plugin-wildmidi.xml
@@ -3,7 +3,7 @@
   <description>Wildmidi Plugin</description>
   <filename>../../ext/timidity/.libs/libgstwildmidi.so</filename>
   <basename>libgstwildmidi.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-x265.xml b/docs/plugins/inspect/plugin-x265.xml
index b58cb39..bf51dd8 100644
--- a/docs/plugins/inspect/plugin-x265.xml
+++ b/docs/plugins/inspect/plugin-x265.xml
@@ -3,7 +3,7 @@
   <description>x265-based H265 plugins</description>
   <filename>../../ext/x265/.libs/libgstx265.so</filename>
   <basename>libgstx265.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-y4mdec.xml b/docs/plugins/inspect/plugin-y4mdec.xml
index 351642d..e5d4cb7 100644
--- a/docs/plugins/inspect/plugin-y4mdec.xml
+++ b/docs/plugins/inspect/plugin-y4mdec.xml
@@ -3,7 +3,7 @@
   <description>Demuxes/decodes YUV4MPEG streams</description>
   <filename>../../gst/y4m/.libs/libgsty4mdec.so</filename>
   <basename>libgsty4mdec.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-yadif.xml b/docs/plugins/inspect/plugin-yadif.xml
index d7c00c6..271489e 100644
--- a/docs/plugins/inspect/plugin-yadif.xml
+++ b/docs/plugins/inspect/plugin-yadif.xml
@@ -3,7 +3,7 @@
   <description>YADIF deinterlacing filter</description>
   <filename>../../gst/yadif/.libs/libgstyadif.so</filename>
   <basename>libgstyadif.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>GPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins</package>
diff --git a/docs/plugins/inspect/plugin-zbar.xml b/docs/plugins/inspect/plugin-zbar.xml
index 3cd3107..cd75b4a 100644
--- a/docs/plugins/inspect/plugin-zbar.xml
+++ b/docs/plugins/inspect/plugin-zbar.xml
@@ -3,7 +3,7 @@
   <description>zbar barcode scanner</description>
   <filename>../../ext/zbar/.libs/libgstzbar.so</filename>
   <basename>libgstzbar.so</basename>
-  <version>1.10.2</version>
+  <version>1.10.3</version>
   <license>LGPL</license>
   <source>gst-plugins-bad</source>
   <package>GStreamer Bad Plug-ins source release</package>
diff --git a/ext/chromaprint/gstchromaprint.c b/ext/chromaprint/gstchromaprint.c
index 95600d6..98b3ae3 100644
--- a/ext/chromaprint/gstchromaprint.c
+++ b/ext/chromaprint/gstchromaprint.c
@@ -218,7 +218,7 @@
   chromaprint->nsamples += nsamples;
   chromaprint->duration = chromaprint->nsamples / rate;
 
-  chromaprint_feed (chromaprint->context, map_info.data,
+  chromaprint_feed (chromaprint->context, (gint16 *) map_info.data,
       map_info.size / sizeof (guint16));
 
   if (chromaprint->duration >= chromaprint->max_duration
diff --git a/ext/dash/gstisoff.c b/ext/dash/gstisoff.c
index 38e3ddc..2bddcdb 100644
--- a/ext/dash/gstisoff.c
+++ b/ext/dash/gstisoff.c
@@ -26,6 +26,9 @@
 #include <gst/base/gstbytereader.h>
 
 #include <string.h>
+#include "gstdash_debug.h"
+
+#define GST_CAT_DEFAULT gst_dash_demux_debug
 
 /* gst_isoff_parse_box:
  * @reader:
diff --git a/ext/dtls/gstdtlsagent.c b/ext/dtls/gstdtlsagent.c
index 29aaa3f..4a97c79 100644
--- a/ext/dtls/gstdtlsagent.c
+++ b/ext/dtls/gstdtlsagent.c
@@ -100,10 +100,10 @@
   }
 }
 
-static gulong
-ssl_thread_id_function (void)
+static void
+ssl_thread_id_function (CRYPTO_THREADID * id)
 {
-  return (gulong) g_thread_self ();
+  CRYPTO_THREADID_set_pointer (id, g_thread_self ());
 }
 #endif
 
@@ -138,7 +138,7 @@
         g_rw_lock_init (&ssl_locks[i]);
       }
       CRYPTO_set_locking_callback (ssl_locking_function);
-      CRYPTO_set_id_callback (ssl_thread_id_function);
+      CRYPTO_THREADID_set_callback (ssl_thread_id_function);
     }
 #endif
 
diff --git a/ext/gl/gstgleffects.c b/ext/gl/gstgleffects.c
index 458d95a..cbb2d1c 100644
--- a/ext/gl/gstgleffects.c
+++ b/ext/gl/gstgleffects.c
@@ -279,7 +279,7 @@
   gint i;
 
   base_alloc = (GstGLBaseMemoryAllocator *)
-      gst_gl_memory_allocator_get_default (context);
+      gst_allocator_find (GST_GL_MEMORY_ALLOCATOR_NAME);
   params =
       (GstGLAllocationParams *) gst_gl_video_allocation_params_new (context,
       NULL, &filter->out_info, 0, NULL, GST_GL_TEXTURE_TARGET_2D,
diff --git a/ext/hls/gsthlsdemux-util.c b/ext/hls/gsthlsdemux-util.c
index 252f042..efa1129 100644
--- a/ext/hls/gsthlsdemux-util.c
+++ b/ext/hls/gsthlsdemux-util.c
@@ -265,13 +265,15 @@
 
 static gboolean
 gst_hlsdemux_tsreader_find_pcrs_id3 (GstHLSTSReader * r,
-    GstBuffer * buffer, GstClockTime * first_pcr, GstClockTime * last_pcr)
+    GstBuffer ** buffer_out, GstClockTime * first_pcr, GstClockTime * last_pcr,
+    GstTagList ** tags)
 {
   GstMapInfo info;
   guint32 tag_size;
   gsize size;
   GstTagList *taglist;
   GstSample *priv_data = NULL;
+  GstBuffer *buffer = *buffer_out;
   GstBuffer *tag_buf;
   guint64 pts;
 
@@ -297,10 +299,17 @@
    * not try and read again */
   r->have_id3 = TRUE;
 
+  *buffer_out =
+      gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, tag_size, -1);
+
   /* Parse the tag */
   taglist = gst_tag_list_from_id3v2_tag (buffer);
-  if (taglist == NULL)
+  if (taglist == NULL) {
+    gst_buffer_unref (buffer);
     return TRUE;                /* Invalid tag, stop trying */
+  }
+
+  *tags = taglist;
 
   /* Extract the timestamps */
   if (!gst_tag_list_get_sample (taglist, GST_TAG_PRIVATE_DATA, &priv_data))
@@ -330,19 +339,22 @@
 out:
   if (priv_data)
     gst_sample_unref (priv_data);
-
-  gst_tag_list_unref (taglist);
+  gst_buffer_unref (buffer);
 
   return TRUE;
 }
 
 gboolean
 gst_hlsdemux_tsreader_find_pcrs (GstHLSTSReader * r,
-    GstBuffer * buffer, GstClockTime * first_pcr, GstClockTime * last_pcr)
+    GstBuffer ** buffer, GstClockTime * first_pcr, GstClockTime * last_pcr,
+    GstTagList ** tags)
 {
+  *tags = NULL;
+
   if (r->rtype == GST_HLS_TSREADER_MPEGTS)
-    return gst_hlsdemux_tsreader_find_pcrs_mpegts (r, buffer, first_pcr,
+    return gst_hlsdemux_tsreader_find_pcrs_mpegts (r, *buffer, first_pcr,
         last_pcr);
 
-  return gst_hlsdemux_tsreader_find_pcrs_id3 (r, buffer, first_pcr, last_pcr);
+  return gst_hlsdemux_tsreader_find_pcrs_id3 (r, buffer, first_pcr, last_pcr,
+      tags);
 }
diff --git a/ext/hls/gsthlsdemux.c b/ext/hls/gsthlsdemux.c
index 9247d45..3e82d58 100644
--- a/ext/hls/gsthlsdemux.c
+++ b/ext/hls/gsthlsdemux.c
@@ -767,6 +767,7 @@
   GstHLSDemux *hlsdemux = GST_HLS_DEMUX_CAST (demux);
   GstMapInfo info;
   GstClockTime first_pcr, last_pcr;
+  GstTagList *tags;
 
   if (buffer == NULL)
     return GST_FLOW_OK;
@@ -832,14 +833,18 @@
     hls_stream->pending_pcr_buffer = NULL;
   }
 
-  if (!gst_hlsdemux_tsreader_find_pcrs (&hls_stream->tsreader, buffer,
-          &first_pcr, &last_pcr)
+  if (!gst_hlsdemux_tsreader_find_pcrs (&hls_stream->tsreader, &buffer,
+          &first_pcr, &last_pcr, &tags)
       && !at_eos) {
     // Store this buffer for later
     hls_stream->pending_pcr_buffer = buffer;
     return GST_FLOW_OK;
   }
 
+  if (tags) {
+    gst_adaptive_demux_stream_set_tags (stream, tags);
+  }
+
   if (buffer) {
     buffer = gst_buffer_make_writable (buffer);
     GST_BUFFER_OFFSET (buffer) = hls_stream->current_offset;
diff --git a/ext/hls/gsthlsdemux.h b/ext/hls/gsthlsdemux.h
index f2bc238..4a2b9c0 100644
--- a/ext/hls/gsthlsdemux.h
+++ b/ext/hls/gsthlsdemux.h
@@ -154,8 +154,8 @@
 void gst_hlsdemux_tsreader_init (GstHLSTSReader *r);
 void gst_hlsdemux_tsreader_set_type (GstHLSTSReader *r, GstHLSTSReaderType rtype);
 
-gboolean gst_hlsdemux_tsreader_find_pcrs (GstHLSTSReader *r, GstBuffer *buffer,
-    GstClockTime *first_pcr, GstClockTime *last_pcr);
+gboolean gst_hlsdemux_tsreader_find_pcrs (GstHLSTSReader *r, GstBuffer **buffer,
+    GstClockTime *first_pcr, GstClockTime *last_pcr, GstTagList **tags);
 
 GType gst_hls_demux_get_type (void);
 
diff --git a/ext/opencv/gstmotioncells.cpp b/ext/opencv/gstmotioncells.cpp
index 33f314a..0069634 100644
--- a/ext/opencv/gstmotioncells.cpp
+++ b/ext/opencv/gstmotioncells.cpp
@@ -848,7 +848,7 @@
     int thickness, success, motioncellsidxcnt, numberOfCells,
         motioncellsnumber, cellsOfInterestNumber;
     int mincellsOfInterestNumber, motiondetect;
-    uint minimum_motion_frames, postnomotion;
+    guint minimum_motion_frames, postnomotion;
     char *datafile;
     bool display, changed_datafile, useAlpha;
     gint64 starttime;
diff --git a/gst-libs/gst/adaptivedemux/gstadaptivedemux.c b/gst-libs/gst/adaptivedemux/gstadaptivedemux.c
index bf311d3..1a307c8 100644
--- a/gst-libs/gst/adaptivedemux/gstadaptivedemux.c
+++ b/gst-libs/gst/adaptivedemux/gstadaptivedemux.c
@@ -2507,7 +2507,7 @@
 
         stream->src = NULL;
         GST_DEBUG_OBJECT (demux, "Failed to re-use old source element: %s",
-            err->message);
+            err ? err->message : "Unknown error");
         g_clear_error (&err);
         gst_object_unref (stream->src_srcpad);
         stream->src_srcpad = NULL;
diff --git a/gst-libs/gst/gl/egl/gstglcontext_egl.c b/gst-libs/gst/gl/egl/gstglcontext_egl.c
index 057c6a9..7bc1207 100644
--- a/gst-libs/gst/gl/egl/gstglcontext_egl.c
+++ b/gst-libs/gst/gl/egl/gstglcontext_egl.c
@@ -481,9 +481,13 @@
     for (i = 0; i < G_N_ELEMENTS (gles2_versions); i++) {
       gint profileMask = 0;
       gint contextFlags = 0;
+      guint maj = gles2_versions[i].major;
+      guint min = gles2_versions[i].minor;
 
-      if (!gst_gl_context_egl_choose_config (egl, GST_GL_API_GLES2,
-              gles2_versions[i].major, error)) {
+      if (!gst_gl_context_egl_choose_config (egl, GST_GL_API_GLES2, maj, error)) {
+        GST_DEBUG_OBJECT (context, "Failed to choose a GLES%d config: %s",
+            maj, error && *error ? (*error)->message : "Unknown");
+        g_clear_error (error);
         continue;
       }
 #if defined(EGL_KHR_create_context)
@@ -492,8 +496,7 @@
 
       egl->egl_context =
           _create_context_with_flags (egl, (EGLContext) external_gl_context,
-          GST_GL_API_GLES2, gles2_versions[i].major,
-          gles2_versions[i].minor, contextFlags, profileMask);
+          GST_GL_API_GLES2, maj, min, contextFlags, profileMask);
 
       if (egl->egl_context)
         break;
@@ -504,8 +507,7 @@
 
       egl->egl_context =
           _create_context_with_flags (egl, (EGLContext) external_gl_context,
-          GST_GL_API_GLES2, gles2_versions[i].major,
-          gles2_versions[i].minor, contextFlags, profileMask);
+          GST_GL_API_GLES2, maj, min, contextFlags, profileMask);
 
       if (egl->egl_context)
         break;
diff --git a/gst-libs/gst/gl/gstglbuffer.h b/gst-libs/gst/gl/gstglbuffer.h
index b939310..f139f2d 100644
--- a/gst-libs/gst/gl/gstglbuffer.h
+++ b/gst-libs/gst/gl/gstglbuffer.h
@@ -126,13 +126,6 @@
 GST_EXPORT
 gboolean      gst_is_gl_buffer        (GstMemory * mem);
 
-GST_EXPORT
-GstGLBuffer * gst_gl_buffer_alloc     (GstGLContext * context,
-                                       guint gl_target,
-                                       guint gl_usage,
-                                       GstAllocationParams * params,
-                                       gsize maxsize);
-
 G_END_DECLS
 
 #endif /* _GST_GL_BUFFER_H_ */
diff --git a/gst-libs/gst/gl/gstglslstage.c b/gst-libs/gst/gl/gstglslstage.c
index 708dff1..60a5af7 100644
--- a/gst-libs/gst/gl/gstglslstage.c
+++ b/gst-libs/gst/gl/gstglslstage.c
@@ -27,6 +27,19 @@
 #include "gstglslstage.h"
 #include "gstglsl_private.h"
 
+#ifndef GL_GEOMETRY_SHADER
+#define GL_GEOMETRY_SHADER        0x8DD9
+#endif
+#ifndef GL_COMPUTE_SHADER
+#define GL_COMPUTE_SHADER         0x91B9
+#endif
+#ifndef GL_TESS_CONTROL_SHADER
+#define GL_TESS_CONTROL_SHADER    0x8E88
+#endif
+#ifndef GL_TESS_EVALUATION_SHADER
+#define GL_TESS_EVALUATION_SHADER 0x8E87
+#endif
+
 /**
  * SECTION:gstglslstage
  * @short_description: object for dealing with OpenGL shader stages
@@ -130,18 +143,10 @@
   switch (type) {
     case GL_VERTEX_SHADER:
     case GL_FRAGMENT_SHADER:
-#ifdef GL_TESS_CONTROL_SHADER
     case GL_TESS_CONTROL_SHADER:
-#endif
-#ifdef GL_TESS_EVALUATION_SHADER
     case GL_TESS_EVALUATION_SHADER:
-#endif
-#ifdef GL_GEOMETRY_SHADER
     case GL_GEOMETRY_SHADER:
-#endif
-#ifdef GL_COMPUTE_SHADER
     case GL_COMPUTE_SHADER:
-#endif
       return TRUE;
     default:
       return FALSE;
@@ -156,22 +161,14 @@
       return "vertex";
     case GL_FRAGMENT_SHADER:
       return "fragment";
-#ifdef GL_TESS_CONTROL_SHADER
     case GL_TESS_CONTROL_SHADER:
       return "tesselation control";
-#endif
-#ifdef GL_TESS_EVALUATION_SHADER
     case GL_TESS_EVALUATION_SHADER:
       return "tesselation evaluation";
-#endif
-#ifdef GL_GEOMETRY_SHADER
     case GL_GEOMETRY_SHADER:
       return "geometry";
-#endif
-#ifdef GL_COMPUTE_SHADER
     case GL_COMPUTE_SHADER:
       return "compute";
-#endif
     default:
       return "unknown";
   }
diff --git a/gst-libs/gst/gl/gstglwindow.c b/gst-libs/gst/gl/gstglwindow.c
index 7a275e4..e037ad2 100644
--- a/gst-libs/gst/gl/gstglwindow.c
+++ b/gst-libs/gst/gl/gstglwindow.c
@@ -88,7 +88,6 @@
 
 struct _GstGLWindowPrivate
 {
-  GMainContext *main_context;
   GMainLoop *loop;
 
   guint surface_width;
@@ -180,8 +179,8 @@
   g_mutex_init (&window->priv->sync_message_lock);
   g_cond_init (&window->priv->sync_message_cond);
 
-  priv->main_context = g_main_context_new ();
-  priv->loop = g_main_loop_new (priv->main_context, FALSE);
+  window->main_context = g_main_context_new ();
+  priv->loop = g_main_loop_new (window->main_context, FALSE);
   priv->navigation_loop = NULL;
 }
 
@@ -329,8 +328,9 @@
   if (priv->loop)
     g_main_loop_unref (priv->loop);
 
-  if (priv->main_context)
-    g_main_context_unref (priv->main_context);
+  if (window->main_context)
+    g_main_context_unref (window->main_context);
+  window->main_context = NULL;
 
   g_weak_ref_clear (&window->context_ref);
 
@@ -522,27 +522,11 @@
 {
   GstGLWindowPrivate *priv = window->priv;
 
-  if (g_main_context_get_thread_default ()) {
-    if (priv->main_context)
-      g_main_context_unref (priv->main_context);
-    if (priv->loop)
-      g_main_loop_unref (priv->loop);
-    priv->main_context = g_main_context_ref_thread_default ();
-    priv->loop = NULL;
-    priv->alive = TRUE;
-  } else {
-    g_main_context_push_thread_default (priv->main_context);
-  }
+  g_main_context_push_thread_default (window->main_context);
 
   g_main_loop_run (priv->loop);
 
-  if (!priv->loop) {
-    priv->alive = FALSE;
-    g_main_context_unref (priv->main_context);
-    priv->main_context = NULL;
-  } else {
-    g_main_context_pop_thread_default (priv->main_context);
-  }
+  g_main_context_pop_thread_default (window->main_context);
 }
 
 /**
@@ -702,7 +686,7 @@
   message->data = data;
   message->destroy = destroy;
 
-  g_main_context_invoke (priv->main_context, (GSourceFunc) _run_message_async,
+  g_main_context_invoke (window->main_context, (GSourceFunc) _run_message_async,
       message);
 }
 
diff --git a/gst-libs/gst/gl/gstglwindow.h b/gst-libs/gst/gl/gstglwindow.h
index a5cc5b4..2aacac2 100644
--- a/gst-libs/gst/gl/gstglwindow.h
+++ b/gst-libs/gst/gl/gstglwindow.h
@@ -79,6 +79,7 @@
 
   guintptr      external_gl_context;
 
+  /*< protected >*/
   gboolean      is_drawing;
 
   GstGLWindowCB         draw;
@@ -93,6 +94,8 @@
 
   gboolean              queue_resize;
 
+  GMainContext         *main_context; /* default main_context */
+
   /*< private >*/
   GstGLWindowPrivate *priv;
 
diff --git a/gst-libs/gst/gl/wayland/gstglwindow_wayland_egl.c b/gst-libs/gst/gl/wayland/gstglwindow_wayland_egl.c
index 6e1f0c5..338daed 100644
--- a/gst-libs/gst/gl/wayland/gstglwindow_wayland_egl.c
+++ b/gst-libs/gst/gl/wayland/gstglwindow_wayland_egl.c
@@ -408,7 +408,7 @@
   if (!GST_GL_WINDOW_CLASS (parent_class)->open (window, error))
     return FALSE;
 
-  g_source_attach (window_egl->wl_source, g_main_context_get_thread_default ());
+  g_source_attach (window_egl->wl_source, window->main_context);
 
   return TRUE;
 }
diff --git a/gst-libs/gst/gl/win32/gstglwindow_win32.c b/gst-libs/gst/gl/win32/gstglwindow_win32.c
index 2c919cd..8f31825 100644
--- a/gst-libs/gst/gl/win32/gstglwindow_win32.c
+++ b/gst-libs/gst/gl/win32/gstglwindow_win32.c
@@ -120,8 +120,7 @@
   window_win32->msg_source = win32_message_source_new (window_win32);
   g_source_set_callback (window_win32->msg_source, (GSourceFunc) msg_cb,
       NULL, NULL);
-  g_source_attach (window_win32->msg_source,
-      g_main_context_get_thread_default ());
+  g_source_attach (window_win32->msg_source, window->main_context);
 
   return TRUE;
 }
diff --git a/gst-libs/gst/video/gstvideoaggregator.c b/gst-libs/gst/video/gstvideoaggregator.c
index cd42d7e..62fea27 100644
--- a/gst-libs/gst/video/gstvideoaggregator.c
+++ b/gst-libs/gst/video/gstvideoaggregator.c
@@ -796,8 +796,6 @@
         GstVideoAggregatorPad *pad = GST_VIDEO_AGGREGATOR_PAD (l->data);
 
         if (!vaggpad_klass->set_info (pad, vagg, &pad->info, &vagg->info)) {
-          GST_OBJECT_UNLOCK (vagg);
-
           return FALSE;
         }
       }
diff --git a/gst-plugins-bad.doap b/gst-plugins-bad.doap
index 78fe530..3aa2022 100644
--- a/gst-plugins-bad.doap
+++ b/gst-plugins-bad.doap
@@ -35,6 +35,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-bad/gst-plugins-bad-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-bad.spec b/gst-plugins-bad.spec
index 87a344f..ec6d8ce 100644
--- a/gst-plugins-bad.spec
+++ b/gst-plugins-bad.spec
@@ -6,7 +6,7 @@
 
 Summary: GStreamer streaming media framework "bad" plug-ins
 Name: %{gstreamer}-plugins-bad
-Version: 1.10.2
+Version: 1.10.3
 Release: 1.gst
 # The freeze and nfs plugins are LGPLv2 (only)
 License: LGPLv2+ and LGPLv2
diff --git a/gst/autoconvert/gstautoconvert.c b/gst/autoconvert/gstautoconvert.c
index 77e095a..4761f44 100644
--- a/gst/autoconvert/gstautoconvert.c
+++ b/gst/autoconvert/gstautoconvert.c
@@ -1186,7 +1186,8 @@
     GST_WARNING_OBJECT (autoconvert,
         "Got upstream event while no element was selected," "forwarding.");
     ret = gst_pad_push_event (autoconvert->sinkpad, event);
-  }
+  } else
+    gst_event_unref (event);
 
   return ret;
 }
diff --git a/gst/dvdspu/gstspu-vobsub-render.c b/gst/dvdspu/gstspu-vobsub-render.c
index d55b1bf..f4649e9 100644
--- a/gst/dvdspu/gstspu-vobsub-render.c
+++ b/gst/dvdspu/gstspu-vobsub-render.c
@@ -426,6 +426,7 @@
   gint y, last_y;
   gint width, height;
   gint strides[3];
+  gint offset_index = 0;
 
   /* Set up our initial state */
   if (G_UNLIKELY (state->vobsub.pix_buf == NULL))
@@ -534,7 +535,7 @@
     state->vobsub.clip_rect.top = state->vobsub.disp_rect.top;
     state->vobsub.clip_rect.bottom = state->vobsub.disp_rect.bottom;
 
-    /* clip right after the shift */
+    /* clip bottom after the shift */
     if (state->vobsub.clip_rect.bottom >= height)
       state->vobsub.clip_rect.bottom = height - 1;
 
@@ -545,18 +546,48 @@
 
   /* We start rendering from the first line of the display rect */
   y = state->vobsub.disp_rect.top;
-  /* start_y is always an even number and we render lines in pairs from there,
+  /* We render most lines in pairs starting from an even y,
    * accumulating 2 lines of chroma then blending it. We might need to render a
-   * single line at the end if the display rect ends on an even line too. */
-  last_y = (state->vobsub.disp_rect.bottom - 1) & ~(0x01);
+   * single line at the start and end if the display rect starts on an odd line
+   * or ends on an even one */
+  if (y > state->vobsub.disp_rect.bottom)
+    return;                     /* Empty clip rect, nothing to do */
 
   /* Update our plane references to the first line of the disp_rect */
   planes[0] += strides[0] * y;
   planes[1] += strides[1] * (y / 2);
   planes[2] += strides[2] * (y / 2);
 
-  for (state->vobsub.cur_Y = y; state->vobsub.cur_Y <= last_y;
-      state->vobsub.cur_Y++) {
+  /* If the render rect starts on an odd line, render that only to start */
+  state->vobsub.cur_Y = y;
+  if (state->vobsub.cur_Y & 0x1) {
+    gboolean clip, visible = FALSE;
+
+    clip = (state->vobsub.cur_Y < state->vobsub.clip_rect.top
+        || state->vobsub.cur_Y > state->vobsub.clip_rect.bottom);
+
+    if (!clip) {
+      /* Render a first odd line. */
+      gstspu_vobsub_clear_comp_buffers (state);
+      state->vobsub.comp_last_x_ptr = state->vobsub.comp_last_x + 1;
+      visible |=
+          gstspu_vobsub_render_line (state, planes,
+          &state->vobsub.cur_offsets[offset_index]);
+      if (visible)
+        gstspu_vobsub_blend_comp_buffers (state, planes);
+    }
+
+    /* Update all the output pointers */
+    state->vobsub.cur_Y++;
+    planes[0] += strides[0];
+    planes[1] += strides[1];
+    planes[2] += strides[2];
+    /* Switch the offset index 0 <=> 1 */
+    offset_index ^= 0x1;
+  }
+
+  last_y = (state->vobsub.disp_rect.bottom - 1) & ~(0x01);
+  for (; state->vobsub.cur_Y <= last_y; state->vobsub.cur_Y++) {
     gboolean clip, visible = FALSE;
 
     clip = (state->vobsub.cur_Y < state->vobsub.clip_rect.top
@@ -566,10 +597,13 @@
     gstspu_vobsub_clear_comp_buffers (state);
     /* Render even line */
     state->vobsub.comp_last_x_ptr = state->vobsub.comp_last_x;
-    gstspu_vobsub_render_line (state, planes, &state->vobsub.cur_offsets[0]);
+    gstspu_vobsub_render_line (state, planes,
+        &state->vobsub.cur_offsets[offset_index]);
 
     /* Advance the luminance output pointer */
     planes[0] += strides[0];
+    /* Switch the offset index 0 <=> 1 */
+    offset_index ^= 0x1;
 
     state->vobsub.cur_Y++;
 
@@ -577,7 +611,7 @@
     state->vobsub.comp_last_x_ptr = state->vobsub.comp_last_x + 1;
     visible |=
         gstspu_vobsub_render_line (state, planes,
-        &state->vobsub.cur_offsets[1]);
+        &state->vobsub.cur_offsets[offset_index]);
 
     if (visible && !clip) {
       /* Blend the accumulated UV compositing buffers onto the output */
@@ -588,6 +622,8 @@
     planes[0] += strides[0];
     planes[1] += strides[1];
     planes[2] += strides[2];
+    /* Switch the offset index 0 <=> 1 */
+    offset_index ^= 0x1;
   }
 
   if (state->vobsub.cur_Y == state->vobsub.disp_rect.bottom) {
@@ -596,7 +632,7 @@
     clip = (state->vobsub.cur_Y < state->vobsub.clip_rect.top
         || state->vobsub.cur_Y > state->vobsub.clip_rect.bottom);
 
-    g_assert ((state->vobsub.disp_rect.bottom & 0x01) == 0);
+    g_return_if_fail ((state->vobsub.disp_rect.bottom & 0x01) == 0);
 
     if (!clip) {
       /* Render a remaining lone last even line. y already has the correct value
@@ -605,7 +641,7 @@
       state->vobsub.comp_last_x_ptr = state->vobsub.comp_last_x;
       visible |=
           gstspu_vobsub_render_line (state, planes,
-          &state->vobsub.cur_offsets[0]);
+          &state->vobsub.cur_offsets[offset_index]);
       if (visible)
         gstspu_vobsub_blend_comp_buffers (state, planes);
     }
diff --git a/gst/geometrictransform/gstmirror.h b/gst/geometrictransform/gstmirror.h
index 2084f2c..22e6aa5 100644
--- a/gst/geometrictransform/gstmirror.h
+++ b/gst/geometrictransform/gstmirror.h
@@ -66,7 +66,7 @@
 typedef struct _GstMirrorClass GstMirrorClass;
 
 /**
- * GstColorEffectsPreset:
+ * GstMirrorMode:
  * @GST_MIRROR_MODE_LEFT: Split horizontally and reflect left into right
  * @GST_MIRROR_MODE_RIGHT: Split horizontally and reflect right into left
  * @GST_MIRROR_MODE_TOP: Split horizontally and reflect top into bottom
diff --git a/gst/mpegpsmux/mpegpsmux.c b/gst/mpegpsmux/mpegpsmux.c
index fdd1c14..cdd3681 100644
--- a/gst/mpegpsmux/mpegpsmux.c
+++ b/gst/mpegpsmux/mpegpsmux.c
@@ -341,6 +341,7 @@
   }
 
 beach:
+  gst_caps_unref (caps);
   return ret;
 }
 
diff --git a/gst/mpegtsdemux/mpegtsbase.c b/gst/mpegtsdemux/mpegtsbase.c
index a36ed41..ee2460c 100644
--- a/gst/mpegtsdemux/mpegtsbase.c
+++ b/gst/mpegtsdemux/mpegtsbase.c
@@ -1243,7 +1243,9 @@
 
           if (gst_mpegts_descriptor_parse_dvb_short_event (desc, NULL, &name,
                   &text)) {
-            program->tags = gst_tag_list_new_empty ();
+            if (!program->tags)
+              program->tags = gst_tag_list_new_empty ();
+
             if (name) {
               gst_tag_list_add (program->tags, GST_TAG_MERGE_APPEND,
                   GST_TAG_TITLE, name, NULL);
diff --git a/gst/mpegtsdemux/tsdemux.c b/gst/mpegtsdemux/tsdemux.c
index c701c37..20357a8 100644
--- a/gst/mpegtsdemux/tsdemux.c
+++ b/gst/mpegtsdemux/tsdemux.c
@@ -1366,9 +1366,6 @@
 
               if (channels != -1) {
                 is_audio = TRUE;
-                template = gst_static_pad_template_get (&audio_template);
-                name = g_strdup_printf ("audio_%04x", bstream->pid);
-
                 caps =
                     gst_codec_utils_opus_create_caps (48000, channels,
                     mapping_family, stream_count, coupled_count,
@@ -1621,15 +1618,15 @@
           GST_STREAM_FLAG_SPARSE);
     }
     stream->sparse = sparse;
-
-    gst_pad_push_event (pad, event);
-    gst_pad_set_caps (pad, caps);
     gst_stream_set_caps (bstream->stream_object, caps);
     if (!stream->taglist)
       stream->taglist = gst_tag_list_new_empty ();
     gst_pb_utils_add_codec_description_to_tag_list (stream->taglist, NULL,
         caps);
     gst_stream_set_tags (bstream->stream_object, stream->taglist);
+
+    gst_pad_push_event (pad, event);
+    gst_pad_set_caps (pad, caps);
     gst_pad_set_query_function (pad, gst_ts_demux_srcpad_query);
     gst_pad_set_event_function (pad, gst_ts_demux_srcpad_event);
   }
diff --git a/gst/mxf/mxfdemux.c b/gst/mxf/mxfdemux.c
index a380f6d..54ceec1 100644
--- a/gst/mxf/mxfdemux.c
+++ b/gst/mxf/mxfdemux.c
@@ -835,6 +835,7 @@
         etrack->mapping_data = NULL;
         if (etrack->tags)
           gst_tag_list_unref (etrack->tags);
+        etrack->tags = NULL;
         goto next;
       } else if (!caps) {
         GST_WARNING_OBJECT (demux, "Couldn't create updated caps for stream");
diff --git a/gst/rawparse/gstrawvideoparse.c b/gst/rawparse/gstrawvideoparse.c
index 3808369..27ba047 100644
--- a/gst/rawparse/gstrawvideoparse.c
+++ b/gst/rawparse/gstrawvideoparse.c
@@ -300,7 +300,7 @@
       PROP_PLANE_STRIDES,
       g_param_spec_value_array ("plane-strides",
           "Plane strides",
-          "Strides of the planets in bytes",
+          "Strides of the planes in bytes",
           g_param_spec_uint ("plane-stride",
               "Plane stride",
               "Stride of the n-th plane in bytes (0 = stride equals width*bytes-per-pixel)",
@@ -313,7 +313,7 @@
       PROP_PLANE_OFFSETS,
       g_param_spec_value_array ("plane-offsets",
           "Plane offsets",
-          "Offsets of the planets in bytes",
+          "Offsets of the planes in bytes",
           g_param_spec_uint ("plane-offset",
               "Plane offset",
               "Offset of the n-th plane in bytes",
diff --git a/gst/vmnc/vmncdec.c b/gst/vmnc/vmncdec.c
index b3c9778..cbbaeb6 100644
--- a/gst/vmnc/vmncdec.c
+++ b/gst/vmnc/vmncdec.c
@@ -785,7 +785,8 @@
                 r.type);
             return ERROR_INVALID;
           }
-          if (r.x + r.width > dec->format.width ||
+          if (r.x > dec->format.width || r.y > dec->format.height ||
+              r.x + r.width > dec->format.width ||
               r.y + r.height > dec->format.height) {
             GST_WARNING_OBJECT (dec, "Rectangle out of range, type %d", r.type);
             return ERROR_INVALID;
diff --git a/pkgconfig/gstreamer-bad-audio.pc.in b/pkgconfig/gstreamer-bad-audio.pc.in
index be90d67..fa90010 100644
--- a/pkgconfig/gstreamer-bad-audio.pc.in
+++ b/pkgconfig/gstreamer-bad-audio.pc.in
@@ -9,5 +9,5 @@
 Version: @VERSION@
 Requires: gstreamer-@GST_API_VERSION@ gstreamer-bad-base-@GST_API_VERSION@
 
-Libs: -L${libdir} ${libdir}/libgstbadaudio-@GST_API_VERSION@.la
+Libs: -L${libdir} -gstbadaudio-@GST_API_VERSION@
 Cflags: -I${includedir}
diff --git a/pkgconfig/gstreamer-bad-base.pc.in b/pkgconfig/gstreamer-bad-base.pc.in
index 10afe0e..cf46745 100644
--- a/pkgconfig/gstreamer-bad-base.pc.in
+++ b/pkgconfig/gstreamer-bad-base.pc.in
@@ -12,5 +12,5 @@
 Version: @VERSION@
 Requires: gstreamer-@GST_API_VERSION@
 
-Libs: -L${libdir} ${libdir}/libgstbadbase-@GST_API_VERSION@.la
+Libs: -L${libdir} -lgstbadbase-@GST_API_VERSION@
 Cflags: -I${includedir}
diff --git a/pkgconfig/gstreamer-bad-video.pc.in b/pkgconfig/gstreamer-bad-video.pc.in
index 40127be..43a54c0 100644
--- a/pkgconfig/gstreamer-bad-video.pc.in
+++ b/pkgconfig/gstreamer-bad-video.pc.in
@@ -12,5 +12,5 @@
 Version: @VERSION@
 Requires: gstreamer-@GST_API_VERSION@ gstreamer-bad-base-@GST_API_VERSION@
 
-Libs: -L${libdir} ${libdir}/libgstbadvideo-@GST_API_VERSION@.la
+Libs: -L${libdir} -lgstbadvideo-@GST_API_VERSION@
 Cflags: -I${includedir}
diff --git a/po/af.gmo b/po/af.gmo
index 72c32a8..3db4190 100644
--- a/po/af.gmo
+++ b/po/af.gmo
Binary files differ
diff --git a/po/af.po b/po/af.po
index 0e16b39..62b2b71 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:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/az.gmo b/po/az.gmo
index f6c9536..e7a7253 100644
--- a/po/az.gmo
+++ b/po/az.gmo
Binary files differ
diff --git a/po/az.po b/po/az.po
index 32f7c2b..fcbff29 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:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/bg.gmo b/po/bg.gmo
index 49ec4c6..07b2eb7 100644
--- a/po/bg.gmo
+++ b/po/bg.gmo
Binary files differ
diff --git a/po/bg.po b/po/bg.po
index b4487eb..e4fd47e 100644
--- a/po/bg.po
+++ b/po/bg.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/ca.gmo b/po/ca.gmo
index bca5133..29f4217 100644
--- a/po/ca.gmo
+++ b/po/ca.gmo
Binary files differ
diff --git a/po/ca.po b/po/ca.po
index ccda1cb..42151c5 100644
--- a/po/ca.po
+++ b/po/ca.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/cs.gmo b/po/cs.gmo
index 850e58b..a89fd6c 100644
--- a/po/cs.gmo
+++ b/po/cs.gmo
Binary files differ
diff --git a/po/cs.po b/po/cs.po
index 77ab332..00f8532 100644
--- a/po/cs.po
+++ b/po/cs.po
@@ -11,7 +11,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.6.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2015-10-15 20:54+0200\n"
 "Last-Translator: Marek Černocký <marek@manet.cz>\n"
 "Language-Team: Czech <translation-team-cs@lists.sourceforge.net>\n"
diff --git a/po/da.gmo b/po/da.gmo
index d24ab54..fb1df2d 100644
--- a/po/da.gmo
+++ b/po/da.gmo
Binary files differ
diff --git a/po/da.po b/po/da.po
index bd90d18..84e65bb 100644
--- a/po/da.po
+++ b/po/da.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-03 11:28+0200\n"
 "Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
 "Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
diff --git a/po/de.gmo b/po/de.gmo
index 585f773..7596d1b 100644
--- a/po/de.gmo
+++ b/po/de.gmo
Binary files differ
diff --git a/po/de.po b/po/de.po
index d068781..e7d982f 100644
--- a/po/de.po
+++ b/po/de.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-02 19:18+0100\n"
 "Last-Translator: Christian Kirbach <christian.kirbach@gmail.com>\n"
 "Language-Team: German <translation-team-de@lists.sourceforge.net>\n"
diff --git a/po/el.gmo b/po/el.gmo
index 22097b4..538e5cd 100644
--- a/po/el.gmo
+++ b/po/el.gmo
Binary files differ
diff --git a/po/el.po b/po/el.po
index 6f248c4..35d295a 100644
--- a/po/el.po
+++ b/po/el.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2012-05-05 19:17+0100\n"
 "Last-Translator: Savvas Radevic <vicedar@gmail.com>\n"
 "Language-Team: Greek <team@lists.gnome.gr>\n"
diff --git a/po/en_GB.gmo b/po/en_GB.gmo
index 7d0abe1..dbd4eb9 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 8341e78..b08d81b 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:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/eo.gmo b/po/eo.gmo
index 303ce32..a5b259b 100644
--- a/po/eo.gmo
+++ b/po/eo.gmo
Binary files differ
diff --git a/po/eo.po b/po/eo.po
index 21ce85c..d96def2 100644
--- a/po/eo.po
+++ b/po/eo.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2011-06-04 22:18+0200\n"
 "Last-Translator: Kristjan SCHMIDT <kristjan.schmidt@googlemail.com>\n"
 "Language-Team: Esperanto <translation-team-eo@lists.sourceforge.net>\n"
diff --git a/po/es.gmo b/po/es.gmo
index d08d44a..7e71f3a 100644
--- a/po/es.gmo
+++ b/po/es.gmo
Binary files differ
diff --git a/po/es.po b/po/es.po
index d192f14..8e7908b 100644
--- a/po/es.po
+++ b/po/es.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2011-10-02 15:47+0200\n"
 "Last-Translator: Jorge González González <aloriel@gmail.com>\n"
 "Language-Team: Spanish <es@li.org>\n"
diff --git a/po/eu.gmo b/po/eu.gmo
index ed6c2e7..bcb6999 100644
--- a/po/eu.gmo
+++ b/po/eu.gmo
Binary files differ
diff --git a/po/eu.po b/po/eu.po
index 5efc36c..e24bec9 100644
--- a/po/eu.po
+++ b/po/eu.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2010-03-25 12:30+0100\n"
 "Last-Translator: Mikel Olasagasti Uranga <hey_neken@mundurat.net>\n"
 "Language-Team: Basque <translation-team-eu@lists.sourceforge.net>\n"
diff --git a/po/fi.gmo b/po/fi.gmo
index f64759f..4152c1b 100644
--- a/po/fi.gmo
+++ b/po/fi.gmo
Binary files differ
diff --git a/po/fi.po b/po/fi.po
index ec41403..8681d1d 100644
--- a/po/fi.po
+++ b/po/fi.po
@@ -11,7 +11,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.13.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2009-08-12 22:13+0300\n"
 "Last-Translator: Tommi Vainikainen <Tommi.Vainikainen@iki.fi>\n"
 "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
diff --git a/po/fr.gmo b/po/fr.gmo
index 5ff6255..fd66452 100644
--- a/po/fr.gmo
+++ b/po/fr.gmo
Binary files differ
diff --git a/po/fr.po b/po/fr.po
index 95790c5..b8f305f 100644
--- a/po/fr.po
+++ b/po/fr.po
@@ -3,26 +3,27 @@
 # This file is distributed under the same license as the gst-plugins-bad package.
 #
 # Claude Paroz <claude@2xlibre.net>, 2008-2011.
-# Stéphane Aulery <lkppo@free.fr>, 2015.
+# Stéphane Aulery <lkppo@free.fr>, 2015-2016.
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-bad 1.7.2\n"
+"Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
-"PO-Revision-Date: 2016-02-20 16:27+0100\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
+"PO-Revision-Date: 2016-12-23 20:45+0100\n"
 "Last-Translator: Stéphane Aulery <lkppo@free.fr>\n"
 "Language-Team: French <traduc@traduc.org>\n"
 "Language: fr\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"X-Bugs: Report translation errors to the Language-Team address.\n"
 
 msgid "failed to draw pattern"
-msgstr ""
+msgstr "échec du rendu de motif"
 
 msgid "A GL error occured"
-msgstr ""
+msgstr "Une erreur de rendu GL s’est produite"
 
 msgid "format wasn't negotiated before get function"
 msgstr "Format non négocié avant l'appel de la fonction get"
@@ -130,148 +131,28 @@
 msgid "Could not open file \"%s\" for reading."
 msgstr "Impossible d’ouvrir le fichier « %s » en lecture."
 
-#, fuzzy
 msgid "Couldn't find channel configuration file"
-msgstr "Impossible de trouver le fichier de configuration de canal DVB"
+msgstr "Impossible de trouver le fichier de configuration de canal"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't load channel configuration file: '%s'"
-msgstr "Impossible de charger le fichier de configuration de canal DVB : %s"
+msgstr "Impossible de charger le fichier de configuration du canal « %s »"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find details for channel '%s'"
-msgstr "Impossible de trouver des informations sur le canal DVB %s"
+msgstr "Impossible de trouver des informations sur le canal « %s »"
 
-#, fuzzy, c-format
+#, c-format
 msgid "No properties for channel '%s'"
-msgstr "Impossible de trouver des informations sur le canal DVB %s"
+msgstr "Aucun réglage pour le canal « %s »"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Failed to set properties for channel '%s'"
-msgstr "Impossible de trouver des informations sur le canal DVB %s"
+msgstr "Impossible d’enregistrer le réglage du canal « %s »."
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find channel configuration file: '%s'"
-msgstr "Impossible de trouver le fichier de configuration de canal DVB"
+msgstr "Impossible de trouver le fichier de configuration du canal « %s »"
 
-#, fuzzy
 msgid "Channel configuration file doesn't contain any channels"
-msgstr "Le fichier de configuration de canal DVB ne contient aucun canal"
-
-#~ msgid "Internal data flow error."
-#~ msgstr "Erreur du flux de données interne."
-
-#~ msgid "default GStreamer sound events audiosink"
-#~ msgstr "récepteur audio GStreamer par défaut pour les événements sonores"
-
-#~ msgid ""
-#~ "GStreamer can play audio using any number of output elements. Some "
-#~ "possible choices are osssink, pulsesink and alsasink. The audiosink can "
-#~ "be a partial pipeline instead of just one element."
-#~ msgstr ""
-#~ "GStreamer peut lire des sons depuis un nombre quelconque d’éléments en "
-#~ "entrée. Les choix possibles sont osssink, pulsesink et alsasink. Le "
-#~ "source audio peut être un pipeline partiel au lieu d’un élément unique."
-
-#~ msgid "description for default GStreamer sound events audiosink"
-#~ msgstr ""
-#~ "description du récepteur audio GStreamer par défaut pour les événements "
-#~ "sonores"
-
-#~ msgid "Describes the selected audiosink element."
-#~ msgstr "Décrit le récepteur audio sélectionné."
-
-#~ msgid "default GStreamer audiosink for Audio/Video Conferencing"
-#~ msgstr ""
-#~ "récepteur audio GStreamer par défaut pour les confèrences audiovisuelles"
-
-#~ msgid ""
-#~ "description for default GStreamer audiosink for Audio/Video Conferencing"
-#~ msgstr ""
-#~ "description du récepteur audio GStreamer par défaut pour les confèrences "
-#~ "audiovisuelles"
-
-#~ msgid "default GStreamer audiosink for Music and Movies"
-#~ msgstr "récepteur audio GStreamer par défaut pour la musique et les films"
-
-#~ msgid "description for default GStreamer audiosink for Music and Movies"
-#~ msgstr ""
-#~ "description du récepteur audio GStreamer par défaut pour la musique et "
-#~ "les films"
-
-#~ msgid "default GStreamer videosink"
-#~ msgstr "récepteur vidéo GStreamer par défaut"
-
-#~ msgid ""
-#~ "GStreamer can play video using any number of output elements. Some "
-#~ "possible choices are xvimagesink, ximagesink, sdlvideosink and aasink. "
-#~ "The videosink can be a partial pipeline instead of just one element."
-#~ msgstr ""
-#~ "GStreamer peut lire une vidéo depuis un nombre quelconque d’éléments en "
-#~ "entrée. Les choix possibles sont xvimagesink, ximagesink, sdlvideosink et "
-#~ "aasink. Le source vidéo peut être un pipeline partiel au lieu d’un "
-#~ "élément unique."
-
-#~ msgid "description for default GStreamer videosink"
-#~ msgstr "description du récepteur vidéo GStreamer par défaut"
-
-#~ msgid "Describes the selected videosink element."
-#~ msgstr "Décrit le récepteur vidéo sélectionné."
-
-#~ msgid "default GStreamer audiosrc"
-#~ msgstr "source audio GStreamer par défaut"
-
-#~ msgid ""
-#~ "GStreamer can record audio using any number of input elements. Some "
-#~ "possible choices are osssrc, pulsesrc and alsasrc. The audio source can "
-#~ "be a partial pipeline instead of just one element."
-#~ msgstr ""
-#~ "GStreamer peut enregistrer des sons depuis un nombre quelconque "
-#~ "d’éléments en entrée. Les choix possibles sont osssrc, pulsesrc et "
-#~ "alsasrc. Le source audio peut être un pipeline partiel au lieu d’un "
-#~ "élément unique."
-
-#~ msgid "description for default GStreamer audiosrc"
-#~ msgstr "description de la source audio GStreamer par défaut"
-
-#~ msgid "Describes the selected audiosrc element."
-#~ msgstr "Décrit la source audio sélectionnée."
-
-#~ msgid "default GStreamer videosrc"
-#~ msgstr "source vidéo GStreamer par défaut"
-
-#~ msgid ""
-#~ "GStreamer can record video from any number of input elements. Some "
-#~ "possible choices are v4lsrc, v4l2src and videotestsrc. The video source "
-#~ "can be a partial pipeline instead of just one element."
-#~ msgstr ""
-#~ "GStreamer peut enregistrer une vidéo depuis un nombre quelconque "
-#~ "d’éléments en entrée. Les choix possibles sont v4lsrc, v4l2src et "
-#~ "videotestsrc. Le source vidéo peut être un pipeline partiel au lieu d’un "
-#~ "élément unique."
-
-#~ msgid "description for default GStreamer videosrc"
-#~ msgstr "description de la source vidéo GStreamer par défaut"
-
-#~ msgid "Describes the selected videosrc element."
-#~ msgstr "Décrit la source vidéo sélectionnée."
-
-#~ msgid "default GStreamer visualization"
-#~ msgstr "aperçu GStreamer par défaut"
-
-#~ msgid ""
-#~ "GStreamer can put visualization plugins in a pipeline to transform audio "
-#~ "streams in video frames. Some possible choices are goom, goom2k1 and "
-#~ "synaesthesia. The visualization plugin can be a partial pipeline instead "
-#~ "of just one element."
-#~ msgstr ""
-#~ "GStreamer peut mettre les extensions d’aperçu dans un pipeline pour "
-#~ "transformer les flux audios en frames vidéo. Les choix possibles sont "
-#~ "goom, goom2k1 et synaesthesia. L’extension d’aperçu peut être un pipeline "
-#~ "partiel au lieu d’un élément unique."
-
-#~ msgid "description for default GStreamer visualization"
-#~ msgstr "description de l’aperçu GStreamer par défaut"
-
-#~ msgid "Describes the selected visualization element."
-#~ msgstr "Décrit l’élément d’aperçu sélectionné."
+msgstr "Le fichier de configuration ne contient aucun canal"
diff --git a/po/gl.gmo b/po/gl.gmo
index aaceaa9..931b24b 100644
--- a/po/gl.gmo
+++ b/po/gl.gmo
Binary files differ
diff --git a/po/gl.po b/po/gl.po
index 0fc6cb5..a293372 100644
--- a/po/gl.po
+++ b/po/gl.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2011-09-05 12:50+0200\n"
 "Last-Translator: Fran Dieguez <frandieguez@ubuntu.com>\n"
 "Language-Team: Galician <proxecto@trasno.net>\n"
diff --git a/po/gst-plugins-bad-1.0.pot b/po/gst-plugins-bad-1.0.pot
index ee78a91..1516fb9 100644
--- a/po/gst-plugins-bad-1.0.pot
+++ b/po/gst-plugins-bad-1.0.pot
@@ -5,9 +5,9 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-bad 1.10.2\n"
+"Project-Id-Version: gst-plugins-bad 1.10.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
@@ -111,7 +111,7 @@
 msgstr ""
 
 #: gst-libs/gst/adaptivedemux/gstadaptivedemux.c:3551
-#: gst/mpegtsdemux/mpegtsbase.c:1608
+#: gst/mpegtsdemux/mpegtsbase.c:1610
 msgid "Internal data stream error."
 msgstr ""
 
@@ -129,27 +129,27 @@
 msgid "Could not open file \"%s\" for writing."
 msgstr ""
 
-#: sys/dvb/gstdvbsrc.c:1571 sys/dvb/gstdvbsrc.c:1784
+#: sys/dvb/gstdvbsrc.c:1573 sys/dvb/gstdvbsrc.c:1787
 #, c-format
 msgid "Device \"%s\" does not exist."
 msgstr ""
 
-#: sys/dvb/gstdvbsrc.c:1575
+#: sys/dvb/gstdvbsrc.c:1577
 #, c-format
 msgid "Could not open frontend device \"%s\"."
 msgstr ""
 
-#: sys/dvb/gstdvbsrc.c:1594
+#: sys/dvb/gstdvbsrc.c:1596
 #, c-format
 msgid "Could not get settings from frontend device \"%s\"."
 msgstr ""
 
-#: sys/dvb/gstdvbsrc.c:1611
+#: sys/dvb/gstdvbsrc.c:1613
 #, c-format
 msgid "Cannot enumerate delivery systems from frontend device \"%s\"."
 msgstr ""
 
-#: sys/dvb/gstdvbsrc.c:1788
+#: sys/dvb/gstdvbsrc.c:1791
 #, c-format
 msgid "Could not open file \"%s\" for reading."
 msgstr ""
diff --git a/po/hr.gmo b/po/hr.gmo
index a6d89ab..869ab40 100644
--- a/po/hr.gmo
+++ b/po/hr.gmo
Binary files differ
diff --git a/po/hr.po b/po/hr.po
index 3192a86..f259bdf 100644
--- a/po/hr.po
+++ b/po/hr.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-19 10:21-0800\n"
 "Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
diff --git a/po/hu.gmo b/po/hu.gmo
index 5388a47..c1c65b9 100644
--- a/po/hu.gmo
+++ b/po/hu.gmo
Binary files differ
diff --git a/po/hu.po b/po/hu.po
index 1f14bde..1117d53 100644
--- a/po/hu.po
+++ b/po/hu.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.6.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2015-11-20 23:46+0100\n"
 "Last-Translator: Balázs Úr <urbalazs@gmail.com>\n"
 "Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
diff --git a/po/id.gmo b/po/id.gmo
index 1ad98ee..b7e0053 100644
--- a/po/id.gmo
+++ b/po/id.gmo
Binary files differ
diff --git a/po/id.po b/po/id.po
index 5c3a840..26c0f5f 100644
--- a/po/id.po
+++ b/po/id.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-14 20:38+0700\n"
 "Last-Translator: Andhika Padmawan <andhika.padmawan@gmail.com>\n"
 "Language-Team: Indonesian <translation-team-id@lists.sourceforge.net>\n"
diff --git a/po/it.gmo b/po/it.gmo
index fd78ab7..b10ead1 100644
--- a/po/it.gmo
+++ b/po/it.gmo
Binary files differ
diff --git a/po/it.po b/po/it.po
index 0c3b1a0..311adec 100644
--- a/po/it.po
+++ b/po/it.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.13.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2009-08-14 00:12+0200\n"
 "Last-Translator: Luca Ferretti <elle.uca@infinito.it>\n"
 "Language-Team: Italian <tp@lists.linux.it>\n"
diff --git a/po/ja.gmo b/po/ja.gmo
index 22f7a8d..1d71c35 100644
--- a/po/ja.gmo
+++ b/po/ja.gmo
Binary files differ
diff --git a/po/ja.po b/po/ja.po
index 3116b0d..747d95c 100644
--- a/po/ja.po
+++ b/po/ja.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2011-04-26 19:38+0900\n"
 "Last-Translator: Makoto Kato <makoto.kt@gmail.com>\n"
 "Language-Team: Japanese <translation-team-ja@lists.sourceforge.net>\n"
diff --git a/po/ky.gmo b/po/ky.gmo
index a6a56d2..a13ecb9 100644
--- a/po/ky.gmo
+++ b/po/ky.gmo
Binary files differ
diff --git a/po/ky.po b/po/ky.po
index cb7c08d..3f268eb 100644
--- a/po/ky.po
+++ b/po/ky.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.5\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2007-11-13 17:16+0600\n"
 "Last-Translator: Ilyas Bakirov <just_ilyas@yahoo.com>\n"
 "Language-Team: Kirghiz <i18n-team-ky-kyrgyz@lists.sourceforge.net>\n"
diff --git a/po/lt.gmo b/po/lt.gmo
index 2c498c8..ca73f06 100644
--- a/po/lt.gmo
+++ b/po/lt.gmo
Binary files differ
diff --git a/po/lt.po b/po/lt.po
index e7612b3..a83812b 100644
--- a/po/lt.po
+++ b/po/lt.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-0.10.6.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2008-05-14 02:13+0300\n"
 "Last-Translator: Gintautas Miliauskas <gintas@akl.lt>\n"
 "Language-Team: Lithuanian <komp_lt@konferencijos.lt>\n"
diff --git a/po/lv.gmo b/po/lv.gmo
index 87753e0..46ad6c1 100644
--- a/po/lv.gmo
+++ b/po/lv.gmo
Binary files differ
diff --git a/po/lv.po b/po/lv.po
index 1b850d8..c6455f9 100644
--- a/po/lv.po
+++ b/po/lv.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.2.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2014-04-20 15:52+0300\n"
 "Last-Translator: Rihards Prieditis <rprieditis@gmail.com>\n"
 "Language-Team: Latvian <translation-team-lv@lists.sourceforge.net>\n"
diff --git a/po/mt.gmo b/po/mt.gmo
index 00d8da8..10c712f 100644
--- a/po/mt.gmo
+++ b/po/mt.gmo
Binary files differ
diff --git a/po/mt.po b/po/mt.po
index 16fe0a6..54b294d 100644
--- a/po/mt.po
+++ b/po/mt.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-0.10.8.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2008-10-26 20:27+0100\n"
 "Last-Translator: Michel Bugeja <michelbugeja@rabatmalta.com>\n"
 "Language-Team: Maltese <translation-team-mt@lists.sourceforge.net>\n"
diff --git a/po/nb.gmo b/po/nb.gmo
index ca1218a..fad44ed 100644
--- a/po/nb.gmo
+++ b/po/nb.gmo
Binary files differ
diff --git a/po/nb.po b/po/nb.po
index 6cd5dee..5cc153a 100644
--- a/po/nb.po
+++ b/po/nb.po
@@ -2,27 +2,28 @@
 # This file is put in the public domain.
 #
 # Kjartan Maraas <kmaraas@gnome.org>, 2004-2007.
-# Johnny A. Solbu <johnny@solbu.net>, 2012-2015
+# Johnny A. Solbu <johnny@solbu.net>, 2012-2017
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-bad 1.6.0\n"
+"Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
-"PO-Revision-Date: 2015-12-22 21:08+0100\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
+"PO-Revision-Date: 2017-01-05 01:34+0100\n"
 "Last-Translator: Johnny A. Solbu <johnny@solbu.net>\n"
 "Language-Team: Norwegian Bokmaal <i18n-nb@lister.ping.uio.no>\n"
 "Language: nb_NO\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"X-Generator: Poedit 1.6.9\n"
+"X-Bugs: Report translation errors to the Language-Team address.\n"
+"X-Generator: Poedit 1.8.7.1\n"
 
 msgid "failed to draw pattern"
-msgstr ""
+msgstr "Kunne ikke tegne mønster"
 
 msgid "A GL error occured"
-msgstr ""
+msgstr "En GL-feil oppsto"
 
 msgid "format wasn't negotiated before get function"
 msgstr "formatet ble ikke forhandlet før get-funksjon"
@@ -125,36 +126,31 @@
 msgid "Could not open file \"%s\" for reading."
 msgstr "Kunne ikke åpne filen «%s» for lesing."
 
-#, fuzzy
 msgid "Couldn't find channel configuration file"
-msgstr "Kunne ikke finne DVB-kanal-konfigurasjonsfil"
+msgstr "Kunne ikke finne kanal-konfigurasjonsfil"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't load channel configuration file: '%s'"
-msgstr "Kunne ikke finne DVB-kanalkonfigurasjonsfil: %s"
+msgstr "Kunne ikke finne kanalkonfigurasjonsfil: «%s»"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find details for channel '%s'"
-msgstr "Kunne ikke finne detaljer for DVB-kanal %s"
+msgstr "Kunne ikke finne detaljer for kanal «%s»"
 
-#, fuzzy, c-format
+#, c-format
 msgid "No properties for channel '%s'"
-msgstr "Kunne ikke finne detaljer for DVB-kanal %s"
+msgstr "Kunne ikke finne detaljer for kanal «%s»"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Failed to set properties for channel '%s'"
-msgstr "Kunne ikke finne detaljer for DVB-kanal %s"
+msgstr "Kunne ikke sette egenskaper for kanal «%s»"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find channel configuration file: '%s'"
-msgstr "Kunne ikke finne DVB-kanal-konfigurasjonsfil"
+msgstr "Kunne ikke finne kanal-konfigurasjonsfil: «%s»"
 
-#, fuzzy
 msgid "Channel configuration file doesn't contain any channels"
-msgstr "DVB-kanalkonfigurasjonsfilen inneholder ingen kanaler"
-
-#~ msgid "Internal data flow error."
-#~ msgstr "Intern feil i datastrøm."
+msgstr "Kanalkonfigurasjonsfilen inneholder ingen kanaler"
 
 #~ msgid "default GStreamer sound events audiosink"
 #~ msgstr "standard GStreamer lydhendelser-audiosink"
@@ -261,6 +257,9 @@
 #~ msgid "Describes the selected visualization element."
 #~ msgstr "Beskriver valgt visualiseringselement."
 
+#~ msgid "Internal data flow error."
+#~ msgstr "Intern feil i datastrøm."
+
 #~ msgid "Couldn't get the Manifest's URI"
 #~ msgstr "Kunne ikke hente Manifest-nettadressen."
 
diff --git a/po/nl.gmo b/po/nl.gmo
index a381044..bfa8571 100644
--- a/po/nl.gmo
+++ b/po/nl.gmo
Binary files differ
diff --git a/po/nl.po b/po/nl.po
index a400221..d55c3e0 100644
--- a/po/nl.po
+++ b/po/nl.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-02-20 12:35+0100\n"
 "Last-Translator: Freek de Kruijf <f.de.kruijf@gmail.com>\n"
 "Language-Team: Dutch <vertaling@vrijschrift.org>\n"
diff --git a/po/or.gmo b/po/or.gmo
index 76af1dd..5ac2e25 100644
--- a/po/or.gmo
+++ b/po/or.gmo
Binary files differ
diff --git a/po/or.po b/po/or.po
index eba41b1..1cd6420 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:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/pl.gmo b/po/pl.gmo
index e55d27f..c1f15ad 100644
--- a/po/pl.gmo
+++ b/po/pl.gmo
Binary files differ
diff --git a/po/pl.po b/po/pl.po
index 357dc5e..d6d0dc5 100644
--- a/po/pl.po
+++ b/po/pl.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-01 20:53+0100\n"
 "Last-Translator: Jakub Bogusz <qboosh@pld-linux.org>\n"
 "Language-Team: Polish <translation-team-pl@lists.sourceforge.net>\n"
diff --git a/po/pt_BR.gmo b/po/pt_BR.gmo
index 067d978..1fa4982 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 d510617..7dd15c4 100644
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-05-06 16:02-0300\n"
 "Last-Translator: Fabrício Godoy <skarllot@gmail.com>\n"
 "Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge."
diff --git a/po/ro.gmo b/po/ro.gmo
index 5c6ab53..a27d144 100644
--- a/po/ro.gmo
+++ b/po/ro.gmo
Binary files differ
diff --git a/po/ro.po b/po/ro.po
index 8486783..28f1df6 100644
--- a/po/ro.po
+++ b/po/ro.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.18.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2010-08-16 03:11+0300\n"
 "Last-Translator: Lucian Adrian Grijincu <lucian.grijincu@gmail.com>\n"
 "Language-Team: Romanian <translation-team-ro@lists.sourceforge.net>\n"
diff --git a/po/ru.gmo b/po/ru.gmo
index dcd4387..c97b997 100644
--- a/po/ru.gmo
+++ b/po/ru.gmo
Binary files differ
diff --git a/po/ru.po b/po/ru.po
index 78dfbb1..ec8cef1 100644
--- a/po/ru.po
+++ b/po/ru.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-02 21:21+0300\n"
 "Last-Translator: Yuri Kozlov <yuray@komyakino.ru>\n"
 "Language-Team: Russian <gnu@d07.ru>\n"
diff --git a/po/sk.gmo b/po/sk.gmo
index 0b8c3f7..7ac77f4 100644
--- a/po/sk.gmo
+++ b/po/sk.gmo
Binary files differ
diff --git a/po/sk.po b/po/sk.po
index 27358de..c0aa042 100644
--- a/po/sk.po
+++ b/po/sk.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-05-20 12:33+0100\n"
 "Last-Translator: Peter Tuhársky <tuharsky@misbb.sk>\n"
 "Language-Team: Slovak <sk-i18n@lists.linux.sk>\n"
diff --git a/po/sl.gmo b/po/sl.gmo
index abf5726..bdf1489 100644
--- a/po/sl.gmo
+++ b/po/sl.gmo
Binary files differ
diff --git a/po/sl.po b/po/sl.po
index c5d8077..15b6f78 100644
--- a/po/sl.po
+++ b/po/sl.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.21.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2011-04-26 15:21+0100\n"
 "Last-Translator: Klemen Košir <klemen.kosir@gmx.com>\n"
 "Language-Team: Slovenian <translation-team-sl@lists.sourceforge.net>\n"
diff --git a/po/sq.gmo b/po/sq.gmo
index 27cc06f..6d3b813 100644
--- a/po/sq.gmo
+++ b/po/sq.gmo
Binary files differ
diff --git a/po/sq.po b/po/sq.po
index e391aff..e5250f2 100644
--- a/po/sq.po
+++ b/po/sq.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 0.10.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2008-08-15 16:07+0200\n"
 "Last-Translator: Laurent Dhima <laurenti@alblinux.net>\n"
 "Language-Team: Albanian <translation-team-sq@lists.sourceforge.net>\n"
diff --git a/po/sr.gmo b/po/sr.gmo
index 24c40d4..e0869a7 100644
--- a/po/sr.gmo
+++ b/po/sr.gmo
Binary files differ
diff --git a/po/sr.po b/po/sr.po
index b71d324..d9c9445 100644
--- a/po/sr.po
+++ b/po/sr.po
@@ -2,13 +2,13 @@
 # Copyright (C) 2014 Free Software Foundation, Inc.
 # This file is distributed under the same license as the gst-plugins-bad package.
 # Danilo Segan <dsegan@gmx.net>, 2004.
-# Мирослав Николић <miroslavnikolic@rocketmail.com>, 2011—2015.
+# Мирослав Николић <miroslavnikolic@rocketmail.com>, 2011—2015, 2016.
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-bad-1.6.0\n"
+"Project-Id-Version: gst-plugins-bad-1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
-"PO-Revision-Date: 2015-12-24 11:34+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
+"PO-Revision-Date: 2016-12-04 14:22+0200\n"
 "Last-Translator: Мирослав Николић <miroslavnikolic@rocketmail.com>\n"
 "Language-Team: Serbian <(nothing)>\n"
 "Language: sr\n"
@@ -17,12 +17,14 @@
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+"X-Bugs: Report translation errors to the Language-Team address.\n"
+"X-Project-Style: gnome\n"
 
 msgid "failed to draw pattern"
-msgstr ""
+msgstr "нисам успео да исцртам образац"
 
 msgid "A GL error occured"
-msgstr ""
+msgstr "Дошло је до ГЛ грешке"
 
 msgid "format wasn't negotiated before get function"
 msgstr "запис није договорен пре функције добављања (get)"
@@ -127,36 +129,31 @@
 msgid "Could not open file \"%s\" for reading."
 msgstr "Не могу да отворим датотеку „%s“ за читање."
 
-#, fuzzy
 msgid "Couldn't find channel configuration file"
-msgstr "Не могу да пронађем датотеку подешавања ДВБ канала"
+msgstr "Не могу да нађем датотеку подешавања канала"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't load channel configuration file: '%s'"
-msgstr "Не могу да учитам датотеку подешавања ДВБ канала: %s"
+msgstr "Не могу да учитам датотеку подешавања канала: %s"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find details for channel '%s'"
-msgstr "Не могу да пронађем податке за ДВБ канал „%s“"
+msgstr "Не могу да пронађем податке за канал „%s“"
 
-#, fuzzy, c-format
+#, c-format
 msgid "No properties for channel '%s'"
-msgstr "Не могу да пронађем податке за ДВБ канал „%s“"
+msgstr "Нема својстава за канал „%s“"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Failed to set properties for channel '%s'"
-msgstr "Не могу да пронађем податке за ДВБ канал „%s“"
+msgstr "Нисам успео да подесим својства за канал „%s“"
 
-#, fuzzy, c-format
+#, c-format
 msgid "Couldn't find channel configuration file: '%s'"
-msgstr "Не могу да пронађем датотеку подешавања ДВБ канала"
+msgstr "Не могу да нађем датотеку подешавања канала: %s"
 
-#, fuzzy
 msgid "Channel configuration file doesn't contain any channels"
-msgstr "Датотека подешавања ДВБ канала не садржи ниједан канал"
-
-#~ msgid "Internal data flow error."
-#~ msgstr "Унутрашња грешка протока података."
+msgstr "Датотека подешавања канала не садржи ниједан канал"
 
 #~ msgid "default GStreamer sound events audiosink"
 #~ msgstr "основни аудио усклађивач звучних догађаја Гстримера"
@@ -264,6 +261,9 @@
 #~ msgid "Describes the selected visualization element."
 #~ msgstr "Описује изабрани елемент приказивања."
 
+#~ msgid "Internal data flow error."
+#~ msgstr "Унутрашња грешка протока података."
+
 #~ msgid "Couldn't get the Manifest's URI"
 #~ msgstr "Не могу да добавим путању Манифеста"
 
diff --git a/po/sv.gmo b/po/sv.gmo
index 9cc0a61..bcbce1c 100644
--- a/po/sv.gmo
+++ b/po/sv.gmo
Binary files differ
diff --git a/po/sv.po b/po/sv.po
index 7f92daf..bd741cf 100644
--- a/po/sv.po
+++ b/po/sv.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.6.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2015-11-01 00:48+0100\n"
 "Last-Translator: Sebastian Rasmussen <sebras@gmail.com>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
diff --git a/po/tr.gmo b/po/tr.gmo
index bd87b74..5fe535d 100644
--- a/po/tr.gmo
+++ b/po/tr.gmo
Binary files differ
diff --git a/po/tr.po b/po/tr.po
index 06cff2f..4b7a865 100644
--- a/po/tr.po
+++ b/po/tr.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad-1.4.1\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+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"
diff --git a/po/uk.gmo b/po/uk.gmo
index 3eaa54d..866e0aa 100644
--- a/po/uk.gmo
+++ b/po/uk.gmo
Binary files differ
diff --git a/po/uk.po b/po/uk.po
index db819b3..67640be 100644
--- a/po/uk.po
+++ b/po/uk.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-01 20:55+0200\n"
 "Last-Translator: Yuri Chornoivan <yurchor@ukr.net>\n"
 "Language-Team: Ukrainian <translation-team-uk@lists.sourceforge.net>\n"
diff --git a/po/vi.gmo b/po/vi.gmo
index 2ae17b5..8795485 100644
--- a/po/vi.gmo
+++ b/po/vi.gmo
Binary files differ
diff --git a/po/vi.po b/po/vi.po
index f93b6d2..4cf53af 100644
--- a/po/vi.po
+++ b/po/vi.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-02 13:38+0700\n"
 "Last-Translator: Trần Ngọc Quân <vnwildman@gmail.com>\n"
 "Language-Team: Vietnamese <translation-team-vi@lists.sourceforge.net>\n"
diff --git a/po/zh_CN.gmo b/po/zh_CN.gmo
index eb0db0c..079c274 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 18f39db..d62d1f9 100644
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-bad 1.10.0\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2016-11-29 15:49+0200\n"
+"POT-Creation-Date: 2017-01-30 15:47+0200\n"
 "PO-Revision-Date: 2016-11-02 13:41+0800\n"
 "Last-Translator: Tianze Wang <zwpwjwtz@126.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
diff --git a/sys/androidmedia/Makefile.am b/sys/androidmedia/Makefile.am
index c56eee2..cb194f1 100644
--- a/sys/androidmedia/Makefile.am
+++ b/sys/androidmedia/Makefile.am
@@ -27,7 +27,8 @@
 	gst-android-graphics-imageformat.h \
 	gst-android-hardware-camera.h \
 	gst-android-hardware-sensor.h \
-	gstjniutils.h
+	gstjniutils.h \
+	gstsensors.h
 
 libgstandroidmedia_la_CFLAGS = \
 	-I$(top_srcdir)/gst-libs \
@@ -56,3 +57,6 @@
 	org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java \
 	org/freedesktop/gstreamer/androidmedia/GstAhsCallback.java \
 	org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java
+
+# Make sure the .java files end up in the tarball
+EXTRA_DIST = $(androidmedia_java_classes_DATA)
diff --git a/sys/androidmedia/Makefile.in b/sys/androidmedia/Makefile.in
index ab2e4ea..d3ef9fe 100644
--- a/sys/androidmedia/Makefile.in
+++ b/sys/androidmedia/Makefile.in
@@ -832,7 +832,8 @@
 	gst-android-graphics-imageformat.h \
 	gst-android-hardware-camera.h \
 	gst-android-hardware-sensor.h \
-	gstjniutils.h
+	gstjniutils.h \
+	gstsensors.h
 
 libgstandroidmedia_la_CFLAGS = \
 	-I$(top_srcdir)/gst-libs \
@@ -862,6 +863,9 @@
 	org/freedesktop/gstreamer/androidmedia/GstAhsCallback.java \
 	org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java
 
+
+# Make sure the .java files end up in the tarball
+EXTRA_DIST = $(androidmedia_java_classes_DATA)
 all: all-am
 
 .SUFFIXES:
diff --git a/sys/androidmedia/gstamc.c b/sys/androidmedia/gstamc.c
index 643be54..a581081 100644
--- a/sys/androidmedia/gstamc.c
+++ b/sys/androidmedia/gstamc.c
@@ -3561,6 +3561,11 @@
         for (j = 0; j < type->n_color_formats; j++) {
           GstVideoFormat format;
 
+          /* Skip here without a warning, this is special and handled
+           * in the decoder when doing rendering to a surface */
+          if (type->color_formats[j] == COLOR_FormatAndroidOpaque)
+            continue;
+
           format =
               gst_amc_color_format_to_video_format (codec_info,
               type->mime, type->color_formats[j]);
diff --git a/sys/androidmedia/gstamcaudiodec.c b/sys/androidmedia/gstamcaudiodec.c
index 49c8c60..f46df7b 100644
--- a/sys/androidmedia/gstamcaudiodec.c
+++ b/sys/androidmedia/gstamcaudiodec.c
@@ -882,6 +882,21 @@
     return FALSE;
   }
 
+  if (gst_structure_has_name (s, "audio/mpeg")) {
+    gint mpegversion;
+    const gchar *stream_format;
+
+    if (!gst_structure_get_int (s, "mpegversion", &mpegversion))
+      mpegversion = -1;
+    stream_format = gst_structure_get_string (s, "stream-format");
+
+    if (mpegversion == 4 && g_strcmp0 (stream_format, "adts") == 0) {
+      gst_amc_format_set_int (format, "is-adts", 1, &err);
+      if (err)
+        GST_ELEMENT_WARNING_FROM_ERROR (self, err);
+    }
+  }
+
   /* FIXME: These buffers needs to be valid until the codec is stopped again */
   g_list_foreach (self->codec_datas, (GFunc) gst_buffer_unref, NULL);
   g_list_free (self->codec_datas);
diff --git a/sys/androidmedia/gstsensors.h b/sys/androidmedia/gstsensors.h
new file mode 100644
index 0000000..8b7dc89
--- /dev/null
+++ b/sys/androidmedia/gstsensors.h
@@ -0,0 +1,182 @@
+/* Copyright (C) 2016 SurroundIO
+ *   Author: Martin Kelly <martin@surround.io>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef _GST_AHSCAPS_H__
+#define _GST_AHSCAPS_H__
+
+G_BEGIN_DECLS
+
+#define GST_SENSOR_FORMATS_ALL "{" \
+     "accelerometer, " \
+     "ambient-temperature, " \
+     "game-rotation-vector, " \
+     "geomagnetic-rotation-vector, " \
+     "gravity, " \
+     "gyroscope, " \
+     "gyroscope-uncalibrated, " \
+     "heart-rate, " \
+     "light, " \
+     "linear-acceleration, " \
+     "magnetic-field, " \
+     "magnetic-field-uncalibrated, " \
+     "orientation, " \
+     "pressure, " \
+     "proximity, " \
+     "relative-humidity, " \
+     "rotation-vector, " \
+     "significant-motion, " \
+     "step-counter, " \
+     "step-detector" \
+   "}"
+
+#define GST_SENSOR_CAPS_MAKE(format)                             \
+    "application/sensor, " \
+    "type = (string) " format
+
+typedef struct GstAHSAccelerometerValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+} GstAHSAccelerometerValues;
+
+typedef struct GstAHSAmbientTemperatureValues
+{
+  gfloat temperature;
+} GstAHSAmbientTemperatureValues;
+
+typedef struct GstAHSGameRotationVectorValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+  gfloat cos;
+  gfloat accuracy;
+} GstAHSGameRotationVectorValues;
+
+typedef struct GstAHSGeomagneticRotationVectorValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+  gfloat cos;
+  gfloat accuracy;
+} GstAHSGeomagneticRotationVectorValues;
+
+typedef struct GstAHSGravityValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+} GstAHSGravityValues;
+
+typedef struct GstAHSGyroscopeValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+} GstAHSGyroscopeValues;
+
+typedef struct GstAHSGyroscopeUncalibratedValues
+{
+  gfloat x_speed;
+  gfloat y_speed;
+  gfloat z_speed;
+  gfloat x_drift;
+  gfloat y_drift;
+  gfloat z_drift;
+} GstAHSGyroscopeUncalibratedValues;
+
+typedef struct GstAHSHeartRateValues
+{
+  gfloat bpm;
+} GstAHSHeartRateValues;
+
+typedef struct GstAHSLightValues
+{
+  gfloat lux;
+} GstAHSLightValues;
+
+typedef struct GstAHSLinearAccelerationValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+} GstAHSLinearAccelerationValues;
+
+typedef struct GstAHSMagneticFieldValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+} GstAHSMagneticFieldValues;
+
+typedef struct GstAHSMagneticFieldUncalibratedValues
+{
+  gfloat x_uncalib;
+  gfloat y_uncalib;
+  gfloat z_uncalib;
+  gfloat x_bias;
+  gfloat y_bias;
+  gfloat z_bias;
+} GstAHSMagneticFieldUncalibratedValues;
+
+typedef struct GstAHSOrientationValues
+{
+  gfloat azimuth;
+  gfloat pitch;
+  gfloat roll;
+} GstAHSOrientationValues;
+
+typedef struct GstAHSProximity
+{
+  gfloat distance;
+} GstAHSProximityValues;
+
+typedef struct GstAHSPressureValues
+{
+  gfloat pressure;
+} GstAHSPressureValues;
+
+typedef struct GstAHSRelativeHumidityValues
+{
+  gfloat humidity;
+} GstAHSRelativeHumidityValues;
+
+typedef struct GstAHSRotationVectorValues
+{
+  gfloat x;
+  gfloat y;
+  gfloat z;
+  gfloat cos;
+  gfloat accuracy;
+} GstAHSRotationVectorValues;
+
+typedef struct GstAHSStepCounterValues
+{
+  gfloat count;
+} GstAHSStepCounterValues;
+
+typedef struct GstAHSStepDetectorValues
+{
+  gfloat one;
+} GstAHSStepDetectorValues;
+
+G_END_DECLS
+#endif
diff --git a/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java
new file mode 100644
index 0000000..53811a9
--- /dev/null
+++ b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2012, Collabora Ltd.
+ *   Author: Youness Alaoui
+ *
+ * Copyright (C) 2015, Collabora Ltd.
+ *   Author: Justin Kim <justin.kim@collabora.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ */
+
+package org.freedesktop.gstreamer.androidmedia;
+
+import android.hardware.Camera;
+
+public class GstAhcCallback implements Camera.PreviewCallback,
+                                       Camera.ErrorCallback,
+                                       Camera.AutoFocusCallback {
+    public long mUserData;
+    public long mCallback;
+
+    public static native void gst_ah_camera_on_preview_frame(byte[] data, Camera camera,
+                                                             long callback, long user_data);
+    public static native void gst_ah_camera_on_error(int error, Camera camera,
+                                                     long callback, long user_data);
+    public static native void gst_ah_camera_on_auto_focus(boolean success, Camera camera,
+                                                             long callback, long user_data);
+
+    public GstAhcCallback(long callback, long user_data) {
+        mCallback = callback;
+        mUserData = user_data;
+    }
+
+    @Override
+    public void onPreviewFrame(byte[] data, Camera camera) {
+        gst_ah_camera_on_preview_frame(data, camera, mCallback, mUserData);
+    }
+
+    @Override
+    public void onError(int error, Camera camera) {
+        gst_ah_camera_on_error(error, camera, mCallback, mUserData);
+    }
+
+    @Override
+    public void onAutoFocus(boolean success, Camera camera) {
+        gst_ah_camera_on_auto_focus(success, camera, mCallback, mUserData);
+    }
+}
diff --git a/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhsCallback.java b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhsCallback.java
new file mode 100644
index 0000000..b6fb015
--- /dev/null
+++ b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhsCallback.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 SurroundIO
+ *   Author: Martin Kelly <martin@surround.io>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+package org.freedesktop.gstreamer.androidmedia;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+
+public class GstAhsCallback implements SensorEventListener {
+    public long mUserData;
+    public long mSensorCallback;
+    public long mAccuracyCallback;
+
+    public static native void gst_ah_sensor_on_sensor_changed(SensorEvent event,
+                                                              long callback, long user_data);
+    public static native void gst_ah_sensor_on_accuracy_changed(Sensor sensor, int accuracy,
+                                                                long callback, long user_data);
+
+    public GstAhsCallback(long sensor_callback,
+        long accuracy_callback, long user_data) {
+        mSensorCallback = sensor_callback;
+        mAccuracyCallback = accuracy_callback;
+        mUserData = user_data;
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+      gst_ah_sensor_on_sensor_changed(event, mSensorCallback, mUserData);
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+      gst_ah_sensor_on_accuracy_changed(sensor, accuracy,
+          mAccuracyCallback, mUserData);
+    }
+}
diff --git a/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java
new file mode 100644
index 0000000..f34bcf7
--- /dev/null
+++ b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015, Collabora Ltd.
+ *   Author: Matthieu Bouron <matthieu.bouron@collabora.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ */
+
+package org.freedesktop.gstreamer.androidmedia;
+
+import android.graphics.SurfaceTexture;
+import android.graphics.SurfaceTexture.OnFrameAvailableListener;
+
+public class GstAmcOnFrameAvailableListener implements OnFrameAvailableListener
+{
+    private long context = 0;
+
+    public synchronized void onFrameAvailable (SurfaceTexture surfaceTexture) {
+        native_onFrameAvailable(context, surfaceTexture);
+    }
+
+    public synchronized long getContext () {
+        return context;
+    }
+
+    public synchronized void setContext (long c) {
+        context = c;
+    }
+
+    private native void native_onFrameAvailable (long context, SurfaceTexture surfaceTexture);
+}
diff --git a/sys/applemedia/glcontexthelper.c b/sys/applemedia/glcontexthelper.c
index 4e6f617..4e0b71e 100644
--- a/sys/applemedia/glcontexthelper.c
+++ b/sys/applemedia/glcontexthelper.c
@@ -92,6 +92,9 @@
     gst_gl_ensure_element_data (ctxh->element, &ctxh->display,
         &ctxh->other_context);
 
+  if (!ctxh->display)
+    goto display_error;
+
   context = _find_local_gl_context (ctxh);
   if (context) {
     GST_INFO_OBJECT (ctxh->element, "found local context %p, old context %p",
@@ -129,4 +132,12 @@
 
     return;
   }
+
+display_error:
+  {
+    GST_ELEMENT_ERROR (ctxh->element, RESOURCE, NOT_FOUND,
+        ("Failed to obtain display"), (NULL));
+
+    return;
+  }
 }
diff --git a/sys/dvb/gstdvbsrc.c b/sys/dvb/gstdvbsrc.c
index be2d76d..854ddc9 100644
--- a/sys/dvb/gstdvbsrc.c
+++ b/sys/dvb/gstdvbsrc.c
@@ -274,7 +274,9 @@
     {FEC_AUTO, "AUTO", "auto"},
     {FEC_3_5, "3/5", "3/5"},
     {FEC_9_10, "9/10", "9/10"},
+#if HAVE_V5_MINOR(7)
     {FEC_2_5, "2/5", "2/5"},
+#endif
     {0, NULL, NULL},
   };
 
@@ -1643,7 +1645,7 @@
     object->supported_delsys = g_list_append (object->supported_delsys,
         GINT_TO_POINTER (SYS_DVBC_ANNEX_B));
     gst_structure_set (adapter_structure, "dvb-c-b", G_TYPE_STRING,
-        "DVB-C ANNEX C", NULL);
+        "DVB-C ANNEX B", NULL);
   }
 
   if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBT)) {
@@ -1746,13 +1748,14 @@
     gst_structure_set (adapter_structure, "turbo", G_TYPE_STRING, "TURBO",
         NULL);
   }
-
+#if HAVE_V5_MINOR(6)
   if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBC_ANNEX_C)) {
     object->supported_delsys = g_list_append (object->supported_delsys,
         GINT_TO_POINTER (SYS_DVBC_ANNEX_C));
     gst_structure_set (adapter_structure, "dvb-c-c", G_TYPE_STRING,
         "DVB-C ANNEX C", NULL);
   }
+#endif
 
   GST_TRACE_OBJECT (object, "%s description: %" GST_PTR_FORMAT, adapter_name,
       adapter_structure);
@@ -2112,8 +2115,8 @@
         return TRUE;
       break;
     default:
-      GST_FIXME ("No modulation sanity checks implemented for this delivery "
-          "system");
+      GST_FIXME ("No modulation sanity-checks implemented for delivery "
+          "system: '%d'", delsys);
       return TRUE;
   }
   return FALSE;
diff --git a/sys/uvch264/gstuvch264_src.c b/sys/uvch264/gstuvch264_src.c
index 38397c3..4f2a6f3 100644
--- a/sys/uvch264/gstuvch264_src.c
+++ b/sys/uvch264/gstuvch264_src.c
@@ -1593,7 +1593,7 @@
           GST_TIME_FORMAT, all_headers, count, GST_TIME_ARGS (ts),
           GST_TIME_ARGS (running_time), GST_TIME_ARGS (stream_time));
       downstream = gst_video_event_new_downstream_force_key_unit (ts,
-          running_time, stream_time, all_headers, count);
+          stream_time, running_time, all_headers, count);
       gst_pad_push_event (self->vidsrc, downstream);
       gst_event_replace (&self->key_unit_event, NULL);
     }
diff --git a/tests/check/elements/dash_isoff.c b/tests/check/elements/dash_isoff.c
index 500747b..2b984e8 100644
--- a/tests/check/elements/dash_isoff.c
+++ b/tests/check/elements/dash_isoff.c
@@ -4,6 +4,8 @@
 #include <gst/check/gstcheck.h>
 #include <gst/base/base.h>
 
+GST_DEBUG_CATEGORY (gst_dash_demux_debug);
+
 #include "dash_isoff.h"
 
 GST_START_TEST (dash_isoff_box_header_minimal)
@@ -189,6 +191,9 @@
   TCase *tc_isoff_box = tcase_create ("isoff-box-parsing");
   TCase *tc_moof = tcase_create ("moof");
 
+  GST_DEBUG_CATEGORY_INIT (gst_dash_demux_debug, "gst_dash_demux_debug", 0,
+      "mpeg dash tests");
+
   tcase_add_test (tc_isoff_box, dash_isoff_box_header_minimal);
   tcase_add_test (tc_isoff_box, dash_isoff_box_header_long_size);
   tcase_add_test (tc_isoff_box, dash_isoff_box_header_uuid_type);
diff --git a/tests/examples/directfb/gstdfb.c b/tests/examples/directfb/gstdfb.c
index 32ddd15..5fcc026 100644
--- a/tests/examples/directfb/gstdfb.c
+++ b/tests/examples/directfb/gstdfb.c
@@ -91,11 +91,14 @@
     gint width, height;
 
     if (!(gst_structure_get_int (s, "width", &width) &&
-            gst_structure_get_int (s, "height", &height)))
+            gst_structure_get_int (s, "height", &height))) {
+      gst_caps_unref (caps);
       return;
+    }
 
     window->Resize (window, width, height);
   }
+  gst_caps_unref (caps);
 }
 
 static void
diff --git a/tests/examples/gtk/glliveshader.c b/tests/examples/gtk/glliveshader.c
index d8c8d35..5a71bc3 100644
--- a/tests/examples/gtk/glliveshader.c
+++ b/tests/examples/gtk/glliveshader.c
@@ -25,6 +25,10 @@
 #include <X11/Xlib.h>
 #endif
 
+#ifndef GL_GEOMETRY_SHADER
+#define GL_GEOMETRY_SHADER 0x8DD9
+#endif
+
 static GMainLoop *loop;
 
 static const gchar *vert = "#version 330\n\
diff --git a/win32/common/config.h b/win32/common/config.h
index 86b4818..3f6e1eb 100644
--- a/win32/common/config.h
+++ b/win32/common/config.h
@@ -86,7 +86,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
@@ -737,7 +737,7 @@
 #define PACKAGE_NAME "GStreamer Bad Plug-ins"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "GStreamer Bad Plug-ins 1.10.2"
+#define PACKAGE_STRING "GStreamer Bad Plug-ins 1.10.3"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "gst-plugins-bad"
@@ -746,7 +746,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
@@ -790,7 +790,7 @@
 #undef USE_EGL_RPI
 
 /* 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). */
