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'.

