diff --git a/debian/build-deps b/debian/build-deps
index 4df637e..1264130 100644
--- a/debian/build-deps
+++ b/debian/build-deps
@@ -1,6 +1,6 @@
 @GST_LIB_DEV_DEP@
 @GST_EXTRA_BUILD_DEPENDS@
-libgstreamer-plugins-base@GST_ABI@-dev (>= 1.7.90)
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.7.91)
 autotools-dev
 dh-autoreconf
 automake (>= 1.14)
@@ -30,7 +30,7 @@
 libgtk-3-dev
 libtag1-dev (>= 1.5)
 libwavpack-dev (>= 4.60)
-gstreamer@GST_ABI@-plugins-base (>= 1.7.90)
+gstreamer@GST_ABI@-plugins-base (>= 1.7.91)
 libsoup2.4-dev (>= 2.48)
 libpulse-dev (>= 2.0)
 libbz2-dev
diff --git a/debian/build-deps.in b/debian/build-deps.in
index 4df637e..1264130 100644
--- a/debian/build-deps.in
+++ b/debian/build-deps.in
@@ -1,6 +1,6 @@
 @GST_LIB_DEV_DEP@
 @GST_EXTRA_BUILD_DEPENDS@
-libgstreamer-plugins-base@GST_ABI@-dev (>= 1.7.90)
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.7.91)
 autotools-dev
 dh-autoreconf
 automake (>= 1.14)
@@ -30,7 +30,7 @@
 libgtk-3-dev
 libtag1-dev (>= 1.5)
 libwavpack-dev (>= 4.60)
-gstreamer@GST_ABI@-plugins-base (>= 1.7.90)
+gstreamer@GST_ABI@-plugins-base (>= 1.7.91)
 libsoup2.4-dev (>= 2.48)
 libpulse-dev (>= 2.0)
 libbz2-dev
diff --git a/debian/changelog b/debian/changelog
index c0b3952..5f9c01a 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,12 @@
+gst-plugins-good1.0 (1.7.91-1) experimental; urgency=medium
+
+  * New upstream release candidate:
+    + debian/build-deps.in,
+      debian/rules:
+      - Build-depend on GStreamer >= 1.7.91.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 15 Mar 2016 12:05:31 +0200
+
 gst-plugins-good1.0 (1.7.90-1) experimental; urgency=medium
 
   * New upstream release candidate:
diff --git a/debian/control b/debian/control
index 51d04fa..de36c74 100644
--- a/debian/control
+++ b/debian/control
@@ -5,7 +5,7 @@
 Uploaders: Loic Minier <lool@dooz.org>,
            Sebastian Dröge <slomo@debian.org>,
            Sjoerd Simons <sjoerd@debian.org>
-Build-Depends: libgstreamer1.0-dev (>= 1.7.90),  libraw1394-dev (>= 2.0.0) [linux-any] , libiec61883-dev (>= 1.0.0) [linux-any] , libavc1394-dev [linux-any] , libv4l-dev [linux-any] , libgudev-1.0-dev (>= 143) [linux-any], libgstreamer-plugins-base1.0-dev (>= 1.7.90), autotools-dev, dh-autoreconf, automake (>= 1.14), autoconf (>= 2.69), libtool (>= 2.2.6), autopoint (>= 0.17), cdbs (>= 0.4.93), debhelper (>= 9), dpkg-dev (>= 1.15.1), pkg-config (>= 0.11.0), gtk-doc-tools (>= 1.12), libglib2.0-dev (>= 2.40), liborc-0.4-dev (>= 1:0.4.17), libcairo2-dev (>= 1.10.0), libcaca-dev, libspeex-dev (>= 1.1.6), libpng-dev, libshout3-dev, libjpeg-dev, libaa1-dev (>= 1.4p5), libflac-dev (>= 1.1.4), libdv4-dev | libdv-dev, libxdamage-dev, libxext-dev, libxfixes-dev, libxv-dev, libgtk-3-dev, libtag1-dev (>= 1.5), libwavpack-dev (>= 4.60), gstreamer1.0-plugins-base (>= 1.7.90), libsoup2.4-dev (>= 2.48), libpulse-dev (>= 2.0), libbz2-dev, gstreamer1.0-doc, gstreamer1.0-plugins-base-doc, libjack-jackd2-dev, libvpx-dev (>= 1.3.0)
+Build-Depends: libgstreamer1.0-dev (>= 1.7.91),  libraw1394-dev (>= 2.0.0) [linux-any] , libiec61883-dev (>= 1.0.0) [linux-any] , libavc1394-dev [linux-any] , libv4l-dev [linux-any] , libgudev-1.0-dev (>= 143) [linux-any], libgstreamer-plugins-base1.0-dev (>= 1.7.91), autotools-dev, dh-autoreconf, automake (>= 1.14), autoconf (>= 2.69), libtool (>= 2.2.6), autopoint (>= 0.17), cdbs (>= 0.4.93), debhelper (>= 9), dpkg-dev (>= 1.15.1), pkg-config (>= 0.11.0), gtk-doc-tools (>= 1.12), libglib2.0-dev (>= 2.40), liborc-0.4-dev (>= 1:0.4.17), libcairo2-dev (>= 1.10.0), libcaca-dev, libspeex-dev (>= 1.1.6), libpng-dev, libshout3-dev, libjpeg-dev, libaa1-dev (>= 1.4p5), libflac-dev (>= 1.1.4), libdv4-dev | libdv-dev, libxdamage-dev, libxext-dev, libxfixes-dev, libxv-dev, libgtk-3-dev, libtag1-dev (>= 1.5), libwavpack-dev (>= 4.60), gstreamer1.0-plugins-base (>= 1.7.91), libsoup2.4-dev (>= 2.48), libpulse-dev (>= 2.0), libbz2-dev, gstreamer1.0-doc, gstreamer1.0-plugins-base-doc, libjack-jackd2-dev, libvpx-dev (>= 1.3.0)
 Standards-Version: 3.9.3
 Vcs-Git: git://anonscm.debian.org/pkg-gstreamer/gst-plugins-good1.0.git
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-gstreamer/gst-plugins-good1.0.git;a=summary
diff --git a/debian/rules b/debian/rules
index 1466628..dbfd005 100755
--- a/debian/rules
+++ b/debian/rules
@@ -45,7 +45,7 @@
 gst_lib=libgstreamer$(gst_abi)-0
 gst_lib_dev=libgstreamer$(gst_abi)-dev
 # what gstreamer version is needed
-gst_lib_dev_dep=$(gst_lib_dev) (>= 1.7.90)
+gst_lib_dev_dep=$(gst_lib_dev) (>= 1.7.91)
 
 gst_pkgname=gstreamer$(gst_abi)
 gst_deb_abi=$(gst_abi)-0
