FCL/sf/mw/qtextensions: comparison qtmobility/plugins/multimedia/qt7/qt7playersession.mm

equal deleted inserted replaced

-:06b8e2af4411
+:6fbed849b4f4
 #include "qt7backend.h"
 #include "qt7playersession.h"
 #include "qt7playercontrol.h"
-#include "qt7videooutputcontrol.h"
+#include "qt7videooutput.h"
+#include <QtNetwork/qnetworkcookie.h>
 #include <qmediaplaylistnavigator.h>
 #include <CoreFoundation/CoreFoundation.h>
+#include <Foundation/Foundation.h>
+#include <QtCore/qdatetime.h>
 #include <QtCore/qurl.h>
 #include <QtCore/qdebug.h>
 QT_USE_NAMESPACE
 }
 - (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session;
 - (void) setMovie:(QTMovie *)movie;
 - (void) processEOS:(NSNotification *)notification;
-- (void) processStateChange:(NSNotification *)notification;
+- (void) processLoadStateChange:(NSNotification *)notification;
+- (void) processVolumeChange:(NSNotification *)notification;
+- (void) processNaturalSizeChange :(NSNotification *)notification;
 @end
 @implementation QTMovieObserver
 - (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session
 }
 m_movie = movie;
 if (movie) {
-[[NSNotificationCenter defaultCenter] addObserver: self selector:
+[[NSNotificationCenter defaultCenter] addObserver:self
-@selector(processEOS:) name: QTMovieDidEndNotification object: m_movie];
+selector:@selector(processEOS:)
+name:QTMovieDidEndNotification
-[[NSNotificationCenter defaultCenter] addObserver: self selector:
+object:m_movie];
-@selector(processStateChange:) name: QTMovieLoadStateDidChangeNotification object: m_movie];
+[[NSNotificationCenter defaultCenter] addObserver:self
-[[NSNotificationCenter defaultCenter] addObserver: self selector:
+selector:@selector(processLoadStateChange:)
-@selector(processVolumeChange:) name: QTMovieVolumeDidChangeNotification object: m_movie];
+name:QTMovieLoadStateDidChangeNotification
+object:m_movie];
+[[NSNotificationCenter defaultCenter] addObserver:self
+selector:@selector(processVolumeChange:)
+name:QTMovieVolumeDidChangeNotification
+object:m_movie];
+[[NSNotificationCenter defaultCenter] addObserver:self
+selector:@selector(processNaturalSizeChange:)
+name:
+#if defined(MAC_OS_X_VERSION_10_6) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6)
+QTMovieNaturalSizeDidChangeNotification
+#else
+QTMovieEditedNotification
+#endif
+object:m_movie];
 [movie retain];
 }
 }
 - (void) processEOS:(NSNotification *)notification
 {
 Q_UNUSED(notification);
-m_session->processEOS();
+QMetaObject::invokeMethod(m_session, "processEOS", Qt::AutoConnection);
 }
-- (void) processStateChange:(NSNotification *)notification
+- (void) processLoadStateChange:(NSNotification *)notification
 {
 Q_UNUSED(notification);
-m_session->processStateChange();
+QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
 }
 - (void) processVolumeChange:(NSNotification *)notification
 {
 Q_UNUSED(notification);
-m_session->processVolumeChange();
+QMetaObject::invokeMethod(m_session, "processVolumeChange", Qt::AutoConnection);
 }
+- (void) processNaturalSizeChange :(NSNotification *)notification
+{
+Q_UNUSED(notification);
+QMetaObject::invokeMethod(m_session, "processNaturalSizeChange", Qt::AutoConnection);
+}
 @end
-static CFStringRef qString2CFStringRef(const QString &string)
+static inline NSString *qString2CFStringRef(const QString &string)
 {
-return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(string.unicode()),
+return [NSString stringWithCharacters:reinterpret_cast<const UniChar *>(string.unicode()) length:string.length()];
-string.length());
 }
 QT7PlayerSession::QT7PlayerSession(QObject *parent)
 : QObject(parent)
 , m_QTMovie(0)
 , m_mediaStream(0)
 , m_videoOutput(0)
 , m_muted(false)
 , m_volume(100)
 , m_rate(1.0)
+, m_duration(0)
+, m_videoAvailable(false)
+, m_audioAvailable(false)
 {
 m_movieObserver = [[QTMovieObserver alloc] initWithPlayerSession:this];
 }
 QT7PlayerSession::~QT7PlayerSession()
 {
 [(QTMovieObserver*)m_movieObserver setMovie:nil];
 [(QTMovieObserver*)m_movieObserver release];
+[(QTMovie*)m_QTMovie release];
 }
 void *QT7PlayerSession::movie() const
 {
 return m_QTMovie;
 void QT7PlayerSession::setVideoOutput(QT7VideoOutput *output)
 {
 if (m_videoOutput == output)
 return;
-qDebug() << "set output" << output;
+if (m_videoOutput)
-if (m_videoOutput) {
-m_videoOutput->setEnabled(false);
 m_videoOutput->setMovie(0);
-}
 m_videoOutput = output;
-if (m_videoOutput) {
+if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
-m_videoOutput->setEnabled(m_QTMovie != 0);
 m_videoOutput->setMovie(m_QTMovie);
 }
-}
 qint64 QT7PlayerSession::position() const
 {
 if (!m_QTMovie || m_state == QMediaPlayer::PausedState)
 return m_currentTime;
 [(QTMovie*)m_QTMovie setCurrentTime:newQTTime];
 }
 void QT7PlayerSession::play()
 {
+if (m_videoOutput)
+m_videoOutput->setMovie(m_QTMovie);
 float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
 [(QTMovie*)m_QTMovie setRate:preferredRate*m_rate];
 if (m_state != QMediaPlayer::PlayingState)
 emit stateChanged(m_state = QMediaPlayer::PlayingState);
 }
 void QT7PlayerSession::pause()
 {
+if (m_videoOutput)
+m_videoOutput->setMovie(m_QTMovie);
 m_state = QMediaPlayer::PausedState;
 [(QTMovie*)m_QTMovie setRate:0];
 emit stateChanged(m_state);
 {
 m_state = QMediaPlayer::StoppedState;
 [(QTMovie*)m_QTMovie setRate:0];
 setPosition(0);
+if (m_videoOutput)
+m_videoOutput->setMovie(0);
 if (m_state == QMediaPlayer::StoppedState)
 emit stateChanged(m_state);
 }
 void QT7PlayerSession::setMedia(const QMediaContent &content, QIODevice *stream)
 {
 AutoReleasePool pool;
+qDebug() << "SetMedia" << content.canonicalUrl();
 if (m_QTMovie) {
 [(QTMovieObserver*)m_movieObserver setMovie:nil];
-if (m_videoOutput) {
+if (m_videoOutput)
-m_videoOutput->setEnabled(false);
 m_videoOutput->setMovie(0);
-}
 [(QTMovie*)m_QTMovie release];
 m_QTMovie = 0;
 }
 m_resources = content;
 m_mediaStream = stream;
 m_mediaStatus = QMediaPlayer::NoMedia;
-QUrl url;
+QNetworkRequest request;
 if (!content.isNull())
-url = content.canonicalUrl();
+request = content.canonicalResource().request();
 else
 return;
+QVariant cookies = request.header(QNetworkRequest::CookieHeader);
+if (cookies.isValid()) {
+NSHTTPCookieStorage *store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+QList<QNetworkCookie> cookieList = cookies.value<QList<QNetworkCookie> >();
+foreach (const QNetworkCookie &requestCookie, cookieList) {
+NSMutableDictionary *p = [NSMutableDictionary dictionaryWithObjectsAndKeys:
+qString2CFStringRef(requestCookie.name()), NSHTTPCookieName,
+qString2CFStringRef(requestCookie.value()), NSHTTPCookieValue,
+qString2CFStringRef(requestCookie.domain()), NSHTTPCookieDomain,
+qString2CFStringRef(requestCookie.path()), NSHTTPCookiePath,
+nil
+];
+if (requestCookie.isSessionCookie())
+[p setObject:[NSString stringWithUTF8String:"TRUE"] forKey:NSHTTPCookieDiscard];
+else
+[p setObject:[NSDate dateWithTimeIntervalSince1970:requestCookie.expirationDate().toTime_t()] forKey:NSHTTPCookieExpires];
+[store setCookie:[NSHTTPCookie cookieWithProperties:p]];
+}
+}
+QUrl requestUrl = request.url();
+if (requestUrl.scheme().isEmpty())
+requestUrl.setScheme(QLatin1String("file"));
+qDebug() << "Play" << requestUrl;
 NSError *err = 0;
-QTDataReference *dataRef = 0;
+NSString *urlString = qString2CFStringRef(requestUrl.toString());
-if ( url.scheme() == "file" ) {
-NSString *nsFileName = (NSString *)qString2CFStringRef( url.toLocalFile() );
-dataRef = [QTDataReference dataReferenceWithReferenceToFile:nsFileName];
-} else {
-NSString *urlString = (NSString *)qString2CFStringRef( url.toString() );
-NSURL *url = [NSURL URLWithString: urlString];
-dataRef = [QTDataReference dataReferenceWithReferenceToURL:url];
-}
 NSDictionary *attr = [NSDictionary dictionaryWithObjectsAndKeys:
-dataRef, QTMovieDataReferenceAttribute,
+[NSURL URLWithString:urlString], QTMovieURLAttribute,
 [NSNumber numberWithBool:YES], QTMovieOpenAsyncOKAttribute,
 [NSNumber numberWithBool:YES], QTMovieIsActiveAttribute,
 [NSNumber numberWithBool:YES], QTMovieResolveDataRefsAttribute,
 [NSNumber numberWithBool:YES], QTMovieDontInteractWithUserAttribute,
 nil];
 qWarning() << "QT7PlayerSession::setMedia error" << description;
 emit error(QMediaPlayer::FormatError, description );
 } else {
 [(QTMovieObserver*)m_movieObserver setMovie:(QTMovie*)m_QTMovie];
-if (m_videoOutput) {
+if (m_state != QMediaPlayer::StoppedState && m_videoOutput)
 m_videoOutput->setMovie(m_QTMovie);
-m_videoOutput->setEnabled(true);
-}
+processLoadStateChange();
-processStateChange();
 [(QTMovie*)m_QTMovie setMuted:m_muted];
 setVolume(m_volume);
 }
 }
 }
 void QT7PlayerSession::processEOS()
 {
 m_mediaStatus = QMediaPlayer::EndOfMedia;
+if (m_videoOutput)
+m_videoOutput->setMovie(0);
 emit stateChanged(m_state = QMediaPlayer::StoppedState);
 emit mediaStatusChanged(m_mediaStatus);
 }
-void QT7PlayerSession::processStateChange()
+void QT7PlayerSession::processLoadStateChange()
 {
+if (!m_QTMovie)
+return;
 signed long state = [[(QTMovie*)m_QTMovie attributeForKey:QTMovieLoadStateAttribute]
 longValue];
-//qDebug() << "new State:" << state;
+qDebug() << "Moview load state changed:" << state;
 #ifndef QUICKTIME_C_API_AVAILABLE
 enum {
 kMovieLoadStateError          = -1L,
 kMovieLoadStateLoading        = 1000,
 else if (state >= kMovieLoadStateLoading)
 newStatus = isPlaying ? QMediaPlayer::StalledMedia : QMediaPlayer::LoadingMedia;
 if (state == kMovieLoadStateError) {
 newStatus = QMediaPlayer::InvalidMedia;
-emit error(QMediaPlayer::FormatError, tr("Playback failed"));
+if (m_videoOutput)
-}
+m_videoOutput->setMovie(0);
-if (newStatus != m_mediaStatus) {
+emit error(QMediaPlayer::FormatError, tr("Failed to load media"));
-switch (newStatus) {
+emit stateChanged(m_state = QMediaPlayer::StoppedState);
-case QMediaPlayer::BufferedMedia:
+}
-case QMediaPlayer::BufferingMedia:
-//delayed playback start is necessary for network sources
+if (state >= kMovieLoadStatePlayable &&
-if (m_state == QMediaPlayer::PlayingState) {
+m_state == QMediaPlayer::PlayingState &&
-QMetaObject::invokeMethod(this, "play", Qt::QueuedConnection);
+[(QTMovie*)m_QTMovie rate] == 0) {
-}
+QMetaObject::invokeMethod(this, "play", Qt::QueuedConnection);
-//fall
+}
-case QMediaPlayer::LoadedMedia:
-case QMediaPlayer::LoadingMedia:
+if (state >= kMovieLoadStateLoaded) {
-emit durationChanged(duration());
+qint64 currentDuration = duration();
-emit audioAvailableChanged(isAudioAvailable());
+if (m_duration != currentDuration)
-emit videoAvailableChanged(isVideoAvailable());
+emit durationChanged(m_duration = currentDuration);
-break;
-case QMediaPlayer::InvalidMedia:
+if (m_audioAvailable != isAudioAvailable())
-emit stateChanged(m_state = QMediaPlayer::StoppedState);
+emit audioAvailableChanged(m_audioAvailable = !m_audioAvailable);
-default:
-break;
+if (m_videoAvailable != isVideoAvailable())
-}
+emit videoAvailableChanged(m_videoAvailable = !m_videoAvailable);
+}
+if (newStatus != m_mediaStatus)
 emit mediaStatusChanged(m_mediaStatus = newStatus);
-}
 }
 void QT7PlayerSession::processVolumeChange()
 {
 if (!m_QTMovie)
 if (newVolume != m_volume) {
 emit volumeChanged(m_volume = newVolume);
 }
 }
+void QT7PlayerSession::processNaturalSizeChange()
+{
+NSSize size = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+qDebug() << "Native size changed:" << QSize(size.width, size.height);
+if (m_videoOutput)
+m_videoOutput->updateNaturalSize(QSize(size.width, size.height));
+}
 #include "moc_qt7playersession.cpp"

changeset 14	6fbed849b4f4
parent 11	06b8e2af4411