From 6a88794db4b35128eeef1f3514203d375dbba280 Mon Sep 17 00:00:00 2001 From: Dmytro Poplavskiy Date: Wed, 25 Jan 2012 16:24:55 +1000 Subject: QCameraImageProcessingControl API fixes Moved white balance preset from the separate methods to QCameraImageProcessingControl::ProcessingParameter; Separated absolute contrast/saturation/sharpening/denoising settings with adjustments to backend decided values, with QCameraImageProcessing using adjustments versions. Changed type of parameters from int to qreal with [0..1] range for absolute values and [-1..1] for adjustments. Change-Id: I85c8781c046be6dd45bcf626c25908e1ce5f6bcb Reviewed-by: Jonas Rabbe Reviewed-by: Michael Goddard --- doc/src/snippets/multimedia-snippets/camera.cpp | 4 +- src/multimedia/camera/qcameraimageprocessing.cpp | 181 ++++++++------------- src/multimedia/camera/qcameraimageprocessing.h | 25 ++- .../controls/qcameraimageprocessingcontrol.cpp | 75 +++++---- .../controls/qcameraimageprocessingcontrol.h | 29 ++-- tests/auto/unit/qcamera/tst_qcamera.cpp | 61 +++---- .../mockcameraimageprocessingcontrol.h | 57 ++++--- 7 files changed, 198 insertions(+), 234 deletions(-) diff --git a/doc/src/snippets/multimedia-snippets/camera.cpp b/doc/src/snippets/multimedia-snippets/camera.cpp index 1712a6450..08a2e89b8 100644 --- a/doc/src/snippets/multimedia-snippets/camera.cpp +++ b/doc/src/snippets/multimedia-snippets/camera.cpp @@ -170,9 +170,7 @@ void cameraimageprocessing() //! [Camera image whitebalance] //! [Camera image denoising] - if (imageProcessing->isDenoisingSupported()) { - imageProcessing->setDenoisingLevel(3); - } + imageProcessing->setDenoisingLevel(-0.3); //reduce the amount of denoising applied //! [Camera image denoising] } diff --git a/src/multimedia/camera/qcameraimageprocessing.cpp b/src/multimedia/camera/qcameraimageprocessing.cpp index ab004c34c..3d7812b00 100644 --- a/src/multimedia/camera/qcameraimageprocessing.cpp +++ b/src/multimedia/camera/qcameraimageprocessing.cpp @@ -101,6 +101,18 @@ QT_BEGIN_NAMESPACE \sa QCameraImageProcessingControl */ +class QCameraImageProcessingFakeControl : public QCameraImageProcessingControl { +public: + QCameraImageProcessingFakeControl(QObject *parent) : + QCameraImageProcessingControl(parent) + {} + + bool isParameterSupported(ProcessingParameter) const { return false; } + bool isParameterValueSupported(ProcessingParameter, const QVariant &) const { return false; } + QVariant parameter(ProcessingParameter) const { return QVariant(); } + void setParameter(ProcessingParameter, const QVariant &) {} +}; + class QCameraImageProcessingPrivate : public QMediaObjectPrivate { @@ -112,6 +124,7 @@ public: QCamera *camera; QCameraImageProcessingControl *imageControl; + bool available; }; @@ -122,6 +135,11 @@ void QCameraImageProcessingPrivate::initControls() QMediaService *service = camera->service(); if (service) imageControl = qobject_cast(service->requestControl(QCameraImageProcessingControl_iid)); + + available = (imageControl != 0); + + if (!imageControl) + imageControl = new QCameraImageProcessingFakeControl(q_ptr); } /*! @@ -152,7 +170,7 @@ QCameraImageProcessing::~QCameraImageProcessing() */ bool QCameraImageProcessing::isAvailable() const { - return d_func()->imageControl != 0; + return d_func()->available; } @@ -162,7 +180,8 @@ bool QCameraImageProcessing::isAvailable() const QCameraImageProcessing::WhiteBalanceMode QCameraImageProcessing::whiteBalanceMode() const { - return d_func()->imageControl ? d_func()->imageControl->whiteBalanceMode() : QCameraImageProcessing::WhiteBalanceAuto; + return d_func()->imageControl->parameter(QCameraImageProcessingControl::WhiteBalancePreset) + .value(); } /*! @@ -171,8 +190,9 @@ QCameraImageProcessing::WhiteBalanceMode QCameraImageProcessing::whiteBalanceMod void QCameraImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode) { - if (d_func()->imageControl) - d_func()->imageControl->setWhiteBalanceMode(mode); + d_func()->imageControl->setParameter( + QCameraImageProcessingControl::WhiteBalancePreset, + QVariant::fromValue(mode)); } /*! @@ -181,7 +201,10 @@ void QCameraImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::WhiteBa bool QCameraImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const { - return d_func()->imageControl ? d_func()->imageControl->isWhiteBalanceModeSupported(mode) : false; + return d_func()->imageControl->isParameterValueSupported( + QCameraImageProcessingControl::WhiteBalancePreset, + QVariant::fromValue(mode)); + } /*! @@ -190,14 +213,9 @@ bool QCameraImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessing: return value is undefined. */ -int QCameraImageProcessing::manualWhiteBalance() const +qreal QCameraImageProcessing::manualWhiteBalance() const { - QVariant value; - - if (d_func()->imageControl) - value = d_func()->imageControl->processingParameter(QCameraImageProcessingControl::ColorTemperature); - - return value.toInt(); + return d_func()->imageControl->parameter(QCameraImageProcessingControl::ColorTemperature).toReal(); } /*! @@ -205,161 +223,96 @@ int QCameraImageProcessing::manualWhiteBalance() const when whiteBalanceMode() is set to \c WhiteBalanceManual. The units are Kelvin. */ -void QCameraImageProcessing::setManualWhiteBalance(int colorTemperature) +void QCameraImageProcessing::setManualWhiteBalance(qreal colorTemperature) { - if (d_func()->imageControl) { - d_func()->imageControl->setProcessingParameter( - QCameraImageProcessingControl::ColorTemperature, - QVariant(colorTemperature)); - } + d_func()->imageControl->setParameter( + QCameraImageProcessingControl::ColorTemperature, + QVariant(colorTemperature)); } /*! Returns the contrast adjustment setting. */ -int QCameraImageProcessing::contrast() const +qreal QCameraImageProcessing::contrast() const { - QVariant value; - - if (d_func()->imageControl) - value = d_func()->imageControl->processingParameter(QCameraImageProcessingControl::Contrast); - - return value.toInt(); + return d_func()->imageControl->parameter(QCameraImageProcessingControl::ContrastAdjustment).toReal(); } /*! Set the contrast adjustment to \a value. - Valid contrast adjustment values range between -100 and 100, with a default of 0. + Valid contrast adjustment values range between -1.0 and 1.0, with a default of 0. */ -void QCameraImageProcessing::setContrast(int value) +void QCameraImageProcessing::setContrast(qreal value) { - if (d_func()->imageControl) - d_func()->imageControl->setProcessingParameter(QCameraImageProcessingControl::Contrast, - QVariant(value)); + d_func()->imageControl->setParameter(QCameraImageProcessingControl::ContrastAdjustment, + QVariant(value)); } /*! Returns the saturation adjustment value. */ -int QCameraImageProcessing::saturation() const +qreal QCameraImageProcessing::saturation() const { - QVariant value; - - if (d_func()->imageControl) - value = d_func()->imageControl->processingParameter(QCameraImageProcessingControl::Saturation); - - return value.toInt(); + return d_func()->imageControl->parameter(QCameraImageProcessingControl::SaturationAdjustment).toReal(); } /*! Sets the saturation adjustment value to \a value. - Valid saturation values range between -100 and 100, with a default of 0. + Valid saturation values range between -1.0 and 1.0, with a default of 0. */ -void QCameraImageProcessing::setSaturation(int value) -{ - if (d_func()->imageControl) - d_func()->imageControl->setProcessingParameter(QCameraImageProcessingControl::Saturation, - QVariant(value)); -} - -/*! - Identifies if sharpening is supported. - - Returns true if sharpening is supported; and false if it is not. -*/ -bool QCameraImageProcessing::isSharpeningSupported() const +void QCameraImageProcessing::setSaturation(qreal value) { - if (d_func()->imageControl) - return d_func()->imageControl->isProcessingParameterSupported(QCameraImageProcessingControl::Sharpening); - else - return false; + d_func()->imageControl->setParameter(QCameraImageProcessingControl::SaturationAdjustment, + QVariant(value)); } /*! - Returns the sharpening level. - - This may be \c DefaultSharpening if no particular sharpening level has been applied. - + Returns the sharpening adjustment level. */ -int QCameraImageProcessing::sharpeningLevel() const +qreal QCameraImageProcessing::sharpeningLevel() const { - QVariant value; - - if (d_func()->imageControl) - value = d_func()->imageControl->processingParameter(QCameraImageProcessingControl::Sharpening); - - if (value.isNull()) - return DefaultSharpening; - else - return value.toInt(); + return d_func()->imageControl->parameter(QCameraImageProcessingControl::SharpeningAdjustment).toReal(); } /*! - Sets the sharpening \a level. - - If \c DefaultSharpening is supplied, the camera will decide what sharpening - to perform. Otherwise a level of 0 will disable sharpening, and a level of 100 - corresponds to maximum sharpening applied. + Sets the sharpening adjustment \a level. + Valid sharpening values range between -1.0 and 1.0, with a default of 0. */ -void QCameraImageProcessing::setSharpeningLevel(int level) +void QCameraImageProcessing::setSharpeningLevel(qreal level) { - Q_D(QCameraImageProcessing); - if (d->imageControl) - d->imageControl->setProcessingParameter(QCameraImageProcessingControl::Sharpening, - level == DefaultSharpening ? QVariant() : QVariant(level)); + d_func()->imageControl->setParameter(QCameraImageProcessingControl::SharpeningAdjustment, + QVariant(level)); } /*! - Returns true if denoising is supported. + Returns the denoising adjustment level. */ -bool QCameraImageProcessing::isDenoisingSupported() const +qreal QCameraImageProcessing::denoisingLevel() const { - if (d_func()->imageControl) - return d_func()->imageControl->isProcessingParameterSupported(QCameraImageProcessingControl::Denoising); - else - return false; + return d_func()->imageControl->parameter(QCameraImageProcessingControl::DenoisingAdjustment).toReal(); } /*! - Returns the denoising level. This may be \c DefaultDenoising if no - particular value has been set. + Sets the denoising adjustment \a level. -*/ -int QCameraImageProcessing::denoisingLevel() const -{ - QVariant value; - - if (d_func()->imageControl) - value = d_func()->imageControl->processingParameter(QCameraImageProcessingControl::Denoising); - - if (value.isNull()) - return DefaultDenoising; - else - return value.toInt(); -} - -/*! - Sets the denoising \a level. - - If \c DefaultDenoising is supplied, the camera will decide what denoising - to perform. Otherwise a level of 0 will disable denoising, and a level of 100 - corresponds to maximum denoising applied. + Valid sharpening values range between -1.0 and 1.0, with a default of 0. + If the parameter value is set to 0, the amount of denoising applied + is selected by camera and depends on camera capabilities and settings. + Changing value in -1.0..1.0 range adjusts the amount of denoising applied + within the supported range. */ -void QCameraImageProcessing::setDenoisingLevel(int level) +void QCameraImageProcessing::setDenoisingLevel(qreal level) { - Q_D(QCameraImageProcessing); - if (d->imageControl) - d->imageControl->setProcessingParameter(QCameraImageProcessingControl::Denoising, - level == DefaultDenoising ? QVariant() : QVariant(level)); + d_func()->imageControl->setParameter(QCameraImageProcessingControl::DenoisingAdjustment, + QVariant(level)); } - /*! \enum QCameraImageProcessing::WhiteBalanceMode @@ -373,7 +326,7 @@ void QCameraImageProcessing::setDenoisingLevel(int level) \value WhiteBalanceFluorescent Fluorescent white balance mode. \value WhiteBalanceFlash Flash white balance mode. \value WhiteBalanceSunset Sunset white balance mode. - \value WhiteBalanceVendor Vendor defined white balance mode. + \value WhiteBalanceVendor Base value for vendor defined white balance modes. */ #include "moc_qcameraimageprocessing.cpp" diff --git a/src/multimedia/camera/qcameraimageprocessing.h b/src/multimedia/camera/qcameraimageprocessing.h index 5f118d9d1..ea1e76c01 100644 --- a/src/multimedia/camera/qcameraimageprocessing.h +++ b/src/multimedia/camera/qcameraimageprocessing.h @@ -86,24 +86,21 @@ public: WhiteBalanceMode whiteBalanceMode() const; void setWhiteBalanceMode(WhiteBalanceMode mode); bool isWhiteBalanceModeSupported(WhiteBalanceMode mode) const; - int manualWhiteBalance() const; - void setManualWhiteBalance(int colorTemperature); - int contrast() const; - void setContrast(int value); + qreal manualWhiteBalance() const; + void setManualWhiteBalance(qreal colorTemperature); - int saturation() const; - void setSaturation(int value); + qreal contrast() const; + void setContrast(qreal value); - static const int DefaultSharpening = -1; - bool isSharpeningSupported() const; - int sharpeningLevel() const; - void setSharpeningLevel(int value); + qreal saturation() const; + void setSaturation(qreal value); - static const int DefaultDenoising = -1; - bool isDenoisingSupported() const; - int denoisingLevel() const; - void setDenoisingLevel(int value); + qreal sharpeningLevel() const; + void setSharpeningLevel(qreal value); + + qreal denoisingLevel() const; + void setDenoisingLevel(qreal value); private: friend class QCamera; diff --git a/src/multimedia/controls/qcameraimageprocessingcontrol.cpp b/src/multimedia/controls/qcameraimageprocessingcontrol.cpp index 1beb94035..ba1eda498 100644 --- a/src/multimedia/controls/qcameraimageprocessingcontrol.cpp +++ b/src/multimedia/controls/qcameraimageprocessingcontrol.cpp @@ -71,7 +71,19 @@ namespace The interface name of QCameraImageProcessingControl is \c com.nokia.Qt.QCameraImageProcessingControl/1.0 as defined in QCameraImageProcessingControl_iid. + Camera service may choose the parameters of image processing pipeline depending + on sensor properties camera settings and capture parameters. + This control allows to modify some parameters of image processing pipeline + to achieve desired results. + + Parameters with the "Adjustment" suffix, like ContrastAdjustment, SaturationAdjustment etc + allows to adjust the parameter values, selected by camera engine, + while parameters like Contrast and Saturation overwrites them. + + For example setting the SharpeningAdjustment parameter to -0.1 + slightly reduces the amount of sharpening applied, + while settings the Sharpening parameter to 0 disables sharpening at all. \sa QMediaService::requestControl(), QCamera */ @@ -103,25 +115,8 @@ QCameraImageProcessingControl::~QCameraImageProcessingControl() { } - -/*! - \fn QCameraImageProcessingControl::whiteBalanceMode() const - Return the white balance mode being used. -*/ - -/*! - \fn QCameraImageProcessingControl::setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode) - Set the white balance mode to \a mode -*/ - -/*! - \fn QCameraImageProcessingControl::isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const - Returns true if the white balance \a mode is supported. - The backend should support at least QCameraImageProcessing::WhiteBalanceAuto mode. -*/ - /*! - \fn bool QCameraImageProcessingControl::isProcessingParameterSupported(ProcessingParameter parameter) const + \fn bool QCameraImageProcessingControl::isParameterSupported(ProcessingParameter parameter) const Returns true if the camera supports adjusting image processing \a parameter. @@ -132,29 +127,43 @@ QCameraImageProcessingControl::~QCameraImageProcessingControl() */ /*! - \fn QCameraImageProcessingControl::processingParameter(ProcessingParameter parameter) const + \fn bool QCameraImageProcessingControl::isParameterValueSupported(ProcessingParameter parameter, const QVariant &value) const + + Returns true if the camera supports settings the the image processing \a parameter \a value. + + It's used only for parameters with a limited set of values, like WhiteBalancePreset. +*/ + + +/*! + \fn QCameraImageProcessingControl::parameter(ProcessingParameter parameter) const + Returns the image processing \a parameter value. */ /*! - \fn QCameraImageProcessingControl::setProcessingParameter(ProcessingParameter parameter, QVariant value) + \fn QCameraImageProcessingControl::setParameter(ProcessingParameter parameter, const QVariant &value) Sets the image processing \a parameter \a value. Passing the null or invalid QVariant value allows backend to choose the suitable parameter value. - The valid values range depends on the parameter type, - for contrast, saturation and brightness value should be - between -100 and 100, the default is 0, - - For sharpening and denoising the range is 0..100, - 0 for sharpening or denoising disabled - and 100 for maximum sharpening/denoising applied. + The valid values range depends on the parameter type. + For WhiteBalancePreset the value should be one of QCameraImageProcessing::WhiteBalanceMode values; + for Contrast, Saturation, Brightness, Sharpening and Denoising the value should be + in [0..1.0] range with invalid QVariant value indicating the default parameter value; + for ContrastAdjustment, SaturationAdjustment, BrightnessAdjustment, + SharpeningAdjustment and DenoisingAdjustment the value should be + in [-1.0..1.0] range with default 0. */ /*! \enum QCameraImageProcessingControl::ProcessingParameter + \value WhiteBalancePreset + The white balance preset. + \value ColorTemperature + Color temperature in K. This value is used when the manual white balance mode is selected. \value Contrast Image contrast. \value Saturation @@ -165,8 +174,16 @@ QCameraImageProcessingControl::~QCameraImageProcessingControl() Amount of sharpening applied. \value Denoising Amount of denoising applied. - \value ColorTemperature - Color temperature in K. This value is used when the manual white balance mode is selected. + \value ContrastAdjustment + Image contrast adjustment. + \value SaturationAdjustment + Image saturation adjustment. + \value BrightnessAdjustment + Image brightness adjustment. + \value SharpeningAdjustment + Adjustment of sharpening applied. + \value DenoisingAdjustment + Adjustment of denoising applied. \value ExtendedParameter The base value for platform specific extended parameters. */ diff --git a/src/multimedia/controls/qcameraimageprocessingcontrol.h b/src/multimedia/controls/qcameraimageprocessingcontrol.h index 4da0051c0..41200b2d3 100644 --- a/src/multimedia/controls/qcameraimageprocessingcontrol.h +++ b/src/multimedia/controls/qcameraimageprocessingcontrol.h @@ -64,22 +64,25 @@ public: ~QCameraImageProcessingControl(); enum ProcessingParameter { - Contrast = 0, - Saturation = 1, - Brightness = 2, - Sharpening = 3, - Denoising = 4, - ColorTemperature = 5, + WhiteBalancePreset, + ColorTemperature, + Contrast, + Saturation, + Brightness, + Sharpening, + Denoising, + ContrastAdjustment, + SaturationAdjustment, + BrightnessAdjustment, + SharpeningAdjustment, + DenoisingAdjustment, ExtendedParameter = 1000 }; - virtual QCameraImageProcessing::WhiteBalanceMode whiteBalanceMode() const = 0; - virtual void setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode) = 0; - virtual bool isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode) const = 0; - - virtual bool isProcessingParameterSupported(ProcessingParameter) const = 0; - virtual QVariant processingParameter(ProcessingParameter parameter) const = 0; - virtual void setProcessingParameter(ProcessingParameter parameter, QVariant value) = 0; + virtual bool isParameterSupported(ProcessingParameter) const = 0; + virtual bool isParameterValueSupported(ProcessingParameter parameter, const QVariant &value) const = 0; + virtual QVariant parameter(ProcessingParameter parameter) const = 0; + virtual void setParameter(ProcessingParameter parameter, const QVariant &value) = 0; protected: QCameraImageProcessingControl(QObject* parent = 0); diff --git a/tests/auto/unit/qcamera/tst_qcamera.cpp b/tests/auto/unit/qcamera/tst_qcamera.cpp index 7f09b07eb..83b00a338 100644 --- a/tests/auto/unit/qcamera/tst_qcamera.cpp +++ b/tests/auto/unit/qcamera/tst_qcamera.cpp @@ -217,9 +217,9 @@ void tst_QCamera::testSimpleCameraWhiteBalance() QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto); camera.imageProcessing()->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceCloudy); QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto); - QCOMPARE(camera.imageProcessing()->manualWhiteBalance(), 0); + QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0); camera.imageProcessing()->setManualWhiteBalance(5000); - QCOMPARE(camera.imageProcessing()->manualWhiteBalance(), 0); + QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0); } void tst_QCamera::testSimpleCameraExposure() @@ -529,7 +529,7 @@ void tst_QCamera::testCameraWhiteBalance() MockCameraService service; service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFlash); service.mockImageProcessingControl->setSupportedWhiteBalanceModes(whiteBalanceModes); - service.mockImageProcessingControl->setProcessingParameter( + service.mockImageProcessingControl->setParameter( QCameraImageProcessingControl::ColorTemperature, QVariant(34)); @@ -549,10 +549,10 @@ void tst_QCamera::testCameraWhiteBalance() cameraImageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceManual); QCOMPARE(cameraImageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceManual); - QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 34); + QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 34.0); - cameraImageProcessing->setManualWhiteBalance(432); - QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 432); + cameraImageProcessing->setManualWhiteBalance(432.0); + QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 432.0); } void tst_QCamera::testCameraExposure() @@ -1550,11 +1550,11 @@ void tst_QCamera::testContrast() QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing(); QVERIFY(cameraImageProcessing->contrast() ==0); - cameraImageProcessing->setContrast(123); - QVERIFY(cameraImageProcessing->contrast() ==123); + cameraImageProcessing->setContrast(0.123); + QCOMPARE(cameraImageProcessing->contrast(), 0.123); cameraImageProcessing->setContrast(4.56); - QVERIFY(cameraImageProcessing->contrast() ==4); + QCOMPARE(cameraImageProcessing->contrast(), 4.56); } void tst_QCamera::testDenoisingLevel() @@ -1562,18 +1562,13 @@ void tst_QCamera::testDenoisingLevel() QCamera camera; QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing(); - if (cameraImageProcessing->isDenoisingSupported()) - { - QVERIFY(cameraImageProcessing->denoisingLevel() == -1); + QCOMPARE(cameraImageProcessing->denoisingLevel()+1 , 1.0); - cameraImageProcessing->setDenoisingLevel(0); - QVERIFY(cameraImageProcessing->denoisingLevel() == 0); + cameraImageProcessing->setDenoisingLevel(-0.3); + QCOMPARE(cameraImageProcessing->denoisingLevel() , -0.3); - cameraImageProcessing->setDenoisingLevel(12); - QVERIFY(cameraImageProcessing->denoisingLevel() == 12); - } - else - QVERIFY(cameraImageProcessing->denoisingLevel() == -1); + cameraImageProcessing->setDenoisingLevel(0.3); + QCOMPARE(cameraImageProcessing->denoisingLevel() , 0.3); } void tst_QCamera::testIsAvailable() @@ -1587,19 +1582,13 @@ void tst_QCamera::testSaturation() { QCamera camera; QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing(); - QVERIFY(cameraImageProcessing->saturation() == 0); - - cameraImageProcessing->setSaturation(50); - QVERIFY(cameraImageProcessing->saturation() == 50); + QCOMPARE(cameraImageProcessing->saturation()+1.0, 1.0); - cameraImageProcessing->setSaturation(-50); - QVERIFY(cameraImageProcessing->saturation() == -50); + cameraImageProcessing->setSaturation(0.5); + QCOMPARE(cameraImageProcessing->saturation(), 0.5); - cameraImageProcessing->setSaturation(100); - QVERIFY(cameraImageProcessing->saturation() == 100); - - cameraImageProcessing->setSaturation(-100); - QVERIFY(cameraImageProcessing->saturation() == -100); + cameraImageProcessing->setSaturation(-0.5); + QCOMPARE(cameraImageProcessing->saturation(), -0.5); } void tst_QCamera::testSharpeningLevel() @@ -1607,14 +1596,14 @@ void tst_QCamera::testSharpeningLevel() QCamera camera; QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing(); - QVERIFY(cameraImageProcessing->isSharpeningSupported()); - QVERIFY(cameraImageProcessing->sharpeningLevel() == -1); - cameraImageProcessing->setSharpeningLevel(123); - QVERIFY(cameraImageProcessing->sharpeningLevel() == 123); + QCOMPARE(cameraImageProcessing->sharpeningLevel()+1 , 1.0); + + cameraImageProcessing->setSharpeningLevel(-0.3); + QCOMPARE(cameraImageProcessing->sharpeningLevel() , -0.3); - cameraImageProcessing->setSharpeningLevel(4.67); - QVERIFY(cameraImageProcessing->sharpeningLevel() == 4); + cameraImageProcessing->setSharpeningLevel(0.3); + QCOMPARE(cameraImageProcessing->sharpeningLevel() , 0.3); } void tst_QCamera::testEnumOfQCameraImageProcessing() diff --git a/tests/auto/unit/qmultimedia_common/mockcameraimageprocessingcontrol.h b/tests/auto/unit/qmultimedia_common/mockcameraimageprocessingcontrol.h index 29a3a1b59..eca2d346d 100644 --- a/tests/auto/unit/qmultimedia_common/mockcameraimageprocessingcontrol.h +++ b/tests/auto/unit/qmultimedia_common/mockcameraimageprocessingcontrol.h @@ -73,67 +73,75 @@ public: m_supportedWhiteBalance = modes; } - bool isProcessingParameterSupported(ProcessingParameter parameter) const + bool isParameterSupported(ProcessingParameter parameter) const { - //return parameter == Contrast || parameter == Sharpening || parameter == ColorTemperature; switch (parameter) { - case Contrast: - case Brightness: - case Sharpening: - case Saturation: - case Denoising: + case ContrastAdjustment: + case BrightnessAdjustment: + case SharpeningAdjustment: + case SaturationAdjustment: + case DenoisingAdjustment: case ColorTemperature: - case ExtendedParameter: + case WhiteBalancePreset: return true; default : return false; } } - QVariant processingParameter(ProcessingParameter parameter) const + + bool isParameterValueSupported(ProcessingParameter parameter, const QVariant &value) const + { + if (parameter != WhiteBalancePreset) + return false; + + return m_supportedWhiteBalance.contains(value.value()); + } + + QVariant parameter(ProcessingParameter parameter) const { switch (parameter) { - case Contrast: + case ContrastAdjustment: return m_contrast; - case Saturation: + case SaturationAdjustment: return m_saturation; - case Brightness: + case BrightnessAdjustment: return m_brightness; - case Sharpening: + case SharpeningAdjustment: return m_sharpeningLevel; - case Denoising: + case DenoisingAdjustment: return m_denoising; case ColorTemperature: return m_manualWhiteBalance; - case ExtendedParameter: - return m_extendedParameter; + case WhiteBalancePreset: + return QVariant::fromValue(m_whiteBalanceMode); default: return QVariant(); } } - void setProcessingParameter(ProcessingParameter parameter, QVariant value) + void setParameter(ProcessingParameter parameter, const QVariant &value) { switch (parameter) { - case Contrast: + case ContrastAdjustment: m_contrast = value; break; - case Saturation: + case SaturationAdjustment: m_saturation = value; break; - case Brightness: + case BrightnessAdjustment: m_brightness = value; break; - case Sharpening: + case SharpeningAdjustment: m_sharpeningLevel = value; break; - case Denoising: + case DenoisingAdjustment: m_denoising = value; break; case ColorTemperature: m_manualWhiteBalance = value; break; - case ExtendedParameter: - m_extendedParameter = value; + case WhiteBalancePreset: + m_whiteBalanceMode = value.value(); break; default: break; @@ -150,7 +158,6 @@ private: QVariant m_saturation; QVariant m_brightness; QVariant m_denoising; - QVariant m_extendedParameter; }; #endif // MOCKCAMERAIMAGEPROCESSINGCONTROL_H -- cgit v1.2.3