/*
This file is part of the KDE project
Copyright (C) 2005-2007 Matthias Kretz <kretz@kde.org>
Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
Contact: Nokia Corporation (qt-info@nokia.com)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
/*!
\enum Phonon::DiscType
Enum to identify the media discs supported by MediaObject.
\value NoDisc
No disc was selected. This is only useful as a return value from
MediaSource::diskType().
\value Cd Identifies Audio CDs.
\value Dvd Identifies DVDs (not arbitrary data DVDs, only movie DVDs).
\value Vcd Identifies Video CDs.
\sa MediaSource, MediaObject
*/
/*!
\enum Phonon::MetaData
Provided as keys for Phonon::MediaObject::metaData(). The enum
values matches strings defined in the Ogg Vorbis specification
\value ArtistMetaData
\value AlbumMetaData
\value TitleMetaData
\value DateMetaData
\value GenreMetaData
\value TracknumberMetaData
\value DescriptionMetaData
\value MusicBrainzDiscIdMetaData
*/
/*!
\enum Phonon::State
\since 4.4
The state enum describes the different states a media object can
take. Several functions of \l{Phonon::}{MediaObject} are
asynchronous, so even if a you have requested a state change
through a function call, e.g., through
\l{Phonon::MediaObject::}{play()}, you cannot be sure that the
change has taken place before you receive the
\l{Phonon::MediaObject::}{stateChanged()} signal.
A media object can at any time change into any state, regardless
of the state it previously had. \omit In the
\l{Phonon::}{MediaObject} class description explains the typical
state changes in the life of a media object. \endomit
\value LoadingState
After construction it might take a while before the media object
is ready to \l{Phonon::MediaObject::}{play()}. This state is
commonly used by backends to initialize the \l{Phonon
Overview}{media graph} and loading the source. When
the object leaves the loading state, it will enter the
StoppedState unless an error occurred or another state is
requested through a function call, e.g.,
\l{Phonon::}{MediaObject::play()}.
\value StoppedState
In the stopped state, the media object is ready to play its
current media source. The current
\l{MediaObject::seek()}{position} in the media stream is then 0.
\value PlayingState
The media object is playing back its media source.
\value BufferingState
The Player is waiting for data to be able to start or continue
playing. This state is commonly used to wait for media data over a
network connection.
\value PausedState
The media player has currently paused its playback, i.e., it
stops playing but keeps the current playback position in the
stream.
\value ErrorState
When a media object enters the error state a problem with the
playback has occurred. The possible errors are grouped into
two categories by Phonon::ErrorType, and the type can be
queried through \l{Phonon::MediaObject::}{errorType()}. A
\l{Phonon::}{FatalError} implies that the playback
cannot continue, but one can still try with a new media
source. With a \l{Phonon::}{NormalError} it might
be possible to continue playback, and a media object may
therefore change state from the ErrorState.
\sa MediaObject
*/
/*!
\enum Phonon::Category
Sets the category your program should be listed in in the mixer.
\value NoCategory
Will make use of the default device.
\value NotificationCategory
If the sounds produced are notifications (ping, beep and such) you
should use this category.
\value MusicCategory
If your application is a music player (like a jukebox or media player
playing an audio file).
\value VideoCategory
If the sound is the audio channel of a video.
\value CommunicationCategory
If your applications produces sounds from communication with somebody
else (VoIP, voice chat).
\value GameCategory
Sound produced by a computer game should go into this category.
\value AccessibilityCategory
Sounds produced for accessibility (e.g., Text-To-Speech)
\omitvalue LastCategory
Holds the largest value of categories.
\omitvalue AccessibilityCategory
A Jukebox will set this to Music, a VoIP program to Communication, a
DVD player to video, and so on.
\note These categories can also become useful for an application that
controls the volumes automatically, like turning down the music when a call
comes in, or turning down the notifications when the media player knows
it's playing classical music.
*/
/*!
\enum Phonon::ErrorType
This enum describes the severity when an error has occurred during
playback.
After a media object has entered the \l{Phonon::}{ErrorState}, one
can query the type of error from
\l{Phonon::}{MediaObject::errorType()}. Note that you should query
the error when receiving the
\l{Phonon::}{MediaObject::stateChanged()} signal, because the
error type will be lost if the media object leaves the error
state.
\value NoError No error. MediaObject::errorType() returns this if
MediaObject::state() != Phonon::ErrorState.
\value NormalError An error has occurred with the playback of the current
source. It might be possible to continue playback, for instance, if only the
audio stream in a video cannot be played back. The media object will then
leave the error state again.
\value FatalError. Something important does not work. Your program cannot continue
the playback of the current source, but it might be possible to try another.
\sa MediaObject::errorType()
*/
/*!
\fn QString Phonon::categoryToString(Category c)
Returns a (translated) string to show to the user identifying the given
Category (\a c).
*/
/*!
\enum Phonon::ObjectDescriptionType
\relates Phonon::ObjectDescription
This enum defines the type of information that is contained in a
\l{Phonon::}{ObjectDescription} object.
\value AudioOutputDeviceType An audio output device (\l{Phonon::}{AudioOutputDevice}).
This can be soundcards (with different drivers),
sound servers, or other virtual outputs like playback on a different
computer on the network.
\value EffectType An audio effect (\l{Phonon::}{EffectDescription}).
\omitvalue SubtitleType
\omitvalue AudioCaptureDeviceType
\omitvalue AudioChannelType
*/
/*!
\typedef Phonon::AudioOutputDevice
\relates Phonon::ObjectDescription
This typedef of \l{Phonon::}{ObjectDescription} describes an audio output
device, such as soundcards (with different drivers), sound servers, or other
virtual outputs like playback on a different computer on the network.
\omit
For Hardware devices the backend should use libkaudiodevicelist
(AudioDevice and AudioDeviceEnumerator) which will list removable
devices even when they are unplugged and provide a unique identifier
that can make backends use the same identifiers.
\endomit
A list of available devices is given by the backend with
Backendcapabilities::availableAudioOutputDevices()
\snippet doc/src/snippets/phononobjectdescription.cpp 1
*/
/*!
\fn Phonon::phononVersion()
\inmodule Phonon
\since 4.5
Returns the Phonon version.
*/
/*!
\class Phonon::ObjectDescription
\inmodule Phonon
\inheaderfile Phonon/ObjectDescription
\since 4.4
\brief The ObjectDescription class provides information about Phonon objects.
Phonon currently uses this class to describe audio effects and
audio output devices - using the typedefs AudioOutputDevice and
EffectDescription. The type of an ObjectDescription is also
described through the \l{Phonon::}{ObjectDescriptionType} enum.
Objects of the same \l{Phonon::ObjectDescriptionType}{type} are
uniquely identified by an index().
The class gives a description() and a name() of the object, both
of which are strings appropriate for end users of a Phonon
application. You can also check whether the device or effect
described is \l{isValid()}{valid}. This does not guarantee that
the device or effect functions as expected, but that the
ObjectDescription describes an existing device or effect.
Audio output devices and effect descriptions are used to select
the audio output device to be used for playback and to create
effects; we show examples of this in the snippet below. The
available descriptions can be fetched with
\l{Phonon::BackendCapabilities::}{availableAudioOutputDevices()}
and \l{Phonon::BackendCapabilities::}{availableAudioEffects()}
static functions in the Phonon::BackendCapabilities namespace
\snippet doc/src/snippets/phononobjectdescription.cpp 0
Other types of ObjectDescriptions might be possible in the future,
e.g., descriptions of audio capture devices, such as microphones.
\omit Not implemented yet.
Need a new paragraph on that some descriptions 'belong
together', such as chained audio effects.
Some parts give the end user choices, e.g. what source to capture
audio from. These choices are described by the name and
description methods of this class and identified with the id
method. Subclasses then define additional information like which
audio and video choices belong together. \endomit
\sa Phonon::AudioOutputDevice, Phonon::EffectDescription, {Capabilities Example}, {Phonon Module}
*/
/*!
\fn Phonon::ObjectDescription::ObjectDescription()
\brief constructs a new object description.
\internal
*/
/*!
\fn Phonon::ObjectDescription::ObjectDescription (int index, const QHash<QByteArray, QVariant> & properties)
\internal
*/
/*!
\fn Phonon::ObjectDescription::ObjectDescription(const QExplicitlySharedDataPointer<ObjectDescriptionData> &dd)
\internal
*/
/*!
\fn static inline ObjectDescription<T> Phonon::ObjectDescription::fromIndex(int index)
\internal
\omit Currently indices are not unique for all ObjectDescription types, making
the behavior of this function undefined. \endomit
Returns a new description object that describes the
device/effect/codec/... with the given \a index.
*/
/*!
\fn inline bool Phonon::ObjectDescription::operator==(const ObjectDescription &otherDescription) const
Returns \c true if this ObjectDescription describes the same
object as \a otherDescription; otherwise, returns \c false.
*/
/*!
\fn inline bool Phonon::ObjectDescription::operator!=(const ObjectDescription &otherDescription) const
Returns \c false if this ObjectDescription describes the same
as \a otherDescription; otherwise, returns \c true.
*/
/*!
\fn inline QString Phonon::ObjectDescription::name() const
Returns a string appropriate for a user to select between
object descriptions, e.g., from a QComboBox.
\sa description()
*/
/*!
\fn inline QString Phonon::ObjectDescription::description() const
Returns a more extensive description than the name() function.
For example, in the case of \l{Phonon::}{AudioOutputDevice}s, this
text should make clear which sound source is described; this is
sometimes hard to describe or understand from just the name.
The text is appropriate to present to an end user in for example
tool tips of items, with the name()'s as text, in a QComboBox.
*/
/*!
\fn inline QVariant Phonon::ObjectDescription::property(const char *name) const
Returns the property named \a name. A property can be used for
extended information, such as the manufacturer of a sound card. The
information will usually be given as text.
If the property is not set an invalid QVariant is returned.
Qt's backends do not use properties at the time of this writing.
\sa propertyNames()
*/
/*!
\fn inline QList<QByteArray> Phonon::ObjectDescription::propertyNames() const
Properties can be used for extended information about a
ObjectDescription, e.g., a manufacturer of a sound card. The
information will usually be given text.
This function returns all names that return valid data when
property() is called.
Currently, Qt backends do not use properties for their object
descriptions.
\sa property()
*/
/*!
\fn inline bool Phonon::ObjectDescription::isValid() const
Returns true if the device or effect described exists.
An ObjectDescription that is invalid, will also have an
index() of -1.
\sa index()
*/
/*!
\fn inline int Phonon::ObjectDescription::index() const
Returns a unique identifier for this ObjectDescription. Used
internally to distinguish between the descriptions.
Notice that the identifiers are only unique to the type of
description, e.g., \l{Phonon::}{AudioOutputDevice} or
\l{Phonon::}{EffectDescription}.
*/
/*!
\class Phonon::ObjectDescriptionPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::StreamInterface
\inmodule Phonon
\since 4.4
\brief Backend interface to handle media streams (AbstractMediaStream).
\internal
*/
/*!
\fn virtual Phonon::StreamInterface::~StreamInterface()
*/
/*!
\fn virtual void Phonon::StreamInterface::writeData(const QByteArray &data) = 0
\internal
*/
/*!
\fn virtual void Phonon::StreamInterface::endOfData() = 0
\internal
*/
/*!
\fn virtual void Phonon::StreamInterface::setStreamSize(qint64 newSize) = 0
\internal
*/
/*!
\fn virtual void Phonon::StreamInterface::setStreamSeekable(bool s) = 0
\internal
*/
/*!
\fn void Phonon::StreamInterface::connectToSource(const MediaSource &mediaSource)
\internal
*/
/*!
\fn void Phonon::StreamInterface::needData()
\internal
*/
/*!
\fn void Phonon::StreamInterface::enoughData()
\internal
*/
/*!
\fn void Phonon::StreamInterface::seekStream(qint64)
\internal
*/
/*!
\fn void Phonon::StreamInterface::reset()
\internal
*/
/*!
\fn Phonon::StreamInterface::StreamInterface()
\internal
\omit
For subclasses.
\endomit
*/
/*!
\class StreamInterfacePrivate
\inmodule Phonon
\internal
*/
/*!
\class Phonon::AbstractVideoOutput
\inmodule Phonon
\internal
\since 4.4
\brief The AbstractVideoOutput class is the common base class for all video output classes.
\sa VideoWidget
*/
/*!
\namespace Phonon::Experimental
\internal
*/
/*!
\fn Phonon::AbstractVideoOutput::AbstractVideoOutput(AbstractVideoOutputPrivate &d)
\internal
Constructor that is called from derived classes.
\param parent Standard QObject parent.
*/
/*!
\class Phonon::AbstractVideoOutputPrivate
\inmodule Phonon
\internal
\since 4.4
*/
/*!
\class Phonon::VolumeFaderEffect
\inmodule Phonon
\internal
\since 4.4
This effect differs from gradually changing the output volume in that
a dedicated effect can change the volume in the smallest possible
steps while every other volume control will make more or less
noticeable steps.
\sa AudioOutput::volume()
*/
/*!
\property Phonon::VolumeFaderEffect::volume
This is the current volume of the output as voltage factor.
Setting this property changes the volume immediately.
1.0 means 100%, 0.5 means 50% voltage/25% power, 0.0 means 0%
\sa volumeDecibel
*/
/*!
\property Phonon::VolumeFaderEffect::volumeDecibel
This is the current volume of the output in decibel.
Setting this property changes the volume immediately.
0 dB means no change in volume, -6dB means an attenuation of the
voltage to 50% and an attenuation of the power to 25%, -inf dB means
silence.
\sa volume
*/
/*!
\property Phonon::VolumeFaderEffect::fadeCurve
This property holds the fade curve to be used for the fadeIn(), fadeOut()
and fadeTo() slots.
Defaults to Fade3Decibel.
\sa FadeCurve
*/
/*!
\enum Phonon::VolumeFaderEffect::FadeCurve
Determines the curve of the volume change.
\value Fade3Decibel Crossfade curve/fast fade out.
This is the default fade curve.
\value Fade6Decibel Linear fade out.
\value Fade9Decibel Slow fade out.
\value Fade12Decibel A more extreme version of the -9dB fade.
\bold{Notes:}
\c Fade3Decibel is often the best fade for a crossfade, as after half
of the time the volume reached -3dB. This means that half the
possible power (which is proportional to the square of the
voltage) is reached. Summed, the maximum power of two audio
signals fading with a -3dB curve will always be equal.
For fading in or out the -3dB curve is too abrupt in the end.
With a -6dB fade curve, a volume of -6dB is reached after half of
the fading time. -6dB is equal to half of the voltage meaning
that the voltage multiplier changes linearly from the start
of the fade to the end.
With the \c Fade9Decibel fade, a volume of -9dB is reached after
half of the fade time, so the fade is fast in the beginning and
slow at the end. This is a good fade for ending music.
*/
/*!
\fn void Phonon::VolumeFaderEffect::fadeIn(int fadeTime)
Tells the Fader to change the volume from the current volume to 100%
in \a fadeTime milliseconds.
Short for \c fadeTo(1.0, fadeTime).
\param fadeTime the fade duration in milliseconds
\sa fadeTo(), volume
*/
/*!
\fn void Phonon::VolumeFaderEffect::fadeOut(int fadeTime)
Tells the Fader to change the volume from the current volume to 0%
in \a fadeTime milliseconds.
Short for \c fadeTo(0.0, fadeTime).
\param fadeTime the fade duration in milliseconds
\sa fadeTo
*/
/*!
\fn void Phonon::VolumeFaderEffect::fadeTo(float volume, int fadeTime)
Tells the Fader to change the volume from the current value to
\a volume in \a fadeTime milliseconds.
\sa fadeIn(), fadeOut()
*/
/*!
\class Phonon::VolumeFaderEffectPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::VolumeFaderInterface
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn virtual Phonon::VolumeFaderInterface::~VolumeFaderInterface()
\internal
*/
/*!
\fn virtual float Phonon::VolumeFaderInterface::volume() const
\internal
*/
/*!
\fn virtual void Phonon::VolumeFaderInterface::setVolume(float)
\internal
*/
/*!
\fn virtual Phonon::VolumeFaderEffect::FadeCurve Phonon::VolumeFaderInterface::fadeCurve() const
\internal
*/
/*!
\fn virtual void Phonon::VolumeFaderInterface::setFadeCurve(Phonon::VolumeFaderEffect::FadeCurve)
\internal
*/
/*!
\fn virtual void Phonon::VolumeFaderInterface::fadeTo(float, int)
\internal
*/
/*!
\class Phonon::AbstractMediaStream
\inmodule Phonon
\internal
\since 4.4
\brief The AbstractMediaStream class is the base class for custom media data streams.
\inheaderfile Phonon/AbstractMediaStream
This class is subclassed to provide custom data streams for
\l{Phonon::}{MediaSource}s.
The \l{Phonon::}{MediaSource} knows how to handle the most common
media sources, such as files and CD. If you need to fetch
multimedia from other sources, you can reimplement this class,
which can be used by a \l{Phonon::}{MediaSource}.
When a backend needs more data from the stream, needData() will be
called. You must then use writeData() to write the data to the
backend. You can either write one time and wait for a new
needData() call, or continue to write data until you receive an
enoughData() call. When the stream is at its end, call endOfData()
instead of writeData().
Before the custom stream is passed to a \l{Phonon::}{MediaSource},
setStreamSize() needs to be called, and also setStreamSeekable()
(if the stream is seekable). A good place to do this work is in
the constructor. A seekable stream must also reimplement
seekStream().
We show two examples. The first writes data repeatedly until it
receives the enoughData() call, while the second only writes once
and waits for a new needData() call.
Example where data is written repeatedly.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 0
Example where data is written once:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 1
\sa Phonon::MediaSource, Phonon::MediaObject
*/
/*!
\fn Phonon::AbstractMediaStream::AbstractMediaStream(QObject *parent = 0)
\internal
Constructs an AbstractMediaStream object with the given \a parent.
*/
/*!
\fn qint64 Phonon::AbstractMediaStream::streamSize() const
Returns the stream size that was set with setStreamSize().
A negative value means that the length of the stream cannot be known.
Defaults to 0.
\sa setStreamSize()
*/
/*!
\fn void Phonon::AbstractMediaStream::setStreamSize(qint64 size)
Sets the \a size of the stream in number of bytes.
A negative value means that the length of the stream cannot be known.
Defaults to 0.
This function has to be called. A backend will not call needData()
until the stream size is set.
\sa streamSize()
*/
/*!
\fn bool Phonon::AbstractMediaStream::streamSeekable() const
Returns whether your data stream is set as seekable.
Defaults to \c false.
\sa setStreamSeekable()
*/
/*!
\fn void Phonon::AbstractMediaStream::setStreamSeekable(bool s)
Sets whether your data stream is seekable. \a s should be true if
the stream is seekable; otherwise false.
Defaults to \c false.
If you set this to \c true you have to implement the seekStream()
function.
\sa streamSeekable()
*/
/*!
\fn void Phonon::AbstractMediaStream::writeData(const QByteArray &data)
Sends the media \a data to the backend for decoding.
Use this function to send data to the backend after needData() has
been called.
If your stream is a push stream, data should be written until the
enoughData() function is called. For a pull stream, write data
once before the call to needData() function returns.
If the data is depleted, call endOfData() instead of writeData().
\warning Don't call this function before the first needData() is emitted.
\sa needData(), endOfData()
*/
/*!
\fn void Phonon::AbstractMediaStream::endOfData()
Tells the backend that the media data stream is at its end.
\warning Don't call this function before the first needData() is emitted.
\sa writeData(), needData()
*/
/*!
\fn void Phonon::AbstractMediaStream::error(Phonon::ErrorType errorType, const QString &errorString)
If an I/O error occurs you should call this function to make
MediaObject go into ErrorState. \c errorType classifies the error,
while \a errorString is a textual description of the error suitable
for users of Phonon applications.
\sa MediaObject::errorType(), MediaObject::errorString()
*/
/*!
\fn virtual void Phonon::AbstractMediaStream::reset() = 0
Reimplement this function to reset the stream. Subsequent calls to writeData should start
from the first position of the data unless a seek is requested.
The function is necessary for the case where a non-seekable MediaStream is
played more than once. For a seekable stream the implementation can simply call
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 2
\sa writeData(), needData()
*/
/*!
\fn virtual void Phonon::AbstractMediaStream::needData() = 0
Reimplement this function to be notified when the backend needs data.
When this function is called you should write data to the backend
(See writeData()).
\sa writeData(), endOfData(), enoughData()
*/
/*!
\fn virtual void Phonon::AbstractMediaStream::enoughData()
If your stream is a push stream, reimplement this function to be
notified when the backend has enough data and your stream object
may take a break.
This method is important for pushing data to the backend in order
to not fill the backend buffer unnecessarily.
\sa needData()
*/
/*!
\fn virtual void Phonon::AbstractMediaStream::seekStream(qint64 offset)
Reimplement this function if your stream is seekable.
When this function is called the next call to writeData has to be at the
requested \a offset.
\warning Do not call the parent implementation.
\sa setStreamSeekable(), streamSeekable(), needData()
*/
/*!
\class Phonon::BackendInterface
\inmodule Phonon
\since 4.4
\brief Main Backend class interface
\internal
This interface defines the main factory of the backend. The createObject() function creates all the
objects needed by the frontend.
The objectDescriptionIndexes and objectDescriptionProperties functions return information about
available devices, effects and codecs.
An implementation could look like this:
\snippet snippets/phonon/samplebackend/main.cpp snippet
*/
/*!
\fn virtual Phonon::BackendInterface::~BackendInterface()
\internal
Silence gcc's warning.
*/
/*!
\enum Phonon::BackendInterface::Class
\internal
Classes that the createObject() function has to handle.
\value MediaObjectClass Request to return a \c MediaObject object.
\value VolumeFaderEffectClass Request to return a \c VolumeFaderEffect
object.
\value AudioOutputClass Request to return an \c AudioOutput object.
\value AudioDataOutputClass Request to return an \c AudioDataOutput object.
\value VisualizationClass Request to return a \c Visualization object.
\value VideoDataOutputClass Request to return a \c VideoDataOutput object.
\value EffectClass Request to return a \c Effect object.
Takes an additional int that specifies the effect ID.
\value VideoWidgetClass Request to return a \c VideoWidget object.
*/
/*!
\fn virtual QObject *Phonon::BackendInterface::createObject(Class c, QObject *parent, const QList<QVariant> &args = QList<QVariant>()) = 0
\internal
Returns a new instance of the requested class.
\param c The requested class.
\param parent The parent object.
\param args Additional arguments (documented in Class).
*/
/*!
\fn virtual QList<int> Phonon::BackendInterface::objectDescriptionIndexes(ObjectDescriptionType type) const = 0
\internal
Returns the unique identifiers for the devices/effects/codecs of the given \a type.
\param type see ObjectDescriptionType
*/
/*!
\fn virtual QHash<QByteArray, QVariant> Phonon::BackendInterface::objectDescriptionProperties(ObjectDescriptionType type, int index) const = 0
\internal
Given a unique identifier that was returned from objectDescriptionIndexes this function
returns a hash mapping property names to values.
The property "name" must always be present. All other properties are optional.
\table
\header \o Property \o Description
\row \o name \o The name of the device/effect/codec/...
\row \o description \o A text explaining what this device/effect/codec/... is/can do
\row \o icon \o An icon name (using the freedesktop naming scheme) or a QIcon for this
device/effect/codec/...
\row \o available \o A bool telling whether the device is present or unplugged.
\endtable
\param type see ObjectDescriptionType
\param index The unique identifier that is returned from objectDescriptionIndexes
*/
/*!
\fn virtual bool Phonon::BackendInterface::startConnectionChange(QSet<QObject *>) = 0;
\internal
When this function is called the nodes given in the parameter list should
not lose any signal data when connections are changed.
*/
/*!
\fn virtual bool Phonon::BackendInterface::connectNodes(QObject *, QObject *) = 0
\internal
Defines a signal connection between the two given nodes.
*/
/*!
\fn virtual bool Phonon::BackendInterface::disconnectNodes(QObject *, QObject *) = 0
\internal
Cuts a signal connection between the two given nodes.
*/
/*!
\fn virtual bool Phonon::BackendInterface::endConnectionChange(QSet<QObject *>) = 0
\internal
When this function is called the nodes given in the parameter list may lose
signal data when a port is not connected.
*/
/*!
\fn virtual QStringList Phonon::BackendInterface::availableMimeTypes() const = 0
\internal
Returns all available MIME types.
*/
/*!
\class Phonon::MediaSource
\inmodule Phonon
\inheaderfile Phonon/MediaSource
\since 4.4
\brief The MediaSource class provides multimedia data for media objects.
The MediaSource class manages a source of multimedia content, such
as a music or video file, of which data is given to a
\l{Phonon::}{MediaObject}.
The media source knows how fetch its data from several sources,
e.g., from files, a QIODevice, or a CD. The possible source types
are described by the \l{MediaSource::}{Type} enum. The type of the
source is set by the media source itself, and is dependent on the
constructor used to create it. Note that it is possible to provide
data from any source by implementing a QIODevice.
The class has several functions to acquire information about the
source it manages, e.g., fileName() and url(). The return from
these functions are dependent on the type() of the media source.
Normally, a programmer does not need to be concerned with media
sources. It's constructors are implicit, so one can, for instance,
send an URL or filename directly to the constructors of the
\l{Phonon::}{MediaObject}.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 3
A MediaSource object cannot be reused for another multimedia
source. It is possible to play the same source again, and also
stop and start a non-seekable media source, such as a radio
stream, with the same MediaSource object.
\section1 Qt Backends
Currently, Qt's backends support files in local and remote
locations. Support for other sources, such as CD/DVD, are planned
for the future.
\sa MediaObject, {Phonon Module}
*/
/*!
\enum Phonon::MediaSource::Type
Identifies the type of media described by the MediaSource object.
\value Invalid The MediaSource object does not describe any valid source.
\value LocalFile The MediaSource object describes a local file.
\value Url The MediaSource object describes an URL, which can be either a
local file or a file on the network.
\value Disc The MediaSource object describes a disc, e.g., a CD.
\value Stream The MediaSource object describes a data stream.
This is the type used for \l{QIODevice}s. Note
that a stream opened with a QUrl, will still be of the Url type.
\value Empty The media source doesn't have a source.
\sa MediaSource::type()
*/
/*!
\fn Phonon::MediaSource::MediaSource()
\internal
Creates an invalid MediaSource object.
\sa Invalid
*/
/*!
\fn Phonon::MediaSource::MediaSource(const QString &fileName)
Creates a MediaSource object for the file specified by \a
fileName. You can also use this constructor with \l{The Qt
Resource System}{Qt resources}
\omit
\param fileName file name of a local media file or a Qt resource that was compiled in.
\endomit
*/
/*!
\fn Phonon::MediaSource::MediaSource(const QUrl &url)
Creates a MediaSource object for a the URL specified by \a url.
If the multimedia content you would like to play back is on a
remote network location, you should use this constructor; though,
it also possible to specify an URL to a local file.
\sa QUrl
*/
/*!
\fn Phonon::MediaSource::MediaSource(Phonon::DiscType discType, const QString &deviceName = QString())
Creates a MediaSource object for the type of disc specified by \a discType in the named
device referred to by \a deviceName.
\note \a deviceName is a platform dependent device name. It can be useful to specify this
if the computer has more than one CD drive. On KDE, it is recommended to use the Solid
hardware discovery framework to retrieve the device name in a portable way.
*/
/*!
\fn Phonon::MediaSource::MediaSource(AbstractMediaStream *stream)
\internal
Creates a MediaSource object for a data stream.
Your application can provide the media data by subclassing AbstractMediaStream and
passing a pointer to that object. Phonon will never delete the \a stream.
\param stream The AbstractMediaStream subclass to provide the media data.
\sa setAutoDelete
*/
/*!
\fn Phonon::MediaSource::MediaSource(QIODevice *ioDevice)
Creates a MediaSource object for the QIODevice specified by \a ioDevice.
This constructor can be very handy in the combination of
QByteArray and QBuffer.
If you need to fetch multimedia data from a source that is not
supported by MediaSource, you should subclass QIODevice and use
this MediaSource constructor. It is important that you reimplement
QIODevice::isSequential(), as it is used by MediaSource to
determine if the media source is seekable.
\a ioDevice is an arbitrary readable QIODevice subclass. If the device is not opened
MediaSource will open it as QIODevice::ReadOnly.
\note Sequential devices can also be used, but MediaObject::isSeekable() will
return false as a result.
\warning On Windows, we only support \l{QIODevice}s containing the
\c avi, \c mp3, or \c mpg formats. Use the constructor that takes
a file name to open files (the Qt backend does not use a QFile
internally).
\sa setAutoDelete()
*/
/*!
\fn Phonon::MediaSource::MediaSource(MediaSourcePrivate &)
\internal
*/
/*!
\fn Phonon::MediaSource::~MediaSource()
Destroys the MediaSource object. You should never delete a
MediaSource yourself, the MediaObject will handle this.
*/
/*!
\fn Phonon::MediaSource::MediaSource(const MediaSource &other)
Constructs a copy of the \a other media source.
This constructor is fast thanks to explicit sharing.
*/
/*!
\fn MediaSource &Phonon::MediaSource::operator=(const MediaSource &other)
Assigns the \a other media source to this media source and returns a
reference to it.
This operation is fast thanks to explicit sharing.
*/
/*!
\fn bool Phonon::MediaSource::operator==(const MediaSource &other) const
Returns true if this media source is equal to the \a other media source;
otherwise returns false.
*/
/*!
\fn void Phonon::MediaSource::setAutoDelete(bool enable)
If \a enable is true, the media source will take ownership of the
object passed in the \l{Phonon::}{MediaSource}'s constructor
object that was passed in the constructor; otherwise, the
programmer is responsible for deletion of this object.
This setting is false by default. If you enable it, you should
only access the stream or device as long as you keep the media
source object around. As long as you keep the media source
wrapping the stream or device, the object will not get deleted.
\sa autoDelete()
*/
/*!
\fn bool Phonon::MediaSource::autoDelete() const
Returns the setting of the auto-delete option. The default is
false.
\sa setAutoDelete()
*/
/*!
\fn Type Phonon::MediaSource::type() const
Returns the type of the MediaSource (depends on the constructor
that was used).
\sa Type
*/
/*!
\fn QString Phonon::MediaSource::fileName() const
Returns the file name of the MediaSource if type() ==
LocalFile; otherwise, returns QString().
\sa type()
*/
/*!
\fn QUrl Phonon::MediaSource::url() const
Returns the URL of the MediaSource if type() == URL or type() == LocalFile;
otherwise returns QUrl().
\sa type()
*/
/*!
\fn Phonon::DiscType Phonon::MediaSource::discType() const
Returns the disc type of the MediaSource if type() == Disc; otherwise
returns NoDisc.
\sa type()
*/
/*!
\fn QString Phonon::MediaSource::deviceName() const
Returns the device name of the MediaSource if type() == Disc; otherwise
returns QString().
\sa type()
*/
/*!
\fn AbstractMediaStream *Phonon::MediaSource::stream() const
\internal
Returns the media stream of the MediaSource if type() == Stream; otherwise
returns 0.
QIODevices are handled as streams, too.
*/
/*!
\class Phonon::MediaSourcePrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::SeekSlider
\inmodule Phonon
\inheaderfile Phonon/SeekSlider
\since 4.4
\brief The SeekSlider class provides a slider for seeking to positions in media streams.
The SeekSlider connects to a \l{Phonon::}{MediaObject}, and
controls the seek position in the object's media stream.
The slider will connect to the necessary signals to keep track of
the sliders maximum, minimum, and current values. It will also
disable itself for non-seekable streams, and update the media
object when the current value of the slider changes.
Here follows a typical example of SeekSlider usage:
\snippet doc/src/snippets/seekslider.cpp 0
\sa Phonon::VolumeSlider, Phonon::VideoWidget, {Music Player Example}, {Phonon Module}
*/
/*!
\property Phonon::SeekSlider::iconVisible
\brief whether the icon next to the slider is visible
By default the icon is visible if the platform provides an icon; else
it's hidden.
*/
/*!
\property Phonon::SeekSlider::tracking
\brief whether slider tracking is enabled
If tracking is enabled (the default), the media seeks
while the slider is being dragged. If tracking is
disabled, the media seeks only when the user
releases the slider.
*/
/*!
\property Phonon::SeekSlider::pageStep
\brief the page step interval
The larger of two natural steps that a slider provides and
typically corresponds to the user pressing PageUp or PageDown.
Defaults to 5 seconds.
*/
/*!
\property Phonon::SeekSlider::singleStep
\brief the single step interval
The smaller of two natural steps that a slider provides and
typically corresponds to the user pressing an arrow key.
Defaults to 0.5 seconds.
*/
/*!
\property Phonon::SeekSlider::orientation
\brief the orientation of the slider
The orientation must be Qt::Vertical or Qt::Horizontal (the default).
*/
/*!
\property Phonon::SeekSlider::iconSize
\brief the icon size used for the mute button/icon.
The default size is defined by the GUI style.
*/
/*!
\fn explicit Phonon::SeekSlider::SeekSlider(QWidget *parent = 0)
Constructs a seek slider widget with the given \a parent.
*/
/*!
\fn explicit Phonon::SeekSlider::SeekSlider(MediaObject *media, QWidget *parent = 0)
Constructs a seek slider widget for the specified \a media with the
given \a parent.
*/
/*!
\fn Phonon::SeekSlider::~SeekSlider()
Destroys the seek slider.
*/
/*!
\fn Phonon::MediaObject *Phonon::SeekSlider::mediaObject() const
Return the media object this SeekSlider controls.
*/
/*!
\class Phonon::SeekSliderPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn void Phonon::SeekSlider::setMediaObject(MediaObject *media)
Sets the media object to be controlled by this slider to the \a media specified.
*/
/*!
\class Phonon::VideoPlayer
\inmodule Phonon
\inheaderfile Phonon/VideoPlayer
\since 4.4
\brief The VideoPlayer widget is used to perform playback of video.
With VideoPlayer you can get results quickly and easily. You can
do the standard playback tasks like play(), pause(), and stop(),
but also set a playback volume and seek - if the media and backend
supports seeking.
VideoPlayer is provided for convenience and removes the need to
create a media graph with a \l{Phonon::}{MediaObject},
\l{Phonon::}{AudioOutput}, and \l{Phonon::}{VideoWidget}. If
you need functionality not supported by the player, you can build
this \l{Building Graphs}{graph} yourself.
Keep in mind that when the VideoPlayer instance is deleted the
playback will stop.
Note also that most of the functions in this class are
asynchronous. For instance, a media source may not play
immediately after you call the play() function.
A play and forget code example:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 4
\sa {Phonon Module}, MediaObject
*/
/*!
\fn Phonon::VideoPlayer::VideoPlayer(QWidget *parent = 0)
Constructs a new video widget with a \a parent using
Phonon::VideoCategory as its category.
\param parent The QObject parent.
*/
/*!
\fn Phonon::VideoPlayer::VideoPlayer(Phonon::Category category, QWidget *parent = 0)
Constructs a new VideoPlayer instance with the specified \a
parent.
\a category is the category used for the audio output device.
*/
/*!
\fn Phonon::VideoPlayer::~VideoPlayer()
On destruction the playback is stopped, also the audio output is
removed so that the desktop mixer will not show the application
anymore. If you need a persistent audio output don't use
VideoPlayer but MediaObject, VideoPath and VideoOutput.
*/
/*!
\fn qint64 Phonon::VideoPlayer::totalTime() const
Get the total time (in milliseconds) of the file currently being played.
*/
/*!
\fn qint64 Phonon::VideoPlayer::currentTime() const
Get the current time (in milliseconds) of the file currently being played.
*/
/*!
\fn float Phonon::VideoPlayer::volume() const
This is the current volume of the output as voltage factor.
1.0 means 100%, 0.5 means 50% voltage/25% power, 0.0 means 0%
*/
/*!
\fn bool Phonon::VideoPlayer::isPlaying() const
Returns true if it is currently playing; otherwise returns false if it
is currently stopped or paused
*/
/*!
\fn bool Phonon::VideoPlayer::isPaused() const
Returns true if it is currently paused; otherwise returns false if it
is currently playing or stopped.
*/
/*!
\fn void Phonon::VideoPlayer::load(const Phonon::MediaSource &source)
Starts pre-loading the media data from the specified \a source and
filling audio buffers in the backend.
When there's already a media playing (or paused) it will be stopped
(the finished signal will not be emitted).
\sa MediaObject::setCurrentSource()
*/
/*!
\fn void Phonon::VideoPlayer::play(const Phonon::MediaSource &source)
Plays the media from the given \a source. Starts playback as fast as
possible.
This can take a considerable time depending on the URL and the
backend.
If you need low latency between calling play() and the sound actually
starting to play on your output device you need to use MediaObject
and be able to set the URL before calling play(). Note that
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 5
doesn't make a difference: the application should be idle between the
load and play calls so that the backend can start preloading the
media and fill audio buffers.
*/
/*!
\fn void Phonon::VideoPlayer::play()
Continues playback of paused media. Restarts playback of a stopped
(or newly loaded) media.
\sa MediaObject::play(), play()
*/
/*!
\fn void Phonon::VideoPlayer::pause()
Pauses the playback.
\sa MediaObject::pause()
*/
/*!
\fn void Phonon::VideoPlayer::stop()
Stops the playback.
\sa MediaObject::stop()
*/
/*!
\fn void Phonon::VideoPlayer::seek(qint64 ms)
Seeks to the requested time. Note that the backend is free to
ignore the seek request if the media source isn't seekable; you
can check this by asking the media object of the VideoPlayer.
\snippet doc/src/snippets/videomedia.cpp 0
The \a ms parameter is the time in milliseconds from the start of
the media.
The call is asynchronous, so currentTime() can still be the old
value right after this method was called. If all you need is a
slider that shows the current position and allows the user to
seek, use the class SeekSlider.
\sa MediaObject::seek(), MediaObject::isSeekable(), mediaObject()
*/
/*!
\fn void Phonon::VideoPlayer::setVolume(float volume)
Sets the \a volume of the output as voltage factor.
1.0 means 100%, 0.5 means 50% voltage/25% power, 0.0 means 0%
*/
/*!
\fn MediaObject *Phonon::VideoPlayer::mediaObject() const
Returns the media object being used by the player.
The media object can be accessed directly instead of using the
\l{VideoPlayer}s convenience functions, e.g., play() and stop().
It is also possible to give the object to other Phonon widgets,
e.g., a \l{Phonon::}{SeekSlider} or a \l{Phonon::}{VolumeSlider}.
\sa Phonon::SeekSlider, Phonon::MediaObject
*/
/*!
\fn AudioOutput *Phonon::VideoPlayer::audioOutput() const
Returns the audio output object being used by the player.
*/
/*!
\fn VideoWidget *Phonon::VideoPlayer::videoWidget() const
Returns the video widget being used by the player.
*/
/*!
\fn void Phonon::VideoPlayer::finished()
This signal is emitted when the playback finished.
*/
/*!
\class Phonon::VideoWidgetPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::MediaObject
\inmodule Phonon
\inheaderfile Phonon/MediaObject
\since 4.4
\brief The MediaObject class provides an interface for media playback.
The media object manages a \l{Phonon::}{MediaSource}, which
supplies the media object with multimedia content, e.g., from a
file. A playback in Phonon is always started by calling the
\l{Phonon::MediaObject::}{play()} function.
The state of play (play, pause, stop, seek) is controlled by the
media object, and you can also query the current
\l{Phonon::MediaObject::}{state()}. It keeps track of the playback
position in the media stream, and emits the
\l{Phonon::MediaObject::}{tick()} signal when the current position
in the stream changes.
Notice that most functions of this class are asynchronous, so you
cannot rely on that a state is entered after a function call
before you receive the \l{Phonon::MediaObject::}{stateChanged()}
signal. The description of the \l{Phonon::}{State} enum gives a
description of the different states.
Before play() is called, the media object should be connected to
\l{Sinks}{output nodes}, which outputs the media to the
underlying hardware. The output nodes required are dependent on
the contents of the multimedia file that is played back. Phonon
has currently two output nodes: the \l{Phonon::}{AudioOutput} for
audio content and \l{Phonon::}{VideoWidget} for video content. If
a \l{Phonon::}{MediaSource} contains both audio and video, both
nodes need to be connected to the media object.
\snippet snippets/phonon.cpp 4
\snippet snippets/phonon.cpp 5
The media object can queue sources for playback. When it has
finished to play one source, it will start playing the next in the
queue; the new source is then removed from the queue. The
queue can be altered at any time.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 7
You can also make use of the
\l{Phonon::MediaObject::}{aboutToFinish()} signal, which is
guaranteed to be emitted in time for altering the queue.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 8
When playback is finishing, i.e., when a media source has been
played to the end and the queue is empty, several signals are
emitted. First, the media object will emit aboutToFinish() -
shortly before the playback has finished - and then finished().
The stateChanged() signal will also be emitted with
\l{Phonon::}{PausedState}, which is the state the media object
takes when the playback is finished. If you wish to enter another
state, you can connect a slot to finished() and set a new state
there.
The media object resolves the meta information, such as title,
artist, and album. The meta data is not resolved immediately after
a new source is provided, but will be resolved before the object
leaves the \l{Phonon::}{LoadingState}. The data is queried by
string keys - which should follow the Ogg Vorbis specification
\l http://xiph.org/vorbis/doc/v-comment.html - or by using the
\l{Phonon::}{MetaData} enum. The data available will depend on the
type and content of the individual media files. metaDataChanged()
will be emitted when the media object has resolved new meta data.
Errors encountered during playback and loading of media sources
are reported by emitting a state changed signal with
\l{Phonon::}{ErrorState}. The severity of the error can be queried
by the \l{Phonon::}{ErrorType}. With a \l{Phonon::}{NormalError},
it might be possible to continue the playback, for instance, if
only audio playback fails for a media source which also has video.
A \l{Phonon::}{FatalError} indicates that Phonon cannot continue
playback of the current source, but it is possible to try with a
different one. A user readable error message is given by
errorString().
\section1 Symbian Platform Security Requirements
On Symbian, processes which access media via the network must
have the \c NetworkServices platform security capability. If the client
process lacks this capability, operations will result in errors.
This failure is indicated by a state() of Phonon::ErrorState.
Platform security capabilities are added via the
\l{qmake-variable-reference.html#target-capability}{TARGET.CAPABILITY}
qmake variable.
\sa Phonon::MediaSource, Phonon::AudioOutput, VideoWidget,
{Music Player Example}, {Phonon Overview}, Phonon::VideoPlayer,
Phonon::createPlayer(), {Phonon Module}
*/
/*!
\property Phonon::MediaObject::transitionTime
\brief Defines the time between playback of two media sources
in the media queue.
A positive transition time defines a gap of silence between queued
media sources.
A transition time of 0 ms requests gapless playback (i.e., the
next source in the media queue starts immediately after the
playback of the current source finishes).
A negative transition time defines a crossfade between the queued
media sources.
Defaults to 0 (gapless playback).
\warning This feature might not work reliably with every
backend.
*/
/*!
\property Phonon::MediaObject::prefinishMark
\brief the time when the prefinishMarkReached signal is emitted before playback ends.
This property specifies the time in milliseconds the
prefinishMarkReached() signal is emitted before the playback
finishes. A value of \c 0 disables the signal. The signal is only
emitted for the last source in the \l{queue()}{media queue}.
Defaults to \c 0 (disabled).
\warning For some media data the total time cannot be determined
accurately, therefore the accuracy of the prefinishMarkReached signal
can be bad sometimes. Still, it is better to use this method than to
look at totalTime() and currentTime() to emulate the behavior
because the backend might have more information available than your
application does through totalTime() and currentTime().
\sa prefinishMarkReached()
*/
/*!
\property Phonon::MediaObject::tickInterval
\brief The time interval in milliseconds between two ticks.
The tick() signal is emitted continuously during playback.
The tick interval is the time that elapses between the emission of two tick signals.
If you set the interval to \c 0 the tick signal gets disabled.
The tick() signal can, for instance, be used to update widgets
that show the current position in the playback of a media source.
Defaults to \c 0 (disabled).
\warning The back-end is free to choose a different tick interval close
to what you asked for. This means that the following code \c may fail:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 9
On the other hand the following is guaranteed:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 10
\sa tick()
*/
/*!
\fn Phonon::MediaObject::~MediaObject()
Destroys the MediaObject.
*/
/*!
\fn State Phonon::MediaObject::state() const
Returns the current Phonon::State of the object.
\sa Phonon::State, stateChanged()
*/
/*!
\fn bool Phonon::MediaObject::hasVideo() const
Check whether the current media source includes a video stream.
\warning This information is not resolved immediately after a
media object gets a new source. Listen to the hasVideoChanged()
signal instead.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 11
Returns \c true if the media contains video data; otherwise,
returns \c false.
\sa hasVideoChanged()
*/
/*!
\fn bool Phonon::MediaObject::isSeekable() const
Check whether it is possible to seek, i.e., change the
playback position in the media stream.
\warning This information is not solved immediately after the
media object gets a new media source. The hasVideoChanged() signal
is emitted after this information is available.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 12
Returns \c true if the current media may be seeked; otherwise,
returns \c false.
\sa seekableChanged()
*/
/*!
\fn QStringList Phonon::MediaObject::metaData(const QString &key) const
Returns the strings associated with the given \a key.
Backends should use the keys specified in the Ogg Vorbis
documentation: \l http://xiph.org/vorbis/doc/v-comment.html
Therefore the following should work with every backend:
Note that meta data is not resolved before the \c
metaDataChanged() signal is emitted.
A typical usage looks like this:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 13
*/
/*!
\fn QStringList Phonon::MediaObject::metaData(Phonon::MetaData key) const
Returns the strings associated with the given \a key.
Same as above except that the keys are defined in the
Phonon::MetaData enum.
\sa metaDataChanged()
*/
/*!
\fn QMultiMap<QString, QString> Phonon::MediaObject::metaData() const
Returns all meta data in a multi map.
\sa metaDataChanged()
*/
/*!
\fn QString Phonon::MediaObject::errorString() const
Returns a human-readable description of the last error that occurred.
The strings given may vary between backends.
The error description can be used to give a message to the user -
and the developer - when the stateChanged() signal is emitted with
\l{Phonon::}{ErrorState}.
\section1 Qt Backends
On Windows, Qt fetches its error messages from the DirectShow
backend. This usually includes an error number, which can be
looked up in the DirectShow documentation:
\l{http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dx81_c/directx_cpp/htm/errorandsuccesscodes.asp}.
On Linux and Mac, the error strings are not fetched directly from
the backend, but are created in the backend.
\sa Phonon::ErrorState, stateChanged()
*/
/*!
\fn ErrorType Phonon::MediaObject::errorType() const
Tells your program what to do about the last error that occurred.
Use this function after receiving a stateChanged() signal with
\l{Phonon::}{ErrorState}.
\sa Phonon::ErrorType, Phonon::ErrorState, stateChanged()
*/
/*!
\fn MediaSource Phonon::MediaObject::currentSource() const
Returns the current media source, i.e., the media source that is
being played back. The current source is either set with
setCurrentSource() or taken from the media queue() when a media
source has finished playing.
\sa setCurrentSource()
*/
/*!
\fn void Phonon::MediaObject::setCurrentSource(const MediaSource &source)
Set the media source the MediaObject should use.
After the media object receives a new source, it will enter the
\l{Phonon::}{LoadingState}. When it is ready to play, it
enters the \l{Phonon::}{StoppedState} unless another state
has been requested, e.g., by calling play().
\a source is the MediaSource object to the media data. You can
just as well use a QUrl or QString (for a local file) here.
We show an example:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 14
\sa currentSource(), MediaSource
*/
/*!
\fn QList<MediaSource> Phonon::MediaObject::queue() const
Returns the queued media sources.
This does list does not include the current source,
returned by currentSource().
\sa enqueue()
*/
/*!
\fn void Phonon::MediaObject::setQueue(const QList<MediaSource> &sources)
Set the \a sources to play when the current source has finished.
This function will overwrite the current queue.
\sa clearQueue(), enqueue()
*/
/*!
\fn void Phonon::MediaObject::setQueue(const QList<QUrl> &urls)
Set the \a urls to play when the current media has finished.
This function overwrites the current queue.
\sa clearQueue(), enqueue()
*/
/*!
\fn void Phonon::MediaObject::enqueue(const MediaSource &source)
Appends \a source to the queue.
You can use this function to provide the next source after the
aboutToFinish() signal has been emitted.
\sa aboutToFinish(), setQueue(), clearQueue()
*/
/*!
\fn void Phonon::MediaObject::enqueue(const QList<MediaSource> &sources)
Appends multiple \a sources to the queue.
\sa setQueue(), clearQueue()
*/
/*!
\fn void Phonon::MediaObject::enqueue(const QList<QUrl> &urls)
Appends the URLs in \a urls to the media source queue.
The function will create \l{MediaSource}s from the \l{QUrl}s, and
append these to the queue.
\sa setQueue(), clearQueue()
*/
/*!
\fn void Phonon::MediaObject::clearQueue()
Clears the queue of media sources.
\sa queue(), enqueue()
*/
/*!
\fn qint64 Phonon::MediaObject::currentTime() const
Returns the current time (in milliseconds), i.e., position in the
media stream, of the file currently being played.
\sa tick(), totalTime(), remainingTime()
*/
/*!
\fn qint64 Phonon::MediaObject::totalTime() const
Get the total time (in milliseconds) of the file currently being played.
Returns the total time in milliseconds.
\warning The total time is not defined before the media object
enters the \l{Phonon::}{LoadingState}.
\sa totalTimeChanged()
*/
/*!
\fn qint64 Phonon::MediaObject::remainingTime() const
Get the remaining time (in milliseconds) of the file currently being played.
Returns the remaining time in milliseconds.
\sa totalTime(), currentTime(), totalTimeChanged()
*/
/*!
\fn void Phonon::MediaObject::play()
Requests playback of the media data to start.
Playback starts when the stateChanged() signal is emitted with
\l{Phonon::}{PlayingState}.
If the media object is already in a
\l{Phonon::}{PlayingState}, nothing happens.
\sa stop(), pause(), stateChanged()
*/
/*!
\fn void Phonon::MediaObject::pause()
Requests playback to pause, and the media object to enter the
\l{Phonon::}{PausedState}. If it was paused already, nothing
changes.
This function is asynchronous and the media might not be paused
immediately.
\sa play(), stop(), stateChanged()
*/
/*!
\fn void Phonon::MediaObject::stop()
Requests playback to stop, and the media object to enter the
\l{Phonon::}{StoppedState}. If it was stopped before
nothing changes.
This function is asynchronous and the media might not be
stopped immediately.
\sa play(), pause(), stateChanged()
*/
/*!
\fn void Phonon::MediaObject::seek(qint64 time)
Requests a seek to the \a time indicated, specified in milliseconds.
You can only seek if state() is PlayingState, BufferingState or PausedState.
The call is asynchronous, so currentTime can still be the old
value right after this method was called. If all you need is a
slider that shows the current position and allows the user to
seek, use the class SeekSlider.
If the current source of the media object is not seekable, calls
to this functions do nothing.
\sa SeekSlider, tick()
*/
/*!
\fn void Phonon::MediaObject::clear()
Stops and removes all playing and enqueued media sources.
\sa setCurrentSource()
*/
/*!
\fn void Phonon::MediaObject::stateChanged(Phonon::State newstate, Phonon::State oldstate)
This signal is emitted when the state of the MediaObject has changed.
The \a oldstate and \a newstate parameters indicate the previous
state and current state of the media object.
If you are only interested in the new state of the media object, you can
connect this signal to a slot that accepts only one State argument.
*/
/*!
\fn void Phonon::MediaObject::tick(qint64 time)
This signal is emitted in intervals defined by the
\l{tickInterval} property. The current position of the media
object in the stream is given by the \a time parameter. The \a
time is specified in milliseconds.
\sa tickInterval
*/
/*!
\fn void Phonon::MediaObject::metaDataChanged()
This signal is emitted when the media object has resolved new meta
data. This will happen before the media object leaves the
\l{Phonon::}{LoadingState} after a new source has been set.
This signal is not emitted when the media object removes the
current data, i.e., when a new source is set or an error has
occurred. If you need to know this, you can listen for the
\l{Phonon::}{ErrorState}, and connect to the
\l{Phonon::MediaObject::}{currentSourceChanged()} signal.
You can get the new meta data with the metaData methods.
\sa metaData(), currentSourceChanged(), stateChanged(), Phonon::State
*/
/*!
\fn void Phonon::MediaObject::seekableChanged(bool isSeekable)
This signal is emitted when the media object's ability to seek in
the media stream changes. \a isSeekable is true if it is possible
to seek(); otherwise, it is false.
Change in the ability to seek in the stream usually happens when
the current source changes or when an error occurs.
\omit Emitted whenever the return value of isSeekable()
changes. \endomit
Normally you'll check isSeekable() after setting a new media
source, and then let this signal tell you when seeking is
possible. That way you don't have to poll isSeekable().
*/
/*!
\fn void Phonon::MediaObject::hasVideoChanged(bool hasVideo)
Emitted whenever the return value of hasVideo() changes, i.e.,
the media source being played back contains video.
Normally you'll check hasVideo() first and then let this signal
tell you whether video is available now or not. That way you
don't have to poll hasVideo().
\a hasVideo is true when the stream contains video and adding a
VideoWidget will show a video, and false if there is no video data
in the stream and adding a VideoWidget will show an empty (black)
VideoWidget.
*/
/*!
\fn void Phonon::MediaObject::bufferStatus(int percentFilled)
Provides information about the status of the buffer.
When a MediaObject is in the \l{Phonon::}{BufferingState}, it will
send this signal regularly. \a percentFilled is a number between 0
and 100 telling you how much the buffer is filled.
You can use this signal to show a progress bar to the user when
in BufferingState:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 15
Note that the \l{Phonon::}{BufferingState} is commonly used when
waiting for data over a network connection, but this might not be
true for all backends.
*/
/*!
\fn void Phonon::MediaObject::finished()
Emitted when the object has finished playback. It is not emitted
if you call stop(), pause() or load(). It is emitted only when the
current media source has finished playing and the media queue() is
empty, or when a \l{Phonon::FatalError}{fatal error} occurs.
\warning This signal is not emitted when the current source has
finished and there's another source in the queue. It is only
emitted when the queue is empty.
\sa currentSourceChanged(), aboutToFinish(), prefinishMarkReached()
*/
/*!
\fn void Phonon::MediaObject::currentSourceChanged(const Phonon::MediaSource &newSource)
Emitted when the MediaObject fetches a new MediaSource from the
queue() and before it enters the \l{Phonon::}{LoadingState} for
the new source. The media object will take a new source from the
queue() when it has finished the playback of the
\l{currentSource()}{current source}.
\a newSource is the source that starts to play at the time the
signal is emitted.
*/
/*!
\fn void Phonon::MediaObject::aboutToFinish()
Emitted before the playback of the whole queue ends. When this
signal is emitted you still have time to enqueue() a new
MediaSource, so that playback continues.
If you need a signal to be emitted at a specific time before
playback is finished, you should use the prefinishMarkReached()
signal instead.
\sa enqueue(), prefinishMark, prefinishMarkReached()
*/
/*!
\fn void Phonon::MediaObject::prefinishMarkReached(qint32 msecToEnd)
Emitted when there are only \a msecToEnd milliseconds left
of playback.
\warning This signal is not emitted when there is another source
in the queue. It is only emitted when the queue is empty.
\sa setPrefinishMark(), prefinishMark(), aboutToFinish(), finished()
*/
/*!
\fn void Phonon::MediaObject::totalTimeChanged(qint64 newTotalTime)
This signal is emitted as soon as the total time of the media file is
known or has changed. For most non-local media data the total
time of the media can only be known after some time. At that time the
totalTime function can not return useful information. You have
to wait for this signal to know the real total time.
\a newTotalTime is the length of the media file in milliseconds.
\sa totalTime()
*/
/*!
\fn MediaObject *Phonon::createPlayer(Phonon::Category category, const MediaSource &source = MediaSource())
Convenience function to create a MediaObject and AudioOutput
connected by a path. The \l{Phonon::}{MediaObject} return will
have \a source set as its current source and the specified \a
category.
*/
/*!
\class Phonon::MediaObjectPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\namespace Phonon::BackendCapabilities
\inmodule Phonon
\since 4.4
\brief The BackendCapabilities namespace contains functions to describe the capabilities of the multimedia backend.
*/
/*!
\class Phonon::BackendCapabilitiesPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::BackendCapabilities::Notifier
\since 4.4
\inmodule Phonon
\inheaderfile Phonon/BackendCapabilities
Notifications about backend capabilities.
*/
/*!
\fn void Phonon::BackendCapabilities::Notifier::capabilitiesChanged()
This signal is emitted if the capabilities have changed. This can
happen if the user has requested a backend change.
*/
/*!
\fn void Phonon::BackendCapabilities::Notifier::availableAudioOutputDevicesChanged()
This signal is emitted when audio output devices were plugged or
unplugged.
Check BackendCapabilities::availableAudioOutputDevices to get the
current list of available devices.
*/
/*!
\fn Notifier *Phonon::BackendCapabilities::notifier()
Use this function to get a QObject pointer to connect to the capabilitiesChanged signal.
\return a pointer to a QObject.
The capabilitiesChanged signal is emitted if the capabilities have changed. This can
happen if the user has requested a backend change.
To connect to this signal do the following:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 16
\sa Notifier::capabilitiesChanged()
*/
/*!
\fn QStringList Phonon::BackendCapabilities::availableMimeTypes()
Returns a list of mime types that the Backend can decode.
\sa isMimeTypeAvailable()
*/
/*!
\fn bool Phonon::BackendCapabilities::isMimeTypeAvailable(const QString &mimeType)
Often all you want to know is whether one given MIME type can be
decoded by the backend. Use this method in favor of
availableMimeTypes() as it can give you a negative answer without
having a backend loaded.
Returns true if the given \a mimeType is supported by the backend;
otherwise, returns false.
\sa availableMimeTypes()
*/
/*!
\fn QList<AudioOutputDevice> Phonon::BackendCapabilities::availableAudioOutputDevices()
Returns the audio output devices the backend supports.
\return A list of AudioOutputDevice objects that give a name and
description for every supported audio output device.
*/
/*!
\fn QList<EffectDescription> Phonon::BackendCapabilities::availableAudioEffects()
Returns descriptions for the audio effects the backend supports.
\return A list of AudioEffectDescription objects that give a name and
description for every supported audio effect.
*/
/*!
\internal
\class ObjectDescriptionModelData
\internal
\inmodule Phonon
\brief Data class for models for ObjectDescription objects.
*/
/*!
\typedef Phonon::EffectDescription
\relates Phonon::ObjectDescription
EffectDescription gives a description of an \l{Processors}{audio
effect}. It is a typedef of the \l{Phonon::}{ObjectDescription}
class. Please see its class description for details.
EffectDescription is used to create audio \l{Phonon::}{Effect}s,
which can be inserted into a media graph, altering an audio
stream.
\sa Phonon::ObjectDescription, {Capabilities Example}, {Media
Player}
*/
/*!
\class Phonon::ObjectDescriptionModel
\inmodule Phonon
\internal
\since 4.4
\brief The ObjectDescriptionModel class provides a model from
a list of ObjectDescription objects.
ObjectDescriptionModel is a read only model that supplies a list
using ObjectDescription::name() for the text and
ObjectDescription::description() for the tooltip. If set the properties
"icon" and "available" are used to set the decoration and disable the
item (disabled only visually, you can still select and drag it).
It also provides the methods moveUp() and moveDown() to order the list.
Additionally drag and drop is possible so that
QAbstractItemView::InternalMove can be used.
The resulting order of the ObjectDescription::index() values can then be
retrieved using tupleIndexOrder().
An example use case would be to give the user a QComboBox to select
the output device:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 17
And to retrieve the selected AudioOutputDevice:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 18
*/
/*!
\fn inline int Phonon::ObjectDescriptionModel::rowCount(const QModelIndex &parent = QModelIndex()) const
Returns the number of rows in the model. This value corresponds
to the size of the list passed through setModelData.
\param parent The optional \a parent argument is used in most models to specify
the parent of the rows to be counted. Because this is a list if a
valid parent is specified the result will always be 0.
Reimplemented from QAbstractItemModel.
\sa QAbstractItemModel::rowCount()
*/
/*!
\fn inline QVariant Phonon::ObjectDescriptionModel::data(const QModelIndex &index, int role = Qt::DisplayRole) const
Returns data from the item with the given \a index for the specified
\a role.
If the view requests an invalid index, an invalid variant is
returned.
Reimplemented from QAbstractItemModel.
\sa QAbstractItemModel::data(), Qt::ItemDataRole
*/
/*!
\fn inline Qt::ItemFlags Phonon::ObjectDescriptionModel::flags(const QModelIndex &index) const
\internal
Reimplemented to show unavailable devices as disabled (but still
selectable). The \a index of the model index for which to return
flags.
*/
/*!
\fn inline QList<int> Phonon::ObjectDescriptionModel::tupleIndexOrder() const
Returns a list of indexes in the same order as they are in the
model. The indexes come from the ObjectDescription::index
method.
This is useful to let the user define a list of preference.
*/
/*!
\fn inline int Phonon::ObjectDescriptionModel::tupleIndexAtPositionIndex(int positionIndex) const
Returns the ObjectDescription::index for the tuple
at the given position \a positionIndex. For example a
QComboBox will give you the currentIndex as the
position in the list. But to select the according
AudioOutputDevice using AudioOutputDevice::fromIndex
you can use this method.
\param positionIndex The position in the list.
*/
/*!
\class Phonon::ObjectDescriptionModelDataPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn inline QMimeData *Phonon::ObjectDescriptionModel::mimeData(const QModelIndexList &indexes) const
\internal
Returns the MIME data that dropMimeData() can use to create new
items.
*/
/*!
\fn inline void Phonon::ObjectDescriptionModel::moveUp(const QModelIndex &index)
Moves the item at the given \a index up. In the resulting list
the items at index.row() and index.row() - 1 are swapped.
Connected views are updated automatically.
*/
/*!
\fn inline void Phonon::ObjectDescriptionModel::moveDown(const QModelIndex &index)
Moves the item at the given \a index down. In the resulting list
the items at index.row() and index.row() + 1 are swapped.
Connected views are updated automatically.
*/
/*!
\fn explicit inline Phonon::ObjectDescriptionModel::ObjectDescriptionModel(QObject *parent = 0)
Constructs a ObjectDescription model with the
given \a parent.
*/
/*!
\fn explicit inline Phonon::ObjectDescriptionModel::ObjectDescriptionModel(const QList<ObjectDescription<type> > &data, QObject *parent = 0)
Constructs a ObjectDescription model with the
given \a parent and the given \a data.
*/
/*!
\fn inline void Phonon::ObjectDescriptionModel::setModelData(const QList<ObjectDescription<type> > &data)
Sets the model data using the list provided by \a data.
All previous model data is cleared.
*/
/*!
\fn inline QList<ObjectDescription<type> > Phonon::ObjectDescriptionModel::modelData() const
Returns the model data.
As the order of the list might have changed this can be different
to what was set using setModelData().
*/
/*!
\fn inline ObjectDescription<type> Phonon::ObjectDescriptionModel::modelData(const QModelIndex &index) const
Returns one ObjectDescription of the model data for the given \a index.
*/
/*!
\fn inline Qt::DropActions Phonon::ObjectDescriptionModel::supportedDropActions() const
This model supports drag and drop to copy or move
items.
*/
/*!
\fn inline bool Phonon::ObjectDescriptionModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
Accept drops from other models of the same ObjectDescriptionType.
The \a data is dropped at the given \a row and \a column; you
also receive the \a parent model index.
If a valid \a parent is given the dropped items will be inserted
above that item.
*/
/*!
\fn inline bool Phonon::ObjectDescriptionModel::removeRows(int row, int count, const QModelIndex &parent = QModelIndex())
Removes count rows starting with the given row.
If a valid \a parent is given no rows are removed since this is a
list model.
Returns true if the rows were successfully removed; otherwise returns false.
*/
/*!
\fn inline QStringList Phonon::ObjectDescriptionModel::mimeTypes() const
Returns a list of supported drag and drop MIME types. Currently
it only supports one type used internally.
*/
/*!
\class Phonon::EffectInterface
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::Effect
\inmodule Phonon
\inheaderfile Phonon/Effect
\since 4.4
\brief The Effect class is used to transform audio streams.
An effect is a media node which is inserted into a path between a
\l{Phonon::}{MediaObject} and an audio output node, for instance,
an \l{Phonon::}{AudioOutput}. The Effect transforms the media
stream on that path.
Examples may include simple modifiers, such as fading or pitch
shifting, and more complex mathematical transformations. You can
query the backend for available effects with
BackendCapabilities::availableAudioEffects(). Note that the
effects available is dependent on the underlying system
(DirectDraw, GStreamer, or QuickTime).
In order to use an effect, insert it into the path as follows:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 19
The effect will immediately begin applying it's transformations on
the path. To stop it, remove the Effect from the path.
To create an effect, you use the \l{Phonon::}{EffectDescription}
class, which you get from
\l{BackendCapabilities::}{availableAudioEffects()}. We give a code
example below.
\snippet doc/src/snippets/audioeffects.cpp 0
An effect can have one or more parameters, which let you alter how
the effect works, for instance, by specifying the depth of a
reverb effect. See the EffectParameter class description for
details.
Phonon also provides EffectWidget, which lets the user modify the
parameters of an effect an the fly; e.g., with combo boxes.
\sa {Phonon Module}, EffectWidget
*/
/*!
\fn explicit Phonon::Effect::Effect(const EffectDescription &description, QObject *parent = 0)
Constructs a new effect object with the given \a description and \a parent object.
The EffectDescription object determines the type of the effect.
\sa {Phonon::BackendCapabilities::availableAudioEffects()}
*/
/*!
\fn Phonon::Effect::Effect(EffectPrivate &dd, QObject *parent)
\internal
*/
/*!
\fn Phonon::Effect::~Effect()
\internal
*/
/*!
\fn QVariant Phonon::Effect::parameterValue(const EffectParameter ¶meter) const
Returns the value of the given effect \a parameter. You can fetch
the available parameters for an effect with parameters().
\sa setParameterValue(), EffectParameter
*/
/*!
\fn void Phonon::Effect::setParameterValue(const EffectParameter ¶meter, const QVariant &value)
Sets the given effect \a parameter to the specified \a value.
Parameters for an effect are returned by parameters(). You can
check which QVariant::Type an EffectParameter takes with the
EffectParameter::type() function.
\sa parameterValue(), EffectParameter
*/
/*!
\fn EffectDescription Phonon::Effect::description() const;
Returns the description of this effect. This is the same
description that was passed to the constructor.
*/
/*!
\fn QList<EffectParameter> Phonon::Effect::parameters() const;
Returns a list of parameters that this effect provides to control
its behavior.
\sa EffectParameter, EffectWidget
*/
/*!
\class Phonon::EffectPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::AudioOutput
\inmodule Phonon
\inheaderfile Phonon/AudioOutput
\since 4.4
\brief The AudioOutput class is used to send data to audio output devices.
The AudioOutput class plays sound over a sound device. The audio
output needs to be connected to a \l{Phonon::}{MediaObject} using
\l{Phonon::}{createPath()}. To start playback, you call
\l{Phonon::MediaObject::}{play()} on the media object.
\snippet snippets/phonon.cpp 2
The class supports changing the volume(). It is also possible to
mute the sound.
To find out what \l{Phonon::}{AudioOutputDevice}s are available
for AudioOutput, you can call
BackendCapabilities::availableAudioOutputDevices(). A default device is
selected by the backend, but it is possible to set the device to
be used with setOutputDevice(). The outputDeviceChanged() signal
will be emitted if the device changes.
If an error occurs with the playback, for instance, if no valid
output device is found, the media object will receive a
stateChanged() signal with the \l{Phonon::}{ErrorState}.
Note that the default values of properties are dependent on the
backend.
\sa Phonon::VolumeSlider, {Music Player Example}, BackendCapabilities, {Phonon Module}
*/
/*!
\property Phonon::AudioOutput::name
This is the name that appears in Mixer applications that control
the volume of this output.
*/
/*!
\property Phonon::AudioOutput::volume
This is the current loudness of the output. \omit The volume is a
real value between 0.0 (minimum) and 1.0 (maximum). The volume
follows the sound device used, with 1.0 being the maximum volume
the device can produce. \endomit
(it is using Stevens' law
to calculate the change in voltage internally).
\sa volumeDecibel
*/
/*!
\property Phonon::AudioOutput::volumeDecibel
This is the current volume of the output in decibel.
0 dB means no change in volume, -6dB means an attenuation of the
voltage to 50% and an attenuation of the power to 25%, -inf dB means
silence.
\sa volume
*/
/*!
\property Phonon::AudioOutput::outputDevice
This property holds the (hardware) destination for the output.
The default device is determined by the \l{Phonon::}{Category} and the global
configuration for that category. Normally you don't need
to override this setting - letting the user change the global
configuration is the right choice. You can still override the
device though, if you have good reasons to do so.
\sa outputDeviceChanged()
*/
/*!
\property Phonon::AudioOutput::muted
This property tells whether the output is muted.
Muting the output has the same effect as calling setVolume(0.0).
*/
/*!
\fn explicit Phonon::AudioOutput::AudioOutput(Phonon::Category category, QObject *parent = 0)
Creates a new AudioOutput with the given \a parent that defines
output to a physical device.
The \a category can be used by mixer applications to group volume
controls of applications into categories. That makes it easier for
the user to identify the programs.
The category is also used for the default output device that is
configured centrally. As an example: often users want to have the
audio signal of a VoIP application go to their USB headset while
all other sounds should go to the internal soundcard.
\sa Phonon::categoryToString(), outputDevice
*/
/*!
\fn explicit Phonon::AudioOutput::AudioOutput(QObject *parent = 0)
Creates a new AudioOutput that defines output to the system
default device with the \{Phonon::Category::}{NoCategory} category
\sa Phonon::categoryToString(), outputDevice
*/
/*!
\fn Phonon::Category Phonon::AudioOutput::category() const
Returns the category of this output.
\sa Phonon::AudioOutput::AudioOutput()
*/
/*!
\fn void Phonon::AudioOutput::volumeChanged(qreal newVolume)
This signal is emitted whenever the volume has changed. As the
volume can change without a call to setVolume (calls over dbus)
this is important to keep a widget showing the current volume up
to date.
\a newVolume is the new volume level.
\sa setVolume(), volume()
*/
/*!
\fn void Phonon::AudioOutput::mutedChanged(bool muted)
This signal is emitted when the muted property has changed. The \a muted
value passed by the signal indicates the state of the muted property.
As this property can change by IPC (DBus) calls a UI element showing
the muted property should listen to this signal.
*/
/*!
\fn void Phonon::AudioOutput::outputDeviceChanged(const Phonon::AudioOutputDevice &newAudioOutputDevice)
This signal is emitted when the (hardware) device for the output
has changed. \a newAudioOutputDevice is the new device.
The change can happen either through setOutputDevice or if the
global configuration for the used category has changed.
\sa outputDevice
*/
/*!
\class Phonon::AudioOutputPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::EffectParameter
\inmodule Phonon
\inheaderfile Phonon/EffectParameter
\since 4.4
\brief The EffectParameter class describes one parameter of an effect.
You fetch the parameters of an \l{Phonon::}{Effect} with
\l{Phonon::}{Effect::parameters()}.
\snippet doc/src/snippets/phononeffectparameter.cpp 0
To describe itself, an effect parameter gives a name() and
possibly description() (depending on the backend used). These are
suited to present the effect parameter to the user of a Phonon
application.
Note that effects are created by the backend, and that
their name and descriptions may vary.
The value of an effect parameter is stored in a \l{QVariant},
of which type() is usually \c int or \c double.
The value is retrieved with \l{Phonon::}{Effect::parameterValue()}
and set with \l{Phonon::Effect::}{setParameterValue()} - both of
which takes the EffectParameter as argument. Note that not all
effect parameters support setting of their value.
You get the values a parameter can take with possibleValues(); an
empty list is returned if the values are continuous.
A parameter may also specify default(), minimum(), and maximum()
values. Values are returned as \l{QVariant}s. If the parameter
does not have the requested value, an \l{QVariant::Invalid}
invalid QVariant is returned from these functions.
The \l{Phonon::}{EffectWidget} provides a widget with which one
can control the parameters of an \l{Phonon::}{Effect}.
\snippet doc/src/snippets/phononeffectparameter.cpp 1
\sa Effect, EffectWidget, {Capabilities Example}, {Phonon Module}
*/
/*!
\fn Phonon::EffectParameter::EffectParameter()
\internal
Creates an invalid effect parameter.
*/
/*!
\fn Phonon::EffectParameter::~EffectParameter()
Destroys the effect parameter.
*/
/*!
\fn Phonon::EffectParameter::EffectParameter(const EffectParameter &other)
Constructs a copy of the \a other effect parameter.
*/
/*!
\fn const QString &Phonon::EffectParameter::name() const
The name of the parameter. Can be used as the label.
\return A label for the parameter.
*/
/*!
\fn const QString &Phonon::EffectParameter::description() const
The parameter may come with a description (LADSPA doesn't have a
field for this, so don't expect many effects to provide a
description).
The description can be used for a tooltip or WhatsThis help.
\return A text describing the parameter.
*/
/*!
\fn QVariant::Type Phonon::EffectParameter::type() const
Returns the parameter type.
Common types are QVariant::Int, QVariant::Double, QVariant::Bool and QVariant::String. When
QVariant::String is returned you get the possible values from possibleValues.
*/
/*!
\fn bool Phonon::EffectParameter::isLogarithmicControl() const
Returns whether the parameter should be
displayed using a logarithmic scale. This is particularly useful for
frequencies and gains.
*/
/*!
\fn QVariant Phonon::EffectParameter::minimumValue() const
The minimum value to be used for the control to edit the parameter.
If the returned QVariant is invalid the value is not bounded from
below.
*/
/*!
\fn QVariant Phonon::EffectParameter::maximumValue() const
The maximum value to be used for the control to edit the parameter.
If the returned QVariant is invalid the value is not bounded from
above.
*/
/*!
\fn QVariant Phonon::EffectParameter::defaultValue() const
The default value.
*/
/*!
\fn QVariantList Phonon::EffectParameter::possibleValues() const
The possible values to be used for the control to edit the parameter.
if the value of this parameter is to be picked from predefined values
this returns the list (otherwise it returns an empty QVariantList).
*/
/*!
\fn bool Phonon::EffectParameter::operator<(const EffectParameter &rhs) const
\internal
compares the ids of the parameters
*/
/*!
\fn bool Phonon::EffectParameter::operator>(const EffectParameter &rhs) const
\internal
compares the ids of the parameters
*/
/*!
\fn bool Phonon::EffectParameter::operator==(const EffectParameter &rhs) const
\internal
compares the ids of the parameters
*/
/*!
\fn Phonon::EffectParameter &Phonon::EffectParameter::operator=(const EffectParameter &other)
Assigns the \a other effect parameter to this parameter and returns
a reference to this parameter.
*/
/*!
\enum Phonon::EffectParameter::Hint
Only for backend developers:
Flags to set the return values of isToggleControl(),
isLogarithmicControl(), isIntegerControl(), isBoundedBelow() and
isBoundedAbove(). The values of the flags correspond to the values
used for LADSPA effects.
\value ToggledHint
If this hint is set it means that
the control has only two states: zero and non-zero
(see isToggleControl()).
\value LogarithmicHint
LADSPA's SAMPLE_RATE hint needs to be translated by the backend
to normal bounds, as the backend knows the sample rate - and the
frontend doesn't (see isLogarithmicControl()).
\value IntegerHint See isIntegerControl().
*/
/*!
\fn Phonon::EffectParameter::EffectParameter(int parameterId,
const QString &name, EffectParameter::Hints hints,
const QVariant &defaultValue, const QVariant &min = QVariant(),
const QVariant &max = QVariant(), const QVariantList &values = QVariantList(),
const QString &description = QString())
Only to be used by backend implementations:
Creates a new effect parameter.
\a parameterId This is a number to uniquely identify the
parameter. The id is used for value() and setValue().
\a name is the name/label for this parameter.
\a hints sets the hints for the type of parameter.
\a defaultValue The value that should be used as a default.
\a min is the minimum value allowed for this parameter. You only
need to set this if the BoundedBelowHint is set.
\a max is the maximum value allowed for this parameter. You only
need to set this if the BoundedAboveHint is set.
The \a values parameter is the values that the effect parameter
can take (only applies if non-continuous)
\a description is a descriptive text for the parameter
(explaining what it controls) to be used as a tooltip or
WhatsThis help.
*/
/*!
\fn int Phonon::EffectParameter::id() const
\internal
Returns the parameter's identifier.
*/
/*!
\typedef Phonon::AudioOutputInterface
\inmodule Phonon
\internal
*/
/*!
\class Phonon::AudioOutputInterface40
\inmodule Phonon
\since 4.4
\internal
\brief Interface for AudioOutput objects
*/
/*!
\fn virtual Phonon::AudioOutputInterface40::~AudioOutputInterface40()
\internal
*/
/*!
\fn virtual qreal Phonon::AudioOutputInterface40::volume() const = 0
\internal
*/
/*!
\fn virtual void Phonon::AudioOutputInterface40::setVolume(qreal) = 0
\internal
*/
/*!
\fn virtual int Phonon::AudioOutputInterface40::outputDevice() const = 0
\internal
*/
/*!
\fn virtual bool Phonon::AudioOutputInterface40::setOutputDevice(int) = 0
\internal
*/
/*!
\class Phonon::Path
\inmodule Phonon
\inheaderfile Phonon/Path
\since 4.4
\brief The Path class describes connections between media nodes.
In a \l{Building Graphs}{media graph}, \l{Phonon::}{MediaNode}s
are connected by Paths. The multimedia travels in streams over
these paths.
You create a path between two media nodes using the static
Phonon::createPath() function, which takes two nodes as arguments.
The first argument will send the media stream to the second.
Please refer to the class description of the individual media
nodes and the Phonon \l{Phonon Overview}{overview} to see which
nodes can be connected to each other.
Paths are also used to insert audio \l{Phonon::}{Effect}s between
two media nodes. The effect will then alter the stream on the
path. Notice that \l{Phonon::}{Effect}s also are media nodes, but
that insertEffect() - instead of Phonon::createPath() - is used to
insert them into the media graph.
The following code example shows how to create a path between two
media nodes and insert an effect on that path.
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 20
\sa Phonon::MediaNode, Phonon::MediaObject, Phonon::AudioOutput,
Phonon::VideoWidget, {Phonon Module}
*/
/*!
\fn Phonon::Path::~Path();
Destroys this reference to the Path. If the path was valid the connection is not broken
as both the source and the sink MediaNodes still keep a reference to the Path.
\sa disconnect()
*/
/*!
\fn Phonon::Path::Path();
Creates an invalid path.
You can still make it a valid path by calling reconnect. It is
recommended to use the Phonon::createPath() function to create
paths.
\sa Phonon::createPath(), isValid()
*/
/*!
\fn Phonon::Path::Path(const Path &path);
Constructs a copy of the other \a path specified.
This constructor is fast thanks to explicit sharing.
*/
/*!
\fn bool Phonon::Path::isValid() const;
A path is considered valid if it is connected to two media nodes,
in which case this function returns true. If it is connected to
one or no media nodes, it is consider invalid, and this function
will then return false.
*/
/*!
\fn Effect *Phonon::Path::insertEffect(const EffectDescription &desc, Effect *insertBefore = 0);
Creates and inserts an effect into the path.
You may insert effects of the same class as often as you like,
but if you insert the same object, the call will fail.
\a desc is the EffectDescription object for the effect to be inserted.
If you already inserted an effect you can
tell with \a insertBefore in which order the data gets
processed. If this is \c 0 the effect is appended at the end of
the processing list. If the effect has not been inserted before
the method will do nothing and return \c false.
Returns a pointer to the effect object if it could be inserted
at the specified position. If \c 0 is returned, the effect was not
inserted.
Below is a code example for inserting an effect into a path:
\snippet doc/src/snippets/audioeffects.cpp 0
\sa removeEffect(), effects()
*/
/*!
\fn bool Phonon::Path::insertEffect(Effect *effect, Effect *insertBefore = 0);
Inserts the given \a effect into the path before the effect specified by \a insertBefore
and returns true if successful; otherwise returns false.
If \a insertBefore is zero, the effect is appended to the processing list.
You may insert effects of the same class as often as you like, but if you insert
the same object, the call will fail.
\a effect will be inserted right before \a insertBefore. If
\a insertBefore is \c 0, the effect is appended at the end of the
processing list. If the effect has not been inserted before the
method will do nothing and return \c false.
Returns whether the effect could be inserted at the specified
position. If \c false is returned the effect was not inserted.
\sa removeEffect(), effects()
*/
/*!
\fn bool Phonon::Path::removeEffect(Effect *effect);
Removes the given \a effect from the path and returns true; otherwise returns false.
Removes an \a effect from the path.
If the effect is deleted while it is still connected, the effect will be removed
automatically.
\omit
\param effect The effect to be removed.
\return Returns whether the call was successful. If it returns
\c false the effect could not be found in the path, meaning it
has not been inserted before.
\endomit
\sa insertEffect(), effects()
*/
/*!
\fn QList<Effect *> Phonon::Path::effects() const;
Returns a list of Effect objects that are currently
used as effects. The order in the list determines the order the
signal is sent through the effects.
\return A list with all current effects.
\sa insertEffect(), removeEffect()
*/
/*!
\fn bool Phonon::Path::reconnect(MediaNode *source, MediaNode *sink);
Changes the media nodes the path is connected to by connecting the path
to the \a source and \a sink nodes specified. Returns true if successful;
otherwise returns false.
If unsuccessful, the path remains connected to the same nodes as before.
\sa Phonon::createPath(), {Phonon Overview}
*/
/*!
\fn bool Phonon::Path::disconnect();
Tries to disconnect the path from the MediaNodes it is connected to, returning
true if successful or false if unsuccessful.
If successful, the path is invalidated: isValid() will returns false.
*/
/*!
\fn Path &Phonon::Path::operator=(const Path &p);
Assigns \a p to this Path and returns a reference to this Path.
This operation is fast thanks to explicit sharing.
*/
/*!
\fn bool Phonon::Path::operator==(const Path &p) const;
Returns true if this Path is equal to \a p; otherwise returns false;
*/
/*!
\fn bool Phonon::Path::operator!=(const Path &p) const;
Returns true if this Path is not equal to \a p; otherwise returns false.
*/
/*!
\fn MediaNode *Phonon::Path::source() const;
Returns the source MediaNode used by the path.
*/
/*!
\fn MediaNode *Phonon::Path::sink() const;
Returns the sink MediaNode used by the path.
*/
/*!
\fn Path Phonon::createPath(MediaNode *source, MediaNode *sink);
\relates Phonon::Path
Creates a new Path connecting the two MediaNodes \a source and \a sink.
The implementation will automatically select the right format and media type. E.g. connecting a
MediaObject and AudioOutput will create a Path object connecting the audio. This might be
represented as PCM or perhaps even AC3 depending on the AudioOutput object.
\param source The MediaNode to connect an output from
\param sink The MediaNode to connect to.
*/
/*!
\class Phonon::PathPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::MediaObjectInterface
\inmodule Phonon
\since 4.4
\internal
\brief Backend interface for media sources.
The backend implementation has to provide two signals, that are not defined
in this interface:
\list
\o \target phonon_MediaObjectInterface_stateChanged
void stateChanged(Phonon::State newstate, Phonon::State oldstate)
Emitted when the state of the MediaObject has changed.
In case you're not interested in the old state you can also
connect to a slot that only has one State argument.
\param newstate The state the Player is in now.
\param oldstate The state the Player was in before.
\o \target phonon_MediaObjectInterface_tick
void tick(qint64 time)
This signal gets emitted every tickInterval milliseconds.
\param time The position of the media file in milliseconds.
\sa setTickInterval()
\sa tickInterval()
\endlist
\sa MediaObject
*/
/*!
\fn virtual Phonon::MediaObjectInterface::~MediaObjectInterface()
\internal
*/
/*!
\fn virtual qint64 Phonon::MediaObjectInterface::remainingTime() const
\internal
*/
/*!
\fn virtual qint32 Phonon::MediaObjectInterface::prefinishMark() const = 0
\internal
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::setPrefinishMark(qint32) = 0
\internal
*/
/*!
\fn virtual qint32 Phonon::MediaObjectInterface::transitionTime() const = 0
\internal
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::setTransitionTime(qint32) = 0
\internal
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::play() = 0
\internal
Requests the playback to start.
This method is only called if the state transition to PlayingState is possible.
The backend should react immediately
by either going into PlayingState or BufferingState if the
former is not possible.
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::pause() = 0
\internal
Requests the playback to pause.
This method is only called if the state transition to PausedState is possible.
The backend should react as fast as possible. Go to PausedState
as soon as playback is paused.
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::stop() = 0
\internal
Requests the playback to be stopped.
This method is only called if the state transition to StoppedState is possible.
The backend should react as fast as possible. Go to StoppedState
as soon as playback is stopped.
A subsequent call to play() will start playback at the beginning of
the media.
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::seek(qint64 milliseconds) = 0
\internal
Requests the playback to be seeked to the given time.
The backend does not have to finish seeking while in this function
(i.e. the backend does not need to block the thread until the seek is
finished; even worse it might lead to deadlocks when using a
ByteStream which gets its data from the thread this function would
block).
As soon as the seek is done the currentTime() function and
the tick() signal will report it.
\param milliseconds The time where playback should seek to in
milliseconds.
*/
/*!
\fn virtual qint32 Phonon::MediaObjectInterface::tickInterval() const = 0
\internal
Return the time interval in milliseconds between two ticks.
Returns the tick interval that it was set to (might not
be the same as you asked for).
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::setTickInterval(qint32 interval) = 0
\internal
Change the interval the tick signal is emitted. Set \a interval to 0 to
disable the signal.
\a interval tick interval in milliseconds
Returns the tick interval that it was set to (might not be the same as you
asked for).
*/
/*!
\fn virtual bool Phonon::MediaObjectInterface::hasVideo() const = 0
\internal
Check whether the media data includes a video stream.
Returns true if the media contains video data.
*/
/*!
\fn virtual bool Phonon::MediaObjectInterface::isSeekable() const = 0
\internal
If the current media may be seeked this function returns true;
otherwise, false.
Returns whether the current media may be seeked.
*/
/*!
\fn virtual qint64 Phonon::MediaObjectInterface::currentTime() const = 0
\internal
Get the current time (in milliseconds) of the file currently being played.
*/
/*!
\fn virtual Phonon::State Phonon::MediaObjectInterface::state() const = 0
\internal
Get the current state.
*/
/*!
\fn virtual QString Phonon::MediaObjectInterface::errorString() const = 0
\internal
A translated string describing the error.
*/
/*!
\fn virtual Phonon::ErrorType Phonon::MediaObjectInterface::errorType() const = 0
\internal
Tells your program what to do about the error.
\sa Phonon::ErrorType
*/
/*!
\fn virtual qint64 Phonon::MediaObjectInterface::totalTime() const = 0
\internal
Returns the total time of the media in milliseconds.
If the total time is not know return -1. Do not block until it is
known, instead emit the totalTimeChanged signal as soon as the total
time is known or changes.
*/
/*!
\fn virtual MediaSource Phonon::MediaObjectInterface::source() const = 0
\internal
Returns the current source.
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::setSource(const MediaSource &) = 0
\internal
Sets the current source. When this function is called the MediaObject is
expected to stop all current activity and start loading the new
source (i.e. go into LoadingState).
It is expected that the
backend now starts preloading the media data, filling the audio
and video buffers and making all media meta data available. It
will also trigger the totalTimeChanged signal.
If the backend does not know how to handle the source it needs to
change state to Phonon::ErrorState. Don't bother about handling KIO
URLs. It is enough to handle AbstractMediaStream sources correctly.
\warning Keep the MediaSource object around as long as the backend
uses the AbstractMediaStream returned by the MediaSource. In case
that no other reference to the MediaSource exists and it is set to
MediaSource::autoDelete, the AbstractMediaStream is deleted when the
last MediaSource ref is deleted.
*/
/*!
\fn virtual void Phonon::MediaObjectInterface::setNextSource(const MediaSource &source) = 0
\internal
Sets the next source to be used for transitions. When a next source
is set playback should continue with the new source. In that case
finished and prefinishMarkReached are not emitted.
\param source The source to transition to (crossfade/gapless/gap). If
\a source is an invalid MediaSource object then the queue is empty
and the playback should stop normally.
\warning Keep the MediaSource object around as long as the backend
uses the AbstractMediaStream returned by the MediaSource. In case
that no other reference to the MediaSource exists and it is set to
MediaSource::autoDelete, the AbstractMediaStream is deleted when the
last MediaSource ref is deleted.
*/
/*!
\class Phonon::EffectWidget effectwidget.h Phonon/EffectWidget
\inmodule Phonon
\inheaderfile Phonon/EffectWidget
\since 4.4
\brief The EffectWidget class provides a widget to control the parameters of an Effect.
The EffectWidget class provides a widget, with which an effects
parameters can be controlled. The widget does not have an API,
and is constructed with the \l{Phonon::}{Effect}, of which
parameters should be controlled.
\snippet doc/src/snippets/audioeffects.cpp 1
The following image shows an example of an effect widget.
\image effectwidget.png
Note that some audio effects do not have parameters, and the
widget will then not \l{QWidget::}{show()} at all.
\sa Effect, BackendCapabilities, EffectDescription, {Phonon Module}
*/
/*!
\class Phonon::AbstractAudioOutput
\inmodule Phonon
\internal
\brief Provides a common base class for all audio outputs.
\sa AudioOutput
*/
/*!
\fn Phonon::AbstractAudioOutput::~AbstractAudioOutput()
\internal
*/
/*!
\class Phonon::AbstractAudioOutputPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class AudioOutputAdaptor
\inmodule Phonon
\brief Provides an adaptor class for interface org.kde.Phonon.AudioOutput
\internal
*/
/*!
\class Phonon::VolumeSlider
\inmodule Phonon
\inheaderfile Phonon/VolumeSlider
\since 4.4
\brief The VolumeSlider widget provides a slider that is used to control the volume of an audio output device.
The slider also displays an icon indicating if the volume of the
\l{Phonon::}{AudioOutput} it is connected to is muted. The icon
can be removed with setMuteVisible().
It is possible to set the \l{maximumVolume}{maximum} value of the
slider. By default, the minimum and maximum values of the slider
are 0.0 (no sound) to 1.0 (the maximum volume the audio output can
produce).
Here follows a code example:
\snippet doc/src/snippets/volumeslider.cpp 0
\omit mention how to change the style of the slider. \endomit
\sa {Phonon Module}
*/
/*!
\property Phonon::VolumeSlider::maximumVolume
This property holds the maximum volume that can be set with this slider.
By default the maximum value is 1.0 (100%).
*/
/*!
\property Phonon::VolumeSlider::orientation
This property holds the orientation of the slider.
The orientation must be Qt::Vertical (the default) or Qt::Horizontal.
*/
/*!
\property Phonon::VolumeSlider::tracking
This property holds whether slider tracking is enabled.
If tracking is enabled (the default), the volume changes
while the slider is being dragged. If tracking is
disabled, the volume changes only when the user
releases the slider.
*/
/*!
\property Phonon::VolumeSlider::pageStep
This property holds the page step.
The larger of two natural steps that a slider provides and
typically corresponds to the user pressing PageUp or PageDown.
Defaults to 5 (5% of the voltage).
*/
/*!
\property Phonon::VolumeSlider::singleStep
This property holds the single step.
The smaller of two natural steps that a slider provides and
typically corresponds to the user pressing an arrow key.
Defaults to 1 (1% of the voltage).
*/
/*!
\property Phonon::VolumeSlider::muteVisible
This property holds whether the mute button/icon next to the slider is visible.
By default the mute button/icon is visible.
*/
/*!
\property Phonon::VolumeSlider::iconSize
\brief the icon size used for the mute button/icon.
The default size is defined by the GUI style.
*/
/*!
\fn explicit Phonon::VolumeSlider::VolumeSlider(QWidget *parent = 0)
Constructs a new volume slider with the given \a parent.
*/
/*!
\fn explicit Phonon::VolumeSlider::VolumeSlider(AudioOutput *output, QWidget *parent = 0)
Constructs a new volume slider with the given \a output object and \a parent.
*/
/*!
\fn Phonon::VolumeSlider::~VolumeSlider()
*/
/*!
\fn AudioOutput *Phonon::VolumeSlider::audioOutput() const
*/
/*!
\fn void Phonon::VolumeSlider::setAudioOutput(Phonon::AudioOutput *output)
Sets the audio output object to be controlled by this slider to the specified
\a output object.
*/
/*!
\class Phonon::VolumeSliderPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::MediaController
\inmodule Phonon
\inheaderfile Phonon/MediaController
\since 4.4
\brief The MediaController class controls optional features of a media file/device.
Some media sources have content that the \l{Phonon::}{MediaObject}
does not provide control over, for instance, chapters in a DVD
file. The functionality the media controller offers is
dependent on the type of media source that is played back.
Commonly, the media controller allows you to:
\list
\o Navigate between \bold chapters.
\o Navigate between \bold titles.
\o Select between \bold angles.
\endlist
The \l{Phonon::MediaController::}{Feature} enum explains these
terms in more detail, and their context in playback of CD and DVD.
The media controller keeps a \l{Phonon::}{MediaObject}, of which
\l{Phonon::MediaObject::currentSource()}{media source} is played
back. You can still call the media object's functions, e.g.,
\l{Phonon::MediaObject::}{stop()}; this is all handled correctly
by the media controller. You have the option of letting the media
controller play all titles of a source in sequence by setting the
\l{autoplayTitles()}{autoplay titles} option.
To start a playback using a media object, you call
\l{Phonon::MediaObject::}{play()} on the media object. To play a
specific title, use setCurrentTitle() and then call
\l{Phonon::MediaObject::}{play()}.
\warning The Phonon::MediaController class is not yet supported by
Qt backends.
\sa {Phonon Module}
*/
/*!
\fn int Phonon::MediaController::availableAudioChannels() const
\internal
*/
/*!
\fn void Phonon::MediaController::availableAudioChannelsChanged()
\internal
*/
/*!
\fn QList<SubtitleDescription> Phonon::MediaController::availableSubtitles() const
\internal
*/
/*!
\fn void Phonon::MediaController::availableSubtitlesChanged()
\internal
*/
/*!
\fn AudioChannelDescription Phonon::MediaController::currentAudioChannel() const
\internal
*/
/*!
\fn SubtitleDescription Phonon::MediaController::currentSubtitle() const
\internal
*/
/*!
\fn void Phonon::MediaController::setCurrentAudioChannel(const Phonon::AudioChannelDescription &stream)
\internal
*/
/*!
\fn void Phonon::MediaController::setCurrentSubtitle(const Phonon::SubtitleDescription &stream)
\internal
*/
/*!
\fn Phonon::BackendCapabilities::availableAudioCaptureDevices()
\internal
*/
/*!
\fn Phonon::BackendCapabilities::Notifier::availableAudioCaptureDevicesChanged()
\internal
*/
/*!
\enum Phonon::MediaController::Feature
The values of this enum are interpreted differently depending on
the type of media source, e.g., DVD or CD. We give examples for
these sources.
\value Angles In the VOB (DVD) format, it is possible to to give
several video streams of the same scene, each of which displays
the scene from a different angle. The DVD viewer can then change
between these angles.
\value Chapters In the VOB format, chapters are points in a
single video stream that can be played and seeked to
separately.
\value Titles On a CD, a title is a separate sound track. On DVD,
a title is a separate VOB file.
*/
/*!
\fn Phonon::MediaController::MediaController(MediaObject *parent)
Constructs a new MediaController with the media object (\a parent)
to be used by the media controller.
\sa MediaObject, Feature
*/
/*!
\fn Phonon::MediaController::~MediaController()
*/
/*!
\fn Features Phonon::MediaController::supportedFeatures() const
*/
/*!
\fn int Phonon::MediaController::availableAngles() const
Returns the available angles that is available for the current
media source.
\sa Feature
*/
/*!
\fn int Phonon::MediaController::currentAngle() const
Returns the angle that is currently used.
\sa Feature
*/
/*!
\fn int Phonon::MediaController::availableChapters() const
Returns the number of chapters the current media source
contains.
\sa Feature
*/
/*!
\fn int Phonon::MediaController::currentChapter() const
Returns the chapter that is currently being played back.
\sa Feature
*/
/*!
\fn int Phonon::MediaController::availableTitles() const
Returns the number of titles that the current media source
contains.
\sa Feature
*/
/*!
\fn int Phonon::MediaController::currentTitle() const
Returns the title that is currently played back.
The current title is 0 (the first) by default.
\sa Feature
*/
/*!
\fn bool Phonon::MediaController::autoplayTitles() const
Returns true if titles will automatically be played when the media
is played; otherwise returns false.
The media controller will play the titles of the media source in
sequence when the media object's \l{Phonon::MediaObject::}{play()}
function is called. If the autoplay option is disabled, the media
object will play the
\l{Phonon::}{MediaController::currentTitle()}{current title} and then
finish the playback.
\sa setAutoplayTitles(), currentTitle()
*/
/*!
\fn void Phonon::MediaController::setAutoplayTitles(bool enable)
Sets the titles to play automatically when the media is played if
\a enable is true; otherwise disables this option.
The media controller will play the titles of the media source in
sequence when the media object's \l{Phonon::MediaObject::}{play()}
function is called. If the autoplay option is disabled, the media
object will play the
\l{Phonon::}{MediaController::currentTitle()}{current title} and then
finish the playback.
\sa autoplayTitles(), currentTitle()
*/
/*!
\fn void Phonon::MediaController::setCurrentAngle(int angleNumber)
Sets the current angle to the given \a angleNumber if the media
file or device supports navigation by angle number.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::setCurrentChapter(int chapterNumber)
Sets the current chapter to the given \a chapterNumber if the media
file or device supports navigation by chapter number.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::setCurrentTitle(int titleNumber)
Skips to the given title \a titleNumber.
If it was playing before the title change it will start playback on the new title if
autoplayTitles is enabled.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::nextTitle()
Skips to the next title.
If it was playing before the title change it will start playback on the next title if
autoplayTitles is enabled.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::previousTitle()
Skips to the previous title.
If it was playing before the title change it will start playback on the previous title if
autoplayTitles is enabled.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::availableAnglesChanged(int availableAngles)
This signal is emitted whenever the number of available angles changes.
The new number of available angles is given by \a availableAngles.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::angleChanged(int angleNumber)
This signal is emitted whenever the current angle changes.
The new angle number is given by \a angleNumber.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::availableChaptersChanged(int availableChapters)
This signal is emitted whenever the number of available chapters changes.
The new number of available chapters is given by \a availableChapters.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::chapterChanged(int chapterNumber)
This signal is emitted whenever the current chapter changes.
The new chapter number is given by \a chapterNumber.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::availableTitlesChanged(int availableTitles)
This signal is emitted whenever the number of available titles changes.
The new number of available titles is given by \a availableTitles.
\sa Feature
*/
/*!
\fn void Phonon::MediaController::titleChanged(int titleNumber)
This signal is emitted whenever the current title changes.
The new title number is given by \a titleNumber.
\sa Feature
*/
/*!
\class Phonon::VideoWidget
\inmodule Phonon
\inheaderfile Phonon/VideoWidget
\since 4.4
\ingroup advanced
\ingroup multimedia
\brief The VideoWidget class provides a widget that is used to display video.
The VideoWidget class renders the video of a media stream on a
QWidget. It is connected to the \l{Phonon::}{MediaObject}, of
which video stream it should render. You connect the two objects
using the Phonon::createPath() function.
The widget has some possibilities to manipulate the video
stream. You can change the brightness(), hue(), saturation(),
and contrast().
Resizing of the video is handled automatically, but you can affect
the way the video is resized with the aspectRatio and scaleMode
properties. By default, the widget will use the aspect ratio of
the video stream itself.
The video widget takes the size of the video when it receives a new video
stream (i.e., when a new MediaSource is set on the MediaObject to which it is
connected). If you need to know the size of the video, you can call
\l{QWidget::}{sizeHint()} after the video has been loaded (i.e., after the
MediaObject leaves the \l{Phonon::}{LoadingState}).
It is also possible to go to \l{fullScreen}{full screen} mode.
A typical example of usage follows below:
\snippet doc/src/snippets/code/doc_src_phonon-api.qdoc 21
\sa {Phonon Module}
*/
/*!
\fn Phonon::VideoWidget::VideoWidget(QWidget *parent = 0)
Constructs a new video widget with the specified \a parent.
*/
/*!
\fn Phonon::VideoWidget::VideoWidget(VideoWidgetPrivate &d, QWidget *parent)
\internal
Constructs a new video widget with the specified \a parent.
*/
/*!
\fn bool Phonon::VideoWidget::event(QEvent *)
\reimp
*/
/*!
\fn void Phonon::VideoWidget::mouseMoveEvent(QMouseEvent *)
\reimp
*/
/*!
\enum Phonon::VideoWidget::ScaleMode
The ScaleMode enum describes how to treat aspect ratio during
resizing of video.
\value FitInView The video will be fitted to fill the view
keeping aspect ratio.
\value ScaleAndCrop The video is scaled
*/
/*!
\property Phonon::VideoWidget::fullScreen
This property holds whether the video is shown using the complete
screen.
The property differs from QWidget::fullScreen in that it is
writeable.
By default the widget is not shown in fullScreen.
\warning When switching to full screen mode using setFullScreen(),
the widget onto which the video is rendered is shown as a
top-level window. Key event forwarding is handled by VideoWidget,
but if you need to handle other events, e.g., mouse events, you
should handle fullscreen mode yourself.
*/
/*!
\property Phonon::VideoWidget::aspectRatio
Defaults to AspectRatioAuto.
\sa AspectRatio
*/
/*!
\property Phonon::VideoWidget::scaleMode
If the size of the widget and the size of the video are not equal.
The video will be zoomed to fit the widget. The smaller zoom
(AddBarsScaleMode) adds black bars at the left/right or top/bottom to
make all of the image visible (default). The bigger zoom (ExpandMode)
fills the widget completely, keeping all information in one direction
and leaving parts of the image outside of the widget in the other
direction.
*/
/*!
\property Phonon::VideoWidget::brightness
This property holds brightness of the video.
Default is 0. Acceptable values are in range of -1, 1.
*/
/*!
\property Phonon::VideoWidget::contrast
This property holds the contrast of the video.
Default is 0. Acceptable values are in range of -1, 1.
*/
/*!
\property Phonon::VideoWidget::hue
This property holds the hue of the video.
Default is 0. Acceptable values are in range of -1, 1.
*/
/*!
\property Phonon::VideoWidget::saturation
This property holds saturation of the video.
Default is 0. Acceptable values are in range of -1, 1.
*/
/*!
\enum Phonon::VideoWidget::AspectRatio
Defines the width:height to be used for the video.
\value AspectRatioAuto
Let the decoder find the aspect ratio automatically from the
media file (this is the default).
\value AspectRatioWidget
Fits the video into the widget making the aspect ratio depend
solely on the size of the widget. This way the aspect ratio
is freely resizeable by the user.
\value AspectRatio4_3
Make width/height == 4/3, which is the old TV size and
monitor size (1024/768 == 4/3). (4:3)
\value AspectRatio16_9
Make width/height == 16/9, which is the size of most current
media. (16:9)
*/
/*!
\fn void Phonon::VideoWidget::exitFullScreen()
Convenience slot, calling setFullScreen(false)
*/
/*!
\fn void Phonon::VideoWidget::enterFullScreen()
Convenience slot, calling setFullScreen(true)
*/
/*!
\class Phonon::VideoWidgetInterface
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn virtual Phonon::VideoWidgetInterface::~VideoWidgetInterface()
*/
/*!
\fn virtual Phonon::VideoWidget::AspectRatio Phonon::VideoWidgetInterface::aspectRatio() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setAspectRatio(Phonon::VideoWidget::AspectRatio ratio) = 0
\internal
*/
/*!
\fn virtual qreal Phonon::VideoWidgetInterface::brightness() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setBrightness(qreal) = 0
\internal
*/
/*!
\fn virtual Phonon::VideoWidget::ScaleMode Phonon::VideoWidgetInterface::scaleMode() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setScaleMode(Phonon::VideoWidget::ScaleMode mode) = 0
\internal
*/
/*!
\fn virtual qreal Phonon::VideoWidgetInterface::contrast() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setContrast(qreal) = 0
\internal
*/
/*!
\fn virtual qreal Phonon::VideoWidgetInterface::hue() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setHue(qreal) = 0
\internal
*/
/*!
\fn virtual qreal Phonon::VideoWidgetInterface::saturation() const = 0
\internal
*/
/*!
\fn virtual void Phonon::VideoWidgetInterface::setSaturation(qreal) = 0
\internal
*/
/*!
\fn virtual QWidget *Phonon::VideoWidgetInterface::widget() = 0
\internal
*/
/*!
\class Phonon::PlatformPlugin
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn virtual AbstractMediaStream *Phonon::PlatformPlugin::createMediaStream(const QUrl &url, QObject *parent) = 0
Creates a AbstractMediaStream object with the given \a parent that provides the data
for the given URL specified by \a url.
\omit
On KDE this uses KIO.
\endomit
*/
/*!
\fn virtual QIcon Phonon::PlatformPlugin::icon(const QString &name) const = 0
Returns the icon for the given icon name.
*/
/*!
\fn virtual void Phonon::PlatformPlugin::notification(const char *notificationName, const QString &text,
const QStringList &actions, QObject *receiver, const char *actionSlot) const = 0
Shows a notification pop-up with the given \a notificationName and \a text.
Each action in the associated list of \a actions is connected to the \a actionSlot
of the specified \a receiver object, which is expected to act on the actions as
they are triggered by the user.
*/
/*!
\fn virtual QString Phonon::PlatformPlugin::applicationName() const = 0
Returns the name of the application. For most Qt application this is
QCoreApplication::applicationName(), but for KDE this is overridden by KAboutData.
*/
/*!
\fn virtual QObject *Phonon::PlatformPlugin::createBackend() = 0
Creates a backend object. This way the platform can decide the backend preference.
*/
/*!
\fn virtual QObject *Phonon::PlatformPlugin::createBackend(const QString &library, const QString &version) = 0
Using the library loader of the platform, loads a given backend provided the
specified \a library and \a version.
*/
/*!
\fn virtual bool Phonon::PlatformPlugin::isMimeTypeAvailable(const QString &mimeType) const = 0
Tries to check whether the default backend supports the MIME type specified by \a mimeType
without loading the actual backend library.
\omit
On KDE this reads the MIME type list from the .desktop file of
the backend.
\endomit
*/
/*!
\fn virtual void Phonon::PlatformPlugin::saveVolume(const QString &outputName, qreal volume) = 0
Saves the volume for the given output.
*/
/*!
\fn virtual qreal Phonon::PlatformPlugin::loadVolume(const QString &outputName) const = 0
Loads the volume for the given output.
*/
/*!
\class Phonon::MediaNode
\inmodule Phonon
\inheaderfile Phonon/MediaNode
\since 4.4
\brief The MediaNode class is the base class for all nodes in a media graph.
In all phonon applications, one builds a media graph consisting of
MediaNodes. The graph will take multimedia content, e.g., from a
file, as input. After its nodes have processed the multimedia, the
graph will output the media again, e.g., to a sound card.
The multimedia content is streamed over \l{Phonon::}{Path}s
between the nodes in the graph. You can query the paths that are
connected to a media node with inputPaths() and outputPaths().
You can check whether the node is implemented by the current
backend by calling isValid(). This does not guarantee that an
instance of the class works as expected, but that the backend has
implemented functionality for the class.
Currently, Phonon has four media nodes: \l{Phonon::}{MediaObject},
\l{Phonon::}{AudioOutput}, \l{Phonon::}{VideoWidget}, and \l{Phonon::}{Effect}.
Please refer to their class descriptions for details about their usage, and to
find out which nodes can be connected to each other. See also \l{Building
Graphs} in Phonon's \l{Phonon Overview}{overview} document.
Two nodes are connected to each other using the
Phonon::createPath() or \l{Phonon::}{Path::insertEffect()}
functions (only \l{Phonon::Effect}s use
\l{Phonon::Path::}{insertEffect()}). We show a code example below,
in which we build a media graph for video playback and then query
its media nodes for their \l{Phonon::}{Path}s:
\snippet doc/src/snippets/medianodesnippet.cpp 0
When you create a Phonon application, you will likely build the
graph yourself. This makes isValid() the most useful function of
this class. The other two functions help navigate the graph, which
you do not need to do as you created the nodes yourself.
\sa {Phonon Overview}, Phonon::MediaObject,
Phonon::AudioOutput, Phonon::VideoWidget, {Phonon Module}
*/
/*!
\fn virtual Phonon::MediaNode::~MediaNode()
Destroys the media node and any paths connecting it to other
nodes. Any \l{Phonon::}{Effect}s connected to these paths will
also be deleted.
*/
/*!
\fn bool Phonon::MediaNode::isValid() const
Returns true if the backend provides an implementation of this
class; otherwise returns false.
This does not guarantee that instances of the class works as
expected, but that the backend has implemented the functionality
for this class. For instance, Qt's GStreamer backend will return
true for instances of the \l{Phonon::}{AudioOutput} class, even if
there is a problem with GStreamer and it could not play sound.
*/
/*!
\fn QList<Path> Phonon::MediaNode::inputPaths() const
Returns the paths that inputs multimedia to this media node.
\sa outputPaths()
*/
/*!
\fn QList<Path> Phonon::MediaNode::outputPaths() const
Returns the paths to which this media node outputs media.
\sa inputPaths()
*/
/*!
\fn Phonon::MediaNode::MediaNode(MediaNodePrivate &dd)
\internal
*/
/*!
\class Phonon::GlobalConfig
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn Phonon::GlobalConfig::GlobalConfig()
\internal
*/
/*!
\fn Phonon::GlobalConfig::~GlobalConfig()
\internal
*/
/*!
\fn QList<int> Phonon::GlobalConfig::audioOutputDeviceListFor(Phonon::Category category, int override = AdvancedDevicesFromSettings) const
\internal
*/
/*!
\fn int Phonon::GlobalConfig::audioOutputDeviceFor(Phonon::Category category, int override = AdvancedDevicesFromSettings) const
\internal
*/
/*!
\class Phonon::ObjectDescriptionData
\inmodule Phonon
\since 4.4
\internal
\brief Data class for objects describing devices or features of the backend.
\sa Phonon::BackendCapabilities
*/
/*!
\fn bool Phonon::ObjectDescriptionData::operator==(const ObjectDescriptionData &otherDescription) const
Returns \c true if this ObjectDescription describes the same
as \a otherDescription; otherwise returns \c false.
*/
/*!
\fn QString Phonon::ObjectDescriptionData::name() const
Returns the name of the capture source.
\return A string that should be presented to the user to
choose the capture source.
*/
/*!
\fn QString Phonon::ObjectDescriptionData::description() const
Returns a description of the capture source. This text should
make clear what sound source this is, which is sometimes hard
to describe or understand from just the name.
\return A string describing the capture source.
*/
/*!
\fn QVariant Phonon::ObjectDescriptionData::property(const char *name) const
Returns a named property.
If the property is not set an invalid value is returned.
\sa propertyNames()
*/
/*!
\fn QList<QByteArray> Phonon::ObjectDescriptionData::propertyNames() const
Returns all names that return valid data when property() is called.
\sa property()
*/
/*!
\fn bool Phonon::ObjectDescriptionData::isValid() const
Returns true if the Tuple is valid (index != -1); otherwise returns
false.
*/
/*!
\fn int Phonon::ObjectDescriptionData::index() const
A unique identifier for this device/. Used internally
to distinguish between the devices/.
\return An integer that uniquely identifies every device.
*/
/*!
\fn static ObjectDescriptionData *Phonon::ObjectDescriptionData::fromIndex(ObjectDescriptionType type, int index)
\internal
*/
/*!
\fn Phonon::ObjectDescriptionData::~ObjectDescriptionData()
\internal
*/
/*!
\fn Phonon::ObjectDescriptionData::ObjectDescriptionData(ObjectDescriptionPrivate * = 0)
\internal
*/
/*!
\class Phonon::AddonInterface
\inmodule Phonon
\since 4.4
\internal
\brief Interface for Menu, Chapter, Angle and Title/Track control.
*/
/*!
\fn virtual Phonon::AddonInterface::~AddonInterface()
\internal
*/
/*!
\enum Phonon::AddonInterface::Interface
This enum describes the type of interface represented by an AddonInterface object.
\value NavigationInterface
\value ChapterInterface
\value AngleInterface
\value TitleInterface
*/
/*!
\enum Phonon::AddonInterface::NavigationCommand
\internal
\value Menu1Button
*/
/*!
\enum Phonon::AddonInterface::ChapterCommand
\internal
\value availableChapters
\value chapter
\value setChapter
*/
/*!
\enum Phonon::AddonInterface::AngleCommand
\internal
\value availableAngles
\value angle
\value setAngle
*/
/*!
\enum Phonon::AddonInterface::TitleCommand
\internal
\value availableTitles
\value title
\value setTitle
\value autoplayTitles
\value setAutoplayTitles
*/
/*!
\fn virtual bool Phonon::AddonInterface::hasInterface(Interface iface) const = 0
\internal
*/
/*!
\fn virtual QVariant Phonon::AddonInterface::interfaceCall(Interface iface, int command,
const QList<QVariant> &arguments) = 0
\internal
*/
/*!
\class Phonon::MediaNodePrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\namespace Phonon::Factory
\inmodule Phonon
\internal
*/
/*!
\fn Sender *Phonon::Factory::sender()
Returns a pointer to the object emitting the signals.
\sa Sender::backendChanged()
*/
/*!
\fn QObject *Phonon::Factory::createMediaObject(QObject *parent = 0)
Create a new backend object for a MediaObject.
\return a pointer to the MediaObject the backend provides.
*/
/*!
\fn QObject *Phonon::Factory::createEffect(int effectId, QObject *parent = 0)
Create a new backend object for a Effect.
\return a pointer to the Effect the backend provides.
*/
/*!
\fn QObject *Phonon::Factory::createVolumeFaderEffect(QObject *parent = 0)
Create a new backend object for a VolumeFaderEffect.
\return a pointer to the VolumeFaderEffect the backend provides.
*/
/*!
\fn QObject *Phonon::Factory::createAudioOutput(QObject *parent = 0)
Create a new backend object for a AudioOutput.
\return a pointer to the AudioOutput the backend provides.
*/
/*!
\fn QObject *Phonon::Factory::createVideoWidget(QObject *parent = 0)
Create a new backend object for a VideoWidget.
\return a pointer to the VideoWidget the backend provides.
*/
/*!
\fn QObject *Phonon::Factory::backend(bool createWhenNull = true)
\return a pointer to the backend interface.
*/
/*!
\fn QString Phonon::Factory::identifier()
Unique identifier for the Backend. Can be used in configuration files
for example.
*/
/*!
\fn QString Phonon::Factory::backendName()
Get the name of the Backend.
\omit
It's the name from the .desktop file.
\endomit
*/
/*!
\fn QString Phonon::Factory::backendComment()
Get the comment of the Backend.
\omit
It's the comment from the .desktop file.
\endomit
*/
/*!
\fn QString Phonon::Factory::backendVersion()
Get the version of the Backend.
\omit
It's the version from the .desktop file.
\endomit
The version is especially interesting if there are several versions
available for binary incompatible versions of the backend's media
framework.
*/
/*!
\fn QString Phonon::Factory::backendIcon()
Get the icon (name) of the Backend.
\omit
It's the icon from the .desktop file.
\endomit
*/
/*!
\fn QString Phonon::Factory::backendWebsite()
Get the website of the Backend.
\omit
It's the website from the .desktop file.
\endomit
*/
/*!
\fn QObject *Phonon::Factory::registerQObject(QObject *object)
Registers the given backend \a object with the factory.
*/
/*!
\fn bool Phonon::Factory::isMimeTypeAvailable(const QString &mimeType)
*/
/*!
\fn void Phonon::Factory::registerFrontendObject(MediaNodePrivate *)
\internal
*/
/*!
\fn void Phonon::Factory::deregisterFrontendObject(MediaNodePrivate *)
\internal
*/
/*!
\fn void Phonon::Factory::setBackend(QObject *)
*/
/*!
\fn PlatformPlugin *Phonon::Factory::platformPlugin()
*/
/*!
/*!
\class Phonon::AbstractMediaStreamPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::FrontendInterfacePrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::EffectWidgetPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::IODeviceStream
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn explicit Phonon::IODeviceStream::IODeviceStream(QIODevice *ioDevice, QObject *parent = 0)
\internal
Creates a new IODeviceStream with the given \a ioDevice and \a
parent.
*/
/*!
\fn Phonon::IODeviceStream::~IODeviceStream()
\internal
*/
/*!
\fn void Phonon::IODeviceStream::reset()
\internal
*/
/*!
\fn void Phonon::IODeviceStream::needData()
\internal
*/
/*!
\fn void Phonon::IODeviceStream::seekStream(qint64)
\internal
*/
/*!
\namespace Phonon::Platform
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::EffectDescriptionModel
\inmodule Phonon
\brief provides a item view model containing available audio effects.
*/
/*!
\typedef Phonon::SubtitleDescription
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::SubtitleDescriptionModel
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::AudioChannelDescription
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::AudioChannelDescriptionModel
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::AudioCaptureDevice
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::AudioCaptureDeviceModel
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::CleanUpFunction
\inmodule Phonon
\internal
*/
/*!
\typedef Phonon::QObjectPair
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\typedef Phonon::AudioOutputDeviceModel
\inmodule Phonon
\brief provides an item view model containing available audio output devices.
*/
/*!
\fn uint Phonon::qHash(const Phonon::EffectParameter ¶m)
\internal
*/
/*!
\fn Phonon::CleanUpGlobalStatic::~CleanUpGlobalStatic()
\internal
*/
/*!
\class Phonon::ConstIface
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::CleanUpGlobalStatic
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::EffectParameterPrivate
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::QSettingsGroup
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class Phonon::MediaNodeDestructionHandler
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\fn Phonon::MediaNodeDestructionHandler::~MediaNodeDestructionHandler()
\internal
Called from Base::~Base if this object was registered
using BasePrivate::addDestructionHandler().
*/
/*!
\fn Phonon::MediaNodeDestructionHandler::phononObjectDestroyed(MediaNodePrivate *)
\internal
*/
/*!
\fn explicit Phonon::EffectWidget::EffectWidget(Effect *effect, QWidget *parent = 0)
\internal
Constructs a new EffectWidget for the specified \a effect and with
the specified \a parent.
*/
/*!
\fn Phonon::EffectWidget::~EffectWidget()
\internal
*/
/*!
\fn QDebug Phonon::operator<<(QDebug s, const ObjectDescription<T> &o)
\internal
*/
/*!
\class Phonon::ListModelHelper
\inmodule Phonon
\since 4.4
\internal
*/
/*!
\class AudioOutputInterface42
\inmodule Phonon
\since 4.4
\internal
*/