slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial copy of QtMultimediaKit.

Browse Source 
Comes from original repo, with SHA1:
2c82d5611655e5967f5c5095af50c0991c4378b2
This commit is contained in:
Michael Goddard
2011-06-29 13:38:46 +10:00
commit 2a34e88c1e
1048 changed files with 206259 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/plugins/qt7/mediaplayer/mediaplayer.pri Normal file
View File

@@ -0,0 +1,16 @@
INCLUDEPATH += $$PWD
DEFINES += QMEDIA_QT7_PLAYER
HEADERS += \
$$PWD/qt7playercontrol.h \
$$PWD/qt7playermetadata.h \
$$PWD/qt7playerservice.h \
$$PWD/qt7playersession.h
OBJECTIVE_SOURCES += \
$$PWD/qt7playercontrol.mm \
$$PWD/qt7playermetadata.mm \
$$PWD/qt7playerservice.mm \
$$PWD/qt7playersession.mm

109
src/plugins/qt7/mediaplayer/qt7playercontrol.h Normal file
View File

@@ -0,0 +1,109 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7PLAYERCONTROL_H
#define QT7PLAYERCONTROL_H
#include <QtCore/qobject.h>
#include <qmediaplayercontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
QT_BEGIN_NAMESPACE
class QT7PlayerSession;
class QT7PlayerService;
class QMediaPlaylist;
class QMediaPlaylistNavigator;
class QT7PlayerControl : public QMediaPlayerControl
{
Q_OBJECT
public:
QT7PlayerControl(QObject *parent = 0);
~QT7PlayerControl();
void setSession(QT7PlayerSession *session);
QMediaPlayer::State state() const;
QMediaPlayer::MediaStatus mediaStatus() const;
QMediaContent media() const;
const QIODevice *mediaStream() const;
void setMedia(const QMediaContent &content, QIODevice *stream);
qint64 position() const;
qint64 duration() const;
int bufferStatus() const;
int volume() const;
bool isMuted() const;
bool isAudioAvailable() const;
bool isVideoAvailable() const;
bool isSeekable() const;
QMediaTimeRange availablePlaybackRanges() const;
qreal playbackRate() const;
void setPlaybackRate(qreal rate);
public Q_SLOTS:
void setPosition(qint64 pos);
void play();
void pause();
void stop();
void setVolume(int volume);
void setMuted(bool muted);
private:
QT7PlayerSession *m_session;
};
QT_END_NAMESPACE
#endif

191
src/plugins/qt7/mediaplayer/qt7playercontrol.mm Normal file
View File

@@ -0,0 +1,191 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7playercontrol.h"
#include "qt7playersession.h"
#include <qmediaplaylistnavigator.h>
#include <QtCore/qurl.h>
#include <QtCore/qdebug.h>
QT_USE_NAMESPACE
QT7PlayerControl::QT7PlayerControl(QObject *parent)
: QMediaPlayerControl(parent)
{
}
QT7PlayerControl::~QT7PlayerControl()
{
}
void QT7PlayerControl::setSession(QT7PlayerSession *session)
{
m_session = session;
connect(m_session, SIGNAL(positionChanged(qint64)), this, SIGNAL(positionChanged(qint64)));
connect(m_session, SIGNAL(durationChanged(qint64)), this, SIGNAL(durationChanged(qint64)));
connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)),
this, SIGNAL(stateChanged(QMediaPlayer::State)));
connect(m_session, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
this, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
connect(m_session, SIGNAL(volumeChanged(int)), this, SIGNAL(volumeChanged(int)));
connect(m_session, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
connect(m_session, SIGNAL(audioAvailableChanged(bool)), this, SIGNAL(audioAvailableChanged(bool)));
connect(m_session, SIGNAL(videoAvailableChanged(bool)), this, SIGNAL(videoAvailableChanged(bool)));
connect(m_session, SIGNAL(error(int,QString)), this, SIGNAL(error(int,QString)));
}
qint64 QT7PlayerControl::position() const
{
return m_session->position();
}
qint64 QT7PlayerControl::duration() const
{
return m_session->duration();
}
QMediaPlayer::State QT7PlayerControl::state() const
{
return m_session->state();
}
QMediaPlayer::MediaStatus QT7PlayerControl::mediaStatus() const
{
return m_session->mediaStatus();
}
int QT7PlayerControl::bufferStatus() const
{
return m_session->bufferStatus();
}
int QT7PlayerControl::volume() const
{
return m_session->volume();
}
bool QT7PlayerControl::isMuted() const
{
return m_session->isMuted();
}
bool QT7PlayerControl::isSeekable() const
{
return m_session->isSeekable();
}
QMediaTimeRange QT7PlayerControl::availablePlaybackRanges() const
{
return m_session->availablePlaybackRanges();
}
qreal QT7PlayerControl::playbackRate() const
{
return m_session->playbackRate();
}
void QT7PlayerControl::setPlaybackRate(qreal rate)
{
m_session->setPlaybackRate(rate);
}
void QT7PlayerControl::setPosition(qint64 pos)
{
m_session->setPosition(pos);
}
void QT7PlayerControl::play()
{
m_session->play();
}
void QT7PlayerControl::pause()
{
m_session->pause();
}
void QT7PlayerControl::stop()
{
m_session->stop();
}
void QT7PlayerControl::setVolume(int volume)
{
m_session->setVolume(volume);
}
void QT7PlayerControl::setMuted(bool muted)
{
m_session->setMuted(muted);
}
QMediaContent QT7PlayerControl::media() const
{
return m_session->media();
}
const QIODevice *QT7PlayerControl::mediaStream() const
{
return m_session->mediaStream();
}
void QT7PlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
{
m_session->setMedia(content, stream);
emit mediaChanged(content);
}
bool QT7PlayerControl::isAudioAvailable() const
{
return m_session->isAudioAvailable();
}
bool QT7PlayerControl::isVideoAvailable() const
{
return m_session->isVideoAvailable();
}
#include "moc_qt7playercontrol.cpp"

77
src/plugins/qt7/mediaplayer/qt7playermetadata.h Normal file
View File

@@ -0,0 +1,77 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7PLAYERMETADATACONTROL_H
#define QT7PLAYERMETADATACONTROL_H
#include <qmetadatareadercontrol.h>
QT_BEGIN_NAMESPACE
class QT7PlayerSession;
class QT7PlayerMetaDataControl : public QMetaDataReaderControl
{
Q_OBJECT
public:
QT7PlayerMetaDataControl(QT7PlayerSession *session, QObject *parent);
virtual ~QT7PlayerMetaDataControl();
bool isMetaDataAvailable() const;
bool isWritable() const;
QVariant metaData(QtMultimediaKit::MetaData key) const;
QList<QtMultimediaKit::MetaData> availableMetaData() const;
QVariant extendedMetaData(const QString &key) const ;
QStringList availableExtendedMetaData() const;
private slots:
void updateTags();
private:
QT7PlayerSession *m_session;
QMap<QtMultimediaKit::MetaData, QVariant> m_tags;
};
QT_END_NAMESPACE
#endif

260
src/plugins/qt7/mediaplayer/qt7playermetadata.mm Normal file
View File

@@ -0,0 +1,260 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7backend.h"
#include "qt7playermetadata.h"
#include "qt7playersession.h"
#include <QtCore/qvarlengtharray.h>
#import <QTKit/QTMovie.h>
#ifdef QUICKTIME_C_API_AVAILABLE
#include <QuickTime/QuickTime.h>
#undef check // avoid name clash;
#endif
QT_USE_NAMESPACE
QT7PlayerMetaDataControl::QT7PlayerMetaDataControl(QT7PlayerSession *session, QObject *parent)
:QMetaDataReaderControl(parent), m_session(session)
{
}
QT7PlayerMetaDataControl::~QT7PlayerMetaDataControl()
{
}
bool QT7PlayerMetaDataControl::isMetaDataAvailable() const
{
return !m_tags.isEmpty();
}
bool QT7PlayerMetaDataControl::isWritable() const
{
return false;
}
QVariant QT7PlayerMetaDataControl::metaData(QtMultimediaKit::MetaData key) const
{
return m_tags.value(key);
}
QList<QtMultimediaKit::MetaData> QT7PlayerMetaDataControl::availableMetaData() const
{
return m_tags.keys();
}
QVariant QT7PlayerMetaDataControl::extendedMetaData(const QString &key) const
{
Q_UNUSED(key);
return QVariant();
}
QStringList QT7PlayerMetaDataControl::availableExtendedMetaData() const
{
return QStringList();
}
#ifdef QUICKTIME_C_API_AVAILABLE
static QString stripCopyRightSymbol(const QString &key)
{
return key.right(key.length()-1);
}
static QString convertQuickTimeKeyToUserKey(const QString &key)
{
if (key == QLatin1String("com.apple.quicktime.displayname"))
return QLatin1String("nam");
else if (key == QLatin1String("com.apple.quicktime.album"))
return QLatin1String("alb");
else if (key == QLatin1String("com.apple.quicktime.artist"))
return QLatin1String("ART");
else
return QLatin1String("???");
}
static OSStatus readMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, QTPropertyClass propClass,
QTPropertyID id, QTPropertyValuePtr *value, ByteCount *size)
{
QTPropertyValueType type;
ByteCount propSize;
UInt32 propFlags;
OSStatus err = QTMetaDataGetItemPropertyInfo(metaDataRef, item, propClass, id, &type, &propSize, &propFlags);
if (err == noErr) {
*value = malloc(propSize);
if (*value != 0) {
err = QTMetaDataGetItemProperty(metaDataRef, item, propClass, id, propSize, *value, size);
if (err == noErr && (type == 'code' || type == 'itsk' || type == 'itlk')) {
// convert from native endian to big endian
OSTypePtr pType = (OSTypePtr)*value;
*pType = EndianU32_NtoB(*pType);
}
}
else
return -1;
}
return err;
}
static UInt32 getMetaType(QTMetaDataRef metaDataRef, QTMetaDataItem item)
{
QTPropertyValuePtr value = 0;
ByteCount ignore = 0;
OSStatus err = readMetaValue(
metaDataRef, item, kPropertyClass_MetaDataItem, kQTMetaDataItemPropertyID_DataType, &value, &ignore);
if (err == noErr) {
UInt32 type = *((UInt32 *) value);
if (value)
free(value);
return type;
}
return 0;
}
static QString cFStringToQString(CFStringRef str)
{
if(!str)
return QString();
CFIndex length = CFStringGetLength(str);
const UniChar *chars = CFStringGetCharactersPtr(str);
if (chars)
return QString(reinterpret_cast<const QChar *>(chars), length);
QVarLengthArray<UniChar> buffer(length);
CFStringGetCharacters(str, CFRangeMake(0, length), buffer.data());
return QString(reinterpret_cast<const QChar *>(buffer.constData()), length);
}
static QString getMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, SInt32 id)
{
QTPropertyValuePtr value = 0;
ByteCount size = 0;
OSStatus err = readMetaValue(metaDataRef, item, kPropertyClass_MetaDataItem, id, &value, &size);
QString string;
if (err == noErr) {
UInt32 dataType = getMetaType(metaDataRef, item);
switch (dataType){
case kQTMetaDataTypeUTF8:
case kQTMetaDataTypeMacEncodedText:
string = cFStringToQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF8, false));
break;
case kQTMetaDataTypeUTF16BE:
string = cFStringToQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF16BE, false));
break;
default:
break;
}
if (value)
free(value);
}
return string;
}
static void readFormattedData(QTMetaDataRef metaDataRef, OSType format, QMultiMap<QString, QString> &result)
{
QTMetaDataItem item = kQTMetaDataItemUninitialized;
OSStatus err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);
while (err == noErr){
QString key = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Key);
if (format == kQTMetaDataStorageFormatQuickTime)
key = convertQuickTimeKeyToUserKey(key);
else
key = stripCopyRightSymbol(key);
if (!result.contains(key)){
QString val = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Value);
result.insert(key, val);
}
err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);
}
}
#endif
void QT7PlayerMetaDataControl::updateTags()
{
bool wasEmpty = m_tags.isEmpty();
m_tags.clear();
QTMovie *movie = (QTMovie*)m_session->movie();
if (movie) {
QMultiMap<QString, QString> metaMap;
#ifdef QUICKTIME_C_API_AVAILABLE
QTMetaDataRef metaDataRef;
OSStatus err = QTCopyMovieMetaData([movie quickTimeMovie], &metaDataRef);
if (err == noErr) {
readFormattedData(metaDataRef, kQTMetaDataStorageFormatUserData, metaMap);
readFormattedData(metaDataRef, kQTMetaDataStorageFormatQuickTime, metaMap);
readFormattedData(metaDataRef, kQTMetaDataStorageFormatiTunes, metaMap);
}
#else
AutoReleasePool pool;
NSString *name = [movie attributeForKey:@"QTMovieDisplayNameAttribute"];
metaMap.insert(QLatin1String("nam"), QString::fromUtf8([name UTF8String]));
#endif // QUICKTIME_C_API_AVAILABLE
m_tags.insert(QtMultimediaKit::AlbumArtist, metaMap.value(QLatin1String("ART")));
m_tags.insert(QtMultimediaKit::AlbumTitle, metaMap.value(QLatin1String("alb")));
m_tags.insert(QtMultimediaKit::Title, metaMap.value(QLatin1String("nam")));
m_tags.insert(QtMultimediaKit::Date, metaMap.value(QLatin1String("day")));
m_tags.insert(QtMultimediaKit::Genre, metaMap.value(QLatin1String("gnre")));
m_tags.insert(QtMultimediaKit::TrackNumber, metaMap.value(QLatin1String("trk")));
m_tags.insert(QtMultimediaKit::Description, metaMap.value(QLatin1String("des")));
}
if (!wasEmpty || !m_tags.isEmpty())
emit metaDataChanged();
}
#include "moc_qt7playermetadata.cpp"

82
src/plugins/qt7/mediaplayer/qt7playerservice.h Normal file
View File

@@ -0,0 +1,82 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7PLAYERSERVICE_H
#define QT7PLAYERSERVICE_H
#include <QtCore/qobject.h>
#include <QtCore/qset.h>
#include <qmediaservice.h>
QT_BEGIN_NAMESPACE
class QMediaMetaData;
class QMediaPlayerControl;
class QMediaPlaylist;
class QMediaPlaylistNavigator;
class QT7PlayerControl;
class QT7PlayerMetaDataControl;
class QT7VideoWindowControl;
class QT7VideoWidgetControl;
class QT7VideoRendererControl;
class QT7VideoOutput;
class QT7PlayerSession;
class QT7PlayerService : public QMediaService
{
Q_OBJECT
public:
QT7PlayerService(QObject *parent = 0);
~QT7PlayerService();
QMediaControl* requestControl(const char *name);
void releaseControl(QMediaControl *control);
private:
QT7PlayerSession *m_session;
QT7PlayerControl *m_control;
QMediaControl * m_videoOutput;
QT7PlayerMetaDataControl *m_playerMetaDataControl;
};
QT_END_NAMESPACE
#endif

129
src/plugins/qt7/mediaplayer/qt7playerservice.mm Normal file
View File

@@ -0,0 +1,129 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtCore/qvariant.h>
#include <QtCore/qdebug.h>
#include <QtGui/qwidget.h>
#include "qt7backend.h"
#include "qt7playerservice.h"
#include "qt7playercontrol.h"
#include "qt7playersession.h"
#include "qt7videooutput.h"
#include "qt7movieviewoutput.h"
#include "qt7movieviewrenderer.h"
#include "qt7movierenderer.h"
#include "qt7movievideowidget.h"
#include "qt7playermetadata.h"
#include <qmediaplaylistnavigator.h>
#include <qmediaplaylist.h>
QT_USE_NAMESPACE
QT7PlayerService::QT7PlayerService(QObject *parent):
QMediaService(parent),
m_videoOutput(0)
{
m_session = new QT7PlayerSession(this);
m_control = new QT7PlayerControl(this);
m_control->setSession(m_session);
m_playerMetaDataControl = new QT7PlayerMetaDataControl(m_session, this);
connect(m_control, SIGNAL(mediaChanged(QMediaContent)), m_playerMetaDataControl, SLOT(updateTags()));
}
QT7PlayerService::~QT7PlayerService()
{
}
QMediaControl *QT7PlayerService::requestControl(const char *name)
{
if (qstrcmp(name, QMediaPlayerControl_iid) == 0)
return m_control;
if (qstrcmp(name, QMetaDataReaderControl_iid) == 0)
return m_playerMetaDataControl;
#ifndef QT_NO_OPENGL
if (!m_videoOutput) {
if (qstrcmp(name, QVideoWindowControl_iid) == 0) {
#if defined(QT_MAC_USE_COCOA)
m_videoOutput = new QT7MovieViewOutput(this);
#endif
}
if (qstrcmp(name, QVideoRendererControl_iid) == 0) {
#ifdef QUICKTIME_C_API_AVAILABLE
m_videoOutput = new QT7MovieRenderer(this);
#else
m_videoOutput = new QT7MovieViewRenderer(this);
#endif
}
if (qstrcmp(name, QVideoWidgetControl_iid) == 0) {
#ifdef QUICKTIME_C_API_AVAILABLE
m_videoOutput = new QT7MovieVideoWidget(this);
#endif
}
if (m_videoOutput) {
QT7VideoOutput *videoOutput = qobject_cast<QT7VideoOutput*>(m_videoOutput);
m_session->setVideoOutput(videoOutput);
return m_videoOutput;
}
}
#endif // !defined(QT_NO_OPENGL)
return 0;
}
void QT7PlayerService::releaseControl(QMediaControl *control)
{
if (m_videoOutput == control) {
m_videoOutput = 0;
m_session->setVideoOutput(0);
delete control;
}
}
#include "moc_qt7playerservice.cpp"

194
src/plugins/qt7/mediaplayer/qt7playersession.h Normal file
View File

@@ -0,0 +1,194 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7PLAYERSESSION_H
#define QT7PLAYERSESSION_H
#include <QtCore/qobject.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qset.h>
#include <QtCore/qresource.h>
#include <qmediaplayercontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
QT_BEGIN_NAMESPACE
class QT7PlayerControl;
class QMediaPlaylist;
class QMediaPlaylistNavigator;
class QT7VideoOutput;
class QT7PlayerSession;
class QT7PlayerService;
class QT7PlayerSession : public QObject
{
Q_OBJECT
public:
QT7PlayerSession(QObject *parent = 0);
~QT7PlayerSession();
void *movie() const;
void setControl(QT7PlayerControl *control);
void setVideoOutput(QT7VideoOutput *output);
QMediaPlayer::State state() const;
QMediaPlayer::MediaStatus mediaStatus() const;
QMediaContent media() const;
const QIODevice *mediaStream() const;
void setMedia(const QMediaContent &content, QIODevice *stream);
qint64 position() const;
qint64 duration() const;
int bufferStatus() const;
int volume() const;
bool isMuted() const;
bool isAudioAvailable() const;
bool isVideoAvailable() const;
bool isSeekable() const;
QMediaTimeRange availablePlaybackRanges() const;
qreal playbackRate() const;
public slots:
void setPlaybackRate(qreal rate);
void setPosition(qint64 pos);
void play();
void pause();
void stop();
void setVolume(int volume);
void setMuted(bool muted);
void processEOS();
void processLoadStateChange();
void processVolumeChange();
void processNaturalSizeChange();
void processPositionChange();
signals:
void positionChanged(qint64 position);
void durationChanged(qint64 duration);
void stateChanged(QMediaPlayer::State newState);
void mediaStatusChanged(QMediaPlayer::MediaStatus status);
void volumeChanged(int volume);
void mutedChanged(bool muted);
void audioAvailableChanged(bool audioAvailable);
void videoAvailableChanged(bool videoAvailable);
void error(int error, const QString &errorString);
private:
class ResourceHandler {
public:
ResourceHandler():resource(0) {}
~ResourceHandler() { clear(); }
void setResourceFile(const QString &file) {
if (resource) {
if (resource->fileName() == file)
return;
delete resource;
rawData.clear();
}
resource = new QResource(file);
}
bool isValid() const { return resource && resource->isValid() && resource->data() != 0; }
const uchar *data() {
if (!isValid())
return 0;
if (resource->isCompressed()) {
if (rawData.size() == 0)
rawData = qUncompress(resource->data(), resource->size());
return (const uchar *)rawData.constData();
}
return resource->data();
}
qint64 size() {
if (data() == 0)
return 0;
return resource->isCompressed() ? rawData.size() : resource->size();
}
void clear() {
delete resource;
rawData.clear();
}
QResource *resource;
QByteArray rawData;
};
void openMovie(bool tryAsync);
void *m_QTMovie;
void *m_movieObserver;
QMediaPlayer::State m_state;
QMediaPlayer::MediaStatus m_mediaStatus;
QIODevice *m_mediaStream;
QMediaContent m_resources;
ResourceHandler m_resourceHandler;
QT7VideoOutput * m_videoOutput;
bool m_muted;
bool m_tryingAsync;
int m_volume;
qreal m_rate;
qint64 m_duration;
bool m_videoAvailable;
bool m_audioAvailable;
};
QT_END_NAMESPACE
#endif

751
src/plugins/qt7/mediaplayer/qt7playersession.mm Normal file
View File

@@ -0,0 +1,751 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <QTKit/QTDataReference.h>
#import <QTKit/QTMovie.h>
#include "qt7backend.h"
#include "qt7playersession.h"
#include "qt7playercontrol.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
//#define QT_DEBUG_QT7
@interface QTMovieObserver : NSObject
{
@private
QT7PlayerSession *m_session;
QTMovie *m_movie;
}
- (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session;
- (void) setMovie:(QTMovie *)movie;
- (void) processEOS:(NSNotification *)notification;
- (void) processLoadStateChange:(NSNotification *)notification;
- (void) processVolumeChange:(NSNotification *)notification;
- (void) processNaturalSizeChange :(NSNotification *)notification;
- (void) processPositionChange :(NSNotification *)notification;
@end
@implementation QTMovieObserver
- (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session
{
if (!(self = [super init]))
return nil;
self->m_session = session;
return self;
}
- (void) setMovie:(QTMovie *)movie
{
if (m_movie == movie)
return;
if (m_movie) {
[[NSNotificationCenter defaultCenter] removeObserver:self];
[m_movie release];
}
m_movie = movie;
if (movie) {
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processEOS:)
name:QTMovieDidEndNotification
object:m_movie];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processLoadStateChange:)
name:QTMovieLoadStateDidChangeNotification
object:m_movie];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processVolumeChange:)
name:QTMovieVolumeDidChangeNotification
object:m_movie];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processPositionChange:)
name:QTMovieTimeDidChangeNotification
object:m_movie];
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) {
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processNaturalSizeChange:)
name:@"QTMovieNaturalSizeDidChangeNotification"
object:m_movie];
}
else {
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(processNaturalSizeChange:)
name:QTMovieEditedNotification
object:m_movie];
}
[movie retain];
}
}
- (void) processEOS:(NSNotification *)notification
{
Q_UNUSED(notification);
QMetaObject::invokeMethod(m_session, "processEOS", Qt::AutoConnection);
}
- (void) processLoadStateChange:(NSNotification *)notification
{
Q_UNUSED(notification);
QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
}
- (void) processVolumeChange:(NSNotification *)notification
{
Q_UNUSED(notification);
QMetaObject::invokeMethod(m_session, "processVolumeChange", Qt::AutoConnection);
}
- (void) processNaturalSizeChange :(NSNotification *)notification
{
Q_UNUSED(notification);
QMetaObject::invokeMethod(m_session, "processNaturalSizeChange", Qt::AutoConnection);
}
- (void) processPositionChange :(NSNotification *)notification
{
Q_UNUSED(notification);
QMetaObject::invokeMethod(m_session, "processPositionChange", Qt::AutoConnection);
}
@end
static inline NSString *qString2CFStringRef(const QString &string)
{
return [NSString stringWithCharacters:reinterpret_cast<const UniChar *>(string.unicode()) length:string.length()];
}
QT7PlayerSession::QT7PlayerSession(QObject *parent)
: QObject(parent)
, m_QTMovie(0)
, m_state(QMediaPlayer::StoppedState)
, m_mediaStatus(QMediaPlayer::NoMedia)
, m_mediaStream(0)
, m_videoOutput(0)
, m_muted(false)
, m_tryingAsync(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()
{
if (m_videoOutput)
m_videoOutput->setMovie(0);
[(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;
if (m_videoOutput)
m_videoOutput->setMovie(0);
m_videoOutput = output;
if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
m_videoOutput->setMovie(m_QTMovie);
}
qint64 QT7PlayerSession::position() const
{
if (!m_QTMovie)
return 0;
QTTime qtTime = [(QTMovie*)m_QTMovie currentTime];
return static_cast<quint64>(float(qtTime.timeValue) / float(qtTime.timeScale) * 1000.0f);
}
qint64 QT7PlayerSession::duration() const
{
if (!m_QTMovie)
return 0;
QTTime qtTime = [(QTMovie*)m_QTMovie duration];
return static_cast<quint64>(float(qtTime.timeValue) / float(qtTime.timeScale) * 1000.0f);
}
QMediaPlayer::State QT7PlayerSession::state() const
{
return m_state;
}
QMediaPlayer::MediaStatus QT7PlayerSession::mediaStatus() const
{
return m_mediaStatus;
}
int QT7PlayerSession::bufferStatus() const
{
return 100;
}
int QT7PlayerSession::volume() const
{
return m_volume;
}
bool QT7PlayerSession::isMuted() const
{
return m_muted;
}
bool QT7PlayerSession::isSeekable() const
{
return true;
}
#ifndef QUICKTIME_C_API_AVAILABLE
@interface QTMovie(QtExtensions)
- (NSArray*)loadedRanges;
- (QTTime)maxTimeLoaded;
@end
#endif
QMediaTimeRange QT7PlayerSession::availablePlaybackRanges() const
{
QTMovie *movie = (QTMovie*)m_QTMovie;
#ifndef QUICKTIME_C_API_AVAILABLE
AutoReleasePool pool;
if ([movie respondsToSelector:@selector(loadedRanges)]) {
QMediaTimeRange rc;
NSArray *r = [movie loadedRanges];
for (NSValue *tr in r) {
QTTimeRange timeRange = [tr QTTimeRangeValue];
qint64 startTime = qint64(float(timeRange.time.timeValue) / timeRange.time.timeScale * 1000.0);
rc.addInterval(startTime, startTime + qint64(float(timeRange.duration.timeValue) / timeRange.duration.timeScale * 1000.0));
}
return rc;
}
else if ([movie respondsToSelector:@selector(maxTimeLoaded)]) {
QTTime loadedTime = [movie maxTimeLoaded];
return QMediaTimeRange(0, qint64(float(loadedTime.timeValue) / loadedTime.timeScale * 1000.0));
}
#else
TimeValue loadedTime;
TimeScale scale;
Movie m = [movie quickTimeMovie];
if (GetMaxLoadedTimeInMovie(m, &loadedTime) == noErr) {
scale = GetMovieTimeScale(m);
return QMediaTimeRange(0, qint64(float(loadedTime) / scale * 1000.0f));
}
#endif
return QMediaTimeRange(0, duration());
}
qreal QT7PlayerSession::playbackRate() const
{
return m_rate;
}
void QT7PlayerSession::setPlaybackRate(qreal rate)
{
if (qFuzzyCompare(m_rate, rate))
return;
m_rate = rate;
if (m_QTMovie != 0 && m_state == QMediaPlayer::PlayingState) {
AutoReleasePool pool;
float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
[(QTMovie*)m_QTMovie setRate:preferredRate * m_rate];
}
}
void QT7PlayerSession::setPosition(qint64 pos)
{
if ( !isSeekable() || pos == position())
return;
if (duration() > 0)
pos = qMin(pos, duration());
QTTime newQTTime = [(QTMovie*)m_QTMovie currentTime];
newQTTime.timeValue = (pos / 1000.0f) * newQTTime.timeScale;
[(QTMovie*)m_QTMovie setCurrentTime:newQTTime];
//reset the EndOfMedia status position is changed after playback is finished
if (m_mediaStatus == QMediaPlayer::EndOfMedia)
processLoadStateChange();
}
void QT7PlayerSession::play()
{
if (m_state == QMediaPlayer::PlayingState)
return;
m_state = QMediaPlayer::PlayingState;
if (m_videoOutput)
m_videoOutput->setMovie(m_QTMovie);
//reset the EndOfMedia status if the same file is played again
if (m_mediaStatus == QMediaPlayer::EndOfMedia)
processLoadStateChange();
AutoReleasePool pool;
float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
[(QTMovie*)m_QTMovie setRate:preferredRate * m_rate];
processLoadStateChange();
emit stateChanged(m_state);
}
void QT7PlayerSession::pause()
{
if (m_state == QMediaPlayer::PausedState)
return;
m_state = QMediaPlayer::PausedState;
if (m_videoOutput)
m_videoOutput->setMovie(m_QTMovie);
//reset the EndOfMedia status if the same file is played again
if (m_mediaStatus == QMediaPlayer::EndOfMedia)
processLoadStateChange();
[(QTMovie*)m_QTMovie setRate:0];
processLoadStateChange();
emit stateChanged(m_state);
}
void QT7PlayerSession::stop()
{
if (m_state == QMediaPlayer::StoppedState)
return;
m_state = QMediaPlayer::StoppedState;
[(QTMovie*)m_QTMovie setRate:0];
setPosition(0);
if (m_videoOutput)
m_videoOutput->setMovie(0);
processLoadStateChange();
emit stateChanged(m_state);
emit positionChanged(position());
}
void QT7PlayerSession::setVolume(int volume)
{
if (m_volume == volume)
return;
m_volume = volume;
if (m_QTMovie != 0)
[(QTMovie*)m_QTMovie setVolume:m_volume / 100.0f];
emit volumeChanged(m_volume);
}
void QT7PlayerSession::setMuted(bool muted)
{
if (m_muted == muted)
return;
m_muted = muted;
if (m_QTMovie != 0)
[(QTMovie*)m_QTMovie setMuted:m_muted];
emit mutedChanged(muted);
}
QMediaContent QT7PlayerSession::media() const
{
return m_resources;
}
const QIODevice *QT7PlayerSession::mediaStream() const
{
return m_mediaStream;
}
void QT7PlayerSession::setMedia(const QMediaContent &content, QIODevice *stream)
{
AutoReleasePool pool;
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO << content.canonicalUrl();
#endif
if (m_QTMovie) {
[(QTMovieObserver*)m_movieObserver setMovie:nil];
if (m_videoOutput)
m_videoOutput->setMovie(0);
[(QTMovie*)m_QTMovie release];
m_QTMovie = 0;
m_resourceHandler.clear();
}
m_resources = content;
m_mediaStream = stream;
QMediaPlayer::MediaStatus oldMediaStatus = m_mediaStatus;
if (content.isNull()) {
m_mediaStatus = QMediaPlayer::NoMedia;
if (m_state != QMediaPlayer::StoppedState)
emit stateChanged(m_state = QMediaPlayer::StoppedState);
if (m_mediaStatus != oldMediaStatus)
emit mediaStatusChanged(m_mediaStatus);
emit positionChanged(position());
return;
}
m_mediaStatus = QMediaPlayer::LoadingMedia;
if (m_mediaStatus != oldMediaStatus)
emit mediaStatusChanged(m_mediaStatus);
QNetworkRequest request = content.canonicalResource().request();
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]];
}
}
// Attempt multiple times to open the movie.
// First try - attempt open in async mode
openMovie(true);
emit positionChanged(position());
}
void QT7PlayerSession::openMovie(bool tryAsync)
{
QUrl requestUrl = m_resources.canonicalResource().request().url();
if (requestUrl.scheme().isEmpty())
requestUrl.setScheme(QLatin1String("file"));
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO << requestUrl;
#endif
NSError *err = 0;
NSString *urlString = [NSString stringWithUTF8String:requestUrl.toEncoded().constData()];
NSMutableDictionary *attr = [NSMutableDictionary dictionaryWithObjectsAndKeys:
[NSNumber numberWithBool:YES], QTMovieOpenAsyncOKAttribute,
[NSNumber numberWithBool:YES], QTMovieIsActiveAttribute,
[NSNumber numberWithBool:YES], QTMovieResolveDataRefsAttribute,
[NSNumber numberWithBool:YES], QTMovieDontInteractWithUserAttribute,
nil];
if (requestUrl.scheme() == QLatin1String("qrc")) {
// Load from Qt resource
m_resourceHandler.setResourceFile(QLatin1Char(':') + requestUrl.path());
if (!m_resourceHandler.isValid()) {
emit error(QMediaPlayer::FormatError, tr("Attempting to play invalid Qt resource"));
return;
}
CFDataRef resourceData =
CFDataCreateWithBytesNoCopy(0, m_resourceHandler.data(), m_resourceHandler.size(), kCFAllocatorNull);
QTDataReference *dataReference =
[QTDataReference dataReferenceWithReferenceToData:(NSData*)resourceData
name:qString2CFStringRef(requestUrl.path())
MIMEType:nil];
[attr setObject:dataReference forKey:QTMovieDataReferenceAttribute];
CFRelease(resourceData);
} else {
[attr setObject:[NSURL URLWithString:urlString] forKey:QTMovieURLAttribute];
}
if (tryAsync && QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) {
[attr setObject:[NSNumber numberWithBool:YES] forKey:@"QTMovieOpenAsyncRequiredAttribute"];
// XXX: This is disabled for now. causes some problems with video playback for some formats
// [attr setObject:[NSNumber numberWithBool:YES] forKey:@"QTMovieOpenForPlaybackAttribute"];
m_tryingAsync = true;
}
else
m_tryingAsync = false;
m_QTMovie = [QTMovie movieWithAttributes:attr error:&err];
if (err != nil) {
// First attempt to test for inability to perform async
// if ([err code] == QTErrorMovieOpeningCannotBeAsynchronous) { XXX: error code unknown!
if (m_tryingAsync) {
m_tryingAsync = false;
err = nil;
[attr removeObjectForKey:@"QTMovieOpenAsyncRequiredAttribute"];
m_QTMovie = [QTMovie movieWithAttributes:attr error:&err];
}
}
if (err != nil) {
m_QTMovie = 0;
QString description = QString::fromUtf8([[err localizedDescription] UTF8String]);
emit error(QMediaPlayer::FormatError, description);
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO << description;
#endif
}
else {
[(QTMovie*)m_QTMovie retain];
[(QTMovieObserver*)m_movieObserver setMovie:(QTMovie*)m_QTMovie];
if (m_state != QMediaPlayer::StoppedState && m_videoOutput)
m_videoOutput->setMovie(m_QTMovie);
processLoadStateChange();
[(QTMovie*)m_QTMovie setMuted:m_muted];
[(QTMovie*)m_QTMovie setVolume:m_volume / 100.0f];
}
}
bool QT7PlayerSession::isAudioAvailable() const
{
if (!m_QTMovie)
return false;
AutoReleasePool pool;
return [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieHasAudioAttribute"] boolValue] == YES;
}
bool QT7PlayerSession::isVideoAvailable() const
{
if (!m_QTMovie)
return false;
AutoReleasePool pool;
return [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieHasVideoAttribute"] boolValue] == YES;
}
void QT7PlayerSession::processEOS()
{
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO;
#endif
emit positionChanged(position());
m_mediaStatus = QMediaPlayer::EndOfMedia;
if (m_videoOutput)
m_videoOutput->setMovie(0);
emit stateChanged(m_state = QMediaPlayer::StoppedState);
emit mediaStatusChanged(m_mediaStatus);
}
void QT7PlayerSession::processLoadStateChange()
{
if (!m_QTMovie)
return;
AutoReleasePool pool;
long state = [[(QTMovie*)m_QTMovie attributeForKey:QTMovieLoadStateAttribute] longValue];
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO << state;
#endif
#ifndef QUICKTIME_C_API_AVAILABLE
enum {
kMovieLoadStateError = -1L,
kMovieLoadStateLoading = 1000,
kMovieLoadStateLoaded = 2000,
kMovieLoadStatePlayable = 10000,
kMovieLoadStatePlaythroughOK = 20000,
kMovieLoadStateComplete = 100000
};
#endif
if (state == kMovieLoadStateError) {
if (m_tryingAsync) {
NSError *error = [(QTMovie*)m_QTMovie attributeForKey:@"QTMovieLoadStateErrorAttribute"];
if ([error code] == componentNotThreadSafeErr) {
// Last Async check, try again with no such flag
openMovie(false);
}
}
else {
if (m_videoOutput)
m_videoOutput->setMovie(0);
emit error(QMediaPlayer::FormatError, tr("Failed to load media"));
emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::InvalidMedia);
emit stateChanged(m_state = QMediaPlayer::StoppedState);
}
return;
}
QMediaPlayer::MediaStatus newStatus = QMediaPlayer::NoMedia;
bool isPlaying = (m_state != QMediaPlayer::StoppedState);
if (state >= kMovieLoadStatePlaythroughOK) {
newStatus = isPlaying ? QMediaPlayer::BufferedMedia : QMediaPlayer::LoadedMedia;
} else if (state >= kMovieLoadStatePlayable)
newStatus = isPlaying ? QMediaPlayer::BufferingMedia : QMediaPlayer::LoadingMedia;
else if (state >= kMovieLoadStateLoading) {
if (!isPlaying)
newStatus = QMediaPlayer::LoadingMedia;
else if (m_mediaStatus >= QMediaPlayer::LoadedMedia)
newStatus = QMediaPlayer::StalledMedia;
else
newStatus = QMediaPlayer::LoadingMedia;
}
if (state >= kMovieLoadStatePlayable &&
m_state == QMediaPlayer::PlayingState &&
[(QTMovie*)m_QTMovie rate] == 0) {
float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
[(QTMovie*)m_QTMovie setRate:preferredRate * m_rate];
}
if (state >= kMovieLoadStateLoaded) {
qint64 currentDuration = duration();
if (m_duration != currentDuration)
emit durationChanged(m_duration = currentDuration);
if (m_audioAvailable != isAudioAvailable())
emit audioAvailableChanged(m_audioAvailable = !m_audioAvailable);
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)
return;
int newVolume = qRound(100.0f * [((QTMovie*)m_QTMovie) volume]);
if (newVolume != m_volume) {
emit volumeChanged(m_volume = newVolume);
}
}
void QT7PlayerSession::processNaturalSizeChange()
{
AutoReleasePool pool;
NSSize size = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
#ifdef QT_DEBUG_QT7
qDebug() << Q_FUNC_INFO << QSize(size.width, size.height);
#endif
if (m_videoOutput)
m_videoOutput->updateNaturalSize(QSize(size.width, size.height));
}
void QT7PlayerSession::processPositionChange()
{
emit positionChanged(position());
}
#include "moc_qt7playersession.cpp"

88
src/plugins/qt7/qcvdisplaylink.h Normal file
View File

@@ -0,0 +1,88 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QCVDISPLAYLINK_H
#define QCVDISPLAYLINK_H
#include <QtCore/qobject.h>
#include <QtCore/qmutex.h>
#include <qmobilityglobal.h>
#include <QuartzCore/CVDisplayLink.h>
QT_BEGIN_NAMESPACE
class QCvDisplayLink : public QObject
{
Q_OBJECT
public:
QCvDisplayLink(QObject *parent = 0);
virtual ~QCvDisplayLink();
bool isValid();
bool isActive() const;
public slots:
void start();
void stop();
signals:
void tick(const CVTimeStamp &ts);
public:
void displayLinkEvent(const CVTimeStamp *);
protected:
virtual bool event(QEvent *);
private:
CVDisplayLinkRef m_displayLink;
QMutex m_displayLinkMutex;
bool m_pendingDisplayLinkEvent;
bool m_isActive;
CVTimeStamp m_frameTimeStamp;
};
QT_END_NAMESPACE
#endif

156
src/plugins/qt7/qcvdisplaylink.mm Normal file
View File

@@ -0,0 +1,156 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qcvdisplaylink.h"
#include <QtCore/qcoreapplication.h>
#include <QtCore/qdebug.h>
QT_USE_NAMESPACE
static CVReturn CVDisplayLinkCallback(CVDisplayLinkRef displayLink,
const CVTimeStamp *inNow,
const CVTimeStamp *inOutputTime,
CVOptionFlags flagsIn,
CVOptionFlags *flagsOut,
void *displayLinkContext)
{
Q_UNUSED(displayLink);
Q_UNUSED(inNow);
Q_UNUSED(flagsIn);
Q_UNUSED(flagsOut);
QCvDisplayLink *link = (QCvDisplayLink *)displayLinkContext;
link->displayLinkEvent(inOutputTime);
return kCVReturnSuccess;
}
QCvDisplayLink::QCvDisplayLink(QObject *parent)
:QObject(parent),
m_pendingDisplayLinkEvent(false),
m_isActive(false)
{
// create display link for the main display
CVDisplayLinkCreateWithCGDisplay(kCGDirectMainDisplay, &m_displayLink);
if (m_displayLink) {
// set the current display of a display link.
CVDisplayLinkSetCurrentCGDisplay(m_displayLink, kCGDirectMainDisplay);
// set the renderer output callback function
CVDisplayLinkSetOutputCallback(m_displayLink, &CVDisplayLinkCallback, this);
}
}
QCvDisplayLink::~QCvDisplayLink()
{
if (m_displayLink) {
CVDisplayLinkStop(m_displayLink);
CVDisplayLinkRelease(m_displayLink);
m_displayLink = NULL;
}
}
bool QCvDisplayLink::isValid()
{
return m_displayLink != 0;
}
bool QCvDisplayLink::isActive() const
{
return m_isActive;
}
void QCvDisplayLink::start()
{
if (m_displayLink && !m_isActive) {
CVDisplayLinkStart(m_displayLink);
m_isActive = true;
}
}
void QCvDisplayLink::stop()
{
if (m_displayLink && m_isActive) {
CVDisplayLinkStop(m_displayLink);
m_isActive = false;
}
}
void QCvDisplayLink::displayLinkEvent(const CVTimeStamp *ts)
{
// 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_frameTimeStamp = *ts;
m_displayLinkMutex.unlock();
if (!pending)
qApp->postEvent(this, new QEvent(QEvent::User), Qt::HighEventPriority);
}
bool QCvDisplayLink::event(QEvent *event)
{
switch (event->type()){
case QEvent::User: {
m_displayLinkMutex.lock();
m_pendingDisplayLinkEvent = false;
CVTimeStamp ts = m_frameTimeStamp;
m_displayLinkMutex.unlock();
emit tick(ts);
return false;
}
break;
default:
break;
}
return QObject::event(event);
}
#include "moc_qcvdisplaylink.cpp"

58
src/plugins/qt7/qt7.pro Normal file
View File

@@ -0,0 +1,58 @@
load(qt_module)
TARGET = qqt7engine
QT += multimediakit-private network
PLUGIN_TYPE = mediaservice
load(qt_plugin)
DESTDIR = $$QT.multimediakit.plugins/$${PLUGIN_TYPE}
!simulator {
QT += opengl
}
#DEFINES += QT_DEBUG_QT7
LIBS += -framework AppKit -framework AudioUnit \
-framework AudioToolbox -framework CoreAudio \
-framework QuartzCore -framework QTKit
# The Quicktime framework is only awailable for 32-bit builds, so we
# need to check for this before linking against it.
# QMAKE_MAC_XARCH is not awailable on Tiger, but at the same time,
# we never build for 64-bit architechtures on Tiger either:
contains(QMAKE_MAC_XARCH, no) {
LIBS += -framework QuickTime
} else {
LIBS += -Xarch_i386 -framework QuickTime -Xarch_ppc -framework QuickTime
}
HEADERS += \
qt7backend.h \
qt7videooutput.h \
qt7serviceplugin.h
OBJECTIVE_SOURCES += \
qt7backend.mm \
qt7serviceplugin.mm
!simulator {
HEADERS += \
qt7movieviewoutput.h \
qt7movievideowidget.h \
qt7movieviewrenderer.h \
qt7movierenderer.h \
qt7ciimagevideobuffer.h \
qcvdisplaylink.h
OBJECTIVE_SOURCES += \
qt7movieviewoutput.mm \
qt7movievideowidget.mm \
qt7movieviewrenderer.mm \
qt7movierenderer.mm \
qt7videooutput.mm \
qt7ciimagevideobuffer.mm \
qcvdisplaylink.mm
}
include(mediaplayer/mediaplayer.pri)

68
src/plugins/qt7/qt7backend.h Normal file
View File

@@ -0,0 +1,68 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7BACKEND_H
#define QT7BACKEND_H
#include "qmobilityglobal.h"
#include <QtCore/QString>
#ifndef Q_WS_SIMULATOR
#ifndef Q_WS_MAC64
#define QUICKTIME_C_API_AVAILABLE
#endif
#endif // !defined(Q_WS_SIMULATOR)
QT_BEGIN_NAMESPACE
class AutoReleasePool
{
private:
void *pool;
public:
AutoReleasePool();
~AutoReleasePool();
};
QT_END_NAMESPACE
#endif

60
src/plugins/qt7/qt7backend.mm Normal file
View File

@@ -0,0 +1,60 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7backend.h"
#import <Foundation/NSAutoreleasePool.h>
#include <CoreFoundation/CFBase.h>
QT_BEGIN_NAMESPACE
AutoReleasePool::AutoReleasePool()
{
pool = (void*)[[NSAutoreleasePool alloc] init];
}
AutoReleasePool::~AutoReleasePool()
{
[(NSAutoreleasePool*)pool release];
}
QT_END_NAMESPACE

86
src/plugins/qt7/qt7ciimagevideobuffer.h Normal file
View File

@@ -0,0 +1,86 @@
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7CIIMAGEVIDEOBUFFER_H
#define QT7CIIMAGEVIDEOBUFFER_H
#include "qt7backend.h"
#import <QTKit/QTKit.h>
#include <QtCore/qvariant.h>
#include <qabstractvideobuffer.h>
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
QT_BEGIN_NAMESPACE
class QT7CIImageVideoBuffer : public QAbstractVideoBuffer
{
public:
QT7CIImageVideoBuffer(CIImage *image);
virtual ~QT7CIImageVideoBuffer();
MapMode mapMode() const;
uchar *map(MapMode mode, int *numBytes, int *bytesPerLine);
void unmap();
QVariant handle() const;
private:
CIImage *m_image;
NSBitmapImageRep *m_buffer;
MapMode m_mode;
};
QT_END_NAMESPACE
#endif

107
src/plugins/qt7/qt7ciimagevideobuffer.mm Normal file
View File

@@ -0,0 +1,107 @@
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7ciimagevideobuffer.h"
#include <QuartzCore/CIFilter.h>
#include <QuartzCore/CIVector.h>
QT7CIImageVideoBuffer::QT7CIImageVideoBuffer(CIImage *image)
: QAbstractVideoBuffer(CoreImageHandle)
, m_image(image)
, m_buffer(0)
, m_mode(NotMapped)
{
[m_image retain];
}
QT7CIImageVideoBuffer::~QT7CIImageVideoBuffer()
{
[m_image release];
[m_buffer release];
}
QAbstractVideoBuffer::MapMode QT7CIImageVideoBuffer::mapMode() const
{
return m_mode;
}
uchar *QT7CIImageVideoBuffer::map(QAbstractVideoBuffer::MapMode mode, int *numBytes, int *bytesPerLine)
{
if (mode == NotMapped || m_mode != NotMapped || !m_image)
return 0;
if (!m_buffer) {
//swap R and B channels
CIFilter *colorSwapFilter = [CIFilter filterWithName: @"CIColorMatrix" keysAndValues:
@"inputImage", m_image,
@"inputRVector", [CIVector vectorWithX: 0 Y: 0 Z: 1 W: 0],
@"inputGVector", [CIVector vectorWithX: 0 Y: 1 Z: 0 W: 0],
@"inputBVector", [CIVector vectorWithX: 1 Y: 0 Z: 0 W: 0],
@"inputAVector", [CIVector vectorWithX: 0 Y: 0 Z: 0 W: 1],
@"inputBiasVector", [CIVector vectorWithX: 0 Y: 0 Z: 0 W: 0],
nil];
CIImage *img = [colorSwapFilter valueForKey: @"outputImage"];
m_buffer = [[NSBitmapImageRep alloc] initWithCIImage:img];
}
if (numBytes)
*numBytes = [m_buffer bytesPerPlane];
if (bytesPerLine)
*bytesPerLine = [m_buffer bytesPerRow];
m_mode = mode;
return [m_buffer bitmapData];
}
void QT7CIImageVideoBuffer::unmap()
{
m_mode = NotMapped;
}
QVariant QT7CIImageVideoBuffer::handle() const
{
return QVariant::fromValue<void*>(m_image);
}

107
src/plugins/qt7/qt7movierenderer.h Normal file
View File

@@ -0,0 +1,107 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7MOVIERENDERER_H
#define QT7MOVIERENDERER_H
#include "qt7backend.h"
#include <QtCore/qobject.h>
#include <QtCore/qmutex.h>
#include <qvideorenderercontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
#include "qt7videooutput.h"
#include <QuartzCore/CVOpenGLTexture.h>
#include <QuickTime/QuickTime.h>
QT_BEGIN_NAMESPACE
class QGLContext;
class QCvDisplayLink;
class QT7PlayerSession;
class QT7PlayerService;
class QT7MovieRenderer : public QT7VideoRendererControl
{
Q_OBJECT
public:
QT7MovieRenderer(QObject *parent = 0);
virtual ~QT7MovieRenderer();
void setMovie(void *movie);
void updateNaturalSize(const QSize &newSize);
QAbstractVideoSurface *surface() const;
void setSurface(QAbstractVideoSurface *surface);
QSize nativeSize() const;
private slots:
void updateVideoFrame(const CVTimeStamp &ts);
private:
void setupVideoOutput();
bool createPixelBufferVisualContext();
bool createGLVisualContext();
void *m_movie;
QMutex m_mutex;
QCvDisplayLink *m_displayLink;
#ifdef QUICKTIME_C_API_AVAILABLE
QTVisualContextRef m_visualContext;
bool m_usingGLContext;
const QGLContext *m_currentGLContext;
QSize m_pixelBufferContextGeometry;
#endif
QAbstractVideoSurface *m_surface;
QSize m_nativeSize;
};
QT_END_NAMESPACE
#endif

479
src/plugins/qt7/qt7movierenderer.mm Normal file
View File

@@ -0,0 +1,479 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <QTKit/QTKit.h>
#include "qt7backend.h"
#include "qt7playercontrol.h"
#include "qt7movierenderer.h"
#include "qt7playersession.h"
#include "qt7ciimagevideobuffer.h"
#include "qcvdisplaylink.h"
#include <QtCore/qdebug.h>
#include <QtCore/qcoreapplication.h>
#include <QGLWidget>
#include <qabstractvideobuffer.h>
#include <qabstractvideosurface.h>
#include <qvideosurfaceformat.h>
QT_USE_NAMESPACE
//#define USE_MAIN_MONITOR_COLOR_SPACE 1
class CVGLTextureVideoBuffer : public QAbstractVideoBuffer
{
public:
CVGLTextureVideoBuffer(CVOpenGLTextureRef buffer)
: QAbstractVideoBuffer(GLTextureHandle)
, m_buffer(buffer)
, m_mode(NotMapped)
{
CVOpenGLTextureRetain(m_buffer);
}
virtual ~CVGLTextureVideoBuffer()
{
CVOpenGLTextureRelease(m_buffer);
}
QVariant handle() const
{
GLuint id = CVOpenGLTextureGetName(m_buffer);
return QVariant(int(id));
}
MapMode mapMode() const { return m_mode; }
uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
{
if (numBytes)
*numBytes = 0;
if (bytesPerLine)
*bytesPerLine = 0;
m_mode = mode;
return 0;
}
void unmap() { m_mode = NotMapped; }
private:
CVOpenGLTextureRef m_buffer;
MapMode m_mode;
};
class CVPixelBufferVideoBuffer : public QAbstractVideoBuffer
{
public:
CVPixelBufferVideoBuffer(CVPixelBufferRef buffer)
: QAbstractVideoBuffer(NoHandle)
, m_buffer(buffer)
, m_mode(NotMapped)
{
CVPixelBufferRetain(m_buffer);
}
virtual ~CVPixelBufferVideoBuffer()
{
CVPixelBufferRelease(m_buffer);
}
MapMode mapMode() const { return m_mode; }
uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
{
if (mode != NotMapped && m_mode == NotMapped) {
CVPixelBufferLockBaseAddress(m_buffer, 0);
if (numBytes)
*numBytes = CVPixelBufferGetDataSize(m_buffer);
if (bytesPerLine)
*bytesPerLine = CVPixelBufferGetBytesPerRow(m_buffer);
m_mode = mode;
return (uchar*)CVPixelBufferGetBaseAddress(m_buffer);
} else {
return 0;
}
}
void unmap()
{
if (m_mode != NotMapped) {
m_mode = NotMapped;
CVPixelBufferUnlockBaseAddress(m_buffer, 0);
}
}
private:
CVPixelBufferRef m_buffer;
MapMode m_mode;
};
QT7MovieRenderer::QT7MovieRenderer(QObject *parent)
:QT7VideoRendererControl(parent),
m_movie(0),
#ifdef QUICKTIME_C_API_AVAILABLE
m_visualContext(0),
m_usingGLContext(false),
m_currentGLContext(0),
#endif
m_surface(0)
{
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieRenderer";
#endif
m_displayLink = new QCvDisplayLink(this);
connect(m_displayLink, SIGNAL(tick(CVTimeStamp)), SLOT(updateVideoFrame(CVTimeStamp)));
}
bool QT7MovieRenderer::createGLVisualContext()
{
#ifdef QUICKTIME_C_API_AVAILABLE
AutoReleasePool pool;
CGLContextObj cglContext = CGLGetCurrentContext();
NSOpenGLPixelFormat *nsglPixelFormat = [NSOpenGLView defaultPixelFormat];
CGLPixelFormatObj cglPixelFormat = static_cast<CGLPixelFormatObj>([nsglPixelFormat CGLPixelFormatObj]);
OSStatus err = QTOpenGLTextureContextCreate(kCFAllocatorDefault, cglContext,
cglPixelFormat, NULL, &m_visualContext);
if (err != noErr)
qWarning() << "Could not create visual context (OpenGL)";
return (err == noErr);
#endif // QUICKTIME_C_API_AVAILABLE
return false;
}
#ifdef QUICKTIME_C_API_AVAILABLE
static bool DictionarySetValue(CFMutableDictionaryRef dict, CFStringRef key, SInt32 value)
{
CFNumberRef number = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
if (number) {
CFDictionarySetValue( dict, key, number );
CFRelease( number );
return true;
}
return false;
}
#endif // QUICKTIME_C_API_AVAILABLE
bool QT7MovieRenderer::createPixelBufferVisualContext()
{
#ifdef QUICKTIME_C_API_AVAILABLE
if (m_visualContext) {
QTVisualContextRelease(m_visualContext);
m_visualContext = 0;
}
m_pixelBufferContextGeometry = m_nativeSize;
CFMutableDictionaryRef pixelBufferOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
//DictionarySetValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, k32ARGBPixelFormat );
DictionarySetValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, k32BGRAPixelFormat );
DictionarySetValue(pixelBufferOptions, kCVPixelBufferWidthKey, m_nativeSize.width() );
DictionarySetValue(pixelBufferOptions, kCVPixelBufferHeightKey, m_nativeSize.height() );
DictionarySetValue(pixelBufferOptions, kCVPixelBufferBytesPerRowAlignmentKey, 16);
//CFDictionarySetValue(pixelBufferOptions, kCVPixelBufferOpenGLCompatibilityKey, kCFBooleanTrue);
CFMutableDictionaryRef visualContextOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(visualContextOptions, kQTVisualContextPixelBufferAttributesKey, pixelBufferOptions);
CGColorSpaceRef colorSpace = NULL;
#if USE_MAIN_MONITOR_COLOR_SPACE
CMProfileRef sysprof = NULL;
// Get the Systems Profile for the main display
if (CMGetSystemProfile(&sysprof) == noErr) {
// Create a colorspace with the systems profile
colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysprof);
CMCloseProfile(sysprof);
}
#endif
if (!colorSpace)
colorSpace = CGColorSpaceCreateDeviceRGB();
CFDictionarySetValue(visualContextOptions, kQTVisualContextOutputColorSpaceKey, colorSpace);
OSStatus err = QTPixelBufferContextCreate(kCFAllocatorDefault,
visualContextOptions,
&m_visualContext);
CFRelease(pixelBufferOptions);
CFRelease(visualContextOptions);
if (err != noErr) {
qWarning() << "Could not create visual context (PixelBuffer)";
return false;
}
return true;
#endif // QUICKTIME_C_API_AVAILABLE
return false;
}
QT7MovieRenderer::~QT7MovieRenderer()
{
m_displayLink->stop();
}
void QT7MovieRenderer::setupVideoOutput()
{
AutoReleasePool pool;
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieRenderer::setupVideoOutput" << m_movie;
#endif
if (m_movie == 0 || m_surface == 0) {
m_displayLink->stop();
return;
}
NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
m_nativeSize = QSize(size.width, size.height);
#ifdef QUICKTIME_C_API_AVAILABLE
bool usedGLContext = m_usingGLContext;
if (!m_nativeSize.isEmpty()) {
bool glSupported = !m_surface->supportedPixelFormats(QAbstractVideoBuffer::GLTextureHandle).isEmpty();
//Try rendering using opengl textures first:
if (glSupported) {
QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32, QAbstractVideoBuffer::GLTextureHandle);
if (m_surface->isActive())
m_surface->stop();
if (!m_surface->start(format)) {
qWarning() << "failed to start video surface" << m_surface->error();
qWarning() << "Surface format:" << format;
glSupported = false;
} else {
m_usingGLContext = true;
}
}
if (!glSupported) {
m_usingGLContext = false;
QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32);
if (m_surface->isActive() && m_surface->surfaceFormat() != format) {
#ifdef QT_DEBUG_QT7
qDebug() << "Surface format was changed, stop the surface.";
#endif
m_surface->stop();
}
if (!m_surface->isActive()) {
#ifdef QT_DEBUG_QT7
qDebug() << "Starting the surface with format" << format;
#endif
if (!m_surface->start(format)) {
qWarning() << "failed to start video surface" << m_surface->error();
qWarning() << "Surface format:" << format;
}
}
}
}
if (m_visualContext) {
//check if the visual context still can be reused
if (usedGLContext != m_usingGLContext ||
(m_usingGLContext && (m_currentGLContext != QGLContext::currentContext())) ||
(!m_usingGLContext && (m_pixelBufferContextGeometry != m_nativeSize))) {
QTVisualContextRelease(m_visualContext);
m_pixelBufferContextGeometry = QSize();
m_visualContext = 0;
}
}
if (!m_nativeSize.isEmpty()) {
if (!m_visualContext) {
if (m_usingGLContext) {
#ifdef QT_DEBUG_QT7
qDebug() << "Building OpenGL visual context" << m_nativeSize;
#endif
m_currentGLContext = QGLContext::currentContext();
if (!createGLVisualContext()) {
qWarning() << "QT7MovieRenderer: failed to create visual context";
return;
}
} else {
#ifdef QT_DEBUG_QT7
qDebug() << "Building Pixel Buffer visual context" << m_nativeSize;
#endif
if (!createPixelBufferVisualContext()) {
qWarning() << "QT7MovieRenderer: failed to create visual context";
return;
}
}
}
// targets a Movie to render into a visual context
SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], m_visualContext);
m_displayLink->start();
}
#endif
}
void QT7MovieRenderer::setMovie(void *movie)
{
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieRenderer::setMovie" << movie;
#endif
#ifdef QUICKTIME_C_API_AVAILABLE
QMutexLocker locker(&m_mutex);
if (m_movie != movie) {
if (m_movie) {
//ensure the old movie doesn't hold the visual context, otherwise it can't be reused
SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], nil);
[(QTMovie*)m_movie release];
}
m_movie = movie;
[(QTMovie*)m_movie retain];
setupVideoOutput();
}
#endif
}
void QT7MovieRenderer::updateNaturalSize(const QSize &newSize)
{
if (m_nativeSize != newSize) {
m_nativeSize = newSize;
setupVideoOutput();
}
}
QAbstractVideoSurface *QT7MovieRenderer::surface() const
{
return m_surface;
}
void QT7MovieRenderer::setSurface(QAbstractVideoSurface *surface)
{
#ifdef QT_DEBUG_QT7
qDebug() << "Set video surface" << surface;
#endif
if (surface == m_surface)
return;
QMutexLocker locker(&m_mutex);
if (m_surface && m_surface->isActive())
m_surface->stop();
m_surface = surface;
setupVideoOutput();
}
QSize QT7MovieRenderer::nativeSize() const
{
return m_nativeSize;
}
void QT7MovieRenderer::updateVideoFrame(const CVTimeStamp &ts)
{
#ifdef QUICKTIME_C_API_AVAILABLE
QMutexLocker locker(&m_mutex);
if (m_surface && m_surface->isActive() &&
m_visualContext && QTVisualContextIsNewImageAvailable(m_visualContext, &ts)) {
CVImageBufferRef imageBuffer = NULL;
OSStatus status = QTVisualContextCopyImageForTime(m_visualContext, NULL, &ts, &imageBuffer);
if (status == noErr && imageBuffer) {
QAbstractVideoBuffer *buffer = 0;
if (m_usingGLContext) {
buffer = new QT7CIImageVideoBuffer([CIImage imageWithCVImageBuffer:imageBuffer]);
CVOpenGLTextureRelease((CVOpenGLTextureRef)imageBuffer);
} else {
buffer = new CVPixelBufferVideoBuffer((CVPixelBufferRef)imageBuffer);
//buffer = new QT7CIImageVideoBuffer( [CIImage imageWithCVImageBuffer:imageBuffer] );
CVPixelBufferRelease((CVPixelBufferRef)imageBuffer);
}
QVideoFrame frame(buffer, m_nativeSize, QVideoFrame::Format_RGB32);
m_surface->present(frame);
QTVisualContextTask(m_visualContext);
}
}
#else
Q_UNUSED(ts);
#endif
}
#include "moc_qt7movierenderer.cpp"

126
src/plugins/qt7/qt7movievideowidget.h Normal file
View File

@@ -0,0 +1,126 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7MOVIEVIDEOWIDGET_H
#define QT7MOVIEVIDEOWIDGET_H
#include <QtCore/qobject.h>
#include <QtCore/qmutex.h>
#include <qvideowindowcontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
#include "qt7videooutput.h"
#include <QuartzCore/CVOpenGLTexture.h>
#include <QuickTime/QuickTime.h>
class GLVideoWidget;
QT_BEGIN_NAMESPACE
class QCvDisplayLink;
class QT7PlayerSession;
class QT7PlayerService;
class QT7MovieVideoWidget : public QT7VideoWidgetControl
{
Q_OBJECT
public:
QT7MovieVideoWidget(QObject *parent = 0);
virtual ~QT7MovieVideoWidget();
void setMovie(void *movie);
void updateNaturalSize(const QSize &newSize);
QWidget *videoWidget();
bool isFullScreen() const;
void setFullScreen(bool fullScreen);
QSize nativeSize() const;
Qt::AspectRatioMode aspectRatioMode() const;
void setAspectRatioMode(Qt::AspectRatioMode mode);
int brightness() const;
void setBrightness(int brightness);
int contrast() const;
void setContrast(int contrast);
int hue() const;
void setHue(int hue);
int saturation() const;
void setSaturation(int saturation);
private slots:
void updateVideoFrame(const CVTimeStamp &ts);
private:
void setupVideoOutput();
bool createVisualContext();
void updateColors();
void *m_movie;
GLVideoWidget *m_videoWidget;
QCvDisplayLink *m_displayLink;
#ifdef QUICKTIME_C_API_AVAILABLE
QTVisualContextRef m_visualContext;
#endif
bool m_fullscreen;
QSize m_nativeSize;
Qt::AspectRatioMode m_aspectRatioMode;
int m_brightness;
int m_contrast;
int m_hue;
int m_saturation;
};
QT_END_NAMESPACE
#endif

437
src/plugins/qt7/qt7movievideowidget.mm Normal file
View File

@@ -0,0 +1,437 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7backend.h"
#import <QTKit/QTDataReference.h>
#import <QTKit/QTMovie.h>
#import <QTKit/QTMovieView.h>
#import <QTKit/QTMovieLayer.h>
#import <AppKit/NSImage.h>
#import <OpenGL/glu.h>
#include "qt7playercontrol.h"
#include "qt7movievideowidget.h"
#include "qt7playersession.h"
#include "qcvdisplaylink.h"
#include <QtCore/qdebug.h>
#include <QtCore/qcoreapplication.h>
#include <QGLWidget>
#include <CoreFoundation/CoreFoundation.h>
#import <QuartzCore/QuartzCore.h>
#include "math.h"
QT_USE_NAMESPACE
class GLVideoWidget : public QGLWidget
{
public:
GLVideoWidget(QWidget *parent, const QGLFormat &format)
: QGLWidget(format, parent),
m_texRef(0),
m_nativeSize(640,480),
m_aspectRatioMode(Qt::KeepAspectRatio)
{
setAutoFillBackground(false);
}
void initializeGL()
{
QColor bgColor = palette().color(QPalette::Background);
glClearColor(bgColor.redF(), bgColor.greenF(), bgColor.blueF(), bgColor.alphaF());
}
void resizeGL(int w, int h)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0, 0, GLsizei(w), GLsizei(h));
gluOrtho2D(0, GLsizei(w), 0, GLsizei(h));
updateGL();
}
void paintGL()
{
glClear(GL_COLOR_BUFFER_BIT);
if (!m_texRef)
return;
glPushMatrix();
glDisable(GL_CULL_FACE);
GLenum target = CVOpenGLTextureGetTarget(m_texRef);
glEnable(target);
glBindTexture(target, CVOpenGLTextureGetName(m_texRef));
glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLfloat lowerLeft[2], lowerRight[2], upperRight[2], upperLeft[2];
CVOpenGLTextureGetCleanTexCoords(m_texRef, lowerLeft, lowerRight, upperRight, upperLeft);
glBegin(GL_QUADS);
QRect rect = displayRect();
glTexCoord2f(lowerLeft[0], lowerLeft[1]);
glVertex2i(rect.topLeft().x(), rect.topLeft().y());
glTexCoord2f(lowerRight[0], lowerRight[1]);
glVertex2i(rect.topRight().x() + 1, rect.topRight().y());
glTexCoord2f(upperRight[0], upperRight[1]);
glVertex2i(rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);
glTexCoord2f(upperLeft[0], upperLeft[1]);
glVertex2i(rect.bottomLeft().x(), rect.bottomLeft().y() + 1);
glEnd();
glPopMatrix();
}
void setCVTexture(CVOpenGLTextureRef texRef)
{
if (m_texRef)
CVOpenGLTextureRelease(m_texRef);
m_texRef = texRef;
if (m_texRef)
CVOpenGLTextureRetain(m_texRef);
if (isVisible()) {
makeCurrent();
paintGL();
swapBuffers();
}
}
QSize sizeHint() const
{
return m_nativeSize;
}
void setNativeSize(const QSize &size)
{
m_nativeSize = size;
}
void setAspectRatioMode(Qt::AspectRatioMode mode)
{
if (m_aspectRatioMode != mode) {
m_aspectRatioMode = mode;
update();
}
}
private:
QRect displayRect() const
{
QRect displayRect = rect();
if (m_aspectRatioMode == Qt::KeepAspectRatio) {
QSize size = m_nativeSize;
size.scale(displayRect.size(), Qt::KeepAspectRatio);
displayRect = QRect(QPoint(0, 0), size);
displayRect.moveCenter(rect().center());
}
return displayRect;
}
CVOpenGLTextureRef m_texRef;
QSize m_nativeSize;
Qt::AspectRatioMode m_aspectRatioMode;
};
QT7MovieVideoWidget::QT7MovieVideoWidget(QObject *parent)
:QT7VideoWidgetControl(parent),
m_movie(0),
m_videoWidget(0),
m_fullscreen(false),
m_aspectRatioMode(Qt::KeepAspectRatio),
m_brightness(0),
m_contrast(0),
m_hue(0),
m_saturation(0)
{
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieVideoWidget";
#endif
QGLFormat format = QGLFormat::defaultFormat();
format.setSwapInterval(1); // Vertical sync (avoid tearing)
m_videoWidget = new GLVideoWidget(0, format);
m_displayLink = new QCvDisplayLink(this);
connect(m_displayLink, SIGNAL(tick(CVTimeStamp)), SLOT(updateVideoFrame(CVTimeStamp)));
if (!createVisualContext()) {
qWarning() << "QT7MovieVideoWidget: failed to create visual context";
}
}
bool QT7MovieVideoWidget::createVisualContext()
{
#ifdef QUICKTIME_C_API_AVAILABLE
m_videoWidget->makeCurrent();
AutoReleasePool pool;
CGLContextObj cglContext = CGLGetCurrentContext();
NSOpenGLPixelFormat *nsglPixelFormat = [NSOpenGLView defaultPixelFormat];
CGLPixelFormatObj cglPixelFormat = static_cast<CGLPixelFormatObj>([nsglPixelFormat CGLPixelFormatObj]);
CFTypeRef keys[] = { kQTVisualContextOutputColorSpaceKey };
CGColorSpaceRef colorSpace = NULL;
CMProfileRef sysprof = NULL;
// Get the Systems Profile for the main display
if (CMGetSystemProfile(&sysprof) == noErr) {
// Create a colorspace with the systems profile
colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysprof);
CMCloseProfile(sysprof);
}
if (!colorSpace)
colorSpace = CGColorSpaceCreateDeviceRGB();
CFDictionaryRef textureContextAttributes = CFDictionaryCreate(kCFAllocatorDefault,
(const void **)keys,
(const void **)&colorSpace, 1,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
OSStatus err = QTOpenGLTextureContextCreate(kCFAllocatorDefault,
cglContext,
cglPixelFormat,
textureContextAttributes,
&m_visualContext);
if (err != noErr)
qWarning() << "Could not create visual context (OpenGL)";
return (err == noErr);
#endif // QUICKTIME_C_API_AVAILABLE
return false;
}
QT7MovieVideoWidget::~QT7MovieVideoWidget()
{
m_displayLink->stop();
[(QTMovie*)m_movie release];
delete m_videoWidget;
}
QWidget *QT7MovieVideoWidget::videoWidget()
{
return m_videoWidget;
}
void QT7MovieVideoWidget::setupVideoOutput()
{
AutoReleasePool pool;
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieVideoWidget::setupVideoOutput" << m_movie;
#endif
if (m_movie == 0) {
m_displayLink->stop();
return;
}
NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
m_nativeSize = QSize(size.width, size.height);
m_videoWidget->setNativeSize(m_nativeSize);
#ifdef QUICKTIME_C_API_AVAILABLE
// targets a Movie to render into a visual context
SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], m_visualContext);
#endif
m_displayLink->start();
}
void QT7MovieVideoWidget::setMovie(void *movie)
{
if (m_movie == movie)
return;
if (m_movie) {
#ifdef QUICKTIME_C_API_AVAILABLE
SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], nil);
#endif
[(QTMovie*)m_movie release];
}
m_movie = movie;
[(QTMovie*)m_movie retain];
setupVideoOutput();
}
void QT7MovieVideoWidget::updateNaturalSize(const QSize &newSize)
{
if (m_nativeSize != newSize) {
m_nativeSize = newSize;
setupVideoOutput();
}
}
bool QT7MovieVideoWidget::isFullScreen() const
{
return m_fullscreen;
}
void QT7MovieVideoWidget::setFullScreen(bool fullScreen)
{
m_fullscreen = fullScreen;
}
QSize QT7MovieVideoWidget::nativeSize() const
{
return m_nativeSize;
}
Qt::AspectRatioMode QT7MovieVideoWidget::aspectRatioMode() const
{
return m_aspectRatioMode;
}
void QT7MovieVideoWidget::setAspectRatioMode(Qt::AspectRatioMode mode)
{
m_aspectRatioMode = mode;
m_videoWidget->setAspectRatioMode(mode);
}
int QT7MovieVideoWidget::brightness() const
{
return m_brightness;
}
void QT7MovieVideoWidget::setBrightness(int brightness)
{
m_brightness = brightness;
updateColors();
}
int QT7MovieVideoWidget::contrast() const
{
return m_contrast;
}
void QT7MovieVideoWidget::setContrast(int contrast)
{
m_contrast = contrast;
updateColors();
}
int QT7MovieVideoWidget::hue() const
{
return m_hue;
}
void QT7MovieVideoWidget::setHue(int hue)
{
m_hue = hue;
updateColors();
}
int QT7MovieVideoWidget::saturation() const
{
return m_saturation;
}
void QT7MovieVideoWidget::setSaturation(int saturation)
{
m_saturation = saturation;
updateColors();
}
void QT7MovieVideoWidget::updateColors()
{
#ifdef QUICKTIME_C_API_AVAILABLE
if (m_movie) {
QTMovie *movie = (QTMovie*)m_movie;
Float32 value;
value = m_brightness/100.0;
SetMovieVisualBrightness([movie quickTimeMovie], value, 0);
value = pow(2, m_contrast/50.0);
SetMovieVisualContrast([movie quickTimeMovie], value, 0);
value = m_hue/100.0;
SetMovieVisualHue([movie quickTimeMovie], value, 0);
value = 1.0+m_saturation/100.0;
SetMovieVisualSaturation([movie quickTimeMovie], value, 0);
}
#endif
}
void QT7MovieVideoWidget::updateVideoFrame(const CVTimeStamp &ts)
{
#ifdef QUICKTIME_C_API_AVAILABLE
AutoReleasePool pool;
// check for new frame
if (m_visualContext && QTVisualContextIsNewImageAvailable(m_visualContext, &ts)) {
CVOpenGLTextureRef currentFrame = NULL;
// get a "frame" (image buffer) from the Visual Context, indexed by the provided time
OSStatus status = QTVisualContextCopyImageForTime(m_visualContext, NULL, &ts, &currentFrame);
// the above call may produce a null frame so check for this first
// if we have a frame, then draw it
if (status == noErr && currentFrame) {
#ifdef QT_DEBUG_QT7
qDebug() << "render video frame";
#endif
m_videoWidget->setCVTexture(currentFrame);
CVOpenGLTextureRelease(currentFrame);
}
QTVisualContextTask(m_visualContext);
}
#else
Q_UNUSED(ts);
#endif
}
#include "moc_qt7movievideowidget.cpp"

116
src/plugins/qt7/qt7movieviewoutput.h Normal file
View File

@@ -0,0 +1,116 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7MOVIEVIEWOUTPUT_H
#define QT7MOVIEVIEWOUTPUT_H
#include <QtCore/qobject.h>
#include <qvideowindowcontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
#include "qt7videooutput.h"
QT_BEGIN_NAMESPACE
class QT7PlayerSession;
class QT7PlayerService;
class QT7MovieViewOutput : public QT7VideoWindowControl
{
public:
QT7MovieViewOutput(QObject *parent = 0);
~QT7MovieViewOutput();
void setMovie(void *movie);
void updateNaturalSize(const QSize &newSize);
WId winId() const;
void setWinId(WId id);
QRect displayRect() const;
void setDisplayRect(const QRect &rect);
bool isFullScreen() const;
void setFullScreen(bool fullScreen);
void repaint();
QSize nativeSize() const;
Qt::AspectRatioMode aspectRatioMode() const;
void setAspectRatioMode(Qt::AspectRatioMode mode);
int brightness() const;
void setBrightness(int brightness);
int contrast() const;
void setContrast(int contrast);
int hue() const;
void setHue(int hue);
int saturation() const;
void setSaturation(int saturation);
private:
void setupVideoOutput();
void *m_movie;
void *m_movieView;
bool m_layouted;
WId m_winId;
QRect m_displayRect;
bool m_fullscreen;
QSize m_nativeSize;
Qt::AspectRatioMode m_aspectRatioMode;
int m_brightness;
int m_contrast;
int m_hue;
int m_saturation;
};
QT_END_NAMESPACE
#endif

339
src/plugins/qt7/qt7movieviewoutput.mm Normal file
View File

@@ -0,0 +1,339 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <QTKit/QTkit.h>
#include "qt7backend.h"
#include "qt7playercontrol.h"
#include "qt7movieviewoutput.h"
#include "qt7playersession.h"
#include <QtCore/qdebug.h>
#include <QuartzCore/CIFilter.h>
#include <QuartzCore/CIVector.h>
QT_USE_NAMESPACE
#define VIDEO_TRANSPARENT(m) -(void)m:(NSEvent *)e{[[self superview] m:e];}
@interface TransparentQTMovieView : QTMovieView
{
@private
QRect *m_drawRect;
qreal m_brightness, m_contrast, m_saturation, m_hue;
}
- (TransparentQTMovieView *) init;
- (void) setDrawRect:(QRect &)rect;
- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img;
- (void) setContrast:(qreal) contrast;
@end
@implementation TransparentQTMovieView
- (TransparentQTMovieView *) init
{
self = [super initWithFrame:NSZeroRect];
if (self) {
[self setControllerVisible:NO];
[self setContrast:1.0];
[self setDelegate:self];
}
return self;
}
- (void) dealloc
{
[super dealloc];
}
- (void) setContrast:(qreal) contrast
{
m_hue = 0.0;
m_brightness = 0.0;
m_contrast = contrast;
m_saturation = 1.0;
}
- (void) setDrawRect:(QRect &)rect
{
*m_drawRect = rect;
NSRect nsrect;
nsrect.origin.x = m_drawRect->x();
nsrect.origin.y = m_drawRect->y();
nsrect.size.width = m_drawRect->width();
nsrect.size.height = m_drawRect->height();
[self setFrame:nsrect];
}
- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img
{
// This method is called from QTMovieView just
// before the image will be drawn.
Q_UNUSED(view);
if ( !qFuzzyCompare(m_brightness, 0.0) ||
!qFuzzyCompare(m_contrast, 1.0) ||
!qFuzzyCompare(m_saturation, 1.0)){
CIFilter *colorFilter = [CIFilter filterWithName:@"CIColorControls"];
[colorFilter setValue:[NSNumber numberWithFloat:m_brightness] forKey:@"inputBrightness"];
[colorFilter setValue:[NSNumber numberWithFloat:(m_contrast < 1) ? m_contrast : 1 + ((m_contrast-1)*3)] forKey:@"inputContrast"];
[colorFilter setValue:[NSNumber numberWithFloat:m_saturation] forKey:@"inputSaturation"];
[colorFilter setValue:img forKey:@"inputImage"];
img = [colorFilter valueForKey:@"outputImage"];
}
/*if (m_hue){
CIFilter *colorFilter = [CIFilter filterWithName:@"CIHueAdjust"];
[colorFilter setValue:[NSNumber numberWithFloat:(m_hue * 3.14)] forKey:@"inputAngle"];
[colorFilter setValue:img forKey:@"inputImage"];
img = [colorFilter valueForKey:@"outputImage"];
}*/
return img;
}
VIDEO_TRANSPARENT(mouseDown);
VIDEO_TRANSPARENT(mouseDragged);
VIDEO_TRANSPARENT(mouseUp);
VIDEO_TRANSPARENT(mouseMoved);
VIDEO_TRANSPARENT(mouseEntered);
VIDEO_TRANSPARENT(mouseExited);
VIDEO_TRANSPARENT(rightMouseDown);
VIDEO_TRANSPARENT(rightMouseDragged);
VIDEO_TRANSPARENT(rightMouseUp);
VIDEO_TRANSPARENT(otherMouseDown);
VIDEO_TRANSPARENT(otherMouseDragged);
VIDEO_TRANSPARENT(otherMouseUp);
VIDEO_TRANSPARENT(keyDown);
VIDEO_TRANSPARENT(keyUp);
VIDEO_TRANSPARENT(scrollWheel)
@end
QT7MovieViewOutput::QT7MovieViewOutput(QObject *parent)
:QT7VideoWindowControl(parent),
m_movie(0),
m_movieView(0),
m_layouted(false),
m_winId(0),
m_fullscreen(false),
m_aspectRatioMode(Qt::KeepAspectRatio),
m_brightness(0),
m_contrast(0),
m_hue(0),
m_saturation(0)
{
}
QT7MovieViewOutput::~QT7MovieViewOutput()
{
[(QTMovieView*)m_movieView release];
[(QTMovie*)m_movie release];
}
void QT7MovieViewOutput::setupVideoOutput()
{
AutoReleasePool pool;
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieViewOutput::setupVideoOutput" << m_movie << m_winId;
#endif
if (m_movie == 0 || m_winId <= 0)
return;
NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
m_nativeSize = QSize(size.width, size.height);
if (!m_movieView)
m_movieView = [[TransparentQTMovieView alloc] init];
[(QTMovieView*)m_movieView setControllerVisible:NO];
[(QTMovieView*)m_movieView setMovie:(QTMovie*)m_movie];
[(NSView *)m_winId addSubview:(QTMovieView*)m_movieView];
m_layouted = true;
setDisplayRect(m_displayRect);
}
void QT7MovieViewOutput::setMovie(void *movie)
{
if (m_movie != movie) {
if (m_movie) {
if (m_movieView)
[(QTMovieView*)m_movieView setMovie:nil];
[(QTMovie*)m_movie release];
}
m_movie = movie;
if (m_movie)
[(QTMovie*)m_movie retain];
setupVideoOutput();
}
}
void QT7MovieViewOutput::updateNaturalSize(const QSize &newSize)
{
if (m_nativeSize != newSize) {
m_nativeSize = newSize;
emit nativeSizeChanged();
}
}
WId QT7MovieViewOutput::winId() const
{
return m_winId;
}
void QT7MovieViewOutput::setWinId(WId id)
{
if (m_winId != id) {
if (m_movieView && m_layouted) {
[(QTMovieView*)m_movieView removeFromSuperview];
m_layouted = false;
}
m_winId = id;
setupVideoOutput();
}
}
QRect QT7MovieViewOutput::displayRect() const
{
return m_displayRect;
}
void QT7MovieViewOutput::setDisplayRect(const QRect &rect)
{
m_displayRect = rect;
if (m_movieView) {
AutoReleasePool pool;
[(QTMovieView*)m_movieView setPreservesAspectRatio:(m_aspectRatioMode == Qt::KeepAspectRatio ? YES : NO)];
[(QTMovieView*)m_movieView setFrame:NSMakeRect(m_displayRect.x(),
m_displayRect.y(),
m_displayRect.width(),
m_displayRect.height())];
}
}
bool QT7MovieViewOutput::isFullScreen() const
{
return m_fullscreen;
}
void QT7MovieViewOutput::setFullScreen(bool fullScreen)
{
m_fullscreen = fullScreen;
setDisplayRect(m_displayRect);
}
void QT7MovieViewOutput::repaint()
{
}
QSize QT7MovieViewOutput::nativeSize() const
{
return m_nativeSize;
}
Qt::AspectRatioMode QT7MovieViewOutput::aspectRatioMode() const
{
return m_aspectRatioMode;
}
void QT7MovieViewOutput::setAspectRatioMode(Qt::AspectRatioMode mode)
{
m_aspectRatioMode = mode;
setDisplayRect(m_displayRect);
}
int QT7MovieViewOutput::brightness() const
{
return m_brightness;
}
void QT7MovieViewOutput::setBrightness(int brightness)
{
m_brightness = brightness;
}
int QT7MovieViewOutput::contrast() const
{
return m_contrast;
}
void QT7MovieViewOutput::setContrast(int contrast)
{
m_contrast = contrast;
[(TransparentQTMovieView*)m_movieView setContrast:(contrast/100.0+1.0)];
}
int QT7MovieViewOutput::hue() const
{
return m_hue;
}
void QT7MovieViewOutput::setHue(int hue)
{
m_hue = hue;
}
int QT7MovieViewOutput::saturation() const
{
return m_saturation;
}
void QT7MovieViewOutput::setSaturation(int saturation)
{
m_saturation = saturation;
}

93
src/plugins/qt7/qt7movieviewrenderer.h Normal file
View File

@@ -0,0 +1,93 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7MOVIEVIEWRENDERER_H
#define QT7MOVIEVIEWRENDERER_H
#include <QtCore/qobject.h>
#include <QtCore/qmutex.h>
#include <qvideowindowcontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
#include "qt7videooutput.h"
#include <qvideoframe.h>
QT_BEGIN_NAMESPACE
class QVideoFrame;
class QT7PlayerSession;
class QT7PlayerService;
class QT7MovieViewRenderer : public QT7VideoRendererControl
{
public:
QT7MovieViewRenderer(QObject *parent = 0);
~QT7MovieViewRenderer();
void setMovie(void *movie);
void updateNaturalSize(const QSize &newSize);
QAbstractVideoSurface *surface() const;
void setSurface(QAbstractVideoSurface *surface);
void renderFrame(const QVideoFrame &);
protected:
bool event(QEvent *event);
private:
void setupVideoOutput();
void *m_movie;
void *m_movieView;
QSize m_nativeSize;
QAbstractVideoSurface *m_surface;
QVideoFrame m_currentFrame;
bool m_pendingRenderEvent;
QMutex m_mutex;
};
QT_END_NAMESPACE
#endif

371
src/plugins/qt7/qt7movieviewrenderer.mm Normal file
View File

@@ -0,0 +1,371 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <QTKit/QTKit.h>
#include "qt7backend.h"
#include "qt7playercontrol.h"
#include "qt7movieviewrenderer.h"
#include "qt7playersession.h"
#include "qt7ciimagevideobuffer.h"
#include <QtCore/qdebug.h>
#include <QtCore/qcoreevent.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qreadwritelock.h>
#include <qabstractvideobuffer.h>
#include <qabstractvideosurface.h>
#include <qvideosurfaceformat.h>
#include <QuartzCore/CIFilter.h>
#include <QuartzCore/CIVector.h>
QT_USE_NAMESPACE
class NSBitmapVideoBuffer : public QAbstractVideoBuffer
{
public:
NSBitmapVideoBuffer(NSBitmapImageRep *buffer)
: QAbstractVideoBuffer(NoHandle)
, m_buffer(buffer)
, m_mode(NotMapped)
{
[m_buffer retain];
}
virtual ~NSBitmapVideoBuffer()
{
[m_buffer release];
}
MapMode mapMode() const { return m_mode; }
uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
{
if (mode != NotMapped && m_mode == NotMapped) {
if (numBytes)
*numBytes = [m_buffer bytesPerPlane];
if (bytesPerLine)
*bytesPerLine = [m_buffer bytesPerRow];
m_mode = mode;
return [m_buffer bitmapData];
} else {
return 0;
}
}
void unmap() { m_mode = NotMapped; }
private:
NSBitmapImageRep *m_buffer;
MapMode m_mode;
};
#define VIDEO_TRANSPARENT(m) -(void)m:(NSEvent *)e{[[self superview] m:e];}
@interface HiddenQTMovieView : QTMovieView
{
@private
QWidget *m_window;
QT7MovieViewRenderer *m_renderer;
QReadWriteLock m_rendererLock;
}
- (HiddenQTMovieView *) initWithRenderer:(QT7MovieViewRenderer *)renderer;
- (void) setRenderer:(QT7MovieViewRenderer *)renderer;
- (void) setDrawRect:(const QRect &)rect;
- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img;
@end
@implementation HiddenQTMovieView
- (HiddenQTMovieView *) initWithRenderer:(QT7MovieViewRenderer *)renderer
{
self = [super initWithFrame:NSZeroRect];
if (self) {
[self setControllerVisible:NO];
[self setDelegate:self];
QWriteLocker lock(&self->m_rendererLock);
self->m_renderer = renderer;
self->m_window = new QWidget;
self->m_window->setWindowOpacity(0.0);
self->m_window->show();
self->m_window->hide();
[(NSView *)(self->m_window->winId()) addSubview:self];
[self setDrawRect:QRect(0,0,1,1)];
}
return self;
}
- (void) dealloc
{
[super dealloc];
}
- (void) setRenderer:(QT7MovieViewRenderer *)renderer
{
QWriteLocker lock(&m_rendererLock);
m_renderer = renderer;
}
- (void) setDrawRect:(const QRect &)rect
{
NSRect nsrect;
nsrect.origin.x = rect.x();
nsrect.origin.y = rect.y();
nsrect.size.width = rect.width();
nsrect.size.height = rect.height();
[self setFrame:nsrect];
}
- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img
{
// This method is called from QTMovieView just
// before the image will be drawn.
Q_UNUSED(view);
QReadLocker lock(&m_rendererLock);
if (m_renderer) {
CGRect bounds = [img extent];
int w = bounds.size.width;
int h = bounds.size.height;
QVideoFrame frame;
QAbstractVideoSurface *surface = m_renderer->surface();
if (!surface || !surface->isActive())
return img;
if (surface->surfaceFormat().handleType() == QAbstractVideoBuffer::CoreImageHandle) {
//surface supports rendering of opengl based CIImage
frame = QVideoFrame(new QT7CIImageVideoBuffer(img), QSize(w,h), QVideoFrame::Format_RGB32 );
} else {
//Swap R and B colors
CIFilter *colorSwapFilter = [CIFilter filterWithName: @"CIColorMatrix" keysAndValues:
@"inputImage", img,
@"inputRVector", [CIVector vectorWithX: 0 Y: 0 Z: 1 W: 0],
@"inputGVector", [CIVector vectorWithX: 0 Y: 1 Z: 0 W: 0],
@"inputBVector", [CIVector vectorWithX: 1 Y: 0 Z: 0 W: 0],
@"inputAVector", [CIVector vectorWithX: 0 Y: 0 Z: 0 W: 1],
@"inputBiasVector", [CIVector vectorWithX: 0 Y: 0 Z: 0 W: 0],
nil];
CIImage *img = [colorSwapFilter valueForKey: @"outputImage"];
NSBitmapImageRep *bitmap =[[NSBitmapImageRep alloc] initWithCIImage:img];
//requesting the bitmap data is slow,
//but it's better to do it here to avoid blocking the main thread for a long.
[bitmap bitmapData];
frame = QVideoFrame(new NSBitmapVideoBuffer(bitmap), QSize(w,h), QVideoFrame::Format_RGB32 );
[bitmap release];
}
m_renderer->renderFrame(frame);
}
return img;
}
// Override this method so that the movie doesn't stop if
// the window becomes invisible
- (void)viewWillMoveToWindow:(NSWindow *)newWindow
{
Q_UNUSED(newWindow);
}
VIDEO_TRANSPARENT(mouseDown);
VIDEO_TRANSPARENT(mouseDragged);
VIDEO_TRANSPARENT(mouseUp);
VIDEO_TRANSPARENT(mouseMoved);
VIDEO_TRANSPARENT(mouseEntered);
VIDEO_TRANSPARENT(mouseExited);
VIDEO_TRANSPARENT(rightMouseDown);
VIDEO_TRANSPARENT(rightMouseDragged);
VIDEO_TRANSPARENT(rightMouseUp);
VIDEO_TRANSPARENT(otherMouseDown);
VIDEO_TRANSPARENT(otherMouseDragged);
VIDEO_TRANSPARENT(otherMouseUp);
VIDEO_TRANSPARENT(keyDown);
VIDEO_TRANSPARENT(keyUp);
VIDEO_TRANSPARENT(scrollWheel)
@end
QT7MovieViewRenderer::QT7MovieViewRenderer(QObject *parent)
:QT7VideoRendererControl(parent),
m_movie(0),
m_movieView(0),
m_surface(0),
m_pendingRenderEvent(false)
{
}
QT7MovieViewRenderer::~QT7MovieViewRenderer()
{
[(HiddenQTMovieView*)m_movieView setRenderer:0];
QMutexLocker locker(&m_mutex);
m_currentFrame = QVideoFrame();
[(HiddenQTMovieView*)m_movieView release];
}
void QT7MovieViewRenderer::setupVideoOutput()
{
AutoReleasePool pool;
#ifdef QT_DEBUG_QT7
qDebug() << "QT7MovieViewRenderer::setupVideoOutput" << m_movie << m_surface;
#endif
HiddenQTMovieView *movieView = (HiddenQTMovieView*)m_movieView;
if (movieView && !m_movie) {
[movieView setMovie:nil];
}
if (m_movie) {
NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
m_nativeSize = QSize(size.width, size.height);
if (!movieView) {
movieView = [[HiddenQTMovieView alloc] initWithRenderer:this];
m_movieView = movieView;
[movieView setControllerVisible:NO];
}
[movieView setMovie:(QTMovie*)m_movie];
[movieView setDrawRect:QRect(QPoint(0,0), m_nativeSize)];
}
if (m_surface && !m_nativeSize.isEmpty()) {
bool coreImageFrameSupported = !m_surface->supportedPixelFormats(QAbstractVideoBuffer::CoreImageHandle).isEmpty() &&
!m_surface->supportedPixelFormats(QAbstractVideoBuffer::GLTextureHandle).isEmpty();
QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32,
coreImageFrameSupported ? QAbstractVideoBuffer::CoreImageHandle : QAbstractVideoBuffer::NoHandle);
if (m_surface->isActive() && m_surface->surfaceFormat() != format) {
#ifdef QT_DEBUG_QT7
qDebug() << "Surface format was changed, stop the surface.";
#endif
m_surface->stop();
}
if (!m_surface->isActive()) {
#ifdef QT_DEBUG_QT7
qDebug() << "Starting the surface with format" << format;
#endif
if (!m_surface->start(format))
qWarning() << "failed to start video surface" << m_surface->error();
}
}
}
void QT7MovieViewRenderer::setMovie(void *movie)
{
if (movie == m_movie)
return;
QMutexLocker locker(&m_mutex);
m_movie = movie;
setupVideoOutput();
}
void QT7MovieViewRenderer::updateNaturalSize(const QSize &newSize)
{
if (m_nativeSize != newSize) {
m_nativeSize = newSize;
setupVideoOutput();
}
}
QAbstractVideoSurface *QT7MovieViewRenderer::surface() const
{
return m_surface;
}
void QT7MovieViewRenderer::setSurface(QAbstractVideoSurface *surface)
{
if (surface == m_surface)
return;
QMutexLocker locker(&m_mutex);
if (m_surface && m_surface->isActive())
m_surface->stop();
m_surface = surface;
setupVideoOutput();
}
void QT7MovieViewRenderer::renderFrame(const QVideoFrame &frame)
{
QMutexLocker locker(&m_mutex);
m_currentFrame = frame;
if (!m_pendingRenderEvent)
qApp->postEvent(this, new QEvent(QEvent::User), Qt::HighEventPriority);
m_pendingRenderEvent = true;
}
bool QT7MovieViewRenderer::event(QEvent *event)
{
if (event->type() == QEvent::User) {
QMutexLocker locker(&m_mutex);
m_pendingRenderEvent = false;
if (m_surface->isActive())
m_surface->present(m_currentFrame);
}
return QT7VideoRendererControl::event(event);
}

75
src/plugins/qt7/qt7serviceplugin.h Normal file
View File

@@ -0,0 +1,75 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7SERVICEPLUGIN_H
#define QT7SERVICEPLUGIN_H
#include <qmediaserviceproviderplugin.h>
QT_BEGIN_NAMESPACE
class QT7ServicePlugin
: public QMediaServiceProviderPlugin
, public QMediaServiceSupportedFormatsInterface
, public QMediaServiceFeaturesInterface
{
Q_INTERFACES(QMediaServiceFeaturesInterface)
public:
QT7ServicePlugin();
QStringList keys() const;
QMediaService* create(QString const& key);
void release(QMediaService *service);
QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const;
QtMultimediaKit::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const;
QStringList supportedMimeTypes() const;
private:
void buildSupportedTypes();
QStringList m_supportedMimeTypes;
};
QT_END_NAMESPACE
#endif // QGSTREAMERSERVICEPLUGIN_H

129
src/plugins/qt7/qt7serviceplugin.mm Normal file
View File

@@ -0,0 +1,129 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <Foundation/Foundation.h>
#import <QTKit/QTKit.h>
#include <QtCore/qstring.h>
#include <QtCore/qdebug.h>
#include "qt7backend.h"
#include "qt7serviceplugin.h"
#include "qt7playerservice.h"
#include <qmediaserviceprovider.h>
QT_BEGIN_NAMESPACE
QT7ServicePlugin::QT7ServicePlugin()
{
buildSupportedTypes();
}
QStringList QT7ServicePlugin::keys() const
{
return QStringList()
#ifdef QMEDIA_QT7_PLAYER
<< QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
#endif
;
}
QMediaService* QT7ServicePlugin::create(QString const& key)
{
#ifdef QT_DEBUG_QT7
qDebug() << "QT7ServicePlugin::create" << key;
#endif
#ifdef QMEDIA_QT7_PLAYER
if (key == QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER))
return new QT7PlayerService;
#endif
qWarning() << "unsupported key:" << key;
return 0;
}
void QT7ServicePlugin::release(QMediaService *service)
{
delete service;
}
QMediaServiceProviderHint::Features QT7ServicePlugin::supportedFeatures(
const QByteArray &service) const
{
if (service == Q_MEDIASERVICE_MEDIAPLAYER)
return QMediaServiceProviderHint::VideoSurface;
else
return QMediaServiceProviderHint::Features();
}
QtMultimediaKit::SupportEstimate QT7ServicePlugin::hasSupport(const QString &mimeType, const QStringList& codecs) const
{
Q_UNUSED(codecs);
if (m_supportedMimeTypes.contains(mimeType))
return QtMultimediaKit::ProbablySupported;
return QtMultimediaKit::MaybeSupported;
}
QStringList QT7ServicePlugin::supportedMimeTypes() const
{
return m_supportedMimeTypes;
}
void QT7ServicePlugin::buildSupportedTypes()
{
AutoReleasePool pool;
NSArray *utis = [QTMovie movieTypesWithOptions:QTIncludeCommonTypes];
for (NSString *uti in utis) {
NSString* mimeType = (NSString*)UTTypeCopyPreferredTagWithClass((CFStringRef)uti, kUTTagClassMIMEType);
if (mimeType != 0) {
m_supportedMimeTypes.append(QString::fromUtf8([mimeType UTF8String]));
[mimeType release];
}
}
}
Q_EXPORT_PLUGIN2(qtmedia_qt7engine, QT7ServicePlugin);
QT_END_NAMESPACE

116
src/plugins/qt7/qt7videooutput.h Normal file
View File

@@ -0,0 +1,116 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QT7VIDEOOUTPUTCONTROL_H
#define QT7VIDEOOUTPUTCONTROL_H
#include <QtCore/qobject.h>
#include <QtCore/qsize.h>
#include <qvideowindowcontrol.h>
#include <qvideowidgetcontrol.h>
#include <qvideorenderercontrol.h>
#include <qmediaplayer.h>
#include <QtGui/qmacdefines_mac.h>
QT_BEGIN_NAMESPACE
class QMediaPlaylist;
class QMediaPlaylistNavigator;
class QT7PlayerSession;
class QT7PlayerService;
class QT7VideoOutput {
public:
virtual ~QT7VideoOutput() {}
virtual void setMovie(void *movie) = 0;
virtual void updateNaturalSize(const QSize &newSize) = 0;
};
#define QT7VideoOutput_iid \
"com.nokia.Qt.QT7VideoOutput/1.0"
Q_DECLARE_INTERFACE(QT7VideoOutput, QT7VideoOutput_iid)
class QT7VideoWindowControl : public QVideoWindowControl, public QT7VideoOutput
{
Q_OBJECT
Q_INTERFACES(QT7VideoOutput)
public:
virtual ~QT7VideoWindowControl() {}
protected:
QT7VideoWindowControl(QObject *parent)
:QVideoWindowControl(parent)
{}
};
class QT7VideoRendererControl : public QVideoRendererControl, public QT7VideoOutput
{
Q_OBJECT
Q_INTERFACES(QT7VideoOutput)
public:
virtual ~QT7VideoRendererControl() {}
protected:
QT7VideoRendererControl(QObject *parent)
:QVideoRendererControl(parent)
{}
};
class QT7VideoWidgetControl : public QVideoWidgetControl, public QT7VideoOutput
{
Q_OBJECT
Q_INTERFACES(QT7VideoOutput)
public:
virtual ~QT7VideoWidgetControl() {}
protected:
QT7VideoWidgetControl(QObject *parent)
:QVideoWidgetControl(parent)
{}
};
QT_END_NAMESPACE
#endif

91
src/plugins/qt7/qt7videooutput.mm Normal file
View File

@@ -0,0 +1,91 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt7playercontrol.h"
#include "qt7playersession.h"
#include <QtCore/qdebug.h>
QT_USE_NAMESPACE
/*
QT7VideoOutputControl::QT7VideoOutputControl(QObject *parent)
:QVideoOutputControl(parent),
m_session(0),
m_output(QVideoOutputControl::NoOutput)
{
}
QT7VideoOutputControl::~QT7VideoOutputControl()
{
}
void QT7VideoOutputControl::setSession(QT7PlayerSession *session)
{
m_session = session;
}
QList<QVideoOutputControl::Output> QT7VideoOutputControl::availableOutputs() const
{
return m_outputs;
}
void QT7VideoOutputControl::enableOutput(QVideoOutputControl::Output output)
{
if (!m_outputs.contains(output))
m_outputs.append(output);
}
QVideoOutputControl::Output QT7VideoOutputControl::output() const
{
return m_output;
}
void QT7VideoOutputControl::setOutput(Output output)
{
if (m_output != output) {
m_output = output;
emit videoOutputChanged(m_output);
}
}
#include "moc_qt7videooutputcontrol.cpp"
*/