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..e359129
--- /dev/null
+++ b/debian/build-deps
@@ -0,0 +1,37 @@
+@GST_LIB_DEV_DEP@
+@GST_EXTRA_BUILD_DEPENDS@
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.12.0)
+autotools-dev
+dh-autoreconf
+automake (>= 1.14)
+autoconf (>= 2.69)
+libtool (>= 2.2.6)
+autopoint (>= 0.17)
+cdbs (>= 0.4.93)
+debhelper (>= 10)
+dpkg-dev (>= 1.15.1)
+pkg-config (>= 0.11.0)
+gtk-doc-tools (>= 1.12)
+libglib2.0-dev (>= 2.40)
+liborc-0.4-dev (>= 1:0.4.17)
+libcairo2-dev (>= 1.10.0)
+libcaca-dev
+libspeex-dev (>= 1.1.6)
+libpng-dev
+libshout3-dev
+libjpeg-dev
+libaa1-dev (>= 1.4p5)
+libflac-dev (>= 1.1.4)
+libdv4-dev | libdv-dev
+libxdamage-dev
+libxext-dev
+libxfixes-dev
+libxv-dev
+libtag1-dev (>= 1.5)
+libwavpack-dev (>= 4.60)
+gstreamer@GST_ABI@-plugins-base (>= 1.12.0)
+libsoup2.4-dev (>= 2.48)
+libpulse-dev (>= 2.0)
+libbz2-dev
+libjack-jackd2-dev
+libvpx-dev (>= 1.3.0)
diff --git a/debian/build-deps.in b/debian/build-deps.in
new file mode 100644
index 0000000..e359129
--- /dev/null
+++ b/debian/build-deps.in
@@ -0,0 +1,37 @@
+@GST_LIB_DEV_DEP@
+@GST_EXTRA_BUILD_DEPENDS@
+libgstreamer-plugins-base@GST_ABI@-dev (>= 1.12.0)
+autotools-dev
+dh-autoreconf
+automake (>= 1.14)
+autoconf (>= 2.69)
+libtool (>= 2.2.6)
+autopoint (>= 0.17)
+cdbs (>= 0.4.93)
+debhelper (>= 10)
+dpkg-dev (>= 1.15.1)
+pkg-config (>= 0.11.0)
+gtk-doc-tools (>= 1.12)
+libglib2.0-dev (>= 2.40)
+liborc-0.4-dev (>= 1:0.4.17)
+libcairo2-dev (>= 1.10.0)
+libcaca-dev
+libspeex-dev (>= 1.1.6)
+libpng-dev
+libshout3-dev
+libjpeg-dev
+libaa1-dev (>= 1.4p5)
+libflac-dev (>= 1.1.4)
+libdv4-dev | libdv-dev
+libxdamage-dev
+libxext-dev
+libxfixes-dev
+libxv-dev
+libtag1-dev (>= 1.5)
+libwavpack-dev (>= 4.60)
+gstreamer@GST_ABI@-plugins-base (>= 1.12.0)
+libsoup2.4-dev (>= 2.48)
+libpulse-dev (>= 2.0)
+libbz2-dev
+libjack-jackd2-dev
+libvpx-dev (>= 1.3.0)
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..ca8a381
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,7 @@
+gst-plugins-good1.0 (1.12.2+imx-0) unstable; urgency=medium
+
+  * Initial release
+
+ -- AIY Projects <support-aiyprojects@google.com>  Wed, 04 Jul 2018 10:45:53 -0800
+
+
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..77d2bfe
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,85 @@
+Source: gst-plugins-good1.0
+Section: libs
+Priority: optional
+Maintainer: AIY Projects <support-aiyprojects@google.com>
+Build-Depends: libgstreamer1.0-dev (>= 1.12.0),  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.12.0), autotools-dev, dh-autoreconf, automake (>= 1.14), autoconf (>= 2.69), libtool (>= 2.2.6), autopoint (>= 0.17), cdbs (>= 0.4.93), debhelper (>= 9), dpkg-dev (>= 1.15.1), pkg-config (>= 0.11.0), gtk-doc-tools (>= 1.12), libglib2.0-dev (>= 2.40), liborc-0.4-dev (>= 1:0.4.17), libcairo2-dev (>= 1.10.0), libcaca-dev, libspeex-dev (>= 1.1.6), libpng-dev, libshout3-dev, libjpeg-dev, libaa1-dev (>= 1.4p5), libflac-dev (>= 1.1.4), libdv4-dev | libdv-dev, libxdamage-dev, libxext-dev, libxfixes-dev, libxv-dev, libtag1-dev (>= 1.5), libwavpack-dev (>= 4.60), gstreamer1.0-plugins-base (>= 1.12.0), libsoup2.4-dev (>= 2.48), libpulse-dev (>= 2.0), libbz2-dev, libjack-jackd2-dev, libvpx-dev (>= 1.3.0)
+Standards-Version: 3.9.3
+Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html
+
+
+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.7.90)
+XB-GStreamer-Version: ${gstreamer:Version}
+XB-GStreamer-Elements: ${gstreamer:Elements}
+XB-GStreamer-URI-Sources: ${gstreamer:URISources}
+XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
+XB-GStreamer-Encoders: ${gstreamer:Encoders}
+XB-GStreamer-Decoders: ${gstreamer:Decoders}
+Provides: ${gstreamer:Provides}
+Description: GStreamer plugins from the "good" set
+ GStreamer is a streaming media framework, based on graphs of filters
+ which operate on media data.  Applications using this library can do
+ anything from real-time sound processing to playing videos, and just
+ about anything else media-related.  Its plugin-based architecture means
+ that new data types or processing capabilities can be added simply by
+ installing new plug-ins.
+ .
+ This package contains the GStreamer plugins from the "good" set, a set
+ of good-quality plug-ins under the LGPL license.
+
+Package: 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.7.90)
+Description: GStreamer plugins from the "good" set
+ GStreamer is a streaming media framework, based on graphs of filters
+ which operate on media data.  Applications using this library can do
+ anything from real-time sound processing to playing videos, and just
+ about anything else media-related.  Its plugin-based architecture means
+ that new data types or processing capabilities can be added simply by
+ installing new plug-ins.
+ .
+ This package contains unstripped shared libraries. It is provided primarily
+ to provide a backtrace with names in a debugger, this makes it somewhat
+ easier to interpret core dumps. The libraries are installed in
+ /usr/lib/debug and are automatically used by gdb.
+
diff --git a/debian/control.in b/debian/control.in
new file mode 100644
index 0000000..afab448
--- /dev/null
+++ b/debian/control.in
@@ -0,0 +1,85 @@
+Source: gst-plugins-good@GST_ABI@
+Section: libs
+Priority: optional
+Maintainer: AIY Projects <support-aiyprojects@google.com>
+Build-Depends: BUILDDEPS
+Standards-Version: 3.9.3
+Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html
+
+
+Package: @GST_PKGNAME@-pulseaudio
+Architecture: any
+Multi-Arch: same
+Section: sound
+Depends: ${misc:Depends},
+         ${shlibs:Depends}
+XB-GStreamer-Version: ${gstreamer:Version}
+XB-GStreamer-Elements: ${gstreamer:Elements}
+XB-GStreamer-URI-Sources: ${gstreamer:URISources}
+XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
+XB-GStreamer-Encoders: ${gstreamer:Encoders}
+XB-GStreamer-Decoders: ${gstreamer:Decoders}
+Provides: ${gstreamer:Provides}
+Description: GStreamer plugin for PulseAudio
+ GStreamer is a streaming media framework, based on graphs of filters
+ which operate on media data.  Applications using this library can do
+ anything from real-time sound processing to playing videos, and just
+ about anything else media-related.  Its plugin-based architecture means
+ that new data types or processing capabilities can be added simply by
+ installing new plug-ins.
+ .
+ This package contains the GStreamer plugin for PulseAudio, a sound server
+ for POSIX and WIN32 systems.
+
+Package: @GST_PKGNAME@-plugins-good
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         @GST_PKGNAME@-pulseaudio | @GST_PKGNAME@-audiosink,
+         gstreamer@GST_ABI@-plugins-base,
+Recommends: @GST_PKGNAME@-x
+Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
+Breaks: gstreamer1.0-plugins-bad (<< 1.7.90)
+XB-GStreamer-Version: ${gstreamer:Version}
+XB-GStreamer-Elements: ${gstreamer:Elements}
+XB-GStreamer-URI-Sources: ${gstreamer:URISources}
+XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
+XB-GStreamer-Encoders: ${gstreamer:Encoders}
+XB-GStreamer-Decoders: ${gstreamer:Decoders}
+Provides: ${gstreamer:Provides}
+Description: GStreamer plugins from the "good" set
+ GStreamer is a streaming media framework, based on graphs of filters
+ which operate on media data.  Applications using this library can do
+ anything from real-time sound processing to playing videos, and just
+ about anything else media-related.  Its plugin-based architecture means
+ that new data types or processing capabilities can be added simply by
+ installing new plug-ins.
+ .
+ This package contains the GStreamer plugins from the "good" set, a set
+ of good-quality plug-ins under the LGPL license.
+
+Package: @GST_PKGNAME@-plugins-good-dbg
+Architecture: any
+Multi-Arch: same
+Section: debug
+Priority: extra
+Depends: @GST_PKGNAME@-plugins-good (= ${binary:Version}),
+         @GST_PKGNAME@-pulseaudio (= ${binary:Version}),
+         ${misc:Depends}
+Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
+Breaks: gstreamer1.0-plugins-bad (<< 1.7.90)
+Description: GStreamer plugins from the "good" set
+ GStreamer is a streaming media framework, based on graphs of filters
+ which operate on media data.  Applications using this library can do
+ anything from real-time sound processing to playing videos, and just
+ about anything else media-related.  Its plugin-based architecture means
+ that new data types or processing capabilities can be added simply by
+ installing new plug-ins.
+ .
+ This package contains unstripped shared libraries. It is provided primarily
+ to provide a backtrace with names in a debugger, this makes it somewhat
+ easier to interpret core dumps. The libraries are installed in
+ /usr/lib/debug and are automatically used by gdb.
+
diff --git a/debian/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.install b/debian/gstreamer-plugins-good.install
new file mode 100644
index 0000000..0dcf139
--- /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@/libgstsoup.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..3b31a5a
--- /dev/null
+++ b/debian/gstreamer-pulseaudio.install
@@ -0,0 +1 @@
+debian/tmp/usr/lib/*/gstreamer-@GST_ABI@/libgstpulseaudio.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/patches/series b/debian/patches/series
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/debian/patches/series
diff --git a/debian/rules b/debian/rules
new file mode 100755
index 0000000..6df4648
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,190 @@
+#!/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
+
+# 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.12.0)
+
+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= \
+
+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)/libgstoss4.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) \
+	--disable-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)
