diff --git a/ChangeLog b/ChangeLog
index 25dd016..f9b88ee 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,9 +1,130 @@
-=== release 1.1.4 ===
+=== release 1.1.90 ===
 
-2013-08-28  Sebastian Dröge <sebastian.droege@collabora.co.uk>
+2013-09-19  Sebastian Dröge <sebastian.droege@collabora.co.uk>
 
 	* configure.ac:
-	  releasing 1.1.4
+	  releasing 1.1.90
+
+2013-09-19 09:45:55 +0200  Sebastian Dröge <slomo@circular-chaos.org>
+
+	* po/cs.po:
+	  po: Update translations
+
+2013-09-18 19:13:45 -0400  Olivier Crête <olivier.crete@collabora.com>
+
+	* ext/x264/gstx264enc.c:
+	* tests/check/elements/x264enc.c:
+	  x264enc: Implement getcaps that restricts the input format depending on the output profile
+	  Also add some x264enc profile tests
+	  https://bugzilla.gnome.org/show_bug.cgi?id=708326
+
+2013-09-16 19:38:36 +0200  Matej Knopp <matej.knopp@gmail.com>
+
+	* gst/asfdemux/asfpacket.c:
+	* gst/asfdemux/gstasfdemux.c:
+	  asfdemux: fix playback regression in push mode
+
+2013-09-10 19:33:33 -0300  Thiago Santos <thiago.sousa.santos@collabora.com>
+
+	* gst/asfdemux/gstasfdemux.h:
+	  asfdemux: remove unused variable
+
+2013-09-05 22:56:48 +0200  Mathieu Duponchelle <mathieu.duponchelle@epitech.eu>
+
+	* ext/x264/gstx264enc.c:
+	  x264enc: Don't unref future state but the old one
+	  Being silly will lead us nowhere.
+
+2013-09-04 16:32:43 +0200  Sebastian Dröge <slomo@circular-chaos.org>
+
+	* ext/x264/gstx264enc.c:
+	  x264enc: Check if we have an input state before using it
+	  Flushing might happen before caps were set on the encoder,
+	  which would lead to crashes here.
+	  Thanks to Matej Knopp for analyzing this.
+	  https://bugzilla.gnome.org/show_bug.cgi?id=707414
+
+2013-09-03 20:28:35 +0200  Matej Knopp <matej.knopp@gmail.com>
+
+	* ext/x264/gstx264enc.c:
+	  x264enc: fix unsigned comparison warning
+
+2013-08-28 13:27:05 +0200  Sebastian Dröge <slomo@circular-chaos.org>
+
+	* configure.ac:
+	  Back to development
+
+=== release 1.1.4 ===
+
+2013-08-28 12:58:43 +0200  Sebastian Dröge <slomo@circular-chaos.org>
+
+	* ChangeLog:
+	* NEWS:
+	* RELEASE:
+	* configure.ac:
+	* docs/plugins/inspect/plugin-a52dec.xml:
+	* docs/plugins/inspect/plugin-amrnb.xml:
+	* docs/plugins/inspect/plugin-amrwbdec.xml:
+	* docs/plugins/inspect/plugin-asf.xml:
+	* docs/plugins/inspect/plugin-cdio.xml:
+	* docs/plugins/inspect/plugin-dvdlpcmdec.xml:
+	* docs/plugins/inspect/plugin-dvdread.xml:
+	* docs/plugins/inspect/plugin-dvdsub.xml:
+	* docs/plugins/inspect/plugin-lame.xml:
+	* docs/plugins/inspect/plugin-mad.xml:
+	* docs/plugins/inspect/plugin-mpeg2dec.xml:
+	* docs/plugins/inspect/plugin-realmedia.xml:
+	* docs/plugins/inspect/plugin-siddec.xml:
+	* docs/plugins/inspect/plugin-twolame.xml:
+	* docs/plugins/inspect/plugin-x264.xml:
+	* docs/plugins/inspect/plugin-xingmux.xml:
+	* gst-plugins-ugly.doap:
+	* win32/common/config.h:
+	  Release 1.1.4
+
+2013-08-28 12:58:37 +0200  Sebastian Dröge <slomo@circular-chaos.org>
+
+	* po/af.po:
+	* po/az.po:
+	* po/bg.po:
+	* po/ca.po:
+	* po/cs.po:
+	* po/da.po:
+	* po/de.po:
+	* po/el.po:
+	* po/en_GB.po:
+	* po/eo.po:
+	* po/es.po:
+	* po/eu.po:
+	* po/fi.po:
+	* po/fr.po:
+	* po/gl.po:
+	* po/hr.po:
+	* po/hu.po:
+	* po/id.po:
+	* po/it.po:
+	* po/ja.po:
+	* po/lt.po:
+	* po/lv.po:
+	* po/ms.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
 
 2013-08-28 12:32:37 +0200  Sebastian Dröge <slomo@circular-chaos.org>
 
diff --git a/Makefile.in b/Makefile.in
index 3a94ad7..a120bc0 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
@@ -572,8 +572,8 @@
 $(am__aclocal_m4_deps):
 
 config.h: stamp-h1
-	@if test ! -f $@; then rm -f stamp-h1; else :; fi
-	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi
+	@test -f $@ || rm -f stamp-h1
+	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
 
 stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
 	@rm -f stamp-h1
@@ -786,10 +786,16 @@
 	$(am__post_remove_distdir)
 
 dist-tarZ: distdir
+	@echo WARNING: "Support for shar distribution archives is" \
+	               "deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
 	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
 	$(am__post_remove_distdir)
 
 dist-shar: distdir
+	@echo WARNING: "Support for distribution archives compressed with" \
+		       "legacy program 'compress' is deprecated." >&2
+	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
 	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
 	$(am__post_remove_distdir)
 
diff --git a/NEWS b/NEWS
index 6602710..c5aebea 100644
--- a/NEWS
+++ b/NEWS
@@ -1,2 +1,2 @@
-This is GStreamer Ugly Plugins 1.1.4
+This is GStreamer Ugly Plugins 1.1.90
 
diff --git a/RELEASE b/RELEASE
index 136e1a3..3dba9ae 100644
--- a/RELEASE
+++ b/RELEASE
@@ -1,5 +1,5 @@
 
-Release notes for GStreamer Ugly Plugins 1.1.4
+Release notes for GStreamer Ugly Plugins 1.1.90
 
 The GStreamer team is proud to announce a new bug-fix release
 in the 1.x stable series of the
@@ -58,8 +58,9 @@
 
 Bugs fixed in this release
      
-      * 705026 : asfdemux: add support dvr-ms files
-      * 705153 : regression: asfdemux: cannot seek in push mode any longer
+      * 707414 : x264enc: crash and warning
+      * 708010 : asfdemux: Fails to output anything on mms streams after adding support for dvr-ms
+      * 708326 : x264enc caps negotiation broken, tries input 4:4:4 for non-4:4:4 profiles
 
 ==== Download ====
 
@@ -96,9 +97,9 @@
         
 Contributors to this release
     
-      * Edward Hervey
-      * Lubosz Sarnecki
       * Matej Knopp
+      * Mathieu Duponchelle
+      * Olivier Crête
       * Sebastian Dröge
-      * Tim-Philipp Müller
+      * Thiago Santos
  
\ No newline at end of file
diff --git a/aclocal.m4 b/aclocal.m4
index 9ab41a7..e6be8e9 100644
--- a/aclocal.m4
+++ b/aclocal.m4
@@ -1,4 +1,4 @@
-# generated automatically by aclocal 1.13.3 -*- Autoconf -*-
+# generated automatically by aclocal 1.14 -*- Autoconf -*-
 
 # Copyright (C) 1996-2013 Free Software Foundation, Inc.
 
@@ -32,10 +32,10 @@
 # generated from the m4 files accompanying Automake X.Y.
 # (This private macro should not be called outside this file.)
 AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.13'
+[am__api_version='1.14'
 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
 dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.13.3], [],
+m4_if([$1], [1.14], [],
       [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
 ])
 
@@ -51,7 +51,7 @@
 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.13.3])dnl
+[AM_AUTOMAKE_VERSION([1.14])dnl
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
 _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
@@ -418,6 +418,12 @@
 # This macro actually does too much.  Some checks are only needed if
 # your package does certain things.  But this isn't really a big deal.
 
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
 # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
 # AM_INIT_AUTOMAKE([OPTIONS])
 # -----------------------------------------------
@@ -526,7 +532,48 @@
 AC_CONFIG_COMMANDS_PRE(dnl
 [m4_provide_if([_AM_COMPILER_EXEEXT],
   [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
-])
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+  fi
+fi])
 
 dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
 dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
@@ -534,7 +581,6 @@
 m4_define([_AC_COMPILER_EXEEXT],
 m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
 
-
 # When config.status generates a header, we must update the stamp-h file.
 # This file resides in the same directory as the config header
 # that is generated.  The stamp files are numbered to have different names.
@@ -682,38 +728,6 @@
 rm -f confinc confmf
 ])
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_PROG_CC_C_O
-# --------------
-# Like AC_PROG_CC_C_O, but changed for automake.
-AC_DEFUN([AM_PROG_CC_C_O],
-[AC_REQUIRE([AC_PROG_CC_C_O])dnl
-AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([compile])dnl
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-dnl Make sure AC_PROG_CC is never called again, or it will override our
-dnl setting of CC.
-m4_define([AC_PROG_CC],
-          [m4_fatal([AC_PROG_CC cannot be called after AM_PROG_CC_C_O])])
-])
-
 # Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
 
 # Copyright (C) 1997-2013 Free Software Foundation, Inc.
@@ -822,6 +836,53 @@
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+  [whether $CC understands -c and -o together],
+  [am_cv_prog_cc_c_o],
+  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
 
 # AM_PATH_PYTHON([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
 # ---------------------------------------------------------------------------
diff --git a/common/Makefile.in b/common/Makefile.in
index c7b43b2..3163eba 100644
--- a/common/Makefile.in
+++ b/common/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/common/m4/Makefile.in b/common/m4/Makefile.in
index dbf0dbd..566401d 100644
--- a/common/m4/Makefile.in
+++ b/common/m4/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/config.h.in b/config.h.in
index 0bdc46a..5ab1c2a 100644
--- a/config.h.in
+++ b/config.h.in
@@ -233,9 +233,6 @@
    */
 #undef LT_OBJDIR
 
-/* Define to 1 if your C compiler doesn't accept -c and -o together. */
-#undef NO_MINUS_C_MINUS_O
-
 /* Name of package */
 #undef PACKAGE
 
diff --git a/configure b/configure
index 58b0d01..1853ae6 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 Ugly Plug-ins 1.1.4.
+# Generated by GNU Autoconf 2.69 for GStreamer Ugly Plug-ins 1.1.90.
 #
 # Report bugs to <http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer>.
 #
@@ -591,8 +591,8 @@
 # Identity of this package.
 PACKAGE_NAME='GStreamer Ugly Plug-ins'
 PACKAGE_TARNAME='gst-plugins-ugly'
-PACKAGE_VERSION='1.1.4'
-PACKAGE_STRING='GStreamer Ugly Plug-ins 1.1.4'
+PACKAGE_VERSION='1.1.90'
+PACKAGE_STRING='GStreamer Ugly Plug-ins 1.1.90'
 PACKAGE_BUGREPORT='http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer'
 PACKAGE_URL=''
 
@@ -1647,7 +1647,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 Ugly Plug-ins 1.1.4 to adapt to many kinds of systems.
+\`configure' configures GStreamer Ugly Plug-ins 1.1.90 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1719,7 +1719,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of GStreamer Ugly Plug-ins 1.1.4:";;
+     short | recursive ) echo "Configuration of GStreamer Ugly Plug-ins 1.1.90:";;
    esac
   cat <<\_ACEOF
 
@@ -1950,7 +1950,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-GStreamer Ugly Plug-ins configure 1.1.4
+GStreamer Ugly Plug-ins configure 1.1.90
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2856,7 +2856,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 Ugly Plug-ins $as_me 1.1.4, which was
+It was created by GStreamer Ugly Plug-ins $as_me 1.1.90, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -3349,7 +3349,7 @@
 
 
 
-am__api_version='1.13'
+am__api_version='1.14'
 
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
@@ -3835,7 +3835,7 @@
 
 # Define the identity of the package.
  PACKAGE='gst-plugins-ugly'
- VERSION='1.1.4'
+ VERSION='1.1.90'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -4002,11 +4002,52 @@
 
 
 
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+  fi
+fi
 
 
-  PACKAGE_VERSION_MAJOR=$(echo 1.1.4 | cut -d'.' -f1)
-  PACKAGE_VERSION_MINOR=$(echo 1.1.4 | cut -d'.' -f2)
-  PACKAGE_VERSION_MICRO=$(echo 1.1.4 | cut -d'.' -f3)
+  PACKAGE_VERSION_MAJOR=$(echo 1.1.90 | cut -d'.' -f1)
+  PACKAGE_VERSION_MINOR=$(echo 1.1.90 | cut -d'.' -f2)
+  PACKAGE_VERSION_MICRO=$(echo 1.1.90 | cut -d'.' -f3)
 
 
 
@@ -4017,7 +4058,7 @@
   { $as_echo "$as_me:${as_lineno-$LINENO}: checking nano version" >&5
 $as_echo_n "checking nano version... " >&6; }
 
-  NANO=$(echo 1.1.4 | cut -d'.' -f4)
+  NANO=$(echo 1.1.90 | cut -d'.' -f4)
 
   if test x"$NANO" = x || test "x$NANO" = "x0" ; then
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: 0 (release)" >&5
@@ -5065,6 +5106,65 @@
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
+if ${am_cv_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+$as_echo "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
 depcc="$CC"   am_compiler_list=
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
@@ -8601,10 +8701,10 @@
 done
 
 
-  GST_CURRENT=104
+  GST_CURRENT=190
   GST_REVISION=0
-  GST_AGE=104
-  GST_LIBVERSION=104:0:104
+  GST_AGE=190
+  GST_LIBVERSION=190:0:190
 
 
 
@@ -12929,8 +13029,8 @@
 
 
 
-GST_REQ=1.1.4
-GSTPB_REQ=1.1.4
+GST_REQ=1.1.90
+GSTPB_REQ=1.1.90
 
 
 
@@ -16894,6 +16994,65 @@
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
+if ${am_cv_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+$as_echo "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
 depcc="$CC"   am_compiler_list=
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
@@ -20939,131 +21098,6 @@
 
 
 
-if test "x$CC" != xcc; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
-$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
-$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
-fi
-set dummy $CC; ac_cc=`$as_echo "$2" |
-		      sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-if eval \${ac_cv_prog_cc_${ac_cc}_c_o+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-# Make sure it works both with $CC and with simple cc.
-# We do the test twice because some compilers refuse to overwrite an
-# existing .o file with -o, though they will create one.
-ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-rm -f conftest2.*
-if { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } &&
-   test -f conftest2.$ac_objext && { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; };
-then
-  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
-  if test "x$CC" != xcc; then
-    # Test first that cc exists at all.
-    if { ac_try='cc -c conftest.$ac_ext >&5'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
-      rm -f conftest2.*
-      if { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } &&
-	 test -f conftest2.$ac_objext && { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; };
-      then
-	# cc works too.
-	:
-      else
-	# cc exists but doesn't like -o.
-	eval ac_cv_prog_cc_${ac_cc}_c_o=no
-      fi
-    fi
-  fi
-else
-  eval ac_cv_prog_cc_${ac_cc}_c_o=no
-fi
-rm -f core conftest*
-
-fi
-if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-
-$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
-
-fi
-
-# FIXME: we rely on the cache variable name because
-# there is no other way.
-set dummy $CC
-am_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
-eval am_t=\$ac_cv_prog_cc_${am_cc}_c_o
-if test "$am_t" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-
 
 
 # Extract the first word of "valgrind", so it can be a program name with args.
@@ -28096,7 +28130,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by GStreamer Ugly Plug-ins $as_me 1.1.4, which was
+This file was extended by GStreamer Ugly Plug-ins $as_me 1.1.90, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -28162,7 +28196,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 Ugly Plug-ins config.status 1.1.4
+GStreamer Ugly Plug-ins config.status 1.1.90
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git a/configure.ac b/configure.ac
index 513c5c1..e73e50b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -5,7 +5,7 @@
 dnl initialize autoconf
 dnl releases only do -Wall, cvs and prerelease does -Werror too
 dnl use a three digit version number for releases, and four for cvs/prerelease
-AC_INIT([GStreamer Ugly Plug-ins],[1.1.4],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-ugly])
+AC_INIT([GStreamer Ugly Plug-ins],[1.1.90],[http://bugzilla.gnome.org/enter_bug.cgi?product=GStreamer],[gst-plugins-ugly])
 
 AG_GST_INIT
 
@@ -42,11 +42,11 @@
 AC_DEFINE_UNQUOTED(GST_API_VERSION, "$GST_API_VERSION",
   [GStreamer API Version])
 
-AS_LIBTOOL(GST, 104, 0, 104)
+AS_LIBTOOL(GST, 190, 0, 190)
 
 dnl *** required versions of GStreamer stuff ***
-GST_REQ=1.1.4
-GSTPB_REQ=1.1.4
+GST_REQ=1.1.90
+GSTPB_REQ=1.1.90
 
 dnl *** autotools stuff ****
 
diff --git a/docs/Makefile.in b/docs/Makefile.in
index c5b064a..f18ba00 100644
--- a/docs/Makefile.in
+++ b/docs/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/docs/plugins/Makefile.in b/docs/plugins/Makefile.in
index 41bd022..47ce70f 100644
--- a/docs/plugins/Makefile.in
+++ b/docs/plugins/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/docs/plugins/html/ch01.html b/docs/plugins/html/ch01.html
index be14f30..bb99f6f 100644
--- a/docs/plugins/html/ch01.html
+++ b/docs/plugins/html/ch01.html
@@ -8,7 +8,7 @@
 <link rel="up" href="index.html" title="GStreamer Ugly Plugins 1.0 Plugins Reference Manual">
 <link rel="prev" href="index.html" title="GStreamer Ugly Plugins 1.0 Plugins Reference Manual">
 <link rel="next" href="gst-plugins-ugly-plugins-a52dec.html" title="a52dec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -21,7 +21,7 @@
 </tr></table>
 <div class="chapter">
 <div class="titlepage"><div><div><h1 class="title">
-<a name="idp50681600"></a>gst-plugins-ugly Elements</h1></div></div></div>
+<a name="id-1.2"></a>gst-plugins-ugly Elements</h1></div></div></div>
 <div class="toc"><dl class="toc">
 <dt>
 <span class="refentrytitle"><a href="gst-plugins-ugly-plugins-a52dec.html">a52dec</a></span><span class="refpurpose"> — Decodes ATSC A/52 encoded audio streams</span>
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/ch02.html b/docs/plugins/html/ch02.html
index d9b72b6..277e09c 100644
--- a/docs/plugins/html/ch02.html
+++ b/docs/plugins/html/ch02.html
@@ -8,7 +8,7 @@
 <link rel="up" href="index.html" title="GStreamer Ugly Plugins 1.0 Plugins Reference Manual">
 <link rel="prev" href="gst-plugins-ugly-plugins-xingmux.html" title="xingmux">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-a52dec.html" title="a52dec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -21,7 +21,7 @@
 </tr></table>
 <div class="chapter">
 <div class="titlepage"><div><div><h1 class="title">
-<a name="idp54552784"></a>gst-plugins-ugly Plugins</h1></div></div></div>
+<a name="id-1.3"></a>gst-plugins-ugly Plugins</h1></div></div></div>
 <div class="toc"><dl class="toc">
 <dt>
 <span class="refentrytitle"><a href="gst-plugins-ugly-plugins-plugin-a52dec.html">a52dec</a></span><span class="refpurpose">Decodes ATSC A/52 encoded audio streams</span>
@@ -72,6 +72,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-1.0.devhelp2 b/docs/plugins/html/gst-plugins-ugly-plugins-1.0.devhelp2
index a7aadc1..41221d4 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-1.0.devhelp2
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-1.0.devhelp2
@@ -39,29 +39,29 @@
     </sub>
   </chapters>
   <functions>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-a52dec.html#idp57282416"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-a52dec.html#idp57563760"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-a52dec.html#id-1.2.2.6.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-a52dec.html#id-1.2.2.6.2.2"/>
     <keyword type="struct" name="struct GstA52Dec" link="gst-plugins-ugly-plugins-a52dec.html#GstA52Dec-struct"/>
     <keyword type="property" name="The &quot;drc&quot; property" link="gst-plugins-ugly-plugins-a52dec.html#GstA52Dec--drc"/>
     <keyword type="property" name="The &quot;lfe&quot; property" link="gst-plugins-ugly-plugins-a52dec.html#GstA52Dec--lfe"/>
     <keyword type="property" name="The &quot;mode&quot; property" link="gst-plugins-ugly-plugins-a52dec.html#GstA52Dec--mode"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrnbdec.html#idp58697536"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrnbdec.html#idp58281600"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrnbdec.html#id-1.2.3.6.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrnbdec.html#id-1.2.3.6.2.2"/>
     <keyword type="struct" name="struct GstAmrnbDec" link="gst-plugins-ugly-plugins-amrnbdec.html#GstAmrnbDec-struct"/>
     <keyword type="property" name="The &quot;variant&quot; property" link="gst-plugins-ugly-plugins-amrnbdec.html#GstAmrnbDec--variant"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrnbenc.html#idp55589472"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrnbenc.html#idp58052064"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrnbenc.html#id-1.2.4.7.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrnbenc.html#id-1.2.4.7.2.2"/>
     <keyword type="struct" name="struct GstAmrnbEnc" link="gst-plugins-ugly-plugins-amrnbenc.html#GstAmrnbEnc-struct"/>
     <keyword type="property" name="The &quot;band-mode&quot; property" link="gst-plugins-ugly-plugins-amrnbenc.html#GstAmrnbEnc--band-mode"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrwbdec.html#idp59286304"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrwbdec.html#idp56094096"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-amrwbdec.html#id-1.2.5.5.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-amrwbdec.html#id-1.2.5.5.2.2"/>
     <keyword type="struct" name="struct GstAmrwbDec" link="gst-plugins-ugly-plugins-amrwbdec.html#GstAmrwbDec-struct"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-cdiocddasrc.html#idp57608416"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-cdiocddasrc.html#idp59626240"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-cdiocddasrc.html#id-1.2.6.7.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-cdiocddasrc.html#id-1.2.6.7.2.2"/>
     <keyword type="struct" name="struct GstCdioCddaSrc" link="gst-plugins-ugly-plugins-cdiocddasrc.html#GstCdioCddaSrc-struct"/>
     <keyword type="property" name="The &quot;read-speed&quot; property" link="gst-plugins-ugly-plugins-cdiocddasrc.html#GstCdioCddaSrc--read-speed"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-lamemp3enc.html#idp58160064"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-lamemp3enc.html#idp58167472"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-lamemp3enc.html#id-1.2.7.7.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-lamemp3enc.html#id-1.2.7.7.2.2"/>
     <keyword type="struct" name="struct GstLameMP3Enc" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc-struct"/>
     <keyword type="property" name="The &quot;bitrate&quot; property" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc--bitrate"/>
     <keyword type="property" name="The &quot;cbr&quot; property" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc--cbr"/>
@@ -69,20 +69,20 @@
     <keyword type="property" name="The &quot;mono&quot; property" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc--mono"/>
     <keyword type="property" name="The &quot;quality&quot; property" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc--quality"/>
     <keyword type="property" name="The &quot;target&quot; property" link="gst-plugins-ugly-plugins-lamemp3enc.html#GstLameMP3Enc--target"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-mad.html#idp55641776"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-mad.html#idp59720032"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-mad.html#id-1.2.8.6.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-mad.html#id-1.2.8.6.2.2"/>
     <keyword type="struct" name="struct GstMad" link="gst-plugins-ugly-plugins-mad.html#GstMad-struct"/>
     <keyword type="property" name="The &quot;half&quot; property" link="gst-plugins-ugly-plugins-mad.html#GstMad--half"/>
     <keyword type="property" name="The &quot;ignore-crc&quot; property" link="gst-plugins-ugly-plugins-mad.html#GstMad--ignore-crc"/>
-    <keyword type="" name="Example launch line" link="gst-plugins-ugly-plugins-rademux.html#idp58360000"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rademux.html#idp58768064"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rademux.html#idp53056896"/>
+    <keyword type="" name="Example launch line" link="gst-plugins-ugly-plugins-rademux.html#id-1.2.9.5.3.1"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rademux.html#id-1.2.9.5.5.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rademux.html#id-1.2.9.5.5.2"/>
     <keyword type="struct" name="struct GstRealAudioDemux" link="gst-plugins-ugly-plugins-rademux.html#GstRealAudioDemux-struct"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rmdemux.html#idp59701648"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rmdemux.html#idp56179264"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rmdemux.html#id-1.2.10.5.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rmdemux.html#id-1.2.10.5.2.2"/>
     <keyword type="struct" name="struct GstRMDemux" link="gst-plugins-ugly-plugins-rmdemux.html#GstRMDemux-struct"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rdtmanager.html#idp58730704"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rdtmanager.html#idp58256736"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rdtmanager.html#id-1.2.11.7.4.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rdtmanager.html#id-1.2.11.7.4.2"/>
     <keyword type="struct" name="struct GstRDTManager" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager-struct"/>
     <keyword type="property" name="The &quot;latency&quot; property" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager--latency"/>
     <keyword type="signal" name="The &quot;clear-pt-map&quot; signal" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager-clear-pt-map"/>
@@ -91,14 +91,14 @@
     <keyword type="signal" name="The &quot;on-timeout&quot; signal" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager-on-timeout"/>
     <keyword type="signal" name="The &quot;request-pt-map&quot; signal" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager-request-pt-map"/>
     <keyword type="signal" name="The &quot;on-npt-stop&quot; signal" link="gst-plugins-ugly-plugins-rdtmanager.html#GstRDTManager-on-npt-stop"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rtspreal.html#idp57221584"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rtspreal.html#idp59004512"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rtspreal.html#id-1.2.12.6.4.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rtspreal.html#id-1.2.12.6.4.2"/>
     <keyword type="struct" name="struct GstRTSPReal" link="gst-plugins-ugly-plugins-rtspreal.html#GstRTSPReal-struct"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rtspwms.html#idp57569408"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rtspwms.html#idp55919664"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-rtspwms.html#id-1.2.13.6.4.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-rtspwms.html#id-1.2.13.6.4.2"/>
     <keyword type="struct" name="struct GstRTSPWMS" link="gst-plugins-ugly-plugins-rtspwms.html#GstRTSPWMS-struct"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-siddec.html#idp53252224"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-siddec.html#idp53259680"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-siddec.html#id-1.2.14.6.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-siddec.html#id-1.2.14.6.2.2"/>
     <keyword type="struct" name="struct GstSidDec" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec-struct"/>
     <keyword type="property" name="The &quot;blocksize&quot; property" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec--blocksize"/>
     <keyword type="property" name="The &quot;clock&quot; property" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec--clock"/>
@@ -109,8 +109,8 @@
     <keyword type="property" name="The &quot;metadata&quot; property" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec--metadata"/>
     <keyword type="property" name="The &quot;mos8580&quot; property" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec--mos8580"/>
     <keyword type="property" name="The &quot;tune&quot; property" link="gst-plugins-ugly-plugins-siddec.html#GstSidDec--tune"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-twolame.html#idp60780496"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-twolame.html#idp60787904"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-twolame.html#id-1.2.15.7.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-twolame.html#id-1.2.15.7.2.2"/>
     <keyword type="struct" name="struct GstTwoLame" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame-struct"/>
     <keyword type="property" name="The &quot;ath-level&quot; property" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame--ath-level"/>
     <keyword type="property" name="The &quot;bitrate&quot; property" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame--bitrate"/>
@@ -127,8 +127,8 @@
     <keyword type="property" name="The &quot;vbr&quot; property" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame--vbr"/>
     <keyword type="property" name="The &quot;vbr-level&quot; property" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame--vbr-level"/>
     <keyword type="property" name="The &quot;vbr-max-bitrate&quot; property" link="gst-plugins-ugly-plugins-twolame.html#GstTwoLame--vbr-max-bitrate"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-x264enc.html#idp60952432"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-x264enc.html#idp60959840"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-x264enc.html#id-1.2.16.7.2.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-x264enc.html#id-1.2.16.7.2.2"/>
     <keyword type="struct" name="struct GstX264Enc" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc-struct"/>
     <keyword type="property" name="The &quot;analyse&quot; property" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc--analyse"/>
     <keyword type="property" name="The &quot;aud&quot; property" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc--aud"/>
@@ -169,9 +169,9 @@
     <keyword type="property" name="The &quot;psy-tune&quot; property" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc--psy-tune"/>
     <keyword type="property" name="The &quot;speed-preset&quot; property" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc--speed-preset"/>
     <keyword type="property" name="The &quot;tune&quot; property" link="gst-plugins-ugly-plugins-x264enc.html#GstX264Enc--tune"/>
-    <keyword type="" name="Example launch line" link="gst-plugins-ugly-plugins-xingmux.html#idp56810976"/>
-    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-xingmux.html#idp58725184"/>
-    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-xingmux.html#idp55787776"/>
+    <keyword type="" name="Example launch line" link="gst-plugins-ugly-plugins-xingmux.html#id-1.2.17.5.4.1"/>
+    <keyword type="" name="Element Information" link="gst-plugins-ugly-plugins-xingmux.html#id-1.2.17.5.5.1"/>
+    <keyword type="" name="Element Pads" link="gst-plugins-ugly-plugins-xingmux.html#id-1.2.17.5.5.2"/>
     <keyword type="struct" name="struct GstXingMux" link="gst-plugins-ugly-plugins-xingmux.html#GstXingMux-struct"/>
   </functions>
 </book>
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-a52dec.html b/docs/plugins/html/gst-plugins-ugly-plugins-a52dec.html
index 590d4e4..64eb30b 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-a52dec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-a52dec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="next" href="gst-plugins-ugly-plugins-amrnbdec.html" title="amrnbdec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -68,7 +68,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp57282416"></a><h3>Element Information</h3>
+<a name="id-1.2.2.6.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -94,7 +94,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp57563760"></a><h3>Element Pads</h3>
+<a name="id-1.2.2.6.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -191,6 +191,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-amrnbdec.html b/docs/plugins/html/gst-plugins-ugly-plugins-amrnbdec.html
index 3024347..d96cab0 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-amrnbdec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-amrnbdec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-a52dec.html" title="a52dec">
 <link rel="next" href="gst-plugins-ugly-plugins-amrnbenc.html" title="amrnbenc">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -66,7 +66,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp58697536"></a><h3>Element Information</h3>
+<a name="id-1.2.3.6.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -92,7 +92,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp58281600"></a><h3>Element Pads</h3>
+<a name="id-1.2.3.6.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -167,6 +167,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-amrnbenc.html b/docs/plugins/html/gst-plugins-ugly-plugins-amrnbenc.html
index 68e5bbb..362a3f9 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-amrnbenc.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-amrnbenc.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-amrnbdec.html" title="amrnbdec">
 <link rel="next" href="gst-plugins-ugly-plugins-amrwbdec.html" title="amrwbdec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -74,7 +74,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp55589472"></a><h3>Element Information</h3>
+<a name="id-1.2.4.7.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -100,7 +100,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp58052064"></a><h3>Element Pads</h3>
+<a name="id-1.2.4.7.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -175,6 +175,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-amrwbdec.html b/docs/plugins/html/gst-plugins-ugly-plugins-amrwbdec.html
index 4e25d4e..9b04d91 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-amrwbdec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-amrwbdec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-amrnbenc.html" title="amrnbenc">
 <link rel="next" href="gst-plugins-ugly-plugins-cdiocddasrc.html" title="cdiocddasrc">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -58,7 +58,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp59286304"></a><h3>Element Information</h3>
+<a name="id-1.2.5.5.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -84,7 +84,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp56094096"></a><h3>Element Pads</h3>
+<a name="id-1.2.5.5.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -150,6 +150,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-cdiocddasrc.html b/docs/plugins/html/gst-plugins-ugly-plugins-cdiocddasrc.html
index 5de8fdf..583532a 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-cdiocddasrc.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-cdiocddasrc.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-amrwbdec.html" title="amrwbdec">
 <link rel="next" href="gst-plugins-ugly-plugins-lamemp3enc.html" title="lamemp3enc">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -76,7 +76,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp57608416"></a><h3>Element Information</h3>
+<a name="id-1.2.6.7.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -102,7 +102,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp59626240"></a><h3>Element Pads</h3>
+<a name="id-1.2.6.7.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -154,6 +154,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-lamemp3enc.html b/docs/plugins/html/gst-plugins-ugly-plugins-lamemp3enc.html
index 17621f5..0bf5e75 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-lamemp3enc.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-lamemp3enc.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-cdiocddasrc.html" title="cdiocddasrc">
 <link rel="next" href="gst-plugins-ugly-plugins-mad.html" title="mad">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -79,7 +79,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp58160064"></a><h3>Element Information</h3>
+<a name="id-1.2.7.7.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -105,7 +105,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp58167472"></a><h3>Element Pads</h3>
+<a name="id-1.2.7.7.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -221,6 +221,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-mad.html b/docs/plugins/html/gst-plugins-ugly-plugins-mad.html
index 2f2053e..e001a80 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-mad.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-mad.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-lamemp3enc.html" title="lamemp3enc">
 <link rel="next" href="gst-plugins-ugly-plugins-rademux.html" title="rademux">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -67,7 +67,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp55641776"></a><h3>Element Information</h3>
+<a name="id-1.2.8.6.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -93,7 +93,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp59720032"></a><h3>Element Pads</h3>
+<a name="id-1.2.8.6.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -175,6 +175,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-a52dec.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-a52dec.html
index 60437f7..01229d9 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-a52dec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-a52dec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-amrnb.html" title="amrnb">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp55647760"></a><h2>Plugin Information</h2>
+<a name="id-1.3.2.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp56019552"></a><h2>Elements</h2>
+<a name="id-1.3.2.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrnb.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrnb.html
index 93622f5..5ecf8fb 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrnb.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrnb.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-a52dec.html" title="a52dec">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-amrwbdec.html" title="amrwbdec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp58004880"></a><h2>Plugin Information</h2>
+<a name="id-1.3.3.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp56774160"></a><h2>Elements</h2>
+<a name="id-1.3.3.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -81,6 +81,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrwbdec.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrwbdec.html
index 1090960..707d098 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrwbdec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-amrwbdec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-amrnb.html" title="amrnb">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-asf.html" title="asf">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp58204896"></a><h2>Plugin Information</h2>
+<a name="id-1.3.4.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp55740928"></a><h2>Elements</h2>
+<a name="id-1.3.4.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-asf.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-asf.html
index c87994a..f72bc98 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-asf.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-asf.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-amrwbdec.html" title="amrwbdec">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-cdio.html" title="cdio">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp59711424"></a><h2>Plugin Information</h2>
+<a name="id-1.3.5.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp55761216"></a><h2>Elements</h2>
+<a name="id-1.3.5.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -85,6 +85,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-cdio.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-cdio.html
index d334fce..03f3eac 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-cdio.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-cdio.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-asf.html" title="asf">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html" title="dvdlpcmdec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp58651184"></a><h2>Plugin Information</h2>
+<a name="id-1.3.6.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp57587936"></a><h2>Elements</h2>
+<a name="id-1.3.6.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html
index 4796a79..cf0dab0 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-cdio.html" title="cdio">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-dvdread.html" title="dvdread">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp60511456"></a><h2>Plugin Information</h2>
+<a name="id-1.3.7.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp57202128"></a><h2>Elements</h2>
+<a name="id-1.3.7.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdread.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdread.html
index 8c8dfdb..f88856a 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdread.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdread.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-dvdlpcmdec.html" title="dvdlpcmdec">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-dvdsub.html" title="dvdsub">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp58275408"></a><h2>Plugin Information</h2>
+<a name="id-1.3.8.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp58316000"></a><h2>Elements</h2>
+<a name="id-1.3.8.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdsub.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdsub.html
index c875cc5..01694a6 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdsub.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-dvdsub.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-dvdread.html" title="dvdread">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-lame.html" title="lame">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp56162512"></a><h2>Plugin Information</h2>
+<a name="id-1.3.9.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp57717216"></a><h2>Elements</h2>
+<a name="id-1.3.9.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -81,6 +81,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-lame.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-lame.html
index 5505575..592b4d0 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-lame.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-lame.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-dvdsub.html" title="dvdsub">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-mad.html" title="mad">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp60666624"></a><h2>Plugin Information</h2>
+<a name="id-1.3.10.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp55978528"></a><h2>Elements</h2>
+<a name="id-1.3.10.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mad.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mad.html
index eabd935..e903ef9 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mad.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mad.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-lame.html" title="lame">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-mpeg2dec.html" title="mpeg2dec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp59385680"></a><h2>Plugin Information</h2>
+<a name="id-1.3.11.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp60666912"></a><h2>Elements</h2>
+<a name="id-1.3.11.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mpeg2dec.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mpeg2dec.html
index 2decce0..de75e2d 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mpeg2dec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-mpeg2dec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-mad.html" title="mad">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-realmedia.html" title="realmedia">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp59136496"></a><h2>Plugin Information</h2>
+<a name="id-1.3.12.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp58232624"></a><h2>Elements</h2>
+<a name="id-1.3.12.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-realmedia.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-realmedia.html
index 28b8201..92ab10d 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-realmedia.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-realmedia.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-mpeg2dec.html" title="mpeg2dec">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-siddec.html" title="siddec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp57548672"></a><h2>Plugin Information</h2>
+<a name="id-1.3.13.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp57673520"></a><h2>Elements</h2>
+<a name="id-1.3.13.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -97,6 +97,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-siddec.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-siddec.html
index 2ae4fb5..1e3a773 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-siddec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-siddec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-realmedia.html" title="realmedia">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-twolame.html" title="twolame">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp56539536"></a><h2>Plugin Information</h2>
+<a name="id-1.3.14.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp56144944"></a><h2>Elements</h2>
+<a name="id-1.3.14.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-twolame.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-twolame.html
index 2da41d2..21ebd4e 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-twolame.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-twolame.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-siddec.html" title="siddec">
 <link rel="next" href="gst-plugins-ugly-plugins-plugin-x264.html" title="x264">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -29,7 +29,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp59201536"></a><h2>Plugin Information</h2>
+<a name="id-1.3.15.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -42,7 +42,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -60,7 +60,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp56495520"></a><h2>Elements</h2>
+<a name="id-1.3.15.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -75,6 +75,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-x264.html b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-x264.html
index f6bc87d..edbe189 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-plugin-x264.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-plugin-x264.html
@@ -7,7 +7,7 @@
 <link rel="home" href="index.html" title="GStreamer Ugly Plugins 1.0 Plugins Reference Manual">
 <link rel="up" href="ch02.html" title="gst-plugins-ugly Plugins">
 <link rel="prev" href="gst-plugins-ugly-plugins-plugin-twolame.html" title="twolame">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -28,7 +28,7 @@
 <td valign="top" align="right"></td>
 </tr></table></div>
 <div class="refsect1">
-<a name="idp55645472"></a><h2>Plugin Information</h2>
+<a name="id-1.3.16.3"></a><h2>Plugin Information</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -41,7 +41,7 @@
 </tr>
 <tr>
 <td><p><span class="term">version</span></p></td>
-<td>1.1.4</td>
+<td>1.1.90</td>
 </tr>
 <tr>
 <td><p><span class="term">run-time license</span></p></td>
@@ -59,7 +59,7 @@
 </table></div>
 </div>
 <div class="refsect1">
-<a name="idp56542416"></a><h2>Elements</h2>
+<a name="id-1.3.16.4"></a><h2>Elements</h2>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -74,6 +74,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-rademux.html b/docs/plugins/html/gst-plugins-ugly-plugins-rademux.html
index 5488e1e..ffb9d77 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-rademux.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-rademux.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-mad.html" title="mad">
 <link rel="next" href="gst-plugins-ugly-plugins-rmdemux.html" title="rmdemux">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -60,7 +60,7 @@
 <p>
 </p>
 <div class="refsect2">
-<a name="idp58360000"></a><h3>Example launch line</h3>
+<a name="id-1.2.9.5.3.1"></a><h3>Example launch line</h3>
 <div class="informalexample">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
     <tbody>
@@ -94,7 +94,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp58768064"></a><h3>Element Information</h3>
+<a name="id-1.2.9.5.5.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -120,7 +120,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp53056896"></a><h3>Element Pads</h3>
+<a name="id-1.2.9.5.5.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -186,6 +186,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-rdtmanager.html b/docs/plugins/html/gst-plugins-ugly-plugins-rdtmanager.html
index 56757b5..408f579 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-rdtmanager.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-rdtmanager.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-rmdemux.html" title="rmdemux">
 <link rel="next" href="gst-plugins-ugly-plugins-rtspreal.html" title="rtspreal">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -84,7 +84,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp58730704"></a><h3>Element Information</h3>
+<a name="id-1.2.11.7.4.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -110,7 +110,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp58256736"></a><h3>Element Pads</h3>
+<a name="id-1.2.11.7.4.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -440,6 +440,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-rmdemux.html b/docs/plugins/html/gst-plugins-ugly-plugins-rmdemux.html
index c6e166a..7aede36 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-rmdemux.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-rmdemux.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-rademux.html" title="rademux">
 <link rel="next" href="gst-plugins-ugly-plugins-rdtmanager.html" title="rdtmanager">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -57,7 +57,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp59701648"></a><h3>Element Information</h3>
+<a name="id-1.2.10.5.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -83,7 +83,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp56179264"></a><h3>Element Pads</h3>
+<a name="id-1.2.10.5.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -173,6 +173,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-rtspreal.html b/docs/plugins/html/gst-plugins-ugly-plugins-rtspreal.html
index cb1cee0..5039c7e 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-rtspreal.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-rtspreal.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-rdtmanager.html" title="rdtmanager">
 <link rel="next" href="gst-plugins-ugly-plugins-rtspwms.html" title="rtspwms">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -71,7 +71,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp57221584"></a><h3>Element Information</h3>
+<a name="id-1.2.12.6.4.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -97,7 +97,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp59004512"></a><h3>Element Pads</h3>
+<a name="id-1.2.12.6.4.2"></a><h3>Element Pads</h3>
 </div>
 </div>
 <p>
@@ -115,6 +115,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-rtspwms.html b/docs/plugins/html/gst-plugins-ugly-plugins-rtspwms.html
index 526c67a..ec23ab6 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-rtspwms.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-rtspwms.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-rtspreal.html" title="rtspreal">
 <link rel="next" href="gst-plugins-ugly-plugins-siddec.html" title="siddec">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -71,7 +71,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp57569408"></a><h3>Element Information</h3>
+<a name="id-1.2.13.6.4.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -97,7 +97,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp55919664"></a><h3>Element Pads</h3>
+<a name="id-1.2.13.6.4.2"></a><h3>Element Pads</h3>
 </div>
 </div>
 <p>
@@ -115,6 +115,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-siddec.html b/docs/plugins/html/gst-plugins-ugly-plugins-siddec.html
index 15e9f83..a037121 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-siddec.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-siddec.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-rtspwms.html" title="rtspwms">
 <link rel="next" href="gst-plugins-ugly-plugins-twolame.html" title="twolame">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -73,7 +73,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp53252224"></a><h3>Element Information</h3>
+<a name="id-1.2.14.6.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -99,7 +99,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp53259680"></a><h3>Element Pads</h3>
+<a name="id-1.2.14.6.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -231,6 +231,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-twolame.html b/docs/plugins/html/gst-plugins-ugly-plugins-twolame.html
index ba7401e..ccb3a8b 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-twolame.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-twolame.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-siddec.html" title="siddec">
 <link rel="next" href="gst-plugins-ugly-plugins-x264enc.html" title="x264enc">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -88,7 +88,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp60780496"></a><h3>Element Information</h3>
+<a name="id-1.2.15.7.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -114,7 +114,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp60787904"></a><h3>Element Pads</h3>
+<a name="id-1.2.15.7.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -296,6 +296,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-x264enc.html b/docs/plugins/html/gst-plugins-ugly-plugins-x264enc.html
index 6da9215..f46a6aa 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-x264enc.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-x264enc.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-twolame.html" title="twolame">
 <link rel="next" href="gst-plugins-ugly-plugins-xingmux.html" title="xingmux">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -112,7 +112,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp60952432"></a><h3>Element Information</h3>
+<a name="id-1.2.16.7.2.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -138,7 +138,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp60959840"></a><h3>Element Pads</h3>
+<a name="id-1.2.16.7.2.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -183,7 +183,7 @@
 </tr>
 <tr>
 <td><p><span class="term">details</span></p></td>
-<td>video/x-h264, framerate=(fraction)[ 0/1, 2147483647/1 ], width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], stream-format=(string){ avc, byte-stream }, alignment=(string)au, profile=(string){ high-10, high, main, baseline, constrained-baseline, high-10-intra }</td>
+<td>video/x-h264, framerate=(fraction)[ 0/1, 2147483647/1 ], width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], stream-format=(string){ avc, byte-stream }, alignment=(string)au, profile=(string){ high-4:4:4, high-4:2:2, high-10, high, main, baseline, constrained-baseline, high-4:4:4-intra, high-4:2:2-intra, high-10-intra }</td>
 </tr>
 </tbody>
 </table></div>
@@ -494,6 +494,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/gst-plugins-ugly-plugins-xingmux.html b/docs/plugins/html/gst-plugins-ugly-plugins-xingmux.html
index b2167f1..fbf424b 100644
--- a/docs/plugins/html/gst-plugins-ugly-plugins-xingmux.html
+++ b/docs/plugins/html/gst-plugins-ugly-plugins-xingmux.html
@@ -8,7 +8,7 @@
 <link rel="up" href="ch01.html" title="gst-plugins-ugly Elements">
 <link rel="prev" href="gst-plugins-ugly-plugins-x264enc.html" title="x264enc">
 <link rel="next" href="ch02.html" title="gst-plugins-ugly Plugins">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -65,7 +65,7 @@
 <p>
 </p>
 <div class="refsect2">
-<a name="idp56810976"></a><h3>Example launch line</h3>
+<a name="id-1.2.17.5.4.1"></a><h3>Example launch line</h3>
 <div class="informalexample">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
     <tbody>
@@ -87,7 +87,7 @@
 <div class="refsynopsisdiv">
 <h2>Synopsis</h2>
 <div class="refsect2">
-<a name="idp58725184"></a><h3>Element Information</h3>
+<a name="id-1.2.17.5.5.1"></a><h3>Element Information</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -113,7 +113,7 @@
 </div>
 <hr>
 <div class="refsect2">
-<a name="idp55787776"></a><h3>Element Pads</h3>
+<a name="id-1.2.17.5.5.2"></a><h3>Element Pads</h3>
 <div class="variablelist"><table border="0" class="variablelist">
 <colgroup>
 <col align="left" valign="top">
@@ -180,6 +180,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/html/index.html b/docs/plugins/html/index.html
index 44a551d..92265b0 100644
--- a/docs/plugins/html/index.html
+++ b/docs/plugins/html/index.html
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
 <link rel="home" href="index.html" title="GStreamer Ugly Plugins 1.0 Plugins Reference Manual">
 <link rel="next" href="ch01.html" title="gst-plugins-ugly Elements">
-<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -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 Ugly Plugins 1.0 Plugins Reference Manual</p></th></tr></table></div>
 <div><p class="releaseinfo">
-      for GStreamer Ugly Plugins 1.0 (1.1.4)
+      for GStreamer Ugly Plugins 1.0 (1.1.90)
       The latest version of this documentation can be found on-line at
       <a class="ulink" href="http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-ugly/html/" target="_top">http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-ugly/html/</a>.
     </p></div>
@@ -126,6 +126,6 @@
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.18</div>
+          Generated by GTK-Doc V1.19</div>
 </body>
 </html>
\ No newline at end of file
diff --git a/docs/plugins/inspect/plugin-a52dec.xml b/docs/plugins/inspect/plugin-a52dec.xml
index 6e1d3d4..bdba84c 100644
--- a/docs/plugins/inspect/plugin-a52dec.xml
+++ b/docs/plugins/inspect/plugin-a52dec.xml
@@ -3,7 +3,7 @@
   <description>Decodes ATSC A/52 encoded audio streams</description>
   <filename>../../ext/a52dec/.libs/libgsta52dec.so</filename>
   <basename>libgsta52dec.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-amrnb.xml b/docs/plugins/inspect/plugin-amrnb.xml
index ae56190..82b3b8c 100644
--- a/docs/plugins/inspect/plugin-amrnb.xml
+++ b/docs/plugins/inspect/plugin-amrnb.xml
@@ -3,7 +3,7 @@
   <description>Adaptive Multi-Rate Narrow-Band</description>
   <filename>../../ext/amrnb/.libs/libgstamrnb.so</filename>
   <basename>libgstamrnb.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>unknown</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-amrwbdec.xml b/docs/plugins/inspect/plugin-amrwbdec.xml
index 5e75d4a..3b9b2dc 100644
--- a/docs/plugins/inspect/plugin-amrwbdec.xml
+++ b/docs/plugins/inspect/plugin-amrwbdec.xml
@@ -3,7 +3,7 @@
   <description>Adaptive Multi-Rate Wide-Band Decoder</description>
   <filename>../../ext/amrwbdec/.libs/libgstamrwbdec.so</filename>
   <basename>libgstamrwbdec.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>unknown</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-asf.xml b/docs/plugins/inspect/plugin-asf.xml
index d442ba9..14515f2 100644
--- a/docs/plugins/inspect/plugin-asf.xml
+++ b/docs/plugins/inspect/plugin-asf.xml
@@ -3,7 +3,7 @@
   <description>Demuxes and muxes audio and video in Microsofts ASF format</description>
   <filename>../../gst/asfdemux/.libs/libgstasf.so</filename>
   <basename>libgstasf.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-cdio.xml b/docs/plugins/inspect/plugin-cdio.xml
index c87a947..920de9a 100644
--- a/docs/plugins/inspect/plugin-cdio.xml
+++ b/docs/plugins/inspect/plugin-cdio.xml
@@ -3,7 +3,7 @@
   <description>Read audio from audio CDs</description>
   <filename>../../ext/cdio/.libs/libgstcdio.so</filename>
   <basename>libgstcdio.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvdlpcmdec.xml b/docs/plugins/inspect/plugin-dvdlpcmdec.xml
index 1c6cd83..fb591b6 100644
--- a/docs/plugins/inspect/plugin-dvdlpcmdec.xml
+++ b/docs/plugins/inspect/plugin-dvdlpcmdec.xml
@@ -3,7 +3,7 @@
   <description>Decode DVD LPCM frames into standard PCM</description>
   <filename>../../gst/dvdlpcmdec/.libs/libgstdvdlpcmdec.so</filename>
   <basename>libgstdvdlpcmdec.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvdread.xml b/docs/plugins/inspect/plugin-dvdread.xml
index 6ad0e60..defe957 100644
--- a/docs/plugins/inspect/plugin-dvdread.xml
+++ b/docs/plugins/inspect/plugin-dvdread.xml
@@ -3,7 +3,7 @@
   <description>Access a DVD with dvdread</description>
   <filename>../../ext/dvdread/.libs/libgstdvdread.so</filename>
   <basename>libgstdvdread.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-dvdsub.xml b/docs/plugins/inspect/plugin-dvdsub.xml
index 5df70d0..88b4f6b 100644
--- a/docs/plugins/inspect/plugin-dvdsub.xml
+++ b/docs/plugins/inspect/plugin-dvdsub.xml
@@ -3,7 +3,7 @@
   <description>DVD subtitle parser and decoder</description>
   <filename>../../gst/dvdsub/.libs/libgstdvdsub.so</filename>
   <basename>libgstdvdsub.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-lame.xml b/docs/plugins/inspect/plugin-lame.xml
index 79612fd..eeba6d8 100644
--- a/docs/plugins/inspect/plugin-lame.xml
+++ b/docs/plugins/inspect/plugin-lame.xml
@@ -3,7 +3,7 @@
   <description>Encode MP3s with LAME</description>
   <filename>../../ext/lame/.libs/libgstlame.so</filename>
   <basename>libgstlame.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mad.xml b/docs/plugins/inspect/plugin-mad.xml
index 8817f31..0fefba0 100644
--- a/docs/plugins/inspect/plugin-mad.xml
+++ b/docs/plugins/inspect/plugin-mad.xml
@@ -3,7 +3,7 @@
   <description>mp3 decoding based on the mad library</description>
   <filename>../../ext/mad/.libs/libgstmad.so</filename>
   <basename>libgstmad.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-mpeg2dec.xml b/docs/plugins/inspect/plugin-mpeg2dec.xml
index 1d80912..e6e715a 100644
--- a/docs/plugins/inspect/plugin-mpeg2dec.xml
+++ b/docs/plugins/inspect/plugin-mpeg2dec.xml
@@ -3,7 +3,7 @@
   <description>LibMpeg2 decoder</description>
   <filename>../../ext/mpeg2dec/.libs/libgstmpeg2dec.so</filename>
   <basename>libgstmpeg2dec.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-realmedia.xml b/docs/plugins/inspect/plugin-realmedia.xml
index 6f54519..87d50f6 100644
--- a/docs/plugins/inspect/plugin-realmedia.xml
+++ b/docs/plugins/inspect/plugin-realmedia.xml
@@ -3,7 +3,7 @@
   <description>RealMedia support plugins</description>
   <filename>../../gst/realmedia/.libs/libgstrmdemux.so</filename>
   <basename>libgstrmdemux.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-siddec.xml b/docs/plugins/inspect/plugin-siddec.xml
index 5dc4c1e..f642b98 100644
--- a/docs/plugins/inspect/plugin-siddec.xml
+++ b/docs/plugins/inspect/plugin-siddec.xml
@@ -3,7 +3,7 @@
   <description>Uses libsidplay to decode .sid files</description>
   <filename>../../ext/sidplay/.libs/libgstsid.so</filename>
   <basename>libgstsid.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-twolame.xml b/docs/plugins/inspect/plugin-twolame.xml
index ade173f..b101a8a 100644
--- a/docs/plugins/inspect/plugin-twolame.xml
+++ b/docs/plugins/inspect/plugin-twolame.xml
@@ -3,7 +3,7 @@
   <description>Encode MP2s with TwoLAME</description>
   <filename>../../ext/twolame/.libs/libgsttwolame.so</filename>
   <basename>libgsttwolame.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/docs/plugins/inspect/plugin-x264.xml b/docs/plugins/inspect/plugin-x264.xml
index 8d1b296..61a1839 100644
--- a/docs/plugins/inspect/plugin-x264.xml
+++ b/docs/plugins/inspect/plugin-x264.xml
@@ -3,7 +3,7 @@
   <description>libx264-based H264 plugins</description>
   <filename>../../ext/x264/.libs/libgstx264.so</filename>
   <basename>libgstx264.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>GPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
@@ -26,7 +26,7 @@
           <name>src</name>
           <direction>source</direction>
           <presence>always</presence>
-          <details>video/x-h264, framerate=(fraction)[ 0/1, 2147483647/1 ], width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], stream-format=(string){ avc, byte-stream }, alignment=(string)au, profile=(string){ high-10, high, main, baseline, constrained-baseline, high-10-intra }</details>
+          <details>video/x-h264, framerate=(fraction)[ 0/1, 2147483647/1 ], width=(int)[ 1, 2147483647 ], height=(int)[ 1, 2147483647 ], stream-format=(string){ avc, byte-stream }, alignment=(string)au, profile=(string){ high-4:4:4, high-4:2:2, high-10, high, main, baseline, constrained-baseline, high-4:4:4-intra, high-4:2:2-intra, high-10-intra }</details>
         </caps>
       </pads>
     </element>
diff --git a/docs/plugins/inspect/plugin-xingmux.xml b/docs/plugins/inspect/plugin-xingmux.xml
index 3bf31f2..e686e8e 100644
--- a/docs/plugins/inspect/plugin-xingmux.xml
+++ b/docs/plugins/inspect/plugin-xingmux.xml
@@ -3,7 +3,7 @@
   <description>Add XING tags to mpeg audio files</description>
   <filename>../../gst/xingmux/.libs/libgstxingmux.so</filename>
   <basename>libgstxingmux.so</basename>
-  <version>1.1.4</version>
+  <version>1.1.90</version>
   <license>LGPL</license>
   <source>gst-plugins-ugly</source>
   <package>GStreamer Ugly Plug-ins source release</package>
diff --git a/ext/Makefile.in b/ext/Makefile.in
index 6bea85b..d658772 100644
--- a/ext/Makefile.in
+++ b/ext/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/a52dec/Makefile.in b/ext/a52dec/Makefile.in
index c2d6ad9..183edb5 100644
--- a/ext/a52dec/Makefile.in
+++ b/ext/a52dec/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/amrnb/Makefile.in b/ext/amrnb/Makefile.in
index d2a33f2..3b75141 100644
--- a/ext/amrnb/Makefile.in
+++ b/ext/amrnb/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/amrwbdec/Makefile.in b/ext/amrwbdec/Makefile.in
index 613de0b..4123f03 100644
--- a/ext/amrwbdec/Makefile.in
+++ b/ext/amrwbdec/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/cdio/Makefile.in b/ext/cdio/Makefile.in
index 5c3af65..2ce6038 100644
--- a/ext/cdio/Makefile.in
+++ b/ext/cdio/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/dvdread/Makefile.in b/ext/dvdread/Makefile.in
index 953d014..9150bfe 100644
--- a/ext/dvdread/Makefile.in
+++ b/ext/dvdread/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/lame/Makefile.in b/ext/lame/Makefile.in
index 851ea00..6bba547 100644
--- a/ext/lame/Makefile.in
+++ b/ext/lame/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/mad/Makefile.in b/ext/mad/Makefile.in
index 77d33bc..be78998 100644
--- a/ext/mad/Makefile.in
+++ b/ext/mad/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/mpeg2dec/Makefile.in b/ext/mpeg2dec/Makefile.in
index 2ad05dd..474263b 100644
--- a/ext/mpeg2dec/Makefile.in
+++ b/ext/mpeg2dec/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/sidplay/Makefile.in b/ext/sidplay/Makefile.in
index 429a93d..598bf19 100644
--- a/ext/sidplay/Makefile.in
+++ b/ext/sidplay/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/twolame/Makefile.in b/ext/twolame/Makefile.in
index 7115c95..c2d7877 100644
--- a/ext/twolame/Makefile.in
+++ b/ext/twolame/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/x264/Makefile.in b/ext/x264/Makefile.in
index 3d116c7..9b24b1d 100644
--- a/ext/x264/Makefile.in
+++ b/ext/x264/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/ext/x264/gstx264enc.c b/ext/x264/gstx264enc.c
index 1eb6f1c..dcaf5d0 100644
--- a/ext/x264/gstx264enc.c
+++ b/ext/x264/gstx264enc.c
@@ -412,8 +412,9 @@
         "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ], "
         "stream-format = (string) { avc, byte-stream }, "
         "alignment = (string) au, "
-        "profile = (string) { high-10, high, main, baseline, "
-        "constrained-baseline, high-10-intra }")
+        "profile = (string) { high-4:4:4, high-4:2:2, high-10, high, main,"
+        " baseline, constrained-baseline, high-4:4:4-intra, high-4:2:2-intra,"
+        " high-10-intra }")
     );
 
 static void gst_x264_enc_finalize (GObject * object);
@@ -498,53 +499,51 @@
     g_value_unset (&sval);
 }
 
-static GstCaps *
-gst_x264_enc_get_supported_input_caps (void)
+static void
+gst_x264_enc_add_x264_chroma_format (GstStructure * s,
+    int x264_chroma_format_local)
 {
   GValue fmt = G_VALUE_INIT;
-  GstCaps *caps;
-
-  caps = gst_caps_new_empty_simple ("video/x-raw");
 
   if (x264_bit_depth == 8) {
     GST_INFO ("This x264 build supports 8-bit depth");
-    if (x264_chroma_format == 0) {
+    if (x264_chroma_format_local == 0) {
       set_value (&fmt, 5, "I420", "YV12", "Y42B", "Y444", "NV12");
-    } else if (x264_chroma_format == X264_CSP_I420) {
+    } else if (x264_chroma_format_local == X264_CSP_I420) {
       set_value (&fmt, 3, "I420", "YV12", "NV12");
-    } else if (x264_chroma_format == X264_CSP_I422) {
+    } else if (x264_chroma_format_local == X264_CSP_I422) {
       set_value (&fmt, 1, "Y42B");
-    } else if (x264_chroma_format == X264_CSP_I444) {
+    } else if (x264_chroma_format_local == X264_CSP_I444) {
       set_value (&fmt, 1, "Y444");
     } else {
-      GST_ERROR ("Unsupported chroma format %d", x264_chroma_format);
+      GST_ERROR ("Unsupported chroma format %d", x264_chroma_format_local);
     }
   } else if (x264_bit_depth == 10) {
     GST_INFO ("This x264 build supports 10-bit depth");
 
     if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
-      if (x264_chroma_format == 0) {
+      if (x264_chroma_format_local == 0) {
         set_value (&fmt, 3, "I420_10LE", "I422_10LE", "Y444_10LE");
-      } else if (x264_chroma_format == X264_CSP_I420) {
+      } else if (x264_chroma_format_local == X264_CSP_I420) {
         set_value (&fmt, 1, "I420_10LE");
-      } else if (x264_chroma_format == X264_CSP_I422) {
-        set_value (&fmt, 1, "Y422_10LE");
-      } else if (x264_chroma_format == X264_CSP_I444) {
+      } else if (x264_chroma_format_local == X264_CSP_I422) {
+        set_value (&fmt, 1, "I422_10LE");
+      } else if (x264_chroma_format_local == X264_CSP_I444) {
         set_value (&fmt, 1, "Y444_10LE");
       } else {
-        GST_ERROR ("Unsupported chroma format %d", x264_chroma_format);
+        GST_ERROR ("Unsupported chroma format %d", x264_chroma_format_local);
       }
     } else {
-      if (x264_chroma_format == 0) {
+      if (x264_chroma_format_local == 0) {
         set_value (&fmt, 3, "I420_10BE", "I422_10BE", "Y444_10BE");
-      } else if (x264_chroma_format == X264_CSP_I420) {
+      } else if (x264_chroma_format_local == X264_CSP_I420) {
         set_value (&fmt, 1, "I420_10BE");
-      } else if (x264_chroma_format == X264_CSP_I422) {
-        set_value (&fmt, 1, "Y422_10BE");
-      } else if (x264_chroma_format == X264_CSP_I444) {
+      } else if (x264_chroma_format_local == X264_CSP_I422) {
+        set_value (&fmt, 1, "I422_10BE");
+      } else if (x264_chroma_format_local == X264_CSP_I444) {
         set_value (&fmt, 1, "Y444_10BE");
       } else {
-        GST_ERROR ("Unsupported chroma format %d", x264_chroma_format);
+        GST_ERROR ("Unsupported chroma format %d", x264_chroma_format_local);
       }
     }
   } else {
@@ -553,28 +552,135 @@
   }
 
   if (G_VALUE_TYPE (&fmt) != G_TYPE_INVALID)
-    gst_structure_take_value (gst_caps_get_structure (caps, 0), "format", &fmt);
+    gst_structure_take_value (s, "format", &fmt);
+}
 
-  gst_caps_set_simple (caps,
+static GstCaps *
+gst_x264_enc_get_supported_input_caps (void)
+{
+  GstCaps *caps;
+
+  caps = gst_caps_new_simple ("video/x-raw",
       "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1,
       "width", GST_TYPE_INT_RANGE, 16, G_MAXINT,
       "height", GST_TYPE_INT_RANGE, 16, G_MAXINT, NULL);
 
+  gst_x264_enc_add_x264_chroma_format (gst_caps_get_structure (caps, 0),
+      x264_chroma_format);
+
   GST_DEBUG ("returning %" GST_PTR_FORMAT, caps);
   return caps;
 }
 
+static void
+check_formats (const gchar * str, gboolean * has_420, gboolean * has_422,
+    gboolean * has_444)
+{
+  if (g_str_has_prefix (str, "high-4:4:4"))
+    *has_444 = TRUE;
+  else if (g_str_has_prefix (str, "high-4:2:2"))
+    *has_422 = TRUE;
+  else
+    *has_420 = TRUE;
+}
+
+
 /* allowed input caps depending on whether libx264 was built for 8 or 10 bits */
 static GstCaps *
 gst_x264_enc_sink_getcaps (GstVideoEncoder * enc, GstCaps * filter)
 {
-  GstCaps *supported_incaps, *caps;
+  GstCaps *supported_incaps;
+  GstCaps *allowed;
+  GstCaps *filter_caps, *fcaps;
+  gint i, j, k;
 
   supported_incaps = gst_x264_enc_get_supported_input_caps ();
-  caps = gst_video_encoder_proxy_getcaps (enc, supported_incaps, filter);
+
+  /* Allow downstream to specify width/height/framerate/PAR constraints
+   * and forward them upstream for video converters to handle
+   */
+  if (!supported_incaps)
+    supported_incaps = gst_pad_get_pad_template_caps (enc->sinkpad);
+  allowed = gst_pad_get_allowed_caps (enc->srcpad);
+
+  if (!allowed || gst_caps_is_empty (allowed) || gst_caps_is_any (allowed)) {
+    fcaps = supported_incaps;
+    goto done;
+  }
+
+  GST_LOG_OBJECT (enc, "template caps %" GST_PTR_FORMAT, supported_incaps);
+  GST_LOG_OBJECT (enc, "allowed caps %" GST_PTR_FORMAT, allowed);
+
+  filter_caps = gst_caps_new_empty ();
+
+  for (i = 0; i < gst_caps_get_size (supported_incaps); i++) {
+    GQuark q_name =
+        gst_structure_get_name_id (gst_caps_get_structure (supported_incaps,
+            i));
+
+    for (j = 0; j < gst_caps_get_size (allowed); j++) {
+      const GstStructure *allowed_s = gst_caps_get_structure (allowed, j);
+      const GValue *val;
+      GstStructure *s;
+
+      s = gst_structure_new_id_empty (q_name);
+      if ((val = gst_structure_get_value (allowed_s, "width")))
+        gst_structure_set_value (s, "width", val);
+      if ((val = gst_structure_get_value (allowed_s, "height")))
+        gst_structure_set_value (s, "height", val);
+      if ((val = gst_structure_get_value (allowed_s, "framerate")))
+        gst_structure_set_value (s, "framerate", val);
+      if ((val = gst_structure_get_value (allowed_s, "pixel-aspect-ratio")))
+        gst_structure_set_value (s, "pixel-aspect-ratio", val);
+      if ((val = gst_structure_get_value (allowed_s, "profile"))) {
+        gboolean has_420 = FALSE;
+        gboolean has_422 = FALSE;
+        gboolean has_444 = FALSE;
+
+        if (G_VALUE_HOLDS_STRING (val)) {
+          check_formats (g_value_get_string (val), &has_420, &has_422,
+              &has_444);
+        } else if (GST_VALUE_HOLDS_LIST (val)) {
+          for (k = 0; k < gst_value_list_get_size (val); k++) {
+            const GValue *vlist = gst_value_list_get_value (val, k);
+
+            if (G_VALUE_HOLDS_STRING (vlist))
+              check_formats (g_value_get_string (vlist), &has_420, &has_422,
+                  &has_444);
+          }
+        }
+
+        if (has_444 && has_422 && has_420)
+          gst_x264_enc_add_x264_chroma_format (s, 0);
+        else if (has_444)
+          gst_x264_enc_add_x264_chroma_format (s, X264_CSP_I444);
+        else if (has_422)
+          gst_x264_enc_add_x264_chroma_format (s, X264_CSP_I422);
+        else if (has_420)
+          gst_x264_enc_add_x264_chroma_format (s, X264_CSP_I420);
+      }
+
+      filter_caps = gst_caps_merge_structure (filter_caps, s);
+    }
+  }
+
+  fcaps = gst_caps_intersect (filter_caps, supported_incaps);
+  gst_caps_unref (filter_caps);
   gst_caps_unref (supported_incaps);
 
-  return caps;
+  if (filter) {
+    GST_LOG_OBJECT (enc, "intersecting with %" GST_PTR_FORMAT, filter);
+    filter_caps = gst_caps_intersect (fcaps, filter);
+    gst_caps_unref (fcaps);
+    fcaps = filter_caps;
+  }
+
+done:
+  gst_caps_replace (&allowed, NULL);
+
+  GST_LOG_OBJECT (enc, "proxy caps %" GST_PTR_FORMAT, fcaps);
+
+  return fcaps;
 }
 
 static void
@@ -1169,7 +1275,14 @@
 gst_x264_enc_init_encoder (GstX264Enc * encoder)
 {
   guint pass = 0;
-  GstVideoInfo *info = &encoder->input_state->info;
+  GstVideoInfo *info;
+
+  if (!encoder->input_state) {
+    GST_DEBUG_OBJECT (encoder, "Have no input state yet");
+    return FALSE;
+  }
+
+  info = &encoder->input_state->info;
 
   /* make sure that the encoder is closed */
   gst_x264_enc_close_encoder (encoder);
@@ -1669,7 +1782,7 @@
   }
 
   if (encoder->input_state)
-    gst_video_codec_state_unref (state);
+    gst_video_codec_state_unref (encoder->input_state);
   encoder->input_state = gst_video_codec_state_ref (state);
 
   encoder->peer_profile = NULL;
@@ -1705,15 +1818,19 @@
       /* FIXME - if libx264 ever adds support for FMO, ASO or redundant slices
        * make sure constrained profile has a separate case which disables
        * those */
+      if (g_str_has_suffix (profile, "-intra")) {
+        encoder->peer_intra_profile = TRUE;
+      }
       if (!strcmp (profile, "constrained-baseline") ||
           !strcmp (profile, "baseline")) {
         encoder->peer_profile = "baseline";
-      } else if (!strcmp (profile, "high-10-intra")) {
-        encoder->peer_intra_profile = TRUE;
+      } else if (g_str_has_prefix (profile, "high-10")) {
         encoder->peer_profile = "high10";
-      } else if (!strcmp (profile, "high-10")) {
-        encoder->peer_profile = "high10";
-      } else if (!strcmp (profile, "high")) {
+      } else if (g_str_has_prefix (profile, "high-4:2:2")) {
+        encoder->peer_profile = "high422";
+      } else if (g_str_has_prefix (profile, "high-4:4:4")) {
+        encoder->peer_profile = "high444";
+      } else if (g_str_has_prefix (profile, "high")) {
         encoder->peer_profile = "high";
       } else if (!strcmp (profile, "main")) {
         encoder->peer_profile = "main";
@@ -1964,7 +2081,7 @@
     }
   }
 
-  if (pic_out.i_dts + encoder->dts_offset < 0) {
+  if (pic_out.i_dts + (gint64) encoder->dts_offset < 0) {
     /* should be ok now, surprise if not */
     GST_WARNING_OBJECT (encoder, "negative dts after offset compensation");
     frame->dts = GST_CLOCK_TIME_NONE;
diff --git a/gst-libs/Makefile.in b/gst-libs/Makefile.in
index 7c9e6db..74df936 100644
--- a/gst-libs/Makefile.in
+++ b/gst-libs/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst-libs/gst/Makefile.in b/gst-libs/gst/Makefile.in
index 231bf86..22d7e62 100644
--- a/gst-libs/gst/Makefile.in
+++ b/gst-libs/gst/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst-plugins-ugly.doap b/gst-plugins-ugly.doap
index e5c1d48..fcf64c3 100644
--- a/gst-plugins-ugly.doap
+++ b/gst-plugins-ugly.doap
@@ -35,6 +35,16 @@
 
  <release>
   <Version>
+   <revision>1.1.90</revision>
+   <branch>1.1</branch>
+   <name></name>
+   <created>2013-09-19</created>
+   <file-release rdf:resource="http://gstreamer.freedesktop.org/src/gst-plugins-ugly/gst-plugins-ugly-1.1.90.tar.xz" />
+  </Version>
+ </release>
+
+ <release>
+  <Version>
    <revision>1.1.4</revision>
    <branch>1.1</branch>
    <name></name>
diff --git a/gst-plugins-ugly.spec b/gst-plugins-ugly.spec
index e8b5a22..095867f 100644
--- a/gst-plugins-ugly.spec
+++ b/gst-plugins-ugly.spec
@@ -4,7 +4,7 @@
 %define gst_minver  0.11.0
 
 Name: 		%{gstreamer}-plugins-ugly
-Version: 	1.1.4
+Version: 	1.1.90
 Release: 	1.gst
 Summary: 	GStreamer streaming media framework "ugly" plug-ins
 
diff --git a/gst/Makefile.in b/gst/Makefile.in
index 49561ba..875d433 100644
--- a/gst/Makefile.in
+++ b/gst/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst/asfdemux/Makefile.in b/gst/asfdemux/Makefile.in
index ea990f4..21a76f1 100644
--- a/gst/asfdemux/Makefile.in
+++ b/gst/asfdemux/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst/asfdemux/asfpacket.c b/gst/asfdemux/asfpacket.c
index 8f6dc23..ecf1e05 100644
--- a/gst/asfdemux/asfpacket.c
+++ b/gst/asfdemux/asfpacket.c
@@ -190,19 +190,6 @@
     GST_BUFFER_FLAG_SET (payload->buf, GST_BUFFER_FLAG_DISCONT);
   }
 
-  /* remember the first queued timestamp for the segment */
-  if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (demux->segment_ts) &&
-          GST_CLOCK_TIME_IS_VALID (demux->first_ts))) {
-    GST_DEBUG_OBJECT (demux, "segment ts: %" GST_TIME_FORMAT,
-        GST_TIME_ARGS (demux->first_ts));
-    demux->segment_ts = demux->first_ts;
-    /* always note, but only determines segment when streaming */
-    if (demux->streaming)
-      gst_segment_do_seek (&demux->segment, demux->in_segment.rate,
-          GST_FORMAT_TIME, (GstSeekFlags) demux->segment.flags,
-          GST_SEEK_TYPE_SET, demux->segment_ts, GST_SEEK_TYPE_NONE, 0, NULL);
-  }
-
   g_array_append_vals (stream->payloads, payload, 1);
 }
 
diff --git a/gst/asfdemux/gstasfdemux.c b/gst/asfdemux/gstasfdemux.c
index b64ee40..ec44035 100644
--- a/gst/asfdemux/gstasfdemux.c
+++ b/gst/asfdemux/gstasfdemux.c
@@ -1314,6 +1314,23 @@
 }
 #endif
 
+static void
+gst_asf_demux_check_segment_ts (GstASFDemux * demux, GstClockTime payload_ts)
+{
+  /* remember the first queued timestamp for the segment */
+  if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (demux->segment_ts) &&
+          GST_CLOCK_TIME_IS_VALID (demux->first_ts))) {
+    GST_DEBUG_OBJECT (demux, "segment ts: %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (demux->first_ts));
+    demux->segment_ts = payload_ts;
+    /* always note, but only determines segment when streaming */
+    if (demux->streaming)
+      gst_segment_do_seek (&demux->segment, demux->in_segment.rate,
+          GST_FORMAT_TIME, (GstSeekFlags) demux->segment.flags,
+          GST_SEEK_TYPE_SET, demux->segment_ts, GST_SEEK_TYPE_NONE, 0, NULL);
+  }
+}
+
 static gboolean
 gst_asf_demux_check_first_ts (GstASFDemux * demux, gboolean force)
 {
@@ -1368,6 +1385,8 @@
     }
   }
 
+  gst_asf_demux_check_segment_ts (demux, 0);
+
   return TRUE;
 }
 
@@ -1505,6 +1524,11 @@
               || !GST_CLOCK_TIME_IS_VALID (payload->ts)); --last_idx) {
         payload = &g_array_index (stream->payloads, AsfPayload, last_idx);
       }
+
+      /* if this is first payload after seek we might need to update the segment */
+      if (GST_CLOCK_TIME_IS_VALID (payload->ts))
+        gst_asf_demux_check_segment_ts (demux, payload->ts);
+
       if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (payload->ts) &&
               (payload->ts < demux->segment.start))) {
         if (G_UNLIKELY ((!demux->accurate) && payload->keyframe)) {
@@ -1558,14 +1582,14 @@
     /* streams are now activated */
   }
 
-  /* wait until we had a chance to "lock on" some payload's timestamp */
-  if (G_UNLIKELY (demux->need_newsegment
-          && !GST_CLOCK_TIME_IS_VALID (demux->segment_ts)))
-    return GST_FLOW_OK;
-
   while ((stream = gst_asf_demux_find_stream_with_complete_payload (demux))) {
     AsfPayload *payload;
 
+    /* wait until we had a chance to "lock on" some payload's timestamp */
+    if (G_UNLIKELY (demux->need_newsegment
+            && !GST_CLOCK_TIME_IS_VALID (demux->segment_ts)))
+      return GST_FLOW_OK;
+
     payload = &g_array_index (stream->payloads, AsfPayload, 0);
 
     /* do we need to send a newsegment event */
diff --git a/gst/asfdemux/gstasfdemux.h b/gst/asfdemux/gstasfdemux.h
index deddb4d..b669d57 100644
--- a/gst/asfdemux/gstasfdemux.h
+++ b/gst/asfdemux/gstasfdemux.h
@@ -171,7 +171,6 @@
   GstClockTime         first_ts;        /* smallest timestamp found        */
 
   guint32              packet_size;
-  guint32              timestamp;       /* in milliseconds              */
   guint64              play_time;
 
   guint64              preroll;
diff --git a/gst/dvdlpcmdec/Makefile.in b/gst/dvdlpcmdec/Makefile.in
index 8c19409..7e66a04 100644
--- a/gst/dvdlpcmdec/Makefile.in
+++ b/gst/dvdlpcmdec/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst/dvdsub/Makefile.in b/gst/dvdsub/Makefile.in
index afec5c6..8b5f263 100644
--- a/gst/dvdsub/Makefile.in
+++ b/gst/dvdsub/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst/realmedia/Makefile.in b/gst/realmedia/Makefile.in
index 2ae1c36..c0ddfcd 100644
--- a/gst/realmedia/Makefile.in
+++ b/gst/realmedia/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/gst/xingmux/Makefile.in b/gst/xingmux/Makefile.in
index a173b4b..1967a60 100644
--- a/gst/xingmux/Makefile.in
+++ b/gst/xingmux/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/m4/Makefile.in b/m4/Makefile.in
index 537b3bd..e7ae8bd 100644
--- a/m4/Makefile.in
+++ b/m4/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/pkgconfig/Makefile.in b/pkgconfig/Makefile.in
index 8214b8b..01be6d5 100644
--- a/pkgconfig/Makefile.in
+++ b/pkgconfig/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/po/af.gmo b/po/af.gmo
index 77d41c2..1e6f2b7 100644
--- a/po/af.gmo
+++ b/po/af.gmo
Binary files differ
diff --git a/po/af.po b/po/af.po
index f30e298..4c55077 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: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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 05f53b3..683b8c2 100644
--- a/po/az.gmo
+++ b/po/az.gmo
Binary files differ
diff --git a/po/az.po b/po/az.po
index 5395cec..f1e385c 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: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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 81691b0..b4963c5 100644
--- a/po/bg.gmo
+++ b/po/bg.gmo
Binary files differ
diff --git a/po/bg.po b/po/bg.po
index 4a7f62b..68784af 100644
--- a/po/bg.po
+++ b/po/bg.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-04-26 22:34+0300\n"
 "Last-Translator: Alexander Shopov <ash@kambanaria.org>\n"
 "Language-Team: Bulgarian <dict@fsa-bg.org>\n"
diff --git a/po/ca.gmo b/po/ca.gmo
index 155b9bc..59f8e3d 100644
--- a/po/ca.gmo
+++ b/po/ca.gmo
Binary files differ
diff --git a/po/ca.po b/po/ca.po
index bdf1754..297a9e3 100644
--- a/po/ca.po
+++ b/po/ca.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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 fc7dda7..05f9a32 100644
--- a/po/cs.gmo
+++ b/po/cs.gmo
Binary files differ
diff --git a/po/cs.po b/po/cs.po
index c9a7d1d..e0a9fdb 100644
--- a/po/cs.po
+++ b/po/cs.po
@@ -2,38 +2,41 @@
 # Copyright (C) 2007, 2008, 2009 the author(s) of gst-plugins-ugly.
 # Copyright (C) 2004 Miloslav Trmac <mitr@volny.cz>.
 # This file is put in the public domain.
+#
 # Miloslav Trmac <mitr@volny.cz>, 2004.
 # Petr Kovar <pknbe@volny.cz>, 2007, 2008, 2009.
+# Marek Černocký <marek@manet.cz>, 2013.
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-ugly-0.10.10.2\n"
+"Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
-"PO-Revision-Date: 2009-03-16 03:46+0100\n"
-"Last-Translator: Petr Kovar <pknbe@volny.cz>\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
+"PO-Revision-Date: 2013-09-07 07:06+0200\n"
+"Last-Translator: Marek Černocký <marek@manet.cz>\n"
 "Language-Team: Czech <translation-team-cs@lists.sourceforge.net>\n"
 "Language: cs\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"
+"X-Generator: Gtranslator 2.91.6\n"
 
 msgid "Could not read from CD."
 msgstr "Nezdařilo se čtení z CD."
 
 msgid "Could not open CD device for reading."
-msgstr "Nezdařilo se otevření zařízení CD ke čtení."
+msgstr "Nezdařilo se otevřít zařízení CD pro čtení."
 
 msgid "Disc is not an Audio CD."
 msgstr "Disk není zvukovým CD."
 
 msgid "Could not open DVD"
-msgstr "Nezdařilo se otevření DVD"
+msgstr "Nezdařilo se otevřít DVD"
 
 #, c-format
 msgid "Could not open DVD title %d"
-msgstr "Nezdařilo se otevření titulu DVD %d"
+msgstr "Nezdařilo se otevřít titul DVD %d"
 
 #, c-format
 msgid "Failed to go to chapter %d of DVD title %d"
@@ -44,59 +47,37 @@
 "Could not open DVD title %d. Interactive titles are not supported by this "
 "element"
 msgstr ""
-"Nezdařilo se otevření titulu DVD %d. Interaktivní tituly nejsou tímto prvkem "
+"Nezdařilo se otevřít titul DVD %d. Interaktivní tituly nejsou tímto prvkem "
 "podporovány"
 
 msgid ""
 "Could not read DVD. This may be because the DVD is encrypted and a DVD "
 "decryption library is not installed."
 msgstr ""
+"Nezdařilo se čtení DVD. To může být způsobeno tím, že je DVD šifrováno a "
+"knihovna pro dešifrování DVD není nainstalována."
 
-#, fuzzy
 msgid "Could not read DVD."
-msgstr "Nezdařilo se otevření DVD"
+msgstr "Nezdařilo se čtení DVD."
 
-#, fuzzy
 msgid ""
 "Failed to configure LAME mp3 audio encoder. Check your encoding parameters."
 msgstr ""
-"Nezdařilo se nastavení kodéru TwoLAME. Je nutné zkontrolovat parametry "
-"kódování."
+"Selhalo nastavení zvukového kodéru LAME mp3. Zkontrolujte parametry kódování."
 
 #, c-format
 msgid ""
 "The requested bitrate %d kbit/s for property '%s' is not allowed. The "
 "bitrate was changed to %d kbit/s."
 msgstr ""
-"Požadovaný datový tok %d kilobitů za sekundu není u vlastnosti \"%s\" "
-"povolen. Datový tok byl změněn na %d kilobitů za sekundu."
+"Požadovaný datový tok %d kb/s za sekundu není u vlastnosti „%s“ povolen. "
+"Datový tok byl změněn na %d kb/s."
 
 msgid "Failed to configure TwoLAME encoder. Check your encoding parameters."
-msgstr ""
-"Nezdařilo se nastavení kodéru TwoLAME. Je nutné zkontrolovat parametry "
-"kódování."
+msgstr "Selhalo nastavení kodéru TwoLAME. Zkontrolujte parametry kódování."
 
 msgid "This stream contains no data."
 msgstr "Tento proud neobsahuje žádná data."
 
 msgid "Internal data stream error."
 msgstr "Interní chyba datového proudu."
-
-#, fuzzy
-#~ msgid ""
-#~ "Failed to configure LAMEMP3ENC encoder. Check your encoding parameters."
-#~ msgstr ""
-#~ "Nezdařilo se nastavení kodéru LAME. Je nutné zkontrolovat parametry "
-#~ "kódování."
-
-#~ msgid "Invalid title information on DVD."
-#~ msgstr "Neplatná informace o titulu na DVD."
-
-#~ msgid "Could not read title information for DVD."
-#~ msgstr "Nezdařilo se čtení informace o titulu u DVD."
-
-#~ msgid "Failed to open DVD device '%s'."
-#~ msgstr "Nezdařilo se otevření zařízení DVD \"%s\"."
-
-#~ msgid "Failed to set PGC based seeking."
-#~ msgstr "Nezdařilo se připravit hledání založené na PGC."
diff --git a/po/da.gmo b/po/da.gmo
index c40f920..7328cbd 100644
--- a/po/da.gmo
+++ b/po/da.gmo
Binary files differ
diff --git a/po/da.po b/po/da.po
index c721b99..c5d1f06 100644
--- a/po/da.po
+++ b/po/da.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-09 03:56+0100\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 523e9a6..de5b34f 100644
--- a/po/de.gmo
+++ b/po/de.gmo
Binary files differ
diff --git a/po/de.po b/po/de.po
index 2a21720..5cc15a3 100644
--- a/po/de.po
+++ b/po/de.po
@@ -13,7 +13,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-11-28 20:25+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 240f5ac..ef4d694 100644
--- a/po/el.gmo
+++ b/po/el.gmo
Binary files differ
diff --git a/po/el.po b/po/el.po
index 74405c1..44a0e90 100644
--- a/po/el.po
+++ b/po/el.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-03-18 01:04+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 62ff078..f4eba60 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 96a194d..dcd0fc3 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: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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 c419fdf..9e57a2c 100644
--- a/po/eo.gmo
+++ b/po/eo.gmo
Binary files differ
diff --git a/po/eo.po b/po/eo.po
index bd22d87..90ea3c9 100644
--- a/po/eo.po
+++ b/po/eo.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-06-04 22:24+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 15a901b..a292163 100644
--- a/po/es.gmo
+++ b/po/es.gmo
Binary files differ
diff --git a/po/es.po b/po/es.po
index 8ed867f..1aa49d7 100644
--- a/po/es.po
+++ b/po/es.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-10-02 15:45+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 6fb010c..fb124bc 100644
--- a/po/eu.gmo
+++ b/po/eu.gmo
Binary files differ
diff --git a/po/eu.po b/po/eu.po
index 7d90d10..8eba2d3 100644
--- a/po/eu.po
+++ b/po/eu.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-0.10.13.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2010-03-07 13:12+0200\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 e31022c..a0639c8 100644
--- a/po/fi.gmo
+++ b/po/fi.gmo
Binary files differ
diff --git a/po/fi.po b/po/fi.po
index f6a5cc9..c9909ce 100644
--- a/po/fi.po
+++ b/po/fi.po
@@ -11,7 +11,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.10.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2009-03-10 20:41+0200\n"
 "Last-Translator: Tommi Vainikainen <Tommi.Vainikainen@iki.fi>\n"
 "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
diff --git a/po/fr.gmo b/po/fr.gmo
index 339c1ef..51bcff2 100644
--- a/po/fr.gmo
+++ b/po/fr.gmo
Binary files differ
diff --git a/po/fr.po b/po/fr.po
index 96cdfe5..13c3b23 100644
--- a/po/fr.po
+++ b/po/fr.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-04-28 09:25+0200\n"
 "Last-Translator: Claude Paroz <claude@2xlibre.net>\n"
 "Language-Team: French <traduc@traduc.org>\n"
diff --git a/po/gl.gmo b/po/gl.gmo
index f55b1e1..4b08e51 100644
--- a/po/gl.gmo
+++ b/po/gl.gmo
Binary files differ
diff --git a/po/gl.po b/po/gl.po
index 37d47ca..0292cb7 100644
--- a/po/gl.po
+++ b/po/gl.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-15 03:47+0200\n"
 "Last-Translator: Fran Dieguez <frandieguez@ubuntu.com>\n"
 "Language-Team: Galician <proxecto@trasno.net>\n"
diff --git a/po/gst-plugins-ugly-1.0.pot b/po/gst-plugins-ugly-1.0.pot
index 40b93e8..15b1716 100644
--- a/po/gst-plugins-ugly-1.0.pot
+++ b/po/gst-plugins-ugly-1.0.pot
@@ -5,9 +5,9 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: gst-plugins-ugly 1.1.4\n"
+"Project-Id-Version: gst-plugins-ugly 1.1.90\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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"
@@ -80,6 +80,6 @@
 msgid "This stream contains no data."
 msgstr ""
 
-#: gst/asfdemux/gstasfdemux.c:419 gst/asfdemux/gstasfdemux.c:1944
+#: gst/asfdemux/gstasfdemux.c:419 gst/asfdemux/gstasfdemux.c:1968
 msgid "Internal data stream error."
 msgstr ""
diff --git a/po/hr.gmo b/po/hr.gmo
index d64a65e..e8f33ca 100644
--- a/po/hr.gmo
+++ b/po/hr.gmo
Binary files differ
diff --git a/po/hr.po b/po/hr.po
index 90b3b7c..e89e33e 100644
--- a/po/hr.po
+++ b/po/hr.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-04-16 03:00+0200\n"
 "Last-Translator: Tomislav Krznar <tomislav.krznar@gmail.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
diff --git a/po/hu.gmo b/po/hu.gmo
index d5cfbba..988a206 100644
--- a/po/hu.gmo
+++ b/po/hu.gmo
Binary files differ
diff --git a/po/hu.po b/po/hu.po
index 273183e..396add2 100644
--- a/po/hu.po
+++ b/po/hu.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-11-30 15:02+0100\n"
 "Last-Translator: Gabor Kelemen <kelemeng@gnome.hu>\n"
 "Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
diff --git a/po/id.gmo b/po/id.gmo
index e25a8b6..318ef19 100644
--- a/po/id.gmo
+++ b/po/id.gmo
Binary files differ
diff --git a/po/id.po b/po/id.po
index 4fb8642..aee8667 100644
--- a/po/id.po
+++ b/po/id.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-01-28 11:39+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 5fb873e..6543588 100644
--- a/po/it.gmo
+++ b/po/it.gmo
Binary files differ
diff --git a/po/it.po b/po/it.po
index a4503ff..ef80dea 100644
--- a/po/it.po
+++ b/po/it.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.11.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2009-06-14 12:31+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 33240d9..c26a01d 100644
--- a/po/ja.gmo
+++ b/po/ja.gmo
Binary files differ
diff --git a/po/ja.po b/po/ja.po
index aeac471..42eb301 100644
--- a/po/ja.po
+++ b/po/ja.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-22 19:42+0900\n"
 "Last-Translator: Takeshi Hamasaki <hmatrjp@users.sourceforge.jp>\n"
 "Language-Team: Japanese <translation-team-ja@lists.sourceforge.net>\n"
diff --git a/po/lt.gmo b/po/lt.gmo
index f236180..a2f9912 100644
--- a/po/lt.gmo
+++ b/po/lt.gmo
Binary files differ
diff --git a/po/lt.po b/po/lt.po
index 54f5397..bb63e48 100644
--- a/po/lt.po
+++ b/po/lt.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-0.10.7.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2008-05-14 02:52+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 46e2ade..cdfa70f 100644
--- a/po/lv.gmo
+++ b/po/lv.gmo
Binary files differ
diff --git a/po/lv.po b/po/lv.po
index fc0c4a4..1c3a2e8 100644
--- a/po/lv.po
+++ b/po/lv.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-09-02 12:04-0000\n"
 "Last-Translator: Rihards Priedītis <rprieditis@gmail.com>\n"
 "Language-Team: Latvian <translation-team-lv@lists.sourceforge.net>\n"
diff --git a/po/ms.gmo b/po/ms.gmo
index 34cde37..5444b3b 100644
--- a/po/ms.gmo
+++ b/po/ms.gmo
Binary files differ
diff --git a/po/ms.po b/po/ms.po
index 1068362..9b4e483 100644
--- a/po/ms.po
+++ b/po/ms.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-0.10.11.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2009-07-16 15:07+0800\n"
 "Last-Translator: Muhammad Najmi bin Ahmad Zabidi <najmi.zabidi@gmail.com>\n"
 "Language-Team: Malay <translation-team-ms@lists.sourceforge.net>\n"
diff --git a/po/mt.gmo b/po/mt.gmo
index c5eaf50..8b5e189 100644
--- a/po/mt.gmo
+++ b/po/mt.gmo
Binary files differ
diff --git a/po/mt.po b/po/mt.po
index 5a6bf01..96bd537 100644
--- a/po/mt.po
+++ b/po/mt.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-0.10.9.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2008-11-13 18:18+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 fbeb207..4c20990 100644
--- a/po/nb.gmo
+++ b/po/nb.gmo
Binary files differ
diff --git a/po/nb.po b/po/nb.po
index 65d01f8..a76224d 100644
--- a/po/nb.po
+++ b/po/nb.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-21 21:38+0100\n"
 "Last-Translator: Johnny A. Solbu <johnny@solbu.net>\n"
 "Language-Team: Norwegian Bokmaal <i18n-nb@lister.ping.uio.no>\n"
diff --git a/po/nl.gmo b/po/nl.gmo
index ba5bd86..b0d8e15 100644
--- a/po/nl.gmo
+++ b/po/nl.gmo
Binary files differ
diff --git a/po/nl.po b/po/nl.po
index 2d3b992..499c888 100644
--- a/po/nl.po
+++ b/po/nl.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-11-29 22:31+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 ada876b..1db7fae 100644
--- a/po/or.gmo
+++ b/po/or.gmo
Binary files differ
diff --git a/po/or.po b/po/or.po
index dd5b545..7e68faa 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: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+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 5e0a6d0..9dae9ae 100644
--- a/po/pl.gmo
+++ b/po/pl.gmo
Binary files differ
diff --git a/po/pl.po b/po/pl.po
index 160d33d..2ef9dec 100644
--- a/po/pl.po
+++ b/po/pl.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-11-28 19:34+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 3e59ddf..b9f496c 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 a92e061..253944a 100644
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2013-08-20 22:54-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 4ceee32..480b549 100644
--- a/po/ro.gmo
+++ b/po/ro.gmo
Binary files differ
diff --git a/po/ro.po b/po/ro.po
index 53d5f7b..549a2f6 100644
--- a/po/ro.po
+++ b/po/ro.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.14.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2010-08-16 03:32+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 b33d60e..05308d2 100644
--- a/po/ru.gmo
+++ b/po/ru.gmo
Binary files differ
diff --git a/po/ru.po b/po/ru.po
index e3c792a..09f3c7f 100644
--- a/po/ru.po
+++ b/po/ru.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-01 13:38+0400\n"
 "Last-Translator: Yuri Kozlov <yuray@komyakino.ru>\n"
 "Language-Team: Russian <gnu@mx.ru>\n"
diff --git a/po/sk.gmo b/po/sk.gmo
index 9cfbc25..3b4f170 100644
--- a/po/sk.gmo
+++ b/po/sk.gmo
Binary files differ
diff --git a/po/sk.po b/po/sk.po
index 99762ac..d0d03bd 100644
--- a/po/sk.po
+++ b/po/sk.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.11.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2009-09-21 10:26+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 d02c2b8..e4a947e 100644
--- a/po/sl.gmo
+++ b/po/sl.gmo
Binary files differ
diff --git a/po/sl.po b/po/sl.po
index d5b71b5..82b3f3f 100644
--- a/po/sl.po
+++ b/po/sl.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-03-26 22:48+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 23786f1..bd90bfe 100644
--- a/po/sq.gmo
+++ b/po/sq.gmo
Binary files differ
diff --git a/po/sq.po b/po/sq.po
index 021119f..f2f1274 100644
--- a/po/sq.po
+++ b/po/sq.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins 0.8.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2004-08-07 20:29+0200\n"
 "Last-Translator: Laurent Dhima <laurenti@alblinux.net>\n"
 "Language-Team: Albanian <begraj@hotmail.com>\n"
diff --git a/po/sr.gmo b/po/sr.gmo
index eed951e..04d2078 100644
--- a/po/sr.gmo
+++ b/po/sr.gmo
Binary files differ
diff --git a/po/sr.po b/po/sr.po
index 2e9cb3c..5cfd4bf 100644
--- a/po/sr.po
+++ b/po/sr.po
@@ -5,7 +5,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-12-04 13:43+0200\n"
 "Last-Translator: Мирослав Николић <miroslavnikolic@rocketmail.com>\n"
 "Language-Team: Serbian <gnu@prevod.org>\n"
diff --git a/po/sv.gmo b/po/sv.gmo
index 26463cc..92690cd 100644
--- a/po/sv.gmo
+++ b/po/sv.gmo
Binary files differ
diff --git a/po/sv.po b/po/sv.po
index bceb93b..8d4d690 100644
--- a/po/sv.po
+++ b/po/sv.po
@@ -7,7 +7,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.10.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2009-03-10 16:12+0100\n"
 "Last-Translator: Daniel Nylander <po@danielnylander.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
diff --git a/po/tr.gmo b/po/tr.gmo
index 4d6b902..5422c6d 100644
--- a/po/tr.gmo
+++ b/po/tr.gmo
Binary files differ
diff --git a/po/tr.po b/po/tr.po
index 68987ee..7abc78e 100644
--- a/po/tr.po
+++ b/po/tr.po
@@ -6,7 +6,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-01 01:19+0200\n"
 "Last-Translator: Server Acim <serveracim@gmail.com>\n"
 "Language-Team: Turkish <gnu-tr-u12a@lists.sourceforge.net>\n"
diff --git a/po/uk.gmo b/po/uk.gmo
index 3427ba8..b5c2019 100644
--- a/po/uk.gmo
+++ b/po/uk.gmo
Binary files differ
diff --git a/po/uk.po b/po/uk.po
index c71dbde..d61517d 100644
--- a/po/uk.po
+++ b/po/uk.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-11-28 20:25+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 9fa0a2e..a975594 100644
--- a/po/vi.gmo
+++ b/po/vi.gmo
Binary files differ
diff --git a/po/vi.po b/po/vi.po
index c78284f..59a7075 100644
--- a/po/vi.po
+++ b/po/vi.po
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly-1.0.3\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2012-12-02 08:07+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 d237f72..7b0c968 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 51bb264..dc03ab7 100644
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
@@ -9,7 +9,7 @@
 msgstr ""
 "Project-Id-Version: gst-plugins-ugly 0.10.17.2\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/\n"
-"POT-Creation-Date: 2013-08-28 12:55+0200\n"
+"POT-Creation-Date: 2013-09-19 10:30+0200\n"
 "PO-Revision-Date: 2011-12-20 10:58+0800\n"
 "Last-Translator: Wylmer Wang <wantinghard@gmail.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
diff --git a/tests/Makefile.in b/tests/Makefile.in
index 07f6460..0281314 100644
--- a/tests/Makefile.in
+++ b/tests/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/tests/check/Makefile.in b/tests/check/Makefile.in
index b55b9b6..d5b36d1 100644
--- a/tests/check/Makefile.in
+++ b/tests/check/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.13.3 from Makefile.am.
+# Makefile.in generated by automake 1.14 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2013 Free Software Foundation, Inc.
diff --git a/tests/check/elements/x264enc.c b/tests/check/elements/x264enc.c
index f62a80c..e91c7ce 100644
--- a/tests/check/elements/x264enc.c
+++ b/tests/check/elements/x264enc.c
@@ -30,7 +30,7 @@
 static GstPad *mysrcpad, *mysinkpad;
 
 #define VIDEO_CAPS_STRING "video/x-raw, " \
-                           "format = (string) I420, " \
+                           "format = (string) { I420, Y42B, Y444 }, " \
                            "width = (int) 384, " \
                            "height = (int) 288, " \
                            "framerate = (fraction) 25/1"
@@ -40,7 +40,8 @@
                            "height = (int) 288, " \
                            "framerate = (fraction) 25/1"
 static GstElement *
-setup_x264enc (const gchar * profile, const gchar * stream_format)
+setup_x264enc (const gchar * profile, const gchar * stream_format,
+    const gchar * input_format)
 {
   GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
       GST_PAD_SINK,
@@ -68,6 +69,7 @@
   gst_pad_set_active (mysinkpad, TRUE);
 
   caps = gst_caps_from_string (VIDEO_CAPS_STRING);
+  gst_caps_set_simple (caps, "format", G_TYPE_STRING, input_format, NULL);
   gst_check_setup_events (mysrcpad, x264enc, caps, GST_FORMAT_TIME);
   gst_caps_unref (caps);
 
@@ -90,11 +92,12 @@
 }
 
 static void
-check_caps (GstCaps * caps, gint profile_id)
+check_caps (GstCaps * caps, const gchar * profile, gint profile_id)
 {
   GstStructure *s;
-  const GValue *sf, *avcc;
+  const GValue *sf, *avcc, *pf;
   const gchar *stream_format;
+  const gchar *caps_profile;
 
   fail_unless (caps != NULL);
 
@@ -125,10 +128,18 @@
   } else {
     fail_if (TRUE, "unexpected stream-format in caps: %s", stream_format);
   }
+
+  pf = gst_structure_get_value (s, "profile");
+  fail_unless (pf != NULL);
+  fail_unless (G_VALUE_HOLDS_STRING (pf));
+  caps_profile = g_value_get_string (pf);
+  fail_unless (caps_profile != NULL);
+  fail_unless (!strcmp (caps_profile, profile));
 }
 
 static void
-test_video_profile (const gchar * profile, gint profile_id)
+test_video_profile (const gchar * profile, gint profile_id,
+    const gchar * input_format)
 {
   GstElement *x264enc;
   GstBuffer *inbuffer, *outbuffer;
@@ -138,13 +149,19 @@
   gsize size;
   int i, num_buffers;
 
-  x264enc = setup_x264enc (profile, "avc");
+  x264enc = setup_x264enc (profile, "avc", input_format);
   fail_unless (gst_element_set_state (x264enc,
           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
       "could not set to playing");
 
   /* corresponds to I420 buffer for the size mentioned in the caps */
-  inbuffer = gst_buffer_new_and_alloc (384 * 288 * 3 / 2);
+  if (!strcmp (input_format, "I420"))
+    inbuffer = gst_buffer_new_and_alloc (384 * 288 * 3 / 2);
+  else if (!strcmp (input_format, "Y42B"))
+    inbuffer = gst_buffer_new_and_alloc (384 * 288 * 2);
+  else if (!strcmp (input_format, "Y444"))
+    inbuffer = gst_buffer_new_and_alloc (384 * 288 * 3);
+
   /* makes valgrind's memcheck happier */
   gst_buffer_memset (inbuffer, 0, 0, -1);
   GST_BUFFER_TIMESTAMP (inbuffer) = 0;
@@ -162,7 +179,7 @@
     GstCaps *outcaps;
 
     outcaps = gst_pad_get_current_caps (mysinkpad);
-    check_caps (outcaps, profile_id);
+    check_caps (outcaps, profile, profile_id);
     gst_caps_unref (outcaps);
   }
 
@@ -237,25 +254,41 @@
 
 GST_START_TEST (test_video_baseline)
 {
-  test_video_profile ("constrained-baseline", 0x42);
+  test_video_profile ("constrained-baseline", 0x42, "I420");
 }
 
 GST_END_TEST;
 
 GST_START_TEST (test_video_main)
 {
-  test_video_profile ("main", 0x4d);
+  test_video_profile ("main", 0x4d, "I420");
 }
 
 GST_END_TEST;
 
 GST_START_TEST (test_video_high)
 {
-  test_video_profile ("high", 0x64);
+  test_video_profile ("high", 0x64, "I420");
 }
 
 GST_END_TEST;
 
+GST_START_TEST (test_video_high422)
+{
+  test_video_profile ("high-4:2:2", 0x7A, "Y42B");
+}
+
+GST_END_TEST;
+
+GST_START_TEST (test_video_high444)
+{
+  test_video_profile ("high-4:4:4", 0xF4, "Y444");
+}
+
+GST_END_TEST;
+
+
+
 Suite *
 x264enc_suite (void)
 {
@@ -266,6 +299,8 @@
   tcase_add_test (tc_chain, test_video_baseline);
   tcase_add_test (tc_chain, test_video_main);
   tcase_add_test (tc_chain, test_video_high);
+  tcase_add_test (tc_chain, test_video_high422);
+  tcase_add_test (tc_chain, test_video_high444);
 
   return s;
 }
diff --git a/win32/common/config.h b/win32/common/config.h
index cf16620..a18b4a8 100644
--- a/win32/common/config.h
+++ b/win32/common/config.h
@@ -61,7 +61,7 @@
 #define GST_PACKAGE_ORIGIN "Unknown package origin"
 
 /* GStreamer package release date/time for plugins as YYYY-MM-DD */
-#define GST_PACKAGE_RELEASE_DATETIME "2013-08-28"
+#define GST_PACKAGE_RELEASE_DATETIME "2013-09-19"
 
 /* Define if static plugins should be built */
 #undef GST_PLUGIN_BUILD_STATIC
@@ -238,9 +238,6 @@
    */
 #undef LT_OBJDIR
 
-/* Define to 1 if your C compiler doesn't accept -c and -o together. */
-#undef NO_MINUS_C_MINUS_O
-
 /* Name of package */
 #define PACKAGE "gst-plugins-ugly"
 
@@ -251,7 +248,7 @@
 #define PACKAGE_NAME "GStreamer Ugly Plug-ins"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "GStreamer Ugly Plug-ins 1.1.4"
+#define PACKAGE_STRING "GStreamer Ugly Plug-ins 1.1.90"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "gst-plugins-ugly"
@@ -260,7 +257,7 @@
 #undef PACKAGE_URL
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "1.1.4"
+#define PACKAGE_VERSION "1.1.90"
 
 /* directory where plugins are located */
 #ifdef _DEBUG
@@ -291,7 +288,7 @@
 #undef TARGET_CPU
 
 /* Version number of package */
-#define VERSION "1.1.4"
+#define VERSION "1.1.90"
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */
