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>

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>())) {

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

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;