src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
changeset 3 41300fa6a67c
parent 0 1918ee327afb
child 4 3b1da2848fc7
equal deleted inserted replaced
2:56cd8111b7f7 3:41300fa6a67c
   107 
   107 
   108     switch (privateState()) {
   108     switch (privateState()) {
   109     case GroundState:
   109     case GroundState:
   110     case LoadingState:
   110     case LoadingState:
   111     case PausedState:
   111     case PausedState:
   112     case ErrorState:
       
   113         // Do nothing
   112         // Do nothing
   114         break;
   113         break;
   115 
   114 
   116     case StoppedState:
   115     case StoppedState:
   117     case PlayingState:
   116     case PlayingState:
       
   117     case ErrorState:
   118     case BufferingState:
   118     case BufferingState:
   119         doPause();
   119         doPause();
   120         stopTickTimer();
   120         stopTickTimer();
   121         changeState(PausedState);
   121         changeState(PausedState);
   122         break;
   122         break;
   287 
   287 
   288     TRACE_EXIT_0();
   288     TRACE_EXIT_0();
   289 }
   289 }
   290 
   290 
   291 
   291 
   292 //-----------------------------------------------------------------------------
       
   293 // VolumeObserver
       
   294 //-----------------------------------------------------------------------------
       
   295 
       
   296 void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
   292 void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
   297 {
   293 {
   298     TRACE_CONTEXT(AbstractMediaPlayer::volumeChanged, EAudioInternal);
   294     TRACE_CONTEXT(AbstractMediaPlayer::volumeChanged, EAudioInternal);
   299     TRACE_ENTRY("state %d", privateState());
   295     TRACE_ENTRY("state %d", privateState());
   300 
   296 
   316 
   312 
   317     case StoppedState:
   313     case StoppedState:
   318     case PausedState:
   314     case PausedState:
   319     case PlayingState:
   315     case PlayingState:
   320     case BufferingState: {
   316     case BufferingState: {
   321         const int err = setDeviceVolume(m_volume * m_mmfMaxVolume);
   317         const qreal volume = (m_volume * m_mmfMaxVolume) + 0.5;
       
   318         const int err = setDeviceVolume(volume);
   322 
   319 
   323         if (KErrNone != err) {
   320         if (KErrNone != err) {
   324             setError(NormalError);
   321             setError(NormalError);
   325         }
   322         }
   326         break;
   323         break;
   357 qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
   354 qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
   358 {
   355 {
   359     return in.Int64() / 1000;
   356     return in.Int64() / 1000;
   360 }
   357 }
   361 
   358 
       
   359 //-----------------------------------------------------------------------------
       
   360 // Slots
       
   361 //-----------------------------------------------------------------------------
       
   362 
       
   363 void MMF::AbstractMediaPlayer::tick()
       
   364 {
       
   365     // For the MWC compiler, we need to qualify the base class.
       
   366     emit MMF::AbstractPlayer::tick(currentTime());
       
   367 }
       
   368 
   362 void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
   369 void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
   363 {
   370 {
   364     TRACE_CONTEXT(AbstractPlayer::changeState, EAudioInternal);
   371     TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);
   365     TRACE_ENTRY("state %d newState %d", privateState(), newState);
       
   366 
       
   367     // TODO: add some invariants to check that the transition is valid
       
   368 
   372 
   369     const Phonon::State oldPhononState = phononState(privateState());
   373     const Phonon::State oldPhononState = phononState(privateState());
   370     const Phonon::State newPhononState = phononState(newState);
   374     const Phonon::State newPhononState = phononState(newState);
   371     if (oldPhononState != newPhononState) {
   375 
   372         TRACE("emit stateChanged(%d, %d)", newPhononState, oldPhononState);
   376     // TODO: add some invariants to check that the transition is valid
   373         emit stateChanged(newPhononState, oldPhononState);
   377     AbstractPlayer::changeState(newState);
   374     }
   378 
   375 
   379     if (LoadingState == oldPhononState && StoppedState == newPhononState) {
   376     setState(newState);
       
   377 
       
   378     if (
       
   379         LoadingState == oldPhononState
       
   380         and StoppedState == newPhononState
       
   381     ) {
       
   382         // Ensure initial volume is set on MMF API before starting playback
   380         // Ensure initial volume is set on MMF API before starting playback
   383         doVolumeChanged();
   381         doVolumeChanged();
   384 
   382 
   385         // Check whether play() was called while clip was being loaded.  If so,
   383         // Check whether play() was called while clip was being loaded.  If so,
   386         // playback should be started now
   384         // playback should be started now
   388             TRACE_0("play was called while loading; starting playback now");
   386             TRACE_0("play was called while loading; starting playback now");
   389             m_playPending = false;
   387             m_playPending = false;
   390             play();
   388             play();
   391         }
   389         }
   392     }
   390     }
   393 
   391 }
   394     TRACE_EXIT_0();
   392 
   395 }
   393 void MMF::AbstractMediaPlayer::updateMetaData()
   396 
   394 {
   397 //-----------------------------------------------------------------------------
   395     TRACE_CONTEXT(AbstractMediaPlayer::updateMetaData, EAudioInternal);
   398 // Slots
   396     TRACE_ENTRY_0();
   399 //-----------------------------------------------------------------------------
   397 
   400 
   398     m_metaData.clear();
   401 void MMF::AbstractMediaPlayer::tick()
   399 
   402 {
   400     const int numberOfEntries = numberOfMetaDataEntries();
   403     // For the MWC compiler, we need to qualify the base class.
   401     for(int i=0; i<numberOfEntries; ++i) {
   404     emit MMF::AbstractPlayer::tick(currentTime());
   402         const QPair<QString, QString> entry = metaDataEntry(i);
       
   403 
       
   404         // Note that we capitalize the key, as required by the Ogg Vorbis
       
   405         // metadata standard to which Phonon adheres:
       
   406         // http://xiph.org/vorbis/doc/v-comment.html
       
   407         m_metaData.insert(entry.first.toUpper(), entry.second);
       
   408     }
       
   409 
       
   410     emit metaDataChanged(m_metaData);
       
   411 
       
   412     TRACE_EXIT_0();
   405 }
   413 }
   406 
   414 
   407 QT_END_NAMESPACE
   415 QT_END_NAMESPACE
   408 
   416