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 <jonas.rabbe@nokia.com>
Reviewed-by: Michael Goddard <michael.goddard@nokia.com>

2 files changed, 57 insertions, 61 deletions

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<QCameraImageProcessing::WhiteBalanceMode>());
+    }
+
+    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<QCameraImageProcessing::WhiteBalanceMode>(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<QCameraImageProcessing::WhiteBalanceMode>();
             break;
         default:
             break;
@@ -150,7 +158,6 @@ private:
     QVariant m_saturation;
     QVariant m_brightness;
     QVariant m_denoising;
-    QVariant m_extendedParameter;
 };
 
 #endif // MOCKCAMERAIMAGEPROCESSINGCONTROL_H