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

Rearrange the automatic tests.

Browse Source 
Split them into unit and integration tests.  Integration tests really
need to be run on the real platform (not in a VM etc) since they are
somewhat unstable or nonfunctional otherwise.

A few tests were previously broken by QUrl changes and they were repaired.
Removed one test since it was not providing a lot of value.

There are still a number of tests that rely on Q_AUTOTEST_EXPORT symbols.

Change-Id: Ic402abf0af946baa5945075d975b3f584f9ef280
Reviewed-by: Kalle Lehtonen <kalle.ju.lehtonen@nokia.com>
This commit is contained in:
Michael Goddard
2011-11-04 13:38:44 +10:00
committed by Qt by Nokia
parent 7dfb883df6
commit e3a8c165ea
190 changed files with 39 additions and 596 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
tests/auto/unit/qmultimedia_common/mock.pri Normal file
View File

@@ -0,0 +1,7 @@
INCLUDEPATH += $$PWD \
../../../src/multimedia \
HEADERS *= \
../qmultimedia_common/mockmediaserviceprovider.h \
../qmultimedia_common/mockmediaservice.h \
../qmultimedia_common/mockmediaobject.h

127
tests/auto/unit/qmultimedia_common/mockaudioencodercontrol.h Normal file
View File

@@ -0,0 +1,127 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKAUDIOENCODERCONTROL_H
#define MOCKAUDIOENCODERCONTROL_H
#include "qaudioencodercontrol.h"
class MockAudioEncoderControl : public QAudioEncoderControl
{
Q_OBJECT
public:
MockAudioEncoderControl(QObject *parent):
QAudioEncoderControl(parent)
{
m_codecs << "audio/pcm" << "audio/mpeg";
m_descriptions << "Pulse Code Modulation" << "mp3 format";
m_supportedEncodeOptions.insert("audio/pcm", QStringList());
m_supportedEncodeOptions.insert("audio/mpeg", QStringList() << "quality" << "bitrate" << "mode" << "vbr");
m_audioSettings.setCodec("audio/pcm");
m_audioSettings.setBitRate(128*1024);
m_audioSettings.setSampleRate(8000);
m_freqs << 8000 << 11025 << 22050 << 44100;
}
~MockAudioEncoderControl() {}
QAudioEncoderSettings audioSettings() const
{
return m_audioSettings;
}
void setAudioSettings(const QAudioEncoderSettings &settings)
{
m_audioSettings = settings;
}
QList<int> supportedChannelCounts(const QAudioEncoderSettings & = QAudioEncoderSettings()) const
{
QList<int> list; list << 1 << 2; return list;
}
QList<int> supportedSampleRates(const QAudioEncoderSettings & = QAudioEncoderSettings(), bool *continuous = 0) const
{
if (continuous)
*continuous = false;
return m_freqs;
}
QStringList supportedAudioCodecs() const
{
return m_codecs;
}
QString codecDescription(const QString &codecName) const
{
return m_descriptions.value(m_codecs.indexOf(codecName));
}
QStringList supportedEncodingOptions(const QString &codec) const
{
return m_supportedEncodeOptions.value(codec);
}
QVariant encodingOption(const QString &codec, const QString &name) const
{
return m_encodeOptions[codec].value(name);
}
void setEncodingOption(const QString &codec, const QString &name, const QVariant &value)
{
m_encodeOptions[codec][name] = value;
}
private:
QAudioEncoderSettings m_audioSettings;
QStringList m_codecs;
QStringList m_descriptions;
QList<int> m_freqs;
QMap<QString, QStringList> m_supportedEncodeOptions;
QMap<QString, QMap<QString, QVariant> > m_encodeOptions;
};
#endif // MOCKAUDIOENCODERCONTROL_H

117
tests/auto/unit/qmultimedia_common/mockaudioendpointselector.h Normal file
View File

@@ -0,0 +1,117 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKAUDIOENDPOINTSELECTOR_H
#define MOCKAUDIOENDPOINTSELECTOR_H
#include "qaudioendpointselector.h"
class MockAudioEndpointSelector : public QAudioEndpointSelector
{
Q_OBJECT
public:
MockAudioEndpointSelector(QObject *parent):
QAudioEndpointSelector(parent)
{
m_names << "device1" << "device2" << "device3";
m_descriptions << "dev1 comment" << "dev2 comment" << "dev3 comment";
m_audioInput = "device1";
emit availableEndpointsChanged();
}
~MockAudioEndpointSelector() {}
QList<QString> availableEndpoints() const
{
return m_names;
}
QString endpointDescription(const QString& name) const
{
QString desc;
for (int i = 0; i < m_names.count(); i++) {
if (m_names.at(i).compare(name) == 0) {
desc = m_descriptions.at(i);
break;
}
}
return desc;
}
QString defaultEndpoint() const
{
return m_names.at(0);
}
QString activeEndpoint() const
{
return m_audioInput;
}
public Q_SLOTS:
void setActiveEndpoint(const QString& name)
{
m_audioInput = name;
emit activeEndpointChanged(name);
}
void addEndpoints()
{
m_names << "device4";
emit availableEndpointsChanged();
}
void removeEndpoints()
{
m_names.clear();
emit availableEndpointsChanged();
}
private:
QString m_audioInput;
QList<QString> m_names;
QList<QString> m_descriptions;
};
#endif // MOCKAUDIOENDPOINTSELECTOR_H

22
tests/auto/unit/qmultimedia_common/mockcamera.pri Normal file
View File

@@ -0,0 +1,22 @@
# Camera related mock backend files
INCLUDEPATH += $$PWD \
../../../src/multimedia \
../../../src/multimedia/video \
../../../src/multimedia/camera
HEADERS *= \
../qmultimedia_common/mockcameraservice.h \
../qmultimedia_common/mockcameraflashcontrol.h \
../qmultimedia_common/mockcameralockscontrol.h \
../qmultimedia_common/mockcamerafocuscontrol.h \
../qmultimedia_common/mockcameraimageprocessingcontrol.h \
../qmultimedia_common/mockcameraimagecapturecontrol.h \
../qmultimedia_common/mockcameraexposurecontrol.h \
../qmultimedia_common/mockcameracapturedestinationcontrol.h \
../qmultimedia_common/mockcameracapturebuffercontrol.h \
../qmultimedia_common/mockimageencodercontrol.h \
../qmultimedia_common/mockcameracontrol.h \
include(mockvideo.pri)

83
tests/auto/unit/qmultimedia_common/mockcameracapturebuffercontrol.h Normal file
View File

@@ -0,0 +1,83 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERACAPTUREBUFFERCONTROL_H
#define MOCKCAMERACAPTUREBUFFERCONTROL_H
#include "qcameracapturebufferformatcontrol.h"
class MockCaptureBufferFormatControl : public QCameraCaptureBufferFormatControl
{
Q_OBJECT
public:
MockCaptureBufferFormatControl(QObject *parent = 0):
QCameraCaptureBufferFormatControl(parent),
m_format(QVideoFrame::Format_Jpeg)
{
}
QList<QVideoFrame::PixelFormat> supportedBufferFormats() const
{
return QList<QVideoFrame::PixelFormat>()
<< QVideoFrame::Format_Jpeg
<< QVideoFrame::Format_RGB32
<< QVideoFrame::Format_AdobeDng;
}
QVideoFrame::PixelFormat bufferFormat() const
{
return m_format;
}
void setBufferFormat(QVideoFrame::PixelFormat format)
{
if (format != m_format && supportedBufferFormats().contains(format)) {
m_format = format;
emit bufferFormatChanged(m_format);
}
}
private:
QVideoFrame::PixelFormat m_format;
};
#endif // MOCKCAMERACAPTUREBUFFERCONTROL_H

80
tests/auto/unit/qmultimedia_common/mockcameracapturedestinationcontrol.h Normal file
View File

@@ -0,0 +1,80 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERACAPTUREDESTINATIONCONTROL_H
#define MOCKCAMERACAPTUREDESTINATIONCONTROL_H
#include "qcameracapturedestinationcontrol.h"
class MockCaptureDestinationControl : public QCameraCaptureDestinationControl
{
Q_OBJECT
public:
MockCaptureDestinationControl(QObject *parent = 0):
QCameraCaptureDestinationControl(parent),
m_destination(QCameraImageCapture::CaptureToFile)
{
}
bool isCaptureDestinationSupported(QCameraImageCapture::CaptureDestinations destination) const
{
return destination == QCameraImageCapture::CaptureToBuffer ||
destination == QCameraImageCapture::CaptureToFile;
}
QCameraImageCapture::CaptureDestinations captureDestination() const
{
return m_destination;
}
void setCaptureDestination(QCameraImageCapture::CaptureDestinations destination)
{
if (isCaptureDestinationSupported(destination) && destination != m_destination) {
m_destination = destination;
emit captureDestinationChanged(m_destination);
}
}
private:
QCameraImageCapture::CaptureDestinations m_destination;
};
#endif // MOCKCAMERACAPTUREDESTINATIONCONTROL_H

145
tests/auto/unit/qmultimedia_common/mockcameracontrol.h Normal file
View File

@@ -0,0 +1,145 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERACONTROL_H
#define MOCKCAMERACONTROL_H
#include "qcameracontrol.h"
class MockCameraControl : public QCameraControl
{
friend class MockCaptureControl;
Q_OBJECT
public:
MockCameraControl(QObject *parent = 0):
QCameraControl(parent),
m_state(QCamera::UnloadedState),
m_captureMode(QCamera::CaptureStillImage),
m_status(QCamera::UnloadedStatus),
m_propertyChangesSupported(false)
{
}
~MockCameraControl() {}
void start() { m_state = QCamera::ActiveState; }
virtual void stop() { m_state = QCamera::UnloadedState; }
QCamera::State state() const { return m_state; }
void setState(QCamera::State state) {
if (m_state != state) {
m_state = state;
switch (state) {
case QCamera::UnloadedState:
m_status = QCamera::UnloadedStatus;
break;
case QCamera::LoadedState:
m_status = QCamera::LoadedStatus;
break;
case QCamera::ActiveState:
m_status = QCamera::ActiveStatus;
break;
default:
emit error(QCamera::NotSupportedFeatureError, "State not supported.");
return;
}
emit stateChanged(m_state);
emit statusChanged(m_status);
}
}
QCamera::Status status() const { return m_status; }
QCamera::CaptureMode captureMode() const { return m_captureMode; }
void setCaptureMode(QCamera::CaptureMode mode)
{
if (m_captureMode != mode) {
if (m_state == QCamera::ActiveState && !m_propertyChangesSupported)
return;
m_captureMode = mode;
emit captureModeChanged(mode);
}
}
bool isCaptureModeSupported(QCamera::CaptureMode mode) const
{
return mode == QCamera::CaptureStillImage || mode == QCamera::CaptureVideo;
}
QCamera::LockTypes supportedLocks() const
{
return QCamera::LockExposure | QCamera::LockFocus | QCamera::LockWhiteBalance;
}
bool canChangeProperty(PropertyChangeType changeType, QCamera::Status status) const
{
Q_UNUSED(status);
if (changeType == QCameraControl::ImageEncodingSettings && m_captureMode == QCamera::CaptureVideo)
return true;
else if (changeType== QCameraControl::VideoEncodingSettings)
return true;
else
return m_propertyChangesSupported;
}
/* helper method to emit the signal error */
void setError(QCamera::Error err, QString errorString)
{
emit error(err, errorString);
}
/* helper method to emit the signal statusChaged */
void setStatus(QCamera::Status newStatus)
{
m_status = newStatus;
emit statusChanged(newStatus);
}
QCamera::State m_state;
QCamera::CaptureMode m_captureMode;
QCamera::Status m_status;
bool m_propertyChangesSupported;
};
#endif // MOCKCAMERACONTROL_H

282
tests/auto/unit/qmultimedia_common/mockcameraexposurecontrol.h Normal file
View File

@@ -0,0 +1,282 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERAEXPOSURECONTROL_H
#define MOCKCAMERAEXPOSURECONTROL_H
#include "qcameraexposurecontrol.h"
class MockCameraExposureControl : public QCameraExposureControl
{
Q_OBJECT
public:
MockCameraExposureControl(QObject *parent = 0):
QCameraExposureControl(parent),
m_aperture(2.8),
m_shutterSpeed(0.01),
m_isoSensitivity(100),
m_meteringMode(QCameraExposure::MeteringMatrix),
m_exposureCompensation(0),
m_exposureMode(QCameraExposure::ExposureAuto),
m_flashMode(QCameraExposure::FlashAuto)
{
m_isoRanges << 100 << 200 << 400 << 800;
m_apertureRanges << 2.8 << 4.0 << 5.6 << 8.0 << 11.0 << 16.0;
m_shutterRanges << 0.001 << 0.01 << 0.1 << 1.0;
m_exposureRanges << -2.0 << 2.0;
}
~MockCameraExposureControl() {}
QCameraExposure::FlashModes flashMode() const {return m_flashMode;}
void setFlashMode(QCameraExposure::FlashModes mode)
{
if (isFlashModeSupported(mode)) {
m_flashMode = mode;
}
}
bool isFlashModeSupported(QCameraExposure::FlashModes mode) const
{
return mode & (QCameraExposure::FlashAuto | QCameraExposure::FlashOff | QCameraExposure::FlashOn);
}
bool isFlashReady() const { return true;}
QCameraExposure::ExposureMode exposureMode() const { return m_exposureMode; }
void setExposureMode(QCameraExposure::ExposureMode mode)
{
if (isExposureModeSupported(mode))
m_exposureMode = mode;
}
//Setting the Exposure Mode Supported Enum values
bool isExposureModeSupported(QCameraExposure::ExposureMode mode) const
{
return ( mode == QCameraExposure::ExposureAuto || mode == QCameraExposure::ExposureManual || mode == QCameraExposure::ExposureBacklight ||
mode == QCameraExposure::ExposureNight || mode == QCameraExposure::ExposureSpotlight ||mode == QCameraExposure::ExposureSports ||
mode == QCameraExposure::ExposureSnow || mode == QCameraExposure:: ExposureLargeAperture ||mode == QCameraExposure::ExposureSmallAperture ||
mode == QCameraExposure::ExposurePortrait || mode == QCameraExposure::ExposureModeVendor ||mode == QCameraExposure::ExposureBeach );
}
bool isParameterSupported(ExposureParameter parameter) const
{
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
case QCameraExposureControl::ISO:
case QCameraExposureControl::Aperture:
case QCameraExposureControl::ShutterSpeed:
return true;
default:
return false;
}
}
QVariant exposureParameter(ExposureParameter parameter) const
{
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
return QVariant(m_exposureCompensation);
case QCameraExposureControl::ISO:
return QVariant(m_isoSensitivity);
case QCameraExposureControl::Aperture:
return QVariant(m_aperture);
case QCameraExposureControl::ShutterSpeed:
return QVariant(m_shutterSpeed);
default:
return QVariant();
}
}
QVariantList supportedParameterRange(ExposureParameter parameter) const
{
QVariantList res;
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
return m_exposureRanges;
case QCameraExposureControl::ISO:
return m_isoRanges;
case QCameraExposureControl::Aperture:
return m_apertureRanges;
case QCameraExposureControl::ShutterSpeed:
return m_shutterRanges;
default:
break;
}
return res;
}
ParameterFlags exposureParameterFlags(ExposureParameter parameter) const
{
ParameterFlags res = 0;
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
case QCameraExposureControl::Aperture:
case QCameraExposureControl::ShutterSpeed:
res |= ContinuousRange;
default:
break;
}
return res;
}
// Added exposureParameterChanged and exposureParameterRangeChanged signal
bool setExposureParameter(ExposureParameter parameter, const QVariant& value)
{
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
{
m_res.clear();
m_res << -4.0 << 4.0;
qreal exposureCompensationlocal = qBound<qreal>(-2.0, value.toReal(), 2.0);
if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
m_exposureCompensation = exposureCompensationlocal;
emit exposureParameterChanged(parameter);
}
if (m_exposureRanges.last().toReal() != m_res.last().toReal()) {
m_exposureRanges.clear();
m_exposureRanges = m_res;
emit exposureParameterRangeChanged(parameter);
}
}
break;
case QCameraExposureControl::ISO:
{
m_res.clear();
m_res << 20 << 50;
qreal exposureCompensationlocal = 100*qRound(qBound(100, value.toInt(), 800)/100.0);
if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
m_isoSensitivity = exposureCompensationlocal;
emit exposureParameterChanged(parameter);
}
if (m_isoRanges.last().toInt() != m_res.last().toInt()) {
m_isoRanges.clear();
m_isoRanges = m_res;
emit exposureParameterRangeChanged(parameter);
}
}
break;
case QCameraExposureControl::Aperture:
{
m_res.clear();
m_res << 12.0 << 18.0 << 20.0;
qreal exposureCompensationlocal = qBound<qreal>(2.8, value.toReal(), 16.0);
if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
m_aperture = exposureCompensationlocal;
emit exposureParameterChanged(parameter);
}
if (m_apertureRanges.last().toReal() != m_res.last().toReal()) {
m_apertureRanges.clear();
m_apertureRanges = m_res;
emit exposureParameterRangeChanged(parameter);
}
}
break;
case QCameraExposureControl::ShutterSpeed:
{
m_res.clear();
m_res << 0.12 << 1.0 << 2.0;
qreal exposureCompensationlocal = qBound<qreal>(0.001, value.toReal(), 1.0);
if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
m_shutterSpeed = exposureCompensationlocal;
emit exposureParameterChanged(parameter);
}
if (m_shutterRanges.last().toReal() != m_res.last().toReal()) {
m_shutterRanges.clear();
m_shutterRanges = m_res;
emit exposureParameterRangeChanged(parameter);
}
}
break;
default:
return false;
}
emit flashReady(true); // depends on Flashcontrol
return true;
}
QString extendedParameterName(ExposureParameter)
{
return QString();
}
QCameraExposure::MeteringMode meteringMode() const
{
return m_meteringMode;
}
void setMeteringMode(QCameraExposure::MeteringMode mode)
{
if (isMeteringModeSupported(mode))
m_meteringMode = mode;
}
//Setting the values for metering mode
bool isMeteringModeSupported(QCameraExposure::MeteringMode mode) const
{
return mode == QCameraExposure::MeteringAverage
|| mode == QCameraExposure::MeteringMatrix
|| mode == QCameraExposure::MeteringAverage
|| mode ==QCameraExposure::MeteringSpot;
}
private:
qreal m_aperture;
qreal m_shutterSpeed;
int m_isoSensitivity;
QCameraExposure::MeteringMode m_meteringMode;
qreal m_exposureCompensation;
QCameraExposure::ExposureMode m_exposureMode;
QCameraExposure::FlashModes m_flashMode;
QVariantList m_isoRanges,m_apertureRanges, m_shutterRanges, m_exposureRanges, m_res;
};
#endif // MOCKCAMERAEXPOSURECONTROL_H

89
tests/auto/unit/qmultimedia_common/mockcameraflashcontrol.h Normal file
View File

@@ -0,0 +1,89 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERAFLASHCONTROL_H
#define MOCKCAMERAFLASHCONTROL_H
#include "qcameraflashcontrol.h"
class MockCameraFlashControl : public QCameraFlashControl
{
Q_OBJECT
public:
MockCameraFlashControl(QObject *parent = 0):
QCameraFlashControl(parent),
m_flashMode(QCameraExposure::FlashAuto)
{
}
~MockCameraFlashControl() {}
QCameraExposure::FlashModes flashMode() const
{
return m_flashMode;
}
void setFlashMode(QCameraExposure::FlashModes mode)
{
if (isFlashModeSupported(mode)) {
m_flashMode = mode;
}
emit flashReady(true);
}
//Setting the values for Flash mode
bool isFlashModeSupported(QCameraExposure::FlashModes mode) const
{
return (mode || (QCameraExposure::FlashAuto | QCameraExposure::FlashOff | QCameraExposure::FlashOn |
QCameraExposure::FlashFill |QCameraExposure::FlashTorch |QCameraExposure::FlashSlowSyncFrontCurtain |
QCameraExposure::FlashRedEyeReduction));
}
bool isFlashReady() const
{
return true;
}
private:
QCameraExposure::FlashModes m_flashMode;
};
#endif // MOCKCAMERAFLASHCONTROL_H

199
tests/auto/unit/qmultimedia_common/mockcamerafocuscontrol.h Normal file
View File

@@ -0,0 +1,199 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERAFOCUSCONTROL_H
#define MOCKCAMERAFOCUSCONTROL_H
#include "qcamerafocuscontrol.h"
#include "qcamerafocus.h"
class MockCameraFocusControl : public QCameraFocusControl
{
Q_OBJECT
public:
MockCameraFocusControl(QObject *parent = 0):
QCameraFocusControl(parent),
m_opticalZoom(1.0),
m_digitalZoom(1.0),
m_focusMode(QCameraFocus::AutoFocus),
m_focusPointMode(QCameraFocus::FocusPointAuto),
m_focusPoint(0.5, 0.5),
m_maxOpticalZoom(3.0),
m_maxDigitalZoom(4.0)
{
m_zones << QCameraFocusZone(QRectF(0.45, 0.45, 0.1, 0.1));
}
~MockCameraFocusControl() {}
QCameraFocus::FocusMode focusMode() const
{
return m_focusMode;
}
void setFocusMode(QCameraFocus::FocusMode mode)
{
if (isFocusModeSupported(mode))
m_focusMode = mode;
}
bool isFocusModeSupported(QCameraFocus::FocusMode mode) const
{
return mode == QCameraFocus::AutoFocus || mode == QCameraFocus::ContinuousFocus;
}
qreal maximumOpticalZoom() const
{
return m_maxOpticalZoom;
}
qreal maximumDigitalZoom() const
{
return m_maxDigitalZoom;
}
qreal opticalZoom() const
{
return m_opticalZoom;
}
qreal digitalZoom() const
{
return m_digitalZoom;
}
void zoomTo(qreal optical, qreal digital)
{
optical = qBound<qreal>(1.0, optical, maximumOpticalZoom());
digital = qBound<qreal>(1.0, digital, maximumDigitalZoom());
if (!qFuzzyCompare(digital, m_digitalZoom)) {
m_digitalZoom = digital;
emit digitalZoomChanged(m_digitalZoom);
}
if (!qFuzzyCompare(optical, m_opticalZoom)) {
m_opticalZoom = optical;
emit opticalZoomChanged(m_opticalZoom);
}
maxOpticalDigitalZoomChange(4.0, 5.0);
focusZonesChange(0.50, 0.50, 0.3, 0.3);
}
QCameraFocus::FocusPointMode focusPointMode() const
{
return m_focusPointMode;
}
void setFocusPointMode(QCameraFocus::FocusPointMode mode)
{
if (isFocusPointModeSupported(mode))
m_focusPointMode = mode;
}
bool isFocusPointModeSupported(QCameraFocus::FocusPointMode mode) const
{
switch (mode) {
case QCameraFocus::FocusPointAuto:
case QCameraFocus::FocusPointCenter:
case QCameraFocus::FocusPointCustom:
return true;
default:
return false;
}
}
QPointF customFocusPoint() const
{
return m_focusPoint;
}
void setCustomFocusPoint(const QPointF &point)
{
m_focusPoint = point;
}
QCameraFocusZoneList focusZones() const
{
return m_zones;
}
// helper function to emit maximum Optical and Digital Zoom Changed signals
void maxOpticalDigitalZoomChange(qreal maxOptical, qreal maxDigital)
{
if (maxOptical != m_maxOpticalZoom) {
m_maxOpticalZoom = maxOptical;
emit maximumOpticalZoomChanged(m_maxOpticalZoom);
}
if (maxDigital != m_maxDigitalZoom) {
m_maxDigitalZoom = maxDigital;
emit maximumDigitalZoomChanged(m_maxDigitalZoom);
}
}
// helper function to emit Focus Zones Changed signals
void focusZonesChange(qreal left, qreal top, qreal width, qreal height)
{
QCameraFocusZone myZone(QRectF(left, top, width, height));
if (m_zones.last().area() != myZone.area()) {
m_zones.clear();
m_zones << myZone;
emit focusZonesChanged();
}
}
private:
qreal m_opticalZoom;
qreal m_digitalZoom;
QCameraFocus::FocusMode m_focusMode;
QCameraFocus::FocusPointMode m_focusPointMode;
QPointF m_focusPoint;
// to emit maximum Optical and Digital Zoom Changed signals
qreal m_maxOpticalZoom;
qreal m_maxDigitalZoom;
// to emit focus zone changed signal
QCameraFocusZoneList m_zones;
};
#endif // MOCKCAMERAFOCUSCONTROL_H

130
tests/auto/unit/qmultimedia_common/mockcameraimagecapturecontrol.h Normal file
View File

@@ -0,0 +1,130 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERACAPTURECONTROL_H
#define MOCKCAMERACAPTURECONTROL_H
#include <QDateTime>
#include <QTimer>
#include "qcameraimagecapturecontrol.h"
#include "qcameracontrol.h"
#include "mockcameracontrol.h"
class MockCaptureControl : public QCameraImageCaptureControl
{
Q_OBJECT
public:
MockCaptureControl(MockCameraControl *cameraControl, QObject *parent = 0)
: QCameraImageCaptureControl(parent), m_cameraControl(cameraControl), m_captureRequest(0), m_ready(true), m_captureCanceled(false)
{
}
~MockCaptureControl()
{
}
QCameraImageCapture::DriveMode driveMode() const { return QCameraImageCapture::SingleImageCapture; }
void setDriveMode(QCameraImageCapture::DriveMode) {}
bool isReadyForCapture() const { return m_ready && m_cameraControl->state() == QCamera::ActiveState; }
int capture(const QString &fileName)
{
if (isReadyForCapture()) {
m_fileName = fileName;
m_captureRequest++;
emit readyForCaptureChanged(m_ready = false);
QTimer::singleShot(5, this, SLOT(captured()));
return m_captureRequest;
} else {
emit error(-1, QCameraImageCapture::NotReadyError,
QLatin1String("Could not capture in stopped state"));
}
return -1;
}
void cancelCapture()
{
m_captureCanceled = true;
}
private Q_SLOTS:
void captured()
{
if (!m_captureCanceled) {
emit imageCaptured(m_captureRequest, QImage());
emit imageMetadataAvailable(m_captureRequest,
QtMultimedia::FocalLengthIn35mmFilm,
QVariant(50));
emit imageMetadataAvailable(m_captureRequest,
QtMultimedia::DateTimeOriginal,
QVariant(QDateTime::currentDateTime()));
emit imageMetadataAvailable(m_captureRequest,
QLatin1String("Answer to the Ultimate Question of Life, the Universe, and Everything"),
QVariant(42));
}
if (!m_ready)
{
emit readyForCaptureChanged(m_ready = true);
emit imageExposed(m_captureRequest);
}
if (!m_captureCanceled)
emit imageSaved(m_captureRequest, m_fileName);
m_captureCanceled = false;
}
private:
MockCameraControl *m_cameraControl;
QString m_fileName;
int m_captureRequest;
bool m_ready;
bool m_captureCanceled;
};
#endif // MOCKCAMERACAPTURECONTROL_H

156
tests/auto/unit/qmultimedia_common/mockcameraimageprocessingcontrol.h Normal file
View File

@@ -0,0 +1,156 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERAIMAGEPROCESSINGCONTROL_H
#define MOCKCAMERAIMAGEPROCESSINGCONTROL_H
#include "qcameraimageprocessingcontrol.h"
class MockImageProcessingControl : public QCameraImageProcessingControl
{
Q_OBJECT
public:
MockImageProcessingControl(QObject *parent = 0)
: QCameraImageProcessingControl(parent)
{
m_supportedWhiteBalance.insert(QCameraImageProcessing::WhiteBalanceAuto);
}
QCameraImageProcessing::WhiteBalanceMode whiteBalanceMode() const
{
return m_whiteBalanceMode;
}
void setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode)
{
m_whiteBalanceMode = mode;
}
bool isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const
{
return m_supportedWhiteBalance.contains(mode);
}
void setSupportedWhiteBalanceModes(QSet<QCameraImageProcessing::WhiteBalanceMode> modes)
{
m_supportedWhiteBalance = modes;
}
bool isProcessingParameterSupported(ProcessingParameter parameter) const
{
//return parameter == Contrast || parameter == Sharpening || parameter == ColorTemperature;
switch (parameter)
{
case Contrast:
case Brightness:
case Sharpening:
case Saturation:
case Denoising:
case ColorTemperature:
case ExtendedParameter:
return true;
default :
return false;
}
}
QVariant processingParameter(ProcessingParameter parameter) const
{
switch (parameter) {
case Contrast:
return m_contrast;
case Saturation:
return m_saturation;
case Brightness:
return m_brightness;
case Sharpening:
return m_sharpeningLevel;
case Denoising:
return m_denoising;
case ColorTemperature:
return m_manualWhiteBalance;
case ExtendedParameter:
return m_extendedParameter;
default:
return QVariant();
}
}
void setProcessingParameter(ProcessingParameter parameter, QVariant value)
{
switch (parameter) {
case Contrast:
m_contrast = value;
break;
case Saturation:
m_saturation = value;
break;
case Brightness:
m_brightness = value;
break;
case Sharpening:
m_sharpeningLevel = value;
break;
case Denoising:
m_denoising = value;
break;
case ColorTemperature:
m_manualWhiteBalance = value;
break;
case ExtendedParameter:
m_extendedParameter = value;
break;
default:
break;
}
}
private:
QCameraImageProcessing::WhiteBalanceMode m_whiteBalanceMode;
QSet<QCameraImageProcessing::WhiteBalanceMode> m_supportedWhiteBalance;
QVariant m_manualWhiteBalance;
QVariant m_contrast;
QVariant m_sharpeningLevel;
QVariant m_saturation;
QVariant m_brightness;
QVariant m_denoising;
QVariant m_extendedParameter;
};
#endif // MOCKCAMERAIMAGEPROCESSINGCONTROL_H

144
tests/auto/unit/qmultimedia_common/mockcameralockscontrol.h Normal file
View File

@@ -0,0 +1,144 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERALOCKCONTROL_H
#define MOCKCAMERALOCKCONTROL_H
#include <QTimer>
#include "qcameralockscontrol.h"
class MockCameraLocksControl : public QCameraLocksControl
{
Q_OBJECT
public:
MockCameraLocksControl(QObject *parent = 0):
QCameraLocksControl(parent),
m_focusLock(QCamera::Unlocked),
m_exposureLock(QCamera::Unlocked)
{
}
~MockCameraLocksControl() {}
QCamera::LockTypes supportedLocks() const
{
return QCamera::LockExposure | QCamera::LockFocus;
}
QCamera::LockStatus lockStatus(QCamera::LockType lock) const
{
switch (lock) {
case QCamera::LockExposure:
return m_exposureLock;
case QCamera::LockFocus:
return m_focusLock;
default:
return QCamera::Unlocked;
}
}
void searchAndLock(QCamera::LockTypes locks)
{
if (locks & QCamera::LockExposure) {
QCamera::LockStatus newStatus = locks & QCamera::LockFocus ? QCamera::Searching : QCamera::Locked;
if (newStatus != m_exposureLock)
emit lockStatusChanged(QCamera::LockExposure,
m_exposureLock = newStatus,
QCamera::UserRequest);
}
if (locks & QCamera::LockFocus) {
emit lockStatusChanged(QCamera::LockFocus,
m_focusLock = QCamera::Searching,
QCamera::UserRequest);
QTimer::singleShot(5, this, SLOT(focused()));
}
}
void unlock(QCamera::LockTypes locks) {
if (locks & QCamera::LockFocus && m_focusLock != QCamera::Unlocked) {
emit lockStatusChanged(QCamera::LockFocus,
m_focusLock = QCamera::Unlocked,
QCamera::UserRequest);
}
if (locks & QCamera::LockExposure && m_exposureLock != QCamera::Unlocked) {
emit lockStatusChanged(QCamera::LockExposure,
m_exposureLock = QCamera::Unlocked,
QCamera::UserRequest);
}
}
/* helper method to emit the signal with LockChangeReason */
void setLockChangeReason (QCamera::LockChangeReason lockChangeReason)
{
emit lockStatusChanged(QCamera::NoLock,
QCamera::Unlocked,
lockChangeReason);
}
private slots:
void focused()
{
if (m_focusLock == QCamera::Searching) {
emit lockStatusChanged(QCamera::LockFocus,
m_focusLock = QCamera::Locked,
QCamera::UserRequest);
}
if (m_exposureLock == QCamera::Searching) {
emit lockStatusChanged(QCamera::LockExposure,
m_exposureLock = QCamera::Locked,
QCamera::UserRequest);
}
}
private:
QCamera::LockStatus m_focusLock;
QCamera::LockStatus m_exposureLock;
};
#endif // MOCKCAMERALOCKCONTROL_H

196
tests/auto/unit/qmultimedia_common/mockcameraservice.h Normal file
View File

@@ -0,0 +1,196 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKCAMERASERVICE_H
#define MOCKCAMERASERVICE_H
#include "qmediaservice.h"
#include "../qmultimedia_common/mockcameraflashcontrol.h"
#include "../qmultimedia_common/mockcameralockscontrol.h"
#include "../qmultimedia_common/mockcamerafocuscontrol.h"
#include "../qmultimedia_common/mockcameraimageprocessingcontrol.h"
#include "../qmultimedia_common/mockcameraimagecapturecontrol.h"
#include "../qmultimedia_common/mockcameraexposurecontrol.h"
#include "../qmultimedia_common/mockcameracapturedestinationcontrol.h"
#include "../qmultimedia_common/mockcameracapturebuffercontrol.h"
#include "../qmultimedia_common/mockimageencodercontrol.h"
#include "../qmultimedia_common/mockcameracontrol.h"
#include "../qmultimedia_common/mockvideosurface.h"
#include "../qmultimedia_common/mockvideorenderercontrol.h"
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
#include "../qmultimedia_common/mockvideowindowcontrol.h"
#endif
class MockSimpleCameraService : public QMediaService
{
Q_OBJECT
public:
MockSimpleCameraService(): QMediaService(0)
{
mockControl = new MockCameraControl(this);
}
~MockSimpleCameraService()
{
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QCameraControl_iid) == 0)
return mockControl;
return 0;
}
void releaseControl(QMediaControl*) {}
MockCameraControl *mockControl;
};
class MockCameraService : public QMediaService
{
Q_OBJECT
public:
MockCameraService(): QMediaService(0)
{
mockControl = new MockCameraControl(this);
mockLocksControl = new MockCameraLocksControl(this);
mockExposureControl = new MockCameraExposureControl(this);
mockFlashControl = new MockCameraFlashControl(this);
mockFocusControl = new MockCameraFocusControl(this);
mockCaptureControl = new MockCaptureControl(mockControl, this);
mockCaptureBufferControl = new MockCaptureBufferFormatControl(this);
mockCaptureDestinationControl = new MockCaptureDestinationControl(this);
mockImageProcessingControl = new MockImageProcessingControl(this);
mockImageEncoderControl = new MockImageEncoderControl(this);
rendererControl = new MockVideoRendererControl(this);
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
windowControl = new MockVideoWindowControl(this);
#endif
rendererRef = 0;
windowRef = 0;
}
~MockCameraService()
{
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QCameraControl_iid) == 0)
return mockControl;
if (qstrcmp(iid, QCameraLocksControl_iid) == 0)
return mockLocksControl;
if (qstrcmp(iid, QCameraExposureControl_iid) == 0)
return mockExposureControl;
if (qstrcmp(iid, QCameraFlashControl_iid) == 0)
return mockFlashControl;
if (qstrcmp(iid, QCameraFocusControl_iid) == 0)
return mockFocusControl;
if (qstrcmp(iid, QCameraImageCaptureControl_iid) == 0)
return mockCaptureControl;
if (qstrcmp(iid, QCameraCaptureBufferFormatControl_iid) == 0)
return mockCaptureBufferControl;
if (qstrcmp(iid, QCameraCaptureDestinationControl_iid) == 0)
return mockCaptureDestinationControl;
if (qstrcmp(iid, QCameraImageProcessingControl_iid) == 0)
return mockImageProcessingControl;
if (qstrcmp(iid, QImageEncoderControl_iid) == 0)
return mockImageEncoderControl;
if (qstrcmp(iid, QVideoRendererControl_iid) == 0) {
if (rendererRef == 0) {
rendererRef += 1;
return rendererControl;
}
}
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
if (qstrcmp(iid, QVideoWindowControl_iid) == 0) {
if (windowRef == 0) {
windowRef += 1;
return windowControl;
}
}
#endif
return 0;
}
void releaseControl(QMediaControl *control)
{
if (control == rendererControl)
rendererRef -= 1;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
if (control == windowControl)
windowRef -= 1;
#endif
}
MockCameraControl *mockControl;
MockCameraLocksControl *mockLocksControl;
MockCaptureControl *mockCaptureControl;
MockCaptureBufferFormatControl *mockCaptureBufferControl;
MockCaptureDestinationControl *mockCaptureDestinationControl;
MockCameraExposureControl *mockExposureControl;
MockCameraFlashControl *mockFlashControl;
MockCameraFocusControl *mockFocusControl;
MockImageProcessingControl *mockImageProcessingControl;
MockImageEncoderControl *mockImageEncoderControl;
MockVideoRendererControl *rendererControl;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
MockVideoWindowControl *windowControl;
#endif
int rendererRef;
int windowRef;
};
#endif // MOCKCAMERASERVICE_H

7
tests/auto/unit/qmultimedia_common/mockcontainer.pri Normal file
View File

@@ -0,0 +1,7 @@
INCLUDEPATH *= $$PWD \
../../../src/multimedia \
HEADERS *= \
../qmultimedia_common/mockmediacontainercontrol.h \
../qmultimedia_common/mockmetadatawritercontrol.h \
../qmultimedia_common/mockmetadatareadercontrol.h

103
tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h Normal file
View File

@@ -0,0 +1,103 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKIMAGEENCODERCONTROL_H
#define MOCKIMAGEENCODERCONTROL_H
#include "qimageencodercontrol.h"
class MockImageEncoderControl : public QImageEncoderControl
{
public:
MockImageEncoderControl(QObject *parent = 0)
: QImageEncoderControl(parent)
{
m_settings = QImageEncoderSettings();
}
QList<QSize> supportedResolutions(const QImageEncoderSettings & settings = QImageEncoderSettings(),
bool *continuous = 0) const
{
if (continuous)
*continuous = true;
QList<QSize> resolutions;
if (settings.resolution().isValid()) {
if (settings.resolution() == QSize(160,160) ||
settings.resolution() == QSize(320,240))
resolutions << settings.resolution();
if (settings.quality() == QtMultimedia::HighQuality && settings.resolution() == QSize(640,480))
resolutions << settings.resolution();
} else {
resolutions << QSize(160, 120);
resolutions << QSize(320, 240);
if (settings.quality() == QtMultimedia::HighQuality)
resolutions << QSize(640, 480);
}
return resolutions;
}
QStringList supportedImageCodecs() const
{
QStringList codecs;
codecs << "PNG" << "JPEG";
return codecs;
}
QString imageCodecDescription(const QString &codecName) const {
if (codecName == "PNG")
return QString("Portable Network Graphic");
if (codecName == "JPEG")
return QString("Joint Photographic Expert Group");
return QString();
}
QImageEncoderSettings imageSettings() const { return m_settings; }
void setImageSettings(const QImageEncoderSettings &settings) { m_settings = settings; }
private:
QImageEncoderSettings m_settings;
};
#endif // MOCKIMAGEENCODERCONTROL_H

97
tests/auto/unit/qmultimedia_common/mockmediacontainercontrol.h Normal file
View File

@@ -0,0 +1,97 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIACONTAINERCONTROL_H
#define MOCKMEDIACONTAINERCONTROL_H
#include <QObject>
#include "qmediacontainercontrol.h"
#include <QMap>
#include <QString>
#include <QStringList>
QT_USE_NAMESPACE
class MockMediaContainerControl : public QMediaContainerControl
{
Q_OBJECT
public:
MockMediaContainerControl(QObject *parent):
QMediaContainerControl(parent)
{
m_supportedContainers.append("wav");
m_supportedContainers.append("mp3");
m_supportedContainers.append("mov");
m_descriptions.insert("wav", "WAV format");
m_descriptions.insert("mp3", "MP3 format");
m_descriptions.insert("mov", "MOV format");
}
virtual ~MockMediaContainerControl() {};
QStringList supportedContainers() const
{
return m_supportedContainers;
}
QString containerMimeType() const
{
return m_format;
}
void setContainerMimeType(const QString &formatMimeType)
{
if (m_supportedContainers.contains(formatMimeType))
m_format = formatMimeType;
}
QString containerDescription(const QString &formatMimeType) const
{
return m_descriptions.value(formatMimeType);
}
private:
QStringList m_supportedContainers;
QMap<QString, QString> m_descriptions;
QString m_format;
};
#endif // MOCKMEDIACONTAINERCONTROL_H

83
tests/auto/unit/qmultimedia_common/mockmedianetworkaccesscontrol.h Normal file
View File

@@ -0,0 +1,83 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIANETWORKACCESSCONTROL_H
#define MOCKMEDIANETWORKACCESSCONTROL_H
#include "qmedianetworkaccesscontrol.h"
#include "qnetworkconfiguration.h"
class MockNetworkAccessControl : public QMediaNetworkAccessControl
{
friend class MockMediaPlayerService;
public:
MockNetworkAccessControl() {}
~MockNetworkAccessControl() {}
void setConfigurations(const QList<QNetworkConfiguration> &configurations)
{
_configurations = configurations;
_current = QNetworkConfiguration();
}
QNetworkConfiguration currentConfiguration() const
{
return _current;
}
private:
void setCurrentConfiguration(QNetworkConfiguration configuration)
{
if (_configurations.contains(configuration))
emit configurationChanged(_current = configuration);
else
emit configurationChanged(_current = QNetworkConfiguration());
}
QList<QNetworkConfiguration> _configurations;
QNetworkConfiguration _current;
};
Q_DECLARE_METATYPE(QNetworkConfiguration)
#endif // MOCKMEDIANETWORKACCESSCONTROL_H

57
tests/auto/unit/qmultimedia_common/mockmediaobject.h Normal file
View File

@@ -0,0 +1,57 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIAOBJECT_H
#define MOCKMEDIAOBJECT_H
#include "qmediaobject.h"
class MockMediaObject : public QMediaObject
{
Q_OBJECT
public:
MockMediaObject(QObject *parent, QMediaService *service):
QMediaObject(parent, service)
{
}
};
#endif // MOCKMEDIAOBJECT_H

118
tests/auto/unit/qmultimedia_common/mockmediaplayercontrol.h Normal file
View File

@@ -0,0 +1,118 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIAPLAYERCONTROL_H
#define MOCKMEDIAPLAYERCONTROL_H
#include "qmediaplayercontrol.h"
class MockMediaPlayerControl : public QMediaPlayerControl
{
friend class MockMediaPlayerService;
public:
MockMediaPlayerControl():QMediaPlayerControl(0) {}
QMediaPlayer::State state() const { return _state; }
QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }
qint64 duration() const { return _duration; }
qint64 position() const { return _position; }
void setPosition(qint64 position) { if (position != _position) emit positionChanged(_position = position); }
int volume() const { return _volume; }
void setVolume(int volume) { emit volumeChanged(_volume = volume); }
bool isMuted() const { return _muted; }
void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }
int bufferStatus() const { return _bufferStatus; }
bool isAudioAvailable() const { return _audioAvailable; }
bool isVideoAvailable() const { return _videoAvailable; }
bool isSeekable() const { return _isSeekable; }
QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(_seekRange.first, _seekRange.second); }
void setSeekRange(qint64 minimum, qint64 maximum) { _seekRange = qMakePair(minimum, maximum); }
qreal playbackRate() const { return _playbackRate; }
void setPlaybackRate(qreal rate) { if (rate != _playbackRate) emit playbackRateChanged(_playbackRate = rate); }
QMediaContent media() const { return _media; }
void setMedia(const QMediaContent &content, QIODevice *stream)
{
_stream = stream;
_media = content;
if (_state != QMediaPlayer::StoppedState) {
_mediaStatus = _media.isNull() ? QMediaPlayer::NoMedia : QMediaPlayer::LoadingMedia;
emit stateChanged(_state = QMediaPlayer::StoppedState);
emit mediaStatusChanged(_mediaStatus);
}
emit mediaChanged(_media = content);
}
QIODevice *mediaStream() const { return _stream; }
void play() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PlayingState) emit stateChanged(_state = QMediaPlayer::PlayingState); }
void pause() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PausedState) emit stateChanged(_state = QMediaPlayer::PausedState); }
void stop() { if (_state != QMediaPlayer::StoppedState) emit stateChanged(_state = QMediaPlayer::StoppedState); }
QMediaPlayer::State _state;
QMediaPlayer::MediaStatus _mediaStatus;
QMediaPlayer::Error _error;
qint64 _duration;
qint64 _position;
int _volume;
bool _muted;
int _bufferStatus;
bool _audioAvailable;
bool _videoAvailable;
bool _isSeekable;
QPair<qint64, qint64> _seekRange;
qreal _playbackRate;
QMediaContent _media;
QIODevice *_stream;
bool _isValid;
QString _errorString;
};
#endif // MOCKMEDIAPLAYERCONTROL_H

176
tests/auto/unit/qmultimedia_common/mockmediaplayerservice.h Normal file
View File

@@ -0,0 +1,176 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKPLAYERSERVICE_H
#define MOCKPLAYERSERVICE_H
#include "qmediaservice.h"
#include "mockmediaplayercontrol.h"
#include "mockmediastreamscontrol.h"
#include "mockmedianetworkaccesscontrol.h"
#include "mockvideorenderercontrol.h"
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
#include "mockvideowindowcontrol.h"
#endif
class MockMediaPlayerService : public QMediaService
{
Q_OBJECT
public:
MockMediaPlayerService():QMediaService(0)
{
mockControl = new MockMediaPlayerControl;
mockStreamsControl = new MockStreamsControl;
mockNetworkControl = new MockNetworkAccessControl;
rendererControl = new MockVideoRendererControl;
rendererRef = 0;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
windowControl = new MockVideoWindowControl;
windowRef = 0;
#endif
}
~MockMediaPlayerService()
{
delete mockControl;
delete mockStreamsControl;
delete mockNetworkControl;
delete rendererControl;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
delete windowControl;
#endif
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QMediaPlayerControl_iid) == 0) {
return mockControl;
} else if (qstrcmp(iid, QVideoRendererControl_iid) == 0) {
if (rendererRef == 0) {
rendererRef += 1;
return rendererControl;
}
}
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
if (qstrcmp(iid, QVideoWindowControl_iid) == 0) {
if (windowRef == 0) {
windowRef += 1;
return windowControl;
}
}
#endif
if (qstrcmp(iid, QMediaNetworkAccessControl_iid) == 0)
return mockNetworkControl;
return 0;
}
void releaseControl(QMediaControl *control)
{
if (control == rendererControl)
rendererRef -= 1;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
if (control == windowControl)
windowRef -= 1;
#endif
}
void setState(QMediaPlayer::State state) { emit mockControl->stateChanged(mockControl->_state = state); }
void setState(QMediaPlayer::State state, QMediaPlayer::MediaStatus status) {
mockControl->_state = state;
mockControl->_mediaStatus = status;
emit mockControl->mediaStatusChanged(status);
emit mockControl->stateChanged(state);
}
void setMediaStatus(QMediaPlayer::MediaStatus status) { emit mockControl->mediaStatusChanged(mockControl->_mediaStatus = status); }
void setIsValid(bool isValid) { mockControl->_isValid = isValid; }
void setMedia(QMediaContent media) { mockControl->_media = media; }
void setDuration(qint64 duration) { mockControl->_duration = duration; }
void setPosition(qint64 position) { mockControl->_position = position; }
void setSeekable(bool seekable) { mockControl->_isSeekable = seekable; }
void setVolume(int volume) { mockControl->_volume = volume; }
void setMuted(bool muted) { mockControl->_muted = muted; }
void setVideoAvailable(bool videoAvailable) { mockControl->_videoAvailable = videoAvailable; }
void setBufferStatus(int bufferStatus) { mockControl->_bufferStatus = bufferStatus; }
void setPlaybackRate(qreal playbackRate) { mockControl->_playbackRate = playbackRate; }
void setError(QMediaPlayer::Error error) { mockControl->_error = error; emit mockControl->error(mockControl->_error, mockControl->_errorString); }
void setErrorString(QString errorString) { mockControl->_errorString = errorString; emit mockControl->error(mockControl->_error, mockControl->_errorString); }
void selectCurrentConfiguration(QNetworkConfiguration config) { mockNetworkControl->setCurrentConfiguration(config); }
void reset()
{
mockControl->_state = QMediaPlayer::StoppedState;
mockControl->_mediaStatus = QMediaPlayer::UnknownMediaStatus;
mockControl->_error = QMediaPlayer::NoError;
mockControl->_duration = 0;
mockControl->_position = 0;
mockControl->_volume = 0;
mockControl->_muted = false;
mockControl->_bufferStatus = 0;
mockControl->_videoAvailable = false;
mockControl->_isSeekable = false;
mockControl->_playbackRate = 0.0;
mockControl->_media = QMediaContent();
mockControl->_stream = 0;
mockControl->_isValid = false;
mockControl->_errorString = QString();
mockNetworkControl->_current = QNetworkConfiguration();
mockNetworkControl->_configurations = QList<QNetworkConfiguration>();
}
MockMediaPlayerControl *mockControl;
MockStreamsControl *mockStreamsControl;
MockNetworkAccessControl *mockNetworkControl;
MockVideoRendererControl *rendererControl;
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
MockVideoWindowControl *windowControl;
int windowRef;
#endif
int rendererRef;
};
#endif // MOCKPLAYERSERVICE_H

112
tests/auto/unit/qmultimedia_common/mockmediaplaylistcontrol.h Normal file
View File

@@ -0,0 +1,112 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIAPLAYLISTCONTROL_H
#define MOCKMEDIAPLAYLISTCONTROL_H
#include "qmediaplaylistcontrol.h"
#include "qmediaplaylistnavigator.h"
#include "mockreadonlyplaylistprovider.h"
// Hmm, read only.
class MockMediaPlaylistControl : public QMediaPlaylistControl
{
Q_OBJECT
public:
MockMediaPlaylistControl(QObject *parent) : QMediaPlaylistControl(parent)
{
m_navigator = new QMediaPlaylistNavigator(new MockReadOnlyPlaylistProvider(this), this);
}
~MockMediaPlaylistControl()
{
}
QMediaPlaylistProvider* playlistProvider() const { return m_navigator->playlist(); }
bool setPlaylistProvider(QMediaPlaylistProvider *newProvider)
{
bool bMediaContentChanged = false;
int i = 0;
for (; i < playlistProvider()->mediaCount(); i++) {
if (playlistProvider()->media(i).canonicalUrl().toString() != newProvider->media(i).canonicalUrl().toString()) {
bMediaContentChanged = true;
break;
}
}
if (playlistProvider()->mediaCount() != newProvider->mediaCount() || bMediaContentChanged ) {
emit playlistProviderChanged();
emit currentMediaChanged(newProvider->media(i));
}
m_navigator->setPlaylist(newProvider);
return true;
}
int currentIndex() const { return m_navigator->currentIndex(); }
void setCurrentIndex(int position)
{
if (position != currentIndex())
emit currentIndexChanged(position);
m_navigator->jump(position);
}
int nextIndex(int steps) const { return m_navigator->nextIndex(steps); }
int previousIndex(int steps) const { return m_navigator->previousIndex(steps); }
void next() { m_navigator->next(); }
void previous() { m_navigator->previous(); }
QMediaPlaylist::PlaybackMode playbackMode() const { return m_navigator->playbackMode(); }
void setPlaybackMode(QMediaPlaylist::PlaybackMode mode)
{
if (playbackMode() != mode)
emit playbackModeChanged(mode);
m_navigator->setPlaybackMode(mode);
}
private:
QMediaPlaylistNavigator *m_navigator;
};
#endif // MOCKMEDIAPLAYLISTCONTROL_H

74
tests/auto/unit/qmultimedia_common/mockmediaplaylistsourcecontrol.h Normal file
View File

@@ -0,0 +1,74 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIAPLAYLISTSOURCECONTROL_H
#define MOCKMEDIAPLAYLISTSOURCECONTROL_H
#include "qmediaplaylistsourcecontrol.h"
class MockPlaylistSourceControl : public QMediaPlaylistSourceControl
{
Q_OBJECT
public:
MockPlaylistSourceControl(QObject *parent)
: QMediaPlaylistSourceControl(parent),
m_playlist(0)
{
}
~MockPlaylistSourceControl()
{
}
void setPlaylist(QMediaPlaylist *playlist)
{
m_playlist = playlist;
}
QMediaPlaylist *playlist() const
{
return m_playlist;
}
private:
QMediaPlaylist *m_playlist;
};
#endif // MOCKMEDIAPLAYLISTSOURCECONTROL_H

125
tests/auto/unit/qmultimedia_common/mockmediarecordercontrol.h Normal file
View File

@@ -0,0 +1,125 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKRECORDERCONTROL_H
#define MOCKRECORDERCONTROL_H
#include <QUrl>
#include "qmediarecordercontrol.h"
class MockMediaRecorderControl : public QMediaRecorderControl
{
Q_OBJECT
public:
MockMediaRecorderControl(QObject *parent = 0):
QMediaRecorderControl(parent),
m_state(QMediaRecorder::StoppedState),
m_position(0),
m_muted(false) {}
QUrl outputLocation() const
{
return m_sink;
}
bool setOutputLocation(const QUrl &sink)
{
m_sink = sink;
return true;
}
QMediaRecorder::State state() const
{
return m_state;
}
qint64 duration() const
{
return m_position;
}
bool isMuted() const
{
return m_muted;
}
void applySettings() {}
using QMediaRecorderControl::error;
public slots:
void record()
{
m_state = QMediaRecorder::RecordingState;
m_position=1;
emit stateChanged(m_state);
emit durationChanged(m_position);
}
void pause()
{
m_state = QMediaRecorder::PausedState;
emit stateChanged(m_state);
}
void stop()
{
m_position=0;
m_state = QMediaRecorder::StoppedState;
emit stateChanged(m_state);
}
void setMuted(bool muted)
{
if (m_muted != muted)
emit mutedChanged(m_muted = muted);
}
public:
QUrl m_sink;
QMediaRecorder::State m_state;
qint64 m_position;
bool m_muted;
};
#endif // MOCKRECORDERCONTROL_H

101
tests/auto/unit/qmultimedia_common/mockmediarecorderservice.h Normal file
View File

@@ -0,0 +1,101 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKSERVICE_H
#define MOCKSERVICE_H
#include "qmediaservice.h"
#include "mockaudioencodercontrol.h"
#include "mockmediarecordercontrol.h"
#include "mockvideoencodercontrol.h"
#include "mockaudioendpointselector.h"
#include "mockmediacontainercontrol.h"
#include "mockmetadatawritercontrol.h"
class MockMediaRecorderService : public QMediaService
{
Q_OBJECT
public:
MockMediaRecorderService(QObject *parent = 0, QMediaControl *control = 0):
QMediaService(parent),
mockControl(control),
hasControls(true)
{
mockAudioEndpointSelector = new MockAudioEndpointSelector(parent);
mockAudioEncoderControl = new MockAudioEncoderControl(parent);
mockFormatControl = new MockMediaContainerControl(parent);
mockVideoEncoderControl = new MockVideoEncoderControl(parent);
mockMetaDataControl = new MockMetaDataWriterControl(parent);
}
QMediaControl* requestControl(const char *name)
{
if (hasControls && qstrcmp(name,QAudioEncoderControl_iid) == 0)
return mockAudioEncoderControl;
if (hasControls && qstrcmp(name,QAudioEndpointSelector_iid) == 0)
return mockAudioEndpointSelector;
if (hasControls && qstrcmp(name,QMediaRecorderControl_iid) == 0)
return mockControl;
if (hasControls && qstrcmp(name,QMediaContainerControl_iid) == 0)
return mockFormatControl;
if (hasControls && qstrcmp(name,QVideoEncoderControl_iid) == 0)
return mockVideoEncoderControl;
if (hasControls && qstrcmp(name, QMetaDataWriterControl_iid) == 0)
return mockMetaDataControl;
return 0;
}
void releaseControl(QMediaControl*)
{
}
QMediaControl *mockControl;
QAudioEndpointSelector *mockAudioEndpointSelector;
QAudioEncoderControl *mockAudioEncoderControl;
QMediaContainerControl *mockFormatControl;
QVideoEncoderControl *mockVideoEncoderControl;
MockMetaDataWriterControl *mockMetaDataControl;
bool hasControls;
};
#endif // MOCKSERVICE_H

66
tests/auto/unit/qmultimedia_common/mockmediaservice.h Normal file
View File

@@ -0,0 +1,66 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIASERVICE_H
#define MOCKMEDIASERVICE_H
#include "qmediaservice.h"
class MockMediaService : public QMediaService
{
Q_OBJECT
public:
MockMediaService(QObject *parent, QMediaControl *control):
QMediaService(parent),
mockControl(control) {}
QMediaControl* requestControl(const char *)
{
return mockControl;
}
void releaseControl(QMediaControl*) {}
QMediaControl *mockControl;
};
#endif // MOCKMEDIASERVICE_H

74
tests/auto/unit/qmultimedia_common/mockmediaserviceprovider.h Normal file
View File

@@ -0,0 +1,74 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIASERVICEPROVIDER_H
#define MOCKMEDIASERVICEPROVIDER_H
#include "qmediaserviceprovider.h"
#include "qmediaservice.h"
// Simple provider that lets you set the service
class MockMediaServiceProvider : public QMediaServiceProvider
{
public:
MockMediaServiceProvider(QMediaService* s = 0, bool del=false)
: service(s), deleteServiceOnRelease(del)
{
}
QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)
{
return service;
}
void releaseService(QMediaService *service)
{
if (deleteServiceOnRelease) {
delete service;
service = 0;
}
}
QMediaService *service;
bool deleteServiceOnRelease;
};
#endif // MOCKMEDIASERVICEPROVIDER_H

78
tests/auto/unit/qmultimedia_common/mockmediastreamscontrol.h Normal file
View File

@@ -0,0 +1,78 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMEDIASTREAMSCONTROL_H
#define MOCKMEDIASTREAMSCONTROL_H
#include "qmediastreamscontrol.h"
class MockStreamsControl : public QMediaStreamsControl
{
public:
MockStreamsControl(QObject *parent = 0) : QMediaStreamsControl(parent) {}
int streamCount() { return _streams.count(); }
void setStreamCount(int count) { _streams.resize(count); }
StreamType streamType(int index) { return _streams.at(index).type; }
void setStreamType(int index, StreamType type) { _streams[index].type = type; }
QVariant metaData(int index, QtMultimedia::MetaData key) {
return _streams.at(index).metaData.value(key); }
void setMetaData(int index, QtMultimedia::MetaData key, const QVariant &value) {
_streams[index].metaData.insert(key, value); }
bool isActive(int index) { return _streams.at(index).active; }
void setActive(int index, bool state) { _streams[index].active = state; }
private:
struct Stream
{
Stream() : type(UnknownStream), active(false) {}
StreamType type;
QMap<QtMultimedia::MetaData, QVariant> metaData;
bool active;
};
QVector<Stream> _streams;
};
#endif // MOCKMEDIASTREAMSCONTROL_H

98
tests/auto/unit/qmultimedia_common/mockmetadatareadercontrol.h Normal file
View File

@@ -0,0 +1,98 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMETADATAREADERCONTROL_H
#define MOCKMETADATAREADERCONTROL_H
#include "qmetadatareadercontrol.h"
class MockMetaDataReaderControl : public QMetaDataReaderControl
{
Q_OBJECT
public:
MockMetaDataReaderControl(QObject *parent = 0)
: QMetaDataReaderControl(parent)
, m_available(false)
{
}
bool isMetaDataAvailable() const
{
return m_available;
}
void setMetaDataAvailable(bool available)
{
if (m_available != available)
emit metaDataAvailableChanged(m_available = available);
}
QList<QtMultimedia::MetaData> availableMetaData() const
{
return m_data.keys();
}
QVariant metaData(QtMultimedia::MetaData key) const
{
return m_data.value(key);
}
QVariant extendedMetaData(const QString &key) const
{
return m_extendedData.value(key);
}
QStringList availableExtendedMetaData() const
{
return m_extendedData.keys();
}
using QMetaDataReaderControl::metaDataChanged;
void populateMetaData()
{
m_available = true;
}
bool m_available;
QMap<QtMultimedia::MetaData, QVariant> m_data;
QMap<QString, QVariant> m_extendedData;
};
#endif // MOCKMETADATAREADERCONTROL_H

107
tests/auto/unit/qmultimedia_common/mockmetadatawritercontrol.h Normal file
View File

@@ -0,0 +1,107 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKMETADATAWRITERCONTROL_H
#define MOCKMETADATAWRITERCONTROL_H
#include <QObject>
#include <QMap>
#include "qmetadatawritercontrol.h"
class MockMetaDataWriterControl : public QMetaDataWriterControl
{
Q_OBJECT
public:
MockMetaDataWriterControl(QObject *parent = 0)
: QMetaDataWriterControl(parent)
, m_available(false)
, m_writable(false)
{
}
bool isMetaDataAvailable() const { return m_available; }
void setMetaDataAvailable(bool available)
{
if (m_available != available)
emit metaDataAvailableChanged(m_available = available);
}
QList<QtMultimedia::MetaData> availableMetaData() const { return m_data.keys(); }
bool isWritable() const { return m_writable; }
void setWritable(bool writable) { emit writableChanged(m_writable = writable); }
QVariant metaData(QtMultimedia::MetaData key) const { return m_data.value(key); }//Getting the metadata from Multimediakit
void setMetaData(QtMultimedia::MetaData key, const QVariant &value)
{
m_data.insert(key, value);
}
QVariant extendedMetaData(const QString &key) const { return m_extendedData.value(key); }
void setExtendedMetaData(const QString &key, const QVariant &value)
{
m_extendedData.insert(key, value);
}
QStringList availableExtendedMetaData() const { return m_extendedData.keys(); }
using QMetaDataWriterControl::metaDataChanged;
void populateMetaData()
{
m_available = true;
}
void setWritable()
{
emit writableChanged(true);
}
void setMetaDataAvailable()
{
emit metaDataAvailableChanged(true);
}
bool m_available;
bool m_writable;
QMap<QtMultimedia::MetaData, QVariant> m_data;
QMap<QString, QVariant> m_extendedData;
};
#endif // MOCKMETADATAWRITERCONTROL_H

12
tests/auto/unit/qmultimedia_common/mockplayer.pri Normal file
View File

@@ -0,0 +1,12 @@
INCLUDEPATH *= $$PWD \
../../../src/multimedia \
../../../src/multimedia/audio \
../../../src/multimedia/video \
HEADERS *= \
../qmultimedia_common/mockmediaplayerservice.h \
../qmultimedia_common/mockmediaplayercontrol.h \
../qmultimedia_common/mockmediastreamscontrol.h \
../qmultimedia_common/mockmedianetworkaccesscontrol.h
include(mockvideo.pri)

8
tests/auto/unit/qmultimedia_common/mockplaylist.pri Normal file
View File

@@ -0,0 +1,8 @@
INCLUDEPATH *= $$PWD \
../../../src/multimedia \
HEADERS *= \
../qmultimedia_common/mockmediaplaylistsourcecontrol.h \
../qmultimedia_common/mockmediaplaylistcontrol.h \
../qmultimedia_common/mockreadonlyplaylistprovider.h \
../qmultimedia_common/mockplaylistservice.h

77
tests/auto/unit/qmultimedia_common/mockplaylistservice.h Normal file
View File

@@ -0,0 +1,77 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKPLAYLISTSERVICE_H
#define MOCKPLAYLISTSERVICE_H
#include "qmediaservice.h"
#include "mockmediaplaylistcontrol.h"
class MockPlaylistService : public QMediaService
{
Q_OBJECT
public:
MockPlaylistService():QMediaService(0)
{
mockControl = new MockMediaPlaylistControl(this);
}
~MockPlaylistService()
{
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QMediaPlaylistControl_iid) == 0)
return mockControl;
return 0;
}
void releaseControl(QMediaControl *)
{
}
MockMediaPlaylistControl *mockControl;
};
#endif // MOCKPLAYLISTSERVICE_H

8
tests/auto/unit/qmultimedia_common/mockradio.pri Normal file
View File

@@ -0,0 +1,8 @@
# Radio related mock backend files
INCLUDEPATH += .
HEADERS += \
../qmultimedia_common/mockradiotunercontrol.h \
../qmultimedia_common/mockradiodatacontrol.h

157
tests/auto/unit/qmultimedia_common/mockradiodatacontrol.h Normal file
View File

@@ -0,0 +1,157 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKRADIODATACONTROL_H
#define MOCKRADIODATACONTROL_H
#include "qradiodatacontrol.h"
class MockRadioDataControl : public QRadioDataControl
{
Q_OBJECT
public:
MockRadioDataControl(QObject *parent):
QRadioDataControl(parent), m_err(QRadioData::NoError),
m_errstr("")
{
}
using QRadioDataControl::error;
bool isAvailable() const
{
return true;
}
QtMultimedia::AvailabilityError availabilityError() const
{
return QtMultimedia::NoError;
}
QRadioData::Error error() const
{
return m_err;
}
QString errorString() const
{
return m_errstr;
}
QString stationId() const
{
return m_stationId;
}
QRadioData::ProgramType programType() const
{
return m_programType;
}
QString programTypeName() const
{
return m_programTypeName;
}
QString stationName() const
{
return m_stationName;
}
QString radioText() const
{
return m_radioText;
}
void setAlternativeFrequenciesEnabled(bool enabled)
{
m_alternativeFrequenciesEnabled = enabled;
emit alternativeFrequenciesEnabledChanged(m_alternativeFrequenciesEnabled);
}
bool isAlternativeFrequenciesEnabled() const
{
return m_alternativeFrequenciesEnabled;
}
void forceRT( QString text )
{
m_radioText = text;
emit radioTextChanged(m_radioText);
}
void forceProgramType( int pty )
{
m_programType = static_cast<QRadioData::ProgramType>(pty);
emit programTypeChanged(m_programType);
}
void forcePTYN( QString ptyn )
{
m_programTypeName = ptyn;
emit programTypeNameChanged(m_programTypeName);
}
void forcePI( QString pi )
{
m_stationId = pi;
emit stationIdChanged(m_stationId);
}
void forcePS( QString ps )
{
m_stationName = ps;
emit stationNameChanged(m_stationName);
}
public:
QString m_radioText;
QRadioData::ProgramType m_programType;
QString m_programTypeName;
QString m_stationId;
QString m_stationName;
bool m_alternativeFrequenciesEnabled;
QRadioData::Error m_err;
QString m_errstr;
};
#endif // MOCKRADIODATACONTROL_H

275
tests/auto/unit/qmultimedia_common/mockradiotunercontrol.h Normal file
View File

@@ -0,0 +1,275 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKRADIOTUNERCONTROL_H
#define MOCKRADIOTUNERCONTROL_H
#include "qradiotunercontrol.h"
class MockRadioTunerControl : public QRadioTunerControl
{
Q_OBJECT
public:
MockRadioTunerControl(QObject *parent):
QRadioTunerControl(parent),
m_active(false),
m_searching(false),m_muted(false),m_stereo(true),
m_volume(100),m_signal(0),m_frequency(0),
m_band(QRadioTuner::FM),m_err(QRadioTuner::NoError),
m_errstr("")
{
}
using QRadioTunerControl::error;
QRadioTuner::State state() const
{
return m_active ? QRadioTuner::ActiveState : QRadioTuner::StoppedState;
}
bool isAvailable() const
{
return true;
}
QtMultimedia::AvailabilityError availabilityError() const
{
return QtMultimedia::NoError;
}
QRadioTuner::Band band() const
{
return m_band;
}
void setBand(QRadioTuner::Band b)
{
if (b == QRadioTuner::FM2 || b == QRadioTuner::LW) {
m_err = QRadioTuner::OutOfRangeError;
m_errstr.clear();
m_errstr = QString("band and range not supported");
} else {
m_err = QRadioTuner::NoError;
m_errstr.clear();
m_band = b;
emit bandChanged(m_band);
}
emit error(m_err);
}
bool isBandSupported(QRadioTuner::Band b) const
{
if (b == QRadioTuner::FM || b == QRadioTuner::AM)
return true;
return false;
}
int frequency() const
{
return m_frequency;
}
QPair<int,int> frequencyRange(QRadioTuner::Band) const
{
return qMakePair<int,int>(1,2);
}
int frequencyStep(QRadioTuner::Band) const
{
return 1;
}
void setFrequency(int frequency)
{
if (frequency >= 148500000) {
m_err = QRadioTuner::OutOfRangeError;
m_errstr.clear();
m_errstr = QString("band and range not supported");
} else {
m_err = QRadioTuner::NoError;
m_errstr.clear();
m_frequency = frequency;
emit frequencyChanged(m_frequency);
}
emit error(m_err);
}
bool isStereo() const
{
return m_stereo;
}
void setStereo(bool stereo)
{
emit stereoStatusChanged(m_stereo = stereo);
}
QRadioTuner::StereoMode stereoMode() const
{
return m_stereoMode;
}
void setStereoMode(QRadioTuner::StereoMode mode)
{
m_stereoMode = mode;
}
QRadioTuner::Error error() const
{
return m_err;
}
QString errorString() const
{
return m_errstr;
}
int signalStrength() const
{
return m_signal;
}
int volume() const
{
return m_volume;
}
void setVolume(int volume)
{
m_volume = volume;
emit volumeChanged(m_volume);
}
bool isMuted() const
{
return m_muted;
}
void setMuted(bool muted)
{
m_muted = muted;
emit mutedChanged(m_muted);
}
bool isSearching() const
{
return m_searching;
}
void searchForward()
{
m_searching = true;
emit searchingChanged(m_searching);
}
void searchBackward()
{
m_searching = true;
emit searchingChanged(m_searching);
}
void cancelSearch()
{
m_searching = false;
emit searchingChanged(m_searching);
}
void findNewStation( int frequency, QString stationId )
{
setFrequency(frequency);
emit stationFound( frequency, stationId );
}
void searchAllStations(QRadioTuner::SearchMode searchMode = QRadioTuner::SearchFast)
{
QString programmeIdentifiers[3] = { "", "", "" };
if ( searchMode == QRadioTuner::SearchGetStationId ) {
programmeIdentifiers[0] = QString("MockProgramPI1");
programmeIdentifiers[1] = QString("MockProgramPI2");
programmeIdentifiers[2] = QString("MockProgramPI3");
}
m_searching = true;
emit searchingChanged(m_searching);
findNewStation(88300000, programmeIdentifiers[0]);
findNewStation(95100000, programmeIdentifiers[1]);
findNewStation(103100000, programmeIdentifiers[2]);
m_searching = false;
emit searchingChanged(m_searching);
}
void start()
{
if (!m_active) {
m_active = true;
emit stateChanged(state());
}
}
void stop()
{
if (m_active) {
m_active = false;
emit stateChanged(state());
}
}
public:
bool m_active;
bool m_searching;
bool m_muted;
bool m_stereo;
int m_volume;
int m_signal;
int m_frequency;
QRadioTuner::StereoMode m_stereoMode;
QRadioTuner::Band m_band;
QRadioTuner::Error m_err;
QString m_errstr;
};
#endif // MOCKRADIOTUNERCONTROL_H

69
tests/auto/unit/qmultimedia_common/mockreadonlyplaylistprovider.h Normal file
View File

@@ -0,0 +1,69 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKREADONLYPLAYLISTPROVIDER_H
#define MOCKREADONLYPLAYLISTPROVIDER_H
#include "qmediaplaylistprovider.h"
class MockReadOnlyPlaylistProvider : public QMediaPlaylistProvider
{
Q_OBJECT
public:
MockReadOnlyPlaylistProvider(QObject *parent)
:QMediaPlaylistProvider(parent)
{
m_items.append(QMediaContent(QUrl(QLatin1String("file:///1"))));
m_items.append(QMediaContent(QUrl(QLatin1String("file:///2"))));
m_items.append(QMediaContent(QUrl(QLatin1String("file:///3"))));
}
int mediaCount() const { return m_items.size(); }
QMediaContent media(int index) const
{
return index >=0 && index < mediaCount() ? m_items.at(index) : QMediaContent();
}
private:
QList<QMediaContent> m_items;
};
#endif // MOCKREADONLYPLAYLISTPROVIDER_H

14
tests/auto/unit/qmultimedia_common/mockrecorder.pri Normal file
View File

@@ -0,0 +1,14 @@
INCLUDEPATH *= $$PWD \
../../../src/multimedia \
../../../src/multimedia/audio \
../../../src/multimedia/video \
HEADERS *= \
../qmultimedia_common/mockmediarecorderservice.h \
../qmultimedia_common/mockmediarecordercontrol.h \
../qmultimedia_common/mockvideoencodercontrol.h \
../qmultimedia_common/mockaudioencodercontrol.h \
../qmultimedia_common/mockaudioendpointselector.h \
# We also need all the container/metadata bits
include(mockcontainer.pri)

14
tests/auto/unit/qmultimedia_common/mockvideo.pri Normal file
View File

@@ -0,0 +1,14 @@
# video related mock backend files
INCLUDEPATH += $$PWD \
../../../src/multimedia \
../../../src/multimedia/video
contains(QT,multimediawidgets)|contains(QT,multimediawidgets-private) {
HEADERS *= ../qmultimedia_common/mockvideowindowcontrol.h
DEFINES *= QT_MULTIMEDIA_MOCK_WIDGETS
}
HEADERS *= \
../qmultimedia_common/mockvideosurface.h \
../qmultimedia_common/mockvideorenderercontrol.h

112
tests/auto/unit/qmultimedia_common/mockvideoencodercontrol.h Normal file
View File

@@ -0,0 +1,112 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKVIDEOENCODERCONTROL_H
#define MOCKVIDEOENCODERCONTROL_H
#include "qvideoencodercontrol.h"
class MockVideoEncoderControl : public QVideoEncoderControl
{
Q_OBJECT
public:
MockVideoEncoderControl(QObject *parent):
QVideoEncoderControl(parent)
{
m_supportedEncodeOptions.insert("video/3gpp", QStringList() << "quantizer" << "me");
m_supportedEncodeOptions.insert("video/H264", QStringList() << "quantizer" << "me" << "bframes");
m_videoCodecs << "video/3gpp" << "video/H264";
m_sizes << QSize(320,240) << QSize(640,480);
m_framerates << 30 << 15 << 1;
}
~MockVideoEncoderControl() {}
QVideoEncoderSettings videoSettings() const { return m_videoSettings; }
void setVideoSettings(const QVideoEncoderSettings &settings) { m_videoSettings = settings; };
QList<QSize> supportedResolutions(const QVideoEncoderSettings & = QVideoEncoderSettings(),
bool *continuous = 0) const
{
if (continuous)
*continuous = true;
return m_sizes;
}
QList<qreal> supportedFrameRates(const QVideoEncoderSettings & = QVideoEncoderSettings(),
bool *continuous = 0) const
{
if (continuous)
*continuous = false;
return m_framerates;
}
QStringList supportedVideoCodecs() const { return m_videoCodecs; }
QString videoCodecDescription(const QString &codecName) const { return codecName; }
QStringList supportedEncodingOptions(const QString &codec) const
{
return m_supportedEncodeOptions.value(codec);
}
QVariant encodingOption(const QString &codec, const QString &name) const
{
return m_encodeOptions[codec].value(name);
}
void setEncodingOption(const QString &codec, const QString &name, const QVariant &value)
{
m_encodeOptions[codec][name] = value;
}
private:
QVideoEncoderSettings m_videoSettings;
QMap<QString, QStringList> m_supportedEncodeOptions;
QMap< QString, QMap<QString, QVariant> > m_encodeOptions;
QStringList m_videoCodecs;
QList<QSize> m_sizes;
QList<qreal> m_framerates;
};
#endif // MOCKVIDEOENCODERCONTROL_H

58
tests/auto/unit/qmultimedia_common/mockvideorenderercontrol.h Normal file
View File

@@ -0,0 +1,58 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKVIDEORENDERERCONTROL_H
#define MOCKVIDEORENDERERCONTROL_H
#include "qvideorenderercontrol.h"
class MockVideoRendererControl : public QVideoRendererControl
{
public:
MockVideoRendererControl(QObject *parent = 0) : QVideoRendererControl(parent), m_surface(0) {}
QAbstractVideoSurface *surface() const { return m_surface; }
void setSurface(QAbstractVideoSurface *surface) { m_surface = surface; }
QAbstractVideoSurface *m_surface;
};
#endif // MOCKVIDEORENDERERCONTROL_H

59
tests/auto/unit/qmultimedia_common/mockvideosurface.h Normal file
View File

@@ -0,0 +1,59 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKVIDEOSURFACE_H
#define MOCKVIDEOSURFACE_H
#include "qabstractvideosurface.h"
class MockVideoSurface : public QAbstractVideoSurface
{
public:
QList<QVideoFrame::PixelFormat> supportedPixelFormats(
const QAbstractVideoBuffer::HandleType) const
{
return QList<QVideoFrame::PixelFormat>();
}
bool present(const QVideoFrame &) { return false; }
};
#endif // MOCKVIDEOSURFACE_H

74
tests/auto/unit/qmultimedia_common/mockvideowindowcontrol.h Normal file
View File

@@ -0,0 +1,74 @@
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 MOCKVIDEOWINDOWCONTROL_H
#define MOCKVIDEOWINDOWCONTROL_H
#if defined(QT_MULTIMEDIA_MOCK_WIDGETS)
#include "qvideowindowcontrol.h"
class MockVideoWindowControl : public QVideoWindowControl
{
public:
MockVideoWindowControl(QObject *parent = 0) : QVideoWindowControl(parent) {}
WId winId() const { return 0; }
void setWinId(WId) {}
QRect displayRect() const { return QRect(); }
void setDisplayRect(const QRect &) {}
bool isFullScreen() const { return false; }
void setFullScreen(bool) {}
void repaint() {}
QSize nativeSize() const { return QSize(); }
Qt::AspectRatioMode aspectRatioMode() const { return Qt::KeepAspectRatio; }
void setAspectRatioMode(Qt::AspectRatioMode) {}
int brightness() const { return 0; }
void setBrightness(int) {}
int contrast() const { return 0; }
void setContrast(int) {}
int hue() const { return 0; }
void setHue(int) {}
int saturation() const { return 0; }
void setSaturation(int) {}
};
#endif // QT_MULTIMEDIA_MOCK_WIDGETS
#endif // MOCKVIDEOWINDOWCONTROL_H