MediaObject Class Reference
from PyKDE4.phonon import *
Inherits: QObject,Phonon.MediaNode
Namespace: Phonon
Detailed Description
\class MediaObject mediaobject.h Phonon/MediaObject 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 that 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"); }
Signals | |
aboutToFinish () | |
bufferStatus (int percentFilled) | |
currentSourceChanged (Phonon.MediaSource newSource) | |
finished () | |
hasVideoChanged (bool hasVideo) | |
metaDataChanged () | |
prefinishMarkReached (int msecToEnd) | |
seekableChanged (bool isSeekable) | |
stateChanged (Phonon.State newstate, Phonon.State oldstate) | |
tick (long time) | |
totalTimeChanged (long newTotalTime) | |
Methods | |
aboutToFinish (self) | |
bufferStatus (self, int percentFilled) | |
clearQueue (self) | |
Phonon.MediaSource | currentSource (self) |
currentSourceChanged (self, Phonon.MediaSource newSource) | |
long | currentTime (self) |
enqueue (self, Phonon.MediaSource source) | |
enqueue (self, [Phonon.MediaSource] sources) | |
enqueue (self, [QUrl] urls) | |
QString | errorString (self) |
ErrorType | errorType (self) |
finished (self) | |
bool | hasVideo (self) |
hasVideoChanged (self, bool hasVideo) | |
bool | isSeekable (self) |
QStringList | metaData (self, QString key) |
QStringList | metaData (self, Phonon.MetaData key) |
QMultiMap | metaData (self) |
metaDataChanged (self) | |
pause (self) | |
play (self) | |
int | prefinishMark (self) |
prefinishMarkReached (self, int msecToEnd) | |
[Phonon.MediaSource] | queue (self) |
long | remainingTime (self) |
seek (self, long time) | |
seekableChanged (self, bool isSeekable) | |
setCurrentSource (self, Phonon.MediaSource source) | |
setPrefinishMark (self, int msecToEnd) | |
setQueue (self, [Phonon.MediaSource] sources) | |
setQueue (self, [QUrl] urls) | |
setTickInterval (self, int newTickInterval) | |
setTransitionTime (self, int msec) | |
State | state (self) |
stateChanged (self, Phonon.State newstate, Phonon.State oldstate) | |
stop (self) | |
tick (self, long time) | |
int | tickInterval (self) |
long | totalTime (self) |
totalTimeChanged (self, long newTotalTime) | |
int | transitionTime (self) |
Method Documentation
aboutToFinish | ( | self ) |
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
- Signal syntax:
QObject.connect(source, SIGNAL("aboutToFinish()"), target_slot)
bufferStatus | ( | self, | ||
int | percentFilled | |||
) |
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.
- Signal syntax:
QObject.connect(source, SIGNAL("bufferStatus(int)"), target_slot)
clearQueue | ( | self ) |
Clears the queue of sources.
Phonon.MediaSource currentSource | ( | self ) |
Returns the current media source.
- See also:
- setCurrentSource
currentSourceChanged | ( | self, | ||
Phonon.MediaSource | newSource | |||
) |
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.
- Signal syntax:
QObject.connect(source, SIGNAL("currentSourceChanged(const MediaSource&)"), target_slot)
long currentTime | ( | self ) |
Get the current time (in milliseconds) of the file currently being played.
- Returns:
- The current time in milliseconds.
- See also:
- tick
enqueue | ( | self, | ||
Phonon.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
- See also:
- setQueue
- See also:
- clearQueue
enqueue | ( | self, | ||
[Phonon.MediaSource] | sources | |||
) |
Appends multiple sources to the queue.
- See also:
- setQueue
- See also:
- clearQueue
enqueue | ( | self, | ||
[QUrl] | urls | |||
) |
Appends multiple sources to the queue.
- See also:
- setQueue
- See also:
- clearQueue
QString errorString | ( | self ) |
Returns a human-readable description of the last error that occurred.
ErrorType errorType | ( | self ) |
Tells your program what to do about the error.
- See also:
- Phonon.ErrorType
finished | ( | self ) |
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
- See also:
- aboutToFinish
- See also:
- prefinishMarkReached
- Signal syntax:
QObject.connect(source, SIGNAL("finished()"), target_slot)
bool hasVideo | ( | self ) |
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
hasVideoChanged | ( | self, | ||
bool | hasVideo | |||
) |
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.
- Signal syntax:
QObject.connect(source, SIGNAL("hasVideoChanged(bool)"), target_slot)
bool isSeekable | ( | self ) |
Check whether the current media may be seeked.
- 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 when the current media may be seeked. false otherwise.
- See also:
- seekableChanged()
QStringList metaData | ( | self, | ||
QString | key | |||
) |
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 metaData | ( | self, | ||
Phonon.MetaData | key | |||
) |
Returns the strings associated with the given key.
Same as above except that the keys are defined in the Phonon.MetaData enum.
QMultiMap |
( | self ) |
Returns all meta data.
metaDataChanged | ( | self ) |
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.
- Signal syntax:
QObject.connect(source, SIGNAL("metaDataChanged()"), target_slot)
pause | ( | self ) |
Requests playback to pause. If it was paused before nothing changes.
Possible states right after this call:
play | ( | self ) |
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:
int prefinishMark | ( | self ) |
prefinishMarkReached | ( | self, | ||
int | msecToEnd | |||
) |
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
- See also:
- prefinishMark
- See also:
- aboutToFinish
- See also:
- finished
- Signal syntax:
QObject.connect(source, SIGNAL("prefinishMarkReached(qint32)"), target_slot)
[Phonon.MediaSource] queue | ( | self ) |
Returns the queued media sources. This does list does not include the current source (returned by currentSource).
long remainingTime | ( | self ) |
Get the remaining time (in milliseconds) of the file currently being played.
- Returns:
- The remaining time in milliseconds.
seek | ( | self, | ||
long | time | |||
) |
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:
- See also:
- SeekSlider
seekableChanged | ( | self, | ||
bool | isSeekable | |||
) |
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)
- Signal syntax:
QObject.connect(source, SIGNAL("seekableChanged(bool)"), target_slot)
setCurrentSource | ( | self, | ||
Phonon.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.
QUrl url("http://www.example.com/music.ogg"); media->setCurrentSource(url);
- See also:
- currentSource
setPrefinishMark | ( | self, | ||
int | msecToEnd | |||
) |
setQueue | ( | self, | ||
[Phonon.MediaSource] | sources | |||
) |
Set the MediaSources to play when the current media has finished.
This function will overwrite the current queue.
- See also:
- clearQueue
- See also:
- enqueue
setQueue | ( | self, | ||
[QUrl] | urls | |||
) |
Set the MediaSources to play when the current media has finished.
This function overwrites the current queue.
- See also:
- clearQueue
- See also:
- enqueue
setTickInterval | ( | self, | ||
int | newTickInterval | |||
) |
setTransitionTime | ( | self, | ||
int | msec | |||
) |
State state | ( | self ) |
Get the current state.
- Returns:
- The state of the object.
- See also:
- State
- See also:
- stateChanged
stateChanged | ( | self, | ||
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.
- Parameters:
-
newstate The state the Player is in now. oldstate The state the Player was in before.
- Signal syntax:
QObject.connect(source, SIGNAL("stateChanged(State, State)"), target_slot)
stop | ( | self ) |
Requests playback to stop. If it was stopped before nothing changes.
Possible states right after this call:
tick | ( | self, | ||
long | time | |||
) |
This signal gets emitted every tickInterval milliseconds.
- Parameters:
-
time The position of the media file in milliseconds.
- See also:
- setTickInterval, tickInterval
- Signal syntax:
QObject.connect(source, SIGNAL("tick(qint64)"), target_slot)
int tickInterval | ( | self ) |
long totalTime | ( | self ) |
Get the total time (in milliseconds) of the file currently being played.
- Returns:
- The total time in milliseconds.
- See also:
- totalTimeChanged
totalTimeChanged | ( | self, | ||
long | 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.
- Parameters:
-
newTotalTime The length of the media file in milliseconds.
- See also:
- totalTime
- Signal syntax:
QObject.connect(source, SIGNAL("totalTimeChanged(qint64)"), target_slot)
int transitionTime | ( | self ) |