diff --git a/debian/HACKING.Debian b/debian/HACKING.Debian
new file mode 100644
index 0000000..e316488
--- /dev/null
+++ b/debian/HACKING.Debian
@@ -0,0 +1,91 @@
+Hacking GStreamer for Debian
+============================
+
+An addition to the README.Debian that has Debian package hacking notes.
+
+Everything should now be versioned.
+
+- To update dependencies edit debian/build-deps.in
+
+- To rebuild package files from .in files:
+
+  debian/rules maint
+
+- After a version update to check for missing files run:
+
+  debian/maint missing
+  debian/maint missing-libs
+  debian/maint missing-so
+
+- To update package files edit gstreamer-foo then rebuild package files.  This
+  will generate the gstreamerX.Y-foo file.  Also update debian/rules and
+  debian/control.in as needed.
+
+- The packaging tries to stay close of upstream choice. gstreamerX.Y-misc has
+  most of the files, extra packages are made for the sinks and by group of 
+  depends (gnome, x, ...)
+
+- Provide gstreamerX.Y-videosink and gstreamerX.Y-audiosink as needed.
+
+- All interfaces and generic libraries go in libgstreamer-plugins, libraries
+  with external dependencies have their own package such as libgstreamer-gconf.
+
+- Applications go in gstreamerX.Y-plugins-base-apps
+
+
+File listing
+------------
+
+build-deps:
+  - generated from "build-deps.in" in "rules
+    debian/build-deps:":
+    * "build-deps.in" lists build-depends for Debian main packages
+  - serves generation with "control.in" and "mk.control" of "control" in
+    "rules debian/control::"
+build-deps.in:
+  - lists build-depends for Debian main packages
+  - serves generation with "extra deps" of "build-deps" in "rules
+    debian/build-deps:"
+changelog: handled classically
+compat: handled classically
+control:
+  - generated for "rules maint"
+  - generated from "control.in" and "build-deps" in "rules debian/control::":
+    * "build-deps" lists build-depends to be inserted in "control
+      Build-Depends:"
+    * "control.in" serves of template for package descriptions of Debian main
+      packages and makes use of special stanzas enclosed in "@" such as
+      "@GST_ABI" which are replaced via sed in "rules debian/control::"
+control.in:
+  - serves generation of "control" in "rules debian/control::" via "mk.control"
+    called in "rules debian/control::"
+  - template for package descriptions of Debian main packages and makes use of
+    special stanzas enclosed in "@" such as "@GST_ABI" which are replaced via
+    sed in "rules debian/control::"
+copyright: handled classically
+gstreamer-$plugin.install:
+  - serves the generation of $gst_pkgname-$plugin.install (for example
+    gstreamer-alsa.install serves the generation of gstreamerX.Y-alsa.install) in
+    "rules pre-build::" via dynamic "@"-enclosed variables replacement
+  - some plugins are handled specially and some special variables are available
+gstreamer-plugins-base-apps.install: this isn't really a plugin, but the
+                                    gstreamerX.Y-plugins-base-apps package
+gstreamer-plugins-base-apps.manpages: man pages for the gstreamerX.Y-plugins-base-apps
+                                package
+HACKING.Debian: this file
+libgstreamer-plugins-base-dev.install libgstreamer-plugins-base.install: handled similarly has gstreamerX.Y-plugins-base-apps
+maint: makefile wrapping some targets of "rules" with some sh filtering
+mk.control:
+  - Perl script serving the generation of "control" which reads "build-deps"
+    and "control.in", and replaces the "BUILDDEPS" stanza with the build-deps
+patches: handled classically
+README.Debian: handled classically
+rules: handled classically, with special targets "maint:", and
+       "debian/build-deps:"
+watch: handled classically
+
+This file is the initial work of:
+David I. Lehn <dlehn@debian.org>  Tue, 13 Apr 2004 21:28:55 -0400
+and had some additions by:
+Loic Minier <lool@dooz.org>  Sun, 19 Jun 2005 19:04:58 +0200
+Sebastien Bacher <seb128@debian.org>  Wed, 14 Dec 2005 17:00:21 +0100
diff --git a/debian/README.Debian b/debian/README.Debian
new file mode 100644
index 0000000..1ef5fdd
--- /dev/null
+++ b/debian/README.Debian
@@ -0,0 +1,57 @@
+Gstreamer for Debian
+====================
+This package contains the GStreamer plugin distribution.
+
+More information can be found at http://gstreamer.net/
+
+As of GStreamer plugins version 0.8.0 all packages are versioned and
+parallel installable with other releases with other major.minor
+versions.  For example, 0.8.x series is versioned as 0.8 and parallel
+installable with both unversioned 0.6.x series and future 0.9.x and
+beyond.  The version part is represented as VER below.
+
+GStreamer plugins are split into a number of packages:
+
+plugins without external dependencies:
+
+   gstreamerVER-misc-good     many independent plugins
+
+plugins with external dependencies:
+
+   gstreamerVER-aa
+   gstreamerVER-auto
+   gstreamerVER-caca
+   gstreamerVER-esd
+   gstreamerVER-oss
+
+documentation:
+
+   gstreamerVER-plugins-good-doc		html documentation
+
+
+Notes
+=====
+
+ChangeLog
+---------
+
+The upstream ChangeLog is not included in all the plugin packages due to its
+large size.  Please see upstream sources if you are interested in detailed
+source changes.
+
+External tools support
+----------------------
+
+Your favorite codec isn't wrapped as a plugin?  External programs can be
+used to process streams.  Take a look at "pipefilter" element or try
+something like this (untested):
+
+  $ mkfifo fifo
+  $ gst-launch myaudiosrc ! filesink location=fifo &
+  $ cat fifo | my_encoder > output_file
+
+
+David I. Lehn <dlehn@debian.org>  Tue, 23 Mar 2004 04:38:37 -0500
+
+update:
+Sebastien Bacher <seb128@debian.org>  Wed, 14 Dec 2005 17:00:21 +0100
diff --git a/debian/build-deps b/debian/build-deps
new file mode 100644
index 0000000..725ea9c
--- /dev/null
+++ b/debian/build-deps
@@ -0,0 +1,40 @@
+@GST_LIB_DEV_DEP@
+@GST_EXTRA_BUILD_DEPENDS@
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.3.3)
+autotools-dev
+dh-autoreconf
+automake (>= 1.11)
+autoconf (>= 2.62)
+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.32)
+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.20)
+gstreamer@GST_ABI@-plugins-base (>= 1.3.3)
+libsoup2.4-dev (>= 2.40)
+libpulse-dev (>= 2.0)
+libbz2-dev
+gstreamer@GST_ABI@-doc
+gstreamer@GST_ABI@-plugins-base-doc
+libjack-jackd2-dev
+libvpx-dev (>= 1.3.0)
diff --git a/debian/build-deps.in b/debian/build-deps.in
new file mode 100644
index 0000000..725ea9c
--- /dev/null
+++ b/debian/build-deps.in
@@ -0,0 +1,40 @@
+@GST_LIB_DEV_DEP@
+@GST_EXTRA_BUILD_DEPENDS@
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.3.3)
+autotools-dev
+dh-autoreconf
+automake (>= 1.11)
+autoconf (>= 2.62)
+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.32)
+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.20)
+gstreamer@GST_ABI@-plugins-base (>= 1.3.3)
+libsoup2.4-dev (>= 2.40)
+libpulse-dev (>= 2.0)
+libbz2-dev
+gstreamer@GST_ABI@-doc
+gstreamer@GST_ABI@-plugins-base-doc
+libjack-jackd2-dev
+libvpx-dev (>= 1.3.0)
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..168ed81
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,2877 @@
+gst-plugins-good1.0 (1.3.3-1) experimental; urgency=medium
+
+  * New upstream development release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build-depend on GStreamer core and base >= 1.3.2.
+  * debian/rules:
+    + Run autopoint during autoreconf too.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 22 Jun 2014 18:01:49 +0200
+
+gst-plugins-good1.0 (1.3.2-1) experimental; urgency=medium
+
+  * New upstream development release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build-depend on GStreamer core and base >= 1.3.2.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 21 May 2014 12:38:54 +0200
+
+gst-plugins-good1.0 (1.3.1-1) experimental; urgency=medium
+
+  * New upstream development release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build-depend on GStreamer core and base >= 1.3.1.
+      - Build-depend on libsoup >= 2.40.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 03 May 2014 19:02:39 +0200
+
+gst-plugins-good1.0 (1.2.4-1) unstable; urgency=medium
+
+  * New upstream bugfix release:
+    + debian/rules:
+      - Build-depend on gstreamer >= 1.2.4.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 19 Apr 2014 15:56:43 +0200
+
+gst-plugins-good1.0 (1.2.3-1) unstable; urgency=medium
+
+  [ Iain Lane ]
+  * Drop ltmain-as-needed patch and do the same with dh_autoreconf
+    --as-needed.
+  * Enable parallel builds 
+
+  [ Sebastian Dröge ]
+  * New upstream bugfix release:
+    + debian/build-deps.in:
+      - Build-depend on gst-plugins-base >= 1.2.3.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 09 Feb 2014 11:23:29 +0100
+
+gst-plugins-good1.0 (1.2.2-1) unstable; urgency=medium
+
+  * New upstream bugfix release.
+  * debian/build-deps.in:
+    + Build-depend on libvpx-dev >= 1.3.0 for VP9 support.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 27 Dec 2013 11:00:18 +0100
+
+gst-plugins-good1.0 (1.2.1-1) unstable; urgency=low
+
+  [ Fabian Greffrath ]
+  * Team upload.
+  * Add Vcs-* and Homepage fields to debian/control[,.in}.
+  * Turn versioned Conflicts into Breaks to simplify lockstep upgrades.
+
+  [ Sebastian Dröge ]
+  * New upstream bugfix release:
+    + debian/build-deps.in:
+      - Build-depend on gst-plugins-base >= 1.2.1.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 09 Nov 2013 17:09:41 +0100
+
+gst-plugins-good1.0 (1.2.0-1) unstable; urgency=low
+
+  * New upstream stable release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer and gst-plugins-base >= 1.2.0.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 24 Sep 2013 16:39:22 +0200
+
+gst-plugins-good1.0 (1.1.90-1) experimental; urgency=low
+
+  * New upstream release candidate:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer and gst-plugins-base >= 1.1.90.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 19 Sep 2013 12:47:00 +0200
+
+gst-plugins-good1.0 (1.1.4-1) experimental; urgency=low
+
+  * New upstream development snapshot:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer and gst-plugins-base >= 1.1.4.
+      - Build depend on libsoup >= 2.38.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 30 Aug 2013 12:53:44 +0200
+
+gst-plugins-good1.0 (1.1.3-1) experimental; urgency=low
+
+  * New upstream development snapshot:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer and gst-plugins-base >= 1.1.3.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 30 Jul 2013 08:46:19 +0200
+
+gst-plugins-good1.0 (1.1.2-1) experimental; urgency=low
+
+  * New upstream development snapshot:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer and gst-plugins-base >= 1.1.2.
+      - Build depend on orc >= 0.4.17.
+      - Build depend on pulseaudio >= 2.0.
+      - Build depend on libsoup2.4-dev instead of libsoup-gnome2.4-dev.
+      - Build depend on libjack-jackd2-dev instead of libjack-dev.
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Add dtmf plugin which moved from gst-plugins-bad.
+      - Add newly ported cairo plugin.
+  * debian/patches/0001-souphttpsrc-ignore-errors-from-HEAD-request.patch:
+    + Patch from upstream GIT to ignore errors that happened as a result
+      of the HEAD request. Only error out later if the GET request fails.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 14 Jul 2013 11:46:14 +0200
+
+gst-plugins-good1.0 (1.0.8-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 13 Jul 2013 11:32:13 +0200
+
+gst-plugins-good1.0 (1.0.7-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 26 Apr 2013 14:09:02 +0200
+
+gst-plugins-good1.0 (1.0.6-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 22 Mar 2013 18:16:56 +0100
+
+gst-plugins-good1.0 (1.0.5-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 08 Jan 2013 13:47:24 +0100
+
+gst-plugins-good1.0 (1.0.4-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 19 Dec 2012 10:31:27 +0100
+
+gst-plugins-good1.0 (1.0.3-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 21 Nov 2012 14:54:15 +0100
+
+gst-plugins-good1.0 (1.0.2-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 25 Oct 2012 13:33:47 +0200
+
+gst-plugins-good1.0 (1.0.1-1) unstable; urgency=low
+
+  * New upstream bugfix release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 08 Oct 2012 10:49:02 +0200
+
+gst-plugins-good1.0 (1.0.0-1) unstable; urgency=low
+
+  * New upstream stable release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 1.0.0.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 25 Sep 2012 00:19:31 +0200
+
+gst-plugins-good1.0 (0.11.99-1) experimental; urgency=low
+
+  * New upstream release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 0.11.99.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 18 Sep 2012 09:38:33 +0200
+
+gst-plugins-good1.0 (0.11.94-1) experimental; urgency=low
+
+  * New upstream release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 0.11.94.
+      - Build depend on gtk-doc >= 1.12.
+    + debian/gstreamer-plugins-good.install:
+      - Add gdkpixbuf plugin.
+    + debian/patches/0001-configure-Fix-GTK-required-version-variable-name.patch,
+      debian/patches/0002-configure-And-fix-the-GTK-check-to-use-the-correct-p.patch:
+      - Dropped, merged upstream.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 14 Sep 2012 10:15:48 +0200
+
+gst-plugins-good1.0 (0.11.93-1) experimental; urgency=low
+
+  * New upstream release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 0.11.93.
+      - Build depend on GLib >= 2.32.
+      - Build depend on ORC >= 0.4.16.
+      - Build depend on libsoup >= 2.26.1.
+      - Build depend on GTK3 instead of GTK2.
+    + debian/gstreamer-plugins-good.install:
+      - Add the imagefreeze, interleave, deinterlace, monoscope,
+        smpte and wavpack plugins.
+    + debian/patches/0001-configure-Fix-GTK-required-version-variable-name.patch:
+      - Fix GTK configure check.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 09 Aug 2012 10:23:42 +0200
+
+gst-plugins-good1.0 (0.11.92-1) experimental; urgency=low
+
+  * New upstream release, "Money":
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 0.11.92.
+    + debian/gstreamer-plugins-good.install,
+      debian/build-deps.in:
+      - Remove annodex plugin.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 08 Jun 2012 12:25:20 +0200
+
+gst-plugins-good1.0 (0.11.91-1) experimental; urgency=low
+
+  * Build-depend on GLib > 2.31.14.
+  * New upstream release, "I smell the blood of an Englishman":
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on GStreamer core/base >= 0.11.91.
+    + debian/gstreamer-plugins-good.install:
+      - Ship some plugins again that were now ported.
+  * debian/build-deps.in:
+    + Update automake, autoconf and libtool build dependencies.
+  * debian/control.in,
+    debian/build-deps.in:
+    + Update debhelper dependency version and Standards-Version.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 21 May 2012 12:56:30 +0200
+
+gst-plugins-good1.0 (0.11.90-1) experimental; urgency=low
+
+  [ Olivier Naudan ]
+  * Imported Upstream version 0.11.90
+  * Imported debian/ from gst-plugins-good 0.10.30-1
+  * Updated debian/ for 0.11.90
+  * Removed -gconf package
+  * gstreamer-plugins-good.intall: Removed the plugins that are not ported or o
+
+  [ Sebastian Dröge ]
+  * Build-depend on libpng-dev instead of libpng12-dev.
+  * Update copyright.
+  * Remove GConf build dependency.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 02 May 2012 20:17:22 +0200
+
+gst-plugins-good0.10 (0.10.31-1) unstable; urgency=low
+
+  * New upstream release, "Faster":
+    + debian/rules,
+      debian/build-deps.in:
+      - (Build-) depend on GStreamer core/base >= 0.10.36.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 21 Feb 2012 10:45:15 +0100
+
+gst-plugins-good0.10 (0.10.30.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 06 Feb 2012 09:59:53 +0100
+
+gst-plugins-good0.10 (0.10.30.2-3) experimental; urgency=low
+
+  * debian/control.in:
+    + Build-depend on automake (>= 1.10), autoconf (>= 2.60) and
+      libtool (>= 2.0) to make dh-autoreconf actually work.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 14 Dec 2011 12:58:12 +0100
+
+gst-plugins-good0.10 (0.10.30.2-2) experimental; urgency=low
+
+  * debian/control.in:
+    + Depend on gstreamer0.10-pulseaudio | gstreamer0.10-audiosink
+      instead of only depending on the virtual package.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 12 Dec 2011 10:54:47 +0100
+
+gst-plugins-good0.10 (0.10.30.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/rules:
+      - Build-depend on GStreamer core/base 0.10.35.2.
+      - Build-depend on PulseAudio 1.0.
+    + debian/patches/04_rtpgst722pay-compensate-for-clockrate.patch:
+      - Dropped, merged upstream.
+    + debian/patches/03_pulse-rank.patch:
+      - Dropped, merged upstream.
+    + debian/patches/99_ltmain_as-needed.patch:
+      - Refreshed to apply cleanly again.
+  * debian/control.in,
+    debian/build-deps.in:
+    + ACK NMU 0.10.30.2-2.1 and 0.10.30.2-2.2 (Closes: #646325, #633438).
+    + Correctly change control file from the last two NMUs.
+  * debian/build-deps.in,
+    debian/compat,
+    debian/control.in,
+    debian/gstreamer-gconf.install,
+    debian/gstreamer-plugins-good.install,
+    debian/gstreamer-pulseaudio.install,
+    debian/rules:
+    + Transition package to multi arch (Closes: #647486).
+      Patch taken from the Ubuntu package.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 12 Dec 2011 09:34:40 +0100
+
+gst-plugins-good0.10 (0.10.30-2.2) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * Transition to libjpeg8 by build-depending against libjpeg-dev
+    (instead of libjpeg62-dev), closes: #633438
+
+ -- Philipp Kaluza <debian@ghostroute.eu>  Sat, 03 Dec 2011 13:34:20 +0100
+
+gst-plugins-good0.10 (0.10.30-2.1) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * Add Replaces/Breaks to gstreamer0.10-gconf for old 
+    gstreamer0.10-plugins-good (Closes: #646325)
+
+ -- Philipp Kaluza <debian@ghostroute.eu>  Sat, 03 Dec 2011 10:34:02 +0000
+
+gst-plugins-good0.10 (0.10.30-2) unstable; urgency=low
+
+  [ Sebastian Dröge ]
+  * debian/control.in:
+    + Let gstreamer0.10-plugins-good depend on gstreamer0.10-gconf for
+      wheezy to guarantee correct upgrades to wheezy (Closes: #625567).
+
+  [ Sjoerd Simons ]
+  * debian/patches/04_rtpgst722pay-compensate-for-clockrate.patch:
+    + Correct clockrate vs. samplerate difference for G722. Fixes people
+      sounding like chipmunks on voip calls with G722 (From upstream git)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Wed, 09 Nov 2011 14:20:22 +0000
+
+gst-plugins-good0.10 (0.10.30-1) unstable; urgency=low
+
+  * New upstream release, "Adagio":
+    + debian/patches/01_path-max.patch:
+      - Dropped, merged upstream.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 23 Jun 2011 09:44:29 +0200
+
+gst-plugins-good0.10 (0.10.29-2) unstable; urgency=low
+
+  * debian/patches/01_path-max.patch:
+    + Define PATH_MAX if it isn't defined, e.g. on GNU Hurd. Thanks
+      to Pino Toscano for the patch (Closes: #626698).
+  * debian/rules,
+    debian/gstreamer-plugins-good.install:
+    + Don't build the oss4 plugin on GNU Hurd, it does not compile
+      because of the way how ioctl() works there. Thanks to Pino
+      Toscano for the patch (Closes: #626698).
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 16 May 2011 09:10:14 +0200
+
+gst-plugins-good0.10 (0.10.29-1) unstable; urgency=low
+
+  * New upstream release, "Soft Cheese Enthusiast":
+    + debian/gstreamer-plugins-good.install:
+      - The quicktime plugin was renamed to isomp4 because
+        of trademark concerns.
+    + debian/rules,
+      debian/build-deps.in:
+      - Build-depend on GStreamer core/base 0.10.33.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 10 May 2011 15:52:01 +0200
+
+gst-plugins-good0.10 (0.10.28.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/gstreamer-plugins-good.install:
+      - The qtdemux plugin was renamed to quicktime because
+        it contains a muxer too now.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 27 Apr 2011 15:48:22 +0200
+
+gst-plugins-good0.10 (0.10.28.2-1) experimental; urgency=low
+
+  [ Alessandro Decina ]
+  * debian/build-deps.in:
+    + Add dependency on dh-autoreconf
+  * debian/rules:
+    + Include dh-autoreconf cdbs rule
+
+  [ Loïc Minier ]
+  * Use linux-any in build-deps instead of type-handling.
+  * Rework sed calls to avoid sed | sed.
+
+  [ Sebastian Dröge ]
+  * debian/control.in,
+    debian/build-deps.in,
+    debian/gstreamer-esd.install,
+    debian/rules:
+    + Drop ESD plugin, nothing is using it anymore, it is
+      unmaintained upstream and pulseaudio is a better 
+      replacement for it.
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/rules:
+      - Build-depend on GStreamer core/base >= 0.10.32.2.
+    + debian/build-deps.in:
+      - Build-depend on libcairo2-dev >= 1.10.0.
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Add audioparsers plugin, which was moved from -bad
+        and Conflict with -bad << 0.10.21.2.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 17 Apr 2011 10:55:39 +0200
+
+gst-plugins-good0.10 (0.10.28-3) unstable; urgency=low
+
+  * debian/control.in,
+    debian/rules,
+    debian/gstreamer-plugins-good.install,
+    debian/gstreamer-gconf.install:
+    + Split the GConf plugin into it's own package. GStreamer is used
+      as the default phonon backend nowadays and there's no reason
+      why KDE should depend on half of GNOME (Closes: #595651).
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 01 Apr 2011 10:13:13 +0200
+
+gst-plugins-good0.10 (0.10.28-2) unstable; urgency=low
+
+  * Upload to unstable.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 22 Mar 2011 15:06:25 +0100
+
+gst-plugins-good0.10 (0.10.28-1) experimental; urgency=low
+
+  * New upstream bugfix release, "Inconvenienced by the Solar System":
+    + Fixes build with kernels that have v4l2 support but not v4l support.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 13 Mar 2011 13:03:07 +0100
+
+gst-plugins-good0.10 (0.10.27-1) experimental; urgency=low
+
+  * New upstream stable release, "Some Kind of Temporal Blend":
+    + debian/build-deps,
+      debian/rules:
+      - Require GStreamer, gst-plugins-base >= 0.10.32.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 22 Jan 2011 13:35:36 +0100
+
+gst-plugins-good0.10 (0.10.26.4-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps,
+      debian/rules:
+      - Require GStreamer, gst-plugins-base >= 0.10.31.4.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 19 Jan 2011 21:16:40 +0100
+
+gst-plugins-good0.10 (0.10.26.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps,
+      debian/rules:
+      - Require GStreamer, gst-plugins-base >= 0.10.31.3.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 13 Jan 2011 13:07:01 +0100
+
+gst-plugins-good0.10 (0.10.26.2-1) experimental; urgency=low
+
+  [ Sebastian Dröge ]
+  * New upstream pre-release:
+    + debian/control.in:
+      - Conflict/Replace gstreamer0.10-plugins-bad (<< 0.10.20.2) because
+        of the moved JACK plugin.
+    + debian/build-deps.in,
+      debian/gstreamer-plugins-good.install:
+      - Add the JACK plugin which was moved from gst-plugins-bad.
+    + debian/build-deps,
+      debian/rules:
+      - Require GStreamer, gst-plugins-base >= 0.10.31.2.
+      - Require GLib >= 2.22.
+
+  [ Emilio Pozuelo Monfort ]
+  * debian/build-deps.in,
+    debian/rules:
+    + Use dpkg-vendor instead of lsb_release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 10 Jan 2011 15:11:27 +0100
+
+gst-plugins-good0.10 (0.10.26-1) experimental; urgency=low
+
+  * New upstream release, "Escapades".
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 02 Dec 2010 10:35:38 +0100
+
+gst-plugins-good0.10 (0.10.25.5-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 19 Nov 2010 11:30:21 +0100
+
+gst-plugins-good0.10 (0.10.25.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 01 Nov 2010 20:18:27 +0100
+
+gst-plugins-good0.10 (0.10.25.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 22 Oct 2010 19:58:54 +0200
+
+gst-plugins-good0.10 (0.10.25.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/01_alphacolor-passthrough.patch,
+      debian/patches/02_qtdemux-eos-handling.patch,
+      debian/patches/04_qtdemux-eos-handling.patch:
+      - Dropped, merged upstream.
+    + debian/rules,
+      debian/build-deps.in:
+      - Require GStreamer core/plugins-base >= 0.10.30.2.
+      - Require ORC >= 0.4.11.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 16 Oct 2010 11:29:22 +0200
+
+gst-plugins-good0.10 (0.10.25-5) experimental; urgency=low
+
+  * debian/build-deps.in:
+    + Add the epoch to the orc build dependency to get dependencies
+      on the correct versions.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 17 Sep 2010 13:24:49 +0200
+
+gst-plugins-good0.10 (0.10.25-4) experimental; urgency=low
+
+  * debian/patches/02_qtdemux-eos-handling.patch:
+    + Another patch from upstream GIT to fix EOS handling in the
+      QT/MP4 demuxer even more.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 16 Sep 2010 11:18:01 +0200
+
+gst-plugins-good0.10 (0.10.25-3) experimental; urgency=low
+
+  * debian/patches/02_qtdemux-eos-handling.patch:
+    + Patch from upstream GIT to fix EOS handling in the QT/MP4 demuxer.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 15 Sep 2010 08:21:56 +0200
+
+gst-plugins-good0.10 (0.10.25-2) experimental; urgency=low
+
+  * debian/patches/01_alphacolor-passthrough.patch:
+    + Simple patch from upstream GIT to fix passthrough mode
+      of the alphacolor element.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 10 Sep 2010 11:40:40 +0200
+
+gst-plugins-good0.10 (0.10.25-1) experimental; urgency=low
+
+  * New upstream release, "Woe to You Oh Earth and Sea".
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 03 Sep 2010 12:36:18 +0200
+
+gst-plugins-good0.10 (0.10.24.5-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 25 Aug 2010 22:12:39 +0200
+
+gst-plugins-good0.10 (0.10.24.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 21 Aug 2010 21:59:12 +0200
+
+gst-plugins-good0.10 (0.10.24.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 11 Aug 2010 21:19:47 +0200
+
+gst-plugins-good0.10 (0.10.24.2-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 11 Aug 2010 09:12:22 +0200
+
+gst-plugins-good0.10 (0.10.24-1) unstable; urgency=low
+
+  * New upstream stable release, "Taking Liberties":
+    + debian/build-deps.in,
+      debian/rules:
+      - Build depend on GStreamer 0.10.30.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 15 Jul 2010 13:54:14 +0200
+
+gst-plugins-good0.10 (0.10.23.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 07 Jul 2010 15:42:43 +0200
+
+gst-plugins-good0.10 (0.10.23.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/rules:
+      - Build depend on GStreamer 0.10.29.3.
+    + debian/patches/01_jpeg-libgstbase-linking.patch:
+      - Dropped, merged upstream.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 30 Jun 2010 10:43:51 +0200
+
+gst-plugins-good0.10 (0.10.23.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/rules,
+      debian/compat,
+      debian/control.in,
+      debian/source/format,
+      debian/patches/*:
+      - Update to debhelper compat level 7.
+      - Update to source format 3.0 (quilt).
+    + debian/build-deps.in,
+      debian/rules:
+      - Build depend on GLib 2.20 and GStreamer 0.10.29.2.
+      - Build depend on libraw1394 2.0.0.
+      - Build depend on ORC instead of liboil.
+    + debian/patches/02_pulsesink-reuse.patch,
+      debian/patches/04_theora_delivery_method.patch,
+      debian/patches/05_rtph264pay_short_startcodes.patch:
+      - Dropped, merged upstream.
+    + debian/patches/01_jpeg-libgstbase-linking.patch:
+      - Link the jpeg plugin with libgstbase to fix FTBFS.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 26 Jun 2010 21:38:03 +0200
+
+gst-plugins-good0.10 (0.10.23-4) unstable; urgency=low
+
+  * debian/patches/05_rtph264pay_short_startcodes.patch:
+    + Patch from upstream GIT to let rtph264 cope with the shorter
+      startcodes that are now used by by x264enc. This fixes interoperability
+      with Google Video and Nokia N900 among others.
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Fri, 04 Jun 2010 12:51:01 +0100
+
+gst-plugins-good0.10 (0.10.23-3) unstable; urgency=low
+
+  * debian/patches/02_pulsesink-reuse.patch:
+    + Patch from upstream GIT to fix reuse of pulsesink.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 02 Jun 2010 10:54:42 +0200
+
+gst-plugins-good0.10 (0.10.23-2) unstable; urgency=low
+
+  * debian/patches/04_theora_delivery_method.patch
+    + Added. Let the theora payloader advertise delivery-method in its caps.
+      Needed for backwards compatibility with older gstreamer/farsight
+      versions. (From Gnome bugzilla #618940)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Mon, 31 May 2010 22:31:06 +0100
+
+gst-plugins-good0.10 (0.10.23-1) unstable; urgency=low
+
+  * New upstream release, "Stylish Kids in Riot".
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 31 May 2010 05:42:46 +0200
+
+gst-plugins-good0.10 (0.10.22.3-1) unstable; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/*:
+      - Drop all VP8/WebM patches and other patches that
+        are upstream now.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 26 May 2010 15:34:01 +0200
+
+gst-plugins-good0.10 (0.10.22.2-3) unstable; urgency=low
+
+  * Upload to unstable.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 20 May 2010 13:55:29 +0200
+
+gst-plugins-good0.10 (0.10.22.2-2) experimental; urgency=low
+
+  * debian/patches/00*:
+    + Add support for VP8 in the AVI, Matroska and QT/MP4 plugins
+      and fix some Matroska issues.
+  * debian/patches/04-pulse-0001-pulse-Don-t-lock-the-mainloop-in-NULL.patch:
+    + Don't try to use a NULL pulse mainloop.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 18 May 2010 20:59:55 +0200
+
+gst-plugins-good0.10 (0.10.22.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Ship the imagefreeze and oss4audio plugins here, they were
+        moved from gstreamer0.10-plugins-bad.
+      - Add conflicts for gstreamer0.10-plugins-bad because of the
+        moved capssetter element.
+  * debian/patches/01_efence-configure-check.patch:
+    + Fix configure check for efence.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 15 May 2010 09:55:08 +0200
+
+gst-plugins-good0.10 (0.10.22-1) unstable; urgency=low
+
+  * New upstream release, "Square One":
+    + debian/build-deps.in,
+      debian/rules:
+      - Build depend on GStreamer core/base >= 0.10.29.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 28 Apr 2010 09:44:17 +0200
+
+gst-plugins-good0.10 (0.10.21.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 26 Apr 2010 08:01:09 +0200
+
+gst-plugins-good0.10 (0.10.21.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/rules:
+      - Build depend on GStreamer core/base >= 0.10.28.2.
+  * debian/build-deps.in,
+    debian/control.in:
+    + (Build-) depend on GStreamer core/base documentation to get
+      documentation cross references right.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 15 Apr 2010 13:56:53 +0200
+
+gst-plugins-good0.10 (0.10.21-1) unstable; urgency=low
+
+  * New upstream stable release, "Lemons".
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 09 Mar 2010 09:48:28 +0000
+
+gst-plugins-good0.10 (0.10.19-1) unstable; urgency=low
+
+  * New upstream stable release, "Closer to the Edit":
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on gstreamer and gst-plugins-base >= 0.10.27.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 08 Mar 2010 10:01:27 +0000
+
+gst-plugins-good0.10 (0.10.18.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on gstreamer and gst-plugins-base >= 0.10.26.3.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 25 Feb 2010 08:27:57 +0100
+
+gst-plugins-good0.10 (0.10.18.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Add shapewipe plugin, which moved from gst-plugins-bad. Also
+        add Replaces for gst-plugins-bad << 0.10.17.2.
+    + debian/build-deps.in:
+      - Build depend on gst-plugins-base 0.10.26.2.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 19 Feb 2010 13:51:58 +0100
+
+gst-plugins-good0.10 (0.10.18-1) unstable; urgency=low
+
+  * New upstream release, "Short Circuit":
+    + debian/rules,
+      debian/build-deps.in:
+      - Update GStreamer and gst-plugins-base build dependencies to >= 0.10.26.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 11 Feb 2010 10:31:48 +0100
+
+gst-plugins-good0.10 (0.10.17.3-1) experimental; urgency=low
+
+  * debian/build-deps.in,
+    debian/gstreamer-plugins-good.install:
+    + Remove HAL plugin, HAL will most probably be dropped soon and
+      nobody uses this plugin anymore.
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 05 Feb 2010 10:10:51 +0100
+
+gst-plugins-good0.10 (0.10.17.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/rules,
+      debian/control.in:
+      - Build depend on GStreamer 0.10.25.2, gst-plugins-base 0.10.25.2
+        and GLib 2.18.
+    + Fixes demuxing of some MOV files (Closes: #561227).
+    + Fixes FTBFS with gcc 4.5 (Closes: #564998).
+  * debian/control.in:
+    + Fix typo in package description (Closes: #557368).
+    + Remove David I. Lehn from Uploaders (Closes: #557285).
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 27 Jan 2010 07:56:17 +0100
+
+gst-plugins-good0.10 (0.10.17-1) unstable; urgency=low
+
+  * debian/build-deps.in:
+    + Build depend on pulseaudio >= 0.9.20 for additional
+      features.
+  * New upstream release, "They used to sparkle".
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 17 Nov 2009 09:17:35 +0100
+
+gst-plugins-good0.10 (0.10.16.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 13 Nov 2009 07:58:08 +0100
+
+gst-plugins-good0.10 (0.10.16.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/00*pulse*.patch,
+      debian/patches/00*equalizer*.patch,
+      debian/patches/04_oss-rank.patch:
+      - Dropped, merged upstream.
+    + debian/build-deps.in,
+      debian/rules:
+      - Update build dependencies.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 10 Nov 2009 10:28:49 +0100
+
+gst-plugins-good0.10 (0.10.16-5) unstable; urgency=low
+
+  * debian/patches/0021-pulsesink-Only-set-the-volume-on-stream-connection-i.patch:
+    + Only set the volume on stream connection if pulse >= 0.9.20 is available,
+      this prevents weird volume changes in totem.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 30 Oct 2009 10:33:31 +0100
+
+gst-plugins-good0.10 (0.10.16-4) unstable; urgency=low
+
+  * debian/patches/000{1,2}-equalizer*.patch:
+    + Patches from upstream GIT to fix equalizer in stereo mode and
+      to use better filters for the first and last band.
+  * debian/patches/00[1-20]-pulse*.patch:
+    + Patches from upstream GIT to improve PulseAudio plugin and fix
+      some major issues, like decreasing the volume after every track
+      in some cases.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 18 Oct 2009 14:00:56 +0200
+
+gst-plugins-good0.10 (0.10.16-3) unstable; urgency=low
+
+  * debian/patches/04_oss-rank.patch:
+    + Downgrade the rank of osssrc to secondary
+  * debian/rules: Change default audio input to autoaudiosrc
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Wed, 07 Oct 2009 22:33:02 +0100
+
+gst-plugins-good0.10 (0.10.16-2) unstable; urgency=low
+
+  * debian/rules:
+    + Use libgudev on Linux for v4l2 device detection.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 30 Sep 2009 08:26:07 +0200
+
+gst-plugins-good0.10 (0.10.16-1) unstable; urgency=low
+
+  * New upstream release, 'Secret Handshakes'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 30 Aug 2009 11:02:26 +0200
+
+gst-plugins-good0.10 (0.10.15.5-1) experimental; urgency=low
+
+  * New upstream pre-release.
+  * debian/control.in:
+    + Update Standards-version to 3.8.3, no additional changes needed.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 26 Aug 2009 17:39:36 +0200
+
+gst-plugins-good0.10 (0.10.15.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 17 Aug 2009 08:11:59 +0200
+
+gst-plugins-good0.10 (0.10.15.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/rules:
+      - Update build dependencies.
+    + debian/control.in,
+      debian/gstreamer-plugins-good.install:
+      - Add the rtpmanager plugin which was moved from gst-plugins-bad.
+        For this also add Replaces for gst-plugins-bad << 0.10.13.2.
+    + debian/patches/01_equalizer-integer-arithmetic-distortions.patch,
+      debian/patches/02_SA35205-pngdec-integer-overflow.patch:
+      - Dropped, merged upstream.
+  * debian/control.in:
+    + Update Standards-version to 3.8.2, no additional changes needed.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 12 Aug 2009 07:13:08 +0200
+
+gst-plugins-good0.10 (0.10.15-2) unstable; urgency=high
+
+  * debian/patches/01_equalizer-integer-arithmetic-distortions.patch:
+    + Patch from upstream GIT to fix distortions when the integer
+      arithmetic mode of the equalizer is used.
+  * debian/patches/02_SA35205-pngdec-integer-overflow.patch:
+    + SECURITY: SA35205 - PNG Processing Integer Overflow Vulnerability
+      Patch from upstream GIT to fix an integer overflow in pngdec:
+      A malformed (or simply huge) PNG file can lead to integer overflow in
+      calculating the size of the output buffer, leading to crashes or buffer
+      overflows later (Closes: #531631).
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 03 Jun 2009 08:22:36 +0200
+
+gst-plugins-good0.10 (0.10.15-1) unstable; urgency=low
+
+  * New upstream release, 'I've been up all night'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 20 May 2009 23:19:36 +0200
+
+gst-plugins-good0.10 (0.10.14.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + Fixes regression in AVI seeking (Closes: #528813).
+    + debian/patches/01_rtp-libm-linking.patch:
+      - Dropped, merged upstream.
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Add the flv, deinterlace and y4menc plugins that
+        were moved from gst-plugins-bad.
+  * debian/control.in:
+    + Change section of the debug package to debug and add ${misc:Depends}
+      to it's dependencies.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 16 May 2009 11:28:14 +0200
+
+gst-plugins-good0.10 (0.10.14.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/01_gconf-notifications.patch:
+      - Dropped, merged upstream.
+    + debian/rules,
+      debian/build-deps.in:
+      - Updated build dependencies.
+    + debian/patches/01_rtp-libm-linking.patch:
+      - Link with -lm to fix unresolved symbols.
+  * debian/control.in:
+    + Update Standards-version to 3.8.1, no additional changes needed.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 12 May 2009 08:59:05 +0200
+
+gst-plugins-good0.10 (0.10.14-2) unstable; urgency=low
+
+  * Upload to unstable.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 06 Mar 2009 23:41:50 +0100
+
+gst-plugins-good0.10 (0.10.14-1) experimental; urgency=low
+
+  * New upstream release, 'Disaffected Affectation'.
+  * debian/patches/02_no-Werror.patch,
+    debian/rules:
+    + Pass -Wno-error via C(XX)FLAGS instead of patching configure.
+  * debian/patches/01_gconf-notifications.patch:
+    + Disconnect GConf notifications after usage, patch from upstream GIT.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 20 Feb 2009 10:31:38 +0100
+
+gst-plugins-good0.10 (0.10.13.3-1) experimental; urgency=low
+
+  * debian/build-deps.in:
+    + Build depend on gstreamer0.10-plugins-base 0.10.22 for the
+      new videotestsrc colors to fix the videocrop unit test.
+  * debian/gstreamer-plugins-good.install:
+    + Include the new equalizer presets.
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 16 Feb 2009 15:30:35 +0100
+
+gst-plugins-good0.10 (0.10.13.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/04_equalizer-coefficients.patch,
+      debian/patches/05_soup-live-source.patch,
+      debian/patches/06_libv4l.patch,
+      debian/patches/07_pulse-hang-and-thread-leak.patch,
+      debian/patches/99_autoreconf.patch:
+      - Dropped, merged upstream.
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on gstreamer and gst-plugins-base 0.10.22.
+      - Build depend on pulseaudio 0.9.13 to enable some optional
+        features in the pulse plugin.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 07 Feb 2009 20:36:03 +0100
+
+gst-plugins-good0.10 (0.10.13-2) experimental; urgency=low
+
+  * debian/patches/07_pulse-hang-and-thread-leak.patch:
+    + Patches from upstream GIT to fix some deadlocks when
+      the pulseaudio daemon disappears and also fix
+      a memory leak.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 26 Jan 2009 15:41:46 +0100
+
+gst-plugins-good0.10 (0.10.13-1) experimental; urgency=low
+
+  * New upstream security release, 'Blatant Discouragement':
+    + Fix potential buffer overflows while reading quicktime headers.
+      Security issue noticed by Tobias Klein (TKADV2009-0xx).
+    + debian/patches/99_autoreconf.patch:
+      - Updated for the new release.
+  * debian/build-deps.in:
+    + Build depend on libcairo2-dev instead of the virtual package
+      libcairo-dev.
+  * -
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 26 Jan 2009 15:41:45 +0100
+
+gst-plugins-good0.10 (0.10.11-2) experimental; urgency=low
+
+  * debian/patches/06_libv4l.patch,
+    debian/patches/99_autoreconf.patch,
+    debian/rules:
+    + Patch from upstream CVS to use libv4l for the v4l2 plugin instead
+      of direct access to the v4l device. This adds support for a lot
+      more v4l2 devices.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 05 Nov 2008 12:38:36 +0100
+
+gst-plugins-good0.10 (0.10.11-1) experimental; urgency=low
+
+  * New upstream release, 'Secondary Consideration'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 25 Oct 2008 09:39:23 +0200
+
+gst-plugins-good0.10 (0.10.10.4-1) experimental; urgency=low
+
+  [ Loic Minier ]
+  * Set gstreamer0.10-pulseaudio's Section to sound to match overrides.
+
+  [ Sebastian Dröge ]
+  * New upstream pre-release.
+  * debian/patches/04_equalizer-coefficients.patch:
+    + Patch from upstream bugtracker to not recalculate the equalizer
+      coefficients for every single buffer but only when it's needed.
+  * debian/patches/05_soup-live-source.patch:
+    + Patch from upstream bugtracker to allow souphttpsrc to work
+      as live source and have it provide timestamps.
+
+ -- Sebastian Dröge <slomo@debian.org>  Wed, 22 Oct 2008 11:08:03 +0200
+
+gst-plugins-good0.10 (0.10.10.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 18 Oct 2008 10:23:40 +0200
+
+gst-plugins-good0.10 (0.10.10.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/rules,
+      debian/build-deps.in:
+      - Build depend on gstreamer and gst-plugins-base >= 0.10.21.
+    + debian/build-deps.in:
+      - Build depend on FLAC >= 1.1.3.
+      - Build depend on bzip2.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 11 Oct 2008 15:42:49 +0200
+
+gst-plugins-good0.10 (0.10.10-1) experimental; urgency=low
+
+  * New upstream release, 'Barely Moving'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 28 Aug 2008 10:29:42 +0200
+
+gst-plugins-good0.10 (0.10.9.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/build-deps.in,
+      debian/gstreamer-plugins-good.install:
+      - Remove the cdio plugin, it moved to gst-plugins-ugly because libcdio
+        is GPL licensed.
+  * debian/rules:
+    + Build depend on gstreamer >= 0.10.20-3 for the new virtual package
+      names.
+  * debian/control.in:
+    + Wrap control fields.
+    + Depend on gstreamer0.10-plugins-base as some plugins need it.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 15 Aug 2008 09:28:10 +0200
+
+gst-plugins-good0.10 (0.10.9-2) experimental; urgency=low
+
+  * debian/control.in,
+    debian/rules:
+    + Use new automatic codec installation infrastructure.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 09 Aug 2008 16:56:46 +0200
+
+gst-plugins-good0.10 (0.10.9-1) experimental; urgency=low
+
+  * New upstream release, 'Steam Train Rolling'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 01 Aug 2008 11:32:53 +0200
+
+gst-plugins-good0.10 (0.10.8.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 29 Jul 2008 12:01:45 +0200
+
+gst-plugins-good0.10 (0.10.8.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 26 Jul 2008 12:34:57 +0200
+
+gst-plugins-good0.10 (0.10.8.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/10_speex_caps.patch,
+      debian/patches/11_rtsp_fdleak.patch,
+      debian/patches/12_matroskamux_track_duration.patch,
+      debian/patches/13_equalizer.patch:
+      - Dropped, merged upstream.
+    + debian/build-deps.in,
+      debian/control.in,
+      debian/gstreamer-pulseaudio.install,
+      debian/rules:
+      - Add the pulseaudio plugin.
+    + debian/gstreamer-plugins-good.install,
+      debian/control.in:
+      - Add the interleave and replaygain plugins.
+    + debian/build-deps.in,
+      debian/rules:
+      - Update gstreamer, gst-plugins-base and libcdio build dependencies.
+  * debian/control.in:
+    + Depend on gstreamer0.10-audiosink instead of a specific audiosink
+      plugin (Closes: #482796).
+  * debian/patches/03_pulse-rank.patch:
+    + Update the rank of the pulse elements to PRIMARY+10.
+  * debian/control.in:
+    + Update Standards-version to 3.8.0, no additional changes needed.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 20 Jul 2008 11:59:00 +0200
+
+gst-plugins-good0.10 (0.10.8-4) unstable; urgency=low
+
+  * debian/patches/13_equalizer.patch:
+    + Fix clipping in integer mode, correctly implement passthrough mode if
+      all bands have a gain of 0dB and delay filter coefficient calculation
+      until they're really needed. Patch from upstream CVS.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 02 Jun 2008 13:44:41 +0200
+
+gst-plugins-good0.10 (0.10.8-3) unstable; urgency=low
+
+  * debian/patches/11_rtsp_fdleak.patch
+    - Added. Fix filedescriptor leak on errors. (From upstream CVS)
+  * debian/patches/12_matroskamux_track_duration.patch
+    - Added. Fix track time calculation when muxing matroska files (From
+      upstream CVS)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Sun, 01 Jun 2008 16:15:48 +0200
+
+gst-plugins-good0.10 (0.10.8-2) unstable; urgency=low
+
+  * debian/patches/10_speex_caps.patch
+    - Added. Fix speexenc and rtpspeexpay caps negotiation (From gnome
+    bugzilla #465146)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Fri, 25 Apr 2008 21:51:20 +0200
+
+gst-plugins-good0.10 (0.10.8-1) unstable; urgency=low
+
+  * New upstream bugfix release, 'One For The Money'.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 24 Apr 2008 07:41:30 +0200
+
+gst-plugins-good0.10 (0.10.7.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 22 Apr 2008 10:28:29 +0200
+
+gst-plugins-good0.10 (0.10.7.3-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/patches/01_goom-missing-header.patch:
+      - Dropped, merged upstream.
+    + debian/build-deps.in:
+      - flex and bison are not necessary anymore.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 18 Apr 2008 10:35:19 +0200
+
+gst-plugins-good0.10 (0.10.7.2-2) experimental; urgency=low
+
+  * debian/patches/02_no-Werror.patch:
+    + Don't build with -Werror to fix FTBFS on some architectures.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 15 Apr 2008 05:29:28 +0200
+
+gst-plugins-good0.10 (0.10.7.2-1) experimental; urgency=low
+
+  * New upstream pre-release:
+    + debian/control.in:
+      - Adjust conflicts for gst-plugins-bad because of moved plugins.
+    + debian/rules,
+      debian/build-deps.in:
+      - Update build dependencies.
+    + debian/gstreamer-plugins-good.install:
+      - Ship soup and goom2k1 plugins.
+    + debian/rules:
+      - Set default audio/video sinks/srcs depending on the platform.
+    + debian/patches/02_v4l2_default.patch,
+      debian/patches/05_speexenc_double_unref.patch,
+      debian/patches/75_build_docs_without_python_xml.patch,
+      debian/patches/80_unit-tests.patch:
+      - Dropped, merged upstream.
+    + debian/patches/01_goom-missing-header.patch:
+      - Add missing header file that was forgotten.
+
+ -- Sebastian Dröge <slomo@debian.org>  Mon, 14 Apr 2008 10:59:00 +0200
+
+gst-plugins-good0.10 (0.10.7-3) unstable; urgency=low
+
+  * debian/patches/05_speexenc_double_unref.patch:
+    + Added. Don't unref a buffer twice when hitting a not-negotiated error
+    in speexenc (from upstream CVS) (Closes: #472096)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Sat, 22 Mar 2008 02:35:15 +0100
+
+gst-plugins-good0.10 (0.10.7-2) unstable; urgency=low
+
+  * debian/patches/02_v4l2_default.patch:
+    + Patch by Mario Limonciello to use v4l2 as default video source instead
+      of the nowadays deprecated v4l (Closes: #468073).
+  * debian/patches/75_build_docs_without_python_xml.patch,
+    debian/build-deps.in:
+    Stop using pyxml for building the docs (Closes: #468630).
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 11 Mar 2008 05:14:10 +0100
+
+gst-plugins-good0.10 (0.10.7-1) unstable; urgency=low
+
+  * New upstream release, "Red Door Black":
+    + debian/patches/01_linking-fixes.patch:
+      - Dropped, merged upstream.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 21 Feb 2008 10:48:23 +0100
+
+gst-plugins-good0.10 (0.10.6.4-1) experimental; urgency=low
+
+  * New upstream pre-release.
+  * debian/patches/99_ltmain_as-needed.patch,
+    debian/rules:
+    + Add -Wl,-z,defs -Wl,-O1 -Wl,--as-needed to LDFLAGS to remove some
+      unnecessary dependencies on various packages.
+  * debian/patches/01_linking-fixes.patch:
+    + Link gstalpha with libgstbase.
+  * debian/build-deps.in:
+    + Build depend on libxv-dev to get Xv support in ximagsink.
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 19 Feb 2008 06:54:55 +0100
+
+gst-plugins-good0.10 (0.10.6.3-1) experimental; urgency=low
+
+  * New upstream pre-release.
+  * debian/build-deps.in:
+    + Build depend on gstreamer0.10-plugins-base for the unit tests.
+  * debian/patches/80_unit-tests.patch:
+    + Disable gconfaudiosrc for the generic/states unit test.
+
+ -- Sebastian Dröge <slomo@debian.org>  Thu, 14 Feb 2008 13:14:55 +0100
+
+gst-plugins-good0.10 (0.10.6.2-1) experimental; urgency=low
+
+  [ Loic Minier ]
+  * Bump up type-handling build-dep to >= 0.2.14 and call it with  two
+    arguments again.
+
+  [ Emilio Pozuelo Monfort ]
+  * debian/rules:
+    - Decide the package name and url depending on the distribution.
+  * debian/build-deps.in:
+    - Build-Depend on lsb-release.
+
+  [ Sebastian Dröge ]
+  * New upstream pre-release:
+    + Fixes FTBFS if built twice in a row (Closes: #424398).
+    + Fixes playback of realaudio streams (Closes: #430364).
+    + Fixes switching of sink after song changes (Closes: #444769).
+    + debian/gstreamer-plugins-good.install:
+      - Add new equalizer, spectrum and multifile plugins and sort
+        alphabetically.
+    + debian/build-deps.in,
+      debian/rules:
+      - Update liboil and gstreamer build dependencies.
+    + debian/patches/20_gconf-state-change.patch,
+      debian/patches/30_id3_gst_tag_defines.patch:
+      - Dropped, merged upstream.
+    + debian/control.in:
+      - Update Replaces on gst-plugins-bad for the plugin moves.
+      - Update Standards-Version to 3.7.3, no additional changes needed.
+  * debian/rules:
+    + Run the unit test suite but don't fail the build on failures.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sat, 09 Feb 2008 12:11:21 +0100
+
+gst-plugins-good0.10 (0.10.6-4) unstable; urgency=low
+
+  * debian/patches/30_id3_gst_tag_defines.patch:
+    + Added. Use GST_TAG_ARTIST_SORTNAME instead of the deprecated
+      GST_TAG_MUSICBRAINZ_SORTNAME (Closes: #452671)
+    + Also add support for GST_TAG_ALBUM_SORTNAME, GST_TAG_TITLE_SORTNAME and
+      GST_TAG_COMPOSER
+    + Based on the current CVS version of gstid3v2mux
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Sat, 24 Nov 2007 22:07:19 +0100
+
+gst-plugins-good0.10 (0.10.6-3) unstable; urgency=low
+
+  * debian/rules:
+    + Set GST_REGISTRY before the dh_gstscancodecs call to save the registry
+      somewhere on buildds without writable home and speed things up a bit.
+  * debian/build-deps.in:
+    + Remove check from build dependencies. This is only an indirect build
+      dependency that is already satisfied by libgstreamer0.10-dev. configure
+      only checks for libgstcheck, not check.
+  * debian/patches/20_gconf-state-change.patch:
+    + Fix errors while changing the state of the gconf sink. Patch from
+      upstream CVS, see http://bugzilla.gnome.org/show_bug.cgi?id=471364 .
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 25 Sep 2007 15:31:31 +0200
+
+gst-plugins-good0.10 (0.10.6-2) unstable; urgency=low
+
+  * debian/control.in:
+    + Add Replaces on gstreamer0.10-plugins-really-bad (<< 0.10.4.2), which is
+      maintained in the Debian Multimedia project and also contained the
+      WavPack plugin.
+  * debian/build-deps.in,
+    debian/rules:
+    + Call dh_gstinstallcodecs to generate the codecs database.
+  * debian/gstreamer-plugins-good.install,
+    debian/gstreamer-plugins-good-doc.install,
+    debian/control.in:
+    + Move translations from the docs package to the plugin package.
+
+ -- Sebastian Dröge <slomo@debian.org>  Fri, 31 Aug 2007 09:27:06 +0200
+
+gst-plugins-good0.10 (0.10.6-1) unstable; urgency=low
+
+  * New upstream release, "Wobble Board":
+    + Fixes muxing of raw audio in Matroska files (Closes: #360536).
+    + Fixes memory leak in cutter and level plugins (Closes: #425114).
+    + debian/patches/20_gstavidemux-error-out-on-pull_range.patch,
+      debian/patches/30_speex-rtp-fixes.patch,
+      debian/patches/40_flac1.1.3.patch,
+      debian/patches/99_autoreconf.patch:
+      - Dropped, merged upstream.
+    + debian/build-deps.in,
+      debian/rules:
+      - Require gstreamer and gst-plugins-base >= 0.10.13.
+    + debian/gstreamer-plugins-good.install,
+      debian/build-deps.in,
+      debian/control.in:
+      - Add wavpack, qtdemux, videocrop, monoscope and gamma plugins.
+        For this add Replaces on gstreamer0.10-plugins-bad (<< 0.10.4.2).
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 19 Jun 2007 19:28:52 +0200
+
+gst-plugins-good0.10 (0.10.5-7) unstable; urgency=low
+
+  * debian/control.in:
+    + Use ${binary:Version} instead of ${Source-Version} to make lintian happy.
+  * debian/patches/40_flac1.1.3.patch:
+    + Patch from upstream CVS to work with flac >= 1.1.3. (Closes: #427744, #426647).
+      http://bugzilla.gnome.org/show_bug.cgi?id=385887
+  * debian/patches/99_autoreconf.patch:
+    + Regenerate configure for the above change.
+
+ -- Sebastian Dröge <slomo@debian.org>  Sun, 10 Jun 2007 22:58:34 +0200
+
+gst-plugins-good0.10 (0.10.5-6) unstable; urgency=low
+
+  * debian/patches/30_speex-rtp-fixes.patch
+    + Added. Fix the speex rtp payloader and depayloader. (From upstream CVS)
+
+ -- Sjoerd Simons <sjoerd@debian.org>  Thu, 10 May 2007 13:27:36 +0200
+
+gst-plugins-good0.10 (0.10.5-5) unstable; urgency=low
+
+  * Upload to unstable
+  * Merge experimental branch:
+    [ Loic Minier ]
+    + Build-depend on libpng12-dev instead of libpng12-0-dev to get the
+      libpng12.pc file.
+
+    [ Sebastian Dröge ]
+    + New upstream release 0.10.5, "The Path of Thorns":
+      - Fixes playback of some internet radio streams (Closes: #384377)
+      - debian/patches/12_gstcacasink-header-include.patch,
+        debian/patches/13_separate-handle-for-avc-ops.patch:
+        . Dropped, merged upstream
+      - debian/rules,
+      - debian/build-deps.in:
+        . Build depend on gstreamer / gst-plugins-base >= 0.10.10.1
+      - debian/gstreamer-plugins-good.install:
+        . Add audiofx plugin
+    + debian/patches/11_esdsink-priority.patch:
+      - Dropped, priorities are cached in the gst registry, thus this patch had
+        almost no effect. This should somehow be solved by a determined priority
+        order for sinks
+    + debian/control:
+      - Updated to use my debian.org mail address
+    + debian/control,
+      debian/gstreamer-plugins-good.install:
+      - Only build the video4linux2 plugin on Linux. Fixes FTBFS everywhere else
+    + debian/build-deps.in,
+      debian/rules:
+      - Use type-handling to only depend on libraw1394 and friends on Linux
+ 
+    [ Sjoerd Simons ]
+    + Enable experimental plugins (the v4l2src plugin)
+    + Conflict with gstreamer0.10-plugins-bad < 0.10.4 which used to provide the
+      v4l2src plugin.
+    + Add myself to uploaders
+
+  * debian/patches/20_gstavidemux-error-out-on-pull_range.patch:
+    + Updated for the new upstream version
+
+ -- Sebastian Dröge <slomo@debian.org>  Tue, 10 Apr 2007 20:34:53 +0200
+
+gst-plugins-good0.10 (0.10.4-3) unstable; urgency=high
+
+  * New patch, 13_separate-handle-for-avc-ops, to use a separate handle on
+    raw1394 for AVC operations.
+  * Urgency high as the dv plugin is unusable without this patch.
+  * Merge 0.10.4-2.
+
+ -- Loic Minier <lool@dooz.org>  Wed, 25 Oct 2006 16:07:07 +0200
+
+gst-plugins-good0.10 (0.10.4-2) experimental; urgency=low
+
+  * Re-add -dbg package and target at experimental.
+
+ -- Loic Minier <lool@dooz.org>  Fri, 13 Oct 2006 12:27:45 +0200
+
+gst-plugins-good0.10 (0.10.4-1) unstable; urgency=low
+
+  [ Loic Minier ]
+  * New patch, 11_esdsink-priority, taken from Ubuntu to include esdsink in
+    the candidates of autoaudiosink. (Closes: #373703)
+
+  [ Sebastian Dröge ]
+  * New upstream release, "Dear Leader".
+    - Fixes reading and parsing of some id3v2 tags. (Closes: #361310)
+    - Tries esdsink but does not autospawn esound. (Closes: #361841)
+    - Fixes crash of dv1394src by using a separate handle for AVC operations.
+      (Closes: #369936)
+    - debian/patches/10_fix-h263-caps.patch:
+      + dropped, merged upstream
+    - debian/patches/11_esdsink-priority.patch:
+      + Updated, partially upstream
+    - debian/rules:
+      + Require libraw1394-dev (>= 1.2.1) and libiec61883-dev (>= 1.0.0)
+  * debian/control.in:
+    + Added myself to Uploaders
+  * debian/gstreamer-plugins-good.install:
+    + Remove the duplicated entries for the dv1394 element
+  * debian/compat,
+    debian/build-deps.in:
+    + Update to debhelper compat level 5
+  * debian/rules,
+    debian/control.in:
+    + Add a -dbg package
+
+  [ Loic Minier ]
+  * Rename patch 11_gstcacasink-header-include to
+    12_gstcacasink-header-include.
+  * Drop -dbg package for now, this version is for etch.
+
+ -- Loic Minier <lool@dooz.org>  Fri, 13 Oct 2006 12:13:08 +0200
+
+gst-plugins-good0.10 (0.10.3-3) unstable; urgency=medium
+
+  * New patch, 11_gstcacasink-header-include, to fix building of the libcaca
+    plugin; thanks Sam Hocevar. (Closes: #386169)
+
+ -- Loic Minier <lool@dooz.org>  Sat,  9 Sep 2006 20:32:43 +0200
+
+gst-plugins-good0.10 (0.10.3-2) unstable; urgency=low
+
+  * Bump up Standards-Version to 3.7.2.
+    [debian/control, debian/control.in]
+  * New patch from upstream to fix caps of H263 RTP streams, thanks Paul van
+    Tilburg.
+    [debian/patches/10_fix-h263-caps.patch]
+  * Export OIL_CPU_FLAGS=0 for commands launched during the build process as
+    it can cause build failures on buildds with specific hardware at build
+    time.
+    [debian/rules]
+
+ -- Loic Minier <lool@dooz.org>  Wed, 17 May 2006 23:05:56 +0200
+
+gst-plugins-good0.10 (0.10.3-1) unstable; urgency=low
+
+  * New upstream release, "Desplazado".
+    - Bump libgstreamer0.10-dev build-dep to 0.10.4.1.
+      [debian/control, debian/rules]
+    - Bump libgstreamer-plugins-base0.10-dev build-dep to 0.10.5.1.
+      [debian/build-deps.in, debian/build-deps, debian/control]
+    - New ximagesrc plugin.
+      . Add libxdamage-dev, libxext-dev, and libxfixes-dev build-deps.
+        [debian/build-deps.in, debian/build-deps, debian/control]
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+    - New annodex plugin.
+      . Add libxml2-dev build-dep.
+        [debian/build-deps.in, debian/build-deps, debian/control]
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+    - New gdkpixbuf plugin.
+      . Add libgtk2.0-dev build-dep.
+        [debian/build-deps.in, debian/build-deps, debian/control]
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+    - New halelements plugin.
+      . Add libdbus-1-dev (>= 0.32) and libhal-dev (>= 0.5.6) build-deps.
+        [debian/build-deps.in, debian/build-deps, debian/control]
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+    - New taglib plugin.
+      . Add libtag1-dev build-dep.
+        [debian/build-deps.in, debian/build-deps, debian/control]
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+    - New videobalance plugin, installed in gstreamer-plugins-good.
+      [debian/gstreamer-plugins-good.install]
+    - New icydemux plugin.
+      . Install in gstreamer-plugins-good.
+        [debian/gstreamer-plugins-good.install]
+
+ -- Loic Minier <lool@dooz.org>  Sat,  6 May 2006 11:52:57 +0200
+
+gst-plugins-good0.10 (0.10.2-2) unstable; urgency=low
+
+  * Depend on the alsa package instead of recommending it, since package
+    managers don't honor Recommends: in all cases. (Closes: #352212)
+    [debian/control, debian/control.in]
+
+ -- Loic Minier <lool@dooz.org>  Thu, 16 Feb 2006 14:45:38 +0100
+
+gst-plugins-good0.10 (0.10.2-1) unstable; urgency=low
+
+  * New upstream release, "Papa was a rolling stone".
+
+ -- Loic Minier <lool@dooz.org>  Tue, 14 Feb 2006 10:44:13 +0100
+
+gst-plugins-good0.10 (0.10.1.2-1) unstable; urgency=low
+
+  * New upstream pre-release.
+    - Bump up libgstreamer0.10-dev build-dep to >= 0.10.2.2.
+      [debian/control, debian/rules]
+    - Bump up libgstreamer-plugins-base0.10-dev to >= 0.10.2.2.
+      [debian/build-deps.in, debian/build-deps, debian/control]
+    - Add apetag plugin.
+      . Install plugin.
+      [debian/gstreamer-plugins-good.install]
+    - Add cdio plugin.
+      . Add libcdio-dev >= 0.71 build-dep.
+      . Install plugin.
+      [debian/build-deps, debian/build-deps.in, debian/control, debian/gstreamer-plugins-good.install]
+  * Use upstream descriptions in packages descriptions.
+    [debian/control, debian/control.in]
+
+ -- Loic Minier <lool@dooz.org>  Sat, 11 Feb 2006 17:30:38 +0100
+
+gst-plugins-good0.10 (0.10.1-2) unstable; urgency=low
+
+  * Recommend gstreamer0.10-alsa and gstreamer0.10-x, as these are used by
+    default upstream -- in the GConf schemas -- and used from the autodetect
+    audio and videosinks.
+    [debian/control, debian/control.in]
+
+ -- Loic Minier <lool@dooz.org>  Sun,  5 Feb 2006 15:08:53 +0100
+
+gst-plugins-good0.10 (0.10.1-1) unstable; urgency=low
+
+  * New upstream release, "Li".
+    - Bump libgstreamer-plugins-base0.10-dev build-dep to >= 0.10.1.
+      [debian/build-deps.in, debian/control]
+    - Bump libgstreamer0.10-dev build-dep to >= 0.10.1.
+      [debian/control, debian/rules]
+    - Add id3demux plugin.
+      [debian/gstreamer-plugins-good.install]
+    - Add translated strings from /usr/share/locale.
+      [debian/gstreamer-plugins-good.install]
+  * Drop useless gst_plugins_base_lib_dev_dep, gst_plugins_base_lib_dev,
+    gst_plugins_base_lib, and gst_plugins_good_version definitions.
+    [debian/rules]
+
+ -- Loic Minier <lool@dooz.org>  Sun, 15 Jan 2006 18:04:49 +0100
+
+gst-plugins-good0.10 (0.10.0-1) unstable; urgency=low
+
+  [ Sebastien Bacher ]
+  * New package:
+    - clean patches
+      [debian/patches/50_cdparanoia-fix-eos-detection-of-last-title.patch]
+    - updated Build-Depends [debian/build-deps.in]
+    - updated documentation [debian/README.Debian, debian/TODO.Debian]
+    - updated packages list [debian/control.in, debian/gstreamer-alsa.install,
+      debian/gstreamer-gnomevfs.install, debian/gstreamer-misc.install,
+      debian/gstreamer-plugins-base-apps.instal,
+      debian/gstreamer-plugins-base-apps.manpages,
+      debian/gstreamer-plugins-base-doc.install,
+      debian/gstreamer-x.install, debian/libgstreamer-plugins-base-dev.install,
+      debian/libgstreamer-plugins-base.install, debian/gstreamer-aa.install,
+      debian/gstreamer-auto.install, debian/gstreamer-caca.install,
+      debian/gstreamer-esd.install, debian/gstreamer-misc-good.install,
+      debian/gstreamer-oss.install, debian/gstreamer-plugins-good-doc.install,
+      debian/rules]
+    - updated upstream location [debian/watch]
+    - don't use type-handling it's not useful
+      [debian/build-deps.in, debian/control.in, debian/rules]
+
+  [ Loic Minier ]
+  * Merge aa, auto, caca, and oss packages and plugins in misc and let it
+    provide audio and videosinks;  use a couple of @GST_ABI@s where
+    appropriate.
+    [debian/control, debian/control.in,
+    debian/gstreamer-aa.install, debian/gstreamer-caca.install,
+    debian/gstreamer-misc-good.install, debian/gstreamer-oss.install,
+    debian/rules]
+  * Rename for good misc-good in good.
+    [debian/control debian/control.in
+     debian/gstreamer-misc-good.install debian/rules]
+  * Downgrade cdbs build-dep for Debian.
+    [debian/build-deps, debian/build-deps.in, debian/control]
+  * Rename gstreamer0.10-good in gstreamer0.10-plugins-good.
+    [debian/control, debian/control.in, debian/gstreamer-good.install,
+    debian/gstreamer-plugins-good.install, debian/rules]
+  * Add a build-dep on check.
+    [debian/build-deps, debian/build-deps.in, debian/control]
+  * Remove python-twisted build-dep.
+    [debian/build-deps, debian/build-deps.in, debian/control]
+
+ -- Loic Minier <lool@dooz.org>  Wed, 21 Dec 2005 17:37:46 +0100
+
+gst-plugins-base0.10 (0.10.0-1) unstable; urgency=low
+
+  [ Sebastien Bacher ]
+  * New package:
+    - build the documentation [debian/rules]
+    - no action needed to register the plugins with the new version
+      [debian/gstreamer-plugin-template.postinst,
+       debian/gstreamer-plugin-template.postrm,
+       debian/libgstreamer-plugins.postinst,
+       debian/libgstreamer-plugins.postrm, debian/rules]
+    - drop mechanism to build extra packages for other distributions around,
+      it's not useful for base [debian/extras, debian/rules]
+    - drop transitionnal workaround [debian/gstreamer-plugin-template.preinst]
+    - new gstreamer-plugin-base-doc package [debian/control.in, debian/rules]
+    - remove obsolete patches
+      [debian/patches/10_wavpack-high-quality-segfault.patch,
+      debian/patches/30_alsa-verify-accepted-period-size.patch,
+      debian/patches/31_alsa-advanced-probing.patch,
+      debian/patches/40_audioscale-timestamps-and-durations.patch,
+      debian/patches/50_ladspa-quiet.patch]
+    - updated the Build-Depends [debian/build-dep.in]
+    - updated the packages descriptions [debian/control.in]
+    - updated the packages names/list [debian/control.in,
+      debian/gstreamer-a52dec.install, debian/gstreamer-aa.install,
+      debian/gstreamer-artsd.install, debian/gstreamer-audiofile.install,
+      debian/gstreamer-avifile.install, debian/gstreamer-caca.install,
+      debian/gstreamer-cdio.install, debian/gstreamer-dvd.install,
+      debian/gstreamer-dv.install, debian/gstreamer-esd.install,
+      debian/gstreamer-festival.install, debian/gstreamer-flac.install,
+      debian/gstreamer-gsm.install, debian/gstreamer-gtk.install,
+      debian/gstreamer-hermes.install, debian/gstreamer-jpeg.install,
+      debian/gstreamer-lame.install, debian/gstreamer-mad.install,
+      debian/gstreamer-mikmod.install, debian/gstreamer-mms.install,
+      debian/gstreamer-mpeg2dec.install, debian/gstreamer-oss.install,
+      debian/gstreamer-sdl.install, debian/gstreamer-sid.install,
+      debian/gstreamer-speex.install, debian/gstreamer-swfdec.install,
+      debian/libgstreamer-gconf.install, debian/libgstreamer-gconf-dev.install,
+      debian/gstreamer-vorbis.install, debian/rules]
+    - updated the packages lists [debian/gstreamer-misc.install,
+      debian/libgstreamer-plugins-base-dev.install,
+      debian/libgstreamer-plugins-base.install]
+    - updated packages content
+      [debian/gstreamer-misc.install, debian/gstreamer-x.install]
+    - updated the version [debian/rules]
+    - updated watch file [debian/watch]
+
+  [ Loic Minier ]
+  * Minor cleanups.
+    [debian/rules]
+  * Add Sebastien Bacher to Uploaders.
+    [debian/control, debian/control.in]
+
+ -- Loic Minier <lool@dooz.org>  Sat, 17 Dec 2005 18:11:03 +0100
+
+gst-plugins0.8 (0.8.11-3) unstable; urgency=medium
+
+  * New CDIO plugin package.
+    . Add libcdio-dev build-dep for CDIO support.
+      [debian/build-deps.in, debian/build-deps, debian/control]
+    . Add package description and file listing.
+      [debian/gstreamer-cdio.install, debian/control.in, debian/control]
+    . List package in plugins build-list. [debian/rules]
+    . List package in gstreamer-plugins deps.
+      [debian/control.in, debian/control]
+  * New MMS plugin package. (Closes: #301246)
+    . Add libmms-dev build-dep for mms:// and mmsh:// support.
+      [debian/build-deps.in, debian/build-deps, debian/control]
+    . Add package description and file listing.
+      [debian/gstreamer-cdio.install, debian/control.in, debian/control]
+    . List package in plugins build-list. [debian/rules]
+    . List package in gstreamer-plugins deps.
+      [debian/control.in, debian/control]
+  * Fix the homepage of the mikmod page and stop linking to an adult web site.
+    [debian/control, debian/control.in]
+  * Remove "Section: libs" from binary packages.
+    [debian/control, debian/control.in]
+  * Exit with non-zero code when requesting an unknown plugin.
+    [debian/extra]
+  * Add sample code to permit other distros to build additional plugins.
+    [debian/rules]
+  * Minor cleanups.
+    [debian/rules]
+  * New Gtk / Gdk package to split out this dep-tree for KDE folks, from
+    Ubuntu, thanks Sebastien Bacher.
+    . Add package description and file listing, remove it from -misc.
+      [debian/control.in, debian/control, debian/gstreamer-gtk.install,
+      debian/gstreamer-misc.install]
+    . List package in plugins build-list. [debian/rules]
+    . List package in gstreamer-plugins deps.
+      [debian/control.in, debian/control]
+    . Only "Replace" with -misc in the first version doing the split
+      (0.8.11-0ubuntu3), no Conflict needed.
+  * Add wavpack support, build the wavpack plugin and ship it in -misc.
+    (Closes: #339598)
+    . Add a libwavpack-dev build-dep.
+      [debian/build-deps, debian/build-deps.in]
+    . Ship plugin in -misc.
+      [debian/gstreamer-misc.install]
+    . Adjust the size of the internal decode buffer dynamically instead of
+      assuming 0.5 seconds are enough;  fixes a segfault when playing files
+      encoded with -h;  upstream bug: #317774;  fix committed in branch
+      BRANCH-GSTREAMER-0_8.
+      [debian/patches/10_wavpack-high-quality-segfault.patch]
+  * Backport some interesting upstream fixes from CVS fixing most resampling
+    issues for non-standard bitrates and for complex ALSA configurations
+    (especially dmix), thanks Tim-Philipp Müller, Luca Ognibene, and others.
+    (Closes: #323447, #324163, #326135, #340038)
+    - When doing _set_period_size_near(), see what period size was actually
+      set in the end and continue working with that value instead of just
+      assuming the desired period size was accepted;  upstream bug #318767;
+      fix committed in branch BRANCH-GSTREAMER-0_8.
+      [debian/patches/30_alsa-verify-accepted-period-size.patch]
+    - Don't mess up timestamps and durations when resampling by more than a
+      factor of 2 (e.g. 8kHz => 48kHz);  upstream bug #318273;  fix committed
+      in branch BRANCH-GSTREAMER-0_8.
+      [debian/patches/40_audioscale-timestamps-and-durations.patch]
+    - When the default device is being used, try to probe the caps of the
+      underlying device instead if possible. This should give more narrowly
+      defined caps that are closer to the hardware's capabilities. This is
+      enabled by default, but can be switched off via the new
+      'advanced-probing' property;  upstream bug #315121;  fix committed in
+      branch BRANCH-GSTREAMER-0_8.
+      [debian/patches/31_alsa-advanced-probing.patch]
+  * Drop the polypaudio plugin package. (Closes: #342278)
+    . Drop libpolyp-dev (>= 0.7) build-dep.
+      [debian/build-deps.in, debian/build-deps, debian/control]
+    . Remove package description and file listing.
+      [debian/gstreamer-polypaudio.install, debian/control.in, debian/control]
+    . Remove package from plugins build-list. [debian/rules]
+    . Remove package from gstreamer-plugins deps.
+      [debian/control.in, debian/control]
+  * Add libgconf2-dev, libglib2.0-dev, liborbit2-dev, libpopt-dev, libxml2-dev
+    deps to libgstreamer-gconf0.8-dev as listed in its .la files.
+    [debian/control, debian/control.in]
+  * Add libglib2.0-dev, libpopt-dev, libxml2-dev deps to
+    libgstreamer-plugins0.8-dev as listed in its .la files.
+    [debian/control, debian/control.in]
+  * Fix EOS detection for last title (fixes gnome-cd hanging after last track
+    ends), thanks Gustavo Noronha Silva;  upstream bug #317630;  fix committed
+    in branch BRANCH-GSTREAMER-0_8. (Closes: #330954)
+    [debian/patches/50_cdparanoia-fix-eos-detection-of-last-title.patch]
+  * Don't overwrite DEB_CONFIGURE_EXTRA_FLAGS.
+    [debian/rules]
+
+ -- Loic Minier <lool@dooz.org>  Sun, 11 Dec 2005 14:52:38 +0100
+
+gst-plugins0.8 (0.8.11-2) unstable; urgency=high
+
+  * Add misc:depends to all binary packages. (Closes: #329759)
+
+ -- Loic Minier <lool@dooz.org>  Mon, 17 Oct 2005 21:41:54 +0200
+
+gst-plugins0.8 (0.8.11-1) unstable; urgency=low
+
+  * Override gstreamer-dv section to extra because it depends on libavc1394-0
+    which is in extra. [debian/control, debian/control.in]
+  * Bump libflac-dev build-dependency for the latest flac soname change
+    (libflac6 -> libflac7). (Closes: #325940)
+  * New upstream release, "... And Thanks For All The Fix".
+    - New plugin imagemixer. [debian/gstreamer-misc.install]
+    - New plugin dvdsubdec. [debian/gstreamer-misc.install]
+    - Drop obsolete artsd patch, merged upstream.
+      [debian/patches/25_artds-no-name.patch]
+  * Update FSF address. [debian/copyright]
+  * Add cairo plugin. [debian/build-deps, debian/build-deps.in,
+    debian/control, debian/gstreamer-misc.install]
+
+ -- Loic Minier <lool@dooz.org>  Sun,  4 Sep 2005 21:19:47 +0200
+
+gst-plugins0.8 (0.8.10-3) unstable; urgency=high
+
+  * Urgency high because this fixes some RC bugs and 0.8.10-2 was caught in
+    the C++ transition.
+  * Bump up build-deps to get versions past the C++ transition.
+    [debian/build-deps, debian/build-deps.in, debian/control]
+    - libsdl1.2-dev
+    - libsidplay1-dev (Closes: #321315)
+    - libarts1-dev, libartsc0-dev
+  * Change X11 build-deps for the Xorg transition.
+    [debian/build-deps, debian/build-deps.in, debian/control]
+    - remove xlibs-dev and xlibs-pic.
+    - add libx11-dev, libxext-dev, and libxv-dev.
+  * Drop jack plugin. [debian/build-deps, debian/build-deps.in,
+    debian/control, debian/control.in, debian/gstreamer-jack.install,
+    debian/rules] (Closes: #321648)
+  * Add libgstglimagesink plugin. [debian/gstreamer-x.install]
+  * Add libgstfreeze plugin. (Closes: #318146) [debian/gstreamer-misc.install]
+  * Let libgstreamer-gconf suggest gnome-media. (Closes: #294490)
+    [debian/control, debian/control.in]
+
+ -- Loic Minier <lool@dooz.org>  Fri, 12 Aug 2005 18:36:58 +0200
+
+gst-plugins0.8 (0.8.10-2) unstable; urgency=medium
+
+  [ Sebastien Bacher ]
+  * debian/build-deps.in:
+    - list libpolyp-dev.
+  * debian/control.in:
+    - gstreamer0.8-plugins depends on gstreamer0.8-polypaudio.
+    - gstreamer0.8-polypaudio description.
+  * gstreamer-polypaudio.install:
+    - install libpolypaudio.so.
+  * debian/rules:
+    - list polypaudio.
+
+  [ Loic Minier ]
+  * Update jack dependency. (Closes: #317197)
+    [debian/build-deps, debian/build-deps.in, debian/control]
+  * Update aalib dependency. (Closes: #320886)
+    [debian/build-deps, debian/build-deps.in, debian/control]
+
+  * Urgency medium because of RC.
+
+ -- Loic Minier <lool@dooz.org>  Sun, 10 Jul 2005 19:27:08 +0200
+
+gst-plugins0.8 (0.8.10-1) unstable; urgency=low
+
+  * Loic Minier:
+    * New upstream release "Jangle".
+      - Bump inter-dependencies to >= 0.8.10.
+    * Use upstream fix for the "name" property of the artsdsink element.
+      [debian/patches/25_artds-no-name.patch]
+
+ -- Loic Minier <lool@dooz.org>  Sat,  2 Jul 2005 21:04:40 +0200
+
+gst-plugins0.8 (0.8.9-2) unstable; urgency=medium
+
+  * Loic Minier:
+    * Urgency medium as last gstreamer0.8 release exposed an artsdsink
+      problem fixed here.
+    * Add a versioned dependency with >= current-upstream-version to all
+      current shlibs inter-dependencies to ensure consistency of symbols.
+      (Closes: #315556) [debian/control, debian/control.in, debian/rules]
+    * Remove the "name" property in the artsd plugin as it interferes with
+      the usage of this property within GStreamer. (Closes: #314762)
+      [debian/patches/25_artds-no-name.patch]
+    * Call gst-register and gst-compprep with GST_REGISTRY in their
+      environment to override the default behavior of writing to
+      /root/.gstreamer-0.8, waiting for an upstream fix.
+      [debian/gstreamer-plugin-template.postinst,
+      debian/gstreamer-plugin-template.postrm]
+    * Add a postinst/postrm snipset to register plugins in
+      libgstreamer-plugins0.8. (Closes: #283658)
+      [debian/libgstreamer-plugins.postrm,
+      debian/libgstreamer-plugins.postinst, debian/changelog, debian/rules]
+    * Remove left over /root/.gstreamer-0.8 tree if it hasn't been modified.
+      [debian/gstreamer-plugin-template.preinst, debian/rules]
+    * Set Maintainer to group. [debian/control, debian/control.in]
+    * Bump Standards-Version to 3.6.2, no change needed.
+      [debian/control, debian/control.in]
+    * Workaround type-handling bug #315761.
+      [debian/control, debian/control.in, debian/rules]
+
+ -- Loic Minier <lool@dooz.org>  Mon, 27 Jun 2005 15:44:35 +0200
+
+gst-plugins0.8 (0.8.9-1) unstable; urgency=low
+
+  * Loic Minier:
+    * New upstream release "Old Hat".
+      - Fix SIGFPE in alsasrc. (Closes: #279399)
+      - New Musepack plugin package.
+        . Add libmpcdec-dev build-dep for Musepack support, this is now
+          detected in a Debian compatible manner via mpcdec/mpcdec.h and
+          -lmpcdec. [debian/build-deps.in, debian/build-deps, debian/control]
+        . Add package description and file listing.
+          [debian/gstreamer-musepack.install, debian/control.in,
+          debian/control]
+        . List package in plugins build-list. [debian/rules]
+        . List package in gstreamer-plugins deps.
+          [debian/control.in, debian/control]
+      - Renamed and updated "ladspa" patch.
+        [debian/patches/ladspa-quiet.patch,
+        debian/patches/50_ladspa-quiet.patch]
+      - Add video4linuxradio plugin to the gstreamer-misc package.
+        [debian/rules]
+    * Add compatibility block for older dpkg and use DEB_HOST_ARCH_OS.
+    * Add myself as uploader. [debian/control.in, debian/control]
+    * Fix indentation and executable permission of package maintaining
+      helpers. [debian/extra, debian/maint, debian/mk.control]
+    * Remove more bits from the arts plugin, left over in 0.8.1-2.
+      [debian/extra, debian/gstreamer-arts.install]
+    * Document the role of most files. [debian/HACKING.Debian]
+    * Add a TODO list for the Debian package. [debian/TODO.Debian]
+
+ -- Loic Minier <lool@dooz.org>  Tue, 21 Jun 2005 07:47:04 +0200
+
+gst-plugins0.8 (0.8.8-3) unstable; urgency=low
+
+  * debian/build-deps.in:
+    * Bump liboil dependency to liboil0.3-dev.  gst-plugins doesn't yet use
+      0.3 itself but the swfdec plugin build requires it.
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 30 Mar 2005 19:08:07 -0500
+
+gst-plugins0.8 (0.8.8-2) unstable; urgency=low
+
+  * debian/control.in:
+    * gstreamer0.8-vorbis depends on gstreamer0.8-misc >= 0.8.8-1
+      (Closes: #300082, #299954, #299921)
+
+ -- David I. Lehn <dlehn@debian.org>  Thu, 17 Mar 2005 12:53:38 -0500
+
+gst-plugins0.8 (0.8.8-1) unstable; urgency=low
+
+  * New upstream
+  * debian/patches/flac.patch:
+    * Remove: included upstream
+  * debian/gstreamer-misc.install:
+    * Add new plugins: autodetect, dvdlpcmdec, puzzle, rfbsrc, subparse
+    * Add new plugins with lib dependencies: gconfelements, mng, shout2
+      (Closes: #292011)
+  * debian/build-deps.in:
+    * Add: libmng-dev, libshout3-dev
+  * Upstream fixes:
+    * Xv falls back to X11 (Closes: #296848)
+    * Better audio sink selection (Closes: #284210)
+    * alsasink crash (Closes: #296751)
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 16 Mar 2005 01:00:39 -0500
+
+gst-plugins0.8 (0.8.7-3) unstable; urgency=low
+
+  * debian/rules, debian/build-deps.in
+    * Apply additional kfreebsd-gnu patch (Closes: #272568)
+  * debian/patches/flac.patch:
+    * Upstream fix for FLAC API change (Closes: #290784)
+
+ -- David I. Lehn <dlehn@debian.org>  Mon, 17 Jan 2005 17:53:42 -0500
+
+gst-plugins0.8 (0.8.7-2) unstable; urgency=low
+
+  * debian/rules:
+    * Bump libgstreamer0.8-dev dependency to >= 0.8.7.1
+
+ -- David I. Lehn <dlehn@debian.org>  Sat,  8 Jan 2005 15:50:45 -0500
+
+gst-plugins0.8 (0.8.7-1) unstable; urgency=low
+
+  * New upstream
+  * debian/build-deps.in, debian/control.in, debian/rules,
+    debian/gstreamer-dv.install, debian/gstreamer-misc.install:
+    * Patch build system for kfreebsd-gnu (Closes: #272568)
+  * debian/rules:
+    * Distribute NEWS (as requested in #275717)
+  * debian/gstreamer-misc.install:
+    * Add new plugins: apetag, tta
+  * debian/patches/configure-speex.patch:
+    * Remove patch, included upstream
+  * debian/build-deps.in:
+    * Build against latest libflac-dev
+
+ -- David I. Lehn <dlehn@debian.org>  Fri,  7 Jan 2005 13:52:27 -0500
+
+gst-plugins0.8 (0.8.6-1) unstable; urgency=low
+
+  * New upstream
+    * Rhythmbox hangs/crashes fixes (Closes: #245757, #277146)
+    * Rhythmbox silence after resume play fixes (Closes: #261841)
+    * Ogg seeking fixes (Closes: #277396)
+  * debian/build-deps.in:
+    * Bump libswfdec to libswfdec0.3-dev
+    * Add libavc1394-dev
+    * Add liboil0.2-dev
+    * Versioned libspeex-dev
+  * debian/gstreamer-misc.install:
+    * Add new plugin: equalizer
+  * debian/watch:
+    * Add watch file
+  * debian/rules:
+    * Update GStreamer core dev dependency to 0.8.4
+  * ext/ladspa/gstladspa.c, debian/patches/ladspa-quiet.patch:
+    * Move patch to debian/patches/
+
+ -- David I. Lehn <dlehn@debian.org>  Mon, 29 Nov 2004 04:02:43 -0500
+
+gst-plugins0.8 (0.8.5-1) unstable; urgency=low
+
+  * New upstream
+  * debian/rules:
+    * Use CDBS simple-patchsys
+    * debian/control: to debian/control:: for newer CDBS
+  * debian/patches/configure-speex.diff:
+    * Fix speex detection
+
+ -- David I. Lehn <dlehn@debian.org>  Wed,  6 Oct 2004 20:15:52 -0400
+
+gst-plugins0.8 (0.8.4-1) unstable; urgency=low
+
+  * New upstream
+  * debian/control.in:
+    * Add -theora package to -plugins package
+  * debian/rules:
+    * Drop upstream ChangeLog from plugin packages due to size
+  * debian/README.Debian:
+    * Add note about ChangeLog
+
+ -- David I. Lehn <dlehn@debian.org>  Thu,  2 Sep 2004 23:03:44 -0400
+
+gst-plugins0.8 (0.8.3-1) unstable; urgency=low
+
+  * New upstream
+  * debian/control.in, debian/build-deps.in, debian/gstreamer-theora.install,
+    debian/rules:
+    * New theora plugin
+  * debian/gstreamer-misc.install:
+    * Add new plugins: alphacolor, decodebin, multifilesink, playbin
+
+ -- David I. Lehn <dlehn@debian.org>  Sat,  7 Aug 2004 09:50:10 -0400
+
+gst-plugins0.8 (0.8.2-3) unstable; urgency=high
+
+  * debian/libgstreamer-gconf.postinst:
+    Remove.  schema install now handled by dh_gconf which moved the schema
+    location causing old hardcoded /etc path to fail.
+    (Closes: #259538, #259119, #259205)
+  * Urgency high: GNOME team wants this in sarge now.
+
+ -- David I. Lehn <dlehn@debian.org>  Fri, 16 Jul 2004 09:17:18 -0400
+
+gst-plugins0.8 (0.8.2-2) unstable; urgency=low
+
+  * debian/rules:
+    * Bump libgstreamer0.8-dev dep up to get fixed shlibs
+  * Rebuild with proper shlibs (Closes: #256181, #256494)
+
+ -- David I. Lehn <dlehn@debian.org>  Wed,  7 Jul 2004 01:16:48 -0400
+
+gst-plugins0.8 (0.8.2-1) unstable; urgency=medium
+
+  * New upstream
+  * debian/build-deps.in:
+    * Add libdts-dev
+  * ext/Makefile.{am,in}:
+    * Fix so dts dir is built
+  * debian/gstreamer-misc.install:
+    * Add DTS plugin
+    * Added alpha, audiorate, dtsdec, multipart, videobox, videomixer, and
+      videorate
+  * debian/rules:
+    * Update libgstreamer0.8-dev build dependency to 0.8.3-2
+  * debian/control.in:
+    * Remove explicit libgstreamer deps, autodetected now
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 23 Jun 2004 23:50:53 -0400
+
+gst-plugins0.8 (0.8.1-4) unstable; urgency=low
+
+  * gst-libs/gst/riff/riff-media.c:
+    * caps type typo fix from CVS
+  * gst-libs/gst/resample/private.h:
+    * disabled ppc code fix from CVS (Closes: #252991)
+  * sys/v4l/gstv4lsrc.c:
+    * caps fix NULL->any from CVS
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 16 Jun 2004 01:24:41 -0400
+
+gst-plugins0.8 (0.8.1-3) unstable; urgency=low
+
+  * rerun autoget.sh to fix arm builds (Closes: #251592)
+  * gconf/gstreamer.schemas.in, gcon/gstreamer-0.8.schemas:
+    s/xvideosink/xvimagesink/ (Closes: #250575) 
+
+ -- David I. Lehn <dlehn@debian.org>  Tue,  1 Jun 2004 10:10:37 -0400
+
+gst-plugins0.8 (0.8.1-2) unstable; urgency=low
+
+  * debian/build-deps.in:
+    * Update "libdv2-dev" to "libdv4-dev | libdv-dev"
+  * debian/control.in, debian/extra, debian/rules:
+    * Remove arts plugin.  Detection, flags, and include directory build code
+      is too buggy for plugin to build at the moment.
+
+ -- David I. Lehn <dlehn@debian.org>  Thu, 29 Apr 2004 18:10:48 -0400
+
+gst-plugins0.8 (0.8.1-1) unstable; urgency=low
+
+  * New upstream
+  * debian/gstreamer-misc.install:
+    * add libgstdebug.so
+
+ -- David I. Lehn <dlehn@debian.org>  Sun, 18 Apr 2004 01:04:36 -0400
+
+gst-plugins0.8 (0.8.0-2) unstable; urgency=low
+
+  * Bump to -2 to ease upgrades for early -1 testers
+  * debian/build-deps.in:
+    * Add libgtk2.0-dev 
+
+ -- David I. Lehn <dlehn@debian.org>  Thu, 15 Apr 2004 17:50:14 -0400
+
+gst-plugins0.8 (0.8.0-1) unstable; urgency=low
+
+  * New upstream (Closes: #234071, #240663)
+  * debian/rules:
+    * Switch to CDBS
+    * Version now at 0.8
+    * Convert various control files to versioned ones for build
+    * Add/rename/remove generated plugins files
+  * debian/control.in:
+    * Update Standards-Version to 3.6.1
+    * Add -caca and -speex plugins
+    * Remove -http plugin
+  * debian/build-deps.in:
+    * Add cdbs
+    * Update debhelper >= 4.1.0
+    * Add caca, speex, and pango deps
+    * Remove libghttp-dev
+  * debian/gstreamer-http.install
+    * Remove
+  * debian/gstreamer-{speex|caca}.install:
+    * Add new plugins
+  * debian/*.install:
+    * Append debian/tmp for CDBS
+    * General cleanups to support versioned files and locations
+  * debian/gstreamer-esd.install:
+    * Remove libgstesdmod
+    * Change libgstesdsink to libgstesd
+  * debian/gstreamer-plugin-libs.install:
+    * Stick locale info in here for lack of a better place
+  * debian/gstreamer-plugin-libs[-dev].install:
+    * Add support for colorbalance, mixer, navigation, propertyprobe, tag,
+      tuner, xoverlay, and xwindowlistener
+    * Add pkgconfig support for plugins, interfaces, and media-info
+  * debian/gstreamer-gnomevfs.install:
+    * s/libgstgnomevfs{src|sink}.so/libgstgnomevfs.so/
+  * debian/gstreamer-colorspace.install:
+    * Rename to gstreamer-hermes.install
+    * Move generic and ffmpeg based colorspace plugins to -misc
+    * Provide gstreamerX.Y-colorspace
+  * debian/gstreamer-misc.install:
+    * v4l/v4l2 support merged to libgstvideo4linux[2].so
+    * Add gdkpixbuf, interleave, nassink, ogg, smoothwave, tagedit,
+      textoverlay, timeoverlay, typefindfunctions, videobalance, videodrop,
+      videofilter, videoflip
+    * Move generic and ffmpeg based colorspace plugins from -hermes
+    * Provide gstreamerX.Y-colorspace
+  * debian/gstreamer-plugin-libs.install:
+    * Rename to libgstreamer-plugins.install
+  * debian/gstreamer-plugin-libs-dev.install:
+    * Rename to libgstreamer-plugins-dev.install
+  * debian/gstreamer-gconf.install:
+    * Rename libgstreamer-gconf.install
+    * Remove dev files
+  * debian/gstreamer-gconf.postinst:
+    * Rename to libgstreamer-gconf.postinst
+  * debian/libgstreamer-gconf-dev.install:
+    * Added
+    * Add dev parts from gstreamer-gconf.install
+  * configure.ac, configure:
+    * Patch from CVS to get arts to detect on Debian boxen
+  * ext/speex/gstspeex{dec,enc}.c:
+    * Upstream patch for static pad templates (caused gst-compprep-0.8 bugs)
+  * ext/ladspa/gstladspa.c:
+    * Change g_warning to DEBUG_OBJ to silence gst-compprep
+  * ext/libcaca/gstcacsink.c:
+    * Upstream patch to avoid cacasink windows with gst-inspect/compprep
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 14 Apr 2004 19:14:14 -0400
+
+gst-plugins0.7 (0.7.6-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 17 Mar 2004 19:06:48 -0500
+
+gst-plugins0.7 (0.7.5-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 17 Mar 2004 18:47:19 -0500
+
+gst-plugins0.7 (0.7.4-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 17 Mar 2004 18:46:27 -0500
+
+gst-plugins0.7 (0.7.3-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 17 Mar 2004 18:42:05 -0500
+
+gst-plugins0.7 (0.7.1-1) unstable; urgency=low
+
+  * New upstream
+    * Versioning package as 0.7
+
+ -- David I. Lehn <dlehn@debian.org>  Wed, 17 Mar 2004 18:31:51 -0500
+
+gst-plugins (0.6.4-4) unstable; urgency=low
+
+  * ext/alsa/gstalsa.h:
+    * Patch to compile with alsa-lib 1.0.x (Closes: #231870)
+
+ -- David I. Lehn <dlehn@debian.org>  Sat, 14 Feb 2004 17:49:01 -0500
+
+gst-plugins (0.6.4-3) unstable; urgency=low
+
+  * debian/build-deps.in:
+    * Update jack dependency to libjack0.80.0-dev (>= 0.94.0)
+      (Closes: #221620, #228784)
+    * Update libmpeg2 dependency to libmpeg2-4-dev (>= 0.4.0b)
+  * ext/mpeg2dec/gstmpeg2dec.c: Patch for libmpeg2 0.4.0b
+
+ -- David I. Lehn <dlehn@debian.org>  Mon, 26 Jan 2004 18:21:45 -0500
+
+gst-plugins (0.6.4-2) unstable; urgency=low
+
+  * debian/rules: Disable ffmpeg for everything but i386 due to PIC issues
+    (Closes: #219284)
+
+ -- David I. Lehn <dlehn@debian.org>  Thu,  6 Nov 2003 16:30:35 -0500
+
+gst-plugins (0.6.4-1) unstable; urgency=low
+
+  * New upstream
+    * ESD updates (Closes: #218736)
+  * Acknowledge NMU (Closes: #217981, #213811)
+  * Rebuild to fix gconf liblinc1 dependency (Closes: #217771)
+  * gstreamer-misc: add v4l2 support (Closes: #199900)
+  * Use pre-Linux-2.6 videodev.h to compile v4l support
+
+ -- David I. Lehn <dlehn@debian.org>  Mon,  3 Nov 2003 15:10:59 -0500
+
+gst-plugins (0.6.3-1.1) unstable; urgency=low
+
+  * NMU - Patch from Jordi Mallach
+  * debian/build-deps.in: libgconf2-dev and libgnomevfs2-dev need GNOME 2.4
+    versions for the liblinc1 transition (closes: #217981).
+  * debian/rules: gstreamer build-dep should be versioned (>= 0.6.3)
+    (closes: #213811).
+
+ -- LaMont Jones <lamont@debian.org>  Thu, 30 Oct 2003 09:12:11 -0700
+
+gst-plugins (0.6.3-1) unstable; urgency=low
+
+  * New upstream
+    * Includes ESD seeking fix (Closes: #201171)
+
+ -- David I. Lehn <dlehn@debian.org>  Mon,  1 Sep 2003 23:15:49 -0400
+
+gst-plugins (0.6.2-2) unstable; urgency=low
+
+  * Fix ffmpeg makefile install rule to work even when ffmpeg build is
+    disabled (Closes: #198148, #199072)
+  * Apply partial patches from running autogen.sh to fix arm builds (excluding
+    other unrelated generated file changes) (Closes: #199872)
+  * Update to support libdvdnav 0.1.9 API
+
+ -- David I. Lehn <dlehn@debian.org>  Fri, 11 Jul 2003 01:01:15 -0400
+
+gst-plugins (0.6.2-1) unstable; urgency=low
+
+  * New upstream
+  * Add dv1394src to gstreamer-dv
+
+ -- David I. Lehn <dlehn@debian.org>  Thu, 12 Jun 2003 11:39:51 -0400
+
+gst-plugins (0.6.1-2) unstable; urgency=low
+
+  * (unreleased)
+  * Adapt to gstreamer package merge: remove -core, -core-libs, -core-libs-dev
+    dependencies as needed.  Fixes missing scheduler bugs.
+    (Closes: #181503, #191720)
+  * Use versioned gst-{register,compprep}-0.6
+  * Update jack dependency to libjack0.71.2-dev (Closes: #195401)
+  * Update libdvdnav dependency to (>= 0.1.7) and revert patch for
+    compatibility with 0.1.3.
+  * Update libdvdread2 dependency to libdvdread3-dev
+  * Remove DISPLAY unset hacks from postinst/postrm scripts and fix non-X
+    installs with 0.6.2 CVS xvideosink patch. (Closes: #165372, #168438)
+  * Link libgstplay to libgstcontrol. (Closes: #194107)
+
+ -- David I. Lehn <dlehn@debian.org>  Thu,  5 Jun 2003 02:29:44 -0400
+
+gst-plugins (0.6.1-1) unstable; urgency=low
+
+  * New upstream
+  * Update maintainer address to @debian.org
+  * gstreamer-gconf libs properly linked upstream (Closes: Bug#187353)
+  * debian/control.in:
+    * gstreamer-vorbis depends on gstreamer-core-libs (Closes: Bug#188606)
+  * Apply gnomevfs patch from http://bugzilla.gnome.org/show_bug.cgi?id=94113
+  * ffmpeg plugin only builds, and now is only packaged, on i386/powerpc (Yes
+    this is bad - better shared lib support needed.) (Closes: Bug#186525)
+  * Revert dvdnav support to libdvdnav 0.1.3 API
+  * Unset DISPLAY before calling gst-register/gst-compprep
+  * ext/ladspa/gstladspa.c:472: s/g_warning/GST_DEBUG/ to avoid printing of a
+    warning on every plugin package install when swh-plugins is installed.
+    (sinCos plugin executes this code path)
+
+ -- David I. Lehn <dlehn@debian.org>  Sat,  3 May 2003 18:30:16 -0400
+
+gst-plugins (0.6.0-4) unstable; urgency=low
+
+  * debian/build-deps.in:
+    * Updated libvorbis-dev to (>= 1.0.0-2) (Closes: Bug#184671)
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 14 Mar 2003 11:12:21 -0500
+
+gst-plugins (0.6.0-3) unstable; urgency=low
+
+  * debian/build-deps.in:
+    * Add libartsc0-dev so artsc-config is present so arts[d] plugins get
+      built so the arts[d] packages actually include the arts[d] plugins
+      (Closes: Bug#181438)
+    * Update JACK dependency to 0.50.0
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri,  7 Mar 2003 23:51:46 -0500
+
+gst-plugins (0.6.0-2) unstable; urgency=low
+
+  * NMU (with maintainer's permission)
+  * Change libarts-dev build-dep to libarts1-dev (Closes: #180537)
+
+ -- David Schleef <ds@schleef.org>  Mon, 10 Feb 2003 21:33:47 -0800
+
+gst-plugins (0.6.0-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@vt.edu>  Sat,  1 Feb 2003 21:51:54 -0500
+
+gst-plugins (0.5.2.3-1) unstable; urgency=low
+
+  * New upstream
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 30 Jan 2003 23:52:08 -0500
+
+gst-plugins (0.5.2.2-1) unstable; urgency=low
+
+  * New upstream
+    * pre-release for 0.6.0
+  * debian/gstreamer-gconf.install:
+    * add gstreamer-gconf-*.pc
+  * debian/gstreamer-misc.install:
+    * remove libgstaviparse.so
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed, 29 Jan 2003 15:07:06 -0500
+
+gst-plugins (0.5.2-1) unstable; urgency=low
+
+  * New upstream
+  * debian/build-deps.in:
+    - Update swfdec dependency to 0.2.0
+  * debian/gstreamer-misc.install:
+    - add libgstaviparse.so
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 23 Jan 2003 22:17:31 -0500
+
+gst-plugins (0.5.1-1) unstable; urgency=low
+
+  * New upstream
+  * Update GStreamer dependency to 0.5.1
+  * Update JACK dependency to 0.44.0
+  * Remove gstreamer-avifile package (avifile not supported on many
+    architectures and upstream is deprecating it in favor of ffmpeg)
+  * Add support for building unsupported plugin packages (avifile, lame, etc)
+  * Tighten shlib deps for gstreamer-plugin-libs and gstreamer-gconf packages
+    (may split off true lib* packages eventually, was trying to avoid even
+    more packages)
+  * gstreamer-misc: add oneton and vbidec
+  * Rebuild for newer sid libs (Closes: Bug#177410)
+  * Various small fixes from CVS
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 20 Jan 2003 11:57:26 -0500
+
+gst-plugins (0.5.0-1) unstable; urgency=low
+
+  * New upstream
+  * Update libpng dependency to libpng12-0-dev
+  * Patch from CVS to support mpeg2dec 0.3.1
+  * Patch from CVS to improve X error handling and remote X usage
+  * gstreamer-plugin-libs[-dev]: add media-info lib
+  * gstreamer-misc: add png plugin
+  * Use swfdec 0.1.3 API: s/swf_init/swfdec_decoder_new/ to avoid symbol
+    conflicts with avifile plugin
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 17 Dec 2002 20:27:42 -0500
+
+gst-plugins (0.4.2-2) unstable; urgency=low
+
+  * Update JACK dependency to 0.40.1
+  * Apply gst-launch-ext perlism patch (Closes: #170736)
+  * Apply patch from Erik Meusel <meusel@codixx.de> to allow building with
+    other KDE arts packages (Closes: Bug#167538)
+  * Update mpeg2dec dependency to 0.3.0, convert over to gstmpeg2deccvs plugin
+    code, and adjust mpeg2dec check
+  * Add Provides: for virtual gstreamer-{audio,video}sink packages to make it
+    easier for applications to ensure output sinks are available.  This isn't
+    foolproof and it's possible that a rare user might not need the standard
+    packaged audio/video sinks.  For now those users can use the "equivs"
+    package to get around the problem. (Closes: Bug#169968)
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed,  4 Dec 2002 02:25:41 -0500
+
+gst-plugins (0.4.2-1.1) unstable; urgency=low
+
+  * NMU
+  * Depend on swfdec-0.1.2-3, since it had a bug.
+
+ -- David Schleef <ds@schleef.org>  Tue, 12 Nov 2002 17:43:48 -0800
+
+gst-plugins (0.4.2-1) unstable; urgency=low
+
+  * New upstream
+  * Add libpng2-dev to Build-Depends for snapshot
+  * Add smpte, snapshot, and wavenc to gstreamer-misc
+  * Add video and play libs to gstreamer-plugin-libs{-dev}
+  * Add gstreamer-swfdec plugin package
+  * Add hack to swfdec plugin to not segfault when avifile also loaded due to
+    symbols conflicts.  This annoyance will spew errors during gst-compprep
+    and probably will cause errors in apps that use both swfdec and avifile.
+  * Tighten dependency on libgstreamer until upstream code can deal with
+    multiple plugin versions and upgrades better
+  * Move gstreamer-plugin-apps to Section: utils from x11
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed,  6 Nov 2002 21:41:01 -0500
+
+gst-plugins (0.4.1-1) unstable; urgency=low
+
+  * New upstream
+  * Update FLAC dependency to 1.0.4 and add support patch from CVS
+  * Rebuild for libflac4 (Closes: Bug#163549)
+  * Build gconf code as a library rather than a plugin
+  * Improved plugin descriptions
+  * Added to -misc: cdplayer, videocrop, videotestsrc, mixmatrix
+  * Add autotools-dev to Build-Depends
+  * Update config.{guess,sub}
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon,  7 Oct 2002 17:51:43 -0400
+
+gst-plugins (0.4.0.2-cvs20020919-1) unstable; urgency=low
+
+  * CVS snapshot, release branch
+  * gstreamer-gconf.files: libgstgconf.so moved to /usr/lib
+  * added control.in, build-deps, and mk.control script.  Edit control.in
+    and/or build-deps, and run 'debian/rules debian/control' from toplevel
+    directory to recreate debian/control.  This should make it a lot
+    easier to diff build dependencies.
+
+ -- David Schleef <ds@schleef.org>  Thu, 19 Sep 2002 15:18:41 -0700
+
+gst-plugins (0.4.0-5) unstable; urgency=low
+
+  * Update Build-Depends
+  * Use pkg-config checking vs m4 macros for libdv
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 23 Aug 2002 10:33:29 -0400
+
+gst-plugins (0.4.0-4) unstable; urgency=low
+
+  * Fixes from CVS for gstgnomevfssrc.c and endian issue in vorbisfile.c
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri,  2 Aug 2002 20:51:38 -0400
+
+gst-plugins (0.4.0-3) unstable; urgency=low
+
+  * Add ladspa-sdk to Build-Depends
+  * Removed qcam plugin from -misc.
+    It's i386 only and probably not widely used.  Will figure out how to
+    package in the future if someone needs it.
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 29 Jul 2002 16:32:33 -0400
+
+gst-plugins (0.4.0-2) unstable; urgency=low
+
+  * Clean up the Build-Depends:
+    - stricter versioning
+    - remove gnome deps (used for examples which are not build now)
+  * Fix segfault in vorbis.m4 check
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 29 Jul 2002 10:47:12 -0400
+
+gst-plugins (0.4.0-1) unstable; urgency=low
+
+  * New upstream
+  * FLAC compile fixes from CVS
+  * DV comiled fixes
+  * Upated ltmain hack
+  * autogen.sh with more recent tools
+  * Update config.{guess,sub}
+  * Added plugin packages: -gconf, -http, -jack, -dv
+  * Added dvdnav plugin to -dvd
+  * Removed osshelper plugin from -oss
+  * Added xvideosink back to -x
+  * Added effectv, filter, and qtdemux plugins to -misc
+  * Rename gstreamer-lib-misc{-dev} to gstreamer-plugin-libs{-dev} to match
+    gstreamer core.
+  * Added gstreamer-plugin-apps package for a lonely 2 scripts
+  * Renamed gstreamer-all to gstreamer-plugins
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 16 Jul 2002 02:10:07 -0400
+
+gst-plugins (0.3.4-2) unstable; urgency=low
+
+  * Rebuild for new avifile
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed, 24 Apr 2002 14:06:46 -0400
+
+gst-plugins (0.3.4-1) unstable; urgency=low
+
+  * New upstream
+  * Fix mpeg2dec.m4 to use newer mpeg2dec libs
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 15 Apr 2002 03:34:21 -0400
+
+gst-plugins (0.3.3-2) unstable; urgency=low
+
+  * Port a52dec plugin to 0.7.3 API (applied upstream)
+  * Use a52dec packages in Debian vs current external ones
+    * This switches a52dec plugin to static linking
+  * Remove LAME support
+    * No LAME packages in Debian to depend on
+    * Added explanation in README.Debian since this will likely
+      cause no end of "Why is there no LAME plugin?"
+  * Depend on and rebuild for mpeg2dec 0.2.1
+  * Depend on and rebuild for glib 2.0
+  * Remove gtk from Build-Depends: (not needed for the built plugins)
+
+ -- David I. Lehn <dlehn@vt.edu>  Sat, 23 Mar 2002 17:52:03 -0500
+
+gst-plugins (0.3.3-1) unstable; urgency=low
+
+  * New upstream version
+  * SDL fixed upstream, remove patch
+  * Require libid3tag for mad support
+  * Remove xvideosink from gstreamer-x package in favor of videosink
+    Needed to be removed due to symbol conflicts with videosink
+  * Sync with upstream changes:
+    * Added videosink to gstreamer-x package
+    * parseau renamed to auparse in -misc
+    * Added various plugins to -misc: goom, monoscope, modplug, ...
+  * Note: new upstream scripts gst-launch-ext and gst-visualise not
+    packaged yet
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 21 Mar 2002 02:06:21 -0500
+
+gst-plugins (0.3.2-3) unstable; urgency=low
+
+  * Rebuild for glib/gtk 1.3.15
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 25 Feb 2002 00:06:51 -0500
+
+gst-plugins (0.3.2-2) unstable; urgency=low
+
+  * Build against liblinc1 and newer gnomevfs
+
+ -- David I. Lehn <dlehn@vt.edu>  Sun, 17 Feb 2002 15:52:57 -0500
+
+gst-plugins (0.3.2-1) unstable; urgency=low
+
+  * New upstream release
+  * Many diffs merged upstream
+  * Unversioned plugins upstream, just packaging .so (no .la, .a)
+  * Added cdxa plugin to -misc
+  * Various plugins in -misc moved around and merged upstream
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 15 Feb 2002 21:54:27 -0500
+
+gst-plugins (0.3.1-4) unstable; urgency=low
+
+  * Rebuild for glib/gtk 1.3.13
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed,  6 Feb 2002 02:16:16 -0500
+
+gst-plugins (0.3.1-3) unstable; urgency=low
+
+  * Fix arts symbol problem (add -lartsflow -lartsflow_idl)
+  * Replace m4/gst-sdl.m4 with Debian's sdl.m4
+  * Use SDL_LIBS_FOR_PLUGINS instead of SDL_LIBS
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed, 23 Jan 2002 12:37:00 -0500
+
+gst-plugins (0.3.1-2) unstable; urgency=low
+
+  * Rebuild against fixed gstreamer.pc in libgst-dev 0.3.1-2
+    Should just link to libxml2 now rather than v1 and v2
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed, 23 Jan 2002 02:29:49 -0500
+
+gst-plugins (0.3.1-1) unstable; urgency=low
+
+  * Upstream split plugins into new package
+  * Upstream removed mpg123 plugin - use mad plugin
+  * Upstream removed ac3dec plugin - use a52dec
+  * Added -lib-misc and -lib-misc-dev packages for
+    library plugins and headers
+  * Patch to link all plugins to GST_LIBS
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 11 Jan 2002 11:22:01 -0500
+
+gstreamer (0.3.0-3) unstable; urgency=low
+
+  * Remove upstream ChangeLog from packages: 128k changelog.gz per
+    plugin package for 40 packages is too much
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 25 Dec 2001 23:36:28 -0500
+
+gstreamer (0.3.0-2) unstable; urgency=low
+
+  * Fix bug that slipped into 0.3.0: s/aasink/xvideosink/ in
+    gstplay/gstplay.c
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 25 Dec 2001 17:56:29 -0500
+
+gstreamer (0.3.0-1) unstable; urgency=low
+
+  * New upstream release
+  * Attempt to update various Build-Depends versions
+  * Added plugin packages: -a52dec, -dvd, -mikmod, -sid
+  * Renamed -elements to -core
+  * Added to -core: gstbasicscheduler
+  * Moved from -common to -core: gsttypes, autoplug related
+  * Renamed -common to -misc
+  * Added to -misc: speed, qcam, bytesteram, control, silence, sinesrc,
+    mpegstream, playondemand, resample
+  * Added gstreamer-guilaunch to gstreamer-tools package
+  * Added dependencies on unofficial LAME packages
+  * Use PIC libs for Xv
+  * Disable broken building of PDF/PS docs
+  * Renamed -all-plugins to -all
+  * Disable docs -- too hard to build
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 21 Dec 2001 12:00:02 -0500
+
+gstreamer (0.2.1-4) unstable; urgency=low
+
+  * Fix some problems reported from lintian 1.20.14:
+    * copyright-lists-upstream-authors-like-dh_make
+    * debian-changelog-file-contains-user-emacs-settings
+  * Patch from CVS to link libgst into plugins
+    Plugins now properly depend on libgst package
+  * Use RedHat Gtk+-1.3 hack to fix relink issues with ltmain.sh
+  * Patch from CVS for xvideosink segfault when no DISPLAY set
+  * Remove builddir references from gstreamer-config.in
+  * Move libgstelements.la from libgst-dev to gstreamer-elements
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 28 Aug 2001 20:05:28 -0400
+
+gstreamer (0.2.1-3) unstable; urgency=low
+
+  * Update build dependencies to FLAC 1.0
+  * Enable debug features
+  * Fixup broken doc build -scan voodoo with link into .libs/ dir
+
+ -- David I. Lehn <dlehn@vt.edu>  Sun,  5 Aug 2001 23:04:28 -0400
+
+gstreamer (0.2.1-2) unstable; urgency=low
+
+  * Fix lib deps: run debhelper tools in the right order
+  * Added arts dir to Makefile.am SUBDIRS so it builds again
+  * Changed libmpeg2dec to libgstmpeg2dec to avoid naming issues
+    when using -lmpeg2dec
+  * Updated system_encode/ with CVS segfaulter bug fix
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 19 Jul 2001 15:47:24 -0400
+
+gstreamer (0.2.1-1) unstable; urgency=low
+
+  * New upstream 0.2.1: "Return of the Sedi Master"
+  * New plugin packages: -festival, -flac, -avifile, -x
+  * New plugins in -common: chart, deinterlace, udp
+  * Added some post-0.2.1 fixes for FLAC, build system, ALSA
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 28 Jun 2001 20:15:15 -0400
+
+gstreamer (0.2.0-6) unstable; urgency=low
+
+  * Move -compprep to -runtime and call it same places as -register
+  * Do -register and -compprep in postrm instead of prerm
+  * Make -arts plugin actually build all the source (sent upstream)
+  * Purge of -runtime removes /etc/gstreamer
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 19 Jun 2001 13:09:32 -0400
+
+gstreamer (0.2.0-5) unstable; urgency=low
+
+  * Added element package dependencies to libgstmediaplay0
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 18 Jun 2001 11:18:53 -0400
+
+gstreamer (0.2.0-4) unstable; urgency=low
+
+  * Add --gst-mask=0 to -runtime.postinst
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 15 Jun 2001 11:47:24 -0400
+
+gstreamer (0.2.0-3) unstable; urgency=low
+
+  * Fix the plugin control file symlink creation
+  * Add audiofile to Build-Depends
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 15 Jun 2001 05:22:28 -0400
+
+gstreamer (0.2.0-2) unstable; urgency=low
+
+  * Fixed ALSA checks to not include -lasound in -every- link
+  * Update LAME plugin to use latest CVS API
+  * Removed OSS src/sink from -common.files (was in -oss too)
+  * Swapped -arts.files and -artsd.files contents
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri, 15 Jun 2001 04:02:21 -0400
+
+gstreamer (0.2.0-1) unstable; urgency=low
+
+  * Added gstreamer-compprep manpage
+  * Upgrade to 0.2.0
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu,  7 Jun 2001 12:53:59 -0400
+
+gstreamer (0.2.0-0.3) unstable; urgency=low
+
+  * GStreamer 0.2.0-pre3
+
+ -- David I. Lehn <dlehn@vt.edu>  Wed,  6 Jun 2001 15:09:59 -0400
+
+gstreamer (0.2.0-0.2) unstable; urgency=low
+
+  * GStreamer 0.2.0-pre2 + CVS 20010604
+  * Added -artsd (vs -arts), -audiofile, -gnomevfs, -gsm, -jpeg,
+    -oss, and -sdl plugin packages
+  * Added osshelper lib to oss package
+  * Added more AVI related plugins and autoplug libs to -common
+  * Added pkgconfig file to libgst-dev
+  * Added gstreamer-all-plugins pseudo package that depends on
+    all other plugin pacakges
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon,  4 Jun 2001 17:33:20 -0400
+
+gstreamer (0.2.0-0.1) unstable; urgency=low
+
+  * GStreamer 0.2.0-pre1
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 31 May 2001 17:16:23 -0400
+
+gstreamer (0.1.1.20010504-1) unstable; urgency=low
+
+  * Latest CVS code
+
+ -- David I. Lehn <dlehn@vt.edu>  Fri,  4 May 2001 21:48:45 -0400
+
+gstreamer (0.1.1.20010430-2) unstable; urgency=low
+
+  * Added -colorspace package for Hermes dependent conversion
+  * Added -arts package for aRts sink
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue,  1 May 2001 19:46:08 -0400
+
+gstreamer (0.1.1.20010430-1) unstable; urgency=low
+
+  * Latest CVS code
+  * Added -aa package for aasink output
+  * Added -mad package for mad mp3 decoder
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 30 Apr 2001 18:25:52 -0400
+
+gstreamer (0.1.1.20010320-1) unstable; urgency=low
+
+  * Latest CVS code
+  * enable main docs
+  * disable broken plugin docs with new option
+
+ -- David I. Lehn <dlehn@vt.edu>  Tue, 20 Mar 2001 18:15:19 -0500
+
+gstreamer (0.1.1.20010315-1) unstable; urgency=low
+
+  * Latest CVS code
+  * Added man pages
+  * Split mpeg2dec to seperate plugin
+  * libgst Architectures updated to cothread supported archs
+
+ -- David I. Lehn <dlehn@vt.edu>  Thu, 15 Mar 2001 20:17:19 -0500
+
+gstreamer (0.1.1-1) unstable; urgency=low
+
+  * New upstream release
+  * disable docs build, broken at the momemnt
+
+ -- David I. Lehn <dlehn@vt.edu>  Sun, 25 Feb 2001 17:58:25 -0500
+
+gstreamer (0.1.0-2) unstable; urgency=low
+
+  * debian/rules: call configure instead of autogen.sh
+
+ -- David I. Lehn <dlehn@vt.edu>  Sat, 24 Feb 2001 18:31:36 -0500
+
+gstreamer (0.1.0-1) unstable; urgency=low
+
+  * Initial Release.
+
+ -- David I. Lehn <dlehn@vt.edu>  Mon, 15 Jan 2001 18:25:18 -0500
diff --git a/debian/compat b/debian/compat
new file mode 100644
index 0000000..ec63514
--- /dev/null
+++ b/debian/compat
@@ -0,0 +1 @@
+9
diff --git a/debian/control b/debian/control
new file mode 100644
index 0000000..ea07cad
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,106 @@
+Source: gst-plugins-good1.0
+Section: libs
+Priority: optional
+Maintainer: Maintainers of GStreamer packages <pkg-gstreamer-maintainers@lists.alioth.debian.org>
+Uploaders: Loic Minier <lool@dooz.org>,
+           Sebastian Dröge <slomo@debian.org>,
+           Sjoerd Simons <sjoerd@debian.org>
+Build-Depends: libgstreamer1.0-dev (>= 1.3.3),  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.3.3), autotools-dev, dh-autoreconf, automake (>= 1.11), autoconf (>= 2.62), 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.32), 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.20), gstreamer1.0-plugins-base (>= 1.3.3), libsoup2.4-dev (>= 2.40), 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
+Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html
+
+Package: gstreamer1.0-plugins-good-doc
+Architecture: all
+Section: doc
+Depends: gstreamer1.0-doc,
+         gstreamer1.0-plugins-base-doc,
+         ${misc:Depends}
+Description: GStreamer documentation for 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 documentation for plugins from the "good" set,
+ a set of good-quality plug-ins under the LGPL license.
+
+Package: gstreamer1.0-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: gstreamer1.0-plugins-good
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         gstreamer1.0-pulseaudio | gstreamer1.0-audiosink,
+         gstreamer1.0-plugins-base,
+Recommends: gstreamer1.0-x
+Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
+Breaks: gstreamer1.0-plugins-bad (<< 1.1.2)
+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: gstreamer1.0-plugins-good-dbg
+Architecture: any
+Multi-Arch: same
+Section: debug
+Priority: extra
+Depends: gstreamer1.0-plugins-good (= ${binary:Version}),
+         gstreamer1.0-pulseaudio (= ${binary:Version}),
+         ${misc:Depends}
+Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
+Breaks: gstreamer1.0-plugins-bad (<< 1.1.2)
+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/control.in b/debian/control.in
new file mode 100644
index 0000000..f45e2da
--- /dev/null
+++ b/debian/control.in
@@ -0,0 +1,106 @@
+Source: gst-plugins-good@GST_ABI@
+Section: libs
+Priority: optional
+Maintainer: Maintainers of GStreamer packages <pkg-gstreamer-maintainers@lists.alioth.debian.org>
+Uploaders: Loic Minier <lool@dooz.org>,
+           Sebastian Dröge <slomo@debian.org>,
+           Sjoerd Simons <sjoerd@debian.org>
+Build-Depends: BUILDDEPS
+Standards-Version: 3.9.3
+Vcs-Git: git://anonscm.debian.org/pkg-gstreamer/gst-plugins-good@GST_ABI@.git
+Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-gstreamer/gst-plugins-good@GST_ABI@.git;a=summary
+Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html
+
+Package: @GST_PKGNAME@-plugins-good-doc
+Architecture: all
+Section: doc
+Depends: gstreamer@GST_ABI@-doc,
+         gstreamer@GST_ABI@-plugins-base-doc,
+         ${misc:Depends}
+Description: GStreamer documentation for 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 documentation for plugins from the "good" set,
+ a set of good-quality plug-ins under the LGPL license.
+
+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.1.2)
+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.1.2)
+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/copyright b/debian/copyright
new file mode 100644
index 0000000..f392e0e
--- /dev/null
+++ b/debian/copyright
@@ -0,0 +1,1801 @@
+This package was debianized by David I. Lehn <dlehn@debian.org> on
+Mon, 15 Jan 2001 18:21:37 -0500.
+
+It was downloaded from http://gstreamer.net/
+
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: Gstreamer Good Plugins 1.0
+Upstream-Contact: gstreamer-devel@lists.freedesktop.org
+Source: http://gstreamer.freedesktop.org
+
+Files: ext/aalib/gstaasink.c
+ ext/aalib/gstaasink.h
+ ext/cairo/gsttimeoverlay.h
+ ext/dv/gstdv.c
+ ext/dv/gstdvdec.c
+ ext/dv/gstdvdec.h
+ ext/dv/gstdvdemux.c
+ ext/dv/gstdvdemux.h
+ ext/flac/gstflac.c
+ ext/flac/gstflacenc.c
+ ext/flac/gstflacenc.h
+ ext/jpeg/gstjpeg.c
+ ext/jpeg/gstjpeg.h
+ ext/jpeg/gstjpegdec.h
+ ext/jpeg/gstjpegenc.c
+ ext/jpeg/gstjpegenc.h
+ ext/libcaca/gstcacasink.c
+ ext/libcaca/gstcacasink.h
+ ext/libpng/gstpngdec.h
+ ext/libpng/gstpngenc.h
+ ext/raw1394/gst1394.c
+ ext/raw1394/gstdv1394src.c
+ ext/raw1394/gstdv1394src.h
+ ext/shout2/gstshout2.h
+ ext/speex/gstspeex.c
+ ext/speex/gstspeexdec.h
+ ext/speex/gstspeexenc.c
+ ext/speex/gstspeexenc.h
+ gst/alpha/gstalphacolor.c
+ gst/avi/avi-ids.h
+ gst/cutter/gstcutter.h
+ gst/debugutils/gstnavigationtest.h
+ gst/debugutils/gstnavseek.h
+ gst/flv/gstmemindex.c
+ gst/flx/flx_color.h
+ gst/flx/flx_fmt.h
+ gst/flx/gstflxdec.h
+ gst/isomp4/qtdemux.h
+ gst/isomp4/qtdemux_fourcc.h
+ gst/isomp4/qtdemux_types.c
+ gst/isomp4/qtpalette.h
+ gst/law/mulaw-decode.c
+ gst/law/mulaw-decode.h
+ gst/law/mulaw-encode.c
+ gst/law/mulaw-encode.h
+ gst/multipart/multipart.c
+ gst/rtp/gstrtp.c
+ gst/rtp/gstrtpgsmdepay.h
+ gst/rtp/gstrtpgsmpay.h
+ gst/smpte/barboxwipes.c
+ gst/smpte/gstmask.c
+ gst/smpte/gstmask.h
+ gst/smpte/gstsmpte.c
+ gst/smpte/gstsmpte.h
+ gst/smpte/gstsmptealpha.h
+ gst/smpte/paint.c
+ gst/smpte/paint.h
+ gst/spectrum/gstspectrum.c
+ gst/udp/gstudp.c
+ gst/udp/gstudp.h
+ gst/udp/gstudpsink.h
+ gst/udp/gstudpsrc.h
+ gst/videobox/gstvideobox.h
+ gst/videofilter/gstvideobalance.h
+ gst/videofilter/gstvideoflip.h
+ gst/y4m/gsty4mencode.h
+ sys/oss/gstossaudio.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: ext/gdk_pixbuf/gstgdkpixbufoverlay.c
+ ext/gdk_pixbuf/gstgdkpixbufoverlay.h
+ ext/gdk_pixbuf/gstgdkpixbufsink.c
+ ext/gdk_pixbuf/gstgdkpixbufsink.h
+ gst/audioparsers/gstdcaparse.c
+ gst/audioparsers/gstdcaparse.h
+ gst/audioparsers/plugin.c
+ gst/isomp4/qtdemux_lang.c
+ gst/isomp4/qtdemux_lang.h
+ gst/videocrop/gstvideocrop.c
+ gst/videocrop/gstvideocrop.h
+ sys/oss4/oss4-audio.c
+ sys/oss4/oss4-audio.h
+ sys/oss4/oss4-mixer-enum.c
+ sys/oss4/oss4-mixer-enum.h
+ sys/oss4/oss4-mixer-slider.c
+ sys/oss4/oss4-mixer-slider.h
+ sys/oss4/oss4-mixer-switch.c
+ sys/oss4/oss4-mixer-switch.h
+ sys/oss4/oss4-mixer.c
+ sys/oss4/oss4-mixer.h
+ sys/oss4/oss4-property-probe.c
+ sys/oss4/oss4-property-probe.h
+ sys/oss4/oss4-sink.c
+ sys/oss4/oss4-sink.h
+ sys/oss4/oss4-source.c
+ sys/oss4/oss4-source.h
+ tests/check/elements/alphacolor.c
+ tests/check/elements/flvdemux.c
+ tests/check/elements/flvmux.c
+ tests/check/elements/gdkpixbufsink.c
+ tests/check/elements/id3demux.c
+ tests/check/elements/id3v2mux.c
+ tests/check/elements/matroskaparse.c
+ tests/check/elements/sunaudio.c
+ tests/check/elements/udpsrc.c
+ tests/check/elements/videocrop.c
+ tests/icles/equalizer-test.c
+ tests/icles/gdkpixbufsink-test.c
+ tests/icles/test-oss4.c
+ tests/icles/videocrop-test.c
+Copyright: 2006, Tim-Philipp Müller <tim centricular net>
+  2006-2008, Tim-Philipp Müller <tim centricular net>
+  2007, Tim-Philipp Müller <tim centricular net>
+  2007-2008, Tim-Philipp Müller <tim centricular net>
+  2008, Tim-Philipp Müller <tim centricular net>
+  2009, Tim-Philipp Müller <tim centricular net>
+  2010, Tim-Philipp Müller <tim centricular net>
+  2011, Tim-Philipp Müller <tim centricular net>
+  2012, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/rtp/gstasteriskh263.c
+ gst/rtp/gstasteriskh263.h
+ gst/rtp/gstrtpL16pay.h
+ gst/rtp/gstrtpac3depay.h
+ gst/rtp/gstrtpamrdepay.c
+ gst/rtp/gstrtpamrdepay.h
+ gst/rtp/gstrtpamrpay.c
+ gst/rtp/gstrtpamrpay.h
+ gst/rtp/gstrtph263depay.h
+ gst/rtp/gstrtph263pay.h
+ gst/rtp/gstrtph263pdepay.c
+ gst/rtp/gstrtph263pdepay.h
+ gst/rtp/gstrtph263ppay.c
+ gst/rtp/gstrtph263ppay.h
+ gst/rtp/gstrtpjpegdepay.h
+ gst/rtp/gstrtpmp2tdepay.c
+ gst/rtp/gstrtpmp4apay.h
+ gst/rtp/gstrtpmp4gdepay.c
+ gst/rtp/gstrtpmp4gdepay.h
+ gst/rtp/gstrtpmp4gpay.h
+ gst/rtp/gstrtpmp4vdepay.c
+ gst/rtp/gstrtpmp4vdepay.h
+ gst/rtp/gstrtpmp4vpay.c
+ gst/rtp/gstrtpmp4vpay.h
+ gst/rtp/gstrtpmpadepay.c
+ gst/rtp/gstrtpmpadepay.h
+ gst/rtp/gstrtpmpapay.c
+ gst/rtp/gstrtpmpapay.h
+ gst/rtp/gstrtpmpvdepay.h
+ gst/rtp/gstrtpsv3vdepay.c
+ gst/rtp/gstrtpsv3vdepay.h
+ gst/rtp/gstrtpvorbispay.h
+Copyright: <2005> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/goom/convolve_fx.c
+ gst/goom/drawmethods.c
+ gst/goom/drawmethods.h
+ gst/goom/filters.c
+ gst/goom/flying_stars_fx.c
+ gst/goom/goom.h
+ gst/goom/goom_config.h
+ gst/goom/goom_config_param.h
+ gst/goom/goom_filters.h
+ gst/goom/goom_fx.h
+ gst/goom/goom_graphic.h
+ gst/goom/goom_plugin_info.h
+ gst/goom/goom_tools.c
+ gst/goom/goom_tools.h
+ gst/goom/goom_typedefs.h
+ gst/goom/graphic.c
+ gst/goom/lines.c
+ gst/goom/lines.h
+ gst/goom/motif_goom1.h
+ gst/goom/motif_goom2.h
+ gst/goom/plugin_info.c
+ gst/goom/sound_tester.c
+ gst/goom/sound_tester.h
+ gst/goom/surf3d.c
+ gst/goom/surf3d.h
+ gst/goom/tentacle3d.c
+ gst/goom/tentacle3d.h
+ gst/goom/v3d.c
+ gst/goom/v3d.h
+Copyright: <2003> iOS-Software
+License: LGPL-2+
+
+Files: gst/audiofx/audiochebband.c
+ gst/audiofx/audiochebband.h
+ gst/audiofx/audiocheblimit.c
+ gst/audiofx/audiocheblimit.h
+ gst/audiofx/audioecho.c
+ gst/audiofx/audioecho.h
+ gst/audiofx/audiofirfilter.c
+ gst/audiofx/audiofirfilter.h
+ gst/audiofx/audiofxbaseiirfilter.c
+ gst/audiofx/audiofxbaseiirfilter.h
+ gst/audiofx/audioiirfilter.c
+ gst/audiofx/audioiirfilter.h
+ gst/deinterlace/tvtime/scalerbob.c
+ gst/flv/gstflvmux.c
+ gst/flv/gstflvmux.h
+ gst/imagefreeze/gstimagefreeze.h
+ gst/matroska/webm-mux.c
+ gst/matroska/webm-mux.h
+ gst/shapewipe/gstshapewipe.c
+ gst/shapewipe/gstshapewipe.h
+ gst/videofilter/plugin.c
+ gst/videomixer/blend.h
+ tests/check/elements/audioecho.c
+ tests/check/elements/imagefreeze.c
+ tests/check/elements/shapewipe.c
+ tests/examples/shapewipe/shapewipe-example.c
+Copyright: 2007-2009, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2008, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2008,2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2008-2009, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2009, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2009-2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/avi/gstavimux.h
+ gst/matroska/ebml-ids.h
+ gst/matroska/ebml-read.c
+ gst/matroska/ebml-read.h
+ gst/matroska/matroska-ids.h
+ gst/matroska/matroska.c
+ sys/oss/gstossmixer.c
+ sys/oss/gstossmixer.h
+ sys/oss/gstossmixertrack.c
+ sys/oss/gstossmixertrack.h
+ sys/v4l2/gstv4l2.c
+ sys/v4l2/gstv4l2bufferpool.c
+ sys/v4l2/gstv4l2bufferpool.h
+ sys/v4l2/gstv4l2colorbalance.c
+ sys/v4l2/gstv4l2colorbalance.h
+ sys/v4l2/gstv4l2object.c
+ sys/v4l2/gstv4l2object.h
+ sys/v4l2/gstv4l2src.c
+ sys/v4l2/gstv4l2src.h
+ sys/v4l2/gstv4l2tuner.c
+ sys/v4l2/gstv4l2tuner.h
+ sys/v4l2/gstv4l2videooverlay.c
+ sys/v4l2/gstv4l2videooverlay.h
+ sys/v4l2/v4l2_calls.c
+ sys/v4l2/v4l2_calls.h
+Copyright: 2001-2002, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2002, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpL16depay.c
+ gst/rtp/gstrtpL16depay.h
+ gst/rtp/gstrtpL16pay.c
+ gst/rtp/gstrtpac3depay.c
+ gst/rtp/gstrtpg722depay.c
+ gst/rtp/gstrtpmp2tpay.c
+ gst/rtp/gstrtpmp2tpay.h
+ gst/rtpmanager/gstrtpbin.c
+ gst/rtpmanager/gstrtpbin.h
+ gst/rtpmanager/gstrtpmanager.c
+ gst/rtpmanager/gstrtpptdemux.h
+ gst/rtpmanager/gstrtpsession.c
+ gst/rtpmanager/gstrtpsession.h
+ gst/rtpmanager/gstrtpssrcdemux.c
+ gst/rtpmanager/gstrtpssrcdemux.h
+ gst/rtpmanager/rtpjitterbuffer.c
+ gst/rtpmanager/rtpjitterbuffer.h
+ gst/rtpmanager/rtpsession.c
+ gst/rtpmanager/rtpsession.h
+ gst/rtpmanager/rtpsource.c
+ gst/rtpmanager/rtpsource.h
+ gst/rtpmanager/rtpstats.c
+ gst/rtpmanager/rtpstats.h
+Copyright: <2007> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/audiofx/audiofxbasefirfilter.c
+ gst/audiofx/audiofxbasefirfilter.h
+ gst/audiofx/audiowsincband.c
+ gst/audiofx/audiowsincband.h
+ gst/audiofx/audiowsinclimit.c
+ gst/audiofx/audiowsinclimit.h
+ gst/flv/gstindex.h
+ gst/interleave/deinterleave.c
+ gst/interleave/deinterleave.h
+ gst/interleave/interleave.c
+ gst/interleave/interleave.h
+ gst/multifile/gstmultifile.c
+ gst/multifile/gstmultifilesink.c
+ gst/multifile/gstmultifilesink.h
+ sys/oss/common.h
+ sys/oss/gstossdmabuffer.h
+ sys/oss/gstosshelper.c
+ sys/oss/gstosshelper.h
+ sys/oss/gstosssink.c
+ sys/oss/gstosssink.h
+ sys/oss/gstosssrc.c
+ sys/oss/gstosssrc.h
+Copyright: 1999-2000, Erik Walthinsen <omega@cse.ogi.edu>
+  1999-2001, Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtph264depay.c
+ gst/rtp/gstrtph264depay.h
+ gst/rtp/gstrtph264pay.h
+ gst/rtp/gstrtpmp1sdepay.h
+ gst/rtp/gstrtpmp2tdepay.h
+ gst/rtp/gstrtpmp4gpay.c
+ gst/rtp/gstrtpmpvdepay.c
+ gst/rtp/gstrtptheoradepay.c
+ gst/rtp/gstrtptheoradepay.h
+ gst/rtp/gstrtptheorapay.c
+ gst/rtp/gstrtptheorapay.h
+ gst/rtp/gstrtpvorbisdepay.c
+ gst/rtp/gstrtpvorbisdepay.h
+ gst/rtp/gstrtpvorbispay.c
+Copyright: <2006> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: ext/annodex/gstannodex.c
+ ext/annodex/gstannodex.h
+ ext/annodex/gstcmmldec.c
+ ext/annodex/gstcmmldec.h
+ ext/annodex/gstcmmlenc.c
+ ext/annodex/gstcmmlenc.h
+ ext/annodex/gstcmmlparser.c
+ ext/annodex/gstcmmlparser.h
+ ext/annodex/gstcmmltag.c
+ ext/annodex/gstcmmltag.h
+ ext/annodex/gstcmmlutils.c
+ ext/annodex/gstcmmlutils.h
+ tests/check/elements/cmmldec.c
+ tests/check/elements/cmmlenc.c
+Copyright: 2005, Alessandro Decina
+License: LGPL-2+
+
+Files: ext/pulse/plugin.c
+ ext/pulse/pulsemixer.c
+ ext/pulse/pulsemixer.h
+ ext/pulse/pulsemixerctrl.c
+ ext/pulse/pulsemixerctrl.h
+ ext/pulse/pulsemixertrack.c
+ ext/pulse/pulsemixertrack.h
+ ext/pulse/pulseprobe.c
+ ext/pulse/pulseprobe.h
+ ext/pulse/pulsesink.h
+ ext/pulse/pulsesrc.c
+ ext/pulse/pulsesrc.h
+ ext/pulse/pulseutil.c
+ ext/pulse/pulseutil.h
+Copyright: 2004-2008, Lennart Poettering
+License: LGPL-2.1+
+
+Files: gst/rtp/gstrtpac3pay.c
+ gst/rtp/gstrtpac3pay.h
+ gst/rtp/gstrtpg722depay.h
+ gst/rtp/gstrtpg722pay.c
+ gst/rtp/gstrtpg722pay.h
+ gst/rtp/gstrtpg723depay.c
+ gst/rtp/gstrtpg723depay.h
+ gst/rtp/gstrtpgstdepay.c
+ gst/rtp/gstrtpgstdepay.h
+ gst/rtp/gstrtpgstpay.c
+ gst/rtp/gstrtpgstpay.h
+ gst/rtp/gstrtpqcelpdepay.c
+ gst/rtp/gstrtpqcelpdepay.h
+Copyright: <2010> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: ext/wavpack/gstwavpackenc.c
+ ext/wavpack/gstwavpackenc.h
+ ext/wavpack/gstwavpackstreamreader.c
+ ext/wavpack/gstwavpackstreamreader.h
+ gst/audiofx/audiodynamic.c
+ gst/audiofx/audiodynamic.h
+ gst/audiofx/math_compat.h
+ tests/check/elements/deinterleave.c
+ tests/check/elements/wavpackdec.c
+ tests/check/elements/wavpackenc.c
+ tests/check/elements/wavpackparse.c
+ tests/check/pipelines/wavpack.c
+Copyright: 2006, Sebastian Dröge <slomo@circular-chaos.org>
+  2007, Sebastian Dröge <slomo@circular-chaos.org>
+  2008, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpbvdepay.c
+ gst/rtp/gstrtpbvdepay.h
+ gst/rtp/gstrtpbvpay.c
+ gst/rtp/gstrtpbvpay.h
+ gst/rtp/gstrtpceltdepay.c
+ gst/rtp/gstrtpceltdepay.h
+ gst/rtp/gstrtpceltpay.c
+ gst/rtp/gstrtpceltpay.h
+ gst/rtp/gstrtpj2kdepay.c
+ gst/rtp/gstrtpj2kdepay.h
+ tests/check/elements/rtpbin.c
+Copyright: <2009> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: sys/sunaudio/gstsunaudio.c
+ sys/sunaudio/gstsunaudiomixer.c
+ sys/sunaudio/gstsunaudiomixer.h
+ sys/sunaudio/gstsunaudiomixerctrl.c
+ sys/sunaudio/gstsunaudiomixerctrl.h
+ sys/sunaudio/gstsunaudiomixeroptions.c
+ sys/sunaudio/gstsunaudiomixeroptions.h
+ sys/sunaudio/gstsunaudiomixertrack.c
+ sys/sunaudio/gstsunaudiomixertrack.h
+ sys/sunaudio/gstsunaudiosrc.c
+ sys/sunaudio/gstsunaudiosrc.h
+Copyright: 2005,2008-2009, Sun Microsystems, Inc.
+  2005-2006, Sun Microsystems, Inc.
+  2005-2006,2008-2009, Sun Microsystems, Inc.
+  2005-2006,2009, Sun Microsystems, Inc.
+  2008, Sun Microsystems, Inc.
+  2009, Sun Microsystems, Inc.
+License: LGPL-2+
+
+Files: gst/replaygain/gstrganalysis.c
+ gst/replaygain/gstrganalysis.h
+ gst/replaygain/gstrglimiter.c
+ gst/replaygain/gstrglimiter.h
+ gst/replaygain/gstrgvolume.c
+ gst/replaygain/gstrgvolume.h
+ gst/replaygain/replaygain.c
+ gst/replaygain/replaygain.h
+ tests/check/elements/rganalysis.c
+ tests/check/elements/rglimiter.c
+ tests/check/elements/rgvolume.c
+Copyright: 2006, Rene Stadler <mail@renestadler.de>
+  2007, Rene Stadler <mail@renestadler.de>
+License: LGPL-2.1+
+
+Files: gst/rtp/gstrtpchannels.c
+ gst/rtp/gstrtpchannels.h
+ gst/rtp/gstrtpjpegdepay.c
+ gst/rtp/gstrtpmp1sdepay.c
+ gst/rtp/gstrtpmp4apay.c
+ gst/rtp/gstrtpvrawdepay.c
+ gst/rtp/gstrtpvrawdepay.h
+ gst/rtp/gstrtpvrawpay.c
+ gst/rtp/gstrtpvrawpay.h
+ gst/smpte/gstsmptealpha.c
+Copyright: <2008> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/audioparsers/gstaacparse.c
+ gst/audioparsers/gstaacparse.h
+ tests/check/elements/aacparse.c
+ tests/check/elements/ac3parse.c
+ tests/check/elements/amrparse.c
+ tests/check/elements/flacparse.c
+ tests/check/elements/mpegaudioparse.c
+ tests/check/elements/parser.c
+ tests/check/elements/parser.h
+Copyright: 2008, Nokia Corporation.
+  2010, Nokia Corporation.
+License: LGPL-2+
+
+Files: ext/jack/gstjack.c
+ ext/jack/gstjack.h
+ ext/jack/gstjackaudioclient.c
+ ext/jack/gstjackaudioclient.h
+ ext/jack/gstjackaudiosink.c
+ ext/jack/gstjackaudiosink.h
+ gst/alpha/gstalphacolor.h
+ gst/multipart/multipartmux.c
+ gst/multipart/multipartmux.h
+ gst/rtp/gstrtpg729depay.c
+ gst/rtp/gstrtpg729depay.h
+ gst/rtp/gstrtph264pay.c
+ gst/rtp/gstrtpsirendepay.c
+ gst/rtp/gstrtpsirendepay.h
+ gst/rtp/gstrtpsirenpay.c
+ gst/rtp/gstrtpsirenpay.h
+ sys/ximage/gstximagesrc.h
+Copyright: 2004, Wim Taymans <wim@fluendo.com>
+  2005, Wim Taymans <wim@fluendo.com>
+  2006, Wim Taymans <wim@fluendo.com>
+License: LGPL-2+
+
+Files: gst/effectv/gsteffectv.c
+ gst/effectv/gsteffectv.h
+ gst/effectv/gstrev.c
+ gst/effectv/gstrev.h
+ gst/effectv/gstshagadelic.c
+ gst/effectv/gstshagadelic.h
+ gst/effectv/gstvertigo.c
+ gst/effectv/gstvertigo.h
+Copyright: 2001, FUKUCHI Kentarou
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtppcmadepay.h
+ gst/rtp/gstrtppcmapay.h
+ gst/rtp/gstrtppcmudepay.h
+ gst/rtp/gstrtppcmupay.h
+ gst/rtp/gstrtpspeexdepay.c
+ gst/rtp/gstrtpspeexdepay.h
+ gst/rtp/gstrtpspeexpay.c
+ gst/rtp/gstrtpspeexpay.h
+Copyright: <2005> Edgard Lima <edgard.lima@indt.org.br>
+License: LGPL-2+
+
+Files: gst/audiofx/audioamplify.c
+ gst/audiofx/audioamplify.h
+ gst/audiofx/audioinvert.c
+ gst/audiofx/audioinvert.h
+ gst/audiofx/audiopanorama.c
+ tests/check/elements/audioamplify.c
+ tests/check/elements/audiodynamic.c
+ tests/check/elements/audioinvert.c
+Copyright: 2006, Sebastian Dröge <slomo@circular-chaos.org>
+  2006, Stefan Kost <ensonic@users.sf.net>
+  2007, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: gst/audiofx/audiokaraoke.c
+ gst/audiofx/audiokaraoke.h
+ gst/rtp/gstrtpj2kpay.c
+ gst/rtp/gstrtpj2kpay.h
+ tests/examples/rtp/client-PCMA.c
+ tests/examples/rtp/server-alsasrc-PCMA.c
+ tests/icles/videobox-test.c
+ tests/icles/videocrop2-test.c
+Copyright: 2008, Wim Taymans <wim.taymans@gmail.com>
+  2009, Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/audiofx/audiofx.c
+ gst/audiofx/audiopanorama.h
+ gst/debugutils/gsttaginject.c
+ gst/debugutils/gsttaginject.h
+ tests/check/elements/audiopanorama.c
+ tests/examples/spectrum/demo-audiotest.c
+ tests/examples/spectrum/demo-osssrc.c
+Copyright: 2006, Stefan Kost <ensonic@users.sf.net>
+  2008, Stefan Kost <ensonic@users.sf.net>
+License: LGPL-2+
+
+Files: gst/effectv/gstop.c
+ gst/effectv/gstop.h
+ gst/effectv/gstripple.c
+ gst/effectv/gstripple.h
+ gst/effectv/gststreak.c
+ gst/effectv/gststreak.h
+Copyright: 2001-2002, FUKUCHI Kentaro
+  2001-2006, FUKUCHI Kentaro
+  2004-2005, FUKUCHI Kentaro
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: sys/osxaudio/gstosxaudioelement.c
+ sys/osxaudio/gstosxaudioelement.h
+ sys/osxaudio/gstosxaudiosink.c
+ sys/osxaudio/gstosxaudiosink.h
+ sys/osxaudio/gstosxaudiosrc.c
+ sys/osxaudio/gstosxringbuffer.c
+Copyright: 2005-2006, Zaheer Abbas Merali <zaheerabbas at merali dot org>
+  2006, Zaheer Abbas Merali <zaheerabbas at merali dot org>
+  2007, Pioneers of the Inevitable <songbird@songbirdnest.com>
+  2007-2008, Pioneers of the Inevitable <songbird@songbirdnest.com>
+  2008, Pioneers of the Inevitable <songbird@songbirdnest.com>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: ext/cairo/gsttextoverlay.c
+ ext/cairo/gsttimeoverlay.c
+ gst/debugutils/gstnavigationtest.c
+ gst/debugutils/gstnavseek.c
+ gst/videofilter/gstvideotemplate.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: gst/goom/config_param.c
+ gst/goom/goom_core.c
+ gst/goom/goom_visual_fx.h
+ gst/goom/mathtools.c
+ gst/goom/mathtools.h
+Copyright: <2003> Jean-Christophe Hoelt <jeko@free.fr>
+License: LGPL-2+
+
+Files: gst/equalizer/gstiirequalizer10bands.c
+ gst/equalizer/gstiirequalizer10bands.h
+ gst/equalizer/gstiirequalizer3bands.c
+ gst/equalizer/gstiirequalizer3bands.h
+ tests/check/elements/spectrum.c
+Copyright: <2007> Stefan Kost <ensonic@users.sf.net>
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/greedyh.c
+ gst/deinterlace/tvtime/linear.c
+ gst/deinterlace/tvtime/linearblend.c
+ gst/deinterlace/tvtime/plugins.h
+ gst/deinterlace/tvtime/tomsmocomp.c
+Copyright: 2002, Billy Biggs <vektor@dumbterm.net>
+  2004, Billy Biggs <vektor@dumbterm.net>
+  2008, Sebastian Dröge <slomo@collabora.co.uk>
+  2008,2010, Sebastian Dröge <slomo@collabora.co.uk>
+License: LGPL-2+
+
+Files: ext/dv/gstsmptetimecode.c
+ ext/dv/gstsmptetimecode.h
+ gst/multifile/gstmultifilesrc.c
+ gst/multifile/gstmultifilesrc.h
+ tests/check/elements/multifile.c
+Copyright: 2006, David A. Schleef <ds@schleef.org>
+  2007, David A. Schleef <ds@schleef.org>
+  2009, David A. Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: tests/check/elements/audiochebband.c
+ tests/check/elements/audiocheblimit.c
+ tests/check/elements/audiowsincband.c
+ tests/check/elements/audiowsinclimit.c
+ tests/check/elements/equalizer.c
+Copyright: 2007, Sebastian Dröge <slomo@circular-chaos.org>
+  2008, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2.1+
+
+Files: gst/effectv/gstedge.c
+ gst/effectv/gstedge.h
+ gst/effectv/gstquark.c
+ gst/effectv/gstquark.h
+Copyright: 2001-2002, FUKUCHI Kentarou
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/equalizer/gstiirequalizer.c
+ gst/equalizer/gstiirequalizer.h
+ gst/equalizer/gstiirequalizernbands.c
+ gst/equalizer/gstiirequalizernbands.h
+Copyright: <2004> Benjamin Otte <otte@gnome.org>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpilbcdepay.c
+ gst/rtp/gstrtpilbcdepay.h
+ gst/rtp/gstrtpilbcpay.c
+ gst/rtp/gstrtpilbcpay.h
+Copyright: <2006> Philippe Khalaf <burger@speedy.org>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpg723pay.c
+ gst/rtp/gstrtpg723pay.h
+ gst/rtp/gstrtpg729pay.c
+ gst/rtp/gstrtpg729pay.h
+Copyright: <2007> Collabora Ltd
+  <2007> Nokia Corporation
+License: LGPL-2+
+
+Files: gst/debugutils/breakmydata.c
+ gst/debugutils/gstdebug.c
+ gst/debugutils/testplugin.c
+ gst/debugutils/tests.h
+Copyright: 2004, Benjamin Otte <otte@gnome.org>
+License: LGPL-2+
+
+Files: gst/icydemux/gsticydemux.c
+ gst/icydemux/gsticydemux.h
+ gst/id3demux/gstid3demux.c
+ gst/id3demux/gstid3demux.h
+Copyright: 2003-2004, Benjamin Otte <otte@gnome.org>
+  2005, Jan Schmidt <thaytan@mad.scientist.com>
+License: LGPL-2+
+
+Files: gst/autodetect/gstautoaudiosink.h
+ gst/autodetect/gstautodetect.c
+ gst/autodetect/gstautodetect.h
+ gst/autodetect/gstautovideosink.h
+Copyright: 2005, Ronald S. Bultje <rbultje@ronald.bitfreak.net>
+License: LGPL-2+
+
+Files: gst/isomp4/fourcc.h
+ gst/rtsp/gstrtsp.c
+ gst/rtsp/gstrtsp.h
+ gst/rtsp/gstrtspsrc.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/atomsrecovery.c
+ gst/isomp4/atomsrecovery.h
+ gst/isomp4/gstqtmoovrecover.c
+ gst/isomp4/gstqtmoovrecover.h
+Copyright: 2010, Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/descriptors.c
+ gst/isomp4/descriptors.h
+ gst/isomp4/properties.c
+ gst/isomp4/properties.h
+Copyright: 2008, Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: common/coverage/coverage-report-entry.pl
+ common/coverage/coverage-report.pl
+ common/coverage/coverage-report.xsl
+Copyright: 2006, Daniel Berrange
+License: GPL-2+
+
+Files: gst/avi/gstavi.c
+ gst/flx/flx_color.c
+ gst/flx/gstflxdec.c
+Copyright: <1999> Erik Walthinsen <omega@temple-baptist.com>
+License: LGPL-2+
+
+Files: tests/check/elements/avimux.c
+ tests/check/elements/videofilter.c
+ tests/check/elements/y4menc.c
+Copyright: <2006> Mark Nauwelaerts <manauw@skynet.be>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpmpvpay.c
+ gst/rtp/gstrtpmpvpay.h
+ tests/check/elements/avisubtitle.c
+Copyright: <2007> Thijs Vermeir <thijsvermeir@gmail.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpjpegpay.c
+ gst/rtp/gstrtpjpegpay.h
+ tests/check/elements/udpsink.c
+Copyright: 2008, Axis Communications <dev-gstreamer@axis.com>
+  2009, Axis Communications <dev-gstreamer@axis.com>
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/weave.c
+ gst/deinterlace/tvtime/weavebff.c
+ gst/deinterlace/tvtime/weavetff.c
+Copyright: 2002, Billy Biggs <vektor@dumbterm.net>
+  2003, Billy Biggs <vektor@dumbterm.net>
+  2008,2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: ext/taglib/gstapev2mux.cc
+ ext/taglib/gstapev2mux.h
+ ext/taglib/gsttaglibplugin.c
+Copyright: 2006, Christophe Fergeau <teuf@gnome.org>
+  2006, Sebastian Dröge <slomo@circular-chaos.org>
+  2006, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/matroska/matroska-demux.h
+ gst/matroska/matroska-parse.h
+ gst/matroska/matroska-read-common.h
+Copyright: 2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2011, Debarshi Ray <rishi@gnu.org>
+License: LGPL-2+
+
+Files: gst/matroska/matroska-demux.c
+ gst/matroska/matroska-parse.c
+ gst/matroska/matroska-read-common.c
+Copyright: 2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2006, Tim-Philipp Müller <tim centricular net>
+  2008, Sebastian Dröge <slomo@circular-chaos.org>
+  2011, Debarshi Ray <rishi@gnu.org>
+License: LGPL-2+
+
+Files: gst/matroska/ebml-write.c
+ gst/matroska/ebml-write.h
+ gst/matroska/matroska-mux.h
+Copyright: 2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2005, Michal Benes <michal.benes@xeris.cz>
+License: LGPL-2+
+
+Files: gst/apetag/gstapedemux.c
+ gst/apetag/gstapedemux.h
+ gst/matroska/matroska-ids.c
+Copyright: 2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2004, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2006, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/videomixer/videomixer2.c
+ gst/videomixer/videomixer2.h
+ gst/videomixer/videomixer2pad.h
+Copyright: 2004, 2008 Wim Taymans <wim@fluendo.com>
+  2008, Wim Taymans <wim@fluendo.com>
+  2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: sys/waveform/gstwaveformplugin.c
+ sys/waveform/gstwaveformsink.c
+ sys/waveform/gstwaveformsink.h
+Copyright: 2005, Sebastien Moutte <sebastien@moutte.net>
+License: LGPL-2+
+
+Files: gst/videocrop/gstaspectratiocrop.c
+ gst/videocrop/gstaspectratiocrop.h
+ tests/check/elements/aspectratiocrop.c
+Copyright: 2009, Thijs Vermeir <thijsvermeir@gmail.com>
+License: LGPL-2+
+
+Files: gst/rtp/fnv1hash.c
+ gst/rtp/fnv1hash.h
+ tests/check/pipelines/flacdec.c
+Copyright: 2007, Thomas Vander Stichele <thomas at apestaart dot org>
+  2009, Thomas Vander Stichele <thomas at apestaart dot org>
+License: LGPL-2+
+
+Files: ext/soup/gstsoup.c
+ ext/soup/gstsouphttpsrc.c
+ ext/soup/gstsouphttpsrc.h
+Copyright: 2007-2008, Wouter Cloetens <wouter@mind.be>
+License: LGPL-2+
+
+Files: gst/isomp4/gstqtmux-doc.c
+ gst/isomp4/gstqtmux-doc.h
+ gst/isomp4/gstqtmux.c
+Copyright: 2008, Mark Nauwelaerts <mnauw@users.sf.net>
+  2008-2010, Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+  2010, Nokia Corporation.
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/effectv/gstradioac.c
+ gst/effectv/gstradioac.h
+Copyright: 2001-2002, FUKUCHI Kentaro
+  2001-2006, FUKUCHI Kentaro
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL
+
+Files: gst/rtp/gstrtpmp4adepay.c
+ gst/rtp/gstrtpmp4adepay.h
+Copyright: <2007> Nokia Corporation (contact <stefan.kost@nokia.com>)
+License: LGPL-2
+
+Files: gst/cutter/gstcutter.c
+ gst/level/gstlevel.c
+Copyright: 2000-2003,2005,
+  2002-2003,2005,
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: gst/debugutils/progressreport.c
+ gst/debugutils/progressreport.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+  <2004> Jan Schmidt <thaytan@mad.scientist.com>
+  <2006> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/effectv/gstaging.c
+ gst/effectv/gstaging.h
+Copyright: 2001-2002, FUKUCHI Kentarou
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/effectv/gstwarp.c
+ gst/effectv/gstwarp.h
+Copyright: 2001, FUKUCHI Kentarou
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: ext/gdk_pixbuf/pixbufscale.c
+ ext/gdk_pixbuf/pixbufscale.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2004> Jan Schmidt <thaytan@mad.scientist.com>
+  <2004> Tim-Philipp Mueller <t.i.m@orange.net>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtppcmapay.c
+ gst/rtp/gstrtppcmupay.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2005> Edgard Lima <edgard.lima@indt.org.br>
+  <2005> Nokia Corporation <kai.vehmanen@nokia.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtppcmadepay.c
+ gst/rtp/gstrtppcmudepay.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2005> Edgard Lima <edgard.lima@indt.org.br>
+  <2005> Zeeshan Ali <zeenix@gmail.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpgsmdepay.c
+ gst/rtp/gstrtpgsmpay.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2005> Zeeshan Ali <zeenix@gmail.com>
+License: LGPL-2+
+
+Files: gst/wavparse/gstwavparse.c
+ gst/wavparse/gstwavparse.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006> Nokia Corporation, Stefan Kost <stefan.kost@nokia.com>
+License: LGPL-2+
+
+Files: gst/auparse/gstauparse.c
+ gst/auparse/gstauparse.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/alpha/gstalpha.c
+ gst/alpha/gstalpha.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2007> Edward Hervey <edward.hervey@collabora.co.uk>
+  <2007> Jan Schmidt <thaytan@noraisin.net>
+  <2007> Wim Taymans <wim.taymans@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/isomp4/qtdemux_dump.h
+ gst/isomp4/qtdemux_types.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> STEricsson <benjamin.gaignard@stericsson.com>
+License: LGPL-2+
+
+Files: gst/effectv/gstdice.c
+ gst/effectv/gstdice.h
+Copyright: 2001, Sam Mertens. This code is subject to the provisions of
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/goom/gstgoom.h
+ gst/goom2k1/gstgoom.h
+Copyright: <2001> Richard Boulton <richard@tartarus.org>
+License: LGPL-2+
+
+Files: gst/monoscope/gstmonoscope.c
+ gst/monoscope/gstmonoscope.h
+Copyright: <2002> Richard Boulton <richard@tartarus.org>
+  <2006> Tim-Philipp Müller <tim centricular net>
+  <2006> Wim Taymans <wim at fluendo dot com>
+License: LGPL-2+
+
+Files: gst/goom/ppc_drawings.h
+ gst/goom/ppc_zoom_ultimate.h
+Copyright: <2003> Guillaume Borios, iOS-Software
+License: LGPL-2+
+
+Files: sys/ximage/ximageutil.c
+ sys/ximage/ximageutil.h
+Copyright: <2005> Luca Ognibene <luogni@tin.it>
+License: LGPL-2+
+
+Files: tests/check/elements/level.c
+ tests/check/generic/states.c
+Copyright: <2005> Thomas Vander Stichele <thomas at apestaart dot org>
+License: LGPL-2+
+
+Files: gst/isomp4/gstrtpxqtdepay.h
+ gst/udp/gstmultiudpsink.h
+Copyright: <2005> Wim Taymans <wim@fluendo.com>
+License: LGPL-2+
+
+Files: gst/flv/gstflvdemux.c
+ gst/flv/gstflvdemux.h
+Copyright: <2007> Julien Moutte <julien@moutte.net>
+License: LGPL-2+
+
+Files: gst/debugutils/gstpushfilesrc.c
+ gst/debugutils/gstpushfilesrc.h
+Copyright: <2007> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: ext/raw1394/gsthdv1394src.c
+ ext/raw1394/gsthdv1394src.h
+Copyright: <2008> Edward Hervey <bilboed@bilboed.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpqdmdepay.c
+ gst/rtp/gstrtpqdmdepay.h
+Copyright: <2009> Edward Hervey <bilboed@bilboed.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpmparobustdepay.c
+ gst/rtp/gstrtpmparobustdepay.h
+Copyright: <2010> Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
+  <2010> Nokia Corporation
+License: LGPL-2+
+
+Files: gst/debugutils/cpureport.c
+ gst/debugutils/cpureport.h
+Copyright: <2010> Zaheer Abbas Merali <zaheerabbas merali org>
+License: LGPL-2+
+
+Files: ext/cairo/gstcairooverlay.c
+ ext/cairo/gstcairooverlay.h
+Copyright: <2011> Jon Nordby <jononor@gmail.com>
+License: LGPL-2+
+
+Files: gst/law/alaw-decode.h
+ gst/law/alaw-encode.h
+Copyright: 2000, Abramo Bagnara <abramo@alsa-project.org>
+License: LGPL-2+
+
+Files: sys/v4l2/gstv4l2radio.c
+ sys/v4l2/gstv4l2radio.h
+Copyright: 2010-2011, Alexey Chernov <4ernov@gmail.com>
+License: LGPL-2+
+
+Files: sys/oss/gstossmixerelement.c
+ sys/oss/gstossmixerelement.h
+Copyright: 2005, Andrew Vander Wingo <wingo@pobox.com>
+License: LGPL-2+
+
+Files: gst/interleave/plugin.c
+ gst/interleave/plugin.h
+Copyright: 2004,2007, Andy Wingo <wingo at pobox.com>
+License: LGPL-2+
+
+Files: ext/wavpack/gstwavpackcommon.h
+ ext/wavpack/gstwavpackdec.h
+Copyright: 2004, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2005, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2006, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: ext/flac/gstflactag.c
+ ext/flac/gstflactag.h
+Copyright: 2003, Christophe Fergeau <teuf@gnome.org>
+  2008, Jonathan Matthew <jonathan@d14n.org>
+  2008, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: ext/taglib/gstid3v2mux.cc
+ ext/taglib/gstid3v2mux.h
+Copyright: 2006, Christophe Fergeau <teuf@gnome.org>
+  2006, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/rtpmanager/gstrtpjitterbuffer.c
+ gst/rtpmanager/gstrtpjitterbuffer.h
+Copyright: 2007, Collabora Ltd
+  2007, Nokia Corporation
+  2007, Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/multifile/gstsplitfilesrc.c
+ gst/multifile/gstsplitfilesrc.h
+Copyright: 2011, Collabora Ltd. <tim.muller@collabora.co.uk>
+License: LGPL-2+
+
+Files: ext/gdk_pixbuf/gstgdkpixbuf.c
+ ext/gdk_pixbuf/gstgdkpixbuf.h
+Copyright: 1999-2001, Erik Walthinsen <omega@cse.ogi.edu>
+  2003, David A. Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: sys/sunaudio/gstsunaudiosink.c
+ sys/sunaudio/gstsunaudiosink.h
+Copyright: 2004, David A. Schleef <ds@schleef.org>
+  2005-2006, Sun Microsystems, Inc.
+  2006, Jan Schmidt <thaytan@mad.scientist.com>
+License: LGPL-2+
+
+Files: ext/soup/gstsouphttpclientsink.c
+ ext/soup/gstsouphttpclientsink.h
+Copyright: 2011, David Schleef <ds@entropywave.com>
+License: LGPL-2+
+
+Files: ext/raw1394/gst1394clock.c
+ ext/raw1394/gst1394clock.h
+Copyright: 1999-2000, Erik Walthinsen <omega@cse.ogi.edu>
+  2009, David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: sys/v4l2/gstv4l2vidorient.c
+ sys/v4l2/gstv4l2vidorient.h
+Copyright: 2006, Edgard Lima <edgard.lima@indt.org.br>
+License: LGPL-2+
+
+Files: sys/directsound/gstdirectsoundsink.c
+ sys/directsound/gstdirectsoundsink.h
+Copyright: 2005, Sebastien Moutte <sebastien@moutte.net>
+  2007, Pioneers of the Inevitable <songbird@songbirdnest.com>
+  2010, Fluendo S.A. <support@fluendo.com>
+License: LGPL-2+
+
+Files: gst/audioparsers/gstmpegaudioparse.c
+ gst/audioparsers/gstmpegaudioparse.h
+Copyright: 2006-2007, Jan Schmidt <thaytan@mad.scientist.com>
+  2010, Mark Nauwelaerts <mnauw users sf net>
+  2010, Nokia Corporation.
+License: LGPL-2+
+
+Files: gst/autodetect/gstautoaudiosink.c
+ gst/autodetect/gstautovideosink.c
+Copyright: 2005, Ronald S. Bultje <rbultje@ronald.bitfreak.net>
+  2006, Jan Schmidt <thaytan@noraisin.net>
+License: LGPL-2+
+
+Files: gst/autodetect/gstautoaudiosrc.c
+ gst/autodetect/gstautovideosrc.c
+Copyright: 2005, Ronald S. Bultje <rbultje@ronald.bitfreak.net>
+  2006, Jan Schmidt <thaytan@noraisin.net>
+  2008, Stefan Kost <ensonic@users.sf.net>
+License: LGPL-2+
+
+Files: ext/raw1394/gst1394probe.c
+ ext/raw1394/gst1394probe.h
+Copyright: 2007, Julien Puydt <jpuydt@free.fr>
+License: LGPL-2+
+
+Files: ext/cairo/gstcairorender.c
+ ext/cairo/gstcairorender.h
+Copyright: 2006-2009, Lutz Mueller <lutz@topfrose.de>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpdvdepay.h
+ gst/rtp/gstrtpdvpay.h
+Copyright: 2006, Marcel Moreaux <marcelm@spacelabs.nl>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpdvdepay.c
+ gst/rtp/gstrtpdvpay.c
+Copyright: 2006, Marcel Moreaux <marcelm@spacelabs.nl>
+  2008, Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/audioparsers/gstwavpackparse.c
+ gst/audioparsers/gstwavpackparse.h
+Copyright: 2012, Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
+  2012, Nokia Corporation.
+License: LGPL-2+
+
+Files: gst/audioparsers/gstflacparse.c
+ gst/audioparsers/gstflacparse.h
+Copyright: 2008, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2009, Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
+  2009, Nokia Corporation.
+License: LGPL-2+
+
+Files: gst/audioparsers/gstac3parse.c
+ gst/audioparsers/gstac3parse.h
+Copyright: 2009, Mark Nauwelaerts <mnauw users sf net>
+  2009, Nokia Corporation.
+  2009, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/debugutils/gstcapssetter.c
+ gst/debugutils/gstcapssetter.h
+Copyright: 2006-2009, Mark Nauwelaerts <mnauw@users.sourceforge.net>
+License: LGPL-2+
+
+Files: tests/check/elements/rtp-payloading.c
+ tests/check/elements/rtpjitterbuffer.c
+Copyright: 2008, Nokia Corporation and its subsidary(-ies)
+  2009, Nokia Corporation and its subsidary(-ies)
+License: LGPL-2+
+
+Files: gst/multifile/patternspec.c
+ gst/multifile/patternspec.h
+Copyright: 1995-1997, 1999 Peter Mattis, Red Hat, Inc
+License: LGPL-2+
+
+Files: sys/osxvideo/cocoawindow.h
+ sys/osxvideo/osxvideosink.h
+Copyright: 2004, Zaheer Abbas Merali <zaheerabbas at merali dot org>
+  2004-6 Zaheer Abbas Merali <zaheerabbas at merali dot org>
+  2007, Pioneers of the Inevitable <songbird@songbirdnest.com>
+License: LGPL-2+
+
+Files: gst/monoscope/convolve.c
+ gst/monoscope/convolve.h
+Copyright: 1999, Ralph Loader <suckfish@ihug.co.nz>
+License: LGPL-2+
+
+Files: gst/autodetect/gstautoaudiosrc.h
+ gst/autodetect/gstautovideosrc.h
+Copyright: 2005, Ronald S. Bultje <rbultje@ronald.bitfreak.net>
+  2008, Stefan Kost <ensonic@users.sf.net>
+License: LGPL-2+
+
+Files: tests/examples/audiofx/firfilter-example.c
+ tests/examples/audiofx/iirfilter-example.c
+Copyright: 2009, Sebastian Droege <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: tests/check/elements/apev2mux.c
+ tests/check/elements/interleave.c
+Copyright: 2006, Sebastian Dröge <slomo@circular-chaos.org>
+  2006, Tim-Philipp Müller <tim centricular net>
+  2007, Tim-Philipp Müller <tim centricular net>
+  2008, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: gst/deinterlace/gstdeinterlacemethod.c
+ gst/deinterlace/gstdeinterlacemethod.h
+Copyright: 2008-2010, Sebastian Dröge <slomo@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/multipart/multipartdemux.c
+ gst/multipart/multipartdemux.h
+Copyright: 2004, Wim Taymans <wim@fluendo.com>
+  2006, Sjoerd Simons <sjoerd@luon.net>
+License: LGPL-2+
+
+Files: sys/v4l2/gstv4l2sink.c
+ sys/v4l2/gstv4l2sink.h
+Copyright: 2009, Texas Instruments, Inc - http://www.ti.com/
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/greedyhmacros.h
+ gst/deinterlace/tvtime/tomsmocomp/TomsMoCompAll.inc
+Copyright: 2001, Tom Barry
+  2002, Tom Barry
+License: LGPL-2+
+
+Files: ext/jack/gstjackutil.c
+ ext/jack/gstjackutil.h
+Copyright: 2010, Tristan Matthews <tristan@sat.qc.ca>
+License: LGPL-2+
+
+Files: gst/law/alaw.c
+ gst/law/mulaw.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2.1+
+
+Files: gst/law/alaw-decode.c
+ gst/law/alaw-encode.c
+Copyright: 2000, Abramo Bagnara <abramo@alsa-project.org>
+License: LGPL-2.1+
+
+Files: tests/check/elements/audiofirfilter.c
+ tests/check/elements/audioiirfilter.c
+Copyright: 2009, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2.1+
+
+Files: gst/rtsp/gstrtspext.c
+ gst/rtsp/gstrtspext.h
+Copyright: <2006> Wim Taymans <wim@fluendo.com>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/gstqtmuxmap.c
+ gst/isomp4/gstqtmuxmap.h
+Copyright: 2008, Mark Nauwelaerts <mnauw@users.sf.net>
+  2008, Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/atoms.h
+ gst/isomp4/gstqtmux.h
+Copyright: 2008-2010, Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: ext/jack/gstjackaudiosrc.c
+ ext/jack/gstjackaudiosrc.h
+Copyright: 2008, Tristan Matthews <tristan@sat.qc.ca>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: sys/osxaudio/gstosxaudiosrc.h
+ sys/osxaudio/gstosxringbuffer.h
+Copyright: 2005-2006, Zaheer Abbas Merali <zaheerabbas at merali dot org>
+  2006, Zaheer Abbas Merali <zaheerabbas at merali dot org>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: ext/libpng/gstpng.c
+ ext/libpng/gstpngenc.c
+Copyright: 2000, Donald A. Graft
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: gst/goom/ifs.c
+ gst/goom/ifs.h
+Copyright: 1997, Massimino Pascal <Pascal.Massimon@ens.fr>
+License: LGPL-2+
+
+Files: gst/monoscope/monoscope.c
+Copyright: 1998-2001, Andy Lo A Foe <andy@alsaplayer.org>
+  2002, Richard Boulton <richard@tartarus.org>
+License: BSD (3 clause)
+
+Files: ltmain.sh
+Copyright: 1996-2001, 2003-2006
+License: GPL-2+
+
+Files: tests/examples/level/level-example.c
+Copyright: 2000-2003,2005
+License: LGPL-2+
+
+Files: gst/level/gstlevel.h
+Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
+  2000-2003,2005,
+License: LGPL-2+
+
+Files: ext/cairo/gstcairo.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003-2004> David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: gst/isomp4/isomp4-plugin.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David A. Schleef <ds@schleef.org>
+  <2006> Wim Taymans <wim@fluendo.com>
+License: LGPL-2+
+
+Files: gst/isomp4/qtdemux.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David A. Schleef <ds@schleef.org>
+  <2006> Wim Taymans <wim@fluendo.com>
+  <2007> Julien Moutte <julien@fluendo.com>
+  <2009> STEricsson <benjamin.gaignard@stericsson.com>
+  <2009> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/videofilter/gstvideobalance.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+  <2010> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/videofilter/gstvideoflip.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+  <2010> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  <2011> Youness Alaoui <youness.alaoui@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/videofilter/gstgamma.h
+Copyright: 2003, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2006, Mark Nauwelaerts <manauw@skynet.be>
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: gst/videofilter/gstgamma.c
+Copyright: 2003, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2006, Mark Nauwelaerts <manauw@skynet.be>
+  2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2003> David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: ext/flac/gstflacdec.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006,2011> Tim-Philipp Müller <tim centricular net>
+  <2006> Jan Schmidt <thaytan at mad scientist com>
+License: LGPL-2+
+
+Files: gst/y4m/gsty4mencode.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006> Mark Nauwelaerts <mnauw@users.sourceforge.net>
+License: LGPL-2+
+
+Files: gst/avi/gstavidemux.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006> Nokia Corporation (contact <stefan.kost@nokia.com>)
+License: LGPL-2+
+
+Files: ext/shout2/gstshout2.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2006> Tim-Philipp Müller <tim centricular net>
+  <2012> Ralph Giles <giles@mozilla.com>
+License: LGPL-2+
+
+Files: gst/isomp4/qtdemux_dump.c
+Copyright: 2009, Tim-Philipp Müller <tim centricular net>
+  <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> STEricsson <benjamin.gaignard@stericsson.com>
+License: LGPL-2+
+
+Files: gst/spectrum/gstspectrum.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: ext/jpeg/gstjpegdec.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2009> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: ext/flac/gstflacdec.h
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  <2011> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/avi/gstavidemux.c
+Copyright: <1999> Erik Walthinsen <omega@temple-baptist.com>
+  <2006> Nokia Corporation (contact <stefan.kost@nokia.com>)
+  <2009-2010> STEricsson <benjamin.gaignard@stericsson.com>
+License: LGPL-2+
+
+Files: gst/goom2k1/gstgoom.c
+Copyright: <2001> Richard Boulton <richard@tartarus.org>
+  <2006> Wim Taymans <wim at fluendo dot com>
+License: LGPL-2+
+
+Files: gst/goom/gstgoom.c
+Copyright: <2001> Richard Boulton <richard@tartarus.org>
+  <2006> Wim Taymans <wim at fluendo dot com>
+  <2011> Wim Taymans <wim.taymans at gmail dot com>
+License: LGPL-2+
+
+Files: gst/wavenc/gstwavenc.c
+Copyright: <2002> Iain Holmes <iain@prettypeople.org>
+  <2006> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/rtpmanager/gstrtpptdemux.c
+Copyright: 2005, Nokia Corporation
+  <2004> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: tests/check/elements/matroskamux.c
+Copyright: <2005> Michal Benes <michal.benes@xeris.cz>
+License: LGPL-2+
+
+Files: gst/udp/gstdynudpsink.c
+Copyright: <2005> Nokia Corporation <kai.vehmanen@nokia.com>
+  <2005> Philippe Khalaf <burger@speedy.org>
+  <2006> Joni Valtanen <joni.valtanen@movial.fi>
+  <2012> Collabora Ltd
+License: LGPL-2+
+
+Files: gst/udp/gstudpsrc.c
+Copyright: <2005> Nokia Corporation <kai.vehmanen@nokia.com>
+  <2005> Wim Taymans <wim@fluendo.com>
+  <2012> Collabora Ltd
+License: LGPL-2+
+
+Files: gst/udp/gstdynudpsink.h
+Copyright: <2005> Philippe Khalaf <burger@speedy.org>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtph263pay.c
+Copyright: <2005> Wim Taymans <wim.taymans@gmail.com>
+  <2008> Dejan Sakelsak <dejan.sakelsak@marand.si>
+  <2009> Janin Kolenc <janin.kolenc@marand.si>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtph263depay.c
+Copyright: 2007, Collabora Ltd
+  2007, Nokia Corporation
+  <2005> Wim Taymans <wim.taymans@gmail.com>
+License: LGPL-2+
+
+Files: gst/udp/gstudpsink.c
+Copyright: <2005> Wim Taymans <wim@fluendo.com>
+  <2012> Collabora Ltd
+License: LGPL-2+
+
+Files: tests/check/elements/autodetect.c
+Copyright: <2006> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/isomp4/gstrtpxqtdepay.c
+Copyright: <2006> Wim Taymans <wim@fluendo.com>
+License: LGPL-2+
+
+Files: tests/icles/ximagesrc-test.c
+Copyright: <2006> Zaheer Abbas Merali <zaheerabbas at merali dot org>
+License: LGPL-2+
+
+Files: gst/avi/gstavisubtitle.c
+Copyright: <2007> Thijs Vermeir <thijsvermeir@gmail.com>
+  <2007> Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/udp/gstmultiudpsink.c
+Copyright: <2007> Wim Taymans <wim.taymans@gmail.com>
+  <2009> Jarkko Palviainen <jarkko.palviainen@sesca.com>
+  <2012> Collabora Ltd
+License: LGPL-2+
+
+Files: tests/check/elements/qtmux.c
+Copyright: <2008> Mark Nauwelaerts <mnauw@users.sf.net>
+License: LGPL-2+
+
+Files: gst/smpte/plugin.c
+Copyright: <2008> Wim Taymans <wim.taymans@google.com>
+License: LGPL-2+
+
+Files: tests/check/elements/capssetter.c
+Copyright: <2009> Mark Nauwelaerts <mnauw@users.sourceforge.net>
+License: LGPL-2+
+
+Files: gst/isomp4/qtatomparser.h
+Copyright: 2009, Tim-Philipp Müller <tim centricular net>
+  <2009> STEricsson <benjamin.gaignard@stericsson.com>
+License: LGPL-2+
+
+Files: tests/check/pipelines/effectv.c
+Copyright: <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: tests/check/pipelines/wavenc.c
+Copyright: <2010> Stefan Kost <ensonic@users.sf.net>
+License: LGPL-2+
+
+Files: tests/check/elements/jpegenc.c
+Copyright: <2010> Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/videomixer/blend.c
+Copyright: 2004, Wim Taymans <wim@fluendo.com>
+  2006, Mindfruit Bv
+  2009, Alex Ugarte <augarte@vicomtech.org>
+  2009, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: tests/check/pipelines/simple-launch-lines.c
+Copyright: 2005, Andy Wingo <wingo@pobox.com>
+License: LGPL-2+
+
+Files: ext/wavpack/gstwavpack.c
+Copyright: 2004, Arwed v. Merkatz <v.merkatz@gmx.net>
+License: LGPL-2+
+
+Files: ext/wavpack/gstwavpackcommon.c
+Copyright: 1998, - 2005, Conifer Software
+  2005, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2006, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: ext/wavpack/gstwavpackdec.c
+Copyright: 2005, Arwed v. Merkatz <v.merkatz@gmx.net>
+  2006, Edward Hervey <bilboed@gmail.com>
+  2006, Sebastian Dröge <slomo@circular-chaos.org>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpg726pay.h
+Copyright: 2005, Edgard Lima <edgard.lima@indt.org.br>
+  2007-2008, Axis Communications <dev-gstreamer@axis.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpg726pay.c
+Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
+  2005, Edgard Lima <edgard.lima@indt.org.br>
+  2005, Nokia Corporation <kai.vehmanen@nokia.com>
+  2007-2008, Axis Communications <dev-gstreamer@axis.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpg726depay.c
+Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
+  2005, Edgard Lima <edgard.lima@indt.org.br>
+  2005, Zeeshan Ali <zeenix@gmail.com>
+  2008, Axis Communications <dev-gstreamer@axis.com>
+License: LGPL-2+
+
+Files: gst/rtp/gstrtpg726depay.h
+Copyright: 2005, Edgard Lima <edgard.lima@indt.org.br>
+  2008, Axis Communications AB <dev-gstreamer@axis.com>
+License: LGPL-2+
+
+Files: ext/gdk_pixbuf/gstgdkanimation.h
+Copyright: 2003, Benjamin Otte <in7y118@public.uni-hamburg.de>
+License: LGPL-2+
+
+Files: gst/debugutils/tests.c
+Copyright: 1995-1997, 1999-2000, Free Software Foundation, Inc
+  2004, Benjamin Otte <otte@gnome.org>
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/vfir.c
+Copyright: 2001-2003, Fabrice Bellard
+  2004, Billy Biggs <vektor@dumbterm.net>
+  2008,2010, Sebastian Dröge <slomo@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/greedy.c
+Copyright: 2000, Tom Barry
+  2002, Billy Biggs <vektor@dumbterm.net>
+  2008,2010, Sebastian Dröge <slomo@collabora.co.uk>
+License: LGPL-2+
+
+Files: tests/check/elements/rtpbin_buffer_list.c
+Copyright: 2009, Branko Subasic <branko dot subasic at axis dot com>
+License: LGPL-2+
+
+Files: gst-libs/gst/glib-compat-private.h
+Copyright: 2005, David Schleef <ds@schleef.org>
+License: LGPL-2+
+
+Files: gst/deinterlace/tvtime/x86-64_macros.inc
+Copyright: 2004, Dirk Ziegelmeier <dziegel@gmx.de>
+License: LGPL-2+
+
+Files: tests/icles/v4l2src-test.c
+Copyright: 2006, Edgard Lima <edgard dot lima at indt dot org dot br>
+License: LGPL-2+
+
+Files: gst/audioparsers/gstamrparse.c
+Copyright: 2006, Edgard Lima <edgard.lima@indt.org.br>
+  2008, Nokia Corporation.
+License: LGPL-2+
+
+Files: gst/imagefreeze/gstimagefreeze.c
+Copyright: 2005, Edward Hervey <bilboed@bilboed.com>
+  2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: sys/osxaudio/gstosxaudio.c
+Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
+  2007-2008, Pioneers of the Inevitable <songbird@songbirdnest.com>
+License: LGPL-2+
+
+Files: gst/videobox/gstvideobox.c
+Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
+  2006, Tim-Philipp Müller <tim centricular net>
+  2010, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/debugutils/gstcapsdebug.h
+
+Files: gst-libs/gst/gettext.h
+Copyright: 1995-1998, 2000-2002, Free Software Foundation, Inc
+License: LGPL-2+
+
+Files: gst/wavenc/gstwavenc.h
+Copyright: 2002, Iain Holmes <iain@prettypeople.org>
+License: LGPL-2+
+
+Files: tests/examples/spectrum/spectrum-example.c
+Copyright: 2006, Stefan Kost <ensonic@users.sf.net>
+  2008, Jan Schmidt <jan.schmidt@sun.com>
+License: LGPL-2+
+
+Files: gst/flv/amfdefs.h
+Copyright: 2011, Jan Schmidt <thaytan@noraisin.net>
+License: LGPL-2+
+
+Files: gst/udp/gstudpnetutils.c
+Copyright: 2006, Joni Valtanen <joni.valtanen@movial.fi>
+  2006, Tim-Philipp Müller <tim centricular net>
+  2009, Jarkko Palviainen <jarkko.palviainen@sesca.com>
+License: LGPL-2+
+
+Files: tests/examples/cairo/cairo_overlay.c
+Copyright: 2011, Jon Nordby <jononor@gmail.com>
+License: LGPL-2+
+
+Files: gst/udp/gstudpnetutils.h
+Copyright: 2006, Joni Valtanen <joni.valtanen@movial.fi>
+  2006, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: gst/avi/gstavimux.c
+Copyright: 2002, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2006, Mark Nauwelaerts <manauw@skynet.be>
+License: LGPL-2+
+
+Files: gst/matroska/matroska-mux.c
+Copyright: 2003, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2005, Michal Benes <michal.benes@xeris.cz>
+  2008, Sebastian Dröge <sebastian.droege@collabora.co.uk>
+  2011, Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/deinterlace/gstdeinterlace.c
+Copyright: 2005, Martin Eikermann <meiker@upb.de>
+  2008-2010, Sebastian Dröge <slomo@collabora.co.uk>
+  2011, Robert Swain <robert.swain@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst/deinterlace/gstdeinterlace.h
+Copyright: 2005, Martin Eikermann <meiker@upb.de>
+  2008-2010, Sebastian Dröge <slomo@collabora.co.uk>
+License: LGPL-2+
+
+Files: tests/check/elements/icydemux.c
+Copyright: 2006, Michael Smith <msmith@fluendo.com>
+License: LGPL-2+
+
+Files: gst/debugutils/rndbuffersize.c
+Copyright: 2007, Nokia Corporation (contact <stefan.kost@nokia.com>)
+License: LGPL-2+
+
+Files: gst/audioparsers/gstamrparse.h
+Copyright: 2004, Ronald Bultje <rbultje@ronald.bitfreak.net>
+  2008, Nokia Corporation.
+License: LGPL-2+
+
+Files: tests/check/pipelines/tagschecking.c
+Copyright: 2008, Nokia Corporation. (contact <stefan.kost@nokia.com>)
+  2010, Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+License: LGPL-2+
+
+Files: sys/directsound/gstdirectsoundplugin.c
+Copyright: 2005, Sebastien Moutte <sebastien@moutte.net>
+  2007, Pioneers of the Inevitable <songbird@songbirdnest.com>
+License: LGPL-2+
+
+Files: gst/flv/gstindex.c
+Copyright: 2001, RidgeRun (http://www.ridgerun.com/)
+License: LGPL-2+
+
+Files: tests/examples/v4l2/camctrl.c
+Copyright: 2010, Stefan Kost <stefan.kost@nokia.com>
+License: LGPL-2+
+
+Files: tests/check/elements/deinterlace.c
+Copyright: 2010, Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+License: LGPL-2+
+
+Files: gst-libs/gst/gst-i18n-plugin.h
+Copyright: 2004, Thomas Vander Stichele <thomas@apestaart.org>
+License: LGPL-2+
+
+Files: ext/speex/gstspeexdec.c
+Copyright: 2004, Wim Taymans <wim@fluendo.com>
+  2006, Tim-Philipp Müller <tim centricular net>
+License: LGPL-2+
+
+Files: tests/check/elements/souphttpsrc.c
+Copyright: 2001-2003, Ximian, Inc
+  2006-2007, Tim-Philipp Müller <tim centricular net>
+  2008, Wouter Cloetens <wouter@mind.be>
+License: LGPL-2+
+
+Files: tests/examples/pulse/pulse.c
+Copyright: 2010, Wim Taymans <wim.taymans at gmail.com>
+License: LGPL-2+
+
+Files: sys/ximage/gstximagesrc.c
+Copyright: 2006, Zaheer Merali <zaheerabbas at merali dot org>
+License: LGPL-2+
+
+Files: gst/matroska/lzo.c
+Copyright: 2006, Reimar Doeffinger
+License: LGPL-2.1+
+
+Files: gst/replaygain/rganalysis.c
+Copyright: 2001, David Robinson
+  2001, David Robinson <David@Robinson.org>
+  2006, Rene Stadler <mail@renestadler.de>
+License: LGPL-2.1+
+
+Files: gst/replaygain/rganalysis.h
+Copyright: 2001, David Robinson <David@Robinson.org>
+  2006, Rene Stadler <mail@renestadler.de>
+License: LGPL-2.1+
+
+Files: ext/pulse/pulsesink.c
+Copyright: 2004-2008, Lennart Poettering
+  2009, Wim Taymans
+License: LGPL-2.1+
+
+Files: gst/matroska/lzo.h
+Copyright: 2006, Reimar Doeffinger
+License: LGPL-2.1+
+
+Files: gst/rtsp/gstrtspsrc.c
+Copyright: <2005-2006> Wim Taymans <wim at fluendo dot com>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/rtsp/gstrtpdec.c
+Copyright: <2005-2006> Wim Taymans <wim.taymans@gmail.com>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/rtsp/gstrtpdec.h
+Copyright: <2005-2006> Wim Taymans <wim@fluendo.com>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/ftypcc.h
+Copyright: <2008> Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: gst/isomp4/atoms.c
+Copyright: 2008, Mark Nauwelaerts <mnauw@users.sf.net>
+  2008-2010, Thiago Santos <thiagoss@embedded.ufcg.edu.br>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: ext/jack/gstjackringbuffer.h
+Copyright: 2006, Wim Taymans <wim@fluendo.com>
+  2008, Tristan Matthews <tristan@sat.qc.ca>
+License: MIT/X11 (BSD like) LGPL-2+
+
+Files: ext/libpng/gstpngdec.c
+Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
+License: LGPL-2+
+
+Files: sys/oss4/oss4-soundcard.h
+Copyright: 4Front Technologies 2000-2006. Released under the BSD license
+License: BSD
+
+Copyright:
+
+    This package is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This package is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this package; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+On Debian GNU/Linux systems, the complete text of the GNU Lesser General
+Public License can be found in `/usr/share/common-licenses/LGPL'.
+
diff --git a/debian/gbp.conf b/debian/gbp.conf
new file mode 100644
index 0000000..ebb3d05
--- /dev/null
+++ b/debian/gbp.conf
@@ -0,0 +1,6 @@
+[DEFAULT]
+upstream-branch = upstream
+debian-branch = master
+pristine-tar = True
+upstream-tag = upstream/%(version)s
+debian-tag = debian/%(version)s
diff --git a/debian/gstreamer-plugins-good-doc.install b/debian/gstreamer-plugins-good-doc.install
new file mode 100644
index 0000000..133e6a2
--- /dev/null
+++ b/debian/gstreamer-plugins-good-doc.install
@@ -0,0 +1 @@
+debian/tmp/usr/share/gtk-doc
diff --git a/debian/gstreamer-plugins-good.install b/debian/gstreamer-plugins-good.install
new file mode 100644
index 0000000..047470c
--- /dev/null
+++ b/debian/gstreamer-plugins-good.install
@@ -0,0 +1,68 @@
+@1394@
+debian/tmp/usr/share/gstreamer-@GST_ABI@/presets/
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstaasink.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstalaw.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstalphacolor.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstalpha.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstapetag.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstaudiofx.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstaudioparsers.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstauparse.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstautodetect.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstavi.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstcacasink.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstcairo.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstcutter.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstdebug.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstdeinterlace.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstdtmf.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstdv.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgsteffectv.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstequalizer.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstflac.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstflv.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstflxdec.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstgdkpixbuf.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstgoom.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstgoom2k1.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgsticydemux.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstimagefreeze.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstinterleave.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstid3demux.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstjack.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstjpeg.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstlevel.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstmatroska.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstmonoscope.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstmulaw.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstmultifile.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstmultipart.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstnavigationtest.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstpng.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstossaudio.so
+@oss4@
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstisomp4.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstreplaygain.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstrtp.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstrtpmanager.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstrtsp.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstshapewipe.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstshout2.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstsmpte.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstsouphttpsrc.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstspectrum.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstspeex.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgsttaglib.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstudp.so
+@video4linux2@
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstvideobox.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstvideocrop.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstvideofilter.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstvideomixer.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstvpx.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstwavenc.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstwavpack.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstwavparse.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstximagesrc.so
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgsty4menc.so
+debian/tmp/usr/share/locale
diff --git a/debian/gstreamer-pulseaudio.install b/debian/gstreamer-pulseaudio.install
new file mode 100644
index 0000000..49032e9
--- /dev/null
+++ b/debian/gstreamer-pulseaudio.install
@@ -0,0 +1 @@
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstpulse.so
diff --git a/debian/maint b/debian/maint
new file mode 100755
index 0000000..de89a47
--- /dev/null
+++ b/debian/maint
@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+
+missing:
+	make -f debian/rules list-missing
+
+missing-so:
+	make -f debian/rules list-missing | grep so$$ | cut -c 2-
+
+missing-libs:
+	for i in `make -f debian/rules list-missing | grep so$$ | cut -c 2-`; do echo "=== $$i ==="; ldd debian/tmp/$$i; echo; done
+
+.PHONY: missing missing-so missing-libs
+
diff --git a/debian/mk.control b/debian/mk.control
new file mode 100755
index 0000000..1ee8287
--- /dev/null
+++ b/debian/mk.control
@@ -0,0 +1,16 @@
+#!/usr/bin/perl -w
+
+open BUILDDEPS, "debian/build-deps";
+@builddeplist = <BUILDDEPS>;
+close BUILDDEPS;
+
+chomp(@builddeplist);
+$builddeps = join(", ", @builddeplist);
+
+open CONTROLIN, "debian/control.in";
+
+while(<CONTROLIN>){
+        s/BUILDDEPS/$builddeps/;
+        print;
+}
+
diff --git a/debian/rules b/debian/rules
new file mode 100755
index 0000000..e33baa9
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,192 @@
+#!/usr/bin/make -f
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/gnome.mk
+include /usr/share/cdbs/1/rules/utils.mk
+include /usr/share/cdbs/1/rules/autoreconf.mk
+
+DEB_BUILD_PARALLEL = 1
+
+DEB_DH_AUTORECONF_ARGS += --as-needed
+
+CFLAGS += -Wno-error
+CXXFLAGS += -Wno-error
+LDFLAGS += -Wl,-z,defs -Wl,-O1 -Wl,--as-needed
+DEB_MAKE_CHECK_TARGET = check || true
+
+# this is for compatibility with dpkg-dev < 1.13.5, see
+# <http://lists.debian.org/debian-devel-announce/2005/06/msg00010.html>
+DEB_HOST_ARCH_CPU := $(shell dpkg-architecture -qDEB_HOST_ARCH_CPU 2>/dev/null)
+DEB_HOST_ARCH_OS := $(shell dpkg-architecture -qDEB_HOST_ARCH_OS 2>/dev/null)
+
+# Take account of old dpkg-architecture output.
+ifeq ($(DEB_HOST_ARCH_CPU),)
+  DEB_HOST_ARCH_CPU := $(shell dpkg-architecture -qDEB_HOST_GNU_CPU)
+  ifeq ($(DEB_HOST_ARCH_CPU),x86_64)
+    DEB_HOST_ARCH_CPU := amd64
+  endif
+endif
+ifeq ($(DEB_HOST_ARCH_OS),)
+  DEB_HOST_ARCH_OS := $(subst -gnu,,$(shell dpkg-architecture -qDEB_HOST_GNU_SYSTEM))
+  ifeq ($(DEB_HOST_ARCH_OS),gnu)
+    DEB_HOST_ARCH_OS := hurd
+  endif
+endif
+# end of compatibility block
+
+# debian package version
+version=$(shell dpkg-parsechangelog | grep ^Version: | cut -d ' ' -f 2)
+# upstream version
+gst_version=$(shell echo $(version) | cut -d '-' -f 1)
+gst_major=1
+gst_minor=0
+gst_abi=$(gst_major).$(gst_minor)
+# gstreamer library package names
+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.3.3)
+
+gst_pkgname=gstreamer$(gst_abi)
+gst_deb_abi=$(gst_abi)-0
+
+gst_extra_build_depends =
+gst_extra_build_depends += libraw1394-dev (>= 2.0.0) [linux-any]
+gst_extra_build_depends += , libiec61883-dev (>= 1.0.0) [linux-any]
+gst_extra_build_depends += , libavc1394-dev [linux-any]
+gst_extra_build_depends += , libv4l-dev [linux-any]
+gst_extra_build_depends += , libgudev-1.0-dev (>= 143) [linux-any]
+
+# debug package
+DEB_DH_STRIP_ARGS := --dbg-package=$(gst_pkgname)-plugins-good-dbg
+
+# disable all CPU specific optimizations in commands launched by this Makefile
+# using liboil; this is to work around liboil related build failures which
+# are not specially interesting to catch on buildds as these might run very
+# specific hardware
+OIL_CPU_FLAGS=0
+export OIL_CPU_FLAGS
+
+# The plugins are basically the same.
+# Link special names to a template file.
+# still need "*.install" to be done by hand
+
+PLUGINS += pulseaudio plugins-good
+CONFIG_ARGS :=
+ifeq ($(DEB_HOST_ARCH_OS),linux)
+PLUGINS +=
+endif
+VERSIONIZE= \
+	plugins-good-doc.install \
+
+ifeq ($(DEB_HOST_ARCH_OS),linux)
+1394 = debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/gstreamer-$(gst_abi)/libgst1394.so
+video4linux2 = debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/gstreamer-$(gst_abi)/libgstvideo4linux2.so
+endif
+
+ifeq ($(DEB_HOST_ARCH_OS),hurd)
+CONFIG_ARGS += --disable-oss4
+else
+oss4 = debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/gstreamer-$(gst_abi)/libgstoss4audio.so
+endif
+
+ifeq ($(DEB_HOST_ARCH_OS),linux)
+DEFAULT_AUDIOSINK = autoaudiosink
+DEFAULT_AUDIOSRC = autoaudiosrc
+DEFAULT_VIDEOSINK = autovideosink
+DEFAULT_VIDEOSRC = v4l2src
+DEFAULT_VISUALIZER = goom
+else
+DEFAULT_AUDIOSINK = autoaudiosink
+DEFAULT_AUDIOSRC = autoaudiosrc
+DEFAULT_VIDEOSINK = autovideosink
+DEFAULT_VIDEOSRC = videotestsrc
+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
+
+
+# setup links for packages
+pre-build::
+	for p in $(PLUGINS); do \
+		rm -f debian/$(gst_pkgname)-$$p.install; \
+		sed \
+			-e 's/@GST_ABI@/$(gst_abi)/g' \
+			-e 's,@1394@,$(1394),g' \
+			-e 's,@video4linux2@,$(video4linux2),g' \
+			-e 's,@oss4@,$(oss4),g' \
+			debian/gstreamer-$$p.install \
+			> debian/$(gst_pkgname)-$$p.install; \
+	done
+
+	for f in $(VERSIONIZE); do \
+		sed 's/@GST_ABI@/$(gst_abi)/g' debian/gstreamer-$$f \
+			> debian/$(gst_pkgname)-$$f; \
+	done
+
+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) \
+	--enable-gtk-doc \
+	--enable-experimental \
+	--with-default-audiosink=$(DEFAULT_AUDIOSINK) \
+	--with-default-audiosrc=$(DEFAULT_AUDIOSRC) \
+	--with-default-videosink=$(DEFAULT_VIDEOSINK) \
+	--with-default-videosrc=$(DEFAULT_VIDEOSRC) \
+	--with-default-visualizer=$(DEFAULT_VISUALIZER) \
+	$(CONFIG_ARGS)
+
+clean::
+	# get rid of the sym links
+	for i in $(PLUGINS); do \
+		rm -f debian/$(gst_pkgname)-$$i.install; \
+		rm -f debian/$(gst_pkgname)-$$i.preinst; \
+	done
+	for f in $(VERSIONIZE); do \
+		rm -f debian/$(gst_pkgname)-$$f; \
+	done
+
+common-binary-fixup-arch::
+	dh_gstscancodecs
+
+DEB_INSTALL_DOCS_ALL += debian/README.Debian NEWS
+
+# Disable inclusion of large upstream ChangeLog
+DEB_INSTALL_CHANGELOGS_ALL :=
+
+.PHONY: maint
diff --git a/debian/source/format b/debian/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/debian/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/debian/watch b/debian/watch
new file mode 100644
index 0000000..60bcea6
--- /dev/null
+++ b/debian/watch
@@ -0,0 +1,2 @@
+version=3
+http://gstreamer.freedesktop.org/src/gst-plugins-good/gst-plugins-good-(0\.11\..*)\.tar\.gz
