Updated the camerabin2 based camera with QtMultimedia changes

Moved it to the separate plugin as the rest of gstreamer based services;
Updated with libqgsttools_p changes;
Implemented QMediaRecorder::status property;
Made gst_photography dependency optional,
it's not always available on desktop;
Added video recording case to auto integration test;
Moved backend implementation into qt namespace

Task-number: QTBUG-26046
Change-Id: Iacfc1a6e263a4c0201d5eb28d04c960b87a230c0
Reviewed-by: Michael Goddard <michael.goddard@nokia.com>

1 files changed, 68 insertions, 17 deletions

diff --git a/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp b/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
index 4983678c4..d0e75cd67 100644
--- a/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
+++ b/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
@@ -42,16 +42,24 @@
 #include "camerabinimageprocessing.h"
 #include "camerabinsession.h"
 
+#ifdef HAVE_GST_PHOTOGRAPHY
+#include <gst/interfaces/photography.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
 CameraBinImageProcessing::CameraBinImageProcessing(CameraBinSession *session)
     :QCameraImageProcessingControl(session),
      m_session(session)
 {
+#ifdef HAVE_GST_PHOTOGRAPHY
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_AUTO] = QCameraImageProcessing::WhiteBalanceAuto;
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT] = QCameraImageProcessing::WhiteBalanceSunlight;
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_CLOUDY] = QCameraImageProcessing::WhiteBalanceCloudy;
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_SUNSET] = QCameraImageProcessing::WhiteBalanceSunset;
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN] = QCameraImageProcessing::WhiteBalanceTungsten;
     m_mappedWbValues[GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT] = QCameraImageProcessing::WhiteBalanceFluorescent;
+#endif
 
     updateColorBalanceValues();
 }
@@ -73,22 +81,29 @@ void CameraBinImageProcessing::updateColorBalanceValues()
     const GList *item;
     GstColorBalanceChannel *channel;
     gint cur_value;
+    qreal scaledValue = 0;
 
     for (item = controls; item; item = g_list_next (item)) {
         channel = (GstColorBalanceChannel *)item->data;
         cur_value = gst_color_balance_get_value (balance, channel);
 
+        //map the [min_value..max_value] range to [-1.0 .. 1.0]
+        if (channel->min_value != channel->max_value) {
+            scaledValue = qreal(cur_value - channel->min_value) /
+                    (channel->max_value - channel->min_value) * 2 - 1;
+        }
+
         if (!g_ascii_strcasecmp (channel->label, "brightness")) {
-            m_values[QCameraImageProcessingControl::Brightness] = cur_value;
+            m_values[QCameraImageProcessingControl::BrightnessAdjustment] = scaledValue;
         } else if (!g_ascii_strcasecmp (channel->label, "contrast")) {
-            m_values[QCameraImageProcessingControl::Contrast] = cur_value;
+            m_values[QCameraImageProcessingControl::ContrastAdjustment] = scaledValue;
         } else if (!g_ascii_strcasecmp (channel->label, "saturation")) {
-            m_values[QCameraImageProcessingControl::Saturation] = cur_value;
+            m_values[QCameraImageProcessingControl::SaturationAdjustment] = scaledValue;
         }
     }
 }
 
-bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, int value)
+bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, qreal value)
 {
 
     if (!GST_IS_COLOR_BALANCE(m_session->cameraBin())) {
@@ -106,7 +121,11 @@ bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, int
         colorBalanceChannel = (GstColorBalanceChannel *)item->data;
 
         if (!g_ascii_strcasecmp (colorBalanceChannel->label, channel.toLatin1())) {
-            gst_color_balance_set_value (balance, colorBalanceChannel, value);
+            //map the [-1.0 .. 1.0] range to [min_value..max_value]
+            gint scaledValue = colorBalanceChannel->min_value + qRound(
+                        (value+1.0)/2.0 * (colorBalanceChannel->max_value - colorBalanceChannel->min_value));
+
+            gst_color_balance_set_value (balance, colorBalanceChannel, scaledValue);
             return true;
         }
     }
@@ -116,30 +135,59 @@ bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, int
 
 QCameraImageProcessing::WhiteBalanceMode CameraBinImageProcessing::whiteBalanceMode() const
 {
+#ifdef HAVE_GST_PHOTOGRAPHY
     GstWhiteBalanceMode wbMode;
     gst_photography_get_white_balance_mode(m_session->photography(), &wbMode);
     return m_mappedWbValues[wbMode];
+#else
+    return QCameraImageProcessing::WhiteBalanceAuto;
+#endif
 }
 
 void CameraBinImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode)
 {
+#ifdef HAVE_GST_PHOTOGRAPHY
     if (isWhiteBalanceModeSupported(mode))
         gst_photography_set_white_balance_mode(m_session->photography(), m_mappedWbValues.key(mode));
+#else
+    Q_UNUSED(mode);
+#endif
 }
 
 bool CameraBinImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const
 {
+#ifdef HAVE_GST_PHOTOGRAPHY
     return m_mappedWbValues.values().contains(mode);
+#else
+    return mode == QCameraImageProcessing::WhiteBalanceAuto;
+#endif
 }
 
-bool CameraBinImageProcessing::isProcessingParameterSupported(QCameraImageProcessingControl::ProcessingParameter parameter) const
+bool CameraBinImageProcessing::isParameterSupported(QCameraImageProcessingControl::ProcessingParameter parameter) const
 {
     return parameter == QCameraImageProcessingControl::Contrast
             || parameter == QCameraImageProcessingControl::Brightness
-            || parameter == QCameraImageProcessingControl::Saturation;
+            || parameter == QCameraImageProcessingControl::Saturation
+            || parameter == QCameraImageProcessingControl::WhiteBalancePreset;
 }
 
-QVariant CameraBinImageProcessing::processingParameter(
+bool CameraBinImageProcessing::isParameterValueSupported(QCameraImageProcessingControl::ProcessingParameter parameter, const QVariant &value) const
+{
+    switch (parameter) {
+    case ContrastAdjustment:
+    case BrightnessAdjustment:
+    case SaturationAdjustment:
+        return qAbs(value.toReal()) <= 1.0;
+    case WhiteBalancePreset:
+        return isWhiteBalanceModeSupported(value.value<QCameraImageProcessing::WhiteBalanceMode>());
+    default:
+        break;
+    }
+
+    return false;
+}
+
+QVariant CameraBinImageProcessing::parameter(
         QCameraImageProcessingControl::ProcessingParameter parameter) const
 {
     if (m_values.contains(parameter))
@@ -148,19 +196,21 @@ QVariant CameraBinImageProcessing::processingParameter(
         return QVariant();
 }
 
-void CameraBinImageProcessing::setProcessingParameter(
-        QCameraImageProcessingControl::ProcessingParameter parameter,
-        QVariant value)
+void CameraBinImageProcessing::setParameter(QCameraImageProcessingControl::ProcessingParameter parameter,
+        const QVariant &value)
 {
     switch (parameter) {
-    case Contrast:
-        setColorBalanceValue("contrast", value.toInt());
+    case ContrastAdjustment:
+        setColorBalanceValue("contrast", value.toReal());
+        break;
+    case BrightnessAdjustment:
+        setColorBalanceValue("brightness", value.toReal());
         break;
-    case Brightness:
-        setColorBalanceValue("brightness", value.toInt());
+    case SaturationAdjustment:
+        setColorBalanceValue("saturation", value.toReal());
         break;
-    case Saturation:
-        setColorBalanceValue("saturation", value.toInt());
+    case WhiteBalancePreset:
+        setWhiteBalanceMode(value.value<QCameraImageProcessing::WhiteBalanceMode>());
         break;
     default:
         break;
@@ -169,3 +219,4 @@ void CameraBinImageProcessing::setProcessingParameter(
     updateColorBalanceValues();
 }
 
+QT_END_NAMESPACE