diff options
36 files changed, 1249 insertions, 2943 deletions
diff --git a/src/multimedia/CMakeLists.txt b/src/multimedia/CMakeLists.txt index a8097ca4e..7994ed945 100644 --- a/src/multimedia/CMakeLists.txt +++ b/src/multimedia/CMakeLists.txt @@ -31,7 +31,6 @@ qt_internal_add_module(Multimedia camera/qcamerainfo.cpp camera/qcamerainfo.h camera/qcamerainfo_p.h platform/qplatformaudiodecoder.cpp platform/qplatformaudiodecoder_p.h platform/qplatformcamera.cpp platform/qplatformcamera_p.h - platform/qplatformcameraexposure.cpp platform/qplatformcameraexposure_p.h platform/qplatformcameraimagecapture.cpp platform/qplatformcameraimagecapture_p.h platform/qplatformcameraimageprocessing.cpp platform/qplatformcameraimageprocessing_p.h platform/qplatformmediacapture.cpp platform/qplatformmediacapture_p.h @@ -153,8 +152,6 @@ qt_internal_extend_target(Multimedia CONDITION WIN32 platform/windows/player/mfvideorenderercontrol.cpp platform/windows/player/mfvideorenderercontrol_p.h platform/windows/player/samplegrabber.cpp platform/windows/player/samplegrabber_p.h platform/windows/mediacapture/qwindowscamera.cpp - platform/windows/mediacapture/qwindowscameraexposure.cpp - platform/windows/mediacapture/qwindowscameraexposure_p.h platform/windows/mediacapture/qwindowscameraimagecapture.cpp platform/windows/mediacapture/qwindowscameraimagecapture_p.h platform/windows/mediacapture/qwindowscameraimageprocessing.cpp @@ -232,7 +229,6 @@ qt_internal_extend_target(Multimedia CONDITION QT_FEATURE_gstreamer platform/gstreamer/qgstreamerintegration.cpp platform/gstreamer/qgstreamerintegration_p.h platform/gstreamer/mediacapture/qgstreamercamera.cpp platform/gstreamer/mediacapture/qgstreamercamera_p.h platform/gstreamer/mediacapture/qgstreamercameraimageprocessing.cpp platform/gstreamer/mediacapture/qgstreamercameraimageprocessing_p.h - platform/gstreamer/mediacapture/qgstreamercameraexposure.cpp platform/gstreamer/mediacapture/qgstreamercameraexposure_p.h platform/gstreamer/mediacapture/qgstreamermediacapture.cpp platform/gstreamer/mediacapture/qgstreamermediacapture_p.h platform/gstreamer/mediacapture/qgstreamercameraimagecapture.cpp platform/gstreamer/mediacapture/qgstreamercameraimagecapture_p.h platform/gstreamer/mediacapture/qgstreamermediaencoder.cpp platform/gstreamer/mediacapture/qgstreamermediaencoder_p.h @@ -311,7 +307,6 @@ qt_internal_extend_target(Multimedia CONDITION ANDROID platform/android/common/qandroidmultimediautils.cpp platform/android/common/qandroidmultimediautils_p.h platform/android/common/qandroidvideooutput.cpp platform/android/common/qandroidvideooutput_p.h platform/android/mediacapture/qandroidcameracontrol.cpp platform/android/mediacapture/qandroidcameracontrol_p.h - platform/android/mediacapture/qandroidcameraexposurecontrol.cpp platform/android/mediacapture/qandroidcameraexposurecontrol_p.h platform/android/mediacapture/qandroidcameraimagecapturecontrol.cpp platform/android/mediacapture/qandroidcameraimagecapturecontrol_p.h platform/android/mediacapture/qandroidcameraimageprocessingcontrol.cpp platform/android/mediacapture/qandroidcameraimageprocessingcontrol_p.h platform/android/mediacapture/qandroidcamerasession.cpp platform/android/mediacapture/qandroidcamerasession_p.h @@ -404,7 +399,6 @@ qt_internal_extend_target(Multimedia CONDITION APPLE AND NOT TVOS AND NOT WATCHO SOURCES platform/darwin/camera/avfcamera.mm platform/darwin/camera/avfcamera_p.h platform/darwin/camera/avfcameradebug_p.h - platform/darwin/camera/avfcameraexposure.mm platform/darwin/camera/avfcameraexposure_p.h platform/darwin/camera/avfcameraimageprocessing.mm platform/darwin/camera/avfcameraimageprocessing_p.h platform/darwin/camera/avfcamerarenderer.mm platform/darwin/camera/avfcamerarenderer_p.h platform/darwin/camera/avfcameraservice.mm platform/darwin/camera/avfcameraservice_p.h diff --git a/src/multimedia/camera/qcamera.cpp b/src/multimedia/camera/qcamera.cpp index 8202248d5..e69155666 100644 --- a/src/multimedia/camera/qcamera.cpp +++ b/src/multimedia/camera/qcamera.cpp @@ -42,7 +42,6 @@ #include <qcamerainfo.h> #include <private/qplatformcamera_p.h> -#include <private/qplatformcameraexposure_p.h> #include <private/qplatformcameraimageprocessing_p.h> #include <private/qplatformcameraimagecapture_p.h> #include <private/qplatformmediaintegration_p.h> @@ -127,15 +126,6 @@ void QCameraPrivate::init() q->connect(control, SIGNAL(activeChanged(bool)), q, SIGNAL(activeChanged(bool))); q->connect(control, SIGNAL(error(int,QString)), q, SLOT(_q_error(int,QString))); - exposureControl = control->exposureControl(); - if (exposureControl) { - q->connect(exposureControl, SIGNAL(actualValueChanged(int)), - q, SLOT(_q_exposureParameterChanged(int))); - q->connect(exposureControl, SIGNAL(parameterRangeChanged(int)), - q, SLOT(_q_exposureParameterRangeChanged(int))); - q->connect(exposureControl, SIGNAL(flashReady(bool)), q, SIGNAL(flashReady(bool))); - } - imageControl = control->imageProcessingControl(); } @@ -651,71 +641,6 @@ void QCamera::zoomTo(float factor, float rate) like capture mode or resolution. */ - -template<typename T> -T QCameraPrivate::actualExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const -{ - QVariant value = exposureControl ? exposureControl->actualValue(parameter) : QVariant(); - - return value.isValid() ? value.value<T>() : defaultValue; -} - -template<typename T> -T QCameraPrivate::requestedExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const -{ - QVariant value = exposureControl ? exposureControl->requestedValue(parameter) : QVariant(); - - return value.isValid() ? value.value<T>() : defaultValue; -} - -template<typename T> -void QCameraPrivate::setExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &value) -{ - if (exposureControl) - exposureControl->setValue(parameter, QVariant::fromValue<T>(value)); -} - -void QCameraPrivate::resetExposureParameter(QPlatformCameraExposure::ExposureParameter parameter) -{ - if (exposureControl) - exposureControl->setValue(parameter, QVariant()); -} - - -void QCameraPrivate::_q_exposureParameterChanged(int parameter) -{ - Q_Q(QCamera); - -#if DEBUG_EXPOSURE_CHANGES - qDebug() << "Exposure parameter changed:" - << QPlatformCameraExposure::ExposureParameter(parameter) - << exposureControl->actualValue(QPlatformCameraExposure::ExposureParameter(parameter)); -#endif - - switch (parameter) { - case QPlatformCameraExposure::ISO: - emit q->isoSensitivityChanged(q->isoSensitivity()); - break; - case QPlatformCameraExposure::ShutterSpeed: - emit q->shutterSpeedChanged(q->shutterSpeed()); - break; - case QPlatformCameraExposure::ExposureCompensation: - emit q->exposureCompensationChanged(q->exposureCompensation()); - break; - } -} - -void QCameraPrivate::_q_exposureParameterRangeChanged(int parameter) -{ - Q_Q(QCamera); - - switch (parameter) { - case QPlatformCameraExposure::ShutterSpeed: - emit q->shutterSpeedRangeChanged(); - break; - } -} - /*! \property QCamera::flashMode \brief The flash mode being used. @@ -726,13 +651,15 @@ void QCameraPrivate::_q_exposureParameterRangeChanged(int parameter) */ QCamera::FlashMode QCamera::flashMode() const { - return d_func()->exposureControl ? d_func()->exposureControl->flashMode() : QCamera::FlashOff; + Q_D(const QCamera); + return d->control ? d->control->flashMode() : QCamera::FlashOff; } void QCamera::setFlashMode(QCamera::FlashMode mode) { - if (d_func()->exposureControl) - d_func()->exposureControl->setFlashMode(mode); + Q_D(QCamera); + if (d->control) + d->control->setFlashMode(mode); } /*! @@ -741,7 +668,8 @@ void QCamera::setFlashMode(QCamera::FlashMode mode) bool QCamera::isFlashModeSupported(QCamera::FlashMode mode) const { - return d_func()->exposureControl ? d_func()->exposureControl->isFlashModeSupported(mode) : (mode == FlashOff); + Q_D(const QCamera); + return d->control ? d->control->isFlashModeSupported(mode) : (mode == FlashOff); } /*! @@ -750,7 +678,8 @@ bool QCamera::isFlashModeSupported(QCamera::FlashMode mode) const bool QCamera::isFlashReady() const { - return d_func()->exposureControl ? d_func()->exposureControl->isFlashReady() : false; + Q_D(const QCamera); + return d->control ? d->control->isFlashReady() : false; } /*! @@ -764,13 +693,15 @@ bool QCamera::isFlashReady() const */ QCamera::TorchMode QCamera::torchMode() const { - return d_func()->exposureControl ? d_func()->exposureControl->torchMode() : TorchOff; + Q_D(const QCamera); + return d->control ? d->control->torchMode() : TorchOff; } void QCamera::setTorchMode(QCamera::TorchMode mode) { - if (d_func()->exposureControl) - d_func()->exposureControl->setTorchMode(mode); + Q_D(QCamera); + if (d->control) + d->control->setTorchMode(mode); } /*! @@ -778,7 +709,8 @@ void QCamera::setTorchMode(QCamera::TorchMode mode) */ bool QCamera::isTorchModeSupported(QCamera::TorchMode mode) const { - return d_func()->exposureControl ? d_func()->exposureControl->isTorchModeSupported(mode) : (mode == TorchOff); + Q_D(const QCamera); + return d->control ? d->control->isTorchModeSupported(mode) : (mode == TorchOff); } /*! @@ -790,12 +722,15 @@ bool QCamera::isTorchModeSupported(QCamera::TorchMode mode) const QCamera::ExposureMode QCamera::exposureMode() const { - return d_func()->actualExposureParameter<QCamera::ExposureMode>(QPlatformCameraExposure::ExposureMode, QCamera::ExposureAuto); + Q_D(const QCamera); + return d->control ? d->control->exposureMode() : QCamera::ExposureAuto; } void QCamera::setExposureMode(QCamera::ExposureMode mode) { - d_func()->setExposureParameter<QCamera::ExposureMode>(QPlatformCameraExposure::ExposureMode, mode); + Q_D(QCamera); + if (d->control) + d->control->setExposureMode(mode); } /*! @@ -804,12 +739,11 @@ void QCamera::setExposureMode(QCamera::ExposureMode mode) bool QCamera::isExposureModeSupported(QCamera::ExposureMode mode) const { - if (!d_func()->exposureControl) + Q_D(const QCamera); + if (!d->control) return false; - bool continuous = false; - return d_func()->exposureControl->supportedParameterRange(QPlatformCameraExposure::ExposureMode, &continuous) - .contains(QVariant::fromValue<QCamera::ExposureMode>(mode)); + return d->control->isExposureModeSupported(mode); } /*! @@ -821,57 +755,21 @@ bool QCamera::isExposureModeSupported(QCamera::ExposureMode mode) const qreal QCamera::exposureCompensation() const { - return d_func()->actualExposureParameter<qreal>(QPlatformCameraExposure::ExposureCompensation, 0.0); + Q_D(const QCamera); + return d->control ? d->control->exposureCompensation() : 0.; } void QCamera::setExposureCompensation(qreal ev) { - d_func()->setExposureParameter<qreal>(QPlatformCameraExposure::ExposureCompensation, ev); + Q_D(QCamera); + if (d->control) + d->control->setExposureCompensation(ev); } int QCamera::isoSensitivity() const { - return d_func()->actualExposureParameter<int>(QPlatformCameraExposure::ISO, -1); -} - -/*! - Returns the requested ISO sensitivity - or -1 if automatic ISO is turned on. -*/ -int QCamera::requestedIsoSensitivity() const -{ - return d_func()->requestedExposureParameter<int>(QPlatformCameraExposure::ISO, -1); -} - -/*! - Returns the list of ISO senitivities camera supports. - - If the camera supports arbitrary ISO sensitivities within the supported range, - *\a continuous is set to true, otherwise *\a continuous is set to false. -*/ -QList<int> QCamera::supportedIsoSensitivities(bool *continuous) const -{ - QList<int> res; - QPlatformCameraExposure *control = d_func()->exposureControl; - - bool tmp = false; - if (!continuous) - continuous = &tmp; - - if (!control) - return res; - - const auto range = control->supportedParameterRange(QPlatformCameraExposure::ISO, continuous); - for (const QVariant &value : range) { - bool ok = false; - int intValue = value.toInt(&ok); - if (ok) - res.append(intValue); - else - qWarning() << "Incompatible ISO value type, int is expected"; - } - - return res; + Q_D(const QCamera); + return d->control ? d->control->isoSensitivity() : -1; } /*! @@ -881,7 +779,17 @@ QList<int> QCamera::supportedIsoSensitivities(bool *continuous) const void QCamera::setManualIsoSensitivity(int iso) { - d_func()->setExposureParameter<int>(QPlatformCameraExposure::ISO, iso); + Q_D(QCamera); + if (iso <= 0) + iso = -1; + if (d->control) + d->control->setManualIsoSensitivity(iso); +} + +int QCamera::manualIsoSensitivity() const +{ + Q_D(const QCamera); + return d->control ? d->control->manualIsoSensitivity() : 100; } /*! @@ -891,7 +799,33 @@ void QCamera::setManualIsoSensitivity(int iso) void QCamera::setAutoIsoSensitivity() { - d_func()->resetExposureParameter(QPlatformCameraExposure::ISO); + Q_D(QCamera); + if (d->control) + d->control->setManualIsoSensitivity(-1); +} + +int QCamera::minimumIsoSensitivity() const +{ + Q_D(const QCamera); + return d->control ? d->control->minIso() : -1; +} + +int QCamera::maximumIsoSensitivity() const +{ + Q_D(const QCamera); + return d->control ? d->control->maxIso() : -1; +} + +float QCamera::minimumShutterSpeed() const +{ + Q_D(const QCamera); + return d->control ? d->control->minShutterSpeed() : -1.; +} + +float QCamera::maximumShutterSpeed() const +{ + Q_D(const QCamera); + return d->control ? d->control->maxShutterSpeed() : -1.; } /*! @@ -918,58 +852,27 @@ void QCamera::setAutoIsoSensitivity() Returns the current shutter speed in seconds. */ -qreal QCamera::shutterSpeed() const +float QCamera::shutterSpeed() const { - return d_func()->actualExposureParameter<qreal>(QPlatformCameraExposure::ShutterSpeed, -1.0); + Q_D(const QCamera); + return d->control ? d->control->shutterSpeed() : -1; } /*! - Returns the requested manual shutter speed in seconds - or -1.0 if automatic shutter speed is turned on. + Set the manual shutter speed to \a seconds */ -qreal QCamera::requestedShutterSpeed() const -{ - return d_func()->requestedExposureParameter<qreal>(QPlatformCameraExposure::ShutterSpeed, -1.0); -} -/*! - Returns the list of shutter speed values in seconds camera supports. - - If the camera supports arbitrary shutter speed values within the supported range, - *\a continuous is set to true, otherwise *\a continuous is set to false. -*/ -QList<qreal> QCamera::supportedShutterSpeeds(bool *continuous) const +void QCamera::setManualShutterSpeed(float seconds) { - QList<qreal> res; - QPlatformCameraExposure *control = d_func()->exposureControl; - - bool tmp = false; - if (!continuous) - continuous = &tmp; - - if (!control) - return res; - - const auto range = control->supportedParameterRange(QPlatformCameraExposure::ShutterSpeed, continuous); - for (const QVariant &value : range) { - bool ok = false; - qreal realValue = value.toReal(&ok); - if (ok) - res.append(realValue); - else - qWarning() << "Incompatible shutter speed value type, qreal is expected"; - } - - return res; + Q_D(QCamera); + if (d->control) + d->control->setManualShutterSpeed(seconds); } -/*! - Set the manual shutter speed to \a seconds -*/ - -void QCamera::setManualShutterSpeed(qreal seconds) +float QCamera::manualShutterSpeed() const { - d_func()->setExposureParameter<qreal>(QPlatformCameraExposure::ShutterSpeed, seconds); + Q_D(const QCamera); + return d->control ? d->control->manualShutterSpeed() : -1; } /*! @@ -978,7 +881,9 @@ void QCamera::setManualShutterSpeed(qreal seconds) void QCamera::setAutoShutterSpeed() { - d_func()->resetExposureParameter(QPlatformCameraExposure::ShutterSpeed); + Q_D(QCamera); + if (d->control) + d->control->setManualShutterSpeed(-1); } diff --git a/src/multimedia/camera/qcamera.h b/src/multimedia/camera/qcamera.h index 1d01f75f1..a7c959124 100644 --- a/src/multimedia/camera/qcamera.h +++ b/src/multimedia/camera/qcamera.h @@ -80,10 +80,10 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject Q_PROPERTY(qreal shutterSpeed READ shutterSpeed NOTIFY shutterSpeedChanged) 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) Q_PROPERTY(bool flashReady READ isFlashReady NOTIFY flashReady) - Q_PROPERTY(QCamera::FlashMode flashMode READ flashMode WRITE setFlashMode) - Q_PROPERTY(QCamera::TorchMode torchMode READ torchMode WRITE setTorchMode) - Q_PROPERTY(QCamera::ExposureMode exposureMode READ exposureMode WRITE setExposureMode) + Q_PROPERTY(QCamera::FlashMode flashMode READ flashMode WRITE setFlashMode NOTIFY flashModeChanged) + Q_PROPERTY(QCamera::TorchMode torchMode READ torchMode WRITE setTorchMode NOTIFY torchModeChanged) Q_PROPERTY(WhiteBalanceMode whiteBalanceMode READ whiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged) Q_PROPERTY(qreal manualWhiteBalance READ manualWhiteBalance WRITE setManualWhiteBalance NOTIFY manualWhiteBalanceChanged) @@ -222,13 +222,16 @@ public: qreal exposureCompensation() const; int isoSensitivity() const; - qreal shutterSpeed() const; + int manualIsoSensitivity() const; - int requestedIsoSensitivity() const; - qreal requestedShutterSpeed() const; + float shutterSpeed() const; + float manualShutterSpeed() const; - QList<int> supportedIsoSensitivities(bool *continuous = nullptr) const; - QList<qreal> supportedShutterSpeeds(bool *continuous = nullptr) const; + int minimumIsoSensitivity() const; + int maximumIsoSensitivity() const; + + float minimumShutterSpeed() const; + float maximumShutterSpeed() const; WhiteBalanceMode whiteBalanceMode() const; Q_INVOKABLE bool isWhiteBalanceModeSupported(WhiteBalanceMode mode) const; @@ -256,7 +259,7 @@ public Q_SLOTS: void setManualIsoSensitivity(int iso); void setAutoIsoSensitivity(); - void setManualShutterSpeed(qreal seconds); + void setManualShutterSpeed(float seconds); void setAutoShutterSpeed(); void setWhiteBalanceMode(WhiteBalanceMode mode); @@ -283,11 +286,13 @@ Q_SIGNALS: void customFocusPointChanged(); void flashReady(bool); + void flashModeChanged(); + void torchModeChanged(); void shutterSpeedChanged(qreal speed); - void shutterSpeedRangeChanged(); void isoSensitivityChanged(int); void exposureCompensationChanged(qreal); + void exposureModeChanged(); void whiteBalanceModeChanged() const; void manualWhiteBalanceChanged() const; diff --git a/src/multimedia/camera/qcamera_p.h b/src/multimedia/camera/qcamera_p.h index 61f4dfe1b..add658454 100644 --- a/src/multimedia/camera/qcamera_p.h +++ b/src/multimedia/camera/qcamera_p.h @@ -54,12 +54,10 @@ #include "private/qobject_p.h" #include "qcamera.h" #include "qcamerainfo.h" -#include <private/qplatformcameraexposure_p.h> QT_BEGIN_NAMESPACE class QPlatformCamera; -class QPlatformCameraExposure; class QPlatformCameraImageProcessing; class QPlatformMediaCaptureSession; @@ -85,8 +83,6 @@ public: QCameraInfo cameraInfo; QCameraFormat cameraFormat; - QPlatformCameraExposure *exposureControl = nullptr; - QPlatformCameraImageProcessing *imageControl = nullptr; QCamera::WhiteBalanceMode whiteBalance = QCamera::WhiteBalanceAuto; @@ -96,14 +92,6 @@ public: qreal saturation = 0; qreal hue = 0; - template<typename T> T actualExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const; - template<typename T> T requestedExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const; - template<typename T> void setExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &value); - void resetExposureParameter(QPlatformCameraExposure::ExposureParameter parameter); - - void _q_exposureParameterChanged(int parameter); - void _q_exposureParameterRangeChanged(int parameter); - void _q_error(int error, const QString &errorString); void unsetError() { error = QCamera::NoError; errorString.clear(); } }; diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp index a8eb9ec16..4e8414381 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp +++ b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol.cpp @@ -39,7 +39,6 @@ #include "qandroidcameracontrol_p.h" #include "qandroidcamerasession_p.h" -#include "qandroidcameraexposurecontrol_p.h" #include "qandroidcameraimageprocessingcontrol_p.h" #include "qandroidcameravideorenderercontrol_p.h" #include "qandroidcaptureservice_p.h" @@ -119,11 +118,6 @@ void QAndroidCameraControl::setCaptureSession(QPlatformMediaCaptureSession *sess } -QPlatformCameraExposure *QAndroidCameraControl::exposureControl() -{ - return m_cameraSession->exposureControl(); -} - QPlatformCameraImageProcessing *QAndroidCameraControl::imageProcessingControl() { return m_cameraSession->imageProcessingControl(); @@ -226,20 +220,86 @@ void QAndroidCameraControl::onCameraOpened() m_zoomRatios.clear(); m_maximumZoom = 1.0; } + + m_minExposureCompensationIndex = m_cameraSession->camera()->getMinExposureCompensation(); + m_maxExposureCompensationIndex = m_cameraSession->camera()->getMaxExposureCompensation(); + m_exposureCompensationStep = m_cameraSession->camera()->getExposureCompensationStep(); + exposureCompensationRangeChanged(m_minExposureCompensationIndex*m_exposureCompensationStep, + m_maxExposureCompensationIndex*m_exposureCompensationStep); + + m_supportedExposureModes.clear(); + QStringList sceneModes = m_cameraSession->camera()->getSupportedSceneModes(); + if (!sceneModes.isEmpty()) { + for (int i = 0; i < sceneModes.size(); ++i) { + const QString &sceneMode = sceneModes.at(i); + if (sceneMode == QLatin1String("auto")) + m_supportedExposureModes << QCamera::ExposureAuto; + else if (sceneMode == QLatin1String("beach")) + m_supportedExposureModes << QCamera::ExposureBeach; + else if (sceneMode == QLatin1String("night")) + m_supportedExposureModes << QCamera::ExposureNight; + else if (sceneMode == QLatin1String("portrait")) + m_supportedExposureModes << QCamera::ExposurePortrait; + else if (sceneMode == QLatin1String("snow")) + m_supportedExposureModes << QCamera::ExposureSnow; + else if (sceneMode == QLatin1String("sports")) + m_supportedExposureModes << QCamera::ExposureSports; + else if (sceneMode == QLatin1String("action")) + m_supportedExposureModes << QCamera::ExposureAction; + else if (sceneMode == QLatin1String("landscape")) + m_supportedExposureModes << QCamera::ExposureLandscape; + else if (sceneMode == QLatin1String("night-portrait")) + m_supportedExposureModes << QCamera::ExposureNightPortrait; + else if (sceneMode == QLatin1String("theatre")) + m_supportedExposureModes << QCamera::ExposureTheatre; + else if (sceneMode == QLatin1String("sunset")) + m_supportedExposureModes << QCamera::ExposureSunset; + else if (sceneMode == QLatin1String("steadyphoto")) + m_supportedExposureModes << QCamera::ExposureSteadyPhoto; + else if (sceneMode == QLatin1String("fireworks")) + m_supportedExposureModes << QCamera::ExposureFireworks; + else if (sceneMode == QLatin1String("party")) + m_supportedExposureModes << QCamera::ExposureParty; + else if (sceneMode == QLatin1String("candlelight")) + m_supportedExposureModes << QCamera::ExposureCandlelight; + else if (sceneMode == QLatin1String("barcode")) + m_supportedExposureModes << QCamera::ExposureBarcode; + } + } + + setExposureCompensation(exposureCompensation()); + setExposureMode(exposureMode()); + + isFlashSupported = false; + isFlashAutoSupported = false; + isTorchSupported = false; + + QStringList flashModes = m_cameraSession->camera()->getSupportedFlashModes(); + for (int i = 0; i < flashModes.size(); ++i) { + const QString &flashMode = flashModes.at(i); + if (flashMode == QLatin1String("auto")) + isFlashAutoSupported = true; + else if (flashMode == QLatin1String("on")) + isFlashSupported = true; + else if (flashMode == QLatin1String("torch")) + isTorchSupported = true; + } + + setFlashMode(flashMode()); } //void QAndroidCameraFocusControl::onCameraCaptureModeChanged() //{ -// if (m_session->camera() && m_focusMode == QCamera::FocusModeAudio) { +// if (m_cameraSession->camera() && m_focusMode == QCamera::FocusModeAudio) { // QString focusMode; -// if ((m_session->captureMode().testFlag(QCamera::CaptureVideo) && m_continuousVideoFocusSupported) +// if ((m_cameraSession->captureMode().testFlag(QCamera::CaptureVideo) && m_continuousVideoFocusSupported) // || !m_continuousPictureFocusSupported) { // focusMode = QLatin1String("continuous-video"); // } else { // focusMode = QLatin1String("continuous-picture"); // } -// m_session->camera()->setFocusMode(focusMode); -// m_session->camera()->cancelAutoFocus(); +// m_cameraSession->camera()->setFocusMode(focusMode); +// m_cameraSession->camera()->cancelAutoFocus(); // } //} @@ -300,4 +360,162 @@ void QAndroidCameraControl::zoomTo(float factor, float rate) zoomFactorChanged(newZoom); } +void QAndroidCameraControl::setFlashMode(QCamera::FlashMode mode) +{ + if (!m_cameraSession->camera()) + return; + + if (!isFlashModeSupported(mode)) + return; + + QString flashMode; + if (mode == QCamera::FlashAuto) + flashMode = QLatin1String("auto"); + else if (mode == QCamera::FlashOn) + flashMode = QLatin1String("on"); + else // FlashOff + flashMode = QLatin1String("off"); + + m_cameraSession->camera()->setFlashMode(flashMode); + flashModeChanged(mode); +} + +bool QAndroidCameraControl::isFlashModeSupported(QCamera::FlashMode mode) const +{ + if (!m_cameraSession->camera()) + return false; + switch (mode) { + case QCamera::FlashOff: + return true; + case QCamera::FlashOn: + return isFlashSupported; + case QCamera::FlashAuto: + return isFlashAutoSupported; + } +} + +bool QAndroidCameraControl::isFlashReady() const +{ + // Android doesn't have an API for that + return true; +} + +void QAndroidCameraControl::setTorchMode(QCamera::TorchMode mode) +{ + auto *camera = m_cameraSession->camera(); + if (!camera || !isTorchSupported || mode == QCamera::TorchAuto) + return; + + if (mode == QCamera::TorchOn) { + camera->setFlashMode(QLatin1String("torch")); + } else if (mode == QCamera::TorchOff) { + // if torch was enabled, it first needs to be turned off before restoring the flash mode + camera->setFlashMode(QLatin1String("off")); + setFlashMode(flashMode()); + } + torchModeChanged(mode); +} + +bool QAndroidCameraControl::isTorchModeSupported(QCamera::TorchMode mode) const +{ + if (!m_cameraSession->camera()) + return false; + switch (mode) { + case QCamera::TorchOff: + return true; + case QCamera::TorchOn: + return isTorchSupported; + case QCamera::TorchAuto: + return false; + } +} + +void QAndroidCameraControl::setExposureMode(QCamera::ExposureMode mode) +{ + if (exposureMode() == mode) + return; + + if (!m_cameraSession->camera()) + return; + + if (!m_supportedExposureModes.contains(mode)) + return; + + QString sceneMode; + switch (mode) { + case QCamera::ExposureAuto: + sceneMode = QLatin1String("auto"); + break; + case QCamera::ExposureSports: + sceneMode = QLatin1String("sports"); + break; + case QCamera::ExposurePortrait: + sceneMode = QLatin1String("portrait"); + break; + case QCamera::ExposureBeach: + sceneMode = QLatin1String("beach"); + break; + case QCamera::ExposureSnow: + sceneMode = QLatin1String("snow"); + break; + case QCamera::ExposureNight: + sceneMode = QLatin1String("night"); + break; + case QCamera::ExposureAction: + sceneMode = QLatin1String("action"); + break; + case QCamera::ExposureLandscape: + sceneMode = QLatin1String("landscape"); + break; + case QCamera::ExposureNightPortrait: + sceneMode = QLatin1String("night-portrait"); + break; + case QCamera::ExposureTheatre: + sceneMode = QLatin1String("theatre"); + break; + case QCamera::ExposureSunset: + sceneMode = QLatin1String("sunset"); + break; + case QCamera::ExposureSteadyPhoto: + sceneMode = QLatin1String("steadyphoto"); + break; + case QCamera::ExposureFireworks: + sceneMode = QLatin1String("fireworks"); + break; + case QCamera::ExposureParty: + sceneMode = QLatin1String("party"); + break; + case QCamera::ExposureCandlelight: + sceneMode = QLatin1String("candlelight"); + break; + case QCamera::ExposureBarcode: + sceneMode = QLatin1String("barcode"); + break; + default: + sceneMode = QLatin1String("auto"); + mode = QCamera::ExposureAuto; + break; + } + + m_cameraSession->camera()->setSceneMode(sceneMode); + exposureModeChanged(mode); +} + +bool QAndroidCameraControl::isExposureModeSupported(QCamera::ExposureMode mode) const +{ + return m_supportedExposureModes.contains(mode); +} + +void QAndroidCameraControl::setExposureCompensation(float bias) +{ + if (exposureCompensation() == bias || !m_cameraSession->camera()) + return; + + int biasIndex = qRound(bias / m_exposureCompensationStep); + biasIndex = qBound(m_minExposureCompensationIndex, biasIndex, m_maxExposureCompensationIndex); + float comp = biasIndex * m_exposureCompensationStep; + m_cameraSession->camera()->setExposureCompensation(biasIndex); + exposureCompensationChanged(comp); +} + QT_END_NAMESPACE diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h index 1c9927dc2..86a685a60 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h +++ b/src/multimedia/platform/android/mediacapture/qandroidcameracontrol_p.h @@ -76,7 +76,6 @@ public: void setCaptureSession(QPlatformMediaCaptureSession *session) override; - QPlatformCameraExposure *exposureControl() override; QPlatformCameraImageProcessing *imageProcessingControl() override; void setFocusMode(QCamera::FocusMode mode) override; @@ -84,6 +83,18 @@ public: void zoomTo(float factor, float rate) override; + void setFlashMode(QCamera::FlashMode mode) override; + bool isFlashModeSupported(QCamera::FlashMode mode) const override; + bool isFlashReady() const override; + + void setTorchMode(QCamera::TorchMode mode) override; + bool isTorchModeSupported(QCamera::TorchMode mode) const override; + + void setExposureMode(QCamera::ExposureMode mode) override; + bool isExposureModeSupported(QCamera::ExposureMode mode) const override; + + void setExposureCompensation(float bias) override; + private Q_SLOTS: void onCameraOpened(); void setCameraFocusArea(); @@ -100,6 +111,15 @@ private: float m_maximumZoom; QList<int> m_zoomRatios; + + QList<QCamera::ExposureMode> m_supportedExposureModes; + int m_minExposureCompensationIndex; + int m_maxExposureCompensationIndex; + qreal m_exposureCompensationStep; + + bool isFlashSupported = false; + bool isFlashAutoSupported = false; + bool isTorchSupported = false; }; diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol.cpp b/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol.cpp deleted file mode 100644 index fc78330af..000000000 --- a/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol.cpp +++ /dev/null @@ -1,377 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qandroidcameraexposurecontrol_p.h" - -#include "qandroidcamerasession_p.h" -#include "androidcamera_p.h" - -QT_BEGIN_NAMESPACE - -QAndroidCameraExposureControl::QAndroidCameraExposureControl(QAndroidCameraSession *session) - : QPlatformCameraExposure() - , m_session(session) - , m_minExposureCompensationIndex(0) - , m_maxExposureCompensationIndex(0) - , m_exposureCompensationStep(0.0) - , m_requestedExposureCompensation(0.0) - , m_actualExposureCompensation(0.0) - , m_requestedExposureMode(QCamera::ExposureAuto) - , m_actualExposureMode(QCamera::ExposureAuto) -{ - connect(m_session, SIGNAL(opened()), - this, SLOT(onCameraOpened())); -} - -bool QAndroidCameraExposureControl::isParameterSupported(ExposureParameter parameter) const -{ - if (!m_session->camera()) - return false; - - switch (parameter) { - case QPlatformCameraExposure::ISO: - return false; - case QPlatformCameraExposure::ShutterSpeed: - return false; - case QPlatformCameraExposure::ExposureCompensation: - return !m_supportedExposureCompensations.isEmpty(); - case QPlatformCameraExposure::TorchPower: - return false; - case QPlatformCameraExposure::ExposureMode: - return !m_supportedExposureModes.isEmpty(); - default: - return false; - } -} - -QVariantList QAndroidCameraExposureControl::supportedParameterRange(ExposureParameter parameter, bool *continuous) const -{ - if (!m_session->camera()) - return QVariantList(); - - if (continuous) - *continuous = false; - - if (parameter == QPlatformCameraExposure::ExposureCompensation) - return m_supportedExposureCompensations; - else if (parameter == QPlatformCameraExposure::ExposureMode) - return m_supportedExposureModes; - - return QVariantList(); -} - -QVariant QAndroidCameraExposureControl::requestedValue(ExposureParameter parameter) const -{ - if (parameter == QPlatformCameraExposure::ExposureCompensation) - return QVariant::fromValue(m_requestedExposureCompensation); - else if (parameter == QPlatformCameraExposure::ExposureMode) - return QVariant::fromValue(m_requestedExposureMode); - - return QVariant(); -} - -QVariant QAndroidCameraExposureControl::actualValue(ExposureParameter parameter) const -{ - if (parameter == QPlatformCameraExposure::ExposureCompensation) - return QVariant::fromValue(m_actualExposureCompensation); - else if (parameter == QPlatformCameraExposure::ExposureMode) - return QVariant::fromValue(m_actualExposureMode); - - return QVariant(); -} - -bool QAndroidCameraExposureControl::setValue(ExposureParameter parameter, const QVariant& value) -{ - if (!value.isValid()) - return false; - - if (parameter == QPlatformCameraExposure::ExposureCompensation) { - qreal expComp = value.toReal(); - if (!qFuzzyCompare(m_requestedExposureCompensation, expComp)) { - m_requestedExposureCompensation = expComp; - emit requestedValueChanged(QPlatformCameraExposure::ExposureCompensation); - } - - if (!m_session->camera()) - return true; - - int expCompIndex = qRound(m_requestedExposureCompensation / m_exposureCompensationStep); - if (expCompIndex >= m_minExposureCompensationIndex - && expCompIndex <= m_maxExposureCompensationIndex) { - qreal comp = expCompIndex * m_exposureCompensationStep; - m_session->camera()->setExposureCompensation(expCompIndex); - if (!qFuzzyCompare(m_actualExposureCompensation, comp)) { - m_actualExposureCompensation = expCompIndex * m_exposureCompensationStep; - emit actualValueChanged(QPlatformCameraExposure::ExposureCompensation); - } - - return true; - } - - } else if (parameter == QPlatformCameraExposure::ExposureMode) { - QCamera::ExposureMode expMode = value.value<QCamera::ExposureMode>(); - if (m_requestedExposureMode != expMode) { - m_requestedExposureMode = expMode; - emit requestedValueChanged(QPlatformCameraExposure::ExposureMode); - } - - if (!m_session->camera()) - return true; - - if (!m_supportedExposureModes.isEmpty()) { - m_actualExposureMode = m_requestedExposureMode; - - QString sceneMode; - switch (m_requestedExposureMode) { - case QCamera::ExposureAuto: - sceneMode = QLatin1String("auto"); - break; - case QCamera::ExposureSports: - sceneMode = QLatin1String("sports"); - break; - case QCamera::ExposurePortrait: - sceneMode = QLatin1String("portrait"); - break; - case QCamera::ExposureBeach: - sceneMode = QLatin1String("beach"); - break; - case QCamera::ExposureSnow: - sceneMode = QLatin1String("snow"); - break; - case QCamera::ExposureNight: - sceneMode = QLatin1String("night"); - break; - case QCamera::ExposureAction: - sceneMode = QLatin1String("action"); - break; - case QCamera::ExposureLandscape: - sceneMode = QLatin1String("landscape"); - break; - case QCamera::ExposureNightPortrait: - sceneMode = QLatin1String("night-portrait"); - break; - case QCamera::ExposureTheatre: - sceneMode = QLatin1String("theatre"); - break; - case QCamera::ExposureSunset: - sceneMode = QLatin1String("sunset"); - break; - case QCamera::ExposureSteadyPhoto: - sceneMode = QLatin1String("steadyphoto"); - break; - case QCamera::ExposureFireworks: - sceneMode = QLatin1String("fireworks"); - break; - case QCamera::ExposureParty: - sceneMode = QLatin1String("party"); - break; - case QCamera::ExposureCandlelight: - sceneMode = QLatin1String("candlelight"); - break; - case QCamera::ExposureBarcode: - sceneMode = QLatin1String("barcode"); - break; - default: - sceneMode = QLatin1String("auto"); - m_actualExposureMode = QCamera::ExposureAuto; - break; - } - - m_session->camera()->setSceneMode(sceneMode); - emit actualValueChanged(QPlatformCameraExposure::ExposureMode); - - return true; - } - } - - return false; -} - -void QAndroidCameraExposureControl::onCameraOpened() -{ - m_supportedExposureCompensations.clear(); - m_minExposureCompensationIndex = m_session->camera()->getMinExposureCompensation(); - m_maxExposureCompensationIndex = m_session->camera()->getMaxExposureCompensation(); - m_exposureCompensationStep = m_session->camera()->getExposureCompensationStep(); - if (m_minExposureCompensationIndex != 0 || m_maxExposureCompensationIndex != 0) { - for (int i = m_minExposureCompensationIndex; i <= m_maxExposureCompensationIndex; ++i) - m_supportedExposureCompensations.append(i * m_exposureCompensationStep); - emit parameterRangeChanged(QPlatformCameraExposure::ExposureCompensation); - } - - m_supportedExposureModes.clear(); - QStringList sceneModes = m_session->camera()->getSupportedSceneModes(); - if (!sceneModes.isEmpty()) { - for (int i = 0; i < sceneModes.size(); ++i) { - const QString &sceneMode = sceneModes.at(i); - if (sceneMode == QLatin1String("auto")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureAuto); - else if (sceneMode == QLatin1String("beach")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureBeach); - else if (sceneMode == QLatin1String("night")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureNight); - else if (sceneMode == QLatin1String("portrait")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposurePortrait); - else if (sceneMode == QLatin1String("snow")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureSnow); - else if (sceneMode == QLatin1String("sports")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureSports); - else if (sceneMode == QLatin1String("action")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureAction); - else if (sceneMode == QLatin1String("landscape")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureLandscape); - else if (sceneMode == QLatin1String("night-portrait")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureNightPortrait); - else if (sceneMode == QLatin1String("theatre")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureTheatre); - else if (sceneMode == QLatin1String("sunset")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureSunset); - else if (sceneMode == QLatin1String("steadyphoto")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureSteadyPhoto); - else if (sceneMode == QLatin1String("fireworks")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureFireworks); - else if (sceneMode == QLatin1String("party")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureParty); - else if (sceneMode == QLatin1String("candlelight")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureCandlelight); - else if (sceneMode == QLatin1String("barcode")) - m_supportedExposureModes << QVariant::fromValue(QCamera::ExposureBarcode); - } - emit parameterRangeChanged(QPlatformCameraExposure::ExposureMode); - } - - setValue(QPlatformCameraExposure::ExposureCompensation, QVariant::fromValue(m_requestedExposureCompensation)); - setValue(QPlatformCameraExposure::ExposureMode, QVariant::fromValue(m_requestedExposureMode)); - - m_supportedFlashModes.clear(); - torchModeSupported = false; - - QStringList flashModes = m_session->camera()->getSupportedFlashModes(); - for (int i = 0; i < flashModes.size(); ++i) { - const QString &flashMode = flashModes.at(i); - if (flashMode == QLatin1String("off")) - m_supportedFlashModes << QCamera::FlashOff; - else if (flashMode == QLatin1String("auto")) - m_supportedFlashModes << QCamera::FlashAuto; - else if (flashMode == QLatin1String("on")) - m_supportedFlashModes << QCamera::FlashOn; - else if (flashMode == QLatin1String("torch")) - torchModeSupported = true; - } - - if (!m_supportedFlashModes.contains(m_flashMode)) - m_flashMode = QCamera::FlashOff; - - setFlashMode(m_flashMode); -} - - -QCamera::FlashMode QAndroidCameraExposureControl::flashMode() const -{ - return m_flashMode; -} - -void QAndroidCameraExposureControl::setFlashMode(QCamera::FlashMode mode) -{ - if (!m_session->camera()) { - m_flashMode = QCamera::FlashOff; - return; - } - - if (!isFlashModeSupported(mode)) - return; - - - m_flashMode = mode; - - QString flashMode; - if (mode == QCamera::FlashAuto) - flashMode = QLatin1String("auto"); - else if (mode == QCamera::FlashOn) - flashMode = QLatin1String("on"); - else // FlashOff - flashMode = QLatin1String("off"); - - m_session->camera()->setFlashMode(flashMode); -} - -bool QAndroidCameraExposureControl::isFlashModeSupported(QCamera::FlashMode mode) const -{ - return m_session->camera() ? m_supportedFlashModes.contains(mode) : false; -} - -bool QAndroidCameraExposureControl::isFlashReady() const -{ - // Android doesn't have an API for that - return true; -} - -QCamera::TorchMode QAndroidCameraExposureControl::torchMode() const -{ - return torchEnabled ? QCamera::TorchOn : QCamera::TorchOff; -} - -void QAndroidCameraExposureControl::setTorchMode(QCamera::TorchMode mode) -{ - auto *camera = m_session->camera(); - if (!camera || !torchModeSupported) - return; - - if (mode == QCamera::TorchOn) { - camera->setFlashMode(QLatin1String("torch")); - torchEnabled = true; - } else if (mode == QCamera::TorchOff) { - // if torch was enabled, it first needs to be turned off before restoring the flash mode - camera->setFlashMode(QLatin1String("off")); - setFlashMode(m_flashMode); - torchEnabled = false; - } -} - -bool QAndroidCameraExposureControl::isTorchModeSupported(QCamera::TorchMode mode) const -{ - if (mode == QCamera::TorchAuto) - return false; - else if (mode == QCamera::TorchOn) - return torchModeSupported; - else - return true; -} - -QT_END_NAMESPACE diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol_p.h b/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol_p.h deleted file mode 100644 index 510a9a764..000000000 --- a/src/multimedia/platform/android/mediacapture/qandroidcameraexposurecontrol_p.h +++ /dev/null @@ -1,109 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef QANDROIDCAMERAEXPOSURECONTROL_H -#define QANDROIDCAMERAEXPOSURECONTROL_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <private/qplatformcameraexposure_p.h> - -QT_BEGIN_NAMESPACE - -class QAndroidCameraSession; - -class QAndroidCameraExposureControl : public QPlatformCameraExposure -{ - Q_OBJECT -public: - explicit QAndroidCameraExposureControl(QAndroidCameraSession *session); - - bool isParameterSupported(ExposureParameter parameter) const override; - QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const override; - - QVariant requestedValue(ExposureParameter parameter) const override; - QVariant actualValue(ExposureParameter parameter) const override; - bool setValue(ExposureParameter parameter, const QVariant& value) override; - - QCamera::FlashMode flashMode() const override; - void setFlashMode(QCamera::FlashMode mode) override; - bool isFlashModeSupported(QCamera::FlashMode mode) const override; - bool isFlashReady() const override; - - QCamera::TorchMode torchMode() const override; - void setTorchMode(QCamera::TorchMode mode) override; - bool isTorchModeSupported(QCamera::TorchMode mode) const override; - -private Q_SLOTS: - void onCameraOpened(); - -private: - QAndroidCameraSession *m_session; - - QVariantList m_supportedExposureCompensations; - QVariantList m_supportedExposureModes; - - int m_minExposureCompensationIndex; - int m_maxExposureCompensationIndex; - qreal m_exposureCompensationStep; - - qreal m_requestedExposureCompensation; - qreal m_actualExposureCompensation; - QCamera::ExposureMode m_requestedExposureMode; - QCamera::ExposureMode m_actualExposureMode; - - QList<QCamera::FlashMode> m_supportedFlashModes; - QCamera::FlashMode m_flashMode; - - bool torchModeSupported = false; - bool torchEnabled = false; -}; - -QT_END_NAMESPACE - -#endif // QANDROIDCAMERAEXPOSURECONTROL_H diff --git a/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp b/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp index 81e208a2a..369c7ed10 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp +++ b/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp @@ -45,7 +45,6 @@ #include "qandroidvideooutput_p.h" #include "qandroidmultimediautils_p.h" #include "qandroidcameravideorenderercontrol_p.h" -#include "qandroidcameraexposurecontrol_p.h" #include "qandroidcameraimageprocessingcontrol_p.h" #include <qvideosink.h> #include <QtConcurrent/qtconcurrentrun.h> @@ -79,7 +78,6 @@ QAndroidCameraSession::QAndroidCameraSession(QObject *parent) QMediaStorageLocation::Pictures, AndroidMultimediaUtils::getDefaultMediaDirectory(AndroidMultimediaUtils::DCIM)); - m_cameraExposureControl = new QAndroidCameraExposureControl(this); m_cameraImageProcessingControl = new QAndroidCameraImageProcessingControl(this); if (qApp) { @@ -90,7 +88,6 @@ QAndroidCameraSession::QAndroidCameraSession(QObject *parent) QAndroidCameraSession::~QAndroidCameraSession() { - delete m_cameraExposureControl; delete m_cameraImageProcessingControl; delete m_renderer; diff --git a/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h b/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h index 69a2d8864..9f88bd76d 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h +++ b/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h @@ -63,7 +63,6 @@ QT_BEGIN_NAMESPACE class QAndroidVideoOutput; -class QAndroidCameraExposureControl; class QAndroidCameraImageProcessingControl; class QAndroidCameraVideoRendererControl; class QVideoSink; @@ -112,7 +111,6 @@ public: void setPreviewCallback(PreviewCallback *callback); bool requestRecordingPermission(); - QAndroidCameraExposureControl *exposureControl() { return m_cameraExposureControl; } QAndroidCameraImageProcessingControl *imageProcessingControl() { return m_cameraImageProcessingControl; } void setVideoSink(QVideoSink *surface); @@ -180,7 +178,6 @@ private: QAndroidCameraVideoRendererControl *m_renderer = nullptr; - QAndroidCameraExposureControl *m_cameraExposureControl; QAndroidCameraImageProcessingControl *m_cameraImageProcessingControl; QImageEncoderSettings m_requestedImageSettings; diff --git a/src/multimedia/platform/darwin/camera/avfcamera.mm b/src/multimedia/platform/darwin/camera/avfcamera.mm index b780e207a..65688ba11 100644 --- a/src/multimedia/platform/darwin/camera/avfcamera.mm +++ b/src/multimedia/platform/darwin/camera/avfcamera.mm @@ -43,12 +43,119 @@ #include "avfcameraservice_p.h" #include "avfcamerautility_p.h" #include "avfcamerarenderer_p.h" -#include "avfcameraexposure_p.h" #include "avfcameraimageprocessing_p.h" #include <qmediacapturesession.h> QT_USE_NAMESPACE + +namespace { + +// All these methods to work with exposure/ISO/SS in custom mode do not support macOS. + +#ifdef Q_OS_IOS + +// Misc. helpers to check values/ranges: + +bool qt_check_ISO_conversion(float isoValue) +{ + if (isoValue >= std::numeric_limits<int>::max()) + return false; + if (isoValue <= std::numeric_limits<int>::min()) + return false; + return true; +} + +bool qt_check_ISO_range(AVCaptureDeviceFormat *format) +{ + // Qt is using int for ISO, AVFoundation - float. It looks like the ISO range + // at the moment can be represented by int (it's max - min > 100, etc.). + Q_ASSERT(format); + if (format.maxISO - format.minISO < 1.) { + // ISO is in some strange units? + return false; + } + + return qt_check_ISO_conversion(format.minISO) + && qt_check_ISO_conversion(format.maxISO); +} + +bool qt_check_exposure_duration(AVCaptureDevice *captureDevice, CMTime duration) +{ + Q_ASSERT(captureDevice); + + AVCaptureDeviceFormat *activeFormat = captureDevice.activeFormat; + if (!activeFormat) { + qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; + return false; + } + + return CMTimeCompare(duration, activeFormat.minExposureDuration) != -1 + && CMTimeCompare(activeFormat.maxExposureDuration, duration) != -1; +} + +bool qt_check_ISO_value(AVCaptureDevice *captureDevice, int newISO) +{ + Q_ASSERT(captureDevice); + + AVCaptureDeviceFormat *activeFormat = captureDevice.activeFormat; + if (!activeFormat) { + qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; + return false; + } + + return !(newISO < activeFormat.minISO || newISO > activeFormat.maxISO); +} + +bool qt_exposure_duration_equal(AVCaptureDevice *captureDevice, qreal qDuration) +{ + Q_ASSERT(captureDevice); + const CMTime avDuration = CMTimeMakeWithSeconds(qDuration, captureDevice.exposureDuration.timescale); + return !CMTimeCompare(avDuration, captureDevice.exposureDuration); +} + +bool qt_iso_equal(AVCaptureDevice *captureDevice, int iso) +{ + Q_ASSERT(captureDevice); + return qFuzzyCompare(float(iso), captureDevice.ISO); +} + +bool qt_exposure_bias_equal(AVCaptureDevice *captureDevice, qreal bias) +{ + Q_ASSERT(captureDevice); + return qFuzzyCompare(bias, qreal(captureDevice.exposureTargetBias)); +} + +// Converters: + +bool qt_convert_exposure_mode(AVCaptureDevice *captureDevice, QCamera::ExposureMode mode, + AVCaptureExposureMode &avMode) +{ + // Test if mode supported and convert. + Q_ASSERT(captureDevice); + + if (mode == QCamera::ExposureAuto) { + if ([captureDevice isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) { + avMode = AVCaptureExposureModeContinuousAutoExposure; + return true; + } + } + + if (mode == QCamera::ExposureManual) { + if ([captureDevice isExposureModeSupported:AVCaptureExposureModeCustom]) { + avMode = AVCaptureExposureModeCustom; + return true; + } + } + + return false; +} + +#endif // defined(Q_OS_IOS) + +} // Unnamed namespace. + + AVFCamera::AVFCamera(QCamera *camera) : QPlatformCamera(camera) , m_active(false) @@ -57,15 +164,10 @@ AVFCamera::AVFCamera(QCamera *camera) Q_ASSERT(camera); m_cameraImageProcessingControl = new AVFCameraImageProcessing(this); - m_cameraExposureControl = nullptr; -#ifdef Q_OS_IOS - m_cameraExposureControl = new AVFCameraExposure(this); -#endif } AVFCamera::~AVFCamera() { - delete m_cameraExposureControl; delete m_cameraImageProcessingControl; } @@ -165,11 +267,6 @@ AVCaptureDevice *AVFCamera::device() const return device; } -QPlatformCameraExposure *AVFCamera::exposureControl() -{ - return m_cameraExposureControl; -} - QPlatformCameraImageProcessing *AVFCamera::imageProcessingControl() { return m_cameraImageProcessingControl; @@ -369,7 +466,84 @@ void AVFCamera::updateCameraConfiguration() maximumZoomFactorChanged(captureDevice.maxAvailableVideoZoomFactor); captureDevice.videoZoomFactor = m_zoomFactor; + + CMTime newDuration = AVCaptureExposureDurationCurrent; + bool setCustomMode = false; + + float shutterSpeed = manualShutterSpeed(); + if (shutterSpeed > 0 + && !qt_exposure_duration_equal(captureDevice, shutterSpeed)) { + newDuration = CMTimeMakeWithSeconds(shutterSpeed, captureDevice.exposureDuration.timescale); + if (!qt_check_exposure_duration(captureDevice, newDuration)) { + qDebugCamera() << Q_FUNC_INFO << "requested exposure duration is out of range"; + return; + } + setCustomMode = true; + } + + float newISO = AVCaptureISOCurrent; + int iso = manualIsoSensitivity(); + if (iso > 0 && !qt_iso_equal(captureDevice, iso)) { + newISO = iso; + if (!qt_check_ISO_value(captureDevice, newISO)) { + qDebugCamera() << Q_FUNC_INFO << "requested ISO value is out of range"; + return; + } + setCustomMode = true; + } + + float bias = exposureCompensation(); + if (!bias != 0 + && !qt_exposure_bias_equal(captureDevice, bias)) { + // TODO: mixed fpns. + if (bias < captureDevice.minExposureTargetBias || bias > captureDevice.maxExposureTargetBias) { + qDebugCamera() << Q_FUNC_INFO << "exposure compensation value is" + << "out of range"; + return; + } + [captureDevice setExposureTargetBias:bias completionHandler:nil]; + } + + // Setting shutter speed (exposure duration) or ISO values + // also reset exposure mode into Custom. With this settings + // we ignore any attempts to set exposure mode. + + if (setCustomMode) { + [captureDevice setExposureModeCustomWithDuration:newDuration + ISO:newISO + completionHandler:nil]; + return; + } + + QCamera::ExposureMode qtMode = exposureMode(); + AVCaptureExposureMode avMode = AVCaptureExposureModeContinuousAutoExposure; + if (!qt_convert_exposure_mode(captureDevice, qtMode, avMode)) { + qDebugCamera() << Q_FUNC_INFO << "requested exposure mode is not supported"; + return; + } + + captureDevice.exposureMode = avMode; #endif + + isFlashSupported = isFlashAutoSupported = false; + isTorchSupported = isTorchAutoSupported = false; + + if (captureDevice.hasFlash) { + if ([captureDevice isFlashModeSupported:AVCaptureFlashModeOn]) + isFlashSupported = true; + if ([captureDevice isFlashModeSupported:AVCaptureFlashModeAuto]) + isFlashAutoSupported = true; + } + + if (captureDevice.hasTorch) { + if ([captureDevice isTorchModeSupported:AVCaptureTorchModeOn]) + isTorchSupported = true; + if ([captureDevice isTorchModeSupported:AVCaptureTorchModeAuto]) + isTorchAutoSupported = true; + } + + applyFlashSettings(); + flashReadyChanged(isFlashSupported); } void AVFCamera::zoomTo(float factor, float rate) @@ -400,4 +574,301 @@ void AVFCamera::zoomTo(float factor, float rate) #endif } +void AVFCamera::setFlashMode(QCamera::FlashMode mode) +{ + if (flashMode() == mode) + return; + + if (isActive() && !isFlashModeSupported(mode)) { + qDebugCamera() << Q_FUNC_INFO << "unsupported mode" << mode; + return; + } + + flashModeChanged(mode); + + if (!isActive()) + return; + + applyFlashSettings(); +} + +bool AVFCamera::isFlashModeSupported(QCamera::FlashMode mode) const +{ + if (mode == QCamera::FlashOff) + return true; + else if (mode == QCamera::FlashOn) + return isFlashSupported; + else //if (mode == QCamera::FlashAuto) + return isFlashAutoSupported; +} + +bool AVFCamera::isFlashReady() const +{ + if (!isActive()) + return false; + + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) + return false; + + if (!captureDevice.hasFlash) + return false; + + if (!isFlashModeSupported(flashMode())) + return false; + +#ifdef Q_OS_IOS + // AVCaptureDevice's docs: + // "The flash may become unavailable if, for example, + // the device overheats and needs to cool off." + return [captureDevice isFlashAvailable]; +#endif + + return true; +} + +void AVFCamera::setTorchMode(QCamera::TorchMode mode) +{ + if (torchMode() == mode) + return; + + if (isActive() && !isTorchModeSupported(mode)) { + qDebugCamera() << Q_FUNC_INFO << "unsupported torch mode" << mode; + return; + } + + torchModeChanged(mode); + + if (!isActive()) + return; + + applyFlashSettings(); +} + +bool AVFCamera::isTorchModeSupported(QCamera::TorchMode mode) const +{ + if (mode == QCamera::TorchOff) + return true; + else if (mode == QCamera::TorchOn) + return isTorchSupported; + else //if (mode == QCamera::TorchAuto) + return isTorchAutoSupported; +} + +void AVFCamera::setExposureMode(QCamera::ExposureMode qtMode) +{ +#ifdef Q_OS_IOS + if (qtMode != QCamera::ExposureAuto && qtMode != QCamera::ExposureManual) { + qDebugCamera() << Q_FUNC_INFO << "exposure mode not supported"; + return; + } + + AVCaptureDevice *captureDevice = m_camera->device(); + if (!captureDevice) { + exposureModeChanged(value); + return; + } + + AVCaptureExposureMode avMode = AVCaptureExposureModeContinuousAutoExpose; + if (!qt_convert_exposure_mode(captureDevice, qtMode, avMode)) { + qDebugCamera() << Q_FUNC_INFO << "exposure mode not supported"; + return false; + } + + const AVFConfigurationLock lock(captureDevice); + if (!lock) { + qDebugCamera() << Q_FUNC_INFO << "failed to lock a capture device" + << "for configuration"; + return false; + } + + [captureDevice setExposureMode:avMode]; + exposureModeChanged(qtMode); +#else + Q_UNUSED(qtMode); +#endif +} + +bool AVFCamera::isExposureModeSupported(QCamera::ExposureMode mode) const +{ + if (mode == QCamera::ExposureAuto) + return true; + if (mode != QCamera::ExposureManual) + return false; + AVCaptureDevice *captureDevice = device(); + return captureDevice && [captureDevice isExposureModeSupported:AVCaptureExposureModeCustom]; +} + +void AVFCamera::applyFlashSettings() +{ + Q_ASSERT(isActive()); + + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) { + qDebugCamera() << Q_FUNC_INFO << "no capture device found"; + return; + } + + + const AVFConfigurationLock lock(captureDevice); + + if (captureDevice.hasFlash) { + auto mode = flashMode(); + if (mode == QCamera::FlashOff) { + captureDevice.flashMode = AVCaptureFlashModeOff; + } else { +#ifdef Q_OS_IOS + if (![captureDevice isFlashAvailable]) { + qDebugCamera() << Q_FUNC_INFO << "flash is not available at the moment"; + return; + } +#endif + if (mode == QCamera::FlashOn) + captureDevice.flashMode = AVCaptureFlashModeOn; + else if (mode == QCamera::FlashAuto) + captureDevice.flashMode = AVCaptureFlashModeAuto; + } + } + + if (captureDevice.hasTorch) { + auto mode = torchMode(); + if (mode == QCamera::TorchOff) { + captureDevice.torchMode = AVCaptureTorchModeOff; + } else { +#ifdef Q_OS_IOS + if (![captureDevice isTorchAvailable]) { + qDebugCamera() << Q_FUNC_INFO << "torch is not available at the moment"; + return; + } +#endif + if (mode == QCamera::TorchOn) + captureDevice.torchMode = AVCaptureTorchModeOn; + else if (mode == QCamera::TorchAuto) + captureDevice.torchMode = AVCaptureTorchModeAuto; + } + } +} + + +void AVFCamera::setExposureCompensation(float bias) +{ +#ifdef Q_OS_IOS + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) { + exposureCompensationChanged(bias); + return; + } + + bias = qBound(captureDevice.minExposureTargetBias, bias, captureDevice.maxExposureTargetBias); + + const AVFConfigurationLock lock(captureDevice); + if (!lock) { + qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; + return false; + } + + [captureDevice setExposureTargetBias:bias completionHandler:nil]; + exposureCompensationChanged(bias); +#else + Q_UNUSED(bias); +#endif +} + +void AVFCamera::setManualShutterSpeed(float value) +{ +#ifdef Q_OS_IOS + if (value < 0) { + setExposureMode(QCamera::ExposureAuto); + return; + } + + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) { + manualShutterSpeedChanged(value); + return; + } + + const CMTime newDuration = CMTimeMakeWithSeconds(value, captureDevice.exposureDuration.timescale); + if (!qt_check_exposure_duration(captureDevice, newDuration)) { + qDebugCamera() << Q_FUNC_INFO << "shutter speed value is out of range"; + return; + } + + const AVFConfigurationLock lock(captureDevice); + if (!lock) { + qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; + return; + } + + // Setting the shutter speed (exposure duration in Apple's terms, + // since there is no shutter actually) will also reset + // exposure mode into custom mode. + [captureDevice setExposureModeCustomWithDuration:newDuration + ISO:AVCaptureISOCurrent + completionHandler:nil]; + + manualShutterSpeedChanged(value); + +#else + Q_UNUSED(value); +#endif +} + +float AVFCamera::shutterSpeed() const +{ +#ifdef Q_OS_IOS + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) + return -1.; + auto duration = captureDevice.exposureDuration; + return CMTimeGetSeconds(duration); +#else + return -1; +#endif +} + +void AVFCamera::setManualIsoSensitivity(int value) +{ +#ifdef Q_OS_IOS + if (value < 0) { + setExposureMode(QCamera::ExposureAuto); + return; + } + + AVCaptureDevice *captureDevice = device(); + if (!captureDevice) { + manualIsoSensitivityChanged(value); + return; + } + + if (!qt_check_ISO_value(captureDevice, value.toInt())) { + qDebugCamera() << Q_FUNC_INFO << "ISO value is out of range"; + return false; + } + + const AVFConfigurationLock lock(captureDevice); + if (!lock) { + qDebugCamera() << Q_FUNC_INFO << "failed to lock a capture device" + << "for configuration"; + return false; + } + + // Setting the ISO will also reset + // exposure mode to the custom mode. + [captureDevice setExposureModeCustomWithDuration:AVCaptureExposureDurationCurrent + ISO:value + completionHandler:nil]; + + manualIsoSensitivityChanged(value); +#else + Q_UNUSED(value); +#endif +} + +int AVFCamera::isoSensitivity() const +{ + return manualIsoSensitivity(); +} + + #include "moc_avfcamera_p.cpp" diff --git a/src/multimedia/platform/darwin/camera/avfcamera_p.h b/src/multimedia/platform/darwin/camera/avfcamera_p.h index 710cd8038..8d2feb658 100644 --- a/src/multimedia/platform/darwin/camera/avfcamera_p.h +++ b/src/multimedia/platform/darwin/camera/avfcamera_p.h @@ -60,7 +60,6 @@ QT_BEGIN_NAMESPACE class AVFCameraSession; class AVFCameraService; class AVFCameraSession; -class AVFCameraExposure; class AVFCameraImageProcessing; Q_FORWARD_DECLARE_OBJC_CLASS(AVCaptureDeviceFormat); @@ -84,7 +83,6 @@ public: void setCaptureSession(QPlatformMediaCaptureSession *) override; - QPlatformCameraExposure *exposureControl() override; QPlatformCameraImageProcessing *imageProcessingControl() override; void setFocusMode(QCamera::FocusMode mode) override; @@ -96,6 +94,22 @@ public: void setFocusDistance(float d) override; void zoomTo(float factor, float rate) override; + void setFlashMode(QCamera::FlashMode mode) override; + bool isFlashModeSupported(QCamera::FlashMode mode) const override; + bool isFlashReady() const override; + + void setTorchMode(QCamera::TorchMode mode) override; + bool isTorchModeSupported(QCamera::TorchMode mode) const override; + + void setExposureMode(QCamera::ExposureMode) override; + bool isExposureModeSupported(QCamera::ExposureMode mode) const override; + + 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; + AVCaptureConnection *videoConnection() const; AVCaptureDevice *device() const; @@ -104,18 +118,23 @@ private Q_SLOTS: private: void updateCameraConfiguration(); + void applyFlashSettings(); friend class AVFCameraSession; AVFCameraService *m_service = nullptr; AVFCameraSession *m_session = nullptr; AVFCameraImageProcessing *m_cameraImageProcessingControl; - AVFCameraExposure *m_cameraExposureControl; QCameraInfo m_cameraInfo; bool m_active; QCamera::Status m_lastStatus; + + bool isFlashSupported = false; + bool isFlashAutoSupported = false; + bool isTorchSupported = false; + bool isTorchAutoSupported = false; }; QT_END_NAMESPACE diff --git a/src/multimedia/platform/darwin/camera/avfcameraexposure.mm b/src/multimedia/platform/darwin/camera/avfcameraexposure.mm deleted file mode 100644 index 53499aa1f..000000000 --- a/src/multimedia/platform/darwin/camera/avfcameraexposure.mm +++ /dev/null @@ -1,833 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "avfcameraexposure_p.h" -#include "avfcamerautility_p.h" -#include "avfcamera_p.h" -#include "avfcameradebug_p.h" - -#include <QtCore/qvariant.h> -#include <QtCore/qpointer.h> -#include <QtCore/qdebug.h> -#include <QtCore/qpair.h> - -#include <AVFoundation/AVFoundation.h> - -#include <limits> - -QT_BEGIN_NAMESPACE - -namespace { - -// All these methods to work with exposure/ISO/SS in custom mode do not support macOS. - -#ifdef Q_OS_IOS - -// Misc. helpers to check values/ranges: - -bool qt_check_ISO_conversion(float isoValue) -{ - if (isoValue >= std::numeric_limits<int>::max()) - return false; - if (isoValue <= std::numeric_limits<int>::min()) - return false; - return true; -} - -bool qt_check_ISO_range(AVCaptureDeviceFormat *format) -{ - // Qt is using int for ISO, AVFoundation - float. It looks like the ISO range - // at the moment can be represented by int (it's max - min > 100, etc.). - Q_ASSERT(format); - if (format.maxISO - format.minISO < 1.) { - // ISO is in some strange units? - return false; - } - - return qt_check_ISO_conversion(format.minISO) - && qt_check_ISO_conversion(format.maxISO); -} - -bool qt_check_exposure_duration(AVCaptureDevice *captureDevice, CMTime duration) -{ - Q_ASSERT(captureDevice); - - AVCaptureDeviceFormat *activeFormat = captureDevice.activeFormat; - if (!activeFormat) { - qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; - return false; - } - - return CMTimeCompare(duration, activeFormat.minExposureDuration) != -1 - && CMTimeCompare(activeFormat.maxExposureDuration, duration) != -1; -} - -bool qt_check_ISO_value(AVCaptureDevice *captureDevice, int newISO) -{ - Q_ASSERT(captureDevice); - - AVCaptureDeviceFormat *activeFormat = captureDevice.activeFormat; - if (!activeFormat) { - qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; - return false; - } - - return !(newISO < activeFormat.minISO || newISO > activeFormat.maxISO); -} - -bool qt_exposure_duration_equal(AVCaptureDevice *captureDevice, qreal qDuration) -{ - Q_ASSERT(captureDevice); - const CMTime avDuration = CMTimeMakeWithSeconds(qDuration, captureDevice.exposureDuration.timescale); - return !CMTimeCompare(avDuration, captureDevice.exposureDuration); -} - -bool qt_iso_equal(AVCaptureDevice *captureDevice, int iso) -{ - Q_ASSERT(captureDevice); - return qFuzzyCompare(float(iso), captureDevice.ISO); -} - -bool qt_exposure_bias_equal(AVCaptureDevice *captureDevice, qreal bias) -{ - Q_ASSERT(captureDevice); - return qFuzzyCompare(bias, qreal(captureDevice.exposureTargetBias)); -} - -// Converters: - -bool qt_convert_exposure_mode(AVCaptureDevice *captureDevice, QCamera::ExposureMode mode, - AVCaptureExposureMode &avMode) -{ - // Test if mode supported and convert. - Q_ASSERT(captureDevice); - - if (mode == QCamera::ExposureAuto) { - if ([captureDevice isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) { - avMode = AVCaptureExposureModeContinuousAutoExposure; - return true; - } - } - - if (mode == QCamera::ExposureManual) { - if ([captureDevice isExposureModeSupported:AVCaptureExposureModeCustom]) { - avMode = AVCaptureExposureModeCustom; - return true; - } - } - - return false; -} - -// We set ISO/exposure duration with completion handlers, completion handlers try -// to avoid dangling pointers (thus QPointer for QObjects) and not to create -// a reference loop (in case we have ARC). - -void qt_set_exposure_bias(QPointer<AVFCamera> camera, QPointer<AVFCameraExposure> control, - AVCaptureDevice *captureDevice, float bias) -{ - Q_ASSERT(captureDevice); - - __block AVCaptureDevice *device = captureDevice; //For ARC. - - void (^completionHandler)(CMTime syncTime) = ^(CMTime) { - // Test that camera control is still alive and that - // capture device is our device, if yes - emit actual value changed. - if (camera) { - if (control) { - if (camera->device() == device) - Q_EMIT control->actualValueChanged(int(QPlatformCameraExposure::ExposureCompensation)); - } - } - device = nil; - }; - - [captureDevice setExposureTargetBias:bias completionHandler:completionHandler]; -} - -void qt_set_duration_iso(QPointer<AVFCamera> camera, QPointer<AVFCameraExposure> control, - AVCaptureDevice *captureDevice, CMTime duration, float iso) -{ - Q_ASSERT(captureDevice); - - __block AVCaptureDevice *device = captureDevice; //For ARC. - const bool setDuration = CMTimeCompare(duration, AVCaptureExposureDurationCurrent); - const bool setISO = !qFuzzyCompare(iso, AVCaptureISOCurrent); - - void (^completionHandler)(CMTime syncTime) = ^(CMTime) { - // Test that camera control is still alive and that - // capture device is our device, if yes - emit actual value changed. - if (camera) { - if (control) { - if (camera->device() == device) { - if (setDuration) - Q_EMIT control->actualValueChanged(int(QPlatformCameraExposure::ShutterSpeed)); - if (setISO) - Q_EMIT control->actualValueChanged(int(QPlatformCameraExposure::ISO)); - } - } - } - device = nil; - }; - - [captureDevice setExposureModeCustomWithDuration:duration - ISO:iso - completionHandler:completionHandler]; -} - -#endif // defined(Q_OS_IOS) - -} // Unnamed namespace. - -AVFCameraExposure::AVFCameraExposure(AVFCamera *camera) - : QPlatformCameraExposure(camera), - m_camera(camera) -{ - Q_ASSERT(m_camera); - - connect(m_camera, SIGNAL(activeChanged(bool)), SLOT(cameraActiveChanged(bool))); -} - -bool AVFCameraExposure::isParameterSupported(ExposureParameter parameter) const -{ -#ifdef Q_OS_IOS - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) - return false; - - // These are the parameters we have an API to support: - return parameter == QPlatformCameraExposure::ISO - || parameter == QPlatformCameraExposure::ShutterSpeed - || parameter == QPlatformCameraExposure::ExposureCompensation - || parameter == QPlatformCameraExposure::ExposureMode; -#else - Q_UNUSED(parameter); - return false; -#endif -} - -QVariantList AVFCameraExposure::supportedParameterRange(ExposureParameter parameter, - bool *continuous) const -{ - QVariantList parameterRange; -#ifdef Q_OS_IOS - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice || !isParameterSupported(parameter)) { - qDebugCamera() << Q_FUNC_INFO << "parameter not supported"; - return parameterRange; - } - - if (continuous) - *continuous = false; - - AVCaptureDeviceFormat *activeFormat = captureDevice.activeFormat; - - if (parameter == QPlatformCameraExposure::ISO) { - if (!activeFormat) { - qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; - return parameterRange; - } - - if (!qt_check_ISO_range(activeFormat)) { - qDebugCamera() << Q_FUNC_INFO << "ISO range can not be represented as int"; - return parameterRange; - } - - parameterRange << QVariant(int(activeFormat.minISO)); - parameterRange << QVariant(int(activeFormat.maxISO)); - if (continuous) - *continuous = true; - } else if (parameter == QPlatformCameraExposure::ExposureCompensation) { - parameterRange << captureDevice.minExposureTargetBias; - parameterRange << captureDevice.maxExposureTargetBias; - if (continuous) - *continuous = true; - } else if (parameter == QPlatformCameraExposure::ShutterSpeed) { - if (!activeFormat) { - qDebugCamera() << Q_FUNC_INFO << "failed to obtain capture device format"; - return parameterRange; - } - - // CMTimeGetSeconds returns Float64, test the conversion below, if it's valid? - parameterRange << qreal(CMTimeGetSeconds(activeFormat.minExposureDuration)); - parameterRange << qreal(CMTimeGetSeconds(activeFormat.maxExposureDuration)); - - if (continuous) - *continuous = true; - } else if (parameter == QPlatformCameraExposure::ExposureMode) { - if ([captureDevice isExposureModeSupported:AVCaptureExposureModeCustom]) - parameterRange << QVariant::fromValue(QCamera::ExposureManual); - - if ([captureDevice isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) - parameterRange << QVariant::fromValue(QCamera::ExposureAuto); - } -#else - Q_UNUSED(parameter); - Q_UNUSED(continuous); -#endif - return parameterRange; -} - -QVariant AVFCameraExposure::requestedValue(ExposureParameter parameter) const -{ - if (!isParameterSupported(parameter)) { - qDebugCamera() << Q_FUNC_INFO << "parameter not supported"; - return QVariant(); - } - - if (parameter == QPlatformCameraExposure::ExposureMode) - return m_requestedMode; - - if (parameter == QPlatformCameraExposure::ExposureCompensation) - return m_requestedCompensation; - - if (parameter == QPlatformCameraExposure::ShutterSpeed) - return m_requestedShutterSpeed; - - if (parameter == QPlatformCameraExposure::ISO) - return m_requestedISO; - - return QVariant(); -} - -QVariant AVFCameraExposure::actualValue(ExposureParameter parameter) const -{ -#ifdef Q_OS_IOS - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice || !isParameterSupported(parameter)) { - // Actually, at the moment !captiredevice => !isParameterSupported. - qDebugCamera() << Q_FUNC_INFO << "parameter not supported"; - return QVariant(); - } - - if (parameter == QPlatformCameraExposure::ExposureMode) { - // This code expects exposureMode to be continuous by default ... - if (captureDevice.exposureMode == AVCaptureExposureModeContinuousAutoExposure) - return QVariant::fromValue(QCamera::ExposureAuto); - return QVariant::fromValue(QCamera::ExposureManual); - } - - if (parameter == QPlatformCameraExposure::ExposureCompensation) - return captureDevice.exposureTargetBias; - - if (parameter == QPlatformCameraExposure::ShutterSpeed) - return qreal(CMTimeGetSeconds(captureDevice.exposureDuration)); - - if (parameter == QPlatformCameraExposure::ISO) { - if (captureDevice.activeFormat && qt_check_ISO_range(captureDevice.activeFormat) - && qt_check_ISO_conversion(captureDevice.ISO)) { - // Can be represented as int ... - return int(captureDevice.ISO); - } else { - qDebugCamera() << Q_FUNC_INFO << "ISO can not be represented as int"; - return QVariant(); - } - } -#else - Q_UNUSED(parameter); -#endif - return QVariant(); -} - -bool AVFCameraExposure::setValue(ExposureParameter parameter, const QVariant &value) -{ - if (parameter == QPlatformCameraExposure::ExposureMode) - return setExposureMode(value); - else if (parameter == QPlatformCameraExposure::ExposureCompensation) - return setExposureCompensation(value); - else if (parameter == QPlatformCameraExposure::ShutterSpeed) - return setShutterSpeed(value); - else if (parameter == QPlatformCameraExposure::ISO) - return setISO(value); - - return false; -} - -bool AVFCameraExposure::setExposureMode(const QVariant &value) -{ -#ifdef Q_OS_IOS - if (!value.canConvert<QCamera::ExposureMode>()) { - qDebugCamera() << Q_FUNC_INFO << "invalid exposure mode value," - << "QCamera::ExposureMode expected"; - return false; - } - - const QCamera::ExposureMode qtMode = value.value<QCamera::ExposureMode>(); - if (qtMode != QCamera::ExposureAuto && qtMode != QCamera::ExposureManual) { - qDebugCamera() << Q_FUNC_INFO << "exposure mode not supported"; - return false; - } - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - m_requestedMode = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ExposureMode)); - return true; - } - - AVCaptureExposureMode avMode = AVCaptureExposureModeAutoExpose; - if (!qt_convert_exposure_mode(captureDevice, qtMode, avMode)) { - qDebugCamera() << Q_FUNC_INFO << "exposure mode not supported"; - return false; - } - - const AVFConfigurationLock lock(captureDevice); - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock a capture device" - << "for configuration"; - return false; - } - - m_requestedMode = value; - [captureDevice setExposureMode:avMode]; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ExposureMode)); - Q_EMIT actualValueChanged(int(QPlatformCameraExposure::ExposureMode)); - - return true; -#else - Q_UNUSED(value); - return false; -#endif -} - -bool AVFCameraExposure::setExposureCompensation(const QVariant &value) -{ -#ifdef Q_OS_IOS - if (!value.canConvert<qreal>()) { - qDebugCamera() << Q_FUNC_INFO << "invalid exposure compensation" - <<"value, floating point number expected"; - return false; - } - - const qreal bias = value.toReal(); - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - m_requestedCompensation = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ExposureCompensation)); - return true; - } - - if (bias < captureDevice.minExposureTargetBias || bias > captureDevice.maxExposureTargetBias) { - // TODO: mixed fp types! - qDebugCamera() << Q_FUNC_INFO << "exposure compenstation value is" - << "out of range"; - return false; - } - - const AVFConfigurationLock lock(captureDevice); - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; - return false; - } - - qt_set_exposure_bias(m_camera, this, captureDevice, bias); - m_requestedCompensation = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ExposureCompensation)); - - return true; -#else - Q_UNUSED(value); - return false; -#endif -} - -bool AVFCameraExposure::setShutterSpeed(const QVariant &value) -{ -#ifdef Q_OS_IOS - if (value.isNull()) - return setExposureMode(QVariant::fromValue(QCamera::ExposureAuto)); - - if (!value.canConvert<qreal>()) { - qDebugCamera() << Q_FUNC_INFO << "invalid shutter speed" - << "value, floating point number expected"; - return false; - } - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - m_requestedShutterSpeed = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ShutterSpeed)); - return true; - } - - const CMTime newDuration = CMTimeMakeWithSeconds(value.toReal(), - captureDevice.exposureDuration.timescale); - if (!qt_check_exposure_duration(captureDevice, newDuration)) { - qDebugCamera() << Q_FUNC_INFO << "shutter speed value is out of range"; - return false; - } - - const AVFConfigurationLock lock(captureDevice); - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; - return false; - } - - // Setting the shutter speed (exposure duration in Apple's terms, - // since there is no shutter actually) will also reset - // exposure mode into custom mode. - qt_set_duration_iso(m_camera, this, captureDevice, newDuration, AVCaptureISOCurrent); - - m_requestedShutterSpeed = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ShutterSpeed)); - - return true; -#else - Q_UNUSED(value); - return false; -#endif -} - -bool AVFCameraExposure::setISO(const QVariant &value) -{ -#ifdef Q_OS_IOS - if (value.isNull()) - return setExposureMode(QVariant::fromValue(QCamera::ExposureAuto)); - - if (!value.canConvert<int>()) { - qDebugCamera() << Q_FUNC_INFO << "invalid ISO value, int expected"; - return false; - } - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - m_requestedISO = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ISO)); - return true; - } - - if (!qt_check_ISO_value(captureDevice, value.toInt())) { - qDebugCamera() << Q_FUNC_INFO << "ISO value is out of range"; - return false; - } - - const AVFConfigurationLock lock(captureDevice); - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock a capture device" - << "for configuration"; - return false; - } - - // Setting the ISO will also reset - // exposure mode to the custom mode. - qt_set_duration_iso(m_camera, this, captureDevice, AVCaptureExposureDurationCurrent, value.toInt()); - - m_requestedISO = value; - Q_EMIT requestedValueChanged(int(QPlatformCameraExposure::ISO)); - - return true; -#else - Q_UNUSED(value); - return false; -#endif -} - -void AVFCameraExposure::cameraActiveChanged(bool active) -{ -#ifdef Q_OS_IOS - if (!m_camera->isActive()) - return; - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - qDebugCamera() << Q_FUNC_INFO << "capture device is nil, but the camera" - << "is 'active'"; - return; - } - - Q_EMIT parameterRangeChanged(int(QPlatformCameraExposure::ExposureCompensation)); - Q_EMIT parameterRangeChanged(int(QPlatformCameraExposure::ExposureMode)); - Q_EMIT parameterRangeChanged(int(QPlatformCameraExposure::ShutterSpeed)); - Q_EMIT parameterRangeChanged(int(QPlatformCameraExposure::ISO)); - - const AVFConfigurationLock lock(captureDevice); - - CMTime newDuration = AVCaptureExposureDurationCurrent; - bool setCustomMode = false; - - if (!m_requestedShutterSpeed.isNull() - && !qt_exposure_duration_equal(captureDevice, m_requestedShutterSpeed.toReal())) { - newDuration = CMTimeMakeWithSeconds(m_requestedShutterSpeed.toReal(), - captureDevice.exposureDuration.timescale); - if (!qt_check_exposure_duration(captureDevice, newDuration)) { - qDebugCamera() << Q_FUNC_INFO << "requested exposure duration is out of range"; - return; - } - setCustomMode = true; - } - - float newISO = AVCaptureISOCurrent; - if (!m_requestedISO.isNull() && !qt_iso_equal(captureDevice, m_requestedISO.toInt())) { - newISO = m_requestedISO.toInt(); - if (!qt_check_ISO_value(captureDevice, newISO)) { - qDebugCamera() << Q_FUNC_INFO << "requested ISO value is out of range"; - return; - } - setCustomMode = true; - } - - if (!m_requestedCompensation.isNull() - && !qt_exposure_bias_equal(captureDevice, m_requestedCompensation.toReal())) { - // TODO: mixed fpns. - const qreal bias = m_requestedCompensation.toReal(); - if (bias < captureDevice.minExposureTargetBias || bias > captureDevice.maxExposureTargetBias) { - qDebugCamera() << Q_FUNC_INFO << "exposure compenstation value is" - << "out of range"; - return; - } - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; - return; - } - qt_set_exposure_bias(m_camera, this, captureDevice, bias); - } - - // Setting shutter speed (exposure duration) or ISO values - // also reset exposure mode into Custom. With this settings - // we ignore any attempts to set exposure mode. - - if (setCustomMode) { - if (!lock) - qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; - else - qt_set_duration_iso(m_camera, this, captureDevice, newDuration, newISO); - return; - } - - if (!m_requestedMode.isNull()) { - QCamera::ExposureMode qtMode = m_requestedMode.value<QCamera::ExposureMode>(); - AVCaptureExposureMode avMode = AVCaptureExposureModeContinuousAutoExposure; - if (!qt_convert_exposure_mode(captureDevice, qtMode, avMode)) { - qDebugCamera() << Q_FUNC_INFO << "requested exposure mode is not supported"; - return; - } - - if (avMode == captureDevice.exposureMode) - return; - - if (!lock) { - qDebugCamera() << Q_FUNC_INFO << "failed to lock for configuration"; - return; - } - - [captureDevice setExposureMode:avMode]; - Q_EMIT actualValueChanged(int(QPlatformCameraExposure::ExposureMode)); - } -#endif - - isFlashSupported = isFlashAutoSupported = false; - isTorchSupported = isTorchAutoSupported = false; - if (!active) { - Q_EMIT flashReady(false); - } else { - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - qDebugCamera() << Q_FUNC_INFO << "no capture device in 'Active' state"; - Q_EMIT flashReady(false); - return; - } - - if (captureDevice.hasFlash) { - if ([captureDevice isFlashModeSupported:AVCaptureFlashModeOn]) - isFlashSupported = true; - if ([captureDevice isFlashModeSupported:AVCaptureFlashModeAuto]) - isFlashAutoSupported = true; - } - - if (captureDevice.hasTorch) { - if ([captureDevice isTorchModeSupported:AVCaptureTorchModeOn]) - isTorchSupported = true; - if ([captureDevice isTorchModeSupported:AVCaptureTorchModeAuto]) - isTorchAutoSupported = true; - } - - applyFlashSettings(); - Q_EMIT flashReady(isFlashSupported); - } -} - - - -QCamera::FlashMode AVFCameraExposure::flashMode() const -{ - return m_flashMode; -} - -void AVFCameraExposure::setFlashMode(QCamera::FlashMode mode) -{ - if (m_flashMode == mode) - return; - - if (m_camera->isActive() && !isFlashModeSupported(mode)) { - qDebugCamera() << Q_FUNC_INFO << "unsupported mode" << mode; - return; - } - - m_flashMode = mode; - - if (!m_camera->isActive()) - return; - - applyFlashSettings(); -} - -bool AVFCameraExposure::isFlashModeSupported(QCamera::FlashMode mode) const -{ - if (mode == QCamera::FlashOff) - return true; - else if (mode == QCamera::FlashOn) - return isFlashSupported; - else //if (mode == QCamera::FlashAuto) - return isFlashAutoSupported; -} - -bool AVFCameraExposure::isFlashReady() const -{ - if (!m_camera->isActive()) - return false; - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) - return false; - - if (!captureDevice.hasFlash && !captureDevice.hasTorch) - return false; - - if (!isFlashModeSupported(m_flashMode)) - return false; - -#ifdef Q_OS_IOS - // AVCaptureDevice's docs: - // "The flash may become unavailable if, for example, - // the device overheats and needs to cool off." - return [captureDevice isFlashAvailable]; -#endif - - return true; -} - -QCamera::TorchMode AVFCameraExposure::torchMode() const -{ - return m_torchMode; -} - -void AVFCameraExposure::setTorchMode(QCamera::TorchMode mode) -{ - if (m_torchMode == mode) - return; - - if (m_camera->isActive() && !isTorchModeSupported(mode)) { - qDebugCamera() << Q_FUNC_INFO << "unsupported torch mode" << mode; - return; - } - - m_torchMode = mode; - - if (!m_camera->isActive()) - return; - - applyFlashSettings(); -} - -bool AVFCameraExposure::isTorchModeSupported(QCamera::TorchMode mode) const -{ - if (mode == QCamera::TorchOff) - return true; - else if (mode == QCamera::TorchOn) - return isTorchSupported; - else //if (mode == QCamera::TorchAuto) - return isTorchAutoSupported; -} - -void AVFCameraExposure::applyFlashSettings() -{ - Q_ASSERT(m_camera->isActive()); - - AVCaptureDevice *captureDevice = m_camera->device(); - if (!captureDevice) { - qDebugCamera() << Q_FUNC_INFO << "no capture device found"; - return; - } - - if (!isFlashModeSupported(m_flashMode)) { - qDebugCamera() << Q_FUNC_INFO << "unsupported mode" << m_flashMode; - return; - } - - const AVFConfigurationLock lock(captureDevice); - - if (captureDevice.hasFlash) { - if (m_flashMode == QCamera::FlashOff) { - captureDevice.flashMode = AVCaptureFlashModeOff; - } else { -#ifdef Q_OS_IOS - if (![captureDevice isFlashAvailable]) { - qDebugCamera() << Q_FUNC_INFO << "flash is not available at the moment"; - return; - } -#endif - if (m_flashMode == QCamera::FlashOn) - captureDevice.flashMode = AVCaptureFlashModeOn; - else if (m_flashMode == QCamera::FlashAuto) - captureDevice.flashMode = AVCaptureFlashModeAuto; - } - } - - if (captureDevice.hasTorch) { - if (m_torchMode == QCamera::TorchOff) { - captureDevice.torchMode = AVCaptureTorchModeOff; - } else { -#ifdef Q_OS_IOS - if (![captureDevice isTorchAvailable]) { - qDebugCamera() << Q_FUNC_INFO << "torch is not available at the moment"; - return; - } -#endif - if (m_torchMode == QCamera::TorchOn) - captureDevice.torchMode = AVCaptureTorchModeOn; - else if (m_torchMode == QCamera::TorchAuto) - captureDevice.torchMode = AVCaptureTorchModeAuto; - } - } -} - -QT_END_NAMESPACE - -#include "moc_avfcameraexposure_p.cpp" diff --git a/src/multimedia/platform/darwin/camera/avfcameraexposure_p.h b/src/multimedia/platform/darwin/camera/avfcameraexposure_p.h deleted file mode 100644 index e432d377f..000000000 --- a/src/multimedia/platform/darwin/camera/avfcameraexposure_p.h +++ /dev/null @@ -1,117 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef AVFCAMERAEXPOSURE_H -#define AVFCAMERAEXPOSURE_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <private/qplatformcameraexposure_p.h> -#include <QtMultimedia/qcamera.h> - -#include <QtCore/qglobal.h> - -QT_BEGIN_NAMESPACE - -class AVFCamera; - -class AVFCameraExposure : public QPlatformCameraExposure -{ - Q_OBJECT - -public: - AVFCameraExposure(AVFCamera *camera); - - bool isParameterSupported(ExposureParameter parameter) const override; - QVariantList supportedParameterRange(ExposureParameter parameter, - bool *continuous) const override; - - QVariant requestedValue(ExposureParameter parameter) const override; - QVariant actualValue(ExposureParameter parameter) const override; - bool setValue(ExposureParameter parameter, const QVariant &value) override; - - QCamera::FlashMode flashMode() const override; - void setFlashMode(QCamera::FlashMode mode) override; - bool isFlashModeSupported(QCamera::FlashMode mode) const override; - bool isFlashReady() const override; - - QCamera::TorchMode torchMode() const override; - void setTorchMode(QCamera::TorchMode mode) override; - bool isTorchModeSupported(QCamera::TorchMode mode) const override; - -private Q_SLOTS: - void cameraActiveChanged(bool active); - -private: - void applyFlashSettings(); - - AVFCamera *m_camera; - - QVariant m_requestedMode; - QVariant m_requestedCompensation; - QVariant m_requestedShutterSpeed; - QVariant m_requestedISO; - - // Aux. setters: - bool setExposureMode(const QVariant &value); - bool setExposureCompensation(const QVariant &value); - bool setShutterSpeed(const QVariant &value); - bool setISO(const QVariant &value); - - // Set of bits: - bool isFlashSupported = false; - bool isFlashAutoSupported = false; - bool isTorchSupported = false; - bool isTorchAutoSupported = false; - QCamera::FlashMode m_flashMode = QCamera::FlashOff; - QCamera::TorchMode m_torchMode = QCamera::TorchOff; -}; - -QT_END_NAMESPACE - -#endif diff --git a/src/multimedia/platform/darwin/camera/avfcameraservice.mm b/src/multimedia/platform/darwin/camera/avfcameraservice.mm index 4d5021076..6a577e4fe 100644 --- a/src/multimedia/platform/darwin/camera/avfcameraservice.mm +++ b/src/multimedia/platform/darwin/camera/avfcameraservice.mm @@ -46,7 +46,6 @@ #include "avfcameraimagecapture_p.h" #include "avfcamerarenderer_p.h" #include "avfcameraimagecapture_p.h" -#include "avfcameraexposure_p.h" #include "avfcameraimageprocessing_p.h" #include "avfmediaencoder_p.h" #include <qmediadevices.h> diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp index e31c8e6f2..9ece4a09e 100644 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp +++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera.cpp @@ -43,7 +43,6 @@ #include "qgstreamercameraimagecapture_p.h" #include <private/qgstreamermediadevices_p.h> #include <private/qgstreamerintegration_p.h> -#include <private/qgstreamercameraexposure_p.h> #include <private/qgstreamercameraimageprocessing_p.h> #include <qmediacapturesession.h> @@ -189,9 +188,20 @@ QPlatformCameraImageProcessing *QGstreamerCamera::imageProcessingControl() return imageProcessing; } -QPlatformCameraExposure *QGstreamerCamera::exposureControl() +GstColorBalance *QGstreamerCamera::colorBalance() const +{ + if (!gstCamera.isNull() && GST_IS_COLOR_BALANCE(gstCamera.element())) + return GST_COLOR_BALANCE(gstCamera.element()); + // ### Add support for manual/SW color balancing using the gstreamer colorbalance element + return nullptr; +} + +#if QT_CONFIG(gstreamer_photography) +GstPhotography *QGstreamerCamera::photography() const { - return exposure; + if (!gstCamera.isNull() && GST_IS_PHOTOGRAPHY(gstCamera.element())) + return GST_PHOTOGRAPHY(gstCamera.element()); + return nullptr; } void QGstreamerCamera::setFocusMode(QCamera::FocusMode mode) @@ -199,7 +209,6 @@ void QGstreamerCamera::setFocusMode(QCamera::FocusMode mode) if (mode == focusMode()) return; -#if QT_CONFIG(gstreamer_photography) auto p = photography(); if (p) { GstPhotographyFocusMode photographyMode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL; @@ -227,34 +236,173 @@ void QGstreamerCamera::setFocusMode(QCamera::FocusMode mode) if (gst_photography_set_focus_mode(p, photographyMode)) focusModeChanged(mode); } -#endif } bool QGstreamerCamera::isFocusModeSupported(QCamera::FocusMode mode) const { + if (photography()) + return true; + return mode == QCamera::FocusModeAuto; +} + +void QGstreamerCamera::setFlashMode(QCamera::FlashMode mode) +{ Q_UNUSED(mode); -#if QT_CONFIG(gstreamer_photography) + if (auto *p = photography()) { + GstPhotographyFlashMode flashMode; + gst_photography_get_flash_mode(p, &flashMode); + + switch (mode) { + case QCamera::FlashAuto: + flashMode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO; + break; + case QCamera::FlashOff: + flashMode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; + break; + case QCamera::FlashOn: + flashMode = GST_PHOTOGRAPHY_FLASH_MODE_ON; + break; + } + + if (gst_photography_set_flash_mode(p, flashMode)) + flashModeChanged(mode); + } +} + +bool QGstreamerCamera::isFlashModeSupported(QCamera::FlashMode mode) const +{ + if (photography()) + return true; + + return mode == QCamera::FlashAuto; +} + +bool QGstreamerCamera::isFlashReady() const +{ if (photography()) return true; -#endif return false; } -GstColorBalance *QGstreamerCamera::colorBalance() const +void QGstreamerCamera::setExposureMode(QCamera::ExposureMode mode) { - if (!gstCamera.isNull() && GST_IS_COLOR_BALANCE(gstCamera.element())) - return GST_COLOR_BALANCE(gstCamera.element()); - // ### Add support for manual/SW color balancing using the gstreamer colorbalance element - return nullptr; + auto *p = photography(); + if (!p) + return; + + GstPhotographySceneMode sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + + switch (mode) { + case QCamera::ExposureManual: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_MANUAL; + break; + case QCamera::ExposurePortrait: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; + break; + case QCamera::ExposureSports: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; + break; + case QCamera::ExposureNight: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; + break; + case QCamera::ExposureAuto: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + break; + case QCamera::ExposureLandscape: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; + break; + case QCamera::ExposureSnow: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SNOW; + break; + case QCamera::ExposureBeach: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_BEACH; + break; + case QCamera::ExposureAction: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_ACTION; + break; + case QCamera::ExposureNightPortrait: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT; + break; + case QCamera::ExposureTheatre: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_THEATRE; + break; + case QCamera::ExposureSunset: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SUNSET; + break; + case QCamera::ExposureSteadyPhoto: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO; + break; + case QCamera::ExposureFireworks: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS; + break; + case QCamera::ExposureParty: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_PARTY; + break; + case QCamera::ExposureCandlelight: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT; + break; + case QCamera::ExposureBarcode: + sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_BARCODE; + break; + default: + return; + } + + if (gst_photography_set_scene_mode(p, sceneMode)) + exposureModeChanged(mode); } -#if QT_CONFIG(gstreamer_photography) -GstPhotography *QGstreamerCamera::photography() const +bool QGstreamerCamera::isExposureModeSupported(QCamera::ExposureMode mode) const { - if (!gstCamera.isNull() && GST_IS_PHOTOGRAPHY(gstCamera.element())) - return GST_PHOTOGRAPHY(gstCamera.element()); - return nullptr; + if (photography()) + return true; + + return mode == QCamera::ExposureAuto; +} + +void QGstreamerCamera::setExposureCompensation(float compensation) +{ + if (auto *p = photography()) { + if (gst_photography_set_ev_compensation(p, compensation)) + exposureCompensationChanged(compensation); + } +} + +void QGstreamerCamera::setManualIsoSensitivity(int iso) +{ + if (auto *p = photography()) { + if (gst_photography_set_iso_speed(p, iso)) + isoSensitivityChanged(iso); + } +} + +int QGstreamerCamera::isoSensitivity() const +{ + if (auto *p = photography()) { + guint speed = 0; + if (gst_photography_get_iso_speed(p, &speed)) + return speed; + } + return 100; +} + +void QGstreamerCamera::setManualShutterSpeed(float secs) +{ + if (auto *p = photography()) { + if (gst_photography_set_exposure(p, guint(secs*1000000))) + shutterSpeedChanged(secs); + } +} + +float QGstreamerCamera::shutterSpeed() const +{ + if (auto *p = photography()) { + guint32 exposure = 0; + if (gst_photography_get_exposure(p, &exposure)) + return exposure/1000000.; + } + return -1; } #endif diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h index 0714bc10a..2397cfa84 100644 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h +++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercamera_p.h @@ -59,7 +59,6 @@ #include <gst/video/colorbalance.h> QT_BEGIN_NAMESPACE -class QGstreamerCameraExposure; class QGstreamerImageProcessing; class QGstreamerCamera : public QPlatformCamera @@ -82,14 +81,26 @@ public: void setPipeline(const QGstPipeline &pipeline) { gstPipeline = pipeline; } QPlatformCameraImageProcessing *imageProcessingControl() override; - QPlatformCameraExposure *exposureControl() override; + +#if QT_CONFIG(gstreamer_photography) + GstPhotography *photography() const; void setFocusMode(QCamera::FocusMode mode) override; bool isFocusModeSupported(QCamera::FocusMode mode) const override; -#if QT_CONFIG(gstreamer_photography) - GstPhotography *photography() const; + void setFlashMode(QCamera::FlashMode mode) override; + bool isFlashModeSupported(QCamera::FlashMode mode) const override; + bool isFlashReady() const override; + + void setExposureMode(QCamera::ExposureMode) override; + bool isExposureModeSupported(QCamera::ExposureMode mode) const override; + void setExposureCompensation(float) override; + void setManualIsoSensitivity(int) override; + int isoSensitivity() const override; + void setManualShutterSpeed(float) override; + float shutterSpeed() const override; #endif + QString v4l2Device() const { return m_v4l2Device; } bool isV4L2Camera() const { return !m_v4l2Device.isEmpty(); } @@ -98,7 +109,6 @@ public: private: QGstreamerMediaCapture *m_session = nullptr; - QGstreamerCameraExposure *exposure = nullptr; QGstreamerImageProcessing *imageProcessing = nullptr; QCameraInfo m_cameraInfo; diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure.cpp b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure.cpp deleted file mode 100644 index bf36ba502..000000000 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure.cpp +++ /dev/null @@ -1,372 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qgstreamercameraexposure_p.h" -#include "qgstreamercamera_p.h" -#include <private/qgst_p.h> -#include <QDebug> - -QT_BEGIN_NAMESPACE - -QGstreamerCameraExposure::QGstreamerCameraExposure(QGstreamerCamera *session) - :QPlatformCameraExposure(session), - m_camera(session) -{ -#if QT_CONFIG(gstreamer_photography) - hasPhotography = m_camera->photography() != nullptr; -#endif -} - -QGstreamerCameraExposure::~QGstreamerCameraExposure() -{ -} - -bool QGstreamerCameraExposure::isParameterSupported(ExposureParameter parameter) const -{ -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - switch (parameter) { - case QPlatformCameraExposure::ExposureCompensation: - case QPlatformCameraExposure::ISO: - case QPlatformCameraExposure::ShutterSpeed: - return true; - default: - break; - } - } -#else - Q_UNUSED(parameter); -#endif - return false; -} - -QVariantList QGstreamerCameraExposure::supportedParameterRange(ExposureParameter parameter, - bool *continuous) const -{ - QVariantList res; - -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - if (continuous) - *continuous = false; - - switch (parameter) { - case QPlatformCameraExposure::ExposureCompensation: - if (continuous) - *continuous = true; - res << -2.0 << 2.0; - break; - case QPlatformCameraExposure::ISO: - res << 100 << 200 << 400; - break; - default: - break; - } - } -#else - Q_UNUSED(parameter); - Q_UNUSED(continuous); -#endif - - return res; -} - -QVariant QGstreamerCameraExposure::requestedValue(ExposureParameter parameter) const -{ - return m_requestedValues.value(parameter); -} - -QVariant QGstreamerCameraExposure::actualValue(ExposureParameter parameter) const -{ -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - switch (parameter) { - case QPlatformCameraExposure::ExposureCompensation: - { - gfloat ev; - gst_photography_get_ev_compensation(m_camera->photography(), &ev); - return QVariant(ev); - } - case QPlatformCameraExposure::ISO: - { - guint isoSpeed = 0; - gst_photography_get_iso_speed(m_camera->photography(), &isoSpeed); - return QVariant(isoSpeed); - } - case QPlatformCameraExposure::ShutterSpeed: - { - guint32 shutterSpeed = 0; - gst_photography_get_exposure(m_camera->photography(), &shutterSpeed); - - return QVariant(shutterSpeed/1000000.0); - } - case QPlatformCameraExposure::ExposureMode: - { - GstPhotographySceneMode sceneMode; - gst_photography_get_scene_mode(m_camera->photography(), &sceneMode); - - switch (sceneMode) { - case GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT: - return QVariant::fromValue(QCamera::ExposurePortrait); - case GST_PHOTOGRAPHY_SCENE_MODE_SPORT: - return QVariant::fromValue(QCamera::ExposureSports); - case GST_PHOTOGRAPHY_SCENE_MODE_NIGHT: - return QVariant::fromValue(QCamera::ExposureNight); - case GST_PHOTOGRAPHY_SCENE_MODE_MANUAL: - return QVariant::fromValue(QCamera::ExposureManual); - case GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE: - return QVariant::fromValue(QCamera::ExposureLandscape); - case GST_PHOTOGRAPHY_SCENE_MODE_SNOW: - return QVariant::fromValue(QCamera::ExposureSnow); - case GST_PHOTOGRAPHY_SCENE_MODE_BEACH: - return QVariant::fromValue(QCamera::ExposureBeach); - case GST_PHOTOGRAPHY_SCENE_MODE_ACTION: - return QVariant::fromValue(QCamera::ExposureAction); - case GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT: - return QVariant::fromValue(QCamera::ExposureNightPortrait); - case GST_PHOTOGRAPHY_SCENE_MODE_THEATRE: - return QVariant::fromValue(QCamera::ExposureTheatre); - case GST_PHOTOGRAPHY_SCENE_MODE_SUNSET: - return QVariant::fromValue(QCamera::ExposureSunset); - case GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO: - return QVariant::fromValue(QCamera::ExposureSteadyPhoto); - case GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS: - return QVariant::fromValue(QCamera::ExposureFireworks); - case GST_PHOTOGRAPHY_SCENE_MODE_PARTY: - return QVariant::fromValue(QCamera::ExposureParty); - case GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT: - return QVariant::fromValue(QCamera::ExposureCandlelight); - case GST_PHOTOGRAPHY_SCENE_MODE_BARCODE: - return QVariant::fromValue(QCamera::ExposureBarcode); - //no direct mapping available so mapping to auto mode - case GST_PHOTOGRAPHY_SCENE_MODE_CLOSEUP: - case GST_PHOTOGRAPHY_SCENE_MODE_AUTO: - default: - return QVariant::fromValue(QCamera::ExposureAuto); - } - } - default: - break; - } - } -#else - Q_UNUSED(parameter); -#endif - return QVariant(); -} - -bool QGstreamerCameraExposure::setValue(ExposureParameter parameter, const QVariant& value) -{ - -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - QVariant oldValue = actualValue(parameter); - - switch (parameter) { - case QPlatformCameraExposure::ExposureCompensation: - gst_photography_set_ev_compensation(m_camera->photography(), value.toReal()); - break; - case QPlatformCameraExposure::ISO: - gst_photography_set_iso_speed(m_camera->photography(), value.toInt()); - break; - case QPlatformCameraExposure::ShutterSpeed: - gst_photography_set_exposure(m_camera->photography(), guint(value.toReal()*1000000)); - break; - case QPlatformCameraExposure::ExposureMode: - { - QCamera::ExposureMode mode = value.value<QCamera::ExposureMode>(); - GstPhotographySceneMode sceneMode; - - gst_photography_get_scene_mode(m_camera->photography(), &sceneMode); - - switch (mode) { - case QCamera::ExposureManual: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_MANUAL; - break; - case QCamera::ExposurePortrait: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; - break; - case QCamera::ExposureSports: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; - break; - case QCamera::ExposureNight: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; - break; - case QCamera::ExposureAuto: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; - break; - case QCamera::ExposureLandscape: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; - break; - case QCamera::ExposureSnow: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SNOW; - break; - case QCamera::ExposureBeach: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_BEACH; - break; - case QCamera::ExposureAction: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_ACTION; - break; - case QCamera::ExposureNightPortrait: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT; - break; - case QCamera::ExposureTheatre: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_THEATRE; - break; - case QCamera::ExposureSunset: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_SUNSET; - break; - case QCamera::ExposureSteadyPhoto: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO; - break; - case QCamera::ExposureFireworks: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS; - break; - case QCamera::ExposureParty: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_PARTY; - break; - case QCamera::ExposureCandlelight: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT; - break; - case QCamera::ExposureBarcode: - sceneMode = GST_PHOTOGRAPHY_SCENE_MODE_BARCODE; - break; - default: - break; - } - - gst_photography_set_scene_mode(m_camera->photography(), sceneMode); - break; - } - default: - return false; - } - - if (!qFuzzyCompare(m_requestedValues.value(parameter).toReal(), value.toReal())) { - m_requestedValues[parameter] = value; - emit requestedValueChanged(parameter); - } - - QVariant newValue = actualValue(parameter); - if (!qFuzzyCompare(oldValue.toReal(), newValue.toReal())) - emit actualValueChanged(parameter); - - return true; - } -#else - Q_UNUSED(parameter); - Q_UNUSED(value); -#endif - - return false; -} - -QCamera::FlashMode QGstreamerCameraExposure::flashMode() const -{ -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - GstPhotographyFlashMode flashMode; - gst_photography_get_flash_mode(m_camera->photography(), &flashMode); - - QCamera::FlashMode mode; - switch (flashMode) { - default: - case GST_PHOTOGRAPHY_FLASH_MODE_AUTO: - mode = QCamera::FlashAuto; - break; - case GST_PHOTOGRAPHY_FLASH_MODE_OFF: - mode = QCamera::FlashOff; - break; - case GST_PHOTOGRAPHY_FLASH_MODE_ON: - mode = QCamera::FlashOn; - break; - } - return mode; - } -#endif - return QCamera::FlashAuto; -} - -void QGstreamerCameraExposure::setFlashMode(QCamera::FlashMode mode) -{ - Q_UNUSED(mode); - -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) { - GstPhotographyFlashMode flashMode; - gst_photography_get_flash_mode(m_camera->photography(), &flashMode); - - switch (mode) { - case QCamera::FlashAuto: - flashMode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO; - break; - case QCamera::FlashOff: - flashMode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; - break; - case QCamera::FlashOn: - flashMode = GST_PHOTOGRAPHY_FLASH_MODE_ON; - break; - } - - gst_photography_set_flash_mode(m_camera->photography(), flashMode); - } -#endif -} - -bool QGstreamerCameraExposure::isFlashModeSupported(QCamera::FlashMode mode) const -{ -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) - return true; -#endif - - return mode == QCamera::FlashAuto; -} - -bool QGstreamerCameraExposure::isFlashReady() const -{ -#if QT_CONFIG(gstreamer_photography) - if (hasPhotography) - return true; -#endif - - return false; -} - -QT_END_NAMESPACE diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure_p.h b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure_p.h deleted file mode 100644 index ecbd72e77..000000000 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraexposure_p.h +++ /dev/null @@ -1,89 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef CAMERABINEXPOSURECONTROL_H -#define CAMERABINEXPOSURECONTROL_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <private/qplatformcameraexposure_p.h> - -QT_BEGIN_NAMESPACE - -class QGstreamerCamera; - -class QGstreamerCameraExposure : public QPlatformCameraExposure -{ - Q_OBJECT - -public: - QGstreamerCameraExposure(QGstreamerCamera *session); - virtual ~QGstreamerCameraExposure(); - - bool isParameterSupported(ExposureParameter parameter) const override; - QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const override; - - QVariant requestedValue(ExposureParameter parameter) const override; - QVariant actualValue(ExposureParameter parameter) const override; - bool setValue(ExposureParameter parameter, const QVariant &value) override; - - QCamera::FlashMode flashMode() const override; - void setFlashMode(QCamera::FlashMode mode) override; - bool isFlashModeSupported(QCamera::FlashMode mode) const override; - - bool isFlashReady() const override; - -private: - bool hasPhotography = false; - QGstreamerCamera *m_camera; - QHash<ExposureParameter, QVariant> m_requestedValues; -}; - -QT_END_NAMESPACE - -#endif // CAMERABINEXPOSURECONTROL_H diff --git a/src/multimedia/platform/qplatformcamera.cpp b/src/multimedia/platform/qplatformcamera.cpp index cf2170fa0..e1a6baac2 100644 --- a/src/multimedia/platform/qplatformcamera.cpp +++ b/src/multimedia/platform/qplatformcamera.cpp @@ -216,6 +216,73 @@ void QPlatformCamera::focusDistanceChanged(float d) } +void QPlatformCamera::flashReadyChanged(bool ready) +{ + if (m_flashReady == ready) + return; + m_flashReady = ready; + emit m_camera->flashReady(m_flashReady); +} + +void QPlatformCamera::flashModeChanged(QCamera::FlashMode mode) +{ + if (m_flashMode == mode) + return; + m_flashMode = mode; + emit m_camera->flashModeChanged(); +} + +void QPlatformCamera::torchModeChanged(QCamera::TorchMode mode) +{ + if (m_torchMode == mode) + return; + m_torchMode = mode; + emit m_camera->torchModeChanged(); +} + +void QPlatformCamera::exposureModeChanged(QCamera::ExposureMode mode) +{ + if (m_exposureMode == mode) + return; + m_exposureMode = mode; + emit m_camera->exposureModeChanged(); +} + +void QPlatformCamera::exposureCompensationChanged(float compensation) +{ + if (m_exposureCompensation == compensation) + return; + m_exposureCompensation = compensation; + emit m_camera->exposureCompensationChanged(compensation); +} + +void QPlatformCamera::exposureCompensationRangeChanged(float min, float max) +{ + if (m_minExposureCompensation == min && m_maxExposureCompensation == max) + return; + m_minExposureCompensation = min; + m_maxExposureCompensation = max; + // tell frontend +} + +void QPlatformCamera::isoSensitivityChanged(int iso) +{ + if (m_iso == iso) + return; + m_iso = iso; + emit m_camera->isoSensitivityChanged(iso); +} + +void QPlatformCamera::shutterSpeedChanged(float speed) +{ + if (m_shutterSpeed == speed) + return; + m_shutterSpeed = speed; + emit m_camera->shutterSpeedChanged(speed); +} + + + QT_END_NAMESPACE #include "moc_qplatformcamera_p.cpp" diff --git a/src/multimedia/platform/qplatformcamera_p.h b/src/multimedia/platform/qplatformcamera_p.h index d5d3721f9..df9c0d4aa 100644 --- a/src/multimedia/platform/qplatformcamera_p.h +++ b/src/multimedia/platform/qplatformcamera_p.h @@ -90,6 +90,21 @@ public: // smaller 0: zoom instantly, rate in power-of-two/sec virtual void zoomTo(float /*newZoomFactor*/, float /*rate*/ = -1.) {} + virtual void setFlashMode(QCamera::FlashMode /*mode*/) {} + virtual bool isFlashModeSupported(QCamera::FlashMode mode) const { return mode == QCamera::FlashOff; } + virtual bool isFlashReady() const { return false; } + + virtual void setTorchMode(QCamera::TorchMode /*mode*/) {} + virtual bool isTorchModeSupported(QCamera::TorchMode mode) const { return mode == QCamera::TorchOff; } + + virtual void setExposureMode(QCamera::ExposureMode) {} + virtual bool isExposureModeSupported(QCamera::ExposureMode mode) const { return mode == QCamera::ExposureAuto; } + virtual void setExposureCompensation(float) {} + virtual int isoSensitivity() const { return 100; } + virtual void setManualIsoSensitivity(int) {} + virtual void setManualShutterSpeed(float) {} + virtual float shutterSpeed() const { return -1.; } + QCamera::FocusMode focusMode() const { return m_focusMode; } QPointF focusPoint() const { return m_customFocusPoint; } @@ -99,6 +114,18 @@ public: QPointF customFocusPoint() const { return m_customFocusPoint; } float focusDistance() const { return m_focusDistance; } + QCamera::FlashMode flashMode() const { return m_flashMode; } + QCamera::TorchMode torchMode() const { return m_torchMode; } + + QCamera::ExposureMode exposureMode() const { return m_exposureMode; } + float exposureCompensation() const { return m_exposureCompensation; } + 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 minShutterSpeed() const { return m_minShutterSpeed; } + float maxShutterSpeed() const { return m_maxShutterSpeed; } + void statusChanged(QCamera::Status); void minimumZoomFactorChanged(float factor); void maximumZoomFactorChanged(float); @@ -106,6 +133,18 @@ public: void customFocusPointChanged(const QPointF &point); void focusDistanceChanged(float d); void zoomFactorChanged(float zoom); + void flashReadyChanged(bool); + void flashModeChanged(QCamera::FlashMode mode); + void torchModeChanged(QCamera::TorchMode mode); + void exposureModeChanged(QCamera::ExposureMode mode); + void exposureCompensationChanged(float compensation); + void exposureCompensationRangeChanged(float min, float max); + void isoSensitivityChanged(int iso); + void minIsoChanged(int iso) { m_minIso = iso; } + void maxIsoChanged(int iso) { m_maxIso = iso; } + void shutterSpeedChanged(float speed); + void minShutterSpeedChanged(float secs) { m_minShutterSpeed = secs; } + void maxShutterSpeedChanged(float secs) { m_maxShutterSpeed = secs; } Q_SIGNALS: void activeChanged(bool); @@ -123,7 +162,20 @@ private: float m_maxZoom = 1.; float m_zoomFactor = 1.; float m_focusDistance = 1.; - QPointF m_customFocusPoint{.5, .5}; + QPointF m_customFocusPoint{-1, -1}; + bool m_flashReady = false; + QCamera::FlashMode m_flashMode = QCamera::FlashOff; + QCamera::TorchMode m_torchMode = QCamera::TorchOff; + QCamera::ExposureMode m_exposureMode = QCamera::ExposureAuto; + float m_exposureCompensation = 0.; + float m_minExposureCompensation = 0.; + float m_maxExposureCompensation = 0.; + int m_iso = -1; + int m_minIso = -1; + int m_maxIso = -1; + float m_shutterSpeed = -1.; + float m_minShutterSpeed = -1.; + float m_maxShutterSpeed = -1.; }; QT_END_NAMESPACE diff --git a/src/multimedia/platform/qplatformcameraexposure.cpp b/src/multimedia/platform/qplatformcameraexposure.cpp deleted file mode 100644 index ca9b9ea16..000000000 --- a/src/multimedia/platform/qplatformcameraexposure.cpp +++ /dev/null @@ -1,166 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qplatformcameraexposure_p.h" - -QT_BEGIN_NAMESPACE - -/*! - \class QPlatformCameraExposure - \obsolete - - \brief The QPlatformCameraExposure class allows controlling camera exposure parameters. - - \inmodule QtMultimedia - - \ingroup multimedia_control - - The QCameraExposure class is the usual method of adjusting exposure related parameters - when using camera functionality. This class provides a more complete but less easy - to use interface, and also forms the interface to implement when writing a new - implementation of QCamera functionality. - - You can adjust a number of parameters that will affect images and video taken with - the corresponding QCamera object - see the \l {QPlatformCameraExposure::ExposureParameter}{ExposureParameter} enumeration. - - \sa QCameraExposure, QCamera -*/ - -/*! - Constructs a camera exposure control object with \a parent. -*/ -QPlatformCameraExposure::QPlatformCameraExposure(QObject *parent) - : QObject(parent) -{ -} - -/*! - \enum QPlatformCameraExposure::ExposureParameter - \value ISO - Camera ISO sensitivity, specified as integer value. - \value ShutterSpeed - Shutter speed in seconds, specified as qreal. - \value ExposureCompensation - Exposure compensation, specified as qreal EV value. - \value TorchPower - Manual torch power, specified as qreal value. - Accepted power range is [0..1.0], - with 0 value means no light and 1.0 corresponds to full torch power. - - This value is only used in the \l{QCamera::FlashVideolight}{torch flash mode}. - \value ExposureMode - Camera exposure mode. -*/ - -/*! - \fn QPlatformCameraExposure::isParameterSupported(ExposureParameter parameter) const - - Returns true is exposure \a parameter is supported by backend. - \since 5.0 -*/ - -/*! - \fn QPlatformCameraExposure::requestedValue(ExposureParameter parameter) const - - Returns the requested exposure \a parameter value. - - \since 5.0 -*/ - -/*! - \fn QPlatformCameraExposure::actualValue(ExposureParameter parameter) const - - Returns the actual exposure \a parameter value, or invalid QVariant() if the value is unknown or not supported. - - The actual parameter value may differ for the requested one if automatic mode is selected or - camera supports only limited set of values within the supported range. - \since 5.0 -*/ - - -/*! - \fn QPlatformCameraExposure::supportedParameterRange(ExposureParameter parameter, bool *continuous = 0) const - - Returns the list of supported \a parameter values; - - If the camera supports arbitrary exposure parameter value within the supported range, - *\a continuous is set to true, otherwise *\a continuous is set to false. - - \since 5.0 -*/ - -/*! - \fn bool QPlatformCameraExposure::setValue(ExposureParameter parameter, const QVariant& value) - - Set the exposure \a parameter to \a value. - If a null or invalid QVariant is passed, backend should choose the value automatically, - and if possible report the actual value to user with QPlatformCameraExposure::actualValue(). - - Returns true if parameter is supported and value is correct. - \since 5.0 -*/ - -/*! - \fn void QPlatformCameraExposure::requestedValueChanged(int parameter) - - Signal emitted when the requested exposure \a parameter value has changed, - usually in result of setValue() call. - \since 5.0 -*/ - -/*! - \fn void QPlatformCameraExposure::actualValueChanged(int parameter) - - Signal emitted when the actual exposure \a parameter value has changed, - usually in result of auto exposure algorithms or manual exposure parameter applied. - - \since 5.0 -*/ - -/*! - \fn void QPlatformCameraExposure::parameterRangeChanged(int parameter) - - Signal emitted when the supported range of exposure \a parameter values has changed. - - \since 5.0 -*/ - -QT_END_NAMESPACE - -#include "moc_qplatformcameraexposure_p.cpp" diff --git a/src/multimedia/platform/qplatformcameraexposure_p.h b/src/multimedia/platform/qplatformcameraexposure_p.h deleted file mode 100644 index 3cdc33754..000000000 --- a/src/multimedia/platform/qplatformcameraexposure_p.h +++ /dev/null @@ -1,112 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef QCAMERAEXPOSURECONTROL_H -#define QCAMERAEXPOSURECONTROL_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <QtCore/qobject.h> -#include <QtMultimedia/qtmultimediaglobal.h> - -#include <QtMultimedia/qcamera.h> -#include <QtMultimedia/qmediaenumdebug.h> - -QT_BEGIN_NAMESPACE - -// Required for QDoc workaround -class QString; - -class Q_MULTIMEDIA_EXPORT QPlatformCameraExposure : public QObject -{ - Q_OBJECT - Q_ENUMS(ExposureParameter) - -public: - enum ExposureParameter { - ISO, - ShutterSpeed, - ExposureCompensation, - TorchPower, - ExposureMode - }; - - virtual bool isParameterSupported(ExposureParameter parameter) const = 0; - virtual QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const = 0; - - virtual QVariant requestedValue(ExposureParameter parameter) const = 0; - virtual QVariant actualValue(ExposureParameter parameter) const = 0; - virtual bool setValue(ExposureParameter parameter, const QVariant& value) = 0; - - virtual QCamera::FlashMode flashMode() const = 0; - virtual void setFlashMode(QCamera::FlashMode mode) = 0; - virtual bool isFlashModeSupported(QCamera::FlashMode mode) const = 0; - - virtual QCamera::TorchMode torchMode() const { return QCamera::TorchOff; } - virtual void setTorchMode(QCamera::TorchMode /*mode*/) {} - virtual bool isTorchModeSupported(QCamera::TorchMode mode) const { return mode == QCamera::TorchOff; } - - virtual bool isFlashReady() const = 0; - -Q_SIGNALS: - void flashReady(bool); - void requestedValueChanged(int parameter); - void actualValueChanged(int parameter); - void parameterRangeChanged(int parameter); - -protected: - explicit QPlatformCameraExposure(QObject *parent = nullptr); -}; - -QT_END_NAMESPACE - -Q_MEDIA_ENUM_DEBUG(QPlatformCameraExposure, ExposureParameter) - - -#endif // QCAMERAEXPOSURECONTROL_H - diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscamera.cpp b/src/multimedia/platform/windows/mediacapture/qwindowscamera.cpp index 6475dccf0..a6cd0e6cc 100644 --- a/src/multimedia/platform/windows/mediacapture/qwindowscamera.cpp +++ b/src/multimedia/platform/windows/mediacapture/qwindowscamera.cpp @@ -40,7 +40,6 @@ #include "qwindowscamera_p.h" #include "qwindowscamerasession_p.h" -#include "qwindowscameraexposure_p.h" #include "qwindowscameraimageprocessing_p.h" #include "qwindowsmediacapture_p.h" #include <qcamerainfo.h> @@ -122,13 +121,6 @@ void QWindowsCamera::setCaptureSession(QPlatformMediaCaptureSession *session) m_cameraSession->setActiveCamera(m_cameraInfo); } -QPlatformCameraExposure *QWindowsCamera::exposureControl() -{ - if (!m_cameraSession) - return nullptr; - return m_cameraSession->exposureControl(); -} - QPlatformCameraImageProcessing *QWindowsCamera::imageProcessingControl() { if (!m_cameraSession) diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscamera_p.h b/src/multimedia/platform/windows/mediacapture/qwindowscamera_p.h index 29df07130..63b9ff84c 100644 --- a/src/multimedia/platform/windows/mediacapture/qwindowscamera_p.h +++ b/src/multimedia/platform/windows/mediacapture/qwindowscamera_p.h @@ -74,7 +74,6 @@ public: void setCaptureSession(QPlatformMediaCaptureSession *) override; - QPlatformCameraExposure *exposureControl() override; QPlatformCameraImageProcessing *imageProcessingControl() override; private Q_SLOTS: diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure.cpp b/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure.cpp deleted file mode 100644 index e5ec4cf83..000000000 --- a/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure.cpp +++ /dev/null @@ -1,114 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2021 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qwindowscameraexposure_p.h" - -#include "qwindowscamerasession_p.h" - -QT_BEGIN_NAMESPACE - -QWindowsCameraExposure::QWindowsCameraExposure(QWindowsCameraSession *session) - : QPlatformCameraExposure() - , m_session(session) -{ - Q_ASSERT(m_session); -} - -bool QWindowsCameraExposure::isParameterSupported(ExposureParameter parameter) const -{ - return false; -} - -QVariantList QWindowsCameraExposure::supportedParameterRange(ExposureParameter parameter, bool *continuous) const -{ - return QVariantList(); -} - -QVariant QWindowsCameraExposure::requestedValue(ExposureParameter parameter) const -{ - return QVariant(); -} - -QVariant QWindowsCameraExposure::actualValue(ExposureParameter parameter) const -{ - return QVariant(); -} - -bool QWindowsCameraExposure::setValue(ExposureParameter parameter, const QVariant& value) -{ - if (!value.isValid()) - return false; - - return false; -} - -QCamera::FlashMode QWindowsCameraExposure::flashMode() const -{ - return QCamera::FlashOff; -} - -void QWindowsCameraExposure::setFlashMode(QCamera::FlashMode mode) -{ -} - -bool QWindowsCameraExposure::isFlashModeSupported(QCamera::FlashMode mode) const -{ - return false; -} - -bool QWindowsCameraExposure::isFlashReady() const -{ - return false; -} - -QCamera::TorchMode QWindowsCameraExposure::torchMode() const -{ - return QCamera::TorchOff; -} - -void QWindowsCameraExposure::setTorchMode(QCamera::TorchMode mode) -{ -} - -bool QWindowsCameraExposure::isTorchModeSupported(QCamera::TorchMode mode) const -{ - return false; -} - -QT_END_NAMESPACE diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure_p.h b/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure_p.h deleted file mode 100644 index aa2b4c421..000000000 --- a/src/multimedia/platform/windows/mediacapture/qwindowscameraexposure_p.h +++ /dev/null @@ -1,88 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2021 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef QWINDOWSCAMERAEXPOSURE_H -#define QWINDOWSCAMERAEXPOSURE_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <private/qplatformcameraexposure_p.h> - -QT_BEGIN_NAMESPACE - -class QWindowsCameraSession; - -class QWindowsCameraExposure : public QPlatformCameraExposure -{ - Q_OBJECT -public: - explicit QWindowsCameraExposure(QWindowsCameraSession *session); - - bool isParameterSupported(ExposureParameter parameter) const override; - QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const override; - - QVariant requestedValue(ExposureParameter parameter) const override; - QVariant actualValue(ExposureParameter parameter) const override; - bool setValue(ExposureParameter parameter, const QVariant& value) override; - - QCamera::FlashMode flashMode() const override; - void setFlashMode(QCamera::FlashMode mode) override; - bool isFlashModeSupported(QCamera::FlashMode mode) const override; - bool isFlashReady() const override; - - QCamera::TorchMode torchMode() const override; - void setTorchMode(QCamera::TorchMode mode) override; - bool isTorchModeSupported(QCamera::TorchMode mode) const override; - -private: - QWindowsCameraSession *m_session; -}; - -QT_END_NAMESPACE - -#endif // QWINDOWSCAMERAEXPOSURE_H diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscamerasession.cpp b/src/multimedia/platform/windows/mediacapture/qwindowscamerasession.cpp index 87f8742a9..2177e6c5f 100644 --- a/src/multimedia/platform/windows/mediacapture/qwindowscamerasession.cpp +++ b/src/multimedia/platform/windows/mediacapture/qwindowscamerasession.cpp @@ -40,7 +40,6 @@ #include "qwindowscamerasession_p.h" #include "qwindowscamerareader_p.h" -#include "qwindowscameraexposure_p.h" #include "qwindowscameraimageprocessing_p.h" #include "qwindowsmultimediautils_p.h" #include <qvideosink.h> @@ -52,7 +51,6 @@ QWindowsCameraSession::QWindowsCameraSession(QObject *parent) : QObject(parent) { m_cameraReader = new QWindowsCameraReader(this); - m_cameraExposure = new QWindowsCameraExposure(this); m_cameraImageProcessing = new QWindowsCameraImageProcessing(this); connect(m_cameraReader, SIGNAL(streamingStarted()), this, SLOT(handleStreamingStarted())); connect(m_cameraReader, SIGNAL(streamingStopped()), this, SLOT(handleStreamingStopped())); @@ -64,7 +62,6 @@ QWindowsCameraSession::QWindowsCameraSession(QObject *parent) QWindowsCameraSession::~QWindowsCameraSession() { delete m_cameraImageProcessing; - delete m_cameraExposure; delete m_cameraReader; } @@ -127,11 +124,6 @@ void QWindowsCameraSession::setVideoSink(QVideoSink *surface) m_cameraReader->setSurface(surface); } -QWindowsCameraExposure *QWindowsCameraSession::exposureControl() -{ - return m_cameraExposure; -} - QWindowsCameraImageProcessing *QWindowsCameraSession::imageProcessingControl() { return m_cameraImageProcessing; diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscamerasession_p.h b/src/multimedia/platform/windows/mediacapture/qwindowscamerasession_p.h index 893036dd8..ca4e31cd2 100644 --- a/src/multimedia/platform/windows/mediacapture/qwindowscamerasession_p.h +++ b/src/multimedia/platform/windows/mediacapture/qwindowscamerasession_p.h @@ -60,7 +60,6 @@ QT_BEGIN_NAMESPACE class QVideoSink; class QWindowsCameraReader; -class QWindowsCameraExposure; class QWindowsCameraImageProcessing; class QWindowsCameraSession : public QObject @@ -85,7 +84,6 @@ public: void setVideoSink(QVideoSink *surface); - QWindowsCameraExposure *exposureControl(); QWindowsCameraImageProcessing *imageProcessingControl(); QMediaEncoderSettings videoSettings() const; @@ -114,7 +112,6 @@ private: bool m_readyForCapture = false; QCameraInfo m_activeCameraInfo; QWindowsCameraReader *m_cameraReader = nullptr; - QWindowsCameraExposure *m_cameraExposure = nullptr; QWindowsCameraImageProcessing *m_cameraImageProcessing = nullptr; QImageEncoderSettings m_imageEncoderSettings; QMediaEncoderSettings m_mediaEncoderSettings; diff --git a/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp b/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp index b13bfe3a4..3d1b970b5 100644 --- a/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp +++ b/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp @@ -33,7 +33,6 @@ #include <QDebug> #include <private/qplatformcamera_p.h> -#include <private/qplatformcameraexposure_p.h> #include <private/qplatformcameraimagecapture_p.h> #include <private/qplatformcameraimageprocessing_p.h> #include <qcamera.h> diff --git a/tests/auto/unit/mockbackend/CMakeLists.txt b/tests/auto/unit/mockbackend/CMakeLists.txt index 8def1a078..0c471e7f1 100644 --- a/tests/auto/unit/mockbackend/CMakeLists.txt +++ b/tests/auto/unit/mockbackend/CMakeLists.txt @@ -15,7 +15,6 @@ target_link_libraries(QtMultimediaMockBackend INTERFACE target_sources(QtMultimediaMockBackend INTERFACE qmockaudiodecoder.h qmockcamera.h - qmockcameraexposure.h qmockcameraimageprocessing.h qmockimagecapture.h qmockimagecapture.cpp qmockmediaplayer.h diff --git a/tests/auto/unit/mockbackend/qmockcamera.h b/tests/auto/unit/mockbackend/qmockcamera.h index 9a8a6549f..5ccf79e2f 100644 --- a/tests/auto/unit/mockbackend/qmockcamera.h +++ b/tests/auto/unit/mockbackend/qmockcamera.h @@ -32,7 +32,6 @@ #include "private/qplatformcamera_p.h" #include "qcamerainfo.h" #include "qmockcameraimageprocessing.h" -#include "qmockcameraexposure.h" #include <qtimer.h> class QMockCamera : public QPlatformCamera @@ -54,8 +53,14 @@ public: m_propertyChangesSupported(false) { if (!simpleCamera) { - mockExposure = new QMockCameraExposure(this); mockImageProcessing = new QMockCameraImageProcessing(this); + minIsoChanged(100); + maxIsoChanged(800); + minShutterSpeedChanged(.001); + maxShutterSpeedChanged(1); + exposureCompensationRangeChanged(-2, 2); + maximumZoomFactorChanged(4.); + setFlashMode(QCamera::FlashAuto); } } @@ -90,17 +95,75 @@ public: m_camera = camera; } - void setFocusMode(QCamera::FocusMode mode) override { focusModeChanged(mode); } - bool isFocusModeSupported(QCamera::FocusMode /*mode*/) const override { return true; } + void setFocusMode(QCamera::FocusMode mode) override + { + if (isFocusModeSupported(mode)) + focusModeChanged(mode); + } + bool isFocusModeSupported(QCamera::FocusMode mode) const override + { return simpleCamera ? mode == QCamera::FocusModeAuto : mode != QCamera::FocusModeInfinity; } - bool isCustomFocusPointSupported() const override { return true; } - void setCustomFocusPoint(const QPointF &point) override { customFocusPointChanged(point); } + bool isCustomFocusPointSupported() const override { return !simpleCamera; } + void setCustomFocusPoint(const QPointF &point) override + { + if (!simpleCamera) + customFocusPointChanged(point); + } - void setFocusDistance(float d) override { focusDistanceChanged(d); } + void setFocusDistance(float d) override + { + if (!simpleCamera) + focusDistanceChanged(d); + } void zoomTo(float newZoomFactor, float /*rate*/) override { zoomFactorChanged(newZoomFactor); } - QPlatformCameraExposure *exposureControl() override { return mockExposure; } + void setFlashMode(QCamera::FlashMode mode) override + { + if (!simpleCamera) + flashModeChanged(mode); + flashReadyChanged(mode != QCamera::FlashOff); + } + bool isFlashModeSupported(QCamera::FlashMode mode) const override { return simpleCamera ? mode == QCamera::FlashOff : true; } + bool isFlashReady() const override { return flashMode() != QCamera::FlashOff; } + + void setExposureMode(QCamera::ExposureMode mode) override + { + if (!simpleCamera && isExposureModeSupported(mode)) + exposureModeChanged(mode); + } + bool isExposureModeSupported(QCamera::ExposureMode mode) const override + { + return simpleCamera ? mode == QCamera::ExposureAuto : mode <= QCamera::ExposureBeach; + } + void setExposureCompensation(float c) override + { + if (!simpleCamera) + exposureCompensationChanged(qBound(-2., c, 2.)); + } + int isoSensitivity() const override + { + if (simpleCamera) + return -1; + return manualIsoSensitivity() > 0 ? manualIsoSensitivity() : 100; + } + void setManualIsoSensitivity(int iso) override + { + if (!simpleCamera) + isoSensitivityChanged(qBound(100, iso, 800)); + } + void setManualShutterSpeed(float secs) override + { + if (!simpleCamera) + shutterSpeedChanged(qBound(0.001, secs, 1.)); + } + float shutterSpeed() const override + { + if (simpleCamera) + return -1.; + return manualShutterSpeed() > 0 ? manualShutterSpeed() : .05; + } + QPlatformCameraImageProcessing *imageProcessingControl() override { return mockImageProcessing; } bool m_active = false; @@ -108,7 +171,6 @@ public: QCameraInfo m_camera; bool m_propertyChangesSupported; - QMockCameraExposure *mockExposure = nullptr; QMockCameraImageProcessing *mockImageProcessing = nullptr; }; diff --git a/tests/auto/unit/mockbackend/qmockcameraexposure.h b/tests/auto/unit/mockbackend/qmockcameraexposure.h deleted file mode 100644 index 61d5104b1..000000000 --- a/tests/auto/unit/mockbackend/qmockcameraexposure.h +++ /dev/null @@ -1,238 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2021 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef MOCKCAMERAEXPOSURECONTROL_H -#define MOCKCAMERAEXPOSURECONTROL_H - -#include "private/qplatformcameraexposure_p.h" - -class QMockCameraExposure : public QPlatformCameraExposure -{ - Q_OBJECT -public: - QMockCameraExposure(QObject *parent = 0): - QPlatformCameraExposure(parent), - m_shutterSpeed(0.01), - m_isoSensitivity(100), - m_exposureCompensation(0), - m_exposureMode(QCamera::ExposureAuto), - m_flashMode(QCamera::FlashAuto) - { - m_isoRanges << 100 << 200 << 400 << 800; - m_shutterRanges << 0.001 << 0.01 << 0.1 << 1.0; - m_exposureRanges << -2.0 << 2.0; - - const QCamera::ExposureMode exposureModes[] = { - QCamera::ExposureAuto, - QCamera::ExposureManual, - QCamera::ExposureNight, - QCamera::ExposureSports, - QCamera::ExposureSnow, - QCamera::ExposurePortrait, - QCamera::ExposureBeach - }; - - for (QCamera::ExposureMode mode : exposureModes) - m_exposureModes << QVariant::fromValue<QCamera::ExposureMode>(mode); - } - - ~QMockCameraExposure() {} - - bool isParameterSupported(ExposureParameter parameter) const - { - switch (parameter) { - case QPlatformCameraExposure::ExposureMode: - case QPlatformCameraExposure::ExposureCompensation: - case QPlatformCameraExposure::ISO: - case QPlatformCameraExposure::ShutterSpeed: - return true; - default: - return false; - } - } - - QVariant requestedValue(ExposureParameter param) const - { - return m_requestedParameters.value(param); - } - - QVariant actualValue(ExposureParameter param) const - { - switch (param) { - case QPlatformCameraExposure::ExposureMode: - return QVariant::fromValue<QCamera::ExposureMode>(m_exposureMode); - case QPlatformCameraExposure::ExposureCompensation: - return QVariant(m_exposureCompensation); - case QPlatformCameraExposure::ISO: - return QVariant(m_isoSensitivity); - case QPlatformCameraExposure::ShutterSpeed: - return QVariant(m_shutterSpeed); - default: - return QVariant(); - } - } - - QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const - { - *continuous = false; - - QVariantList res; - switch (parameter) { - case QPlatformCameraExposure::ExposureCompensation: - *continuous = true; - return m_exposureRanges; - case QPlatformCameraExposure::ISO: - return m_isoRanges; - case QPlatformCameraExposure::ShutterSpeed: - *continuous = true; - return m_shutterRanges; - case QPlatformCameraExposure::ExposureMode: - return m_exposureModes; - default: - break; - } - - return res; - } - - // Added valueChanged and parameterRangeChanged signal - bool setValue(ExposureParameter param, const QVariant& value) - { - if (!isParameterSupported(param)) - return false; - - if (m_requestedParameters.value(param) != value) { - m_requestedParameters.insert(param, value); - emit requestedValueChanged(param); - } - - switch (param) { - case QPlatformCameraExposure::ExposureMode: - { - QCamera::ExposureMode mode = value.value<QCamera::ExposureMode>(); - if (mode != m_exposureMode && m_exposureModes.contains(value)) { - m_exposureMode = mode; - emit actualValueChanged(param); - } - } - break; - case QPlatformCameraExposure::ExposureCompensation: - { - m_res.clear(); - m_res << -4.0 << 4.0; - qreal exposureCompensationlocal = qBound<qreal>(-2.0, value.toReal(), 2.0); - if (actualValue(param).toReal() != exposureCompensationlocal) { - m_exposureCompensation = exposureCompensationlocal; - emit actualValueChanged(param); - } - - if (m_exposureRanges.last().toReal() != m_res.last().toReal()) { - m_exposureRanges.clear(); - m_exposureRanges = m_res; - emit parameterRangeChanged(param); - } - } - break; - case QPlatformCameraExposure::ISO: - { - m_res.clear(); - m_res << 20 << 50; - qreal exposureCompensationlocal = 100*qRound(qBound(100, value.toInt(), 800)/100.0); - if (actualValue(param).toReal() != exposureCompensationlocal) { - m_isoSensitivity = exposureCompensationlocal; - emit actualValueChanged(param); - } - - if (m_isoRanges.last().toInt() != m_res.last().toInt()) { - m_isoRanges.clear(); - m_isoRanges = m_res; - emit parameterRangeChanged(param); - } - } - break; - case QPlatformCameraExposure::ShutterSpeed: - { - m_res.clear(); - m_res << 0.12 << 1.0 << 2.0; - qreal exposureCompensationlocal = qBound<qreal>(0.001, value.toReal(), 1.0); - if (actualValue(param).toReal() != exposureCompensationlocal) { - m_shutterSpeed = exposureCompensationlocal; - emit actualValueChanged(param); - } - - if (m_shutterRanges.last().toReal() != m_res.last().toReal()) { - m_shutterRanges.clear(); - m_shutterRanges = m_res; - emit parameterRangeChanged(param); - } - } - break; - - default: - return false; - } - - return true; - } - - QCamera::FlashMode flashMode() const - { - return m_flashMode; - } - - void setFlashMode(QCamera::FlashMode mode) - { - if (isFlashModeSupported(mode)) { - m_flashMode = mode; - } - emit flashReady(true); - } - //Setting the values for Flash mode - - bool isFlashModeSupported(QCamera::FlashMode /*mode*/) const - { - return true; - } - - bool isFlashReady() const - { - return true; - } - -private: - qreal m_shutterSpeed; - int m_isoSensitivity; - qreal m_exposureCompensation; - QCamera::ExposureMode m_exposureMode; - QCamera::FlashMode m_flashMode; - QVariantList m_isoRanges, m_shutterRanges, m_exposureRanges, m_res, m_exposureModes; - - QMap<QPlatformCameraExposure::ExposureParameter, QVariant> m_requestedParameters; -}; - -#endif // MOCKCAMERAEXPOSURECONTROL_H diff --git a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp index 6f5c584c5..290ed8d1f 100644 --- a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp +++ b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp @@ -33,7 +33,6 @@ #include <qvideosink.h> #include <private/qplatformcamera_p.h> -#include <private/qplatformcameraexposure_p.h> #include <private/qplatformcameraimagecapture_p.h> #include <private/qplatformcameraimageprocessing_p.h> #include <qcamera.h> @@ -154,7 +153,8 @@ void tst_QCamera::testSimpleCameraExposure() QMockCamera::Simple simple; QCamera camera; - QVERIFY(!camera.isExposureModeSupported(QCamera::ExposureAuto)); + QVERIFY(camera.isExposureModeSupported(QCamera::ExposureAuto)); + QVERIFY(!camera.isExposureModeSupported(QCamera::ExposureManual)); QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto); camera.setExposureMode(QCamera::ExposureManual);//should be ignored QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto); @@ -170,14 +170,16 @@ void tst_QCamera::testSimpleCameraExposure() QCOMPARE(camera.exposureCompensation(), 0.0); QCOMPARE(camera.isoSensitivity(), -1); - QVERIFY(camera.supportedIsoSensitivities().isEmpty()); + QCOMPARE(camera.minimumIsoSensitivity(), -1); + QCOMPARE(camera.maximumIsoSensitivity(), -1); camera.setManualIsoSensitivity(100); QCOMPARE(camera.isoSensitivity(), -1); camera.setAutoIsoSensitivity(); QCOMPARE(camera.isoSensitivity(), -1); QVERIFY(camera.shutterSpeed() < 0); - QVERIFY(camera.supportedShutterSpeeds().isEmpty()); + QCOMPARE(camera.minimumShutterSpeed(), -1.); + QCOMPARE(camera.maximumShutterSpeed(), -1.); camera.setAutoShutterSpeed(); QVERIFY(camera.shutterSpeed() < 0); camera.setManualShutterSpeed(1/128.0); @@ -190,11 +192,11 @@ void tst_QCamera::testSimpleCameraFocus() QCamera camera; - QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeAuto)); + QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAuto)); QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity)); QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); - camera.setFocusMode(QCamera::FocusModeAuto); + camera.setFocusMode(QCamera::FocusModeInfinity); QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); QCOMPARE(camera.maximumZoomFactor(), 1.0); @@ -206,7 +208,7 @@ void tst_QCamera::testSimpleCameraFocus() QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.)); camera.setCustomFocusPoint(QPointF(1.0, 1.0)); - QCOMPARE(camera.customFocusPoint(), QPointF(-1, -1)); + QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.)); } void tst_QCamera::testSimpleCameraCapture() @@ -370,28 +372,24 @@ void tst_QCamera::testCameraExposure() camera.setExposureCompensation(2.0); QCOMPARE(camera.exposureCompensation(), 2.0); - int minIso = camera.supportedIsoSensitivities().first(); - int maxIso = camera.supportedIsoSensitivities().last(); - QVERIFY(camera.isoSensitivity() > 0); - QCOMPARE(camera.requestedIsoSensitivity(), -1); + int minIso = camera.minimumIsoSensitivity(); + int maxIso = camera.maximumIsoSensitivity(); + QCOMPARE(camera.isoSensitivity(), 100); QVERIFY(minIso > 0); QVERIFY(maxIso > 0); camera.setManualIsoSensitivity(minIso); QCOMPARE(camera.isoSensitivity(), minIso); camera.setManualIsoSensitivity(maxIso*10); QCOMPARE(camera.isoSensitivity(), maxIso); - QCOMPARE(camera.requestedIsoSensitivity(), maxIso*10); camera.setManualIsoSensitivity(-10); QCOMPARE(camera.isoSensitivity(), minIso); - QCOMPARE(camera.requestedIsoSensitivity(), -10); camera.setAutoIsoSensitivity(); QCOMPARE(camera.isoSensitivity(), 100); - QCOMPARE(camera.requestedIsoSensitivity(), -1); - QCOMPARE(camera.requestedShutterSpeed(), -1.0); - qreal minShutterSpeed = camera.supportedShutterSpeeds().first(); - qreal maxShutterSpeed = camera.supportedShutterSpeeds().last(); + qreal minShutterSpeed = camera.minimumShutterSpeed(); + qreal maxShutterSpeed = camera.maximumShutterSpeed(); + qDebug() << minShutterSpeed << maxShutterSpeed; QVERIFY(minShutterSpeed > 0); QVERIFY(maxShutterSpeed > 0); QVERIFY(camera.shutterSpeed() >= minShutterSpeed); @@ -400,18 +398,14 @@ void tst_QCamera::testCameraExposure() camera.setAutoShutterSpeed(); QVERIFY(camera.shutterSpeed() >= minShutterSpeed); QVERIFY(camera.shutterSpeed() <= maxShutterSpeed); - QCOMPARE(camera.requestedShutterSpeed(), -1.0); camera.setManualShutterSpeed(0); QCOMPARE(camera.shutterSpeed(), minShutterSpeed); - QCOMPARE(camera.requestedShutterSpeed()+1.0, 1.0); camera.setManualShutterSpeed(10000); QCOMPARE(camera.shutterSpeed(), maxShutterSpeed); - QCOMPARE(camera.requestedShutterSpeed(), 10000.0); camera.setAutoShutterSpeed(); - QCOMPARE(camera.requestedShutterSpeed(), -1.0); } void tst_QCamera::testCameraFocus() @@ -424,7 +418,9 @@ void tst_QCamera::testCameraFocus() QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); camera.setFocusMode(QCamera::FocusModeManual); - QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); + QCOMPARE(camera.focusMode(), QCamera::FocusModeManual); + camera.setFocusMode(QCamera::FocusModeInfinity); + QCOMPARE(camera.focusMode(), QCamera::FocusModeManual); camera.setFocusMode(QCamera::FocusModeAuto); QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); @@ -844,15 +840,14 @@ void tst_QCamera::testFocusMode() QCamera camera; session.setCamera(&camera); - QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeHyperfocal)); - QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeAutoNear)); + QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity)); + QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAutoNear)); QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); - camera.setFocusMode(QCamera::FocusModeHyperfocal); - QVERIFY(camera.focusMode()!= QCamera::FocusModeHyperfocal); + camera.setFocusMode(QCamera::FocusModeInfinity); + QVERIFY(camera.focusMode() != QCamera::FocusModeInfinity); QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); camera.setFocusMode(QCamera::FocusModeAutoNear); - QVERIFY(camera.focusMode()!= QCamera::FocusModeAutoNear); - QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto); + QVERIFY(camera.focusMode() == QCamera::FocusModeAutoNear); } void tst_QCamera::testZoomChanged() @@ -934,7 +929,6 @@ void tst_QCamera::testSignalShutterSpeedChanged() session.setCamera(&camera); QSignalSpy spySignalShutterSpeedChanged(&camera, SIGNAL(shutterSpeedChanged(qreal))); - QSignalSpy spySignalShutterSpeedRangeChanged(&camera, SIGNAL(shutterSpeedRangeChanged())); QVERIFY(spySignalShutterSpeedChanged.count() ==0); @@ -942,7 +936,6 @@ void tst_QCamera::testSignalShutterSpeedChanged() QTest::qWait(100); QVERIFY(spySignalShutterSpeedChanged.count() ==1); - QVERIFY(spySignalShutterSpeedRangeChanged.count() ==1); } void tst_QCamera::testSignalFlashReady() @@ -953,15 +946,15 @@ void tst_QCamera::testSignalFlashReady() QSignalSpy spyflashReady(&camera,SIGNAL(flashReady(bool))); - QVERIFY(spyflashReady.count() ==0); + QVERIFY(spyflashReady.count() == 0); - QVERIFY(camera.flashMode() ==QCamera::FlashAuto); + QVERIFY(camera.flashMode() == QCamera::FlashAuto); camera.setFlashMode(QCamera::FlashOff);//set theFlashMode to QCamera::FlashOff - QVERIFY(camera.flashMode() ==QCamera::FlashOff); + QVERIFY(camera.flashMode() == QCamera::FlashOff); - QVERIFY(spyflashReady.count() ==1); + QCOMPARE(spyflashReady.count(), 1); } QTEST_MAIN(tst_QCamera) diff --git a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp index 78c1d4c99..2b11636c0 100644 --- a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp +++ b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp @@ -30,7 +30,6 @@ #include <QDebug> #include <private/qplatformcamera_p.h> -#include <private/qplatformcameraexposure_p.h> #include <private/qplatformcameraimagecapture_p.h> #include <private/qplatformcameraimageprocessing_p.h> #include <qcamera.h> diff --git a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp index 235294779..00cfc1646 100644 --- a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp +++ b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp @@ -32,7 +32,6 @@ #include <QDebug> #include <private/qplatformcamera_p.h> -#include <private/qplatformcameraexposure_p.h> #include <private/qplatformcameraimagecapture_p.h> #include <private/qplatformcameraimageprocessing_p.h> #include <qmediacapturesession.h> |