GStreamer: Add color balance and sharpening adjustments using V4L2

GStreamer's backend does not implements this features, therefore now is
used the V4L2 interface for the contrast, saturation, brightness and the
sharpening adjustments. The V4l2 interface works together with the
GStreamer and covers the features which are not supported by the
GStreamer.

Change-Id: I995ed6cb096a29543fb80206384a92c13a1d1af2
Reviewed-by: Yoann Lopes <yoann.lopes@theqtcompany.com>

3 files changed, 124 insertions, 11 deletions

diff --git a/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp b/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
index d2ff89af0..2d1659900 100644
--- a/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
+++ b/src/plugins/gstreamer/camerabin/camerabinimageprocessing.cpp
@@ -234,8 +234,22 @@ bool CameraBinImageProcessing::isParameterValueSupported(QCameraImageProcessingC
     switch (parameter) {
     case ContrastAdjustment:
     case BrightnessAdjustment:
-    case SaturationAdjustment:
-        return GST_IS_COLOR_BALANCE(m_session->cameraBin()) && qAbs(value.toReal()) <= 1.0;
+    case SaturationAdjustment: {
+        const bool isGstColorBalanceValueSupported = GST_IS_COLOR_BALANCE(m_session->cameraBin())
+                && qAbs(value.toReal()) <= 1.0;
+#ifdef USE_V4L
+        if (!isGstColorBalanceValueSupported)
+            return m_v4lImageControl->isParameterValueSupported(parameter, value);
+#endif
+        return isGstColorBalanceValueSupported;
+    }
+    case SharpeningAdjustment: {
+#ifdef USE_V4L
+        return m_v4lImageControl->isParameterValueSupported(parameter, value);
+#else
+        return false;
+#endif
+    }
     case WhiteBalancePreset: {
         const QCameraImageProcessing::WhiteBalanceMode mode =
                 value.value<QCameraImageProcessing::WhiteBalanceMode>();
@@ -303,25 +317,58 @@ QVariant CameraBinImageProcessing::parameter(
         }
 #endif
         return QVariant::fromValue(QCameraImageProcessing::ColorFilterNone);
-    default:
-        return m_values.contains(parameter)
+    default: {
+        const bool isGstParameterSupported = m_values.contains(parameter);
+#ifdef USE_V4L
+        if (!isGstParameterSupported) {
+            if (parameter == QCameraImageProcessingControl::BrightnessAdjustment
+                    || parameter == QCameraImageProcessingControl::ContrastAdjustment
+                    || parameter == QCameraImageProcessingControl::SaturationAdjustment
+                    || parameter == QCameraImageProcessingControl::SharpeningAdjustment) {
+                return m_v4lImageControl->parameter(parameter);
+            }
+        }
+#endif
+        return isGstParameterSupported
                 ? QVariant(m_values.value(parameter))
                 : QVariant();
     }
+    }
 }
 
 void CameraBinImageProcessing::setParameter(QCameraImageProcessingControl::ProcessingParameter parameter,
         const QVariant &value)
 {
     switch (parameter) {
-    case ContrastAdjustment:
-        setColorBalanceValue("contrast", value.toReal());
+    case ContrastAdjustment: {
+        if (!setColorBalanceValue("contrast", value.toReal())) {
+#ifdef USE_V4L
+            m_v4lImageControl->setParameter(parameter, value);
+#endif
+        }
+    }
         break;
-    case BrightnessAdjustment:
-        setColorBalanceValue("brightness", value.toReal());
+    case BrightnessAdjustment: {
+        if (!setColorBalanceValue("brightness", value.toReal())) {
+#ifdef USE_V4L
+            m_v4lImageControl->setParameter(parameter, value);
+#endif
+        }
+    }
         break;
-    case SaturationAdjustment:
-        setColorBalanceValue("saturation", value.toReal());
+    case SaturationAdjustment: {
+        if (!setColorBalanceValue("saturation", value.toReal())) {
+#ifdef USE_V4L
+            m_v4lImageControl->setParameter(parameter, value);
+#endif
+        }
+    }
+        break;
+    case SharpeningAdjustment: {
+#ifdef USE_V4L
+        m_v4lImageControl->setParameter(parameter, value);
+#endif
+    }
         break;
     case WhiteBalancePreset: {
         if (!setWhiteBalanceMode(value.value<QCameraImageProcessing::WhiteBalanceMode>())) {
diff --git a/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.cpp b/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.cpp
index 47522565c..bf51cbfd0 100644
--- a/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.cpp
+++ b/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.cpp
@@ -92,6 +92,19 @@ bool CameraBinV4LImageProcessing::isParameterValueSupported(
     }
         break;
 
+    case QCameraImageProcessingControl::ContrastAdjustment: // falling back
+    case QCameraImageProcessingControl::SaturationAdjustment: // falling back
+    case QCameraImageProcessingControl::BrightnessAdjustment: // falling back
+    case QCameraImageProcessingControl::SharpeningAdjustment: {
+        const qint32 sourceValue = sourceImageProcessingParameterValue(
+                    value.toReal(), (*sourceValueInfo));
+        if (sourceValue < (*sourceValueInfo).minimumValue
+                || sourceValue > (*sourceValueInfo).maximumValue) {
+            return false;
+        }
+    }
+        break;
+
     default:
         return false;
     }
@@ -140,6 +153,14 @@ QVariant CameraBinV4LImageProcessing::parameter(
     case QCameraImageProcessingControl::ColorTemperature:
         return QVariant::fromValue<qint32>(control.value);
 
+    case QCameraImageProcessingControl::ContrastAdjustment: // falling back
+    case QCameraImageProcessingControl::SaturationAdjustment: // falling back
+    case QCameraImageProcessingControl::BrightnessAdjustment: // falling back
+    case QCameraImageProcessingControl::SharpeningAdjustment: {
+        return scaledImageProcessingParameterValue(
+                    control.value, (*sourceValueInfo));
+    }
+
     default:
         return QVariant();
     }
@@ -184,6 +205,14 @@ void CameraBinV4LImageProcessing::setParameter(
         control.value = value.toInt();
         break;
 
+    case QCameraImageProcessingControl::ContrastAdjustment: // falling back
+    case QCameraImageProcessingControl::SaturationAdjustment: // falling back
+    case QCameraImageProcessingControl::BrightnessAdjustment: // falling back
+    case QCameraImageProcessingControl::SharpeningAdjustment:
+        control.value = sourceImageProcessingParameterValue(
+                    value.toReal(), (*sourceValueInfo));
+        break;
+
     default:
         return;
     }
@@ -213,7 +242,11 @@ void CameraBinV4LImageProcessing::updateParametersInfo(
             QCameraImageProcessingControl::ProcessingParameter parameter;
         } supportedParametersEntries[] = {
             { V4L2_CID_AUTO_WHITE_BALANCE, QCameraImageProcessingControl::WhiteBalancePreset },
-            { V4L2_CID_WHITE_BALANCE_TEMPERATURE, QCameraImageProcessingControl::ColorTemperature }
+            { V4L2_CID_WHITE_BALANCE_TEMPERATURE, QCameraImageProcessingControl::ColorTemperature },
+            { V4L2_CID_CONTRAST, QCameraImageProcessingControl::ContrastAdjustment },
+            { V4L2_CID_SATURATION, QCameraImageProcessingControl::SaturationAdjustment },
+            { V4L2_CID_BRIGHTNESS, QCameraImageProcessingControl::BrightnessAdjustment },
+            { V4L2_CID_SHARPNESS, QCameraImageProcessingControl::SharpeningAdjustment }
         };
 
         for (int i = 0; i < int(sizeof(supportedParametersEntries) / sizeof(SupportedParameterEntry)); ++i) {
@@ -239,4 +272,33 @@ void CameraBinV4LImageProcessing::updateParametersInfo(
     }
 }
 
+qreal CameraBinV4LImageProcessing::scaledImageProcessingParameterValue(
+        qint32 sourceValue, const SourceParameterValueInfo &sourceValueInfo)
+{
+    if (sourceValue == sourceValueInfo.defaultValue) {
+        return 0.0f;
+    } else if (sourceValue < sourceValueInfo.defaultValue) {
+        return ((sourceValue - sourceValueInfo.minimumValue)
+                / qreal(sourceValueInfo.defaultValue - sourceValueInfo.minimumValue))
+                + (-1.0f);
+    } else {
+        return ((sourceValue - sourceValueInfo.defaultValue)
+                / qreal(sourceValueInfo.maximumValue - sourceValueInfo.defaultValue));
+    }
+}
+
+qint32 CameraBinV4LImageProcessing::sourceImageProcessingParameterValue(
+        qreal scaledValue, const SourceParameterValueInfo &valueRange)
+{
+    if (qFuzzyIsNull(scaledValue)) {
+        return valueRange.defaultValue;
+    } else if (scaledValue < 0.0f) {
+        return ((scaledValue - (-1.0f)) * (valueRange.defaultValue - valueRange.minimumValue))
+                + valueRange.minimumValue;
+    } else {
+        return (scaledValue * (valueRange.maximumValue - valueRange.defaultValue))
+                + valueRange.defaultValue;
+    }
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.h b/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.h
index 03b3917ed..7961d6c0d 100644
--- a/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.h
+++ b/src/plugins/gstreamer/camerabin/camerabinv4limageprocessing.h
@@ -70,6 +70,10 @@ private:
         quint32 cid; // V4L control id
     };
 
+    static qreal scaledImageProcessingParameterValue(
+            qint32 sourceValue, const SourceParameterValueInfo &sourceValueInfo);
+    static qint32 sourceImageProcessingParameterValue(
+            qreal scaledValue, const SourceParameterValueInfo &valueRange);
 private:
     CameraBinSession *m_session;
     QMap<ProcessingParameter, SourceParameterValueInfo> m_parametersInfo;