diff --git a/debian/build-deps.in b/debian/build-deps.in
deleted file mode 100644
index e359129..0000000
--- a/debian/build-deps.in
+++ /dev/null
@@ -1,37 +0,0 @@
-@GST_LIB_DEV_DEP@
-@GST_EXTRA_BUILD_DEPENDS@
-libgstreamer-plugins-base@GST_ABI@-dev (>= 1.12.0)
-autotools-dev
-dh-autoreconf
-automake (>= 1.14)
-autoconf (>= 2.69)
-libtool (>= 2.2.6)
-autopoint (>= 0.17)
-cdbs (>= 0.4.93)
-debhelper (>= 10)
-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
-libtag1-dev (>= 1.5)
-libwavpack-dev (>= 4.60)
-gstreamer@GST_ABI@-plugins-base (>= 1.12.0)
-libsoup2.4-dev (>= 2.48)
-libpulse-dev (>= 2.0)
-libbz2-dev
-libjack-jackd2-dev
-libvpx-dev (>= 1.3.0)
diff --git a/debian/changelog b/debian/changelog
index ca8a381..aecdce2 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,4 +1,4 @@
-gst-plugins-good1.0 (1.12.2+imx-0) unstable; urgency=medium
+imx-gst-plugins-good (1.12.2+imx-0) unstable; urgency=medium
 
   * Initial release
 
diff --git a/debian/control b/debian/control
index 77d2bfe..ce005c4 100644
--- a/debian/control
+++ b/debian/control
@@ -1,4 +1,4 @@
-Source: gst-plugins-good1.0
+Source: imx-gst-plugins-good
 Section: libs
 Priority: optional
 Maintainer: AIY Projects <support-aiyprojects@google.com>
diff --git a/debian/control.in b/debian/control.in
deleted file mode 100644
index afab448..0000000
--- a/debian/control.in
+++ /dev/null
@@ -1,85 +0,0 @@
-Source: gst-plugins-good@GST_ABI@
-Section: libs
-Priority: optional
-Maintainer: AIY Projects <support-aiyprojects@google.com>
-Build-Depends: BUILDDEPS
-Standards-Version: 3.9.3
-Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html
-
-
-Package: @GST_PKGNAME@-pulseaudio
-Architecture: any
-Multi-Arch: same
-Section: sound
-Depends: ${misc:Depends},
-         ${shlibs:Depends}
-XB-GStreamer-Version: ${gstreamer:Version}
-XB-GStreamer-Elements: ${gstreamer:Elements}
-XB-GStreamer-URI-Sources: ${gstreamer:URISources}
-XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
-XB-GStreamer-Encoders: ${gstreamer:Encoders}
-XB-GStreamer-Decoders: ${gstreamer:Decoders}
-Provides: ${gstreamer:Provides}
-Description: GStreamer plugin for PulseAudio
- GStreamer is a streaming media framework, based on graphs of filters
- which operate on media data.  Applications using this library can do
- anything from real-time sound processing to playing videos, and just
- about anything else media-related.  Its plugin-based architecture means
- that new data types or processing capabilities can be added simply by
- installing new plug-ins.
- .
- This package contains the GStreamer plugin for PulseAudio, a sound server
- for POSIX and WIN32 systems.
-
-Package: @GST_PKGNAME@-plugins-good
-Architecture: any
-Multi-Arch: same
-Section: libs
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-         @GST_PKGNAME@-pulseaudio | @GST_PKGNAME@-audiosink,
-         gstreamer@GST_ABI@-plugins-base,
-Recommends: @GST_PKGNAME@-x
-Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
-Breaks: gstreamer1.0-plugins-bad (<< 1.7.90)
-XB-GStreamer-Version: ${gstreamer:Version}
-XB-GStreamer-Elements: ${gstreamer:Elements}
-XB-GStreamer-URI-Sources: ${gstreamer:URISources}
-XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
-XB-GStreamer-Encoders: ${gstreamer:Encoders}
-XB-GStreamer-Decoders: ${gstreamer:Decoders}
-Provides: ${gstreamer:Provides}
-Description: GStreamer plugins from the "good" set
- GStreamer is a streaming media framework, based on graphs of filters
- which operate on media data.  Applications using this library can do
- anything from real-time sound processing to playing videos, and just
- about anything else media-related.  Its plugin-based architecture means
- that new data types or processing capabilities can be added simply by
- installing new plug-ins.
- .
- This package contains the GStreamer plugins from the "good" set, a set
- of good-quality plug-ins under the LGPL license.
-
-Package: @GST_PKGNAME@-plugins-good-dbg
-Architecture: any
-Multi-Arch: same
-Section: debug
-Priority: extra
-Depends: @GST_PKGNAME@-plugins-good (= ${binary:Version}),
-         @GST_PKGNAME@-pulseaudio (= ${binary:Version}),
-         ${misc:Depends}
-Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
-Breaks: gstreamer1.0-plugins-bad (<< 1.7.90)
-Description: GStreamer plugins from the "good" set
- GStreamer is a streaming media framework, based on graphs of filters
- which operate on media data.  Applications using this library can do
- anything from real-time sound processing to playing videos, and just
- about anything else media-related.  Its plugin-based architecture means
- that new data types or processing capabilities can be added simply by
- installing new plug-ins.
- .
- This package contains unstripped shared libraries. It is provided primarily
- to provide a backtrace with names in a debugger, this makes it somewhat
- easier to interpret core dumps. The libraries are installed in
- /usr/lib/debug and are automatically used by gdb.
-
diff --git a/debian/rules b/debian/rules
index 6df4648..56ea0bc 100755
--- a/debian/rules
+++ b/debian/rules
@@ -102,22 +102,7 @@
 DEFAULT_VISUALIZER = goom
 endif
 
-# Let's decide the package name and url depending on the distribution
-DISTRO = "$(shell dpkg-vendor --query vendor)"
-
-GST_PACKAGE_NAME := "GStreamer Good Plugins (unknown Debian derivative)"
-GST_PACKAGE_ORIGIN="http://packages.qa.debian.org/gst-plugins-good$(gst_abi)"
-
-ifeq ($(DISTRO),"Debian")
-GST_PACKAGE_NAME := "GStreamer Good Plugins (Debian)"
-GST_PACKAGE_ORIGIN="http://packages.qa.debian.org/gst-plugins-good$(gst_abi)"
-endif
-
-ifeq ($(DISTRO),"Ubuntu")
-GST_PACKAGE_NAME := "GStreamer Good Plugins (Ubuntu)"
-GST_PACKAGE_ORIGIN="https://launchpad.net/distros/ubuntu/+source/gst-plugins-good$(gst_abi)"
-endif
-
+GST_PACKAGE_NAME := "GStreamer Good Plugins"
 
 # setup links for packages
 pre-build::
@@ -139,27 +124,12 @@
 
 maint: debian/control
 
-debian/build-deps: debian/build-deps.in debian/rules
-	cat $< > $@
-
-debian/control:: debian/control.in debian/build-deps debian/mk.control debian/rules
-	perl debian/mk.control | sed \
-		-e 's/@GST_VERSION@/$(gst_version)/g' \
-		-e 's/@GST_ABI@/$(gst_abi)/g' \
-		-e 's/@GST_PKGNAME@/$(gst_pkgname)/g' \
-		-e 's/@GST_LIB@/$(gst_lib)/g' \
-		-e 's/@GST_LIB_DEV@/$(gst_lib_dev)/g' \
-		-e 's/@GST_LIB_DEV_DEP@/$(gst_lib_dev_dep)/g' \
-		-e 's/@GST_EXTRA_BUILD_DEPENDS@/$(gst_extra_build_depends)/g' \
-		>$@
-
 DEB_CONFIGURE_EXTRA_FLAGS += \
 	--libdir=\$${prefix}/lib/$(DEB_HOST_MULTIARCH) \
 	--disable-examples \
 	--enable-DEBUG \
 	--enable-debug \
 	--with-package-name=$(GST_PACKAGE_NAME) \
-	--with-package-origin=$(GST_PACKAGE_ORIGIN) \
 	--disable-gtk-doc \
 	--enable-experimental \
 	--with-default-audiosink=$(DEFAULT_AUDIOSINK) \
