Changeset 561 for trunk/src/3rdparty/phonon/qt7

Timestamp:

Feb 11, 2010, 11:19:06 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/3rdparty/phonon/qt7/backend.mm (modified) (1 diff)
• src/3rdparty/phonon/qt7/mediaobject.h (modified) (9 diffs)
• src/3rdparty/phonon/qt7/mediaobject.mm (modified) (31 diffs)
• src/3rdparty/phonon/qt7/quicktimemetadata.h (modified) (2 diffs)
• src/3rdparty/phonon/qt7/quicktimemetadata.mm (modified) (4 diffs)
• src/3rdparty/phonon/qt7/quicktimevideoplayer.h (modified) (11 diffs)
• src/3rdparty/phonon/qt7/quicktimevideoplayer.mm (modified) (31 diffs)
• src/3rdparty/phonon/qt7/videoframe.mm (modified) (7 diffs)

trunk/src/3rdparty/phonon/qt7/backend.mm

@@ -60 +60 @@
     setProperty("backendVersion", QLatin1String("0.1"));
     setProperty("backendIcon",    QLatin1String(""));
-    setProperty("backendWebsite", QLatin1String("http://qtsoftware.com/"));
+    setProperty("backendWebsite", QLatin1String("http://qt.nokia.com/"));
 }
 

trunk/src/3rdparty/phonon/qt7/mediaobject.h

@@ -25 +25 @@
 
 #include "medianode.h"
+
+#if QT_ALLOW_QUICKTIME
+    #include <QuickTime/QuickTime.h>
+#endif
 
 QT_BEGIN_NAMESPACE
@@ -39 +43 @@
 
     class MediaObject : public MediaNode,
-        public Phonon::MediaObjectInterface, public Phonon::AddonInterface
+        public Phonon::MediaObjectInterface
+#ifndef QT_NO_PHONON_MEDIACONTROLLER
+        , public Phonon::AddonInterface
+#endif
     {
         Q_OBJECT
@@ -92 +99 @@
 
                 int videoOutputCount();
+
+#if QT_ALLOW_QUICKTIME
+        void displayLinkEvent();
+#endif
 
     signals:
@@ -106 +117 @@
         void currentSourceChanged(const MediaSource &newSource);
 
+        // Add-on interface:
+        void availableSubtitlesChanged();
+        void availableAudioChannelsChanged();
+        void titleChanged(int);
+        void availableTitlesChanged(int);
+        void chapterChanged(int);
+        void availableChaptersChanged(int);
+        void angleChanged(int);
+        void availableAnglesChanged(int);
+
     protected:
         void mediaNodeEvent(const MediaNodeEvent *event);
@@ -119 +140 @@
         QuickTimeAudioPlayer *m_nextAudioPlayer;
         MediaObjectAudioNode *m_mediaObjectAudioNode;
-        QuickTimeMetaData *m_metaData;
+
+#if QT_ALLOW_QUICKTIME
+        CVDisplayLinkRef m_displayLink;
+        QMutex m_displayLinkMutex;
+        bool m_pendingDisplayLinkEvent;
+        void startDisplayLink();
+        void stopDisplayLink();
+#endif
 
         qint32 m_tickInterval;
@@ -128 +156 @@
 
         int m_tickTimer;
-        int m_bufferTimer;
+        int m_videoTimer;
+        int m_audioTimer;
         int m_rapidTimer;
 
@@ -134 +163 @@
         int m_swapTimeLeft;
         QTime m_swapTime;
+        bool m_autoplayTitles;
 
         void synchAudioVideo();
@@ -142 +172 @@
         void play_internal();
         void setupAudioSystem();
-        void updateTimer(int &timer, int interval);
-        void bufferAudioVideo();
+        void restartAudioVideoTimers();
         void updateRapidly();
         void updateCrossFade();
@@ -155 +184 @@
         void inspectGraph();
         bool isCrossFading();
+        void setCurrentTrack(int track);
 
         QString m_errorString;

trunk/src/3rdparty/phonon/qt7/mediaobject.mm

@@ -47 +47 @@
     setAudioNode(m_mediaObjectAudioNode);
 
-    m_metaData = new QuickTimeMetaData();
     m_audioGraph = new AudioGraph(this);
 
@@ -56 +55 @@
     m_percentageLoaded = 0;
     m_waitNextSwap = false;
+    m_autoplayTitles = true;
     m_audioEffectCount = 0;
     m_audioOutputCount = 0;
@@ -64 +64 @@
 
     m_tickTimer = 0;
-    m_bufferTimer = 0;
+    m_videoTimer = 0;
+    m_audioTimer = 0;
     m_rapidTimer = 0;
 
+#if QT_ALLOW_QUICKTIME
+    m_displayLink = 0;
+    m_pendingDisplayLinkEvent = false;
+#endif
+
     checkForError();
 }
 
 MediaObject::~MediaObject()
-{   
-    // m_mediaObjectAudioNode is owned by super class.    
+{
+    // m_mediaObjectAudioNode is owned by super class.
+#if QT_ALLOW_QUICKTIME
+    stopDisplayLink();
+#endif
     m_audioPlayer->unsetVideoPlayer();
     m_nextAudioPlayer->unsetVideoPlayer();
     delete m_videoPlayer;
     delete m_nextVideoPlayer;
-    delete m_metaData;
     checkForError();
 }
@@ -89 +97 @@
         if (m_state != state){
             // End-application did something
-            // upon  receiving the signal. 
+            // upon  receiving the signal.
             return false;
         }
@@ -123 +131 @@
     // effects or outputs connected. This will have
     // influence on the audio system and video system that ends up beeing used:
-    int prevVideoOutputCount = m_videoOutputCount;      
+    int prevVideoOutputCount = m_videoOutputCount;
     m_audioEffectCount = 0;
     m_audioOutputCount = 0;
@@ -135 +143 @@
             MediaNodeEvent e1(MediaNodeEvent::VideoOutputCountChanged, &m_videoOutputCount);
             notify(&e1);
-        }       
+    }
 }
 
@@ -168 +176 @@
     if (newAudioSystem == m_audioSystem)
         return;
-  
+
     // Enable selected audio system:
-    m_audioSystem = newAudioSystem; 
+    m_audioSystem = newAudioSystem;
     switch (newAudioSystem){
         case AS_Silent:
             m_audioGraph->stop();
             m_videoPlayer->enableAudio(false);
-            m_nextVideoPlayer->enableAudio(false);    
+            m_nextVideoPlayer->enableAudio(false);
             m_audioPlayer->enableAudio(false);
             m_nextAudioPlayer->enableAudio(false);
@@ -215 +223 @@
         PhononAutoReleasePool pool;
     setState(Phonon::LoadingState);
-    
+
     // Save current state for event/signal handling below:
     bool prevHasVideo = m_videoPlayer->hasVideo();
     qint64 prevTotalTime = totalTime();
+    int prevTrackCount = m_videoPlayer->trackCount();
     m_waitNextSwap = false;
-        
+
     // Cancel cross-fade if any:
     m_nextVideoPlayer->pause();
     m_nextAudioPlayer->pause();
     m_mediaObjectAudioNode->cancelCrossFade();
-    
+
     // Set new source:
     m_audioPlayer->unsetVideoPlayer();
     m_videoPlayer->setMediaSource(source);
     m_audioPlayer->setVideoPlayer(m_videoPlayer);
-    m_metaData->setVideo(m_videoPlayer);        
-
-    m_audioGraph->updateStreamSpecifications();        
+
+    m_audioGraph->updateStreamSpecifications();
     m_nextAudioPlayer->unsetVideoPlayer();
-    m_nextVideoPlayer->unsetVideo();
+    m_nextVideoPlayer->unsetCurrentMediaSource();
     m_currentTime = 0;
-        
+
     // Emit/notify information about the new source:
     QRect videoRect = m_videoPlayer->videoRect();
@@ -247 +255 @@
 
     emit currentSourceChanged(source);
-    emit metaDataChanged(m_metaData->metaData());
+    emit metaDataChanged(m_videoPlayer->metaData());
 
     if (prevHasVideo != m_videoPlayer->hasVideo())
-        emit hasVideoChanged(m_videoPlayer->hasVideo());        
+        emit hasVideoChanged(m_videoPlayer->hasVideo());
     if (prevTotalTime != totalTime())
-        emit totalTimeChanged(totalTime());        
+        emit totalTimeChanged(totalTime());
+    if (prevTrackCount != m_videoPlayer->trackCount())
+        emit availableTitlesChanged(m_videoPlayer->trackCount());
     if (checkForError())
         return;
@@ -261 +271 @@
     if (!m_videoPlayer->canPlayMedia())
         SET_ERROR("Cannot play media.", FATAL_ERROR)
-        
+
     // The state might have changed from LoadingState
     // as a response to an error state change. So we
@@ -288 +298 @@
     bool prevHasVideo = m_videoPlayer->hasVideo();
     qint64 prevTotalTime = totalTime();
+    int prevTrackCount = m_videoPlayer->trackCount();
 
     qSwap(m_audioPlayer, m_nextAudioPlayer);
@@ -293 +304 @@
     m_mediaObjectAudioNode->startCrossFade(transitionTime);
     m_audioGraph->updateStreamSpecifications();
-    m_metaData->setVideo(m_videoPlayer);
 
     m_waitNextSwap = false;
     m_currentTime = 0;
-        
+
     // Emit/notify information about the new source:
     QRect videoRect = m_videoPlayer->videoRect();
@@ -304 +314 @@
 
     emit currentSourceChanged(m_videoPlayer->mediaSource());
-    emit metaDataChanged(m_metaData->metaData());
+    emit metaDataChanged(m_videoPlayer->metaData());
 
     if (prevHasVideo != m_videoPlayer->hasVideo())
-        emit hasVideoChanged(m_videoPlayer->hasVideo());        
+        emit hasVideoChanged(m_videoPlayer->hasVideo());
     if (prevTotalTime != totalTime())
         emit totalTimeChanged(totalTime());
+    if (prevTrackCount != m_videoPlayer->trackCount())
+        emit availableTitlesChanged(m_videoPlayer->trackCount());
     if (checkForError())
         return;
@@ -328 +340 @@
 }
 
-void MediaObject::updateTimer(int &timer, int interval)
-{
-    if (timer)
-        killTimer(timer);
-    timer = 0;
-    if (interval >= 0)    
-        timer = startTimer(interval); 
+#if QT_ALLOW_QUICKTIME
+static CVReturn displayLinkCallback(CVDisplayLinkRef /*displayLink*/,
+                                                                 const CVTimeStamp */*inNow*/,
+                                                                 const CVTimeStamp */*inOutputTime*/,
+                                                                 CVOptionFlags /*flagsIn*/,
+                                                                 CVOptionFlags */*flagsOut*/,
+                                 void *userData)
+{
+    MediaObject *mediaObject = static_cast<MediaObject *>(userData);
+    mediaObject->displayLinkEvent();
+    return kCVReturnSuccess;
+}
+
+void MediaObject::displayLinkEvent()
+{
+    // This function is called from a
+    // thread != gui thread. So we post the event.
+    // But we need to make sure that we don't post faster
+    // than the event loop can eat:
+    m_displayLinkMutex.lock();
+    bool pending = m_pendingDisplayLinkEvent;
+    m_pendingDisplayLinkEvent = true;
+    m_displayLinkMutex.unlock();
+
+    if (!pending)
+        qApp->postEvent(this, new QEvent(QEvent::User), Qt::HighEventPriority);
+}
+
+void MediaObject::startDisplayLink()
+{
+    if (m_displayLink)
+        return;
+    OSStatus err = CVDisplayLinkCreateWithCGDisplay(kCGDirectMainDisplay, &m_displayLink);
+    if (err != noErr)
+        goto fail;
+    err = CVDisplayLinkSetCurrentCGDisplay(m_displayLink, kCGDirectMainDisplay);
+    if (err != noErr)
+        goto fail;
+    err = CVDisplayLinkSetOutputCallback(m_displayLink, displayLinkCallback, this);
+    if (err != noErr)
+        goto fail;
+    err = CVDisplayLinkStart(m_displayLink);
+    if (err != noErr)
+        goto fail;
+    return;
+fail:
+    stopDisplayLink();
+}
+
+void MediaObject::stopDisplayLink()
+{
+    if (!m_displayLink)
+        return;
+    CVDisplayLinkStop(m_displayLink);
+    CFRelease(m_displayLink);
+    m_displayLink = 0;
+}
+#endif
+
+void MediaObject::restartAudioVideoTimers()
+{
+    if (m_videoTimer)
+        killTimer(m_videoTimer);
+    if (m_audioTimer)
+        killTimer(m_audioTimer);
+
+#if QT_ALLOW_QUICKTIME
+    // We prefer to use a display link as timer if available, since
+    // it is more steady, and results in better and smoother frame drawing:
+    startDisplayLink();
+    if (!m_displayLink){
+        float fps = m_videoPlayer->staticFps();
+        long videoUpdateFrequency = fps ? long(1000.0f / fps) : 0.001;
+        m_videoTimer = startTimer(videoUpdateFrequency);
+    }
+#else
+    float fps = m_videoPlayer->staticFps();
+    long videoUpdateFrequency = fps ? long(1000.0f / fps) : 0.001;
+    m_videoTimer = startTimer(videoUpdateFrequency);
+#endif
+
+    long audioUpdateFrequency = m_audioPlayer->regularTaskFrequency();
+    m_audioTimer = startTimer(audioUpdateFrequency);
+    updateVideoFrames();
+    updateAudioBuffers();
 }
 
@@ -341 +431 @@
     // Play main audio/video:
     m_videoPlayer->play();
-    m_audioPlayer->play();     
+    m_audioPlayer->play();
     updateLipSynch(0);
     // Play old audio/video to finish cross-fade:
@@ -348 +438 @@
         m_nextAudioPlayer->play();
     }
-    bufferAudioVideo();
-    updateTimer(m_rapidTimer, 100);
+    restartAudioVideoTimers();
+    if (!m_rapidTimer)
+        m_rapidTimer = startTimer(100);
 }
 
@@ -359 +450 @@
     m_videoPlayer->pause();
     m_nextVideoPlayer->pause();
-    updateTimer(m_rapidTimer, -1);
-    updateTimer(m_bufferTimer, -1);
-
+    killTimer(m_rapidTimer);
+    killTimer(m_videoTimer);
+    killTimer(m_audioTimer);
+    m_rapidTimer = 0;
+    m_videoTimer = 0;
+    m_audioTimer = 0;
+#if QT_ALLOW_QUICKTIME
+    stopDisplayLink();
+#endif
     if (m_waitNextSwap)
         m_swapTimeLeft = m_swapTime.msecsTo(QTime::currentTime());
@@ -383 +480 @@
         return;
     if (!setState(Phonon::PlayingState))
-        return;        
+        return;
     if (m_audioSystem == AS_Graph){
         m_audioGraph->start();
@@ -424 +521 @@
         return;
     m_waitNextSwap = false;
-    m_nextVideoPlayer->unsetVideo();
+    m_nextVideoPlayer->unsetCurrentMediaSource();
     m_nextAudioPlayer->unsetVideoPlayer();
     pause_internal();
@@ -436 +533 @@
     if (m_state == Phonon::ErrorState)
         return;
-        
+
     // Stop cross-fade if any:
-    m_nextVideoPlayer->unsetVideo();
+    m_nextVideoPlayer->unsetCurrentMediaSource();
     m_nextAudioPlayer->unsetVideoPlayer();
     m_mediaObjectAudioNode->cancelCrossFade();
@@ -447 +544 @@
     m_audioPlayer->seek(m_videoPlayer->currentTime());
     m_mediaObjectAudioNode->setMute(false);
-    
+
     // Update time and cancel pending swap:
     if (m_currentTime < m_videoPlayer->duration())
@@ -558 +655 @@
 {
     IMPLEMENTED_SILENT;
-    const_cast<MediaObject *>(this)->updateCurrentTime(); 
+    const_cast<MediaObject *>(this)->updateCurrentTime();
     return m_currentTime;
 }
@@ -568 +665 @@
     quint64 total = m_videoPlayer->duration();
 
-    // Check if it's time to emit aboutToFinish:
-    quint32 mark = qMax(quint64(0), qMin(total, total + m_transitionTime - 2000));
-    if (lastUpdateTime < mark && mark <= m_currentTime)
-        emit aboutToFinish();
-
-    // Check if it's time to emit prefinishMarkReached:
-    mark = qMax(quint64(0), total - m_prefinishMark);
-    if (lastUpdateTime < mark && mark <= m_currentTime)
-        emit prefinishMarkReached(total - m_currentTime);
-
-    if (m_nextVideoPlayer->state() == QuickTimeVideoPlayer::NoMedia){
-        // There is no next source in que.
-        // Check if it's time to emit finished:
+    if (m_videoPlayer->currentTrack() < m_videoPlayer->trackCount() - 1){
+        // There are still more tracks to play after the current track.
+        if (m_autoplayTitles) {
+            if (lastUpdateTime < m_currentTime && m_currentTime == total)
+                setCurrentTrack(m_videoPlayer->currentTrack() + 1);
+        }
+    } else if (m_nextVideoPlayer->state() == QuickTimeVideoPlayer::NoMedia){
+        // There is no more sources or tracks to play after the current source.
+        // Check if it's time to emit aboutToFinish:
+        quint32 mark = qMax(quint64(0), qMin(total, total + m_transitionTime - 2000));
+        if (lastUpdateTime < mark && mark <= m_currentTime)
+            emit aboutToFinish();
+
+        // Check if it's time to emit prefinishMarkReached:
+        mark = qMax(quint64(0), total - m_prefinishMark);
+        if (lastUpdateTime < mark && mark <= m_currentTime)
+            emit prefinishMarkReached(total - m_currentTime);
+
         if (lastUpdateTime < m_currentTime && m_currentTime == total){
             emit finished();
@@ -590 +692 @@
         // We have a next source.
         // Check if it's time to swap to next source:
-        mark = qMax(quint64(0), total + m_transitionTime);
+        quint32 mark = qMax(quint64(0), total + m_transitionTime);
         if (m_waitNextSwap && m_state == Phonon::PlayingState &&
             m_transitionTime < m_swapTime.msecsTo(QTime::currentTime())){
@@ -693 +795 @@
 void MediaObject::updateCrossFade()
 {
-    m_mediaObjectAudioNode->updateCrossFade(m_currentTime);   
+    m_mediaObjectAudioNode->updateCrossFade(m_currentTime);
     // Clean-up previous movie if done fading:
     if (m_mediaObjectAudioNode->m_fadeDuration == 0){
         if (m_nextVideoPlayer->isPlaying() || m_nextAudioPlayer->isPlaying()){
-            m_nextVideoPlayer->unsetVideo();
+            m_nextVideoPlayer->unsetCurrentMediaSource();
             m_nextAudioPlayer->unsetVideoPlayer();
         }
-    }        
+    }
 }
 
@@ -729 +831 @@
     if (m_videoPlayer->videoFrameChanged()){
         updateLipSynch(50);
-        VideoFrame frame(m_videoPlayer);           
+        VideoFrame frame(m_videoPlayer);
         if (m_nextVideoPlayer->isPlaying()
             && m_nextVideoPlayer->hasVideo()
@@ -737 +839 @@
             frame.setBaseOpacity(m_mediaObjectAudioNode->m_volume1);
         }
-        
+
         // Send the frame through the graph:
-        updateVideo(frame);    
+        updateVideo(frame);
         checkForError();
     }
@@ -750 +852 @@
     if (m_videoSinkList.isEmpty() || m_audioSinkList.isEmpty())
         return;
-        
+
     if (m_videoPlayer->hasVideo()){
         qint64 diff = m_audioPlayer->currentTime() - m_videoPlayer->currentTime();
@@ -762 +864 @@
             m_nextAudioPlayer->seek(m_nextVideoPlayer->currentTime());
     }
-}
-
-void MediaObject::bufferAudioVideo()
-{
-    long nextVideoUpdate = m_videoPlayer->hasVideo() ? 30 : INT_MAX;
-    long nextAudioUpdate = m_audioPlayer->regularTaskFrequency();
-    updateAudioBuffers();
-    updateVideoFrames();
-    if (m_state == Phonon::PlayingState)
-        updateTimer(m_bufferTimer, qMin(nextVideoUpdate, nextAudioUpdate));
 }
 
@@ -798 +890 @@
             checkForError();
             m_mediaObjectAudioNode->setMute(false);
-             if (m_state == Phonon::PlayingState)
-                bufferAudioVideo();
+            if (m_state == Phonon::PlayingState)
+                restartAudioVideoTimers();
             break;
         case MediaNodeEvent::AudioGraphCannotPlay:
@@ -810 +902 @@
                 m_mediaObjectAudioNode->setMute(false);
             }
-            break; 
-        default:
-            break;
-    }
-}
-
-bool MediaObject::event(QEvent *event)
-{
-    switch (event->type()){
-        case QEvent::Timer: {
-            QTimerEvent *timerEvent = static_cast<QTimerEvent *>(event);
-            if (timerEvent->timerId() == m_rapidTimer)
-                updateRapidly();
-            else if (timerEvent->timerId() == m_tickTimer)
-                emit tick(currentTime());
-            else if (timerEvent->timerId() == m_bufferTimer)
-                bufferAudioVideo();
-            }
             break;
         default:
             break;
     }
+}
+
+bool MediaObject::event(QEvent *event)
+{
+    switch (event->type()){
+#if QT_ALLOW_QUICKTIME
+        case QEvent::User:{
+            m_displayLinkMutex.lock();
+            m_pendingDisplayLinkEvent = false;
+            m_displayLinkMutex.unlock();
+            updateVideoFrames();
+            break; }
+#endif
+        case QEvent::Timer:{
+            int timerId = static_cast<QTimerEvent *>(event)->timerId();
+            if (timerId == m_rapidTimer)
+                updateRapidly();
+            else if (timerId == m_tickTimer)
+                emit tick(currentTime());
+            else if (timerId == m_videoTimer)
+                updateVideoFrames();
+            else if (timerId == m_audioTimer)
+                updateAudioBuffers();
+            break; }
+        default:
+            break;
+    }
     return QObject::event(event);
 }
 
-bool MediaObject::hasInterface(Interface /*interface*/) const
-{
-    return false;
-}
-
-QVariant MediaObject::interfaceCall(Interface /*interface*/, int /*command*/, const QList<QVariant> &/*arguments*/)
-{
+void MediaObject::setCurrentTrack(int track)
+{
+    if (track == m_videoPlayer->currentTrack() || track < 0 || track >= m_videoPlayer->trackCount())
+        return;
+
+    m_videoPlayer->setCurrentTrack(track);
+    emit titleChanged(track);
+    emit metaDataChanged(m_videoPlayer->metaData());
+}
+
+bool MediaObject::hasInterface(Interface iface) const
+{
+    return iface == AddonInterface::TitleInterface;
+}
+
+QVariant MediaObject::interfaceCall(Interface iface, int command, const QList<QVariant> &params)
+{
+    switch (iface) {
+        case TitleInterface:
+            switch (command) {
+                case availableTitles:
+                    return m_videoPlayer->trackCount();
+                case title:
+                    return m_videoPlayer->currentTrack();
+                case setTitle:
+                    setCurrentTrack(params.first().toInt());
+                    break;
+                case autoplayTitles:
+                    return m_autoplayTitles;
+                case setAutoplayTitles:
+                    m_autoplayTitles = params.first().toBool();
+                    break;
+            }
+        default:
+            break;
+    }
     return QVariant();
 }

trunk/src/3rdparty/phonon/qt7/quicktimemetadata.h

@@ -39 +39 @@
     {
         public:
-            QuickTimeMetaData();
-            virtual ~QuickTimeMetaData();
-
-            void setVideo(QuickTimeVideoPlayer *videoPlayer);
+            QuickTimeMetaData(QuickTimeVideoPlayer *videoPlayer);
+            void update();
             QMultiMap<QString, QString> metaData();
 
@@ -50 +48 @@
             QuickTimeVideoPlayer *m_videoPlayer;
             void readMetaData();
+            void guessMetaDataForCD();
+            void readMetaDataFromMovie();
 
 #ifdef QUICKTIME_C_API_AVAILABLE

trunk/src/3rdparty/phonon/qt7/quicktimemetadata.mm

@@ -16 +16 @@
 */
 
+#include <QtCore/QFileInfo>
 #include "quicktimemetadata.h"
 #include "quicktimevideoplayer.h"
@@ -26 +27 @@
 {
 
-QuickTimeMetaData::QuickTimeMetaData()
-{
-    m_videoPlayer = 0;
+QuickTimeMetaData::QuickTimeMetaData(QuickTimeVideoPlayer *videoPlayer)
+{
+    m_videoPlayer = videoPlayer;
     m_movieChanged = false;
 }
 
-QuickTimeMetaData::~QuickTimeMetaData()
-{
-}
-
-void QuickTimeMetaData::setVideo(QuickTimeVideoPlayer *videoPlayer)
-{
-    m_videoPlayer = videoPlayer;
+void QuickTimeMetaData::update()
+{
     m_movieChanged = true;
     m_metaData.clear();
@@ -146 +142 @@
 #endif // QUICKTIME_C_API_AVAILABLE
 
-void QuickTimeMetaData::readMetaData()
-{
-        if (!m_videoPlayer)
-        return;
+void QuickTimeMetaData::guessMetaDataForCD()
+{
+    QString album = QFileInfo(m_videoPlayer->movieCompactDiscPath()).fileName();
+    QString title = QFileInfo(m_videoPlayer->currentTrackPath()).fileName();
+    title = title.left(title.lastIndexOf('.'));
+    m_metaData.insert(QLatin1String("ALBUM"), album);
+    m_metaData.insert(QLatin1String("TITLE"), title);
+    m_metaData.insert(QLatin1String("TRACKNUMBER"), QString::number(m_videoPlayer->currentTrack()));
+}
+
+void QuickTimeMetaData::readMetaDataFromMovie()
+{
     QMultiMap<QString, QString> metaMap;
-    
+
 #ifdef QUICKTIME_C_API_AVAILABLE
-        QTMetaDataRef metaDataRef;        
+    QTMetaDataRef metaDataRef;
         OSStatus err = QTCopyMovieMetaData([m_videoPlayer->qtMovie() quickTimeMovie], &metaDataRef);
     BACKEND_ASSERT2(err == noErr, "Could not read QuickTime meta data", NORMAL_ERROR)
@@ -174 +178 @@
 }
 
+void QuickTimeMetaData::readMetaData()
+{
+        if (!m_videoPlayer)
+        return;
+
+    if (m_videoPlayer->mediaSource().type() == Phonon::MediaSource::Disc)
+        guessMetaDataForCD();
+    else
+        readMetaDataFromMovie();
+}
+
 QMultiMap<QString, QString> QuickTimeMetaData::metaData()
 {

trunk/src/3rdparty/phonon/qt7/quicktimevideoplayer.h

@@ -40 +40 @@
 {
     class QuickTimeStreamReader;
+    class QuickTimeMetaData;
         class VideoRenderWidgetQTMovieView;
 
@@ -57 +58 @@
             void setMediaSource(const MediaSource &source);
             MediaSource mediaSource() const;
-            void unsetVideo();
+            void unsetCurrentMediaSource();
 
             void play();
@@ -68 +69 @@
                         void *currentFrameAsCIImage();
             QImage currentFrameAsQImage();
+            void releaseImageCache();
             QRect videoRect() const;
 
@@ -73 +75 @@
             quint64 currentTime() const;
             long timeScale() const;
+            float staticFps();
             QString currentTimeString();
 
@@ -85 +88 @@
             void setPlaybackRate(float rate);
             QTMovie *qtMovie() const;
+            QMultiMap<QString, QString> metaData();
 
             float playbackRate() const;
@@ -104 +108 @@
             quint64 timeLoaded();
 
+            int trackCount() const;
+            int currentTrack() const;
+            void setCurrentTrack(int track);
+            QString movieCompactDiscPath() const;
+            QString currentTrackPath() const;
+
             static QString timeToString(quint64 ms);
 
@@ -117 +127 @@
             State m_state;
             QGLPixelBuffer *m_QImagePixelBuffer;
+            QuickTimeMetaData *m_metaData;
+
+            CVOpenGLTextureRef m_cachedCVTextureRef;
+            QImage m_cachedQImage;
 
             bool m_playbackRateSat;
@@ -127 +141 @@
             float m_relativeVolume;
             float m_playbackRate;
+            float m_staticFps;
             quint64 m_currentTime;
             MediaSource m_mediaSource;
+
                         void *m_primaryRenderingCIImage;
                         qreal m_brightness;
@@ -134 +150 @@
                         qreal m_hue;
                         qreal m_saturation;
+            NSArray *m_folderTracks;
+            int m_currentTrack;
+            QString m_movieCompactDiscPath;
 
 #ifdef QUICKTIME_C_API_AVAILABLE
@@ -141 +160 @@
             QuickTimeStreamReader *m_streamReader;
 
+            void prepareCurrentMovieForPlayback();
             void createVisualContext();
             void openMovieFromCurrentMediaSource();
@@ -147 +167 @@
             void openMovieFromUrl();
             void openMovieFromStream();
+            void openMovieFromCompactDisc();
             void openMovieFromData(QByteArray *data, char *fileType);
             void openMovieFromDataGuessType(QByteArray *data);
                         QString mediaSourcePath();
                         bool codecExistsAccordingToSuffix(const QString &fileName);
+            NSString* pathToCompactDisc();
+            bool isCompactDisc(NSString *path);
+            NSArray* scanFolder(NSString *path);
 
             void setError(NSError *error);
             bool errorOccured();
             void readProtection();
+            void calculateStaticFps();
             void checkIfVideoAwailable();
             bool movieNotLoaded();

trunk/src/3rdparty/phonon/qt7/quicktimevideoplayer.mm

@@ -21 +21 @@
 #include "audiodevice.h"
 #include "quicktimestreamreader.h"
+#include "quicktimemetadata.h"
 
 #include <QtCore/QCoreApplication>
@@ -53 +54 @@
     m_state = NoMedia;
     m_mediaSource = MediaSource();
+    m_metaData = new QuickTimeMetaData(this);
     m_QTMovie = 0;
     m_streamReader = 0;
@@ -62 +64 @@
     m_audioEnabled = false;
     m_hasVideo = false;
+    m_staticFps = 0;
     m_playbackRateSat = false;
     m_isDrmProtected = false;
@@ -68 +71 @@
         m_primaryRenderingCIImage = 0;
     m_QImagePixelBuffer = 0;
+    m_cachedCVTextureRef = 0;
+    m_folderTracks = 0;
+    m_currentTrack = 0;
 
 #ifdef QUICKTIME_C_API_AVAILABLE
@@ -78 +84 @@
 QuickTimeVideoPlayer::~QuickTimeVideoPlayer()
 {
-    unsetVideo();
+        PhononAutoReleasePool pool;
+    unsetCurrentMediaSource();
+    delete m_metaData;
     [(NSObject*)m_primaryRenderingTarget release];
     m_primaryRenderingTarget = 0;
@@ -85 +93 @@
         CFRelease(m_visualContext);
 #endif
+}
+
+void QuickTimeVideoPlayer::releaseImageCache()
+{
+    if (m_cachedCVTextureRef){
+        CVOpenGLTextureRelease(m_cachedCVTextureRef);
+        m_cachedCVTextureRef = 0;
+    }
+    m_cachedQImage = QImage();
 }
 
@@ -126 +143 @@
 
     QTVisualContextTask(m_visualContext);
-    return QTVisualContextIsNewImageAvailable(m_visualContext, 0);
+    bool changed = QTVisualContextIsNewImageAvailable(m_visualContext, 0);
+    if (changed)
+        releaseImageCache();
+    return changed;
 
 #elif defined(QT_MAC_USE_COCOA)
@@ -141 +161 @@
     if (!m_visualContext)
         return 0;
-    CVOpenGLTextureRef texture = 0;
-    OSStatus err = QTVisualContextCopyImageForTime(m_visualContext, 0, 0, &texture);
-    BACKEND_ASSERT3(err == noErr, "Could not copy image for time in QuickTime player", FATAL_ERROR, 0)
-    return texture;
+    if (!m_cachedCVTextureRef){
+        OSStatus err = QTVisualContextCopyImageForTime(m_visualContext, 0, 0, &m_cachedCVTextureRef);
+        BACKEND_ASSERT3(err == noErr, "Could not copy image for time in QuickTime player", FATAL_ERROR, 0)
+    }
+    return m_cachedCVTextureRef;
 
 #else
@@ -153 +174 @@
 QImage QuickTimeVideoPlayer::currentFrameAsQImage()
 {
+    if (!m_cachedQImage.isNull())
+        return m_cachedQImage;
+
 #ifdef QUICKTIME_C_API_AVAILABLE
     QGLContext *prevContext = const_cast<QGLContext *>(QGLContext::currentContext());
@@ -182 +206 @@
     glEnd();
 
-    QImage image = m_QImagePixelBuffer->toImage();
-    CVOpenGLTextureRelease(texture);
+    m_cachedQImage = m_QImagePixelBuffer->toImage();
     // Because of QuickTime, m_QImagePixelBuffer->doneCurrent() will fail.
     // So we store, and restore, the context our selves:
     prevContext->makeCurrent();
-    return image;
+    return m_cachedQImage;
 #else
         CIImage *img = (CIImage *)currentFrameAsCIImage();
@@ -196 +219 @@
         CGRect bounds = [img extent];
         QImage qImg([bitmap bitmapData], bounds.size.width, bounds.size.height, QImage::Format_ARGB32);
-        QImage swapped = qImg.rgbSwapped();
+        m_cachedQImage = qImg.rgbSwapped();
         [bitmap release];
         [img release];
-        return swapped;
+        return m_cachedQImage;
 #endif
 }
@@ -251 +274 @@
         CVOpenGLTextureRef cvImg = currentFrameAsCVTexture();
         CIImage *img = [[CIImage alloc] initWithCVImageBuffer:cvImg];
-        CVOpenGLTextureRelease(cvImg);
-        return img;     
+        return img;
 #else
         return 0;
@@ -274 +296 @@
     int samplesPerPixel = [bitmap samplesPerPixel];
     if (![bitmap isPlanar] && (samplesPerPixel == 3 || samplesPerPixel == 4)){
-        glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, 
+        glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0,
             samplesPerPixel == 4 ? GL_RGBA8 : GL_RGB8,
             [bitmap pixelsWide], [bitmap pixelsHigh],
@@ -303 +325 @@
     m_relativeVolume = relativeVolume;
     if (!m_QTMovie || !m_audioEnabled || m_mute)
-        return;                
+        return;
     [m_QTMovie setVolume:(m_masterVolume * m_relativeVolume)];
 }
@@ -314 +336 @@
 
     // Work-around bug that happends if you set/unset mute
-    // before movie is playing, and audio is not played 
+    // before movie is playing, and audio is not played
     // through graph. Then audio is delayed.
     [m_QTMovie setMuted:mute];
@@ -327 +349 @@
 
     // Work-around bug that happends if you set/unset mute
-    // before movie is playing, and audio is not played 
+    // before movie is playing, and audio is not played
     // through graph. Then audio is delayed.
     [m_QTMovie setMuted:(!enable || m_mute)];
@@ -346 +368 @@
     // The following code will not work for some media codecs that
     // typically mingle audio/video frames (e.g mpeg).
-    CFStringRef idString = PhononCFString::toCFStringRef(AudioDevice::deviceUID(id));        
+    CFStringRef idString = PhononCFString::toCFStringRef(AudioDevice::deviceUID(id));
     QTAudioContextRef context;
     QTAudioContextCreateForAudioDevice(kCFAllocatorDefault, idString, 0, &context);
@@ -370 +392 @@
     saturation += 1;
 
+    if (m_brightness == brightness
+        && m_contrast == contrast
+        && m_hue == hue
+        && m_saturation == saturation)
+        return;
+
         m_brightness = brightness;
         m_contrast = contrast;
         m_hue = hue;
         m_saturation = saturation;
-        
 #ifdef QUICKTIME_C_API_AVAILABLE
     Float32 value;
@@ -386 +413 @@
     SetMovieVisualSaturation([m_QTMovie quickTimeMovie], value, 0);
 #endif
+    releaseImageCache();
 }
 
@@ -398 +426 @@
 }
 
-void QuickTimeVideoPlayer::unsetVideo()
+void QuickTimeVideoPlayer::unsetCurrentMediaSource()
 {
     if (!m_QTMovie)
@@ -411 +439 @@
     m_isDrmProtected = false;
     m_isDrmAuthorized = true;
+    m_hasVideo = false;
+    m_staticFps = 0;
     m_mediaSource = MediaSource();
+    m_movieCompactDiscPath.clear();
         [(CIImage *)m_primaryRenderingCIImage release];
         m_primaryRenderingCIImage = 0;
     delete m_QImagePixelBuffer;
     m_QImagePixelBuffer = 0;
+    releaseImageCache();
+    [m_folderTracks release];
+    m_folderTracks = 0;
 }
 
@@ -525 +559 @@
 {
     PhononAutoReleasePool pool;
-    unsetVideo();
+    unsetCurrentMediaSource();
+
     m_mediaSource = mediaSource;
     if (mediaSource.type() == MediaSource::Empty || mediaSource.type() == MediaSource::Invalid){
@@ -531 +566 @@
         return;
     }
+
     openMovieFromCurrentMediaSource();
     if (errorOccured()){
-        unsetVideo();
-        return;
-    }
-
+        unsetCurrentMediaSource();
+        return;
+    }
+
+    prepareCurrentMovieForPlayback();
+}
+
+void QuickTimeVideoPlayer::prepareCurrentMovieForPlayback()
+{
 #ifdef QUICKTIME_C_API_AVAILABLE
     if (m_visualContext)
@@ -544 +585 @@
     waitStatePlayable();
     if (errorOccured()){
-        unsetVideo();
+        unsetCurrentMediaSource();
         return;
     }
@@ -551 +592 @@
     preRollMovie();
     if (errorOccured()){
-        unsetVideo();
+        unsetCurrentMediaSource();
         return;
     }
@@ -558 +599 @@
         m_playbackRate = prefferedPlaybackRate();
     checkIfVideoAwailable();
+    calculateStaticFps();
     enableAudio(m_audioEnabled);
     setMute(m_mute);
     setVolume(m_masterVolume, m_relativeVolume);
+    m_metaData->update();
     pause();
 }
@@ -574 +617 @@
         break;
     case MediaSource::Disc:
-        CASE_UNSUPPORTED("Could not open media source.", FATAL_ERROR)
+        openMovieFromCompactDisc();
         break;
     case MediaSource::Stream:
@@ -636 +679 @@
     // codecs *think* they can decode the stream, and crash...
 #define TryOpenMovieWithCodec(type) gClearError(); \
-    openMovieFromData(data, "."type); \
+    openMovieFromData(data, (char *)"."type); \
     if (m_QTMovie) return;
 
@@ -676 +719 @@
 }
 
+typedef void (*qt_sighandler_t)(int);
+static void sigtest(int) {
+    qApp->exit(0);
+}
+
+void QuickTimeVideoPlayer::openMovieFromCompactDisc()
+{
+    // Interrupting the application while the device is open
+    // causes the application to hang. So we need to handle
+    // this in a more graceful way:
+    qt_sighandler_t hndl = signal(SIGINT, sigtest);
+    if (hndl)
+        signal(SIGINT, hndl);
+
+    PhononAutoReleasePool pool;
+    NSString *cd = 0;
+    QString devName = m_mediaSource.deviceName();
+    if (devName.isEmpty()) {
+        cd = pathToCompactDisc();
+        if (!cd) {
+            SET_ERROR("Could not open media source.", NORMAL_ERROR)
+            return;
+        }
+        m_movieCompactDiscPath = PhononCFString::toQString(reinterpret_cast<CFStringRef>(cd));
+    } else {
+       if (!QFileInfo(devName).isAbsolute())
+           devName = QLatin1String("/Volumes/") + devName;
+       cd = [reinterpret_cast<const NSString *>(PhononCFString::toCFStringRef(devName)) autorelease];
+       if (!isCompactDisc(cd)) {
+           SET_ERROR("Could not open media source.", NORMAL_ERROR)
+           return;
+       }
+       m_movieCompactDiscPath = devName;
+    }
+
+    m_folderTracks = [scanFolder(cd) retain];
+    setCurrentTrack(0);
+}
+
+QString QuickTimeVideoPlayer::movieCompactDiscPath() const
+{
+    return m_movieCompactDiscPath;
+}
+
 MediaSource QuickTimeVideoPlayer::mediaSource() const
 {
@@ -719 +806 @@
         PhononAutoReleasePool pool;
     return [[m_QTMovie attributeForKey:@"QTMovieTimeScaleAttribute"] longValue];
+}
+
+float QuickTimeVideoPlayer::staticFps()
+{
+    return m_staticFps;
+}
+
+void QuickTimeVideoPlayer::calculateStaticFps()
+{
+    if (!m_hasVideo){
+        m_staticFps = 0;
+        return;
+    }
+
+#ifdef QT_ALLOW_QUICKTIME
+    Boolean isMpeg = false;
+    Track videoTrack = GetMovieIndTrackType([m_QTMovie quickTimeMovie], 1,
+            FOUR_CHAR_CODE('vfrr'), // 'vfrr' means: has frame rate
+            movieTrackCharacteristic | movieTrackEnabledOnly);
+    Media media = GetTrackMedia(videoTrack);
+    MediaHandler mediaH = GetMediaHandler(media);
+    MediaHasCharacteristic(mediaH, FOUR_CHAR_CODE('mpeg'), &isMpeg);
+
+    if (isMpeg){
+        MHInfoEncodedFrameRateRecord frameRate;
+        Size frameRateSize = sizeof(frameRate);
+        MediaGetPublicInfo(mediaH, kMHInfoEncodedFrameRate, &frameRate, &frameRateSize);
+        m_staticFps = float(Fix2X(frameRate.encodedFrameRate));
+    } else {
+        Media media = GetTrackMedia(videoTrack);
+        long sampleCount = GetMediaSampleCount(media);
+        TimeValue64 duration = GetMediaDisplayDuration(media);
+        TimeValue64 timeScale = GetMediaTimeScale(media);
+        m_staticFps = float((double)sampleCount * (double)timeScale / (double)duration);
+    }
+#else
+    m_staticFps = 30.0f;
+#endif
 }
 
@@ -951 +1076 @@
 }
 
+QMultiMap<QString, QString> QuickTimeVideoPlayer::metaData()
+{
+    return m_metaData->metaData();
+}
+
+int QuickTimeVideoPlayer::trackCount() const
+{
+    if (!m_folderTracks)
+        return 0;
+    return [m_folderTracks count];
+}
+
+int QuickTimeVideoPlayer::currentTrack() const
+{
+    return m_currentTrack;
+}
+
+QString QuickTimeVideoPlayer::currentTrackPath() const
+{
+    if (!m_folderTracks)
+        return QString();
+
+    PhononAutoReleasePool pool;
+    NSString *trackPath = [m_folderTracks objectAtIndex:m_currentTrack];
+    return PhononCFString::toQString(reinterpret_cast<CFStringRef>(trackPath));
+}
+
+NSString* QuickTimeVideoPlayer::pathToCompactDisc()
+{
+    PhononAutoReleasePool pool;
+    NSArray *devices = [[NSWorkspace sharedWorkspace] mountedRemovableMedia];
+    for (unsigned int i=0; i<[devices count]; ++i) {
+        NSString *dev = [devices objectAtIndex:i];
+        if (isCompactDisc(dev))
+            return [dev retain];
+    }
+    return 0;
+}
+
+bool QuickTimeVideoPlayer::isCompactDisc(NSString *path)
+{
+    PhononAutoReleasePool pool;
+    NSString *type = [NSString string];
+    [[NSWorkspace sharedWorkspace] getFileSystemInfoForPath:path
+        isRemovable:0
+        isWritable:0
+        isUnmountable:0
+        description:0
+        type:&type];
+    return [type hasPrefix:@"cdd"];
+}
+
+NSArray* QuickTimeVideoPlayer::scanFolder(NSString *path)
+{
+    NSMutableArray *tracks = [NSMutableArray arrayWithCapacity:20];
+    if (!path)
+        return tracks;
+
+    NSDirectoryEnumerator *enumerator = [[NSFileManager defaultManager] enumeratorAtPath:path];
+    while (NSString *track = [enumerator nextObject]) {
+        if (![track hasPrefix:@"."])
+            [tracks addObject:[path stringByAppendingPathComponent:track]];
+    }
+    return tracks;
+}
+
+void QuickTimeVideoPlayer::setCurrentTrack(int track)
+{
+    PhononAutoReleasePool pool;
+    [m_QTMovie release];
+        m_QTMovie = 0;
+    m_currentTime = 0;
+    m_currentTrack = track;
+
+    if (!m_folderTracks)
+        return;
+    if (track < 0 || track >= (int)[m_folderTracks count])
+        return;
+
+    NSString *trackPath = [m_folderTracks objectAtIndex:track];
+    QTDataReference *dataRef = [QTDataReference dataReferenceWithReferenceToFile:trackPath];
+    State currentState = m_state;
+    openMovieFromDataRef(dataRef);
+    prepareCurrentMovieForPlayback();
+    if (currentState == Playing)
+        play();
+}
+
 }}
 

trunk/src/3rdparty/phonon/qt7/videoframe.mm

@@ -20 +20 @@
 #import <QuartzCore/CIFilter.h>
 #import <QuartzCore/CIContext.h>
+
+//#define CACHE_CV_TEXTURE
 
 QT_BEGIN_NAMESPACE
@@ -71 +73 @@
     void VideoFrame::copyMembers(const VideoFrame& frame)
     {
+#ifdef CACHE_CV_TEXTURE
         m_cachedCVTextureRef = frame.m_cachedCVTextureRef;
+#endif
                 m_cachedCIImage = frame.m_cachedCIImage;
                 m_cachedQImage = frame.m_cachedQImage;
@@ -106 +110 @@
     CVOpenGLTextureRef VideoFrame::cachedCVTexture() const
     {
+#ifdef CACHE_CV_TEXTURE
         if (!m_cachedCVTextureRef && m_videoPlayer){
             m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);
             (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = m_videoPlayer->currentFrameAsCVTexture();
+            CVOpenGLTextureRetain((const_cast<VideoFrame *>(this))->m_cachedCVTextureRef);
         }
         return m_cachedCVTextureRef;
+#else
+        if (m_videoPlayer){
+            m_videoPlayer->setColors(m_brightness, m_contrast, m_hue, m_saturation);
+            return m_videoPlayer->currentFrameAsCVTexture();
+        }
+        return 0;
+#endif
     }
 
@@ -330 +343 @@
     void VideoFrame::invalidateImage() const
     {
+#ifdef CACHE_CV_TEXTURE
         if (m_cachedCVTextureRef){
             CVOpenGLTextureRelease(m_cachedCVTextureRef);
             (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = 0;
         }
+#endif
         if (m_cachedCIImage){
                         [(CIImage *) m_cachedCIImage release];
@@ -347 +362 @@
     void VideoFrame::retain() const
     {
+#ifdef CACHE_CV_TEXTURE
         if (m_cachedCVTextureRef)
             CVOpenGLTextureRetain(m_cachedCVTextureRef);
+#endif
                 if (m_cachedCIImage)
                         [(CIImage *) m_cachedCIImage retain];
@@ -359 +376 @@
     void VideoFrame::release() const
     {
-        if (m_cachedCVTextureRef)
+#ifdef CACHE_CV_TEXTURE
+        if (m_cachedCVTextureRef){
             CVOpenGLTextureRelease(m_cachedCVTextureRef);
+            (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = 0;
+        }
+#endif
                 if (m_cachedCIImage)
                         [(CIImage *) m_cachedCIImage release];
@@ -369 +390 @@
 
         (const_cast<VideoFrame *>(this))->m_backgroundFrame = 0;
-        (const_cast<VideoFrame *>(this))->m_cachedCVTextureRef = 0;
         (const_cast<VideoFrame *>(this))->m_cachedCIImage = 0;
         (const_cast<VideoFrame *>(this))->m_cachedNSBitmap = 0;