Source: gst-plugins-good1.0
Section: libs
Priority: optional
Maintainer: Maintainers of GStreamer packages <pkg-gstreamer-maintainers@lists.alioth.debian.org>
Uploaders: Loic Minier <lool@dooz.org>,
           Sebastian Dröge <slomo@debian.org>,
           Sjoerd Simons <sjoerd@debian.org>
Build-Depends: libgstreamer1.0-dev (>= 1.8.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.8.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, libgtk-3-dev, libtag1-dev (>= 1.5), libwavpack-dev (>= 4.60), gstreamer1.0-plugins-base (>= 1.8.0), libsoup2.4-dev (>= 2.48), libpulse-dev (>= 2.0), libbz2-dev, gstreamer1.0-doc, gstreamer1.0-plugins-base-doc, libjack-jackd2-dev, libvpx-dev (>= 1.3.0)
Standards-Version: 3.9.3
Vcs-Git: git://anonscm.debian.org/pkg-gstreamer/gst-plugins-good1.0.git
Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-gstreamer/gst-plugins-good1.0.git;a=summary
Homepage: http://gstreamer.freedesktop.org/modules/gst-plugins-good.html

Package: gstreamer1.0-plugins-good-doc
Architecture: all
Section: doc
Depends: gstreamer1.0-doc,
         gstreamer1.0-plugins-base-doc,
         ${misc:Depends}
Description: GStreamer documentation for plugins from the "good" set
 GStreamer is a streaming media framework, based on graphs of filters
 which operate on media data.  Applications using this library can do
 anything from real-time sound processing to playing videos, and just
 about anything else media-related.  Its plugin-based architecture means
 that new data types or processing capabilities can be added simply by
 installing new plug-ins.
 .
 This package contains documentation for plugins from the "good" set,
 a set of good-quality plug-ins under the LGPL license.

Package: gstreamer1.0-pulseaudio
Architecture: any
Multi-Arch: same
Section: sound
Depends: ${misc:Depends},
         ${shlibs:Depends}
XB-GStreamer-Version: ${gstreamer:Version}
XB-GStreamer-Elements: ${gstreamer:Elements}
XB-GStreamer-URI-Sources: ${gstreamer:URISources}
XB-GStreamer-URI-Sinks: ${gstreamer:URISinks}
XB-GStreamer-Encoders: ${gstreamer:Encoders}
XB-GStreamer-Decoders: ${gstreamer:Decoders}
Provides: ${gstreamer:Provides}
Description: GStreamer plugin for PulseAudio
 GStreamer is a streaming media framework, based on graphs of filters
 which operate on media data.  Applications using this library can do
 anything from real-time sound processing to playing videos, and just
 about anything else media-related.  Its plugin-based architecture means
 that new data types or processing capabilities can be added simply by
 installing new plug-ins.
 .
 This package contains the GStreamer plugin for PulseAudio, a sound server
 for POSIX and WIN32 systems.

Package: gstreamer1.0-plugins-good
Architecture: any
Multi-Arch: same
Section: libs
Depends: ${misc:Depends},
         ${shlibs:Depends},
         gstreamer1.0-pulseaudio | gstreamer1.0-audiosink,
         gstreamer1.0-plugins-base,
Recommends: gstreamer1.0-x
Replaces: gstreamer1.0-plugins-bad (<< 1.1.2)
Breaks: gstreamer1.0-plugins-bad (<< 1.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.

