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

Upstream Authors:

    Erik Walthinsen <omegahacker@users.sourceforge.net>
    Wim Taymans <wim.taymans@chello.be>
    Richard Boulton <richard@tartarus.org>
    and many more...

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

