Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtmobility/plugins/multimedia/gstreamer/mediaplayer/qgstreamerplayercontrol.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4 
    58     : QMediaPlayerControl(parent)
 
    58     : QMediaPlayerControl(parent)
 
    59     , m_session(session)
 
    59     , m_session(session)
 
    60     , m_state(QMediaPlayer::StoppedState)
 
    60     , m_state(QMediaPlayer::StoppedState)
 
    61     , m_mediaStatus(QMediaPlayer::NoMedia)
 
    61     , m_mediaStatus(QMediaPlayer::NoMedia)
 
    62     , m_bufferProgress(-1)
 
    62     , m_bufferProgress(-1)
 
       
    63     , m_seekToStartPending(false)
 
    63     , m_stream(0)
 
    64     , m_stream(0)
 
    64     , m_fifoNotifier(0)
 
    65     , m_fifoNotifier(0)
 
    65     , m_fifoCanWrite(false)
 
    66     , m_fifoCanWrite(false)
 
    66     , m_bufferSize(0)
 
    67     , m_bufferSize(0)
 
    67     , m_bufferOffset(0)
 
    68     , m_bufferOffset(0)
 
   103     }
 
   104     }
 
   104 }
 
   105 }
 
   105 
   106 
   106 qint64 QGstreamerPlayerControl::position() const
 
   107 qint64 QGstreamerPlayerControl::position() const
 
   107 {
 
   108 {
 
   108     return m_session->position();
 
   109     return m_seekToStartPending ? 0 : m_session->position();
 
   109 }
 
   110 }
 
   110 
   111 
   111 qint64 QGstreamerPlayerControl::duration() const
 
   112 qint64 QGstreamerPlayerControl::duration() const
 
   112 {
 
   113 {
 
   113     return m_session->duration();
 
   114     return m_session->duration();
 
   166     m_session->setPlaybackRate(rate);
 
   167     m_session->setPlaybackRate(rate);
 
   167 }
 
   168 }
 
   168 
   169 
   169 void QGstreamerPlayerControl::setPosition(qint64 pos)
 
   170 void QGstreamerPlayerControl::setPosition(qint64 pos)
 
   170 {
 
   171 {
 
   171     m_session->seek(pos);
 
   172     if (m_mediaStatus == QMediaPlayer::EndOfMedia) {
 
       
   173         m_mediaStatus = QMediaPlayer::LoadedMedia;
 
       
   174         emit mediaStatusChanged(m_mediaStatus);
 
       
   175     }
 
       
   176 
       
   177     if (m_session->seek(pos))
 
       
   178         m_seekToStartPending = false;
 
   172 }
 
   179 }
 
   173 
   180 
   174 void QGstreamerPlayerControl::play()
 
   181 void QGstreamerPlayerControl::play()
 
   175 {
 
   182 {
 
   176     if (m_session->play()) {
 
   183     playOrPause(QMediaPlayer::PlayingState);
 
   177         if (m_state != QMediaPlayer::PlayingState)
 
       
   178             emit stateChanged(m_state = QMediaPlayer::PlayingState);
 
       
   179     }
 
       
   180 }
 
   184 }
 
   181 
   185 
   182 void QGstreamerPlayerControl::pause()
 
   186 void QGstreamerPlayerControl::pause()
 
   183 {
 
   187 {
 
   184     if (m_session->pause()) {
 
   188     playOrPause(QMediaPlayer::PausedState);
 
   185         if (m_state != QMediaPlayer::PausedState)
 
   189 }
 
   186             emit stateChanged(m_state = QMediaPlayer::PausedState);
 
   190 
   187     }
 
   191 void QGstreamerPlayerControl::playOrPause(QMediaPlayer::State newState)
 
   188 }
 
   192 {
 
   189 
   193     QMediaPlayer::State oldState = m_state;
 
   190 void QGstreamerPlayerControl::stop()
 
   194     QMediaPlayer::MediaStatus oldMediaStatus = m_mediaStatus;
 
   191 {
 
   195 
   192     if (m_state != QMediaPlayer::StoppedState) {
 
   196     if (m_mediaStatus == QMediaPlayer::EndOfMedia)
 
       
   197         m_mediaStatus = QMediaPlayer::BufferedMedia;
 
       
   198 
       
   199     if (m_seekToStartPending) {
 
   193         m_session->pause();
 
   200         m_session->pause();
 
   194         if (!m_session->seek(0)) {
 
   201         if (!m_session->seek(0)) {
 
   195             m_bufferProgress = -1;
 
   202             m_bufferProgress = -1;
 
   196             m_session->stop();
 
   203             m_session->stop();
 
   197             m_session->pause();
 
   204             m_mediaStatus = QMediaPlayer::LoadingMedia;
 
   198         }
 
   205         }
 
       
   206         m_seekToStartPending = false;
 
       
   207     }
 
       
   208 
       
   209     bool ok = false;
 
       
   210     if (newState == QMediaPlayer::PlayingState)
 
       
   211         ok = m_session->play();
 
       
   212     else
 
       
   213         ok = m_session->pause();
 
       
   214 
       
   215     if (!ok)
 
       
   216         return;
 
       
   217 
       
   218     m_state = newState;
 
       
   219 
       
   220     if (m_mediaStatus == QMediaPlayer::EndOfMedia || m_mediaStatus == QMediaPlayer::LoadedMedia) {
 
       
   221         if (m_bufferProgress == -1 || m_bufferProgress == 100)
 
       
   222             m_mediaStatus = QMediaPlayer::BufferedMedia;
 
       
   223         else
 
       
   224             m_mediaStatus = QMediaPlayer::BufferingMedia;
 
       
   225     }
 
       
   226 
       
   227     if (m_state != oldState)
 
       
   228         emit stateChanged(m_state);
 
       
   229     if (m_mediaStatus != oldMediaStatus)
 
       
   230         emit mediaStatusChanged(m_mediaStatus);
 
       
   231 
       
   232 }
 
       
   233 
       
   234 void QGstreamerPlayerControl::stop()
 
       
   235 {
 
       
   236     if (m_state != QMediaPlayer::StoppedState) {
 
       
   237         m_state = QMediaPlayer::StoppedState;
 
       
   238         m_session->pause();
 
       
   239         m_seekToStartPending = true;
 
       
   240         updateState(m_session->state());
 
   199         emit positionChanged(0);
 
   241         emit positionChanged(0);
 
   200         if (m_state != QMediaPlayer::StoppedState)
 
   242         emit stateChanged(m_state);
 
   201             emit stateChanged(m_state = QMediaPlayer::StoppedState);
 
       
   202     }
 
   243     }
 
   203 }
 
   244 }
 
   204 
   245 
   205 void QGstreamerPlayerControl::setVolume(int volume)
 
   246 void QGstreamerPlayerControl::setVolume(int volume)
 
   206 {
 
   247 {
 
   240         m_stream = 0;
 
   281         m_stream = 0;
 
   241     }
 
   282     }
 
   242 
   283 
   243     m_currentResource = content;
 
   284     m_currentResource = content;
 
   244     m_stream = stream;
 
   285     m_stream = stream;
 
       
   286     m_seekToStartPending = false;
 
   245 
   287 
   246     QUrl url;
 
   288     QUrl url;
 
   247 
   289 
   248     if (m_stream) {
 
   290     if (m_stream) {
 
   249         if (m_stream->isReadable() && openFifo()) {
 
   291         if (m_stream->isReadable() && openFifo()) {
 
   251         }
 
   293         }
 
   252     } else if (!content.isNull()) {
 
   294     } else if (!content.isNull()) {
 
   253         url = content.canonicalUrl();
 
   295         url = content.canonicalUrl();
 
   254     }
 
   296     }
 
   255 
   297 
   256     m_session->load(url);
 
   298     m_session->load(url);    
   257 
   299 
   258     if (m_fifoFd[1] >= 0) {
 
   300     if (m_fifoFd[1] >= 0) {
 
   259         m_fifoCanWrite = true;
 
   301         m_fifoCanWrite = true;
 
   260 
   302 
   261         writeFifo();
 
   303         writeFifo();
 
   292 }
 
   334 }
 
   293 
   335 
   294 void QGstreamerPlayerControl::updateState(QMediaPlayer::State state)
 
   336 void QGstreamerPlayerControl::updateState(QMediaPlayer::State state)
 
   295 {
 
   337 {
 
   296     QMediaPlayer::MediaStatus oldStatus = m_mediaStatus;
 
   338     QMediaPlayer::MediaStatus oldStatus = m_mediaStatus;
 
       
   339     QMediaPlayer::State oldState = m_state;
 
   297 
   340 
   298     switch (state) {
 
   341     switch (state) {
 
   299     case QMediaPlayer::StoppedState:
 
   342     case QMediaPlayer::StoppedState:
 
   300         if (m_state != QMediaPlayer::StoppedState)
 
   343         m_state = QMediaPlayer::StoppedState;
 
   301             emit stateChanged(m_state = QMediaPlayer::StoppedState);
 
   344         if (m_currentResource.isNull())
 
       
   345             m_mediaStatus = QMediaPlayer::NoMedia;
 
       
   346         else
 
       
   347             m_mediaStatus = QMediaPlayer::LoadingMedia;
 
   302         break;
 
   348         break;
 
   303 
   349 
   304     case QMediaPlayer::PlayingState:
 
   350     case QMediaPlayer::PlayingState:
 
   305     case QMediaPlayer::PausedState:
 
   351     case QMediaPlayer::PausedState:
 
   306         if (m_state == QMediaPlayer::StoppedState)
 
   352         if (m_state == QMediaPlayer::StoppedState) {
 
   307             m_mediaStatus = QMediaPlayer::LoadedMedia;
 
   353             m_mediaStatus = QMediaPlayer::LoadedMedia;
 
   308         else {            
   354         } else {
 
   309             if (m_bufferProgress == -1)
 
   355             if (m_bufferProgress == -1 || m_bufferProgress == 100)
 
   310                 m_mediaStatus = QMediaPlayer::BufferedMedia;
 
   356                 m_mediaStatus = QMediaPlayer::BufferedMedia;
 
   311         }
 
   357         }
 
   312         break;
 
   358         break;
 
   313     }
 
   359     }
 
   314 
   360 
       
   361     //EndOfMedia status should be kept, until reset by pause, play or setMedia
 
       
   362     if (oldStatus == QMediaPlayer::EndOfMedia)
 
       
   363         m_mediaStatus = QMediaPlayer::EndOfMedia;
 
       
   364 
       
   365     if (m_state != oldState)
 
       
   366         emit stateChanged(m_state);
 
   315     if (m_mediaStatus != oldStatus)
 
   367     if (m_mediaStatus != oldStatus)
 
   316         emit mediaStatusChanged(m_mediaStatus);
 
   368         emit mediaStatusChanged(m_mediaStatus);
 
   317 }
 
   369 }
 
   318 
   370 
   319 void QGstreamerPlayerControl::processEOS()
 
   371 void QGstreamerPlayerControl::processEOS()
 
   320 {
 
   372 {
 
   321     m_mediaStatus = QMediaPlayer::EndOfMedia;
 
   373     m_mediaStatus = QMediaPlayer::EndOfMedia;
 
   322     m_state = QMediaPlayer::StoppedState;
 
   374     stop();
 
   323 
       
   324     emit stateChanged(m_state);
 
       
   325     emit mediaStatusChanged(m_mediaStatus);
 
   375     emit mediaStatusChanged(m_mediaStatus);
 
   326 }
 
   376 }
 
   327 
   377 
   328 void QGstreamerPlayerControl::setBufferProgress(int progress)
 
   378 void QGstreamerPlayerControl::setBufferProgress(int progress)
 
   329 {
 
   379 {
FCL/sf/mw/qtextensions