Some QCamera API cleanups

* Add QCamera::Features flags to determine supported features.
* Rename (manual)shutterSpeed to (manual)ExposureTime, as digital
  cameras don't have a shutter anymore.

Implement support for those feature flags on gstreamer, and
add support for querying iso sensitivity, exposure time and
setting a manual iso value.

Change-Id: I776aa4bc11b02e4de4b02fe33aaccfb83e220ef7
Reviewed-by: Doris Verria <doris.verria@qt.io>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

8 files changed, 142 insertions, 54 deletions

diff --git a/src/multimedia/camera/qcamera.cpp b/src/multimedia/camera/qcamera.cpp
index 116f8985e..835f84f19 100644
--- a/src/multimedia/camera/qcamera.cpp
+++ b/src/multimedia/camera/qcamera.cpp
@@ -243,6 +243,12 @@ QString QCamera::errorString() const
     return d_func()->errorString;
 }
 
+QCamera::Features QCamera::supportedFeatures() const
+{
+    Q_D(const QCamera);
+    return d->control ? d->control->supportedFeatures() : QCamera::Features{};
+}
+
 /*! \fn void QCamera::start()
 
     Starts the camera.
@@ -826,14 +832,14 @@ float QCamera::maximumShutterSpeed() const
 }
 
 /*!
-    \property QCamera::shutterSpeed
+    \property QCamera::exposureTime
     \brief Camera's shutter speed in seconds.
 
-    \sa supportedShutterSpeeds(), setAutoShutterSpeed(), setManualShutterSpeed()
+    \sa supportedShutterSpeeds(), setAutoShutterSpeed(), setManualExposureTime()
 */
 
 /*!
-    \fn QCamera::shutterSpeedChanged(qreal speed)
+    \fn QCamera::exposureTimeChanged(qreal speed)
 
     Signals that a camera's shutter \a speed has changed.
 */
@@ -846,41 +852,45 @@ float QCamera::maximumShutterSpeed() const
 */
 
 /*!
-    Returns the current shutter speed in seconds.
+    Returns the current exposure time in seconds.
 */
 
-float QCamera::shutterSpeed() const
+float QCamera::exposureTime() const
 {
     Q_D(const QCamera);
-    return d->control ? d->control->shutterSpeed() : -1;
+    return d->control ? d->control->exposureTime() : -1;
 }
 
 /*!
-    Set the manual shutter speed to \a seconds
+    Set the manual exposure time to \a seconds
 */
 
-void QCamera::setManualShutterSpeed(float seconds)
+void QCamera::setManualExposureTime(float seconds)
 {
     Q_D(QCamera);
     if (d->control)
-        d->control->setManualShutterSpeed(seconds);
+        d->control->setManualExposureTime(seconds);
 }
 
-float QCamera::manualShutterSpeed() const
+/*!
+    Returns the manual exposure time in \a seconds, or -1
+    if the camera is using automatic exposure times.
+*/
+float QCamera::manualExposureTime() const
 {
     Q_D(const QCamera);
-    return d->control ? d->control->manualShutterSpeed() : -1;
+    return d->control ? d->control->manualExposureTime() : -1;
 }
 
 /*!
     Turn on auto shutter speed
 */
 
-void QCamera::setAutoShutterSpeed()
+void QCamera::setAutoExposureTime()
 {
     Q_D(QCamera);
     if (d->control)
-        d->control->setManualShutterSpeed(-1);
+        d->control->setManualExposureTime(-1);
 }
 
 
@@ -934,7 +944,7 @@ void QCamera::setAutoShutterSpeed()
 */
 
 /*!
-    \fn void QCamera::shutterSpeedRangeChanged()
+    \fn void QCamera::exposureTimeRangeChanged()
 
     Signal emitted when the shutter speed range has changed.
 */
diff --git a/src/multimedia/camera/qcamera.h b/src/multimedia/camera/qcamera.h
index b84e90c36..1b4636307 100644
--- a/src/multimedia/camera/qcamera.h
+++ b/src/multimedia/camera/qcamera.h
@@ -77,7 +77,7 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject
     Q_PROPERTY(float minimumZoomFactor READ minimumZoomFactor NOTIFY minimumZoomFactorChanged)
     Q_PROPERTY(float maximumZoomFactor READ maximumZoomFactor NOTIFY maximumZoomFactorChanged)
     Q_PROPERTY(float zoomFactor READ zoomFactor WRITE setZoomFactor NOTIFY zoomFactorChanged)
-    Q_PROPERTY(qreal shutterSpeed READ shutterSpeed NOTIFY shutterSpeedChanged)
+    Q_PROPERTY(qreal exposureTime READ exposureTime NOTIFY exposureTimeChanged)
     Q_PROPERTY(int isoSensitivity READ isoSensitivity NOTIFY isoSensitivityChanged)
     Q_PROPERTY(qreal exposureCompensation READ exposureCompensation WRITE setExposureCompensation NOTIFY exposureCompensationChanged)
     Q_PROPERTY(QCamera::ExposureMode exposureMode READ exposureMode WRITE setExposureMode NOTIFY exposureModeChanged)
@@ -87,6 +87,7 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject
 
     Q_PROPERTY(WhiteBalanceMode whiteBalanceMode READ whiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged)
     Q_PROPERTY(int colorTemperature READ colorTemperature WRITE setColorTemperature NOTIFY colorTemperatureChanged)
+    Q_PROPERTY(Features supportedFeatures READ supportedFeatures NOTIFY supportedFeaturesChanged)
 
     Q_ENUMS(Status)
     Q_ENUMS(Error)
@@ -166,6 +167,14 @@ public:
         WhiteBalanceSunset = 8
     };
 
+    enum class Feature {
+        ColorTemperature = 0x1,
+        ExposureCompensation = 0x2,
+        IsoSensitivity = 0x4,
+        ManualExposureTime = 0x8
+    };
+    Q_DECLARE_FLAGS(Features, Feature);
+
     explicit QCamera(QObject *parent = nullptr);
     explicit QCamera(const QCameraInfo& cameraInfo, QObject *parent = nullptr);
     explicit QCamera(QCameraInfo::Position position, QObject *parent = nullptr);
@@ -187,6 +196,8 @@ public:
     Error error() const;
     QString errorString() const;
 
+    Features supportedFeatures() const;
+
     FocusMode focusMode() const;
     void setFocusMode(FocusMode mode);
     bool isFocusModeSupported(FocusMode mode) const;
@@ -220,8 +231,8 @@ public:
     int isoSensitivity() const;
     int manualIsoSensitivity() const;
 
-    float shutterSpeed() const;
-    float manualShutterSpeed() const;
+    float exposureTime() const;
+    float manualExposureTime() const;
 
     int minimumIsoSensitivity() const;
     int maximumIsoSensitivity() const;
@@ -250,8 +261,8 @@ public Q_SLOTS:
     void setManualIsoSensitivity(int iso);
     void setAutoIsoSensitivity();
 
-    void setManualShutterSpeed(float seconds);
-    void setAutoShutterSpeed();
+    void setManualExposureTime(float seconds);
+    void setAutoExposureTime();
 
     void setWhiteBalanceMode(WhiteBalanceMode mode);
     void setColorTemperature(int colorTemperature);
@@ -263,6 +274,7 @@ Q_SIGNALS:
     void errorOccurred(QCamera::Error error, const QString &errorString);
     void cameraInfoChanged();
     void cameraFormatChanged();
+    void supportedFeaturesChanged();
 
     void focusModeChanged();
     void zoomFactorChanged(float);
@@ -275,7 +287,7 @@ Q_SIGNALS:
     void flashModeChanged();
     void torchModeChanged();
 
-    void shutterSpeedChanged(qreal speed);
+    void exposureTimeChanged(qreal speed);
     void isoSensitivityChanged(int);
     void exposureCompensationChanged(qreal);
     void exposureModeChanged();
@@ -297,6 +309,8 @@ private:
     friend class QCameraInfo;
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(QCamera::Features);
+
 QT_END_NAMESPACE
 
 Q_MEDIA_ENUM_DEBUG(QCamera, Status)
diff --git a/src/multimedia/platform/darwin/camera/avfcamera.mm b/src/multimedia/platform/darwin/camera/avfcamera.mm
index d026ee3bc..bd4fb18eb 100644
--- a/src/multimedia/platform/darwin/camera/avfcamera.mm
+++ b/src/multimedia/platform/darwin/camera/avfcamera.mm
@@ -460,10 +460,10 @@ void AVFCamera::updateCameraConfiguration()
     CMTime newDuration = AVCaptureExposureDurationCurrent;
     bool setCustomMode = false;
 
-    float shutterSpeed = manualShutterSpeed();
-    if (shutterSpeed > 0
-        && !qt_exposure_duration_equal(captureDevice, shutterSpeed)) {
-        newDuration = CMTimeMakeWithSeconds(shutterSpeed, captureDevice.exposureDuration.timescale);
+    float exposureTime = manualExposureTime();
+    if (exposureTime > 0
+        && !qt_exposure_duration_equal(captureDevice, exposureTime)) {
+        newDuration = CMTimeMakeWithSeconds(exposureTime, captureDevice.exposureDuration.timescale);
         if (!qt_check_exposure_duration(captureDevice, newDuration)) {
             qDebugCamera() << Q_FUNC_INFO << "requested exposure duration is out of range";
             return;
@@ -763,7 +763,7 @@ void AVFCamera::setExposureCompensation(float bias)
 #endif
 }
 
-void AVFCamera::setManualShutterSpeed(float value)
+void AVFCamera::setManualExposureTime(float value)
 {
 #ifdef Q_OS_IOS
     if (value < 0) {
@@ -773,7 +773,7 @@ void AVFCamera::setManualShutterSpeed(float value)
 
     AVCaptureDevice *captureDevice = device();
     if (!captureDevice) {
-        shutterSpeedChanged(value);
+        exposureTimeChanged(value);
         return;
     }
 
@@ -796,14 +796,14 @@ void AVFCamera::setManualShutterSpeed(float value)
                                                  ISO:AVCaptureISOCurrent
                                    completionHandler:nil];
 
-    shutterSpeedChanged(value);
+    exposureTimeChanged(value);
 
 #else
     Q_UNUSED(value);
 #endif
 }
 
-float AVFCamera::shutterSpeed() const
+float AVFCamera::exposureTime() const
 {
 #ifdef Q_OS_IOS
     AVCaptureDevice *captureDevice = device();
diff --git a/src/multimedia/platform/darwin/camera/avfcamera_p.h b/src/multimedia/platform/darwin/camera/avfcamera_p.h
index 75b52abb5..9ac6122a4 100644
--- a/src/multimedia/platform/darwin/camera/avfcamera_p.h
+++ b/src/multimedia/platform/darwin/camera/avfcamera_p.h
@@ -104,8 +104,8 @@ public:
     void setExposureCompensation(float bias) override;
     void setManualIsoSensitivity(int value) override;
     virtual int isoSensitivity() const override;
-    void setManualShutterSpeed(float value) override;
-    virtual float shutterSpeed() const override;
+    void setManualExposureTime(float value) override;
+    virtual float exposureTime() const override;
 
 #ifdef Q_OS_IOS
     // not supported on macOS
diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp
index d1d848e4c..b89fbbea7 100644
--- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp
+++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp
@@ -194,12 +194,17 @@ void QGstreamerCamera::setCaptureSession(QPlatformMediaCaptureSession *session)
 void QGstreamerCamera::updateCameraProperties()
 {
 #if QT_CONFIG(linux_v4l)
-    if (isV4L2Camera())
+    if (isV4L2Camera()) {
         initV4L2Controls();
+        return;
+    }
 #endif
 #if QT_CONFIG(gstreamer_photography)
     if (auto *p = photography())
         gst_photography_set_white_balance_mode(p, GST_PHOTOGRAPHY_WB_MODE_AUTO);
+    QCamera::Features f = QCamera::Feature::ColorTemperature | QCamera::Feature::ExposureCompensation |
+                          QCamera::Feature::IsoSensitivity | QCamera::Feature::ManualExposureTime;
+    supportedFeaturesChanged(f);
 #endif
 
 }
@@ -406,6 +411,18 @@ void QGstreamerCamera::setExposureCompensation(float compensation)
 
 void QGstreamerCamera::setManualIsoSensitivity(int iso)
 {
+#if QT_CONFIG(linux_v4l)
+    if (isV4L2Camera()) {
+        if (!(supportedFeatures() & QCamera::Feature::IsoSensitivity))
+            return;
+        setV4L2Parameter(V4L2_CID_ISO_SENSITIVITY_AUTO, iso <= 0 ? V4L2_ISO_SENSITIVITY_AUTO : V4L2_ISO_SENSITIVITY_MANUAL);
+        if (iso > 0) {
+            iso = qBound(minIso(), iso, maxIso());
+            setV4L2Parameter(V4L2_CID_ISO_SENSITIVITY, iso);
+        }
+        return;
+    }
+#endif
     if (auto *p = photography()) {
         if (gst_photography_set_iso_speed(p, iso))
             isoSensitivityChanged(iso);
@@ -414,6 +431,13 @@ void QGstreamerCamera::setManualIsoSensitivity(int iso)
 
 int QGstreamerCamera::isoSensitivity() const
 {
+#if QT_CONFIG(linux_v4l)
+    if (isV4L2Camera()) {
+        if (!(supportedFeatures() & QCamera::Feature::IsoSensitivity))
+            return -1;
+        return getV4L2Parameter(V4L2_CID_ISO_SENSITIVITY);
+    }
+#endif
     if (auto *p = photography()) {
         guint speed = 0;
         if (gst_photography_get_iso_speed(p, &speed))
@@ -422,25 +446,30 @@ int QGstreamerCamera::isoSensitivity() const
     return 100;
 }
 
-void QGstreamerCamera::setManualShutterSpeed(float secs)
+void QGstreamerCamera::setManualExposureTime(float secs)
 {
 #if QT_CONFIG(linux_v4l)
     if (isV4L2Camera() && v4l2ManualExposureSupported && v4l2AutoExposureSupported) {
         int exposure = qBound(v4l2MinExposure, qRound(secs*10000.), v4l2MaxExposure);
         setV4L2Parameter(V4L2_CID_EXPOSURE_ABSOLUTE, exposure);
-        shutterSpeedChanged(exposure/10000.);
+        exposureTimeChanged(exposure/10000.);
         return;
     }
 #endif
 
     if (auto *p = photography()) {
         if (gst_photography_set_exposure(p, guint(secs*1000000)))
-            shutterSpeedChanged(secs);
+            exposureTimeChanged(secs);
     }
 }
 
-float QGstreamerCamera::shutterSpeed() const
+float QGstreamerCamera::exposureTime() const
 {
+#if QT_CONFIG(linux_v4l)
+    if (isV4L2Camera()) {
+        return getV4L2Parameter(V4L2_CID_EXPOSURE_ABSOLUTE)/10000.;
+    }
+#endif
     if (auto *p = photography()) {
         guint32 exposure = 0;
         if (gst_photography_get_exposure(p, &exposure))
@@ -564,6 +593,8 @@ void QGstreamerCamera::initV4L2Controls()
 {
     v4l2AutoWhiteBalanceSupported = false;
     v4l2ColorTemperatureSupported = false;
+    QCamera::Features features;
+
 
     const QString deviceName = v4l2Device();
     Q_ASSERT(!deviceName.isEmpty());
@@ -581,10 +612,7 @@ void QGstreamerCamera::initV4L2Controls()
 
     if (::ioctl(v4l2FileDescriptor, VIDIOC_QUERYCTRL, &queryControl) == 0) {
         v4l2AutoWhiteBalanceSupported = true;
-        struct v4l2_control control;
-        control.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
-        control.value = true;
-        ::ioctl(v4l2FileDescriptor, VIDIOC_S_CTRL, &control);
+        setV4L2Parameter(V4L2_CID_AUTO_WHITE_BALANCE, true);
     }
 
     ::memset(&queryControl, 0, sizeof(queryControl));
@@ -593,6 +621,7 @@ void QGstreamerCamera::initV4L2Controls()
         v4l2MinColorTemp = queryControl.minimum;
         v4l2MaxColorTemp = queryControl.maximum;
         v4l2ColorTemperatureSupported = true;
+        features |= QCamera::Feature::ColorTemperature;
     }
 
     ::memset(&queryControl, 0, sizeof(queryControl));
@@ -607,6 +636,7 @@ void QGstreamerCamera::initV4L2Controls()
         v4l2ManualExposureSupported = true;
         v4l2MinExposure = queryControl.minimum;
         v4l2MaxExposure = queryControl.maximum;
+        features |= QCamera::Feature::ManualExposureTime;
     }
 
     ::memset(&queryControl, 0, sizeof(queryControl));
@@ -614,7 +644,21 @@ void QGstreamerCamera::initV4L2Controls()
     if (::ioctl(v4l2FileDescriptor, VIDIOC_QUERYCTRL, &queryControl) == 0) {
         v4l2MinExposureAdjustment = queryControl.minimum;
         v4l2MaxExposureAdjustment = queryControl.maximum;
+        features |= QCamera::Feature::ExposureCompensation;
+    }
+
+    ::memset(&queryControl, 0, sizeof(queryControl));
+    queryControl.id = V4L2_CID_ISO_SENSITIVITY_AUTO;
+    if (::ioctl(v4l2FileDescriptor, VIDIOC_QUERYCTRL, &queryControl) == 0) {
+        queryControl.id = V4L2_CID_ISO_SENSITIVITY;
+        if (::ioctl(v4l2FileDescriptor, VIDIOC_QUERYCTRL, &queryControl) == 0) {
+            features |= QCamera::Feature::IsoSensitivity;
+            minIsoChanged(queryControl.minimum);
+            maxIsoChanged(queryControl.minimum);
+        }
     }
+
+    supportedFeaturesChanged(features);
 }
 
 int QGstreamerCamera::setV4L2ColorTemperature(int temperature)
@@ -641,10 +685,7 @@ int QGstreamerCamera::setV4L2ColorTemperature(int temperature)
 
 bool QGstreamerCamera::setV4L2Parameter(quint32 id, qint32 value)
 {
-    struct v4l2_control control;
-    ::memset(&control, 0, sizeof(control));
-    control.id = id;
-    control.value = value;
+    struct v4l2_control control{id, value};
     if (::ioctl(v4l2FileDescriptor, VIDIOC_S_CTRL, &control) != 0) {
         qWarning() << "Unable to set the V4L2 Parameter" << Qt::hex << id << "to" << value << qt_error_string(errno);
         return false;
@@ -652,6 +693,16 @@ bool QGstreamerCamera::setV4L2Parameter(quint32 id, qint32 value)
     return true;
 }
 
+int QGstreamerCamera::getV4L2Parameter(quint32 id) const
+{
+    struct v4l2_control control{id, 0};
+    if (::ioctl(v4l2FileDescriptor, VIDIOC_G_CTRL, &control) != 0) {
+        qWarning() << "Unable to get the V4L2 Parameter" << Qt::hex << id << qt_error_string(errno);
+        return 0;
+    }
+    return control.value;
+}
+
 #endif
 
 #endif
diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h
index 82a7c2c75..54c7112ab 100644
--- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h
+++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h
@@ -93,8 +93,8 @@ public:
     void setExposureCompensation(float) override;
     void setManualIsoSensitivity(int) override;
     int isoSensitivity() const override;
-    void setManualShutterSpeed(float) override;
-    float shutterSpeed() const override;
+    void setManualExposureTime(float) override;
+    float exposureTime() const override;
 #endif
     bool isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const override;
     void setWhiteBalanceMode(QCamera::WhiteBalanceMode mode) override;
@@ -109,6 +109,7 @@ private:
     void initV4L2Controls();
     int setV4L2ColorTemperature(int temperature);
     bool setV4L2Parameter(quint32 id, qint32 value);
+    int getV4L2Parameter(quint32 id) const;
 
     bool v4l2AutoWhiteBalanceSupported = false;
     bool v4l2ColorTemperatureSupported = false;
diff --git a/src/multimedia/platform/qplatformcamera.cpp b/src/multimedia/platform/qplatformcamera.cpp
index 518ec0652..fbb49dc54 100644
--- a/src/multimedia/platform/qplatformcamera.cpp
+++ b/src/multimedia/platform/qplatformcamera.cpp
@@ -157,6 +157,14 @@ QCameraFormat QPlatformCamera::findBestCameraFormat(const QCameraInfo &camera)
 */
 
 
+void QPlatformCamera::supportedFeaturesChanged(QCamera::Features f)
+{
+    if (m_supportedFeatures == f)
+        return;
+    m_supportedFeatures = f;
+    emit m_camera->supportedFeaturesChanged();
+}
+
 void QPlatformCamera::statusChanged(QCamera::Status s)
 {
     if (s == m_status)
@@ -273,12 +281,12 @@ void QPlatformCamera::isoSensitivityChanged(int iso)
     emit m_camera->isoSensitivityChanged(iso);
 }
 
-void QPlatformCamera::shutterSpeedChanged(float speed)
+void QPlatformCamera::exposureTimeChanged(float speed)
 {
-    if (m_shutterSpeed == speed)
+    if (m_exposureTime == speed)
         return;
-    m_shutterSpeed = speed;
-    emit m_camera->shutterSpeedChanged(speed);
+    m_exposureTime = speed;
+    emit m_camera->exposureTimeChanged(speed);
 }
 
 void QPlatformCamera::whiteBalanceModeChanged(QCamera::WhiteBalanceMode mode)
diff --git a/src/multimedia/platform/qplatformcamera_p.h b/src/multimedia/platform/qplatformcamera_p.h
index c895b22ad..3cc48f616 100644
--- a/src/multimedia/platform/qplatformcamera_p.h
+++ b/src/multimedia/platform/qplatformcamera_p.h
@@ -96,13 +96,15 @@ public:
     virtual void setExposureCompensation(float) {}
     virtual int isoSensitivity() const { return 100; }
     virtual void setManualIsoSensitivity(int) {}
-    virtual void setManualShutterSpeed(float) {}
-    virtual float shutterSpeed() const { return -1.; }
+    virtual void setManualExposureTime(float) {}
+    virtual float exposureTime() const { return -1.; }
 
     virtual bool isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const { return mode == QCamera::WhiteBalanceAuto; }
     virtual void setWhiteBalanceMode(QCamera::WhiteBalanceMode /*mode*/) {}
     virtual void setColorTemperature(int /*temperature*/) {}
 
+    QCamera::Features supportedFeatures() const { return m_supportedFeatures; }
+
     QCamera::FocusMode focusMode() const { return m_focusMode; }
     QPointF focusPoint() const { return m_customFocusPoint; }
 
@@ -120,12 +122,13 @@ public:
     int manualIsoSensitivity() const { return m_iso; }
     int minIso() const { return m_minIso; }
     int maxIso() const { return m_maxIso; }
-    float manualShutterSpeed() const { return m_shutterSpeed; }
+    float manualExposureTime() const { return m_exposureTime; }
     float minShutterSpeed() const { return m_minShutterSpeed; }
     float maxShutterSpeed() const { return m_maxShutterSpeed; }
     QCamera::WhiteBalanceMode whiteBalanceMode() const { return m_whiteBalance; }
     int colorTemperature() const { return m_colorTemperature; }
 
+    void supportedFeaturesChanged(QCamera::Features);
     void statusChanged(QCamera::Status);
     void minimumZoomFactorChanged(float factor);
     void maximumZoomFactorChanged(float);
@@ -142,7 +145,7 @@ public:
     void isoSensitivityChanged(int iso);
     void minIsoChanged(int iso) { m_minIso = iso; }
     void maxIsoChanged(int iso) { m_maxIso = iso; }
-    void shutterSpeedChanged(float speed);
+    void exposureTimeChanged(float speed);
     void minShutterSpeedChanged(float secs) { m_minShutterSpeed = secs; }
     void maxShutterSpeedChanged(float secs) { m_maxShutterSpeed = secs; }
     void whiteBalanceModeChanged(QCamera::WhiteBalanceMode mode);
@@ -160,6 +163,7 @@ protected:
     static QCameraFormat findBestCameraFormat(const QCameraInfo &camera);
 private:
     QCamera *m_camera = nullptr;
+    QCamera::Features m_supportedFeatures = {};
     QCamera::Status m_status = QCamera::InactiveStatus;
     QCamera::FocusMode m_focusMode = QCamera::FocusModeAuto;
     float m_minZoom = 1.;
@@ -177,7 +181,7 @@ private:
     int m_iso = -1;
     int m_minIso = -1;
     int m_maxIso = -1;
-    float m_shutterSpeed = -1.;
+    float m_exposureTime = -1.;
     float m_minShutterSpeed = -1.;
     float m_maxShutterSpeed = -1.;
     QCamera::WhiteBalanceMode m_whiteBalance = QCamera::WhiteBalanceAuto;