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.freedesktop.org/

Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: Gstreamer Ugly Plugins 1.0
Upstream-Contact: gstreamer-devel@lists.freedesktop.org
Source: http://gstreamer.freedesktop.org

Files: ext/cdio/gstcdiocddasrc.c
 ext/cdio/gstcdiocddasrc.h
 gst/asfdemux/asfpacket.c
 gst/asfdemux/asfpacket.h
 gst/asfdemux/gstrtpasfdepay.c
 gst/asfdemux/gstrtpasfdepay.h
 gst/realmedia/rademux.c
 gst/realmedia/rademux.h
 gst/realmedia/rmutils.c
 gst/realmedia/rmutils.h
Copyright: 2006, Tim-Philipp Müller <tim centricular net>
  2007, Tim-Philipp Müller <tim centricular net>
License: LGPL-2+

Files: ext/mad/gstmad.c
 ext/mpeg2dec/gstmpeg2dec.c
 ext/mpeg2dec/gstmpeg2dec.h
 ext/sidplay/gstsiddec.h
 gst/asfdemux/asfheaders.c
 gst/asfdemux/asfheaders.h
 gst/asfdemux/gstasf.c
 gst/asfdemux/gstasfdemux.h
 gst/realmedia/rmdemux.h
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
License: LGPL-2+

Files: gst/asfdemux/gstrtspwms.c
 gst/asfdemux/gstrtspwms.h
 gst/realmedia/realhash.c
 gst/realmedia/realhash.h
 gst/realmedia/rtspreal.c
 gst/realmedia/rtspreal.h
Copyright: <2005-2006> Wim Taymans <wim@fluendo.com>
License: LGPL-2+

Files: ext/amrnb/amrnb.c
 ext/amrnb/amrnbdec.c
 ext/amrnb/amrnbdec.h
 ext/amrnb/amrnbenc.c
 ext/amrnb/amrnbenc.h
 ext/amrwbdec/amrwbdec.c
Copyright: 2004, Ronald Bultje <rbultje@ronald.bitfreak.net>
License: LGPL-2+

Files: gst/realmedia/asmrules.c
 gst/realmedia/asmrules.h
 gst/realmedia/rdtjitterbuffer.c
 gst/realmedia/rdtjitterbuffer.h
Copyright: <2007> Wim Taymans <wim.taymans@gmail.com>
License: 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/realmedia/pnmsrc.c
 gst/realmedia/pnmsrc.h
 gst/realmedia/realmedia.c
Copyright: <2009> Wim Taymans <wim.taymans@gmail.com>
License: LGPL-2+

Files: ext/cdio/gstcdio.c
 ext/cdio/gstcdio.h
 gst/asfdemux/gstasfdemux.c
Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
  2006, Tim-Philipp Müller <tim centricular net>
  2006-2009, Tim-Philipp Müller <tim centricular net>
License: LGPL-2+

Files: gst/synaesthesia/gstsynaesthesia.c
 gst/synaesthesia/gstsynaesthesia.h
Copyright: <2001> Richard Boulton <richard@tartarus.org>
License: GPL-2+

Files: gst/synaesthesia/synaescope.c
 gst/synaesthesia/synaescope.h
Copyright: 1999,2002, Richard Boulton <richard@tartarus.org>
License: GPL-2+

Files: gst/dvdlpcmdec/gstdvdlpcmdec.c
 gst/dvdlpcmdec/gstdvdlpcmdec.h
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2005> Jan Schmidt <jan@noraisin.net>
License: LGPL-2+

Files: ext/a52dec/gsta52dec.c
 ext/a52dec/gsta52dec.h
Copyright: <2001> David I. Lehn <dlehn@users.sourceforge.net>
License: LGPL-2+

Files: gst/dvdsub/gstdvdsubdec.c
 gst/dvdsub/gstdvdsubdec.h
Copyright: <2002> Wim Taymans <wim@fluendo.com>
  <2005> Jan Schmidt <jan@fluendo.com>
License: LGPL-2+

Files: gst/realmedia/rdtdepay.c
 gst/realmedia/rdtdepay.h
Copyright: <2006> Lutz Mueller <lutz at topfrose dot de>
License: LGPL-2+

Files: gst/realmedia/gstrdtbuffer.c
 gst/realmedia/gstrdtbuffer.h
Copyright: <2008> Wim Taymans <wim.taymans@gmail.com>
License: LGPL-2+

Files: gst/xingmux/gstxingmux.c
 gst/xingmux/gstxingmux.h
Copyright: 2006, Christophe Fergeau <teuf@gnome.org>
  2008, Sebastian Dröge <slomo@circular-chaos.org>
License: LGPL-2+

Files: ext/amrwbdec/amrwb.c
 ext/amrwbdec/amrwbdec.h
Copyright: 2006, Edgard Lima <edgard.lima@indt.org.br>
License: LGPL-2+

Files: gst/dvdsub/gstdvdsubparse.c
 gst/dvdsub/gstdvdsubparse.h
Copyright: 2007, Mark Nauwelaerts <mnauw@users.sourceforge.net>
License: LGPL-2+

Files: tests/check/elements/amrnbenc.c
 tests/check/pipelines/lame.c
Copyright: 2006, Thomas Vander Stichele <thomas at apestaart dot org>
  2007, Thomas Vander Stichele <thomas at apestaart dot org>
License: LGPL-2+

Files: gst/realmedia/rdtmanager.c
 gst/realmedia/rdtmanager.h
Copyright: <2005-2006> Wim Taymans <wim@fluendo.com>
License: MIT/X11 (BSD like) LGPL-2+

Files: ltmain.sh
Copyright: 1996-2001, 2003-2006
License: GPL-2+

Files: ext/dvdread/dvdreadsrc.h
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2001> Billy Biggs <vektor@dumbterm.net>
  <2006> Tim-Philipp Müller <tim centricular net>
License: LGPL-2+

Files: gst/realmedia/rmdemux.c
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2003> David A. Schleef <ds@schleef.org>
  <2004> Stephane Loeuillet <gstreamer@leroutier.net>
  <2005> Michael Smith <fluendo.com>
  <2005> Owen Fraser-Green <owen@discobabe.net>
  <2006> Tim-Philipp Müller <tim centricular net>
  <2006> Wim Taymans <wim@fluendo.com>
  <2007> Wim Taymans <wim.taymans@gmail.com>
License: LGPL-2+

Files: ext/twolame/gsttwolamemp2enc.c
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2004> Wim Taymans <wim@fluendo.com>
  <2005> Thomas Vander Stichele <thomas at apestaart dot org>
  <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
License: LGPL-2+

Files: ext/lame/gstlamemp3enc.c
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2004> Wim Taymans <wim@fluendo.com>
  <2005> Thomas Vander Stichele <thomas at apestaart dot org>
  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
License: LGPL-2+

Files: ext/sidplay/gstsiddec.cc
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2006> Wim Taymans <wim@fluendo.com>
License: LGPL-2+

Files: ext/twolame/gsttwolamemp2enc.h
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
License: LGPL-2+

Files: ext/lame/gstlamemp3enc.h
Copyright: <1999> Erik Walthinsen <omega@cse.ogi.edu>
  <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
License: LGPL-2+

Files: tests/check/generic/states.c
Copyright: <2005> Thomas Vander Stichele <thomas at apestaart dot org>
License: LGPL-2+

Files: gst/xingmux/plugin.c
Copyright: <2008> Jan Schmidt <jan.schmidt@sun.com>
License: LGPL-2+

Files: tests/check/elements/x264enc.c
Copyright: <2008> Mark Nauwelaerts <mnauw@users.sf.net>
License: LGPL-2+

Files: ext/lame/plugin.c
Copyright: <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
License: LGPL-2+

Files: ext/mad/gstmad.h
Copyright: 2003, Benjamin Otte <in7y118@public.uni-hamburg.de>
License: LGPL-2+

Files: ext/dvdread/dvdreadsrc.c
Copyright: 1999, Erik Walthinsen <omega@cse.ogi.edu>
  2001, Billy Biggs <vektor@dumbterm.net>
  2006, Tim-Philipp Müller <tim centricular net>
License: LGPL-2+

Files: gst-libs/gst/glib-compat-private.h
Copyright: 2005, David Schleef <ds@schleef.org>
License: LGPL-2+

Files: gst-libs/gst/gettext.h
Copyright: 1995-1998, 2000-2002, Free Software Foundation, Inc
License: LGPL-2+

Files: ext/x264/gstx264enc.c
Copyright: 2005, Josef Zlomek <josef.zlomek@itonis.tv>
  2005, Michal Benes <michal.benes@itonis.tv>
  2008, Mark Nauwelaerts <mnauw@users.sf.net>
License: LGPL-2+

Files: ext/x264/gstx264enc.h
Copyright: 2005, Josef Zlomek <josef.zlomek@itonis.tv>
  2005, Michal Benes <michal.benes@itonis.tv>
License: LGPL-2+

Files: tests/check/elements/mpeg2dec.c
Copyright: 2006, Sebastian Dröge <slomo@circular-chaos.org>
License: LGPL-2+

Files: gst-libs/gst/gst-i18n-plugin.h
Copyright: 2004, Thomas Vander Stichele <thomas@apestaart.org>
License: LGPL-2+

Files: tests/check/elements/xingmux.c
Copyright: 2008, Sebastian Dröge <slomo@circular-chaos.org>
License: LGPL-2.1+

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

