Interface for media playback of a given URL. More...

#include <phonon/MediaObject>

Inheritance diagram for Phonon::MediaObject:

Public Slots
void	setTickInterval (qint32 newTickInterval)

void	play ()

void	pause ()

void	stop ()

void	seek (qint64 time)

void	clear ()

Signals
void	stateChanged (Phonon::State newstate, Phonon::State oldstate)

void	tick (qint64 time)

void	metaDataChanged ()

void	seekableChanged (bool isSeekable)

void	hasVideoChanged (bool hasVideo)

void	bufferStatus (int percentFilled)

void	finished ()

void	currentSourceChanged (const Phonon::MediaSource &newSource)

void	aboutToFinish ()

void	prefinishMarkReached (qint32 msecToEnd)

void	totalTimeChanged (qint64 newTotalTime)

Public Member Functions
	~MediaObject ()

State	state () const

bool	hasVideo () const

bool	isSeekable () const

qint32	tickInterval () const
	The time interval in milliseconds between two ticks. More...

QStringList	metaData (const QString &key) const

QStringList	metaData (Phonon::MetaData key) const

QMultiMap< QString, QString >	metaData () const

QString	errorString () const

ErrorType	errorType () const

MediaSource	currentSource () const

void	setCurrentSource (const MediaSource &source)

QList< MediaSource >	queue () const

void	setQueue (const QList< MediaSource > &sources)

void	setQueue (const QList< QUrl > &urls)

void	enqueue (const MediaSource &source)

void	enqueue (const QList< MediaSource > &sources)

void	enqueue (const QList< QUrl > &urls)

void	clearQueue ()

qint64	currentTime () const

qint64	totalTime () const

qint64	remainingTime () const

qint32	prefinishMark () const

void	setPrefinishMark (qint32 msecToEnd)

qint32	transitionTime () const

void	setTransitionTime (qint32 msec)

Public Member Functions inherited from Phonon::MediaNode
bool	isValid () const

QList< Path >	inputPaths () const

QList< Path >	outputPaths () const

Properties
qint32	transitionTime
	Defines the time between media sources. More...

qint32	prefinishMark
	Get a signal before playback finishes. More...

qint32	tickInterval
	The time interval in milliseconds between two ticks. More...

Friends
class	FrontendInterfacePrivate

Additional Inherited Members
Protected Member Functions inherited from Phonon::MediaNode
	MediaNode (MediaNodePrivate &dd)

Protected Attributes inherited from Phonon::MediaNode
MediaNodePrivate *const	k_ptr

Detailed Description

Interface for media playback of a given URL.

This class is the most important class in Phonon. Use it to open a media file at an arbitrary location, a CD or DVD or to stream media data from the application to the backend.

This class controls the state (play, pause, stop, seek) and you can use it to get a lot of information about the media data.

Notice that most functions of this class are asynchronous. That means if you call play() the object only starts playing when the stateChanged() signal tells you that the object changed into PlayingState. The states you can expect are documented for those methods.

A common usage example is the following:

media = new MediaObject(this);
connect(media, SIGNAL(finished()), SLOT(slotFinished());
media->setCurrentSource("/home/username/music/filename.ogg");
media->play();

If you want to play more than one media file (one after another) you can either tell MediaObject about all those files

media->setCurrentSource(":/sounds/startsound.ogg");
media->enqueue("/home/username/music/song.mp3");
media->enqueue(":/sounds/endsound.ogg");

or provide the next file just in time:

  media->setCurrentSource(":/sounds/startsound.ogg");
  connect(media, SIGNAL(aboutToFinish()), SLOT(enqueueNextSource()));
}
void enqueueNextSource()
{
  media->enqueue("/home/username/music/song.mp3");
}

Some platforms support system-wide tracking of a user's activities. For instance, the zeitgeist project (http://zeitgeist-project.com) on Linux.

This integration is opt-in only and can be enabled by setting the PlaybackTracking property to true:

media->setProperty("PlaybackTracking", true);

This kind of information is normally used to provide a universal history view to the user, such as what songs were played when, regardless of the media player. This is in addition to any emails read, IM conversations, websites viewed, etc.

Author: Matthias Kretz kretz.nosp@m.@kde.nosp@m..org

Constructor & Destructor Documentation

PHONON_OBJECT_IMPL Phonon::MediaObject::~MediaObject ( )

Destroys the MediaObject.

Member Function Documentation

void Phonon::MediaObject::aboutToFinish ( )

signal

Emitted before the playback of the whole queue stops. When this signal is emitted you still have time to provide the next MediaSource (using enqueue()) so that playback continues.

This signal can be used to provide the next MediaSource just in time for the transition still to work.

See Also: enqueue

void Phonon::MediaObject::bufferStatus ( int percentFilled)

signal

Tells about the status of the buffer.

You can use this signal to show a progress bar to the user when in BufferingState:

progressBar->setRange(0, 100); // this is the default

connect(media, SIGNAL(bufferStatus(int)), progressBar, SLOT(setValue(int)));

Parameters

percentFilled A number between 0 and 100 telling you how much the buffer is filled.

void Phonon::MediaObject::clear ( )

slot

Stops and removes all playing and enqueued media sources.

See Also: setCurrentSource

void Phonon::MediaObject::clearQueue ( )

Clears the queue of sources.

MediaSource Phonon::MediaObject::currentSource ( ) const

Returns the current media source.

See Also: setCurrentSource

void Phonon::MediaObject::currentSourceChanged ( const Phonon::MediaSource & newSource)

signal

Emitted when the MediaObject makes a transition to the next MediaSource in the queue().

In other words, it is emitted when an individual MediaSource is finished.

Parameters

newSource The source that starts to play at the time the signal is emitted.

qint64 Phonon::MediaObject::currentTime ( ) const

Get the current time (in milliseconds) of the file currently being played.

Returns: The current time in milliseconds.

See Also: tick

void Phonon::MediaObject::enqueue ( const MediaSource & source)

Appends one source to the queue. Use this function to provide the next source just in time after the aboutToFinish signal was emitted.

See Also: aboutToFinish; setQueue; clearQueue

void Phonon::MediaObject::enqueue ( const QList< MediaSource > & sources)

Appends multiple sources to the queue.

See Also: setQueue; clearQueue

void Phonon::MediaObject::enqueue ( const QList< QUrl > & urls)

Appends multiple sources to the queue.

See Also: setQueue; clearQueue

QString Phonon::MediaObject::errorString ( ) const

Returns a human-readable description of the last error that occurred.

ErrorType Phonon::MediaObject::errorType ( ) const

Tells your program what to do about the error.

See Also: Phonon::ErrorType

void Phonon::MediaObject::finished ( )

signal

Emitted when the object has finished playback. It is not emitted if you call stop(), pause() or load(), but only on end-of-queue or a critical error.

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.

See Also: currentSourceChanged; aboutToFinish; prefinishMarkReached

bool Phonon::MediaObject::hasVideo ( ) const

Check whether the media data includes a video stream.

Warning: This information cannot be known immediately. It is best to also listen to the hasVideoChanged signal.

  connect(media, SIGNAL(hasVideoChanged(bool)), hasVideoChanged(bool));
  media->setCurrentSource("somevideo.avi");
  media->hasVideo(); // returns false;
}
void hasVideoChanged(bool b)
{
  // b == true
  media->hasVideo(); // returns true;
}

Returns: true if the media contains video data. false otherwise.

See Also: hasVideoChanged

void Phonon::MediaObject::hasVideoChanged ( bool hasVideo)

signal

Emitted whenever the return value of hasVideo() changes.

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().

Parameters

hasVideo true The stream contains video and adding a VideoWidget will show a video. false There is no video data in the stream and adding a VideoWidget will show an empty (black) VideoWidget.

bool Phonon::MediaObject::isSeekable ( ) const

Check whether the current media may be seeked.

Warning: This information cannot be known immediately. It is best to also listen to the seekableChanged signal.

  connect(media, SIGNAL(seekableChanged(bool)), seekableChanged(bool));
  media->setCurrentSource("somevideo.avi");
  media->isSeekable(); // returns false;
}
void seekableChanged(bool b)
{
  // b == true
  media->isSeekable(); // returns true;
}

Returns: true when the current media may be seeked. false otherwise.

See Also: seekableChanged()

QStringList Phonon::MediaObject::metaData ( const QString & key) const

Returns the strings associated with the given key.

Backends should use the keys specified in the Ogg Vorbis documentation: http://xiph.org/vorbis/doc/v-comment.html

Therefore the following should work with every backend:

A typical usage looks like this:

setMetaArtist (media->metaData("ARTIST"     ));
setMetaAlbum  (media->metaData("ALBUM"      ));
setMetaTitle  (media->metaData("TITLE"      ));
setMetaDate   (media->metaData("DATE"       ));
setMetaGenre  (media->metaData("GENRE"      ));
setMetaTrack  (media->metaData("TRACKNUMBER"));
setMetaComment(media->metaData("DESCRIPTION"));

For Audio CDs you can query

metaData("MUSICBRAINZ_DISCID");

to get a DiscID hash that you can use with the MusicBrainz service: http://musicbrainz.org/doc/ClientHOWTO

QStringList Phonon::MediaObject::metaData ( Phonon::MetaData key) const

Returns the strings associated with the given key.

Same as above except that the keys are defined in the Phonon::MetaData enum.

QMultiMap< QString, QString > Phonon::MediaObject::metaData ( ) const

Returns all meta data.

void Phonon::MediaObject::metaDataChanged ( )

signal

This signal is emitted whenever the audio/video data that is being played is associated with new meta data. E.g. for radio streams this happens when the next song is played.

You can get the new meta data with the metaData methods.

void Phonon::MediaObject::pause ( )

slot

Requests playback to pause. If it was paused before nothing changes.

Possible states right after this call:

PlayingState
PausedState
ErrorState

void Phonon::MediaObject::play ( )

slot

Requests playback of the media data to start. Playback only starts when stateChanged() signals that it goes into PlayingState, though.

Possible states right after this call:

BufferingState
PlayingState
ErrorState

void Phonon::MediaObject::prefinishMarkReached ( qint32 msecToEnd)

signal

Emitted when there are only msecToEnd milliseconds left for playback.

Parameters

msecToEnd The remaining time until the playback queue finishes.

Warning: This signal is not emitted when there is another source in the queue. It is only emitted when the queue is empty.

See Also: setPrefinishMark; prefinishMark; aboutToFinish; finished

QList< MediaSource > Phonon::MediaObject::queue ( ) const

Returns the queued media sources. This list does not include the current source (returned by currentSource).

qint64 Phonon::MediaObject::remainingTime ( ) const

Get the remaining time (in milliseconds) of the file currently being played.

Returns: The remaining time in milliseconds.

void Phonon::MediaObject::seek ( qint64 time)

slot

Requests a seek to the time indicated.

You can only seek if state() == 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.

Parameters

time	The time in milliseconds where to continue playing.

Possible states right after this call:

BufferingState
PlayingState
ErrorState

See Also: SeekSlider

void Phonon::MediaObject::seekableChanged ( bool isSeekable)

signal

Emitted whenever the return value of isSeekable() changes.

Normally you'll check isSeekable() first and then let this signal tell you whether seeking is possible now or not. That way you don't have to poll isSeekable().

Parameters

isSeekable true if the stream is seekable (i.e. calling seek() works) false if the stream is not seekable (i.e. all calls to seek() will be ignored)

void Phonon::MediaObject::setCurrentSource ( const MediaSource & source)

Set the media source the MediaObject should use.

Parameters

source The MediaSource object to the media data. You can just as well use a QUrl or QString (for a local file) here. Setting an empty (invalid) source, will stop and remove the current source.

QUrl url("http://www.example.com/music.ogg");

media->setCurrentSource(url);

See Also: currentSource

void Phonon::MediaObject::setQueue ( const QList< MediaSource > & sources)

Set the MediaSources to play when the current media has finished.

This function will overwrite the current queue.

See Also: clearQueue; enqueue

void Phonon::MediaObject::setQueue ( const QList< QUrl > & urls)

Set the MediaSources to play when the current media has finished.

This function overwrites the current queue.

See Also: clearQueue; enqueue

void Phonon::MediaObject::setTickInterval ( qint32 newTickInterval)

slot

Sets the tick interval in milliseconds.

Parameters

newTickInterval the new tick interval in milliseconds.

See Also: tickInterval

Phonon::State Phonon::MediaObject::state ( ) const

Get the current state.

Returns: The state of the object.

See Also: State; stateChanged

void Phonon::MediaObject::stateChanged	(	Phonon::State	newstate,
		Phonon::State	oldstate
	)

signal

Emitted when the state of the MediaObject has changed.

Parameters

newstate	The state the Player is in now.
oldstate	The state the Player was in before.

void Phonon::MediaObject::stop ( )

slot

Requests playback to stop. If it was stopped before nothing changes.

Possible states right after this call:

the state it was in before (e.g. PlayingState)
StoppedState
ErrorState

void Phonon::MediaObject::tick ( qint64 time)

signal

This signal gets emitted every tickInterval milliseconds.

Parameters

time	The position of the media file in milliseconds.

See Also: setTickInterval, tickInterval

qint32 Phonon::MediaObject::tickInterval ( ) const

The time interval in milliseconds between two ticks.

The tick interval is the time that elapses between the emission of two tick signals.

Returns: the tick interval in milliseconds

qint64 Phonon::MediaObject::totalTime ( ) const

Get the total time (in milliseconds) of the file currently being played.

Returns: The total time in milliseconds.

Note: The total time may change throughout playback as more accurate calculations become available, so it is recommended to connect and use the totalTimeChanged signal whenever possible unless best precision is not of importance.

Warning: The total time is undefined until the MediaObject entered the PlayingState. A valid total time is always indicated by emission of the totalTimeChanged signal.

See Also: totalTimeChanged

void Phonon::MediaObject::totalTimeChanged ( qint64 newTotalTime)

signal

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. Initially the totalTime function can not return useful information. You have to wait for this signal to know the real total time.

This signal may appear at any given point after a MediaSource was set. Namely in the LoadingState, BufferingState, PlayingState or PausedState.

Note: When changing the currentSource there is no signal emission until a reasonable value for the new source has been calculated.

Parameters

newTotalTime The length of the media file in milliseconds.

See Also: totalTime

Property Documentation

qint32 Phonon::MediaObject::prefinishMark

readwrite

Get a signal before playback finishes.

This property specifies the time in milliseconds the prefinishMarkReached signal is emitted before the playback finishes. A value of 0 disables the signal.

Defaults to 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 behaviour because the backend might have more information available than your application does through totalTime and currentTime.

See Also: prefinishMarkReached

qint32 Phonon::MediaObject::tickInterval

readwrite

The time interval in milliseconds between two ticks.

The tick interval is the time that elapses between the emission of two tick signals. If you set the interval to 0 the tick signal gets disabled.

Defaults to 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 may fail:
int x = 200;

media->setTickInterval(x);

Q_ASSERT(x == producer->tickInterval());

On the other hand the following is guaranteed:
int x = 200;

media->setTickInterval(x);

Q_ASSERT(x >= producer->tickInterval() &&

x <= 2 * producer->tickInterval());

See Also: tick

qint32 Phonon::MediaObject::transitionTime

readwrite

Defines the time between media sources.

A positive transition time defines a gap of silence between queued media sources.

A transition time of 0 ms requests gapless playback (sample precise queueing of the next source).

A negative transition time defines a crossfade between the queued media sources.

Defaults to 0 (gapless playback).

Warning: This feature might not work reliably on every platform.

The documentation for this class was generated from the following files:

/home/me/src/git/p/phonon/phonon/mediaobject.h
/home/me/src/git/p/phonon/phonon/mediaobject.cpp

Public Slots

Signals

Public Member Functions

Properties

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Property Documentation