diff options
33 files changed, 4983 insertions, 1 deletions
diff --git a/src/plugins/mediaservices/mediaservices.pro b/src/plugins/mediaservices/mediaservices.pro index 6a00a14..fdc1cd9 100644 --- a/src/plugins/mediaservices/mediaservices.pro +++ b/src/plugins/mediaservices/mediaservices.pro @@ -8,4 +8,6 @@ contains(QT_CONFIG, media-backend) { unix:!mac:!symbian:contains(QT_CONFIG, xvideo):contains(QT_CONFIG, gstreamer) { SUBDIRS += gstreamer } + + symbian:SUBDIRS += symbian } diff --git a/src/plugins/mediaservices/symbian/mediaplayer/mediaplayer.pri b/src/plugins/mediaservices/symbian/mediaplayer/mediaplayer.pri new file mode 100644 index 0000000..205e014 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/mediaplayer.pri @@ -0,0 +1,63 @@ +INCLUDEPATH += $$PWD +LIBS += -lmediaclientvideo \ + -lmediaclientaudio \ + -lws32 \ + -lfbscli \ + -lcone \ + -lmmfcontrollerframework \ + -lefsrv \ + -lbitgdi \ + -lapgrfx \ + -lapmime + + +# We are building Symbian backend with media player support +DEFINES += QMEDIA_MMF_PLAYER + + +HEADERS += \ + $$PWD/s60mediaplayercontrol.h \ + $$PWD/s60mediaplayerservice.h \ + $$PWD/s60mediaplayersession.h \ + $$PWD/s60videoplayersession.h \ + $$PWD/s60mediametadataprovider.h \ + $$PWD/s60videosurface.h \ + $$PWD/s60videooverlay.h \ + $$PWD/s60videorenderer.h \ + $$PWD/s60mediarecognizer.h \ + $$PWD/s60audioplayersession.h \ + $$PWD/ms60mediaplayerresolver.h \ + $$PWD/s60videowidget.h \ + $$PWD/s60mediaplayeraudioendpointselector.h + +SOURCES += \ + $$PWD/s60mediaplayercontrol.cpp \ + $$PWD/s60mediaplayerservice.cpp \ + $$PWD/s60mediaplayersession.cpp \ + $$PWD/s60videoplayersession.cpp \ + $$PWD/s60mediametadataprovider.cpp \ + $$PWD/s60videosurface.cpp \ + $$PWD/s60videooverlay.cpp \ + $$PWD/s60videorenderer.cpp \ + $$PWD/s60mediarecognizer.cpp \ + $$PWD/s60audioplayersession.cpp \ + $$PWD/s60videowidget.cpp \ + $$PWD/s60mediaplayeraudioendpointselector.cpp + +contains(S60_VERSION, 3.1) { + + #3.1 doesn't provide audio routing in videoplayer + DEFINES += HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER + + !exists($${EPOCROOT}epoc32\release\winscw\udeb\audiooutputrouting.lib) { + MMP_RULES += "$${LITERAL_HASH}ifdef WINSCW" \ + "MACRO HAS_NO_AUDIOROUTING" \ + "$${LITERAL_HASH}else" \ + "LIBRARY audiooutputrouting.lib" \ + "$${LITERAL_HASH}endif" + } + +} else { + LIBS += -laudiooutputrouting +} + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/ms60mediaplayerresolver.h b/src/plugins/mediaservices/symbian/mediaplayer/ms60mediaplayerresolver.h new file mode 100644 index 0000000..b655a83 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/ms60mediaplayerresolver.h @@ -0,0 +1,58 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 MS60MEDIAPLAYERRESOLVER_H +#define MS60MEDIAPLAYERRESOLVER_H + +QT_BEGIN_NAMESPACE + +class S60MediaPlayerSession; + +class MS60MediaPlayerResolver +{ + public: + virtual S60MediaPlayerSession* PlayerSession() = 0; + virtual S60MediaPlayerSession* VideoPlayerSession() = 0; + virtual S60MediaPlayerSession* AudioPlayerSession() = 0; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.cpp new file mode 100644 index 0000000..f4065e4 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.cpp @@ -0,0 +1,268 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60audioplayersession.h" +#include <QtCore/qdebug.h> +#include <QtCore/qvariant.h> + +#include <AudioOutput.h> +#include <MAudioOutputObserver.h> + +QT_BEGIN_NAMESPACE + +S60AudioPlayerSession::S60AudioPlayerSession(QObject *parent) + : S60MediaPlayerSession(parent) + , m_player(0) + , m_audioOutput(0) + , m_audioEndpoint("Default") +{ + QT_TRAP_THROWING(m_player = CAudioPlayer::NewL(*this, 0, EMdaPriorityPreferenceNone)); + m_player->RegisterForAudioLoadingNotification(*this); +} + +S60AudioPlayerSession::~S60AudioPlayerSession() +{ +#if !defined(HAS_NO_AUDIOROUTING) + if (m_audioOutput) + m_audioOutput->UnregisterObserver(*this); + delete m_audioOutput; +#endif + m_player->Close(); + delete m_player; +} + +void S60AudioPlayerSession::doLoadL(const TDesC &path) +{ + // m_audioOutput needs to be reinitialized after MapcInitComplete + if (m_audioOutput) + m_audioOutput->UnregisterObserver(*this); + delete m_audioOutput; + m_audioOutput = NULL; + + m_player->OpenFileL(path); +} + +qint64 S60AudioPlayerSession::doGetDurationL() const +{ + return m_player->Duration().Int64() / qint64(1000); +} + +qint64 S60AudioPlayerSession::doGetPositionL() const +{ + TTimeIntervalMicroSeconds ms = 0; + m_player->GetPosition(ms); + return ms.Int64() / qint64(1000); +} + +bool S60AudioPlayerSession::isVideoAvailable() const +{ + return false; +} +bool S60AudioPlayerSession::isAudioAvailable() const +{ + return true; // this is a bit happy scenario, but we do emit error that we can't play +} + +void S60AudioPlayerSession::MaloLoadingStarted() +{ + buffering(); +} + +void S60AudioPlayerSession::MaloLoadingComplete() +{ + buffered(); +} + +void S60AudioPlayerSession::doPlay() +{ +// For some reason loading progress callbalck are not called on emulator +#ifdef __WINSCW__ + buffering(); +#endif + m_player->Play(); +#ifdef __WINSCW__ + buffered(); +#endif + +} + +void S60AudioPlayerSession::doPauseL() +{ + m_player->Pause(); +} + +void S60AudioPlayerSession::doStop() +{ + m_player->Stop(); +} + +void S60AudioPlayerSession::doSetVolumeL(int volume) +{ + m_player->SetVolume((volume / 100.0) * m_player->MaxVolume()); +} + +void S60AudioPlayerSession::doSetPositionL(qint64 microSeconds) +{ + m_player->SetPosition(TTimeIntervalMicroSeconds(microSeconds)); +} + +void S60AudioPlayerSession::updateMetaDataEntriesL() +{ + metaDataEntries().clear(); + int numberOfMetaDataEntries = 0; + + m_player->GetNumberOfMetaDataEntries(numberOfMetaDataEntries); + + for (int i = 0; i < numberOfMetaDataEntries; i++) { + CMMFMetaDataEntry *entry = NULL; + entry = m_player->GetMetaDataEntryL(i); + metaDataEntries().insert(QString::fromUtf16(entry->Name().Ptr(), entry->Name().Length()), QString::fromUtf16(entry->Value().Ptr(), entry->Value().Length())); + delete entry; + } + emit metaDataChanged(); +} + +int S60AudioPlayerSession::doGetBufferStatusL() const +{ + int progress = 0; + m_player->GetAudioLoadingProgressL(progress); + return progress; +} + +void S60AudioPlayerSession::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration) +{ + Q_UNUSED(aDuration); + setError(aError); + TRAPD(err, + m_audioOutput = CAudioOutput::NewL(*m_player); + m_audioOutput->RegisterObserverL(*this); + ); + setActiveEndpoint(m_audioEndpoint); + setError(err); + loaded(); +} + +void S60AudioPlayerSession::MapcPlayComplete(TInt aError) +{ + setError(aError); + endOfMedia(); +} + +void S60AudioPlayerSession::doSetAudioEndpoint(const QString& audioEndpoint) +{ + m_audioEndpoint = audioEndpoint; +} + +QString S60AudioPlayerSession::activeEndpoint() const +{ + QString outputName = QString("Default"); +#if !defined(HAS_NO_AUDIOROUTING) + if (m_audioOutput) { + CAudioOutput::TAudioOutputPreference output = m_audioOutput->AudioOutput(); + outputName = qStringFromTAudioOutputPreference(output); + } +#endif + return outputName; +} + +QString S60AudioPlayerSession::defaultEndpoint() const +{ + QString outputName = QString("Default"); +#if !defined(HAS_NO_AUDIOROUTING) + if (m_audioOutput) { + CAudioOutput::TAudioOutputPreference output = m_audioOutput->DefaultAudioOutput(); + outputName = qStringFromTAudioOutputPreference(output); + } +#endif + return outputName; +} + +void S60AudioPlayerSession::setActiveEndpoint(const QString& name) +{ + CAudioOutput::TAudioOutputPreference output = CAudioOutput::ENoPreference; + + if (name == QString("Default")) + output = CAudioOutput::ENoPreference; + else if (name == QString("All")) + output = CAudioOutput::EAll; + else if (name == QString("None")) + output = CAudioOutput::ENoOutput; + else if (name == QString("Earphone")) + output = CAudioOutput::EPrivate; + else if (name == QString("Speaker")) + output = CAudioOutput::EPublic; +#if !defined(HAS_NO_AUDIOROUTING) + if (m_audioOutput) { + TRAPD(err, m_audioOutput->SetAudioOutputL(output)); + setError(err); + + if (m_audioEndpoint != name) { + m_audioEndpoint = name; + emit activeEndpointChanged(name); + } + } +#endif +} + +void S60AudioPlayerSession::DefaultAudioOutputChanged(CAudioOutput& aAudioOutput, + CAudioOutput::TAudioOutputPreference aNewDefault) +{ + // Emit already implemented in setActiveEndpoint function + Q_UNUSED(aAudioOutput) + Q_UNUSED(aNewDefault) +} + +QString S60AudioPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const +{ + if (output == CAudioOutput::ENoPreference) + return QString("Default"); + else if (output == CAudioOutput::EAll) + return QString("All"); + else if (output == CAudioOutput::ENoOutput) + return QString("None"); + else if (output == CAudioOutput::EPrivate) + return QString("Earphone"); + else if (output == CAudioOutput::EPublic) + return QString("Speaker"); + return QString("Default"); +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.h b/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.h new file mode 100644 index 0000000..fca66b3 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60audioplayersession.h @@ -0,0 +1,116 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60AUDIOPLAYERSESSION_H +#define S60AUDIOPLAYERSESSION_H + +#include "s60mediaplayersession.h" + +#include <mdaaudiosampleplayer.h> +typedef CMdaAudioPlayerUtility CAudioPlayer; +typedef MMdaAudioPlayerCallback MAudioPlayerObserver; + +#include <AudioOutput.h> +#include <MAudioOutputObserver.h> + +QT_BEGIN_NAMESPACE + +class S60AudioPlayerSession : public S60MediaPlayerSession + , public MAudioPlayerObserver + , public MAudioLoadingObserver + , public MAudioOutputObserver +{ + Q_OBJECT + +public: + S60AudioPlayerSession(QObject *parent); + ~S60AudioPlayerSession(); + + //From S60MediaPlayerSession + bool isVideoAvailable() const; + bool isAudioAvailable() const; + + // From MAudioLoadingObserver + void MaloLoadingStarted(); + void MaloLoadingComplete(); + + // From MAudioOutputObserver + void DefaultAudioOutputChanged( CAudioOutput& aAudioOutput, + CAudioOutput::TAudioOutputPreference aNewDefault ); + +public: + // From S60MediaPlayerAudioEndpointSelector + QString activeEndpoint() const; + QString defaultEndpoint() const; +public Q_SLOTS: + void setActiveEndpoint(const QString& name); +Q_SIGNALS: + void activeEndpointChanged(const QString & name); + +protected: + //From S60MediaPlayerSession + void doLoadL(const TDesC &path); + void doLoadUrlL(const TDesC &path){Q_UNUSED(path)/*empty implementation*/} + void doPlay(); + void doStop(); + void doPauseL(); + void doSetVolumeL(int volume); + qint64 doGetPositionL() const; + void doSetPositionL(qint64 microSeconds); + void updateMetaDataEntriesL(); + int doGetBufferStatusL() const; + qint64 doGetDurationL() const; + void doSetAudioEndpoint(const QString& audioEndpoint); + +private: + void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration); + void MapcPlayComplete(TInt aError); + QString qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const; + +private: + CAudioPlayer *m_player; + CAudioOutput *m_audioOutput; + QString m_audioEndpoint; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.cpp new file mode 100644 index 0000000..e80c487 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.cpp @@ -0,0 +1,185 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60mediametadataprovider.h" +#include "s60mediaplayersession.h" +#include <QtCore/qdebug.h> + +QT_BEGIN_NAMESPACE + +S60MediaMetaDataProvider::S60MediaMetaDataProvider(MS60MediaPlayerResolver& mediaPlayerResolver, QObject *parent) + : QMetaDataControl(parent) + , m_mediaPlayerResolver(mediaPlayerResolver) + , m_session(NULL) +{ +} + +S60MediaMetaDataProvider::~S60MediaMetaDataProvider() +{ +} + +bool S60MediaMetaDataProvider::isMetaDataAvailable() const +{ + m_session = m_mediaPlayerResolver.PlayerSession(); + if (m_session) + return m_session->isMetadataAvailable(); + return false; +} + +bool S60MediaMetaDataProvider::isWritable() const +{ + return false; +} + +QVariant S60MediaMetaDataProvider::metaData(QtMediaServices::MetaData key) const +{ + m_session = m_mediaPlayerResolver.PlayerSession(); + if (m_session && m_session->isMetadataAvailable()) + return m_session->metaData(metaDataKeyAsString(key)); + return QVariant(); +} + +void S60MediaMetaDataProvider::setMetaData(QtMediaServices::MetaData key, QVariant const &value) +{ + Q_UNUSED(key); + Q_UNUSED(value); +} +QList<QtMediaServices::MetaData> S60MediaMetaDataProvider::availableMetaData() const +{ + m_session = m_mediaPlayerResolver.PlayerSession(); + QList<QtMediaServices::MetaData> metaDataTags; + if (m_session && m_session->isMetadataAvailable()) { + for (int i = QtMediaServices::Title; i <= QtMediaServices::DeviceSettingDescription; i++) { + QString metaData = metaDataKeyAsString((QtMediaServices::MetaData)i); + if (!metaData.isEmpty()) { + if (!m_session->metaData(metaData).toString().isEmpty()) { + metaDataTags.append((QtMediaServices::MetaData)i); + } + } + } + } + return metaDataTags; +} + +QVariant S60MediaMetaDataProvider::extendedMetaData(const QString &key) const +{ + m_session = m_mediaPlayerResolver.PlayerSession(); + if (m_session && m_session->isMetadataAvailable()) + return m_session->metaData(key); + return QVariant(); +} + +void S60MediaMetaDataProvider::setExtendedMetaData(const QString &key, QVariant const &value) +{ + Q_UNUSED(key); + Q_UNUSED(value); +} + +QStringList S60MediaMetaDataProvider::availableExtendedMetaData() const +{ + m_session = m_mediaPlayerResolver.PlayerSession(); + if (m_session && m_session->isMetadataAvailable()) + return m_session->availableMetaData().keys(); + return QStringList(); +} + +QString S60MediaMetaDataProvider::metaDataKeyAsString(QtMediaServices::MetaData key) const +{ + switch(key) { + case QtMediaServices::Title: return "title"; + case QtMediaServices::AlbumArtist: return "artist"; + case QtMediaServices::Comment: return "comment"; + case QtMediaServices::Genre: return "genre"; + case QtMediaServices::Year: return "year"; + case QtMediaServices::Copyright: return "copyright"; + case QtMediaServices::AlbumTitle: return "album"; + case QtMediaServices::Composer: return "composer"; + case QtMediaServices::TrackNumber: return "albumtrack"; + case QtMediaServices::AudioBitRate: return "audiobitrate"; + case QtMediaServices::VideoBitRate: return "videobitrate"; + case QtMediaServices::Duration: return "duration"; + case QtMediaServices::MediaType: return "contenttype"; + case QtMediaServices::SubTitle: // TODO: Find the matching metadata keys + case QtMediaServices::Description: + case QtMediaServices::Category: + case QtMediaServices::Date: + case QtMediaServices::UserRating: + case QtMediaServices::Keywords: + case QtMediaServices::Language: + case QtMediaServices::Publisher: + case QtMediaServices::ParentalRating: + case QtMediaServices::RatingOrganisation: + case QtMediaServices::Size: + case QtMediaServices::AudioCodec: + case QtMediaServices::AverageLevel: + case QtMediaServices::ChannelCount: + case QtMediaServices::PeakValue: + case QtMediaServices::SampleRate: + case QtMediaServices::Author: + case QtMediaServices::ContributingArtist: + case QtMediaServices::Conductor: + case QtMediaServices::Lyrics: + case QtMediaServices::Mood: + case QtMediaServices::TrackCount: + case QtMediaServices::CoverArtUrlSmall: + case QtMediaServices::CoverArtUrlLarge: + case QtMediaServices::Resolution: + case QtMediaServices::PixelAspectRatio: + case QtMediaServices::VideoFrameRate: + case QtMediaServices::VideoCodec: + case QtMediaServices::PosterUrl: + case QtMediaServices::ChapterNumber: + case QtMediaServices::Director: + case QtMediaServices::LeadPerformer: + case QtMediaServices::Writer: + case QtMediaServices::CameraManufacturer: + case QtMediaServices::CameraModel: + case QtMediaServices::Event: + case QtMediaServices::Subject: + default: + break; + } + + return QString(); +} + +QT_END_NAMESPACE + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.h new file mode 100644 index 0000000..07ae494 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediametadataprovider.h @@ -0,0 +1,81 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60MEDIAMETADATAPROVIDER_H +#define S60MEDIAMETADATAPROVIDER_H + +#include <qmetadatacontrol.h> +#include "ms60mediaplayerresolver.h" + +QT_BEGIN_NAMESPACE + +class S60MediaPlayerSession; + +class S60MediaMetaDataProvider : public QMetaDataControl +{ + Q_OBJECT + +public: + S60MediaMetaDataProvider(MS60MediaPlayerResolver& mediaPlayerResolver, QObject *parent = 0); + ~S60MediaMetaDataProvider(); + + bool isMetaDataAvailable() const; + bool isWritable() const; + + QVariant metaData(QtMediaServices::MetaData key) const; + void setMetaData(QtMediaServices::MetaData key, const QVariant &value); + QList<QtMediaServices::MetaData> availableMetaData() const; + + QVariant extendedMetaData(const QString &key) const ; + void setExtendedMetaData(const QString &key, const QVariant &value); + QStringList availableExtendedMetaData() const; + +private: + QString metaDataKeyAsString(QtMediaServices::MetaData key) const; + +private: + MS60MediaPlayerResolver& m_mediaPlayerResolver; + mutable S60MediaPlayerSession *m_session; +}; + +QT_END_NAMESPACE + +#endif // S60VIDEOMETADATAPROVIDER_H diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.cpp new file mode 100644 index 0000000..dbeed90 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.cpp @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60mediaplayercontrol.h" +#include "s60mediaplayersession.h" +#include "s60mediaplayeraudioendpointselector.h" + +#include <QtGui/QIcon> +#include <QtCore/QDebug> + +QT_BEGIN_NAMESPACE + +S60MediaPlayerAudioEndpointSelector::S60MediaPlayerAudioEndpointSelector(QObject *control, QObject *parent) + :QMediaControl(parent) + , m_control(0) + , m_audioEndpointNames(0) +{ + m_control = qobject_cast<S60MediaPlayerControl*>(control); +} + +S60MediaPlayerAudioEndpointSelector::~S60MediaPlayerAudioEndpointSelector() +{ + delete m_audioEndpointNames; +} + +QList<QString> S60MediaPlayerAudioEndpointSelector::availableEndpoints() const +{ + if(m_audioEndpointNames->count() == 0) { + m_audioEndpointNames->append("Default"); + m_audioEndpointNames->append("All"); + m_audioEndpointNames->append("None"); + m_audioEndpointNames->append("Earphone"); + m_audioEndpointNames->append("Speaker"); + } + return *m_audioEndpointNames; +} + +QString S60MediaPlayerAudioEndpointSelector::endpointDescription(const QString& name) const +{ + if (name == QString("Default")) //ENoPreference + return QString("Used to indicate that the playing audio can be routed to" + "any speaker. This is the default value for audio."); + else if (name == QString("All")) //EAll + return QString("Used to indicate that the playing audio should be routed to all speakers."); + else if (name == QString("None")) //ENoOutput + return QString("Used to indicate that the playing audio should not be routed to any output."); + else if (name == QString("Earphone")) //EPrivate + return QString("Used to indicate that the playing audio should be routed to" + "the default private speaker. A private speaker is one that can only" + "be heard by one person."); + else if (name == QString("Speaker")) //EPublic + return QString("Used to indicate that the playing audio should be routed to" + "the default public speaker. A public speaker is one that can " + "be heard by multiple people."); + + return QString(); +} + +QString S60MediaPlayerAudioEndpointSelector::activeEndpoint() const +{ + if (m_control->session()) + return m_control->session()->activeEndpoint(); + else + return m_control->mediaControlSettings().audioEndpoint(); +} + +QString S60MediaPlayerAudioEndpointSelector::defaultEndpoint() const +{ + if (m_control->session()) + return m_control->session()->defaultEndpoint(); + else + return m_control->mediaControlSettings().audioEndpoint(); +} + +void S60MediaPlayerAudioEndpointSelector::setActiveEndpoint(const QString& name) +{ + QString oldEndpoint = m_control->mediaControlSettings().audioEndpoint(); + + if (name != oldEndpoint && (name == QString("Default") || name == QString("All") || + name == QString("None") || name == QString("Earphone") || name == QString("Speaker"))) { + + if (m_control->session()) { + m_control->session()->setActiveEndpoint(name); + } + m_control->setAudioEndpoint(name); + } +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.h new file mode 100644 index 0000000..a110ae8 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayeraudioendpointselector.h @@ -0,0 +1,81 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60MEDIAPLAYERAUDIOENDPOINTSELECTOR_H +#define S60MEDIAPLAYERAUDIOENDPOINTSELECTOR_H + +#include <QStringList> + +#include <QtMediaServices/qmediacontrol.h> + +QT_BEGIN_NAMESPACE + +class S60MediaPlayerControl; +class S60MediaPlayerSession; + +class S60MediaPlayerAudioEndpointSelector : public QMediaControl +{ + +Q_OBJECT + +public: + S60MediaPlayerAudioEndpointSelector(QObject *control, QObject *parent = 0); + ~S60MediaPlayerAudioEndpointSelector(); + + QList<QString> availableEndpoints() const ; + QString endpointDescription(const QString& name) const; + QString defaultEndpoint() const; + QString activeEndpoint() const; + +public Q_SLOTS: + void setActiveEndpoint(const QString& name); + +private: + S60MediaPlayerControl* m_control; + QString m_audioInput; + QList<QString> *m_audioEndpointNames; +}; + +#define QAudioEndpointSelector_iid "com.nokia.Qt.QAudioEndpointSelector/1.0" + +QT_END_NAMESPACE + +#endif // S60MEDIAPLAYERAUDIOENDPOINTSELECTOR_H diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.cpp new file mode 100644 index 0000000..8e03afd --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.cpp @@ -0,0 +1,274 @@ + +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60mediaplayercontrol.h" +#include "s60mediaplayersession.h" + +#include <QtCore/qdir.h> +#include <QtCore/qurl.h> +#include <QtCore/qdebug.h> + +QT_BEGIN_NAMESPACE + +S60MediaPlayerControl::S60MediaPlayerControl(MS60MediaPlayerResolver& mediaPlayerResolver, QObject *parent) + : QMediaPlayerControl(parent), + m_mediaPlayerResolver(mediaPlayerResolver), + m_session(NULL), + m_stream(NULL) +{ +} + +S60MediaPlayerControl::~S60MediaPlayerControl() +{ +} + +qint64 S60MediaPlayerControl::position() const +{ + if (m_session) + return m_session->position(); + return 0; +} + +qint64 S60MediaPlayerControl::duration() const +{ + if (m_session) + return m_session->duration(); + return -1; +} + +QMediaPlayer::State S60MediaPlayerControl::state() const +{ + if (m_session) + return m_session->state(); + return QMediaPlayer::StoppedState; +} + +QMediaPlayer::MediaStatus S60MediaPlayerControl::mediaStatus() const +{ + if (m_session) + return m_session->mediaStatus(); + return m_mediaSettings.mediaStatus(); +} + +int S60MediaPlayerControl::bufferStatus() const +{ + if (m_session) + return m_session->bufferStatus(); + return 0; +} + +int S60MediaPlayerControl::volume() const +{ + if (m_session) + return m_session->volume(); + return m_mediaSettings.volume(); +} + +bool S60MediaPlayerControl::isMuted() const +{ + if (m_session) + return m_session->isMuted(); + return m_mediaSettings.isMuted(); +} + +bool S60MediaPlayerControl::isSeekable() const +{ + if (m_session) + return m_session->isSeekable(); + return false; +} + +QMediaTimeRange S60MediaPlayerControl::availablePlaybackRanges() const +{ + QMediaTimeRange ranges; + + if(m_session && m_session->isSeekable()) + ranges.addInterval(0, m_session->duration()); + + return ranges; +} + +qreal S60MediaPlayerControl::playbackRate() const +{ + //None of symbian players supports this. + return m_mediaSettings.playbackRate(); +} + +void S60MediaPlayerControl::setPlaybackRate(qreal rate) +{ + //None of symbian players supports this. + m_mediaSettings.setPlaybackRate(rate); + emit playbackRateChanged(playbackRate()); + +} + +void S60MediaPlayerControl::setPosition(qint64 pos) +{ + if (m_session) + m_session->setPosition(pos); +} + +void S60MediaPlayerControl::play() +{ + if (m_session) + m_session->play(); +} + +void S60MediaPlayerControl::pause() +{ + if (m_session) + m_session->pause(); +} + +void S60MediaPlayerControl::stop() +{ + if (m_session) + m_session->stop(); +} + +void S60MediaPlayerControl::setVolume(int volume) +{ + int boundVolume = qBound(0, volume, 100); + if (boundVolume == m_mediaSettings.volume()) + return; + + m_mediaSettings.setVolume(boundVolume); + if (m_session) + m_session->setVolume(boundVolume); + + emit volumeChanged(boundVolume); +} + +void S60MediaPlayerControl::setMuted(bool muted) +{ + if (m_mediaSettings.isMuted() == muted) + return; + + m_mediaSettings.setMuted(muted); + if (m_session) + m_session->setMuted(muted); + + emit mutedChanged(muted); +} + +QMediaContent S60MediaPlayerControl::media() const +{ + return m_currentResource; +} + +const QIODevice *S60MediaPlayerControl::mediaStream() const +{ + return m_stream; +} + +void S60MediaPlayerControl::setMedia(const QMediaContent &source, QIODevice *stream) +{ + Q_UNUSED(stream) + // we don't want to set & load media again when it is already loaded + if (m_session && m_currentResource == source) + return; + + // store to variable as session is created based on the content type. + m_currentResource = source; + S60MediaPlayerSession *newSession = m_mediaPlayerResolver.PlayerSession(); + m_mediaSettings.setMediaStatus(QMediaPlayer::UnknownMediaStatus); + + if (m_session) + m_session->reset(); + else { + emit mediaStatusChanged(QMediaPlayer::UnknownMediaStatus); + emit error(QMediaPlayer::NoError, QString()); + } + + m_session = newSession; + + if (m_session) + m_session->load(source.canonicalUrl()); + else { + QMediaPlayer::MediaStatus status = (source.isNull()) ? QMediaPlayer::NoMedia : QMediaPlayer::InvalidMedia; + m_mediaSettings.setMediaStatus(status); + emit stateChanged(QMediaPlayer::StoppedState); + emit error((source.isNull()) ? QMediaPlayer::NoError : QMediaPlayer::ResourceError, + (source.isNull()) ? "" : tr("Media couldn't be resolved")); + emit mediaStatusChanged(status); + } + emit mediaChanged(m_currentResource); + } + +S60MediaPlayerSession* S60MediaPlayerControl::session() +{ + return m_session; +} + +void S60MediaPlayerControl::setVideoOutput(QObject *output) +{ + S60MediaPlayerSession *session = NULL; + session = m_mediaPlayerResolver.VideoPlayerSession(); + session->setVideoRenderer(output); +} + +bool S60MediaPlayerControl::isAudioAvailable() const +{ + if (m_session) + return m_session->isAudioAvailable(); + return false; +} + +bool S60MediaPlayerControl::isVideoAvailable() const +{ + if (m_session) + return m_session->isVideoAvailable(); + return false; +} + +const S60MediaSettings& S60MediaPlayerControl::mediaControlSettings() const +{ + return m_mediaSettings; +} + +void S60MediaPlayerControl::setAudioEndpoint(const QString& name) +{ + m_mediaSettings.setAudioEndpoint(name); +} + +QT_END_NAMESPACE + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.h new file mode 100644 index 0000000..3d26a5e --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayercontrol.h @@ -0,0 +1,143 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60MEDIAPLAYERCONTROL_H +#define S60MEDIAPLAYERCONTROL_H + +#include <QtCore/qobject.h> + +#include <qmediaplayercontrol.h> + +#include "ms60mediaplayerresolver.h" +#include <QtCore/qdebug.h> + +QT_BEGIN_NAMESPACE + +class QMediaPlayer; +class QMediaTimeRange; +class QMediaContent; + + +class S60MediaPlayerSession; +class S60MediaPlayerService; + +class S60MediaSettings +{ + +public: + S60MediaSettings() + : m_volume(0) + , m_muted(false) + , m_playbackRate(0) + , m_mediaStatus(QMediaPlayer::UnknownMediaStatus) + , m_audioEndpoint(QString("Default")) + { + } + + void setVolume(int volume) { m_volume = volume; } + void setMuted(bool muted) { m_muted = muted; } + void setPlaybackRate(int rate) { m_playbackRate = rate; } + void setMediaStatus(QMediaPlayer::MediaStatus status) {m_mediaStatus=status;} + void setAudioEndpoint(const QString& audioEndpoint) { m_audioEndpoint = audioEndpoint; } + + int volume() const { return m_volume; } + bool isMuted() const { return m_muted; } + qreal playbackRate() const { return m_playbackRate; } + QMediaPlayer::MediaStatus mediaStatus() const {return m_mediaStatus;} + QString audioEndpoint() const { return m_audioEndpoint; } + +private: + int m_volume; + bool m_muted; + qreal m_playbackRate; + QMediaPlayer::MediaStatus m_mediaStatus; + QString m_audioEndpoint; +}; + +class S60MediaPlayerControl : public QMediaPlayerControl +{ + Q_OBJECT + +public: + S60MediaPlayerControl(MS60MediaPlayerResolver& mediaPlayerResolver, QObject *parent = 0); + ~S60MediaPlayerControl(); + + // from QMediaPlayerControl + virtual QMediaPlayer::State state() const; + virtual QMediaPlayer::MediaStatus mediaStatus() const; + virtual qint64 duration() const; + virtual qint64 position() const; + virtual void setPosition(qint64 pos); + virtual int volume() const; + virtual void setVolume(int volume); + virtual bool isMuted() const; + virtual void setMuted(bool muted); + virtual int bufferStatus() const; + virtual bool isAudioAvailable() const; + virtual bool isVideoAvailable() const; + virtual bool isSeekable() const; + virtual QMediaTimeRange availablePlaybackRanges() const; + virtual qreal playbackRate() const; + virtual void setPlaybackRate(qreal rate); + virtual QMediaContent media() const; + virtual const QIODevice *mediaStream() const; + virtual void setMedia(const QMediaContent&, QIODevice *); + virtual void play(); + virtual void pause(); + virtual void stop(); + S60MediaPlayerSession* session(); + void setAudioEndpoint(const QString& name); + + // Own methods + void setVideoOutput(QObject *output); + const S60MediaSettings& mediaControlSettings() const; + +private: + MS60MediaPlayerResolver &m_mediaPlayerResolver; + S60MediaPlayerSession *m_session; + QMediaContent m_currentResource; + QIODevice *m_stream; + S60MediaSettings m_mediaSettings; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.cpp new file mode 100644 index 0000000..0b1c7d5 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.cpp @@ -0,0 +1,259 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60mediaplayerservice.h" +#include "s60mediaplayercontrol.h" +#include "s60videoplayersession.h" +#include "s60audioplayersession.h" +#include "s60mediametadataprovider.h" +#include "s60videowidget.h" +#include "s60mediarecognizer.h" +//#include <qmediatimerange.h> +#include "s60videooverlay.h" +#include "s60videorenderer.h" +#include "s60mediaplayeraudioendpointselector.h" + +#include <qmediaplaylistnavigator.h> +#include <qmediaplaylist.h> + +QT_BEGIN_NAMESPACE + +S60MediaPlayerService::S60MediaPlayerService(QObject *parent) + : QMediaService(parent) + , m_control(NULL) + , m_videoOutput(NULL) + , m_videoPlayerSession(NULL) + , m_audioPlayerSession(NULL) + , m_metaData(NULL) + , m_videoWidget(NULL) + , m_videoWindow(NULL) + , m_videoRenderer(NULL) + , m_audioEndpointSelector(NULL) +{ + m_control = new S60MediaPlayerControl(*this, this); + m_metaData = new S60MediaMetaDataProvider(*this); + m_audioEndpointSelector = new S60MediaPlayerAudioEndpointSelector(m_control, this); +} + +S60MediaPlayerService::~S60MediaPlayerService() +{ + delete m_videoWidget; + delete m_videoRenderer; + delete m_videoWindow; + delete m_videoOutput; +} + +QMediaControl *S60MediaPlayerService::control(const char *name) const +{ + if (qstrcmp(name, QMediaPlayerControl_iid) == 0) + return m_control; + + if (qstrcmp(name, QMetaDataControl_iid) == 0) { + return m_metaData; + } + + if (qstrcmp(name, QVideoOutputControl_iid) == 0) { + if (!m_videoOutput) { + m_videoOutput = new S60VideoOutputControl; + connect(m_videoOutput, SIGNAL(outputChanged(QVideoOutputControl::Output)), + this, SLOT(videoOutputChanged(QVideoOutputControl::Output))); + m_videoOutput->setAvailableOutputs(QList<QVideoOutputControl::Output>() +// << QVideoOutputControl::RendererOutput +// << QVideoOutputControl::WindowOutput + << QVideoOutputControl::WidgetOutput); + + } + return m_videoOutput; + } + + if (qstrcmp(name, QVideoWidgetControl_iid) == 0) { + if (!m_videoWidget) + m_videoWidget = new S60VideoWidgetControl; + return m_videoWidget; + } + + if (qstrcmp(name, QVideoRendererControl_iid) == 0) { + if (m_videoRenderer) + m_videoRenderer = new S60VideoRenderer; + return m_videoRenderer; + } + + if (qstrcmp(name, QVideoWindowControl_iid) == 0) { + if (!m_videoWindow) + m_videoWindow = new S60VideoOverlay; + return m_videoWindow; + } + + if (qstrcmp(name, QAudioEndpointSelector_iid) == 0) { + return m_audioEndpointSelector; + } + + return 0; + +} + +void S60MediaPlayerService::videoOutputChanged(QVideoOutputControl::Output output) +{ + switch (output) { + case QVideoOutputControl::NoOutput: + m_control->setVideoOutput(0); + break; + + case QVideoOutputControl::RendererOutput: + m_control->setVideoOutput(m_videoRenderer); + break; + case QVideoOutputControl::WindowOutput: + m_control->setVideoOutput(m_videoWindow); + break; + + case QVideoOutputControl::WidgetOutput: + m_control->setVideoOutput(m_videoWidget); + break; + default: + qWarning("Invalid video output selection"); + break; + } +} + +S60MediaPlayerSession* S60MediaPlayerService::PlayerSession() +{ + QUrl url = m_control->media().canonicalUrl(); + + if (url.isEmpty() == true) { + return NULL; + } + + S60MediaRecognizer *m_mediaRecognizer = new S60MediaRecognizer(this); + S60MediaRecognizer::MediaType mediaType = m_mediaRecognizer->mediaType(url); + + switch (mediaType) { + case S60MediaRecognizer::Video: + case S60MediaRecognizer::Url: + return VideoPlayerSession(); + case S60MediaRecognizer::Audio: + return AudioPlayerSession(); + default: + break; + } + + return NULL; +} + +S60MediaPlayerSession* S60MediaPlayerService::VideoPlayerSession() +{ + if (!m_videoPlayerSession) { + m_videoPlayerSession = new S60VideoPlayerSession(this); + + connect(m_videoPlayerSession, SIGNAL(positionChanged(qint64)), + m_control, SIGNAL(positionChanged(qint64))); + connect(m_videoPlayerSession, SIGNAL(durationChanged(qint64)), + m_control, SIGNAL(durationChanged(qint64))); + connect(m_videoPlayerSession, SIGNAL(stateChanged(QMediaPlayer::State)), + m_control, SIGNAL(stateChanged(QMediaPlayer::State))); + connect(m_videoPlayerSession, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)), + m_control, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus))); + connect(m_videoPlayerSession,SIGNAL(bufferStatusChanged(int)), + m_control, SIGNAL(bufferStatusChanged(int))); + connect(m_videoPlayerSession, SIGNAL(videoAvailableChanged(bool)), + m_control, SIGNAL(videoAvailableChanged(bool))); + connect(m_videoPlayerSession, SIGNAL(audioAvailableChanged(bool)), + m_control, SIGNAL(audioAvailableChanged(bool))); + connect(m_videoPlayerSession, SIGNAL(seekableChanged(bool)), + m_control, SIGNAL(seekableChanged(bool))); + connect(m_videoPlayerSession, SIGNAL(availablePlaybackRangesChanged(const QMediaTimeRange&)), + m_control, SIGNAL(availablePlaybackRangesChanged(const QMediaTimeRange&))); + connect(m_videoPlayerSession, SIGNAL(error(int, const QString &)), + m_control, SIGNAL(error(int, const QString &))); + connect(m_videoPlayerSession, SIGNAL(metaDataChanged()), + m_metaData, SIGNAL(metaDataChanged())); + connect(m_videoPlayerSession, SIGNAL(activeEndpointChanged(const QString&)), + m_audioEndpointSelector, SIGNAL(activeEndpointChanged(const QString&))); + } + + m_videoPlayerSession->setVolume(m_control->mediaControlSettings().volume()); + m_videoPlayerSession->setMuted(m_control->mediaControlSettings().isMuted()); + m_videoPlayerSession->setAudioEndpoint(m_control->mediaControlSettings().audioEndpoint()); + return m_videoPlayerSession; +} + +S60MediaPlayerSession* S60MediaPlayerService::AudioPlayerSession() +{ + if (!m_audioPlayerSession) { + m_audioPlayerSession = new S60AudioPlayerSession(this); + + connect(m_audioPlayerSession, SIGNAL(positionChanged(qint64)), + m_control, SIGNAL(positionChanged(qint64))); + connect(m_audioPlayerSession, SIGNAL(durationChanged(qint64)), + m_control, SIGNAL(durationChanged(qint64))); + connect(m_audioPlayerSession, SIGNAL(stateChanged(QMediaPlayer::State)), + m_control, SIGNAL(stateChanged(QMediaPlayer::State))); + connect(m_audioPlayerSession, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)), + m_control, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus))); + connect(m_audioPlayerSession,SIGNAL(bufferStatusChanged(int)), + m_control, SIGNAL(bufferStatusChanged(int))); + connect(m_audioPlayerSession, SIGNAL(videoAvailableChanged(bool)), + m_control, SIGNAL(videoAvailableChanged(bool))); + connect(m_audioPlayerSession, SIGNAL(audioAvailableChanged(bool)), + m_control, SIGNAL(audioAvailableChanged(bool))); + connect(m_audioPlayerSession, SIGNAL(seekableChanged(bool)), + m_control, SIGNAL(seekableChanged(bool))); + connect(m_audioPlayerSession, SIGNAL(availablePlaybackRangesChanged(const QMediaTimeRange&)), + m_control, SIGNAL(availablePlaybackRangesChanged(const QMediaTimeRange&))); + connect(m_audioPlayerSession, SIGNAL(error(int, const QString &)), + m_control, SIGNAL(error(int, const QString &))); + connect(m_audioPlayerSession, SIGNAL(metaDataChanged()), + m_metaData, SIGNAL(metaDataChanged())); + connect(m_audioPlayerSession, SIGNAL(activeEndpointChanged(const QString&)), + m_audioEndpointSelector, SIGNAL(activeEndpointChanged(const QString&))); + } + + m_audioPlayerSession->setVolume(m_control->mediaControlSettings().volume()); + m_audioPlayerSession->setMuted(m_control->mediaControlSettings().isMuted()); + m_audioPlayerSession->setAudioEndpoint(m_control->mediaControlSettings().audioEndpoint()); + return m_audioPlayerSession; +} + +QT_END_NAMESPACE + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.h new file mode 100644 index 0000000..6c8155d --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayerservice.h @@ -0,0 +1,105 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOPLAYERSERVICE_H +#define S60VIDEOPLAYERSERVICE_H + +#include <QtCore/qobject.h> + +#include <qmediaservice.h> +#include <qvideooutputcontrol.h> + +#include "s60videooutputcontrol.h" +#include "ms60mediaplayerresolver.h" + +#include "s60mediaplayeraudioendpointselector.h" + +QT_BEGIN_NAMESPACE + +class QMediaMetaData; +class QMediaPlayerControl; +class QMediaPlaylist; + + +class S60VideoPlayerSession; +class S60AudioPlayerSession; +class S60MediaPlayerControl; +class S60MediaMetaDataProvider; +class S60VideoWidgetControl; +class S60MediaRecognizer; +class S60VideoRenderer; +class S60VideoOverlay; + +class QMediaPlaylistNavigator; + +class S60MediaPlayerService : public QMediaService, public MS60MediaPlayerResolver +{ + Q_OBJECT + +public: + S60MediaPlayerService(QObject *parent = 0); + ~S60MediaPlayerService(); + + QMediaControl *control(const char *name) const; + +private slots: + void videoOutputChanged(QVideoOutputControl::Output output); + +protected: // From MS60MediaPlayerResolver + S60MediaPlayerSession* PlayerSession(); + S60MediaPlayerSession* VideoPlayerSession(); + S60MediaPlayerSession* AudioPlayerSession(); + +private: + S60MediaPlayerControl *m_control; + mutable S60VideoOutputControl *m_videoOutput; + S60VideoPlayerSession *m_videoPlayerSession; + S60AudioPlayerSession *m_audioPlayerSession; + mutable S60MediaMetaDataProvider *m_metaData; + mutable S60VideoWidgetControl *m_videoWidget; + mutable S60VideoOverlay *m_videoWindow; + mutable S60VideoRenderer *m_videoRenderer; + S60MediaPlayerAudioEndpointSelector *m_audioEndpointSelector; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.cpp new file mode 100644 index 0000000..693c103 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.cpp @@ -0,0 +1,496 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60mediaplayersession.h" + +#include <QtCore/qdebug.h> +#include <QtCore/qdir.h> +#include <QtCore/qvariant.h> +#include <QtCore/qtimer.h> +#include <mmf/common/mmferrors.h> +#include <qmediatimerange.h> + +QT_BEGIN_NAMESPACE + +S60MediaPlayerSession::S60MediaPlayerSession(QObject *parent) + : QObject(parent) + , m_playbackRate(0) + , m_muted(false) + , m_volume(0) + , m_state(QMediaPlayer::StoppedState) + , m_mediaStatus(QMediaPlayer::UnknownMediaStatus) + , m_progressTimer(new QTimer(this)) + , m_stalledTimer(new QTimer(this)) + , m_error(KErrNone) + , m_play_requested(false) + , m_stream(false) +{ + connect(m_progressTimer, SIGNAL(timeout()), this, SLOT(tick())); + connect(m_stalledTimer, SIGNAL(timeout()), this, SLOT(stalled())); +} + +S60MediaPlayerSession::~S60MediaPlayerSession() +{ +} + +int S60MediaPlayerSession::volume() const +{ + return m_volume; +} + +void S60MediaPlayerSession::setVolume(int volume) +{ + if (m_volume == volume) + return; + + m_volume = volume; + // Dont set symbian players volume until media loaded. + // Leaves with KerrNotReady although documentation says otherwise. + if (!m_muted && + ( mediaStatus() == QMediaPlayer::LoadedMedia + || mediaStatus() == QMediaPlayer::StalledMedia + || mediaStatus() == QMediaPlayer::BufferingMedia + || mediaStatus() == QMediaPlayer::BufferedMedia + || mediaStatus() == QMediaPlayer::EndOfMedia)) { + TRAPD(err, doSetVolumeL(m_volume)); + setError(err); + } +} + +bool S60MediaPlayerSession::isMuted() const +{ + return m_muted; +} + +bool S60MediaPlayerSession::isSeekable() const +{ + return (m_stream)?false:true; +} + +void S60MediaPlayerSession::setMediaStatus(QMediaPlayer::MediaStatus status) +{ + if (m_mediaStatus == status) + return; + + m_mediaStatus = status; + + emit mediaStatusChanged(m_mediaStatus); + + if (m_play_requested) + play(); +} + +void S60MediaPlayerSession::setState(QMediaPlayer::State state) +{ + if (m_state == state) + return; + + m_state = state; + emit stateChanged(m_state); +} + +QMediaPlayer::State S60MediaPlayerSession::state() const +{ + return m_state; +} + +QMediaPlayer::MediaStatus S60MediaPlayerSession::mediaStatus() const +{ + return m_mediaStatus; +} + +void S60MediaPlayerSession::load(QUrl url) +{ + setMediaStatus(QMediaPlayer::LoadingMedia); + startStalledTimer(); + m_stream = (url.scheme() == "file")?false:true; + TRAPD(err, + if(m_stream) + doLoadUrlL(QString2TPtrC(url.toString())); + else + doLoadL(QString2TPtrC(QDir::toNativeSeparators(url.toLocalFile())))); + setError(err); +} + +void S60MediaPlayerSession::play() +{ + if (state() == QMediaPlayer::PlayingState + || mediaStatus() == QMediaPlayer::UnknownMediaStatus + || mediaStatus() == QMediaPlayer::NoMedia + || mediaStatus() == QMediaPlayer::InvalidMedia) + return; + + if (mediaStatus() == QMediaPlayer::LoadingMedia) { + m_play_requested = true; + return; + } + + m_play_requested = false; + setState(QMediaPlayer::PlayingState); + startProgressTimer(); + doPlay(); +} + +void S60MediaPlayerSession::pause() +{ + if (mediaStatus() == QMediaPlayer::NoMedia || + mediaStatus() == QMediaPlayer::InvalidMedia) + return; + + setState(QMediaPlayer::PausedState); + stopProgressTimer(); + TRAP_IGNORE(doPauseL()); +} + +void S60MediaPlayerSession::stop() +{ + m_play_requested = false; + setState(QMediaPlayer::StoppedState); + if (mediaStatus() == QMediaPlayer::BufferingMedia || + mediaStatus() == QMediaPlayer::BufferedMedia) + setMediaStatus(QMediaPlayer::LoadedMedia); + if (mediaStatus() == QMediaPlayer::LoadingMedia) + setMediaStatus(QMediaPlayer::UnknownMediaStatus); + stopProgressTimer(); + stopStalledTimer(); + doStop(); + emit positionChanged(0); +} +void S60MediaPlayerSession::reset() +{ + m_play_requested = false; + setError(KErrNone, QString(), true); + stopProgressTimer(); + stopStalledTimer(); + doStop(); + setState(QMediaPlayer::StoppedState); + setMediaStatus(QMediaPlayer::UnknownMediaStatus); +} + +void S60MediaPlayerSession::setVideoRenderer(QObject *renderer) +{ + Q_UNUSED(renderer); +} + +int S60MediaPlayerSession::bufferStatus() +{ + if( mediaStatus() == QMediaPlayer::LoadingMedia + || mediaStatus() == QMediaPlayer::UnknownMediaStatus + || mediaStatus() == QMediaPlayer::NoMedia + || mediaStatus() == QMediaPlayer::InvalidMedia) + return 0; + + int progress = 0; + TRAPD(err, progress = doGetBufferStatusL()); + + // If buffer status query not supported by codec return 100 + // do not set error + if(err == KErrNotSupported) + return 100; + + setError(err); + return progress; +} + +bool S60MediaPlayerSession::isMetadataAvailable() const +{ + return !m_metaDataMap.isEmpty(); +} + +QVariant S60MediaPlayerSession::metaData(const QString &key) const +{ + return m_metaDataMap.value(key); +} + +QMap<QString, QVariant> S60MediaPlayerSession::availableMetaData() const +{ + return m_metaDataMap; +} + +void S60MediaPlayerSession::setMuted(bool muted) +{ + m_muted = muted; + + if( m_mediaStatus == QMediaPlayer::LoadedMedia + || m_mediaStatus == QMediaPlayer::StalledMedia + || m_mediaStatus == QMediaPlayer::BufferingMedia + || m_mediaStatus == QMediaPlayer::BufferedMedia + || m_mediaStatus == QMediaPlayer::EndOfMedia) { + TRAPD(err, doSetVolumeL((m_muted)?0:m_volume)); + setError(err); + } +} + +qint64 S60MediaPlayerSession::duration() const +{ + if( mediaStatus() == QMediaPlayer::LoadingMedia + || mediaStatus() == QMediaPlayer::UnknownMediaStatus + || mediaStatus() == QMediaPlayer::NoMedia + || mediaStatus() == QMediaPlayer::InvalidMedia) + return -1; + + qint64 pos = 0; + TRAP_IGNORE(pos = doGetDurationL()); + return pos; +} + +qint64 S60MediaPlayerSession::position() const +{ + if( mediaStatus() == QMediaPlayer::LoadingMedia + || mediaStatus() == QMediaPlayer::UnknownMediaStatus + || mediaStatus() == QMediaPlayer::NoMedia + || mediaStatus() == QMediaPlayer::InvalidMedia) + return 0; + + qint64 pos = 0; + TRAP_IGNORE(pos = doGetPositionL()); + return pos; +} + +void S60MediaPlayerSession::setPosition(qint64 pos) +{ + if (position() == pos) + return; + + if (state() == QMediaPlayer::PlayingState) + pause(); + + TRAPD(err, doSetPositionL(pos * 1000)); + setError(err); + + if (state() == QMediaPlayer::PausedState) + play(); + + emit positionChanged(position()); +} + +void S60MediaPlayerSession::setAudioEndpoint(const QString& audioEndpoint) +{ + doSetAudioEndpoint(audioEndpoint); +} + +void S60MediaPlayerSession::loaded() +{ + stopStalledTimer(); + if (m_error == KErrNone || m_error == KErrMMPartialPlayback) { + setMediaStatus(QMediaPlayer::LoadedMedia); + TRAPD(err, updateMetaDataEntriesL()); + setError(err); + setVolume(m_volume); + setMuted(m_muted); + emit durationChanged(duration()); + emit videoAvailableChanged(isVideoAvailable()); + emit audioAvailableChanged(isAudioAvailable()); + } +} + +void S60MediaPlayerSession::endOfMedia() +{ + setMediaStatus(QMediaPlayer::EndOfMedia); + setState(QMediaPlayer::StoppedState); + emit positionChanged(0); +} + +void S60MediaPlayerSession::buffering() +{ + startStalledTimer(); + setMediaStatus(QMediaPlayer::BufferingMedia); +} + +void S60MediaPlayerSession::buffered() +{ + stopStalledTimer(); + setMediaStatus(QMediaPlayer::BufferedMedia); +} +void S60MediaPlayerSession::stalled() +{ + setMediaStatus(QMediaPlayer::StalledMedia); +} + +QMap<QString, QVariant>& S60MediaPlayerSession::metaDataEntries() +{ + return m_metaDataMap; +} + +QMediaPlayer::Error S60MediaPlayerSession::fromSymbianErrorToMultimediaError(int error) +{ + switch(error) { + case KErrNoMemory: + case KErrNotFound: + case KErrBadHandle: + case KErrAbort: + case KErrNotSupported: + case KErrCorrupt: + case KErrGeneral: + case KErrArgument: + case KErrPathNotFound: + case KErrDied: + case KErrServerTerminated: + case KErrServerBusy: + case KErrCompletion: + case KErrBadPower: + return QMediaPlayer::ResourceError; + + case KErrMMPartialPlayback: + return QMediaPlayer::FormatError; + + case KErrMMAudioDevice: + case KErrMMVideoDevice: + case KErrMMDecoder: + case KErrUnknown: + return QMediaPlayer::ServiceMissingError; + + case KErrMMNotEnoughBandwidth: + case KErrMMSocketServiceNotFound: + case KErrMMNetworkRead: + case KErrMMNetworkWrite: + case KErrMMServerSocket: + case KErrMMServerNotSupported: + case KErrMMUDPReceive: + case KErrMMInvalidProtocol: + case KErrMMInvalidURL: + case KErrMMMulticast: + case KErrMMProxyServer: + case KErrMMProxyServerNotSupported: + case KErrMMProxyServerConnect: + return QMediaPlayer::NetworkError; + + case KErrNotReady: + case KErrInUse: + case KErrAccessDenied: + case KErrLocked: + case KErrMMDRMNotAuthorized: + case KErrPermissionDenied: + case KErrCancel: + case KErrAlreadyExists: + return QMediaPlayer::AccessDeniedError; + + case KErrNone: + default: + return QMediaPlayer::NoError; + } +} + +void S60MediaPlayerSession::setError(int error, const QString &errorString, bool forceReset) +{ + if( forceReset ) { + m_error = KErrNone; + emit this->error(QMediaPlayer::NoError, QString()); + return; + } + + // If error does not change and m_error is reseted without forceReset flag + if (error == m_error || + (m_error != KErrNone && error == KErrNone)) + return; + + m_error = error; + QMediaPlayer::Error mediaError = fromSymbianErrorToMultimediaError(m_error); + QString symbianError = QString(errorString); + + if (mediaError != QMediaPlayer::NoError) { + // TODO: fix to user friendly string at some point + // These error string are only dev usable + symbianError.append("Symbian:"); + symbianError.append(QString::number(m_error)); + } + + emit this->error(mediaError, symbianError); + + switch(mediaError){ + case QMediaPlayer::ResourceError: + case QMediaPlayer::NetworkError: + case QMediaPlayer::AccessDeniedError: + case QMediaPlayer::ServiceMissingError: + m_play_requested = false; + setMediaStatus(QMediaPlayer::InvalidMedia); + stop(); + break; + } +} + +void S60MediaPlayerSession::tick() +{ + emit positionChanged(position()); + + if (bufferStatus() < 100) + emit bufferStatusChanged(bufferStatus()); +} + +void S60MediaPlayerSession::startProgressTimer() +{ + m_progressTimer->start(500); +} + +void S60MediaPlayerSession::stopProgressTimer() +{ + m_progressTimer->stop(); +} + +void S60MediaPlayerSession::startStalledTimer() +{ + m_stalledTimer->start(30000); +} + +void S60MediaPlayerSession::stopStalledTimer() +{ + m_stalledTimer->stop(); +} +QString S60MediaPlayerSession::TDesC2QString(const TDesC& aDescriptor) +{ + return QString::fromUtf16(aDescriptor.Ptr(), aDescriptor.Length()); +} +TPtrC S60MediaPlayerSession::QString2TPtrC( const QString& string ) +{ + // Returned TPtrC is valid as long as the given parameter is valid and unmodified + return TPtrC16(static_cast<const TUint16*>(string.utf16()), string.length()); +} +QRect S60MediaPlayerSession::TRect2QRect(const TRect& tr) +{ + return QRect(tr.iTl.iX, tr.iTl.iY, tr.Width(), tr.Height()); +} +TRect S60MediaPlayerSession::QRect2TRect(const QRect& qr) +{ + return TRect(TPoint(qr.left(), qr.top()), TSize(qr.width(), qr.height())); +} + +QT_END_NAMESPACE + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.h new file mode 100644 index 0000000..bb9eddd --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediaplayersession.h @@ -0,0 +1,167 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60MEDIAPLAYERSESSION_H +#define S60MEDIAPLAYERSESSION_H + +#include <QtCore/qobject.h> +#include <QtCore/qurl.h> +#include <QtCore/qpair.h> +#include <qmediaplayer.h> +#include <e32cmn.h> // for TDesC +#include <QRect> +#include "s60mediaplayerservice.h" + +QT_BEGIN_NAMESPACE + +class QMediaTimeRange; + +class QTimer; + +class S60MediaPlayerSession : public QObject +{ + Q_OBJECT + +public: + S60MediaPlayerSession(QObject *parent); + virtual ~S60MediaPlayerSession(); + + // for player control interface to use + QMediaPlayer::State state() const; + QMediaPlayer::MediaStatus mediaStatus() const; + qint64 duration() const; + qint64 position() const; + void setPosition(qint64 pos); + int volume() const; + void setVolume(int volume); + bool isMuted() const; + void setMuted(bool muted); + virtual bool isVideoAvailable() const = 0; + virtual bool isAudioAvailable() const = 0; + bool isSeekable() const; + void play(); + void pause(); + void stop(); + void reset(); + bool isMetadataAvailable() const; + QVariant metaData(const QString &key) const; + QMap<QString, QVariant> availableMetaData() const; + void load(QUrl url); + int bufferStatus(); + virtual void setVideoRenderer(QObject *renderer); + void setMediaStatus(QMediaPlayer::MediaStatus); + void setState(QMediaPlayer::State state); + void setAudioEndpoint(const QString& audioEndpoint); + +protected: + virtual void doLoadL(const TDesC &path) = 0; + virtual void doLoadUrlL(const TDesC &path) = 0; + virtual void doPlay() = 0; + virtual void doStop() = 0; + virtual void doPauseL() = 0; + virtual void doSetVolumeL(int volume) = 0; + virtual void doSetPositionL(qint64 microSeconds) = 0; + virtual qint64 doGetPositionL() const = 0; + virtual void updateMetaDataEntriesL() = 0; + virtual int doGetBufferStatusL() const = 0; + virtual qint64 doGetDurationL() const = 0; + virtual void doSetAudioEndpoint(const QString& audioEndpoint) = 0; + +public: + // From S60MediaPlayerAudioEndpointSelector + virtual QString activeEndpoint() const = 0; + virtual QString defaultEndpoint() const = 0; +public Q_SLOTS: + virtual void setActiveEndpoint(const QString& name) = 0; + +protected: + void setError(int error, const QString &errorString = QString(), bool forceReset = false); + void loaded(); + void buffering(); + void buffered(); + void endOfMedia(); + QMap<QString, QVariant>& metaDataEntries(); + QMediaPlayer::Error fromSymbianErrorToMultimediaError(int error); + void startProgressTimer(); + void stopProgressTimer(); + void startStalledTimer(); + void stopStalledTimer(); + QString TDesC2QString(const TDesC& aDescriptor); + TPtrC QString2TPtrC( const QString& string ); + QRect TRect2QRect(const TRect& tr); + TRect QRect2TRect(const QRect& qr); + + +protected slots: + void tick(); + void stalled(); + +signals: + void durationChanged(qint64 duration); + void positionChanged(qint64 position); + void stateChanged(QMediaPlayer::State state); + void mediaStatusChanged(QMediaPlayer::MediaStatus mediaStatus); + void videoAvailableChanged(bool videoAvailable); + void audioAvailableChanged(bool audioAvailable); + void bufferStatusChanged(int percentFilled); + void seekableChanged(bool); + void availablePlaybackRangesChanged(const QMediaTimeRange&); + void metaDataChanged(); + void error(int error, const QString &errorString); + void activeEndpointChanged(const QString &name); + +private: + qreal m_playbackRate; + QMap<QString, QVariant> m_metaDataMap; + bool m_muted; + int m_volume; + QMediaPlayer::State m_state; + QMediaPlayer::MediaStatus m_mediaStatus; + QTimer *m_progressTimer; + QTimer *m_stalledTimer; + int m_error; + bool m_play_requested; + bool m_stream; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.cpp new file mode 100644 index 0000000..b563dd9 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.cpp @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "S60mediarecognizer.h" +#include <e32def.h> +#include <e32cmn.h> +#include <QtCore/qurl.h> +#include <QtCore/qdir.h> +#include <QtCore/qdebug.h> + +#include <apgcli.h> + +QT_BEGIN_NAMESPACE + +static const TInt KMimeTypePrefixLength = 6; // "audio/" or "video/" +_LIT(KMimeTypePrefixAudio, "audio/"); +_LIT(KMimeTypePrefixVideo, "video/"); + +S60MediaRecognizer::S60MediaRecognizer(QObject *parent) : QObject(parent) +{ +} + +S60MediaRecognizer::~S60MediaRecognizer() +{ + m_file.Close(); + m_fileServer.Close(); + m_recognizer.Close(); +} + +S60MediaRecognizer::MediaType S60MediaRecognizer::mediaType(const QUrl &url) +{ + bool isStream = (url.scheme() == "file")?false:true; + + if (isStream) + return Url; + else + return identifyMediaType(url.toLocalFile()); +} + +S60MediaRecognizer::MediaType S60MediaRecognizer::identifyMediaType(const QString& fileName) +{ + S60MediaRecognizer::MediaType result = NotSupported; + bool recognizerOpened = false; + + TInt err = m_recognizer.Connect(); + if (err == KErrNone) { + recognizerOpened = true; + } + + err = m_fileServer.Connect(); + if (err == KErrNone) { + recognizerOpened = true; + } + + // This is needed for sharing file handles for the recognizer + err = m_fileServer.ShareProtected(); + if (err == KErrNone) { + recognizerOpened = true; + } + + if (recognizerOpened) { + m_file.Close(); + err = m_file.Open(m_fileServer, QString2TPtrC(QDir::toNativeSeparators(fileName)), EFileRead | + EFileShareReadersOnly); + + if (err == KErrNone) { + TDataRecognitionResult recognizerResult; + err = m_recognizer.RecognizeData(m_file, recognizerResult); + if (err == KErrNone) { + const TPtrC mimeType = recognizerResult.iDataType.Des(); + + if (mimeType.Left(KMimeTypePrefixLength).Compare(KMimeTypePrefixAudio) == 0) { + result = Audio; + } else if (mimeType.Left(KMimeTypePrefixLength).Compare(KMimeTypePrefixVideo) == 0) { + result = Video; + } + } + } + } + return result; +} + +TPtrC S60MediaRecognizer::QString2TPtrC( const QString& string ) +{ + // Returned TPtrC is valid as long as the given parameter is valid and unmodified + return TPtrC16(static_cast<const TUint16*>(string.utf16()), string.length()); +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.h b/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.h new file mode 100644 index 0000000..320c34c --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60mediarecognizer.h @@ -0,0 +1,83 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60MEDIARECOGNIZER_H_ +#define S60MEDIARECOGNIZER_H_ + +#include <QtCore/qobject.h> + +#include <apgcli.h> +#include <f32file.h> + +QT_BEGIN_NAMESPACE + +class QUrl; + +class S60MediaRecognizer : public QObject +{ + Q_OBJECT + +public: + enum MediaType { + Audio, + Video, + Url, + NotSupported = -1 + }; + + S60MediaRecognizer(QObject *parent = 0); + ~S60MediaRecognizer(); + + S60MediaRecognizer::MediaType mediaType(const QUrl &url); + S60MediaRecognizer::MediaType identifyMediaType(const QString& fileName); + +protected: + TPtrC QString2TPtrC( const QString& string ); + +private: + RApaLsSession m_recognizer; + RFile m_file; + RFs m_fileServer; +}; + +QT_END_NAMESPACE + +#endif /* S60MEDIARECOGNIZER_H_ */ diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.cpp new file mode 100644 index 0000000..489b2e3 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.cpp @@ -0,0 +1,209 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 <QtMultimedia/qvideosurfaceformat.h> +#include "s60videooverlay.h" +#include "s60videosurface.h" + +QT_BEGIN_NAMESPACE + +S60VideoOverlay::S60VideoOverlay(QObject *parent) + : QVideoWindowControl(parent) + , m_surface(new S60VideoSurface) + , m_aspectRatioMode(Qt::KeepAspectRatio) + , m_fullScreen(false) +{ + connect(m_surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)), + this, SLOT(surfaceFormatChanged())); +} + +S60VideoOverlay::~S60VideoOverlay() +{ + delete m_surface; +} + +WId S60VideoOverlay::winId() const +{ + return m_surface->winId(); +} + +void S60VideoOverlay::setWinId(WId id) +{ + m_surface->setWinId(id); +} + +QRect S60VideoOverlay::displayRect() const +{ + return m_displayRect; +} + +void S60VideoOverlay::setDisplayRect(const QRect &rect) +{ + m_displayRect = rect; + + setScaledDisplayRect(); +} + +Qt::AspectRatioMode S60VideoOverlay::aspectRatioMode() const +{ + return m_aspectRatioMode; +} + +void S60VideoOverlay::setAspectRatioMode(Qt::AspectRatioMode ratio) +{ + m_aspectRatioMode = ratio; + + setScaledDisplayRect(); +} + +QSize S60VideoOverlay::customAspectRatio() const +{ + return m_aspectRatio; +} + +void S60VideoOverlay::setCustomAspectRatio(const QSize &customRatio) +{ + m_aspectRatio = customRatio; + + setScaledDisplayRect(); +} + +void S60VideoOverlay::repaint() +{ +} + +int S60VideoOverlay::brightness() const +{ + return m_surface->brightness(); +} + +void S60VideoOverlay::setBrightness(int brightness) +{ + m_surface->setBrightness(brightness); + + emit brightnessChanged(m_surface->brightness()); +} + +int S60VideoOverlay::contrast() const +{ + return m_surface->contrast(); +} + +void S60VideoOverlay::setContrast(int contrast) +{ + m_surface->setContrast(contrast); + + emit contrastChanged(m_surface->contrast()); +} + +int S60VideoOverlay::hue() const +{ + return m_surface->hue(); +} + +void S60VideoOverlay::setHue(int hue) +{ + m_surface->setHue(hue); + + emit hueChanged(m_surface->hue()); +} + +int S60VideoOverlay::saturation() const +{ + return m_surface->saturation(); +} + +void S60VideoOverlay::setSaturation(int saturation) +{ + m_surface->setSaturation(saturation); + + emit saturationChanged(m_surface->saturation()); +} + +bool S60VideoOverlay::isFullScreen() const +{ + return m_fullScreen; +} + +void S60VideoOverlay::setFullScreen(bool fullScreen) +{ + emit fullScreenChanged(m_fullScreen = fullScreen); +} + +QSize S60VideoOverlay::nativeSize() const +{ + return m_surface->surfaceFormat().sizeHint(); +} + +QAbstractVideoSurface *S60VideoOverlay::surface() const +{ + return m_surface; +} + +void S60VideoOverlay::surfaceFormatChanged() +{ + setScaledDisplayRect(); + + emit nativeSizeChanged(); +} + +void S60VideoOverlay::setScaledDisplayRect() +{ + switch (m_aspectRatioMode) { + case Qt::KeepAspectRatio: + { + QSize size = m_surface->surfaceFormat().viewport().size(); + + size.scale(m_displayRect.size(), Qt::KeepAspectRatio); + + QRect rect(QPoint(0, 0), size); + rect.moveCenter(m_displayRect.center()); + + m_surface->setDisplayRect(rect); + } + break; + case Qt::IgnoreAspectRatio: + m_surface->setDisplayRect(m_displayRect); + break; + }; +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.h b/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.h new file mode 100644 index 0000000..d846f32 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videooverlay.h @@ -0,0 +1,109 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOOVERLAY_H +#define S60VIDEOOVERLAY_H + +#include <QtCore/qobject.h> +#include <qvideowindowcontrol.h> + +QT_BEGIN_NAMESPACE + +class QAbstractVideoSurface; +class S60VideoSurface; + +class S60VideoOverlay : public QVideoWindowControl +{ + Q_OBJECT + +public: + S60VideoOverlay(QObject *parent = 0); + ~S60VideoOverlay(); + + WId winId() const; + void setWinId(WId id); + + QRect displayRect() const; + void setDisplayRect(const QRect &rect); + + bool isFullScreen() const; + void setFullScreen(bool fullScreen); + + QSize nativeSize() const; + + Qt::AspectRatioMode aspectRatioMode() const; + void setAspectRatioMode(Qt::AspectRatioMode mode); + + QSize customAspectRatio() const; + void setCustomAspectRatio(const QSize &customRatio); + + void repaint(); + + 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); + + QAbstractVideoSurface *surface() const; + +private slots: + void surfaceFormatChanged(); + +private: + void setScaledDisplayRect(); + + S60VideoSurface *m_surface; + Qt::AspectRatioMode m_aspectRatioMode; + QRect m_displayRect; + QSize m_aspectRatio; + bool m_fullScreen; +}; + +QT_END_NAMESPACE + +#endif // S60VIDEOOVERLAY_H diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.cpp new file mode 100644 index 0000000..134d5a0 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.cpp @@ -0,0 +1,486 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60videoplayersession.h" +#include "s60videowidget.h" +#include "s60mediaplayerservice.h" +#include "s60videooverlay.h" + +#include <QtCore/qdebug.h> +#include <QtGui/qwidget.h> +#include <QtCore/qtimer.h> +#include <QApplication> + +#include <coecntrl.h> +#include <coemain.h> // For CCoeEnv +#include <w32std.h> +#include <mmf/common/mmfcontrollerframeworkbase.h> + +#include <AudioOutput.h> +#include <MAudioOutputObserver.h> + +QT_BEGIN_NAMESPACE + +S60VideoPlayerSession::S60VideoPlayerSession(QMediaService *service) + : S60MediaPlayerSession(service) + , m_player(0) + , m_rect(0, 0, 0, 0) + , m_output(QVideoOutputControl::NoOutput) + , m_windowId(0) + , m_dsaActive(false) + , m_dsaStopped(false) + , m_wsSession(CCoeEnv::Static()->WsSession()) + , m_screenDevice(*CCoeEnv::Static()->ScreenDevice()) + , m_window(0) + , m_service(*service) + , m_aspectRatioMode(Qt::KeepAspectRatio) + , m_originalSize(1, 1) + , m_audioOutput(0) + , m_audioEndpoint("Default") +{ + resetNativeHandles(); + QT_TRAP_THROWING(m_player = CVideoPlayerUtility::NewL( + *this, + 0, + EMdaPriorityPreferenceNone, + m_wsSession, + m_screenDevice, + *m_window, + m_rect, + m_rect)); + m_dsaActive = true; + m_player->RegisterForVideoLoadingNotification(*this); +} + +S60VideoPlayerSession::~S60VideoPlayerSession() +{ +#if !defined(HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER) + if (m_audioOutput) + m_audioOutput->UnregisterObserver(*this); + delete m_audioOutput; +#endif + m_player->Close(); + delete m_player; +} + +void S60VideoPlayerSession::doLoadL(const TDesC &path) +{ + // m_audioOutput needs to be reinitialized after MapcInitComplete + if (m_audioOutput) + m_audioOutput->UnregisterObserver(*this); + delete m_audioOutput; + m_audioOutput = NULL; + + m_player->OpenFileL(path); +} + +void S60VideoPlayerSession::doLoadUrlL(const TDesC &path) +{ + // m_audioOutput needs to be reinitialized after MapcInitComplete + if (m_audioOutput) + m_audioOutput->UnregisterObserver(*this); + delete m_audioOutput; + m_audioOutput = NULL; + + m_player->OpenUrlL(path); +} + +int S60VideoPlayerSession::doGetBufferStatusL() const +{ + int progress = 0; + m_player->GetVideoLoadingProgressL(progress); + return progress; +} + +qint64 S60VideoPlayerSession::doGetDurationL() const +{ + return m_player->DurationL().Int64() / qint64(1000); +} + +void S60VideoPlayerSession::setVideoRenderer(QObject *videoOutput) +{ + Q_UNUSED(videoOutput) + QVideoOutputControl *videoControl = qobject_cast<QVideoOutputControl *>(m_service.control(QVideoOutputControl_iid)); + + //Render changes + if (m_output != videoControl->output()) { + + if (m_output == QVideoOutputControl::WidgetOutput) { + S60VideoWidgetControl *widgetControl = qobject_cast<S60VideoWidgetControl *>(m_service.control(QVideoWidgetControl_iid)); + disconnect(widgetControl, SIGNAL(widgetUpdated()), this, SLOT(resetVideoDisplay())); + disconnect(widgetControl, SIGNAL(beginVideoWindowNativePaint()), this, SLOT(suspendDirectScreenAccess())); + disconnect(widgetControl, SIGNAL(endVideoWindowNativePaint()), this, SLOT(resumeDirectScreenAccess())); + disconnect(this, SIGNAL(stateChanged(QMediaPlayer::State)), widgetControl, SLOT(videoStateChanged(QMediaPlayer::State))); + } + + if (videoControl->output() == QVideoOutputControl::WidgetOutput) { + S60VideoWidgetControl *widgetControl = qobject_cast<S60VideoWidgetControl *>(m_service.control(QVideoWidgetControl_iid)); + connect(widgetControl, SIGNAL(widgetUpdated()), this, SLOT(resetVideoDisplay())); + connect(widgetControl, SIGNAL(beginVideoWindowNativePaint()), this, SLOT(suspendDirectScreenAccess())); + connect(widgetControl, SIGNAL(endVideoWindowNativePaint()), this, SLOT(resumeDirectScreenAccess())); + connect(this, SIGNAL(stateChanged(QMediaPlayer::State)), widgetControl, SLOT(videoStateChanged(QMediaPlayer::State))); + } + + m_output = videoControl->output(); + resetVideoDisplay(); + } +} + +bool S60VideoPlayerSession::resetNativeHandles() +{ + QVideoOutputControl* videoControl = qobject_cast<QVideoOutputControl *>(m_service.control(QVideoOutputControl_iid)); + WId newId = 0; + TRect newRect = TRect(0,0,0,0); + Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio; + + if (videoControl->output() == QVideoOutputControl::WidgetOutput) { + S60VideoWidgetControl* widgetControl = qobject_cast<S60VideoWidgetControl *>(m_service.control(QVideoWidgetControl_iid)); + QWidget *videoWidget = widgetControl->videoWidget(); + newId = widgetControl->videoWidgetWId(); + newRect = QRect2TRect(QRect(videoWidget->mapToGlobal(videoWidget->pos()), videoWidget->size())); + aspectRatioMode = widgetControl->aspectRatioMode(); + } else if (videoControl->output() == QVideoOutputControl::WindowOutput) { + S60VideoOverlay* windowControl = qobject_cast<S60VideoOverlay *>(m_service.control(QVideoWindowControl_iid)); + newId = windowControl->winId(); + newRect = TRect( newId->DrawableWindow()->AbsPosition(), newId->DrawableWindow()->Size()); + } else { + if (QApplication::activeWindow()) + newId = QApplication::activeWindow()->effectiveWinId(); + + if (!newId && QApplication::allWidgets().count()) + newId = QApplication::allWidgets().at(0)->effectiveWinId(); + + Q_ASSERT(newId != 0); + } + + if (newRect == m_rect && newId == m_windowId && aspectRatioMode == m_aspectRatioMode) + return false; + + if (newId) { + m_rect = newRect; + m_windowId = newId; + m_window = m_windowId->DrawableWindow(); + m_aspectRatioMode = aspectRatioMode; + return true; + } + return false; +} + +bool S60VideoPlayerSession::isVideoAvailable() const +{ +#ifdef PRE_S60_50_PLATFORM + return true; // this is not support in pre 5th platforms +#else + if (m_player) + return m_player->VideoEnabledL(); + else + return false; +#endif +} + +bool S60VideoPlayerSession::isAudioAvailable() const +{ + if (m_player) + return m_player->AudioEnabledL(); + else + return false; +} + +void S60VideoPlayerSession::doPlay() +{ + m_player->Play(); +} + +void S60VideoPlayerSession::doPauseL() +{ + m_player->PauseL(); +} + +void S60VideoPlayerSession::doStop() +{ + m_player->Stop(); +} + +qint64 S60VideoPlayerSession::doGetPositionL() const +{ + return m_player->PositionL().Int64() / qint64(1000); +} + +void S60VideoPlayerSession::doSetPositionL(qint64 microSeconds) +{ + m_player->SetPositionL(TTimeIntervalMicroSeconds(microSeconds)); +} + +void S60VideoPlayerSession::doSetVolumeL(int volume) +{ + m_player->SetVolumeL((volume / 100.0)* m_player->MaxVolume()); +} + +QPair<qreal, qreal> S60VideoPlayerSession::scaleFactor() +{ + QSize scaled = m_originalSize; + if (m_aspectRatioMode == Qt::IgnoreAspectRatio) + scaled.scale(TRect2QRect(m_rect).size(), Qt::IgnoreAspectRatio); + else if(m_aspectRatioMode == Qt::KeepAspectRatio) + scaled.scale(TRect2QRect(m_rect).size(), Qt::KeepAspectRatio); + + qreal width = qreal(scaled.width()) / qreal(m_originalSize.width()) * qreal(100); + qreal height = qreal(scaled.height()) / qreal(m_originalSize.height()) * qreal(100); + + return QPair<qreal, qreal>(width, height); +} + +void S60VideoPlayerSession::startDirectScreenAccess() +{ + if(m_dsaActive) + return; + + TRAPD(err, m_player->StartDirectScreenAccessL()); + if(err == KErrNone) + m_dsaActive = true; + setError(err); +} + +bool S60VideoPlayerSession::stopDirectScreenAccess() +{ + if(!m_dsaActive) + return false; + + TRAPD(err, m_player->StopDirectScreenAccessL()); + if(err == KErrNone) + m_dsaActive = false; + + setError(err); + return true; +} + +void S60VideoPlayerSession::MvpuoOpenComplete(TInt aError) +{ + setError(aError); + m_player->Prepare(); +} + +void S60VideoPlayerSession::MvpuoPrepareComplete(TInt aError) +{ + setError(aError); + TRAPD(err, + m_player->SetDisplayWindowL(m_wsSession, + m_screenDevice, + *m_window, + m_rect, + m_rect); + TSize originalSize; + m_player->VideoFrameSizeL(originalSize); + m_originalSize = QSize(originalSize.iWidth, originalSize.iHeight); + m_player->SetScaleFactorL(scaleFactor().first, scaleFactor().second, true)); + + setError(err); + m_dsaActive = true; +#if !defined(HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER) + TRAP(err, + m_audioOutput = CAudioOutput::NewL(*m_player); + m_audioOutput->RegisterObserverL(*this); + ); + setActiveEndpoint(m_audioEndpoint); + setError(err); +#endif + loaded(); +} + +void S60VideoPlayerSession::MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError) +{ + Q_UNUSED(aFrame); + Q_UNUSED(aError); +} + +void S60VideoPlayerSession::MvpuoPlayComplete(TInt aError) +{ + setError(aError); + endOfMedia(); +} + +void S60VideoPlayerSession::MvpuoEvent(const TMMFEvent &aEvent) +{ + Q_UNUSED(aEvent); +} + +void S60VideoPlayerSession::updateMetaDataEntriesL() +{ + metaDataEntries().clear(); + int numberOfMetaDataEntries = 0; + + numberOfMetaDataEntries = m_player->NumberOfMetaDataEntriesL(); + + for (int i = 0; i < numberOfMetaDataEntries; i++) { + CMMFMetaDataEntry *entry = NULL; + entry = m_player->MetaDataEntryL(i); + metaDataEntries().insert(TDesC2QString(entry->Name()), TDesC2QString(entry->Value())); + delete entry; + } + emit metaDataChanged(); +} + +void S60VideoPlayerSession::resetVideoDisplay() +{ + if (resetNativeHandles()) { + TRAPD(err, + m_player->SetDisplayWindowL(m_wsSession, + m_screenDevice, + *m_window, + m_rect, + m_rect)); + setError(err); + if( mediaStatus() == QMediaPlayer::LoadedMedia + || mediaStatus() == QMediaPlayer::StalledMedia + || mediaStatus() == QMediaPlayer::BufferingMedia + || mediaStatus() == QMediaPlayer::BufferedMedia + || mediaStatus() == QMediaPlayer::EndOfMedia) { + TRAPD(err, m_player->SetScaleFactorL(scaleFactor().first, scaleFactor().second, true)); + setError(err); + } + } +} + +void S60VideoPlayerSession::suspendDirectScreenAccess() +{ + m_dsaStopped = stopDirectScreenAccess(); +} + +void S60VideoPlayerSession::resumeDirectScreenAccess() +{ + if(!m_dsaStopped) + return; + + startDirectScreenAccess(); + m_dsaStopped = false; +} + +void S60VideoPlayerSession::MvloLoadingStarted() +{ + buffering(); +} + +void S60VideoPlayerSession::MvloLoadingComplete() +{ + buffered(); +} + +void S60VideoPlayerSession::doSetAudioEndpoint(const QString& audioEndpoint) +{ + m_audioEndpoint = audioEndpoint; +} + +QString S60VideoPlayerSession::activeEndpoint() const +{ + QString outputName = QString("Default"); +#if !defined(HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER) + if (m_audioOutput) { + CAudioOutput::TAudioOutputPreference output = m_audioOutput->AudioOutput(); + outputName = qStringFromTAudioOutputPreference(output); + } +#endif + return outputName; +} + +QString S60VideoPlayerSession::defaultEndpoint() const +{ + QString outputName = QString("Default"); +#if !defined(HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER) + if (m_audioOutput) { + CAudioOutput::TAudioOutputPreference output = m_audioOutput->DefaultAudioOutput(); + outputName = qStringFromTAudioOutputPreference(output); + } +#endif + return outputName; +} + +void S60VideoPlayerSession::setActiveEndpoint(const QString& name) +{ + CAudioOutput::TAudioOutputPreference output = CAudioOutput::ENoPreference; + + if (name == QString("Default")) + output = CAudioOutput::ENoPreference; + else if (name == QString("All")) + output = CAudioOutput::EAll; + else if (name == QString("None")) + output = CAudioOutput::ENoOutput; + else if (name == QString("Earphone")) + output = CAudioOutput::EPrivate; + else if (name == QString("Speaker")) + output = CAudioOutput::EPublic; +#if !defined(HAS_NO_AUDIOROUTING_IN_VIDEOPLAYER) + if (m_audioOutput) { + TRAPD(err, m_audioOutput->SetAudioOutputL(output)); + setError(err); + + if (m_audioEndpoint != name) { + m_audioEndpoint = name; + emit activeEndpointChanged(name); + } + } +#endif +} + +void S60VideoPlayerSession::DefaultAudioOutputChanged( CAudioOutput& aAudioOutput, + CAudioOutput::TAudioOutputPreference aNewDefault ) +{ + // Emit already implemented in setActiveEndpoint function + Q_UNUSED(aAudioOutput) + Q_UNUSED(aNewDefault) +} + +QString S60VideoPlayerSession::qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const +{ + if (output == CAudioOutput::ENoPreference) + return QString("Default"); + else if (output == CAudioOutput::EAll) + return QString("All"); + else if (output == CAudioOutput::ENoOutput) + return QString("None"); + else if (output == CAudioOutput::EPrivate) + return QString("Earphone"); + else if (output == CAudioOutput::EPublic) + return QString("Speaker"); + return QString("Default"); +} + +QT_END_NAMESPACE + diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.h b/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.h new file mode 100644 index 0000000..52e311a --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videoplayersession.h @@ -0,0 +1,148 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOPLAYERSESSION_H +#define S60VIDEOPLAYERSESSION_H + +#include "s60mediaplayersession.h" +#include "s60mediaplayeraudioendpointselector.h" +#include <videoplayer.h> +#include <QtGui/qwidget.h> +#include <qvideowidget.h> + +#include <AudioOutput.h> +#include <MAudioOutputObserver.h> + +QT_BEGIN_NAMESPACE + +class QTimer; + +class S60VideoPlayerSession : public S60MediaPlayerSession, + public MVideoPlayerUtilityObserver, + public MVideoLoadingObserver, + public MAudioOutputObserver +{ + Q_OBJECT + +public: + S60VideoPlayerSession(QMediaService *service); + ~S60VideoPlayerSession(); + + //From S60MediaPlayerSession + bool isVideoAvailable() const; + bool isAudioAvailable() const; + void setVideoRenderer(QObject *renderer); + + //From MVideoLoadingObserver + void MvloLoadingStarted(); + void MvloLoadingComplete(); + + // From MAudioOutputObserver + void DefaultAudioOutputChanged(CAudioOutput& aAudioOutput, + CAudioOutput::TAudioOutputPreference aNewDefault); + +public: + // From S60MediaPlayerAudioEndpointSelector + QString activeEndpoint() const; + QString defaultEndpoint() const; +public Q_SLOTS: + void setActiveEndpoint(const QString& name); +Q_SIGNALS: + void activeEndpointChanged(const QString &name); + +protected: + //From S60MediaPlayerSession + void doLoadL(const TDesC &path); + void doLoadUrlL(const TDesC &path); + void doPlay(); + void doStop(); + void doPauseL(); + void doSetVolumeL(int volume); + qint64 doGetPositionL() const; + void doSetPositionL(qint64 microSeconds); + void updateMetaDataEntriesL(); + int doGetBufferStatusL() const; + qint64 doGetDurationL() const; + void doSetAudioEndpoint(const QString& audioEndpoint); + +private slots: + void resetVideoDisplay(); + void suspendDirectScreenAccess(); + void resumeDirectScreenAccess(); + +private: + bool resetNativeHandles(); + QPair<qreal, qreal> scaleFactor(); + void startDirectScreenAccess(); + bool stopDirectScreenAccess(); + QString qStringFromTAudioOutputPreference(CAudioOutput::TAudioOutputPreference output) const; + + + // From MVideoPlayerUtilityObserver + void MvpuoOpenComplete(TInt aError); + void MvpuoPrepareComplete(TInt aError); + void MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError); + void MvpuoPlayComplete(TInt aError); + void MvpuoEvent(const TMMFEvent &aEvent); + +private: + // Qwn + CVideoPlayerUtility *m_player; + TRect m_rect; + QVideoOutputControl::Output m_output; + WId m_windowId; + bool m_dsaActive; + bool m_dsaStopped; + + //Reference + RWsSession &m_wsSession; + CWsScreenDevice &m_screenDevice; + RWindowBase *m_window; + QMediaService &m_service; + Qt::AspectRatioMode m_aspectRatioMode; + QSize m_originalSize; + CAudioOutput *m_audioOutput; + QString m_audioEndpoint; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.cpp new file mode 100644 index 0000000..269dd43 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.cpp @@ -0,0 +1,69 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60videorenderer.h" + +#include <QtCore/qcoreevent.h> +#include <QtGui/qapplication.h> + +QT_BEGIN_NAMESPACE + +S60VideoRenderer::S60VideoRenderer(QObject *parent) + : QVideoRendererControl(parent) +{ +} + +S60VideoRenderer::~S60VideoRenderer() +{ +} + + +QAbstractVideoSurface *S60VideoRenderer::surface() const +{ + return m_surface; +} + +void S60VideoRenderer::setSurface(QAbstractVideoSurface *surface) +{ + m_surface = surface; +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.h b/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.h new file mode 100644 index 0000000..260dc8b --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videorenderer.h @@ -0,0 +1,68 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEORENDERER_H +#define S60VIDEORENDERER_H + +#include <QtCore/qobject.h> +#include <qvideorenderercontrol.h> + +QT_BEGIN_NAMESPACE + +class S60VideoRenderer : public QVideoRendererControl +{ + Q_OBJECT + +public: + S60VideoRenderer(QObject *parent = 0); + virtual ~S60VideoRenderer(); + + QAbstractVideoSurface *surface() const; + void setSurface(QAbstractVideoSurface *surface); + +private: + + QAbstractVideoSurface *m_surface; +}; + +QT_END_NAMESPACE + +#endif // S60VIDEORENDERER_H diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.cpp new file mode 100644 index 0000000..bfa7a13 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.cpp @@ -0,0 +1,478 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 <QtGui/qx11info_x11.h> + +#include "s60videosurface.h" + +QT_BEGIN_NAMESPACE + +/*struct XvFormatRgb +{ + QVideoFrame::PixelFormat pixelFormat; + int bits_per_pixel; + int format; + int num_planes; + + int depth; + unsigned int red_mask; + unsigned int green_mask; + unsigned int blue_mask; + +};*/ +/* +bool operator ==(const XvImageFormatValues &format, const XvFormatRgb &rgb) +{ + return format.type == XvRGB + && format.bits_per_pixel == rgb.bits_per_pixel + && format.format == rgb.format + && format.num_planes == rgb.num_planes + && format.depth == rgb.depth + && format.red_mask == rgb.red_mask + && format.blue_mask == rgb.blue_mask; +} + +static const XvFormatRgb qt_xvRgbLookup[] = +{ + { QVideoFrame::Format_ARGB32, 32, XvPacked, 1, 32, 0x00FF0000, 0x0000FF00, 0x000000FF }, + { QVideoFrame::Format_RGB32 , 32, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, + { QVideoFrame::Format_RGB24 , 24, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, + { QVideoFrame::Format_RGB565, 16, XvPacked, 1, 16, 0x0000F800, 0x000007E0, 0x0000001F }, + { QVideoFrame::Format_BGRA32, 32, XvPacked, 1, 32, 0xFF000000, 0x00FF0000, 0x0000FF00 }, + { QVideoFrame::Format_BGR32 , 32, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, + { QVideoFrame::Format_BGR24 , 24, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, + { QVideoFrame::Format_BGR565, 16, XvPacked, 1, 16, 0x0000F800, 0x000007E0, 0x0000001F } +}; + +struct XvFormatYuv +{ + QVideoFrame::PixelFormat pixelFormat; + int bits_per_pixel; + int format; + int num_planes; + + unsigned int y_sample_bits; + unsigned int u_sample_bits; + unsigned int v_sample_bits; + unsigned int horz_y_period; + unsigned int horz_u_period; + unsigned int horz_v_period; + unsigned int vert_y_period; + unsigned int vert_u_period; + unsigned int vert_v_period; + char component_order[32]; +}; + +bool operator ==(const XvImageFormatValues &format, const XvFormatYuv &yuv) +{ + return format.type == XvYUV + && format.bits_per_pixel == yuv.bits_per_pixel + && format.format == yuv.format + && format.num_planes == yuv.num_planes + && format.y_sample_bits == yuv.y_sample_bits + && format.u_sample_bits == yuv.u_sample_bits + && format.v_sample_bits == yuv.v_sample_bits + && format.horz_y_period == yuv.horz_y_period + && format.horz_u_period == yuv.horz_u_period + && format.horz_v_period == yuv.horz_v_period + && format.horz_y_period == yuv.vert_y_period + && format.vert_u_period == yuv.vert_u_period + && format.vert_v_period == yuv.vert_v_period + && qstrncmp(format.component_order, yuv.component_order, 32) == 0; +} + +static const XvFormatYuv qt_xvYuvLookup[] = +{ + { QVideoFrame::Format_YUV444 , 24, XvPacked, 1, 8, 8, 8, 1, 1, 1, 1, 1, 1, "YUV" }, + { QVideoFrame::Format_YUV420P, 12, XvPlanar, 3, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YUV" }, + { QVideoFrame::Format_YV12 , 12, XvPlanar, 3, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YVU" }, + { QVideoFrame::Format_UYVY , 16, XvPacked, 1, 8, 8, 8, 1, 2, 2, 1, 1, 1, "UYVY" }, + { QVideoFrame::Format_YUYV , 16, XvPacked, 1, 8, 8, 8, 1, 2, 2, 1, 1, 1, "YUYV" }, + { QVideoFrame::Format_NV12 , 12, XvPlanar, 2, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YUV" }, + { QVideoFrame::Format_NV12 , 12, XvPlanar, 2, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YVU" }, + { QVideoFrame::Format_Y8 , 8 , XvPlanar, 1, 8, 0, 0, 1, 0, 0, 1, 0, 0, "Y" } +}; +*/ + +S60VideoSurface::S60VideoSurface(QObject *parent) + : QAbstractVideoSurface(parent) + , m_winId(0) + //, m_portId(0) + //, m_gc(0) + //, m_image(0) +{ +} + +S60VideoSurface::~S60VideoSurface() +{ + /*if (m_gc) + XFreeGC(QX11Info::display(), m_gc); + + if (m_portId != 0) + XvUngrabPort(QX11Info::display(), m_portId, 0); + */ +} + +WId S60VideoSurface::winId() const +{ + return m_winId; +} + +void S60VideoSurface::setWinId(WId id) +{ + /*if (id == m_winId) + return; + + if (m_image) + XFree(m_image); + + if (m_gc) { + XFreeGC(QX11Info::display(), m_gc); + m_gc = 0; + } + + if (m_portId != 0) + XvUngrabPort(QX11Info::display(), m_portId, 0); + + m_supportedPixelFormats.clear(); + m_formatIds.clear(); + + m_winId = id; + + if (m_winId && findPort()) { + querySupportedFormats(); + + m_gc = XCreateGC(QX11Info::display(), m_winId, 0, 0); + + if (m_image) { + m_image = 0; + + if (!start(surfaceFormat())) + QAbstractVideoSurface::stop(); + } + } else if (m_image) { + m_image = 0; + + QAbstractVideoSurface::stop(); + }*/ +} + +QRect S60VideoSurface::displayRect() const +{ + return m_displayRect; +} + +void S60VideoSurface::setDisplayRect(const QRect &rect) +{ + m_displayRect = rect; +} + +int S60VideoSurface::brightness() const +{ + //return getAttribute("XV_BRIGHTNESS", m_brightnessRange.first, m_brightnessRange.second); +} + +void S60VideoSurface::setBrightness(int brightness) +{ + //setAttribute("XV_BRIGHTNESS", brightness, m_brightnessRange.first, m_brightnessRange.second); +} + +int S60VideoSurface::contrast() const +{ + //return getAttribute("XV_CONTRAST", m_contrastRange.first, m_contrastRange.second); +} + +void S60VideoSurface::setContrast(int contrast) +{ + //setAttribute("XV_CONTRAST", contrast, m_contrastRange.first, m_contrastRange.second); +} + +int S60VideoSurface::hue() const +{ + //return getAttribute("XV_HUE", m_hueRange.first, m_hueRange.second); +} + +void S60VideoSurface::setHue(int hue) +{ + // setAttribute("XV_HUE", hue, m_hueRange.first, m_hueRange.second); +} + +int S60VideoSurface::saturation() const +{ + //return getAttribute("XV_SATURATION", m_saturationRange.first, m_saturationRange.second); +} + +void S60VideoSurface::setSaturation(int saturation) +{ + //setAttribute("XV_SATURATION", saturation, m_saturationRange.first, m_saturationRange.second); +} + +int S60VideoSurface::getAttribute(const char *attribute, int minimum, int maximum) const +{ + /*if (m_portId != 0) { + Display *display = QX11Info::display(); + + Atom atom = XInternAtom(display, attribute, True); + + int value = 0; + + XvGetPortAttribute(display, m_portId, atom, &value); + + return redistribute(value, minimum, maximum, -100, 100); + } else { + return 0; + }*/ +} + +void S60VideoSurface::setAttribute(const char *attribute, int value, int minimum, int maximum) +{ + /* if (m_portId != 0) { + Display *display = QX11Info::display(); + + Atom atom = XInternAtom(display, attribute, True); + + XvSetPortAttribute( + display, m_portId, atom, redistribute(value, -100, 100, minimum, maximum)); + }*/ +} + +int S60VideoSurface::redistribute( + int value, int fromLower, int fromUpper, int toLower, int toUpper) +{ + /*return fromUpper != fromLower + ? ((value - fromLower) * (toUpper - toLower) / (fromUpper - fromLower)) + toLower + : 0;*/ +} + +QList<QVideoFrame::PixelFormat> S60VideoSurface::supportedPixelFormats( + QAbstractVideoBuffer::HandleType handleType) const +{ + /*return handleType == QAbstractVideoBuffer::NoHandle + ? m_supportedPixelFormats + : QList<QVideoFrame::PixelFormat>();*/ +} + +bool S60VideoSurface::start(const QVideoSurfaceFormat &format) +{ + /*if (m_image) + XFree(m_image); + + int xvFormatId = 0; + for (int i = 0; i < m_supportedPixelFormats.count(); ++i) { + if (m_supportedPixelFormats.at(i) == format.pixelFormat()) { + xvFormatId = m_formatIds.at(i); + break; + } + } + + if (xvFormatId == 0) { + setError(UnsupportedFormatError); + } else { + XvImage *image = XvCreateImage( + QX11Info::display(), + m_portId, + xvFormatId, + 0, + format.frameWidth(), + format.frameHeight()); + + if (!image) { + setError(ResourceError); + } else { + m_viewport = format.viewport(); + m_image = image; + + return QAbstractVideoSurface::start(format); + } + } + + if (m_image) { + m_image = 0; + + QAbstractVideoSurface::stop(); + } +*/ + return false; +} + +void S60VideoSurface::stop() +{/* + if (m_image) { + XFree(m_image); + m_image = 0; + + QAbstractVideoSurface::stop(); + }*/ +} + +bool S60VideoSurface::present(const QVideoFrame &frame) +{/* + if (!m_image) { + setError(StoppedError); + return false; + } else if (m_image->width != frame.width() || m_image->height != frame.height()) { + setError(IncorrectFormatError); + return false; + } else { + QVideoFrame frameCopy(frame); + + if (!frameCopy.map(QAbstractVideoBuffer::ReadOnly)) { + setError(IncorrectFormatError); + return false; + } else { + bool presented = false; + + if (m_image->data_size > frame.numBytes()) { + qWarning("Insufficient frame buffer size"); + setError(IncorrectFormatError); + } else if (m_image->num_planes > 0 && m_image->pitches[0] != frame.bytesPerLine()) { + qWarning("Incompatible frame pitches"); + setError(IncorrectFormatError); + } else { + m_image->data = reinterpret_cast<char *>(frameCopy.bits()); + + XvPutImage( + QX11Info::display(), + m_portId, + m_winId, + m_gc, + m_image, + m_viewport.x(), + m_viewport.y(), + m_viewport.width(), + m_viewport.height(), + m_displayRect.x(), + m_displayRect.y(), + m_displayRect.width(), + m_displayRect.height()); + + m_image->data = 0; + + presented = true; + } + + frameCopy.unmap(); + + return presented; + } + }*/ +} + +bool S60VideoSurface::findPort() +{/* + unsigned int count = 0; + XvAdaptorInfo *adaptors = 0; + bool portFound = false; + + if (XvQueryAdaptors(QX11Info::display(), m_winId, &count, &adaptors) == Success) { + for (unsigned int i = 0; i < count && !portFound; ++i) { + if (adaptors[i].type & XvImageMask) { + m_portId = adaptors[i].base_id; + + for (unsigned int j = 0; j < adaptors[i].num_ports && !portFound; ++j, ++m_portId) + portFound = XvGrabPort(QX11Info::display(), m_portId, 0) == Success; + } + } + XvFreeAdaptorInfo(adaptors); + } + + return portFound;*/ +} + +void S60VideoSurface::querySupportedFormats() +{/* + int count = 0; + if (XvImageFormatValues *imageFormats = XvListImageFormats( + QX11Info::display(), m_portId, &count)) { + const int rgbCount = sizeof(qt_xvRgbLookup) / sizeof(XvFormatRgb); + const int yuvCount = sizeof(qt_xvYuvLookup) / sizeof(XvFormatYuv); + + for (int i = 0; i < count; ++i) { + switch (imageFormats[i].type) { + case XvRGB: + for (int j = 0; j < rgbCount; ++j) { + if (imageFormats[i] == qt_xvRgbLookup[j]) { + m_supportedPixelFormats.append(qt_xvRgbLookup[j].pixelFormat); + m_formatIds.append(imageFormats[i].id); + break; + } + } + break; + case XvYUV: + for (int j = 0; j < yuvCount; ++j) { + if (imageFormats[i] == qt_xvYuvLookup[j]) { + m_supportedPixelFormats.append(qt_xvYuvLookup[j].pixelFormat); + m_formatIds.append(imageFormats[i].id); + break; + } + } + break; + } + } + XFree(imageFormats); + } + + m_brightnessRange = qMakePair(0, 0); + m_contrastRange = qMakePair(0, 0); + m_hueRange = qMakePair(0, 0); + m_saturationRange = qMakePair(0, 0); + + if (XvAttribute *attributes = XvQueryPortAttributes(QX11Info::display(), m_portId, &count)) { + for (int i = 0; i < count; ++i) { + if (qstrcmp(attributes[i].name, "XV_BRIGHTNESS") == 0) + m_brightnessRange = qMakePair(attributes[i].min_value, attributes[i].max_value); + else if (qstrcmp(attributes[i].name, "XV_CONTRAST") == 0) + m_contrastRange = qMakePair(attributes[i].min_value, attributes[i].max_value); + else if (qstrcmp(attributes[i].name, "XV_HUE") == 0) + m_hueRange = qMakePair(attributes[i].min_value, attributes[i].max_value); + else if (qstrcmp(attributes[i].name, "XV_SATURATION") == 0) + m_saturationRange = qMakePair(attributes[i].min_value, attributes[i].max_value); + } + + XFree(attributes); + }*/ +} + +bool S60VideoSurface::isFormatSupported(const QVideoSurfaceFormat &format) const +{ +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.h b/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.h new file mode 100644 index 0000000..836e52f --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videosurface.h @@ -0,0 +1,112 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOSURFACE_H +#define S60VIDEOSURFACE_H + +#include <QtGui/qwidget.h> +#include <QtMultimedia/qabstractvideosurface.h> + +QT_BEGIN_NAMESPACE + +class QVideoSurfaceFormat; + +class S60VideoSurface : public QAbstractVideoSurface +{ + Q_OBJECT +public: + S60VideoSurface(QObject *parent = 0); + ~S60VideoSurface(); + + WId winId() const; + void setWinId(WId id); + + QRect displayRect() const; + void setDisplayRect(const QRect &rect); + + 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); + + QList<QVideoFrame::PixelFormat> supportedPixelFormats( + QAbstractVideoBuffer::HandleType handleType = QAbstractVideoBuffer::NoHandle) const; + + bool isFormatSupported(const QVideoSurfaceFormat &format) const; + + bool start(const QVideoSurfaceFormat &format); + void stop(); + + bool present(const QVideoFrame &frame); + +private: + WId m_winId; + //XvPortID m_portId; + //GC m_gc; + //XvImage *m_image; + QList<QVideoFrame::PixelFormat> m_supportedPixelFormats; + QVector<int> m_formatIds; + QRect m_viewport; + QRect m_displayRect; + QPair<int, int> m_brightnessRange; + QPair<int, int> m_contrastRange; + QPair<int, int> m_hueRange; + QPair<int, int> m_saturationRange; + + bool findPort(); + void querySupportedFormats(); + + int getAttribute(const char *attribute, int minimum, int maximum) const; + void setAttribute(const char *attribute, int value, int minimum, int maximum); + + static int redistribute(int value, int fromLower, int fromUpper, int toLower, int toUpper); +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.cpp b/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.cpp new file mode 100644 index 0000000..84000d5 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.cpp @@ -0,0 +1,208 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60videowidget.h" +#include <QtGui/private/qwidget_p.h> +#include <QEvent> +#include <coemain.h> // For CCoeEnv + +QT_BEGIN_NAMESPACE + +QBlackWidget::QBlackWidget(QWidget *parent) + : QWidget(parent) +{ + setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); + setAttribute(Qt::WA_OpaquePaintEvent, true); + setAttribute(Qt::WA_NoSystemBackground, true); + setAutoFillBackground(false); + setPalette(QPalette(Qt::black)); +#if QT_VERSION >= 0x040601 && !defined(__WINSCW__) + qt_widget_private(this)->extraData()->nativePaintMode = QWExtra::ZeroFill; + qt_widget_private(this)->extraData()->receiveNativePaintEvents = true; +#endif +} + +QBlackWidget::~QBlackWidget() +{ +} + +void QBlackWidget::beginNativePaintEvent(const QRect& /*controlRect*/) +{ + emit beginVideoWindowNativePaint(); +} + +void QBlackWidget::endNativePaintEvent(const QRect& /*controlRect*/) +{ + CCoeEnv::Static()->WsSession().Flush(); + emit endVideoWindowNativePaint(); +} + +void QBlackWidget::paintEvent(QPaintEvent *event) +{ + Q_UNUSED(event); + // Do nothing +} + +S60VideoWidgetControl::S60VideoWidgetControl(QObject *parent) + : QVideoWidgetControl(parent) + , m_widget(0) + , m_aspectRatioMode(Qt::KeepAspectRatio) +{ + m_widget = new QBlackWidget(); + connect(m_widget, SIGNAL(beginVideoWindowNativePaint()), this, SIGNAL(beginVideoWindowNativePaint())); + connect(m_widget, SIGNAL(endVideoWindowNativePaint()), this, SIGNAL(endVideoWindowNativePaint())); + m_widget->installEventFilter(this); + m_widget->winId(); +} + +S60VideoWidgetControl::~S60VideoWidgetControl() +{ + delete m_widget; +} + +QWidget *S60VideoWidgetControl::videoWidget() +{ + return m_widget; +} + +Qt::AspectRatioMode S60VideoWidgetControl::aspectRatioMode() const +{ + return m_aspectRatioMode; +} + +void S60VideoWidgetControl::setAspectRatioMode(Qt::AspectRatioMode ratio) +{ + if (m_aspectRatioMode == ratio) + return; + + m_aspectRatioMode = ratio; + emit widgetUpdated(); +} + +bool S60VideoWidgetControl::isFullScreen() const +{ + return m_widget->isFullScreen(); +} + +void S60VideoWidgetControl::setFullScreen(bool fullScreen) +{ + emit fullScreenChanged(fullScreen); +} + +int S60VideoWidgetControl::brightness() const +{ + return 0; +} + +void S60VideoWidgetControl::setBrightness(int brightness) +{ + Q_UNUSED(brightness); +} + +int S60VideoWidgetControl::contrast() const +{ + return 0; +} + +void S60VideoWidgetControl::setContrast(int contrast) +{ + Q_UNUSED(contrast); +} + +int S60VideoWidgetControl::hue() const +{ + return 0; +} + +void S60VideoWidgetControl::setHue(int hue) +{ + Q_UNUSED(hue); +} + +int S60VideoWidgetControl::saturation() const +{ + return 0; +} + +void S60VideoWidgetControl::setSaturation(int saturation) +{ + Q_UNUSED(saturation); +} + +bool S60VideoWidgetControl::eventFilter(QObject *object, QEvent *e) +{ + if (object == m_widget) { + if ( e->type() == QEvent::Resize + || e->type() == QEvent::Move + || e->type() == QEvent::WinIdChange + || e->type() == QEvent::ParentChange + || e->type() == QEvent::Show) + emit widgetUpdated(); + } + return false; +} + +WId S60VideoWidgetControl::videoWidgetWId() +{ + if (m_widget->internalWinId()) + return m_widget->internalWinId(); + + if (m_widget->effectiveWinId()) + return m_widget->effectiveWinId(); + + return NULL; +} + +void S60VideoWidgetControl::videoStateChanged(QMediaPlayer::State state) +{ + if (state == QMediaPlayer::StoppedState) { +#if QT_VERSION <= 0x040600 && !defined(FF_QT) + qt_widget_private(m_widget)->extraData()->disableBlit = false; +#endif + m_widget->repaint(); + } else if (state == QMediaPlayer::PlayingState) { +#if QT_VERSION <= 0x040600 && !defined(FF_QT) + qt_widget_private(m_widget)->extraData()->disableBlit = true; +#endif + } +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.h b/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.h new file mode 100644 index 0000000..28a1455 --- /dev/null +++ b/src/plugins/mediaservices/symbian/mediaplayer/s60videowidget.h @@ -0,0 +1,115 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOWIDGET_H +#define S60VIDEOWIDGET_H + +#include <qvideowidgetcontrol.h> +#include <qmediaplayer.h> + +QT_BEGIN_NAMESPACE + +class QBlackWidget : public QWidget +{ + Q_OBJECT + +public: + QBlackWidget(QWidget *parent = 0); + virtual ~QBlackWidget(); + +signals: + void beginVideoWindowNativePaint(); + void endVideoWindowNativePaint(); + +public slots: + void beginNativePaintEvent(const QRect&); + void endNativePaintEvent(const QRect&); + +protected: + void paintEvent(QPaintEvent *event); +}; + +class S60VideoWidgetControl : public QVideoWidgetControl +{ + Q_OBJECT + +public: + S60VideoWidgetControl(QObject *parent = 0); + virtual ~S60VideoWidgetControl(); + + // from QVideoWidgetControl + QWidget *videoWidget(); + Qt::AspectRatioMode aspectRatioMode() const; + void setAspectRatioMode(Qt::AspectRatioMode ratio); + bool isFullScreen() const; + void setFullScreen(bool fullScreen); + 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); + + // from QObject + bool eventFilter(QObject *object, QEvent *event); + + //new methods + WId videoWidgetWId(); + +signals: + void widgetUpdated(); + void beginVideoWindowNativePaint(); + void endVideoWindowNativePaint(); + +private slots: + void videoStateChanged(QMediaPlayer::State state); + +private: + QBlackWidget *m_widget; + Qt::AspectRatioMode m_aspectRatioMode; +}; + +QT_END_NAMESPACE + + +#endif // S60VIDEOWIDGET_H diff --git a/src/plugins/mediaservices/symbian/s60mediaserviceplugin.cpp b/src/plugins/mediaservices/symbian/s60mediaserviceplugin.cpp new file mode 100644 index 0000000..1185583 --- /dev/null +++ b/src/plugins/mediaservices/symbian/s60mediaserviceplugin.cpp @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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/qstring.h> +#include <QtCore/qdebug.h> + +#include "s60mediaserviceplugin.h" +#ifdef QMEDIA_MMF_RADIO +#include "s60radiotunerservice.h" +#endif +#ifdef QMEDIA_MMF_PLAYER +#include "s60mediaplayerservice.h" +#endif +#ifdef QMEDIA_MMF_CAPTURE +#include "s60audiocaptureservice.h" +#endif + +QT_BEGIN_NAMESPACE + +QStringList S60MediaServicePlugin::keys() const +{ + QStringList list; +#ifdef QMEDIA_MMF_RADIO + list << QLatin1String(Q_MEDIASERVICE_RADIO); +#endif + +#ifdef QMEDIA_MMF_PLAYER + list << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER); +#endif +#ifdef QMEDIA_MMF_CAPTURE + list << QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE); +#endif + return list; +} + +QMediaService* S60MediaServicePlugin::create(QString const& key) +{ +#ifdef QMEDIA_MMF_PLAYER + if (key == QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)) + return new S60MediaPlayerService; +#endif +#ifdef QMEDIA_MMF_CAPTURE + if (key == QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE)) + return new S60AudioCaptureService; +#endif +#ifdef QMEDIA_MMF_RADIO + if (key == QLatin1String(Q_MEDIASERVICE_RADIO)) + return new S60RadioTunerService; +#endif + + return 0; +} + +void S60MediaServicePlugin::release(QMediaService *service) +{ + delete service; +} + +QT_END_NAMESPACE + +Q_EXPORT_PLUGIN2(qmmfengine, S60MediaServicePlugin); + diff --git a/src/plugins/mediaservices/symbian/s60mediaserviceplugin.h b/src/plugins/mediaservices/symbian/s60mediaserviceplugin.h new file mode 100644 index 0000000..be2e05d --- /dev/null +++ b/src/plugins/mediaservices/symbian/s60mediaserviceplugin.h @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60SERVICEPLUGIN_H +#define S60SERVICEPLUGIN_H + +#include <QtCore/qobject.h> +#include <qmediaservice.h> +#include <qmediaserviceproviderplugin.h> + +QT_BEGIN_NAMESPACE + +class S60MediaServicePlugin : public QMediaServiceProviderPlugin +{ + Q_OBJECT +public: + + QStringList keys() const; + QMediaService* create(QString const& key); + void release(QMediaService *service); +}; + +QT_END_NAMESPACE + +#endif // S60SERVICEPLUGIN_H diff --git a/src/plugins/mediaservices/symbian/s60videooutputcontrol.cpp b/src/plugins/mediaservices/symbian/s60videooutputcontrol.cpp new file mode 100644 index 0000000..da07a7d --- /dev/null +++ b/src/plugins/mediaservices/symbian/s60videooutputcontrol.cpp @@ -0,0 +1,76 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 "s60videooutputcontrol.h" + +QT_BEGIN_NAMESPACE + +S60VideoOutputControl::S60VideoOutputControl(QObject *parent) + : QVideoOutputControl(parent) + , m_output(NoOutput) +{ +} + +QList<QVideoOutputControl::Output> S60VideoOutputControl::availableOutputs() const +{ + return m_outputs; +} + +void S60VideoOutputControl::setAvailableOutputs(const QList<Output> &outputs) +{ + emit availableOutputsChanged(m_outputs = outputs); +} + +QVideoOutputControl::Output S60VideoOutputControl::output() const +{ + return m_output; +} + +void S60VideoOutputControl::setOutput(Output output) +{ + if (!m_outputs.contains(output)) + output = NoOutput; + + if (m_output != output) + emit outputChanged(m_output = output); +} + +QT_END_NAMESPACE diff --git a/src/plugins/mediaservices/symbian/s60videooutputcontrol.h b/src/plugins/mediaservices/symbian/s60videooutputcontrol.h new file mode 100644 index 0000000..dbad889 --- /dev/null +++ b/src/plugins/mediaservices/symbian/s60videooutputcontrol.h @@ -0,0 +1,72 @@ +/**************************************************************************** +** +** 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 plugins of the Qt Toolkit. +** +** $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 S60VIDEOOUTPUTCONTROL_H +#define S60VIDEOOUTPUTCONTROL_H + +#include <QObject> +#include <qvideooutputcontrol.h> + +QT_BEGIN_NAMESPACE + +class S60VideoOutputControl : public QVideoOutputControl +{ + Q_OBJECT +public: + S60VideoOutputControl(QObject *parent = 0); + + QList<Output> availableOutputs() const; + void setAvailableOutputs(const QList<Output> &outputs); + + Output output() const; + void setOutput(Output output); + +Q_SIGNALS: + void outputChanged(QVideoOutputControl::Output output); + +private: + QList<Output> m_outputs; + Output m_output; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/plugins/mediaservices/symbian/symbian.pro b/src/plugins/mediaservices/symbian/symbian.pro new file mode 100644 index 0000000..f76858f --- /dev/null +++ b/src/plugins/mediaservices/symbian/symbian.pro @@ -0,0 +1,27 @@ +TARGET = qmmfengine +QT += multimedia mediaservices + +load(data_caging_paths) + +include (../../qpluginbase.pri) +include(mediaplayer/mediaplayer.pri) + +HEADERS += s60mediaserviceplugin.h \ + s60videooutputcontrol.h + +SOURCES += s60mediaserviceplugin.cpp \ + s60videooutputcontrol.cpp + +contains(S60_VERSION, 3.2)|contains(S60_VERSION, 3.1) { + DEFINES += PRE_S60_50_PLATFORM +} + +INCLUDEPATH += $$APP_LAYER_SYSTEMINCLUDE +symbian-abld:INCLUDEPATH += $$QT_BUILD_TREE/include/QtWidget/private + +# This is needed for having the .qtplugin file properly created on Symbian. +QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/mediaservices +target.path += $$[QT_INSTALL_PLUGINS]/mediaservices +INSTALLS += target + +TARGET.UID3=0x20021318 diff --git a/src/s60installs/s60installs.pro b/src/s60installs/s60installs.pro index ad196a8..9826967 100644 --- a/src/s60installs/s60installs.pro +++ b/src/s60installs/s60installs.pro @@ -151,9 +151,15 @@ symbian: { graphicssystems_plugins.sources += $$QT_BUILD_TREE/plugins/graphicssystems/qvggraphicssystem$${QT_LIBINFIX}.dll } - contains(QT_CONFIG, multimedia) { + contains(QT_CONFIG, multimedia):contains(QT_CONFIG, mediaservices):contains(QT_CONFIG, media-backend) { qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtMultimedia$${QT_LIBINFIX}.dll qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtMediaServices$${QT_LIBINFIX}.dll + + mediaservices_plugins.path = c:$$QT_PLUGINS_BASE_DIR/mediaservices + mediaservices_plugins.sources += $$QT_BUILD_TREE/plugins/mediaservices/qmmfengine$${QT_LIBINFIX}.dll + + DEPLOYMENT += mediaservices_plugins + } BLD_INF_RULES.prj_exports += "qt.iby $$CORE_MW_LAYER_IBY_EXPORT_PATH(qt.iby)" |