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

Make QDeclarativeAudio use QMediaPlayer instead of the controls.

Browse Source 
Very minor changes in semantics due to previous differences:
* negative positions are not supported any more (clamped to >= 0)
* setting muted to the same value previously set to the control itself
  won't signal any more.

Change-Id: Iacf4310508d853ae82b63dee28095fce12b6ff28
Reviewed-by: Dmytro Poplavskiy <dmytro.poplavskiy@nokia.com>
This commit is contained in:
Michael Goddard
2012-03-13 13:29:26 +10:00
committed by Qt by Nokia
parent 7c0b1da0ed
commit e9ebbeef72
11 changed files with 338 additions and 308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/imports/multimedia/multimedia.pro
View File

@@ -28,7 +28,8 @@ HEADERS += \
qdeclarativecamerapreviewprovider_p.h \
qdeclarativetorch_p.h \
qdeclarativeaudio_p_4.h \
qdeclarativemediabase_p_4.h
qdeclarativemediabase_p_4.h \
qdeclarativemediametadata_p_4.h
SOURCES += \
multimedia.cpp \

305
src/imports/multimedia/qdeclarativeaudio.cpp
View File

@@ -56,113 +56,6 @@
QT_BEGIN_NAMESPACE
class QDeclarativeMediaBaseObject : public QMediaObject
{
public:
QDeclarativeMediaBaseObject(QMediaService *service)
: QMediaObject(0, service)
{
}
};
class QDeclarativeMediaBasePlayerControl : public QMediaPlayerControl
{
public:
QDeclarativeMediaBasePlayerControl(QObject *parent)
: QMediaPlayerControl(parent)
{
}
QMediaPlayer::State state() const { return QMediaPlayer::StoppedState; }
QMediaPlayer::MediaStatus mediaStatus() const { return QMediaPlayer::NoMedia; }
qint64 duration() const { return 0; }
qint64 position() const { return 0; }
void setPosition(qint64) {}
int volume() const { return 0; }
void setVolume(int) {}
bool isMuted() const { return false; }
void setMuted(bool) {}
int bufferStatus() const { return 0; }
bool isAudioAvailable() const { return false; }
bool isVideoAvailable() const { return false; }
bool isSeekable() const { return false; }
QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(); }
qreal playbackRate() const { return 1; }
void setPlaybackRate(qreal) {}
QMediaContent media() const { return QMediaContent(); }
const QIODevice *mediaStream() const { return 0; }
void setMedia(const QMediaContent &, QIODevice *) {}
void play() {}
void pause() {}
void stop() {}
};
class QDeclarativeMediaBaseAvailabilityControl : public QMediaAvailabilityControl
{
public:
QDeclarativeMediaBaseAvailabilityControl(bool available)
: m_available(available)
{
}
QtMultimedia::AvailabilityError availability() const
{
return m_available ? QtMultimedia::NoError : QtMultimedia::ServiceMissingError;
}
private:
bool m_available;
};
class QDeclarativeMediaBaseMetaDataControl : public QMetaDataReaderControl
{
public:
QDeclarativeMediaBaseMetaDataControl(QObject *parent)
: QMetaDataReaderControl(parent)
{
}
bool isMetaDataAvailable() const { return false; }
QVariant metaData(const QString &) const { return QVariant(); }
QStringList availableMetaData() const { return QStringList(); }
};
class QDeclarativeMediaBaseAnimation : public QObject
{
public:
QDeclarativeMediaBaseAnimation(QDeclarativeAudio *media)
: m_media(media)
{
}
void start() { if (!m_timer.isActive()) m_timer.start(500, this); }
void stop() { m_timer.stop(); }
protected:
void timerEvent(QTimerEvent *event)
{
if (event->timerId() == m_timer.timerId()) {
event->accept();
if (m_media->m_playbackState == QMediaPlayer::PlayingState)
emit m_media->positionChanged();
if (m_media->m_status == QMediaPlayer::BufferingMedia || QMediaPlayer::StalledMedia)
emit m_media->bufferProgressChanged();
} else {
QObject::timerEvent(event);
}
}
private:
QDeclarativeAudio *m_media;
QBasicTimer m_timer;
};
/*!
\qmlclass MediaPlayer
\brief The MediaPlayer element allows you to add media playback to a scene.
@@ -261,12 +154,12 @@ private:
\brief The QDeclarativeAudio class provides an audio item that you can add to a QDeclarativeView.
*/
void QDeclarativeAudio::_q_error(int errorCode, const QString &errorString)
void QDeclarativeAudio::_q_error(QMediaPlayer::Error errorCode)
{
m_error = QMediaPlayer::Error(errorCode);
m_errorString = errorString;
m_error = errorCode;
m_errorString = m_player->errorString();
emit error(Error(errorCode), errorString);
emit error(Error(errorCode), m_errorString);
emit errorChanged();
}
@@ -275,7 +168,6 @@ void QDeclarativeAudio::_q_availabilityChanged(QtMultimedia::AvailabilityError)
emit availabilityChanged(availability());
}
QDeclarativeAudio::QDeclarativeAudio(QObject *parent)
: QObject(parent)
, m_autoPlay(false)
@@ -288,28 +180,17 @@ QDeclarativeAudio::QDeclarativeAudio(QObject *parent)
, m_position(0)
, m_vol(1.0)
, m_playbackRate(1.0)
, m_mediaService(0)
, m_playerControl(0)
, m_mediaObject(0)
, m_mediaProvider(0)
, m_metaDataControl(0)
, m_animation(0)
, m_availabilityControl(0)
, m_playbackState(QMediaPlayer::StoppedState)
, m_status(QMediaPlayer::NoMedia)
, m_error(QMediaPlayer::ServiceMissingError)
, m_player(0)
{
}
QDeclarativeAudio::~QDeclarativeAudio()
{
delete m_mediaObject;
m_metaData.reset();
if (m_mediaProvider)
m_mediaProvider->releaseService(m_mediaService);
delete m_animation;
delete m_player;
}
/*!
@@ -334,11 +215,9 @@ QDeclarativeAudio::~QDeclarativeAudio()
*/
QDeclarativeAudio::Availability QDeclarativeAudio::availability() const
{
if (!m_playerControl)
if (!m_player)
return Unavailable;
if (m_availabilityControl)
return Availability(m_availabilityControl->availability());
return Available;
return Availability(m_player->availabilityError());
}
QUrl QDeclarativeAudio::source() const
@@ -376,13 +255,14 @@ void QDeclarativeAudio::setSource(const QUrl &url)
emit errorChanged();
}
m_playerControl->setMedia(m_source, 0);
m_player->setMedia(m_source, 0);
m_loaded = true;
}
else
emit sourceChanged();
if (m_autoPlay) m_playerControl->play();
if (m_autoPlay)
m_player->play();
}
bool QDeclarativeAudio::isAutoLoad() const
@@ -428,53 +308,58 @@ void QDeclarativeAudio::setPlaybackState(QMediaPlayer::State playbackState)
switch (playbackState){
case (QMediaPlayer::PlayingState):
if (!m_loaded) {
m_playerControl->setMedia(m_source, 0);
m_playerControl->setPosition(m_position);
m_player->setMedia(m_source, 0);
m_player->setPosition(m_position);
m_loaded = true;
}
m_playerControl->play();
m_player->play();
break;
case (QMediaPlayer::PausedState):
if (!m_loaded) {
m_playerControl->setMedia(m_source, 0);
m_playerControl->setPosition(m_position);
m_player->setMedia(m_source, 0);
m_player->setPosition(m_position);
m_loaded = true;
}
m_playerControl->pause();
m_player->pause();
break;
case (QMediaPlayer::StoppedState):
m_playerControl->stop();
m_player->stop();
}
}
}
int QDeclarativeAudio::duration() const
{
return !m_complete ? 0 : m_playerControl->duration();
return !m_complete ? 0 : m_player->duration();
}
int QDeclarativeAudio::position() const
{
return !m_complete ? m_position : m_playerControl->position();
return !m_complete ? m_position : m_player->position();
}
void QDeclarativeAudio::setPosition(int position)
{
// QMediaPlayer clamps this to positive numbers
if (position < 0)
position = 0;
if (this->position() == position)
return;
m_position = position;
if (m_complete)
m_playerControl->setPosition(m_position);
m_player->setPosition(m_position);
else
emit positionChanged();
}
qreal QDeclarativeAudio::volume() const
{
return !m_complete ? m_vol : qreal(m_playerControl->volume()) / 100;
return !m_complete ? m_vol : qreal(m_player->volume()) / 100;
}
void QDeclarativeAudio::setVolume(qreal volume)
@@ -490,14 +375,14 @@ void QDeclarativeAudio::setVolume(qreal volume)
m_vol = volume;
if (m_complete)
m_playerControl->setVolume(qRound(volume * 100));
m_player->setVolume(qRound(volume * 100));
else
emit volumeChanged();
}
bool QDeclarativeAudio::isMuted() const
{
return !m_complete ? m_muted : m_playerControl->isMuted();
return !m_complete ? m_muted : m_player->isMuted();
}
void QDeclarativeAudio::setMuted(bool muted)
@@ -508,19 +393,19 @@ void QDeclarativeAudio::setMuted(bool muted)
m_muted = muted;
if (m_complete)
m_playerControl->setMuted(muted);
m_player->setMuted(muted);
else
emit mutedChanged();
}
qreal QDeclarativeAudio::bufferProgress() const
{
return !m_complete ? 0 : qreal(m_playerControl->bufferStatus()) / 100;
return !m_complete ? 0 : qreal(m_player->bufferStatus()) / 100;
}
bool QDeclarativeAudio::isSeekable() const
{
return !m_complete ? false : m_playerControl->isSeekable();
return !m_complete ? false : m_player->isSeekable();
}
qreal QDeclarativeAudio::playbackRate() const
@@ -536,7 +421,7 @@ void QDeclarativeAudio::setPlaybackRate(qreal rate)
m_playbackRate = rate;
if (m_complete)
m_playerControl->setPlaybackRate(m_playbackRate);
m_player->setPlaybackRate(m_playbackRate);
else
emit playbackRateChanged();
}
@@ -724,7 +609,7 @@ QDeclarativeAudio::PlaybackState QDeclarativeAudio::playbackState() const
bool QDeclarativeAudio::hasAudio() const
{
return !m_complete ? false : m_playerControl->isAudioAvailable();
return !m_complete ? false : m_player->isAudioAvailable();
}
/*!
@@ -735,7 +620,7 @@ bool QDeclarativeAudio::hasAudio() const
bool QDeclarativeAudio::hasVideo() const
{
return !m_complete ? false : m_playerControl->isVideoAvailable();
return !m_complete ? false : m_player->isVideoAvailable();
}
/*!
@@ -782,115 +667,89 @@ QDeclarativeAudio::Error QDeclarativeAudio::error() const
void QDeclarativeAudio::classBegin()
{
if ((m_mediaProvider = QMediaServiceProvider::defaultServiceProvider()) != 0) {
m_mediaService = m_mediaProvider->requestService(Q_MEDIASERVICE_MEDIAPLAYER);
if (m_mediaService != 0) {
m_playerControl = qobject_cast<QMediaPlayerControl *>(
m_mediaService->requestControl(QMediaPlayerControl_iid));
m_metaDataControl = qobject_cast<QMetaDataReaderControl *>(
m_mediaService->requestControl(QMetaDataReaderControl_iid));
m_mediaObject = new QDeclarativeMediaBaseObject(m_mediaService);
m_availabilityControl = m_mediaService->requestControl<QMediaAvailabilityControl*>();
}
}
m_player = new QMediaPlayer(this);
bool realPlayer = m_playerControl;
connect(m_player, SIGNAL(stateChanged(QMediaPlayer::State)),
this, SLOT(_q_statusChanged()));
connect(m_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
this, SLOT(_q_statusChanged()));
connect(m_player, SIGNAL(mediaChanged(QMediaContent)),
this, SIGNAL(sourceChanged()));
connect(m_player, SIGNAL(durationChanged(qint64)),
this, SIGNAL(durationChanged()));
connect(m_player, SIGNAL(positionChanged(qint64)),
this, SIGNAL(positionChanged()));
connect(m_player, SIGNAL(volumeChanged(int)),
this, SIGNAL(volumeChanged()));
connect(m_player, SIGNAL(mutedChanged(bool)),
this, SIGNAL(mutedChanged()));
connect(m_player, SIGNAL(bufferStatusChanged(int)),
this, SIGNAL(bufferProgressChanged()));
connect(m_player, SIGNAL(seekableChanged(bool)),
this, SIGNAL(seekableChanged()));
connect(m_player, SIGNAL(playbackRateChanged(qreal)),
this, SIGNAL(playbackRateChanged()));
connect(m_player, SIGNAL(error(QMediaPlayer::Error)),
this, SLOT(_q_error(QMediaPlayer::Error)));
connect(m_player, SIGNAL(audioAvailableChanged(bool)),
this, SIGNAL(hasAudioChanged()));
connect(m_player, SIGNAL(videoAvailableChanged(bool)),
this, SIGNAL(hasVideoChanged()));
if (m_playerControl) {
QObject::connect(m_playerControl, SIGNAL(stateChanged(QMediaPlayer::State)),
this, SLOT(_q_statusChanged()));
QObject::connect(m_playerControl, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
this, SLOT(_q_statusChanged()));
QObject::connect(m_playerControl, SIGNAL(mediaChanged(QMediaContent)),
this, SIGNAL(sourceChanged()));
QObject::connect(m_playerControl, SIGNAL(durationChanged(qint64)),
this, SIGNAL(durationChanged()));
QObject::connect(m_playerControl, SIGNAL(positionChanged(qint64)),
this, SIGNAL(positionChanged()));
QObject::connect(m_playerControl, SIGNAL(volumeChanged(int)),
this, SIGNAL(volumeChanged()));
QObject::connect(m_playerControl, SIGNAL(mutedChanged(bool)),
this, SIGNAL(mutedChanged()));
QObject::connect(m_playerControl, SIGNAL(bufferStatusChanged(int)),
this, SIGNAL(bufferProgressChanged()));
QObject::connect(m_playerControl, SIGNAL(seekableChanged(bool)),
this, SIGNAL(seekableChanged()));
QObject::connect(m_playerControl, SIGNAL(playbackRateChanged(qreal)),
this, SIGNAL(playbackRateChanged()));
QObject::connect(m_playerControl, SIGNAL(error(int,QString)),
this, SLOT(_q_error(int,QString)));
m_error = m_player->availabilityError() == QtMultimedia::ServiceMissingError ? QMediaPlayer::ServiceMissingError : QMediaPlayer::NoError;
m_animation = new QDeclarativeMediaBaseAnimation(this);
m_error = QMediaPlayer::NoError;
} else {
m_playerControl = new QDeclarativeMediaBasePlayerControl(this);
}
if (!m_metaDataControl)
m_metaDataControl = new QDeclarativeMediaBaseMetaDataControl(this);
if (!m_availabilityControl)
m_availabilityControl = new QDeclarativeMediaBaseAvailabilityControl(realPlayer);
QObject::connect(m_availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityError)),
connect(m_player, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)),
this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
m_metaData.reset(new QDeclarativeMediaMetaData(m_metaDataControl));
m_metaData.reset(new QDeclarativeMediaMetaData(m_player));
QObject::connect(m_metaDataControl, SIGNAL(metaDataChanged()),
connect(m_player, SIGNAL(metaDataChanged()),
m_metaData.data(), SIGNAL(metaDataChanged()));
if (m_mediaService) {
connect(m_playerControl, SIGNAL(audioAvailableChanged(bool)),
this, SIGNAL(hasAudioChanged()));
connect(m_playerControl, SIGNAL(videoAvailableChanged(bool)),
this, SIGNAL(hasVideoChanged()));
}
emit mediaObjectChanged();
}
void QDeclarativeAudio::componentComplete()
{
if (!qFuzzyCompare(m_vol, qreal(1.0)))
m_playerControl->setVolume(m_vol * 100);
m_player->setVolume(m_vol * 100);
if (m_muted)
m_playerControl->setMuted(m_muted);
m_player->setMuted(m_muted);
if (!qFuzzyCompare(m_playbackRate, qreal(1.0)))
m_playerControl->setPlaybackRate(m_playbackRate);
m_player->setPlaybackRate(m_playbackRate);
if (!m_source.isEmpty() && (m_autoLoad || m_autoPlay)) {
m_playerControl->setMedia(m_source, 0);
m_player->setMedia(m_source, 0);
m_loaded = true;
if (m_position > 0)
m_playerControl->setPosition(m_position);
m_player->setPosition(m_position);
}
m_complete = true;
if (m_autoPlay) {
if (m_source.isEmpty()) {
m_playerControl->stop();
m_player->stop();
} else {
m_playerControl->play();
m_player->play();
}
}
}
void QDeclarativeAudio::_q_statusChanged()
{
if (m_playerControl->mediaStatus() == QMediaPlayer::EndOfMedia && m_runningCount != 0) {
if (m_player->mediaStatus() == QMediaPlayer::EndOfMedia && m_runningCount != 0) {
m_runningCount -= 1;
m_playerControl->play();
m_player->play();
}
const QMediaPlayer::MediaStatus oldStatus = m_status;
const QMediaPlayer::State lastPlaybackState = m_playbackState;
const QMediaPlayer::State state = m_playerControl->state();
const QMediaPlayer::State state = m_player->state();
m_playbackState = state;
m_status = m_playerControl->mediaStatus();
m_status = m_player->mediaStatus();
if (m_status != oldStatus)
emit statusChanged();
@@ -914,16 +773,6 @@ void QDeclarativeAudio::_q_statusChanged()
emit playbackStateChanged();
}
// Check
if ((state == QMediaPlayer::PlayingState)
|| m_status == QMediaPlayer::BufferingMedia
|| m_status == QMediaPlayer::StalledMedia) {
m_animation->start();
}
else {
m_animation->stop();
}
}
/*!

18
src/imports/multimedia/qdeclarativeaudio_p.h
View File

@@ -158,7 +158,7 @@ public:
void classBegin();
void componentComplete();
QObject *mediaObject() { return m_mediaObject; }
QObject *mediaObject() { return m_player; }
Availability availability() const;
@@ -236,7 +236,7 @@ Q_SIGNALS:
void mediaObjectChanged();
private Q_SLOTS:
void _q_error(int, const QString &);
void _q_error(QMediaPlayer::Error);
void _q_availabilityChanged(QtMultimedia::AvailabilityError);
void _q_statusChanged();
@@ -253,16 +253,6 @@ private:
int m_position;
qreal m_vol;
qreal m_playbackRate;
QMediaService *m_mediaService;
QMediaPlayerControl *m_playerControl;
QMediaObject *m_mediaObject;
QMediaServiceProvider *m_mediaProvider;
QMetaDataReaderControl *m_metaDataControl;
QDeclarativeMediaBaseAnimation *m_animation;
QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
QMediaAvailabilityControl *m_availabilityControl;
QMediaPlayer::State m_playbackState;
QMediaPlayer::MediaStatus m_status;
@@ -270,6 +260,10 @@ private:
QString m_errorString;
QUrl m_source;
QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
QMediaPlayer *m_player;
friend class QDeclarativeMediaBaseAnimation;
};

2
src/imports/multimedia/qdeclarativeaudio_p_4.h
View File

@@ -85,7 +85,7 @@ class QDeclarativeAudio_4 : public QObject, public QDeclarativeMediaBase_4, publ
Q_PROPERTY(qreal playbackRate READ playbackRate WRITE setPlaybackRate NOTIFY playbackRateChanged)
Q_PROPERTY(Error error READ error NOTIFY errorChanged)
Q_PROPERTY(QString errorString READ errorString NOTIFY errorChanged)
Q_PROPERTY(QDeclarativeMediaMetaData *metaData READ metaData CONSTANT)
Q_PROPERTY(QDeclarativeMediaMetaData_4 *metaData READ metaData CONSTANT)
Q_PROPERTY(QObject *mediaObject READ mediaObject NOTIFY mediaObjectChanged SCRIPTABLE false DESIGNABLE false)
Q_ENUMS(Status)
Q_ENUMS(Error)

6
src/imports/multimedia/qdeclarativemediabase_4.cpp
View File

@@ -50,7 +50,7 @@
#include <private/qmediaserviceprovider_p.h>
#include <qmetadatareadercontrol.h>
#include "qdeclarativemediametadata_p.h"
#include "qdeclarativemediametadata_p_4.h"
QT_BEGIN_NAMESPACE
@@ -304,7 +304,7 @@ void QDeclarativeMediaBase_4::setObject(QObject *object, const QByteArray &type)
if (!m_metaDataControl)
m_metaDataControl = new QDeclarativeMediaBaseMetaDataControl(object);
m_metaData.reset(new QDeclarativeMediaMetaData(m_metaDataControl));
m_metaData.reset(new QDeclarativeMediaMetaData_4(m_metaDataControl));
QObject::connect(m_metaDataControl, SIGNAL(metaDataChanged()),
m_metaData.data(), SIGNAL(metaDataChanged()));
@@ -558,7 +558,7 @@ QString QDeclarativeMediaBase_4::errorString() const
return m_errorString;
}
QDeclarativeMediaMetaData *QDeclarativeMediaBase_4::metaData() const
QDeclarativeMediaMetaData_4 *QDeclarativeMediaBase_4::metaData() const
{
return m_metaData.data();
}

6
src/imports/multimedia/qdeclarativemediabase_p_4.h
View File

@@ -66,7 +66,7 @@ class QMediaService;
class QMediaServiceProvider;
class QMetaDataReaderControl;
class QDeclarativeMediaBaseAnimation;
class QDeclarativeMediaMetaData;
class QDeclarativeMediaMetaData_4;
class QDeclarativeMediaBase_4
{
@@ -113,7 +113,7 @@ public:
QString errorString() const;
QDeclarativeMediaMetaData *metaData() const;
QDeclarativeMediaMetaData_4 *metaData() const;
void _q_statusChanged();
@@ -171,7 +171,7 @@ protected:
QMediaServiceProvider *m_mediaProvider;
QMetaDataReaderControl *m_metaDataControl;
QDeclarativeMediaBaseAnimation *m_animation;
QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
QScopedPointer<QDeclarativeMediaMetaData_4> m_metaData;
QMediaPlayer::MediaStatus m_status;
QMediaPlayer::Error m_error;

101
src/imports/multimedia/qdeclarativemediametadata_p.h
View File

@@ -53,9 +53,8 @@
// We mean it.
//
#include <qmetadatareadercontrol.h>
#include <QtQml/qqml.h>
#include "qmediaobject.h"
QT_BEGIN_HEADER
@@ -111,69 +110,69 @@ class QDeclarativeMediaMetaData : public QObject
Q_PROPERTY(QVariant leadPerformer READ leadPerformer NOTIFY metaDataChanged)
Q_PROPERTY(QVariant writer READ writer NOTIFY metaDataChanged)
public:
QDeclarativeMediaMetaData(QMetaDataReaderControl *control, QObject *parent = 0)
QDeclarativeMediaMetaData(QMediaObject *player, QObject *parent = 0)
: QObject(parent)
, m_control(control)
, m_mediaObject(player)
{
}
QVariant title() const { return m_control->metaData(QtMultimedia::MetaData::Title); }
QVariant subTitle() const { return m_control->metaData(QtMultimedia::MetaData::SubTitle); }
QVariant author() const { return m_control->metaData(QtMultimedia::MetaData::Author); }
QVariant comment() const { return m_control->metaData(QtMultimedia::MetaData::Comment); }
QVariant description() const { return m_control->metaData(QtMultimedia::MetaData::Description); }
QVariant category() const { return m_control->metaData(QtMultimedia::MetaData::Category); }
QVariant genre() const { return m_control->metaData(QtMultimedia::MetaData::Genre); }
QVariant year() const { return m_control->metaData(QtMultimedia::MetaData::Year); }
QVariant date() const { return m_control->metaData(QtMultimedia::MetaData::Date); }
QVariant userRating() const { return m_control->metaData(QtMultimedia::MetaData::UserRating); }
QVariant keywords() const { return m_control->metaData(QtMultimedia::MetaData::Keywords); }
QVariant language() const { return m_control->metaData(QtMultimedia::MetaData::Language); }
QVariant publisher() const { return m_control->metaData(QtMultimedia::MetaData::Publisher); }
QVariant copyright() const { return m_control->metaData(QtMultimedia::MetaData::Copyright); }
QVariant parentalRating() const { return m_control->metaData(QtMultimedia::MetaData::ParentalRating); }
QVariant title() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Title); }
QVariant subTitle() const { return m_mediaObject->metaData(QtMultimedia::MetaData::SubTitle); }
QVariant author() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Author); }
QVariant comment() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Comment); }
QVariant description() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Description); }
QVariant category() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Category); }
QVariant genre() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Genre); }
QVariant year() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Year); }
QVariant date() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Date); }
QVariant userRating() const { return m_mediaObject->metaData(QtMultimedia::MetaData::UserRating); }
QVariant keywords() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Keywords); }
QVariant language() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Language); }
QVariant publisher() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Publisher); }
QVariant copyright() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Copyright); }
QVariant parentalRating() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ParentalRating); }
QVariant ratingOrganization() const {
return m_control->metaData(QtMultimedia::MetaData::RatingOrganization); }
QVariant size() const { return m_control->metaData(QtMultimedia::MetaData::Size); }
QVariant mediaType() const { return m_control->metaData(QtMultimedia::MetaData::MediaType); }
QVariant duration() const { return m_control->metaData(QtMultimedia::MetaData::Duration); }
QVariant audioBitRate() const { return m_control->metaData(QtMultimedia::MetaData::AudioBitRate); }
QVariant audioCodec() const { return m_control->metaData(QtMultimedia::MetaData::AudioCodec); }
QVariant averageLevel() const { return m_control->metaData(QtMultimedia::MetaData::AverageLevel); }
QVariant channelCount() const { return m_control->metaData(QtMultimedia::MetaData::ChannelCount); }
QVariant peakValue() const { return m_control->metaData(QtMultimedia::MetaData::PeakValue); }
QVariant sampleRate() const { return m_control->metaData(QtMultimedia::MetaData::SampleRate); }
QVariant albumTitle() const { return m_control->metaData(QtMultimedia::MetaData::AlbumTitle); }
QVariant albumArtist() const { return m_control->metaData(QtMultimedia::MetaData::AlbumArtist); }
return m_mediaObject->metaData(QtMultimedia::MetaData::RatingOrganization); }
QVariant size() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Size); }
QVariant mediaType() const { return m_mediaObject->metaData(QtMultimedia::MetaData::MediaType); }
QVariant duration() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Duration); }
QVariant audioBitRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AudioBitRate); }
QVariant audioCodec() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AudioCodec); }
QVariant averageLevel() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AverageLevel); }
QVariant channelCount() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ChannelCount); }
QVariant peakValue() const { return m_mediaObject->metaData(QtMultimedia::MetaData::PeakValue); }
QVariant sampleRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::SampleRate); }
QVariant albumTitle() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AlbumTitle); }
QVariant albumArtist() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AlbumArtist); }
QVariant contributingArtist() const {
return m_control->metaData(QtMultimedia::MetaData::ContributingArtist); }
QVariant composer() const { return m_control->metaData(QtMultimedia::MetaData::Composer); }
QVariant conductor() const { return m_control->metaData(QtMultimedia::MetaData::Conductor); }
QVariant lyrics() const { return m_control->metaData(QtMultimedia::MetaData::Lyrics); }
QVariant mood() const { return m_control->metaData(QtMultimedia::MetaData::Mood); }
QVariant trackNumber() const { return m_control->metaData(QtMultimedia::MetaData::TrackNumber); }
QVariant trackCount() const { return m_control->metaData(QtMultimedia::MetaData::TrackCount); }
return m_mediaObject->metaData(QtMultimedia::MetaData::ContributingArtist); }
QVariant composer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Composer); }
QVariant conductor() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Conductor); }
QVariant lyrics() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Lyrics); }
QVariant mood() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Mood); }
QVariant trackNumber() const { return m_mediaObject->metaData(QtMultimedia::MetaData::TrackNumber); }
QVariant trackCount() const { return m_mediaObject->metaData(QtMultimedia::MetaData::TrackCount); }
QVariant coverArtUrlSmall() const {
return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
return m_mediaObject->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
QVariant coverArtUrlLarge() const {
return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
QVariant resolution() const { return m_control->metaData(QtMultimedia::MetaData::Resolution); }
return m_mediaObject->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
QVariant resolution() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Resolution); }
QVariant pixelAspectRatio() const {
return m_control->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
QVariant videoFrameRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoFrameRate); }
QVariant videoBitRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoBitRate); }
QVariant videoCodec() const { return m_control->metaData(QtMultimedia::MetaData::VideoCodec); }
QVariant posterUrl() const { return m_control->metaData(QtMultimedia::MetaData::PosterUrl); }
QVariant chapterNumber() const { return m_control->metaData(QtMultimedia::MetaData::ChapterNumber); }
QVariant director() const { return m_control->metaData(QtMultimedia::MetaData::Director); }
QVariant leadPerformer() const { return m_control->metaData(QtMultimedia::MetaData::LeadPerformer); }
QVariant writer() const { return m_control->metaData(QtMultimedia::MetaData::Writer); }
return m_mediaObject->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
QVariant videoFrameRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoFrameRate); }
QVariant videoBitRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoBitRate); }
QVariant videoCodec() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoCodec); }
QVariant posterUrl() const { return m_mediaObject->metaData(QtMultimedia::MetaData::PosterUrl); }
QVariant chapterNumber() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ChapterNumber); }
QVariant director() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Director); }
QVariant leadPerformer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::LeadPerformer); }
QVariant writer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Writer); }
Q_SIGNALS:
void metaDataChanged();
private:
QMetaDataReaderControl *m_control;
QMediaObject *m_mediaObject;
};
QT_END_NAMESPACE

187
src/imports/multimedia/qdeclarativemediametadata_p_4.h Normal file
View File

@@ -0,0 +1,187 @@
/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QDECLARATIVEMEDIAMETADATA_P_4_H
#define QDECLARATIVEMEDIAMETADATA_P_4_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of other Qt classes. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <qmetadatareadercontrol.h>
#include <QtQml/qqml.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QDeclarativeMediaMetaData_4 : public QObject
{
Q_OBJECT
Q_PROPERTY(QVariant title READ title NOTIFY metaDataChanged)
Q_PROPERTY(QVariant subTitle READ subTitle NOTIFY metaDataChanged)
Q_PROPERTY(QVariant author READ author NOTIFY metaDataChanged)
Q_PROPERTY(QVariant comment READ comment NOTIFY metaDataChanged)
Q_PROPERTY(QVariant description READ description NOTIFY metaDataChanged)
Q_PROPERTY(QVariant category READ category NOTIFY metaDataChanged)
Q_PROPERTY(QVariant genre READ genre NOTIFY metaDataChanged)
Q_PROPERTY(QVariant year READ year NOTIFY metaDataChanged)
Q_PROPERTY(QVariant date READ date NOTIFY metaDataChanged)
Q_PROPERTY(QVariant userRating READ userRating NOTIFY metaDataChanged)
Q_PROPERTY(QVariant keywords READ keywords NOTIFY metaDataChanged)
Q_PROPERTY(QVariant language READ language NOTIFY metaDataChanged)
Q_PROPERTY(QVariant publisher READ publisher NOTIFY metaDataChanged)
Q_PROPERTY(QVariant copyright READ copyright NOTIFY metaDataChanged)
Q_PROPERTY(QVariant parentalRating READ parentalRating NOTIFY metaDataChanged)
Q_PROPERTY(QVariant ratingOrganization READ ratingOrganization NOTIFY metaDataChanged)
Q_PROPERTY(QVariant size READ size NOTIFY metaDataChanged)
Q_PROPERTY(QVariant mediaType READ mediaType NOTIFY metaDataChanged)
Q_PROPERTY(QVariant duration READ duration NOTIFY metaDataChanged)
Q_PROPERTY(QVariant audioBitRate READ audioBitRate NOTIFY metaDataChanged)
Q_PROPERTY(QVariant audioCodec READ audioCodec NOTIFY metaDataChanged)
Q_PROPERTY(QVariant averageLevel READ averageLevel NOTIFY metaDataChanged)
Q_PROPERTY(QVariant channelCount READ channelCount NOTIFY metaDataChanged)
Q_PROPERTY(QVariant peakValue READ peakValue NOTIFY metaDataChanged)
Q_PROPERTY(QVariant sampleRate READ sampleRate NOTIFY metaDataChanged)
Q_PROPERTY(QVariant albumTitle READ albumTitle NOTIFY metaDataChanged)
Q_PROPERTY(QVariant albumArtist READ albumArtist NOTIFY metaDataChanged)
Q_PROPERTY(QVariant contributingArtist READ contributingArtist NOTIFY metaDataChanged)
Q_PROPERTY(QVariant composer READ composer NOTIFY metaDataChanged)
Q_PROPERTY(QVariant conductor READ conductor NOTIFY metaDataChanged)
Q_PROPERTY(QVariant lyrics READ lyrics NOTIFY metaDataChanged)
Q_PROPERTY(QVariant mood READ mood NOTIFY metaDataChanged)
Q_PROPERTY(QVariant trackNumber READ trackNumber NOTIFY metaDataChanged)
Q_PROPERTY(QVariant trackCount READ trackCount NOTIFY metaDataChanged)
Q_PROPERTY(QVariant coverArtUrlSmall READ coverArtUrlSmall NOTIFY metaDataChanged)
Q_PROPERTY(QVariant coverArtUrlLarge READ coverArtUrlLarge NOTIFY metaDataChanged)
Q_PROPERTY(QVariant resolution READ resolution NOTIFY metaDataChanged)
Q_PROPERTY(QVariant pixelAspectRatio READ pixelAspectRatio NOTIFY metaDataChanged)
Q_PROPERTY(QVariant videoFrameRate READ videoFrameRate NOTIFY metaDataChanged)
Q_PROPERTY(QVariant videoBitRate READ videoBitRate NOTIFY metaDataChanged)
Q_PROPERTY(QVariant videoCodec READ videoCodec NOTIFY metaDataChanged)
Q_PROPERTY(QVariant posterUrl READ posterUrl NOTIFY metaDataChanged)
Q_PROPERTY(QVariant chapterNumber READ chapterNumber NOTIFY metaDataChanged)
Q_PROPERTY(QVariant director READ director NOTIFY metaDataChanged)
Q_PROPERTY(QVariant leadPerformer READ leadPerformer NOTIFY metaDataChanged)
Q_PROPERTY(QVariant writer READ writer NOTIFY metaDataChanged)
public:
QDeclarativeMediaMetaData_4(QMetaDataReaderControl *control, QObject *parent = 0)
: QObject(parent)
, m_control(control)
{
}
QVariant title() const { return m_control->metaData(QtMultimedia::MetaData::Title); }
QVariant subTitle() const { return m_control->metaData(QtMultimedia::MetaData::SubTitle); }
QVariant author() const { return m_control->metaData(QtMultimedia::MetaData::Author); }
QVariant comment() const { return m_control->metaData(QtMultimedia::MetaData::Comment); }
QVariant description() const { return m_control->metaData(QtMultimedia::MetaData::Description); }
QVariant category() const { return m_control->metaData(QtMultimedia::MetaData::Category); }
QVariant genre() const { return m_control->metaData(QtMultimedia::MetaData::Genre); }
QVariant year() const { return m_control->metaData(QtMultimedia::MetaData::Year); }
QVariant date() const { return m_control->metaData(QtMultimedia::MetaData::Date); }
QVariant userRating() const { return m_control->metaData(QtMultimedia::MetaData::UserRating); }
QVariant keywords() const { return m_control->metaData(QtMultimedia::MetaData::Keywords); }
QVariant language() const { return m_control->metaData(QtMultimedia::MetaData::Language); }
QVariant publisher() const { return m_control->metaData(QtMultimedia::MetaData::Publisher); }
QVariant copyright() const { return m_control->metaData(QtMultimedia::MetaData::Copyright); }
QVariant parentalRating() const { return m_control->metaData(QtMultimedia::MetaData::ParentalRating); }
QVariant ratingOrganization() const {
return m_control->metaData(QtMultimedia::MetaData::RatingOrganization); }
QVariant size() const { return m_control->metaData(QtMultimedia::MetaData::Size); }
QVariant mediaType() const { return m_control->metaData(QtMultimedia::MetaData::MediaType); }
QVariant duration() const { return m_control->metaData(QtMultimedia::MetaData::Duration); }
QVariant audioBitRate() const { return m_control->metaData(QtMultimedia::MetaData::AudioBitRate); }
QVariant audioCodec() const { return m_control->metaData(QtMultimedia::MetaData::AudioCodec); }
QVariant averageLevel() const { return m_control->metaData(QtMultimedia::MetaData::AverageLevel); }
QVariant channelCount() const { return m_control->metaData(QtMultimedia::MetaData::ChannelCount); }
QVariant peakValue() const { return m_control->metaData(QtMultimedia::MetaData::PeakValue); }
QVariant sampleRate() const { return m_control->metaData(QtMultimedia::MetaData::SampleRate); }
QVariant albumTitle() const { return m_control->metaData(QtMultimedia::MetaData::AlbumTitle); }
QVariant albumArtist() const { return m_control->metaData(QtMultimedia::MetaData::AlbumArtist); }
QVariant contributingArtist() const {
return m_control->metaData(QtMultimedia::MetaData::ContributingArtist); }
QVariant composer() const { return m_control->metaData(QtMultimedia::MetaData::Composer); }
QVariant conductor() const { return m_control->metaData(QtMultimedia::MetaData::Conductor); }
QVariant lyrics() const { return m_control->metaData(QtMultimedia::MetaData::Lyrics); }
QVariant mood() const { return m_control->metaData(QtMultimedia::MetaData::Mood); }
QVariant trackNumber() const { return m_control->metaData(QtMultimedia::MetaData::TrackNumber); }
QVariant trackCount() const { return m_control->metaData(QtMultimedia::MetaData::TrackCount); }
QVariant coverArtUrlSmall() const {
return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
QVariant coverArtUrlLarge() const {
return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
QVariant resolution() const { return m_control->metaData(QtMultimedia::MetaData::Resolution); }
QVariant pixelAspectRatio() const {
return m_control->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
QVariant videoFrameRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoFrameRate); }
QVariant videoBitRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoBitRate); }
QVariant videoCodec() const { return m_control->metaData(QtMultimedia::MetaData::VideoCodec); }
QVariant posterUrl() const { return m_control->metaData(QtMultimedia::MetaData::PosterUrl); }
QVariant chapterNumber() const { return m_control->metaData(QtMultimedia::MetaData::ChapterNumber); }
QVariant director() const { return m_control->metaData(QtMultimedia::MetaData::Director); }
QVariant leadPerformer() const { return m_control->metaData(QtMultimedia::MetaData::LeadPerformer); }
QVariant writer() const { return m_control->metaData(QtMultimedia::MetaData::Writer); }
Q_SIGNALS:
void metaDataChanged();
private:
QMetaDataReaderControl *m_control;
};
QT_END_NAMESPACE
QML_DECLARE_TYPE(QT_PREPEND_NAMESPACE(QDeclarativeMediaMetaData_4))
QT_END_HEADER
#endif // QDECLARATIVEMEDIAMETADATA_P_4_H

14
tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
View File

@@ -617,18 +617,18 @@ void tst_QDeclarativeAudio::position()
QCOMPARE(spy.count(), 1);
audio.setPosition(-5403);
QCOMPARE(audio.position(), -5403);
QCOMPARE(provider.playerControl()->position(), qint64(-5403));
QCOMPARE(audio.position(), 0);
QCOMPARE(provider.playerControl()->position(), qint64(0));
QCOMPARE(spy.count(), 2);
audio.setPosition(-5403);
QCOMPARE(audio.position(), -5403);
QCOMPARE(provider.playerControl()->position(), qint64(-5403));
QCOMPARE(audio.position(), 0);
QCOMPARE(provider.playerControl()->position(), qint64(0));
QCOMPARE(spy.count(), 2);
// Check the signal change signal is emitted if the change originates from the media service.
provider.playerControl()->setPosition(0);
QCOMPARE(audio.position(), 0);
provider.playerControl()->setPosition(450);
QCOMPARE(audio.position(), 450);
QCOMPARE(spy.count(), 3);
connect(&audio, SIGNAL(positionChanged()), &QTestEventLoop::instance(), SLOT(exitLoop()));
@@ -691,7 +691,7 @@ void tst_QDeclarativeAudio::muted()
audio.setMuted(false);
QCOMPARE(audio.isMuted(), false);
QCOMPARE(provider.playerControl()->isMuted(), false);
QCOMPARE(spy.count(), 3);
QCOMPARE(spy.count(), 2);
}
void tst_QDeclarativeAudio::bufferProgress()

2
tests/auto/unit/qdeclarativeaudio_4/qdeclarativeaudio_4.pro
View File

@@ -7,7 +7,7 @@ CONFIG += no_private_qt_headers_warning
HEADERS += \
$$QT.multimedia.sources/../imports/multimedia/qdeclarativeaudio_p_4.h \
$$QT.multimedia.sources/../imports/multimedia/qdeclarativemediabase_p_4.h \
$$QT.multimedia.sources/../imports/multimedia/qdeclarativemediametadata_p.h
$$QT.multimedia.sources/../imports/multimedia/qdeclarativemediametadata_p_4.h
SOURCES += \
tst_qdeclarativeaudio_4.cpp \

2
tests/auto/unit/qdeclarativeaudio_4/tst_qdeclarativeaudio_4.cpp
View File

@@ -44,7 +44,7 @@
#include <QtTest/QtTest>
#include "qdeclarativeaudio_p_4.h"
#include "qdeclarativemediametadata_p.h"
#include "qdeclarativemediametadata_p_4.h"
#include <qmediaplayercontrol.h>
#include <qmediaservice.h>