From 76bcf3c97513638cda46b1f488c53a749eb3888d Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Mon, 17 May 2021 15:32:00 +0200 Subject: Merge QCameraImageProcessing into QCamera At the same time remove the colorFilter property. Color filters are at most a post-processing effect and should not be part of QCamera itself. The support for the filters was in any case missing pretty much everywhere (except gst-photography, which is not supported by most cameras today). Change-Id: I59306cc75470b11490feeb910c26a414d796f9f1 Reviewed-by: Volker Hilsheimer --- src/multimedia/CMakeLists.txt | 1 - src/multimedia/camera/qcamera.cpp | 217 +++++++++++- src/multimedia/camera/qcamera.h | 50 ++- src/multimedia/camera/qcamera_p.h | 16 +- src/multimedia/camera/qcameraimageprocessing.cpp | 391 --------------------- src/multimedia/camera/qcameraimageprocessing.h | 150 -------- .../doc/snippets/multimedia-snippets/camera.cpp | 9 +- src/multimedia/doc/src/cameraoverview.qdoc | 8 +- .../qandroidcameraimageprocessingcontrol.cpp | 26 +- .../qandroidcameraimageprocessingcontrol_p.h | 6 +- .../darwin/camera/avfcameraimageprocessing.mm | 40 +-- .../darwin/camera/avfcameraimageprocessing_p.h | 8 +- .../qgstreamercameraimageprocessing.cpp | 109 ++---- .../qgstreamercameraimageprocessing_p.h | 10 +- .../qnx/camera/bbcameraimageprocessingcontrol.cpp | 14 +- .../platform/qplatformcameraimageprocessing.cpp | 2 +- .../platform/qplatformcameraimageprocessing_p.h | 3 +- src/multimedia/qmediametadata.cpp | 2 +- 18 files changed, 349 insertions(+), 713 deletions(-) delete mode 100644 src/multimedia/camera/qcameraimageprocessing.cpp delete mode 100644 src/multimedia/camera/qcameraimageprocessing.h (limited to 'src/multimedia') diff --git a/src/multimedia/CMakeLists.txt b/src/multimedia/CMakeLists.txt index 1b2e6a779..3da633f8d 100644 --- a/src/multimedia/CMakeLists.txt +++ b/src/multimedia/CMakeLists.txt @@ -28,7 +28,6 @@ qt_internal_add_module(Multimedia audio/qwavedecoder.cpp audio/qwavedecoder.h camera/qcamera.cpp camera/qcamera.h camera/qcamera_p.h camera/qcameraimagecapture.cpp camera/qcameraimagecapture.h - camera/qcameraimageprocessing.cpp camera/qcameraimageprocessing.h camera/qcamerainfo.cpp camera/qcamerainfo.h camera/qcamerainfo_p.h platform/qplatformaudiodecoder.cpp platform/qplatformaudiodecoder_p.h platform/qplatformcamera.cpp platform/qplatformcamera_p.h diff --git a/src/multimedia/camera/qcamera.cpp b/src/multimedia/camera/qcamera.cpp index 0a159470e..291fcdae9 100644 --- a/src/multimedia/camera/qcamera.cpp +++ b/src/multimedia/camera/qcamera.cpp @@ -85,6 +85,19 @@ QT_BEGIN_NAMESPACE \snippet multimedia-snippets/camera.cpp Camera zoom + + After capturing the data for a camera frame, the camera hardware and + software performs various image processing tasks to produce a final + image. This includes compensating for ambient light color, reducing + noise, as well as making some other adjustments to the image. + + For example, you can set the white balance (or color temperature) used + for processing images: + + \snippet multimedia-snippets/camera.cpp Camera image whitebalance + + For more information on image processing of camera frames, see \l {camera_image_processing}{Camera Image Processing}. + See the \l{Camera Overview}{camera overview} for more information. */ @@ -133,7 +146,7 @@ void QCameraPrivate::init() q->connect(exposureControl, SIGNAL(flashReady(bool)), q, SIGNAL(flashReady(bool))); } - imageProcessing = new QCameraImageProcessing(q, control); + imageControl = control->imageProcessingControl(); } /*! @@ -236,14 +249,6 @@ void QCamera::setActive(bool active) d->control->setActive(active); } -/*! - Returns the camera image processing control object. -*/ -QCameraImageProcessing *QCamera::imageProcessing() const -{ - return d_func()->imageProcessing; -} - /*! Returns the error state of the object. */ @@ -1153,6 +1158,200 @@ void QCamera::setAutoShutterSpeed() Signal emitted when the exposure compensation changes to \a value. */ + + +/*! + Returns the white balance mode being used. +*/ + +QCamera::WhiteBalanceMode QCamera::whiteBalanceMode() const +{ + Q_D(const QCamera); + return d->whiteBalance; +} + +/*! + Sets the white balance to \a mode. +*/ + +void QCamera::setWhiteBalanceMode(QCamera::WhiteBalanceMode mode) +{ + Q_D(QCamera); + if (d->whiteBalance == mode || !isWhiteBalanceModeSupported(mode)) + return; + + d->imageControl->setParameter( + QPlatformCameraImageProcessing::WhiteBalancePreset, + QVariant::fromValue(mode)); + d->whiteBalance = mode; + emit whiteBalanceModeChanged(); +} + +/*! + Returns true if the white balance \a mode is supported. +*/ + +bool QCamera::isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const +{ + Q_D(const QCamera); + if (!d->imageControl) + return false; + return d->imageControl->isParameterValueSupported( + QPlatformCameraImageProcessing::WhiteBalancePreset, + QVariant::fromValue(mode)); + +} + +/*! + Returns the current color temperature if the + current white balance mode is \c WhiteBalanceManual. For other modes the + return value is undefined. +*/ + +qreal QCamera::manualWhiteBalance() const +{ + Q_D(const QCamera); + return d->colorTemperature; +} + +/*! + Sets manual white balance to \a colorTemperature. This is used + when whiteBalanceMode() is set to \c WhiteBalanceManual. The units are Kelvin. +*/ + +void QCamera::setManualWhiteBalance(qreal colorTemperature) +{ + Q_D(QCamera); + if (!d->imageControl) + return; + if (d->colorTemperature == colorTemperature) + return; + if (colorTemperature == 0) { + setWhiteBalanceMode(WhiteBalanceAuto); + } else if (!isWhiteBalanceModeSupported(WhiteBalanceManual)) { + return; + } else { + setWhiteBalanceMode(WhiteBalanceManual); + d->imageControl->setParameter( + QPlatformCameraImageProcessing::ColorTemperature, + QVariant(colorTemperature)); + } + d->colorTemperature = colorTemperature; + emit manualWhiteBalanceChanged(); +} + +/*! + Returns the brightness adjustment setting. + */ +qreal QCamera::brightness() const +{ + Q_D(const QCamera); + return d->brightness; +} + +/*! + Set the brightness adjustment to \a value. + + Valid brightness adjustment values range between -1.0 and 1.0, with a default of 0. +*/ +void QCamera::setBrightness(qreal value) +{ + Q_D(QCamera); + if (!d->imageControl || d->brightness == value) + return; + d->brightness = value; + d->imageControl->setParameter(QPlatformCameraImageProcessing::BrightnessAdjustment, + QVariant(value)); + emit brightnessChanged(); +} + +/*! + Returns the contrast adjustment setting. +*/ +qreal QCamera::contrast() const +{ + Q_D(const QCamera); + return d->contrast; +} + +/*! + Set the contrast adjustment to \a value. + + Valid contrast adjustment values range between -1.0 and 1.0, with a default of 0. +*/ +void QCamera::setContrast(qreal value) +{ + Q_D(QCamera); + if (!d->imageControl || d->contrast == value) + return; + d->contrast = value; + d->imageControl->setParameter(QPlatformCameraImageProcessing::ContrastAdjustment, + QVariant(value)); + emit contrastChanged(); +} + +/*! + Returns the saturation adjustment value. +*/ +qreal QCamera::saturation() const +{ + Q_D(const QCamera); + return d->saturation; +} + +/*! + Sets the saturation adjustment value to \a value. + + Valid saturation values range between -1.0 and 1.0, with a default of 0. +*/ +void QCamera::setSaturation(qreal value) +{ + Q_D(QCamera); + if (!d->imageControl || d->saturation == value) + return; + d->saturation = value; + d->imageControl->setParameter(QPlatformCameraImageProcessing::SaturationAdjustment, + QVariant(value)); + emit saturationChanged(); +} + +qreal QCamera::hue() const +{ + Q_D(const QCamera); + return d->hue; +} + +/*! + Sets the hue adjustment value to \a value. + + Valid hue values range between -1.0 and 1.0, with a default of 0. +*/ +void QCamera::setHue(qreal value) +{ + Q_D(QCamera); + if (!d->imageControl || d->hue == value) + return; + d->hue = value; + d->imageControl->setParameter(QPlatformCameraImageProcessing::HueAdjustment, + QVariant(value)); + emit hueChanged(); +} + +/*! + \enum QCamera::WhiteBalanceMode + + \value WhiteBalanceAuto Auto white balance mode. + \value WhiteBalanceManual Manual white balance. In this mode the white balance should be set with + setManualWhiteBalance() + \value WhiteBalanceSunlight Sunlight white balance mode. + \value WhiteBalanceCloudy Cloudy white balance mode. + \value WhiteBalanceShade Shade white balance mode. + \value WhiteBalanceTungsten Tungsten (incandescent) white balance mode. + \value WhiteBalanceFluorescent Fluorescent white balance mode. + \value WhiteBalanceFlash Flash white balance mode. + \value WhiteBalanceSunset Sunset white balance mode. +*/ + QT_END_NAMESPACE #include "moc_qcamera.cpp" diff --git a/src/multimedia/camera/qcamera.h b/src/multimedia/camera/qcamera.h index 988b9adf3..904d0e098 100644 --- a/src/multimedia/camera/qcamera.h +++ b/src/multimedia/camera/qcamera.h @@ -48,7 +48,6 @@ #include -#include #include #include @@ -66,7 +65,6 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject Q_OBJECT Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged) Q_PROPERTY(QCamera::Status status READ status NOTIFY statusChanged) - Q_PROPERTY(QCameraImageProcessing* imageProcessing READ imageProcessing CONSTANT) Q_PROPERTY(QCameraInfo cameraInfo READ cameraInfo WRITE setCameraInfo NOTIFY cameraInfoChanged) Q_PROPERTY(Error error READ error NOTIFY errorChanged) Q_PROPERTY(QString errorString READ errorString NOTIFY errorChanged) @@ -88,6 +86,13 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject Q_PROPERTY(QCamera::TorchMode torchMode READ torchMode WRITE setTorchMode) Q_PROPERTY(QCamera::ExposureMode exposureMode READ exposureMode WRITE setExposureMode) + Q_PROPERTY(WhiteBalanceMode whiteBalanceMode READ whiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged) + Q_PROPERTY(qreal manualWhiteBalance READ manualWhiteBalance WRITE setManualWhiteBalance NOTIFY manualWhiteBalanceChanged) + Q_PROPERTY(qreal brightness READ brightness WRITE setBrightness NOTIFY brightnessChanged) + Q_PROPERTY(qreal contrast READ contrast WRITE setContrast NOTIFY contrastChanged) + Q_PROPERTY(qreal hue READ hue WRITE setHue NOTIFY hueChanged) + Q_PROPERTY(qreal saturation READ saturation WRITE setSaturation NOTIFY saturationChanged) + Q_ENUMS(Status) Q_ENUMS(Error) @@ -97,6 +102,7 @@ class Q_MULTIMEDIA_EXPORT QCamera : public QObject Q_ENUMS(TorchMode) Q_ENUMS(ExposureMode) + Q_ENUMS(WhiteBalanceMode) public: enum Status { UnavailableStatus, @@ -153,6 +159,18 @@ public: ExposureBarcode }; + enum WhiteBalanceMode { + WhiteBalanceAuto = 0, + WhiteBalanceManual = 1, + WhiteBalanceSunlight = 2, + WhiteBalanceCloudy = 3, + WhiteBalanceShade = 4, + WhiteBalanceTungsten = 5, + WhiteBalanceFluorescent = 6, + WhiteBalanceFlash = 7, + WhiteBalanceSunset = 8 + }; + explicit QCamera(QObject *parent = nullptr); explicit QCamera(const QCameraInfo& cameraInfo, QObject *parent = nullptr); explicit QCamera(QCameraInfo::Position position, QObject *parent = nullptr); @@ -171,8 +189,6 @@ public: QCameraFormat cameraFormat() const; void setCameraFormat(const QCameraFormat &format); - QCameraImageProcessing *imageProcessing() const; - Error error() const; QString errorString() const; @@ -218,6 +234,16 @@ public: QList supportedApertures(bool *continuous = nullptr) const; QList supportedShutterSpeeds(bool *continuous = nullptr) const; + WhiteBalanceMode whiteBalanceMode() const; + Q_INVOKABLE bool isWhiteBalanceModeSupported(WhiteBalanceMode mode) const; + + qreal manualWhiteBalance() const; + + qreal brightness() const; + qreal contrast() const; + qreal saturation() const; + qreal hue() const; + public Q_SLOTS: void setActive(bool active); void start() { setActive(true); } @@ -240,6 +266,14 @@ public Q_SLOTS: void setManualShutterSpeed(qreal seconds); void setAutoShutterSpeed(); + void setWhiteBalanceMode(WhiteBalanceMode mode); + void setManualWhiteBalance(qreal colorTemperature); + + void setBrightness(qreal value); + void setContrast(qreal value); + void setSaturation(qreal value); + void setHue(qreal value); + Q_SIGNALS: void activeChanged(bool); void statusChanged(QCamera::Status status); @@ -264,6 +298,14 @@ Q_SIGNALS: void isoSensitivityChanged(int); void exposureCompensationChanged(qreal); + void whiteBalanceModeChanged() const; + void manualWhiteBalanceChanged() const; + + void brightnessChanged(); + void contrastChanged(); + void saturationChanged(); + void hueChanged(); + private: void setCaptureSession(QMediaCaptureSession *session); friend class QMediaCaptureSession; diff --git a/src/multimedia/camera/qcamera_p.h b/src/multimedia/camera/qcamera_p.h index 0224ac6d5..ee11bc946 100644 --- a/src/multimedia/camera/qcamera_p.h +++ b/src/multimedia/camera/qcamera_p.h @@ -61,6 +61,7 @@ QT_BEGIN_NAMESPACE class QPlatformCamera; class QPlatformCameraFocus; class QPlatformCameraExposure; +class QPlatformCameraImageProcessing; class QPlatformMediaCaptureSession; class QCameraPrivate : public QObjectPrivate @@ -79,10 +80,6 @@ public: QPlatformMediaCaptureSession *captureInterface = nullptr; QPlatformCamera *control = nullptr; - QCameraImageProcessing *imageProcessing = nullptr; - - QObject *capture = nullptr; - QCamera::Error error; QString errorString; @@ -93,7 +90,16 @@ public: float zoomFactor = 1.; QPointF customFocusPoint{-1, -1}; - QPlatformCameraExposure *exposureControl; + QPlatformCameraExposure *exposureControl = nullptr; + + QPlatformCameraImageProcessing *imageControl = nullptr; + + QCamera::WhiteBalanceMode whiteBalance = QCamera::WhiteBalanceAuto; + qreal colorTemperature = 0; + qreal brightness = 0; + qreal contrast = 0; + qreal saturation = 0; + qreal hue = 0; template T actualExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const; template T requestedExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const; diff --git a/src/multimedia/camera/qcameraimageprocessing.cpp b/src/multimedia/camera/qcameraimageprocessing.cpp deleted file mode 100644 index 7ed07244b..000000000 --- a/src/multimedia/camera/qcameraimageprocessing.cpp +++ /dev/null @@ -1,391 +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 "qcameraimageprocessing.h" -#include "private/qobject_p.h" - -#include -#include - -#include - -QT_BEGIN_NAMESPACE - -/*! - \class QCameraImageProcessing - - \brief The QCameraImageProcessing class provides an interface for - image processing related camera settings. - - \inmodule QtMultimedia - \ingroup multimedia - \ingroup multimedia_camera - - After capturing the data for a camera frame, the camera hardware and - software performs various image processing tasks to produce a final - image. This includes compensating for ambient light color, reducing - noise, as well as making some other adjustments to the image. - - You can retrieve this class from an instance of a \l QCamera object. - - For example, you can set the white balance (or color temperature) used - for processing images: - - \snippet multimedia-snippets/camera.cpp Camera image whitebalance - - In some cases changing these settings may result in a longer delay - before an image is ready. - - For more information on image processing of camera frames, see \l {camera_image_processing}{Camera Image Processing}. - - \sa QPlatformCameraImageProcessing -*/ - -class QCameraImageProcessingPrivate : public QObjectPrivate -{ -public: - void init(QPlatformCamera *cameraControl); - - QCamera *camera; - QPlatformCameraImageProcessing *imageControl; - - QCameraImageProcessing::WhiteBalanceMode whiteBalance = QCameraImageProcessing::WhiteBalanceAuto; - QCameraImageProcessing::ColorFilter colorFilter = QCameraImageProcessing::ColorFilterNone; - qreal colorTemperature = 0; - qreal brightness = 0; - qreal contrast = 0; - qreal saturation = 0; - qreal hue = 0; -}; - - -void QCameraImageProcessingPrivate::init(QPlatformCamera *cameraControl) -{ - imageControl = cameraControl->imageProcessingControl(); -} - -/*! - Construct a QCameraImageProcessing for \a camera. -*/ - -QCameraImageProcessing::QCameraImageProcessing(QCamera *camera, QPlatformCamera *cameraControl) - : QObject(*new QCameraImageProcessingPrivate, camera) -{ - Q_D(QCameraImageProcessing); - d->camera = camera; - d->init(cameraControl); -} - - -/*! - Destroys the camera focus object. -*/ - -QCameraImageProcessing::~QCameraImageProcessing() = default; - - -/*! - Returns true if image processing related settings are supported by this camera. -*/ -bool QCameraImageProcessing::isAvailable() const -{ - return d_func()->imageControl; -} - - -/*! - Returns the white balance mode being used. -*/ - -QCameraImageProcessing::WhiteBalanceMode QCameraImageProcessing::whiteBalanceMode() const -{ - Q_D(const QCameraImageProcessing); - return d->whiteBalance; -} - -/*! - Sets the white balance to \a mode. -*/ - -void QCameraImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode) -{ - Q_D(QCameraImageProcessing); - if (d->whiteBalance == mode || !isWhiteBalanceModeSupported(mode)) - return; - - d->imageControl->setParameter( - QPlatformCameraImageProcessing::WhiteBalancePreset, - QVariant::fromValue(mode)); - d->whiteBalance = mode; - emit whiteBalanceModeChanged(); -} - -/*! - Returns true if the white balance \a mode is supported. -*/ - -bool QCameraImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const -{ - Q_D(const QCameraImageProcessing); - if (!d->imageControl) - return false; - return d->imageControl->isParameterValueSupported( - QPlatformCameraImageProcessing::WhiteBalancePreset, - QVariant::fromValue(mode)); - -} - -/*! - Returns the current color temperature if the - current white balance mode is \c WhiteBalanceManual. For other modes the - return value is undefined. -*/ - -qreal QCameraImageProcessing::manualWhiteBalance() const -{ - Q_D(const QCameraImageProcessing); - return d->colorTemperature; -} - -/*! - Sets manual white balance to \a colorTemperature. This is used - when whiteBalanceMode() is set to \c WhiteBalanceManual. The units are Kelvin. -*/ - -void QCameraImageProcessing::setManualWhiteBalance(qreal colorTemperature) -{ - Q_D(QCameraImageProcessing); - if (!d->imageControl) - return; - if (d->colorTemperature == colorTemperature) - return; - if (colorTemperature == 0) { - setWhiteBalanceMode(WhiteBalanceAuto); - } else if (!isWhiteBalanceModeSupported(WhiteBalanceManual)) { - return; - } else { - setWhiteBalanceMode(WhiteBalanceManual); - d->imageControl->setParameter( - QPlatformCameraImageProcessing::ColorTemperature, - QVariant(colorTemperature)); - } - d->colorTemperature = colorTemperature; - emit manualWhiteBalanceChanged(); -} - -/*! - Returns the brightness adjustment setting. - */ -qreal QCameraImageProcessing::brightness() const -{ - Q_D(const QCameraImageProcessing); - return d->brightness; -} - -/*! - Set the brightness adjustment to \a value. - - Valid brightness adjustment values range between -1.0 and 1.0, with a default of 0. - */ -void QCameraImageProcessing::setBrightness(qreal value) -{ - Q_D(QCameraImageProcessing); - if (!d->imageControl || d->brightness == value) - return; - d->brightness = value; - d->imageControl->setParameter(QPlatformCameraImageProcessing::BrightnessAdjustment, - QVariant(value)); - emit brightnessChanged(); -} - -/*! - Returns the contrast adjustment setting. -*/ -qreal QCameraImageProcessing::contrast() const -{ - Q_D(const QCameraImageProcessing); - return d->contrast; -} - -/*! - Set the contrast adjustment to \a value. - - Valid contrast adjustment values range between -1.0 and 1.0, with a default of 0. -*/ -void QCameraImageProcessing::setContrast(qreal value) -{ - Q_D(QCameraImageProcessing); - if (!d->imageControl || d->contrast == value) - return; - d->contrast = value; - d->imageControl->setParameter(QPlatformCameraImageProcessing::ContrastAdjustment, - QVariant(value)); - emit contrastChanged(); -} - -/*! - Returns the saturation adjustment value. -*/ -qreal QCameraImageProcessing::saturation() const -{ - Q_D(const QCameraImageProcessing); - return d->saturation; -} - -/*! - Sets the saturation adjustment value to \a value. - - Valid saturation values range between -1.0 and 1.0, with a default of 0. -*/ - -void QCameraImageProcessing::setSaturation(qreal value) -{ - Q_D(QCameraImageProcessing); - if (!d->imageControl || d->saturation == value) - return; - d->saturation = value; - d->imageControl->setParameter(QPlatformCameraImageProcessing::SaturationAdjustment, - QVariant(value)); - emit saturationChanged(); -} - -qreal QCameraImageProcessing::hue() const -{ - Q_D(const QCameraImageProcessing); - return d->hue; -} - -/*! - Sets the hue adjustment value to \a value. - - Valid hue values range between -1.0 and 1.0, with a default of 0. -*/ -void QCameraImageProcessing::setHue(qreal value) -{ - Q_D(QCameraImageProcessing); - if (!d->imageControl || d->hue == value) - return; - d->hue = value; - d->imageControl->setParameter(QPlatformCameraImageProcessing::HueAdjustment, - QVariant(value)); - emit hueChanged(); -} - -/*! - \enum QCameraImageProcessing::WhiteBalanceMode - - \value WhiteBalanceAuto Auto white balance mode. - \value WhiteBalanceManual Manual white balance. In this mode the white balance should be set with - setManualWhiteBalance() - \value WhiteBalanceSunlight Sunlight white balance mode. - \value WhiteBalanceCloudy Cloudy white balance mode. - \value WhiteBalanceShade Shade white balance mode. - \value WhiteBalanceTungsten Tungsten (incandescent) white balance mode. - \value WhiteBalanceFluorescent Fluorescent white balance mode. - \value WhiteBalanceFlash Flash white balance mode. - \value WhiteBalanceSunset Sunset white balance mode. -*/ - -/*! - \enum QCameraImageProcessing::ColorFilter - - \value ColorFilterNone No filter is applied to images. - \value ColorFilterGrayscale A grayscale filter. - \value ColorFilterNegative A negative filter. - \value ColorFilterSolarize A solarize filter. - \value ColorFilterSepia A sepia filter. - \value ColorFilterPosterize A posterize filter. - \value ColorFilterWhiteboard A whiteboard filter. - \value ColorFilterBlackboard A blackboard filter. - \value ColorFilterAqua An aqua filter. - - \since 5.5 -*/ - -/*! - Returns the color filter which will be applied to image data captured by the camera. - - \since 5.5 -*/ - -QCameraImageProcessing::ColorFilter QCameraImageProcessing::colorFilter() const -{ - Q_D(const QCameraImageProcessing); - return d->colorFilter; -} - - -/*! - Sets the color \a filter which will be applied to image data captured by the camera. - - \since 5.5 -*/ - -void QCameraImageProcessing::setColorFilter(QCameraImageProcessing::ColorFilter filter) -{ - Q_D(QCameraImageProcessing); - if (d->colorFilter == filter || !isColorFilterSupported(filter)) - return; - d->colorFilter = filter; - d->imageControl->setParameter( - QPlatformCameraImageProcessing::ColorFilter, - QVariant::fromValue(filter)); - emit colorFilterChanged(); -} - -/*! - Returns true if a color \a filter is supported. - - \since 5.5 -*/ - -bool QCameraImageProcessing::isColorFilterSupported(QCameraImageProcessing::ColorFilter filter) const -{ - Q_D(const QCameraImageProcessing); - if (!d->imageControl) - return false; - return d->imageControl->isParameterValueSupported( - QPlatformCameraImageProcessing::ColorFilter, - QVariant::fromValue(filter)); - -} - -QT_END_NAMESPACE - -#include "moc_qcameraimageprocessing.cpp" diff --git a/src/multimedia/camera/qcameraimageprocessing.h b/src/multimedia/camera/qcameraimageprocessing.h deleted file mode 100644 index fe23e092d..000000000 --- a/src/multimedia/camera/qcameraimageprocessing.h +++ /dev/null @@ -1,150 +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 QCAMERAIMAGEPROCESSING_H -#define QCAMERAIMAGEPROCESSING_H - -#include -#include -#include -#include -#include -#include - -#include -#include - -QT_BEGIN_NAMESPACE - - -class QCamera; -class QPlatformCamera; - -class QCameraImageProcessingPrivate; -class Q_MULTIMEDIA_EXPORT QCameraImageProcessing : public QObject -{ - Q_OBJECT - Q_PROPERTY(WhiteBalanceMode whiteBalanceMode READ whiteBalanceMode WRITE setWhiteBalanceMode NOTIFY whiteBalanceModeChanged) - Q_PROPERTY(qreal manualWhiteBalance READ manualWhiteBalance WRITE setManualWhiteBalance NOTIFY manualWhiteBalanceChanged) - Q_PROPERTY(ColorFilter colorFilter READ colorFilter WRITE setColorFilter NOTIFY colorFilterChanged) - Q_PROPERTY(qreal brightness READ brightness WRITE setBrightness NOTIFY brightnessChanged) - Q_PROPERTY(qreal contrast READ contrast WRITE setContrast NOTIFY contrastChanged) - Q_PROPERTY(qreal hue READ hue WRITE setHue NOTIFY hueChanged) - Q_PROPERTY(qreal saturation READ saturation WRITE setSaturation NOTIFY saturationChanged) - Q_ENUMS(WhiteBalanceMode) - Q_ENUMS(ColorFilter) -public: - enum WhiteBalanceMode { - WhiteBalanceAuto = 0, - WhiteBalanceManual = 1, - WhiteBalanceSunlight = 2, - WhiteBalanceCloudy = 3, - WhiteBalanceShade = 4, - WhiteBalanceTungsten = 5, - WhiteBalanceFluorescent = 6, - WhiteBalanceFlash = 7, - WhiteBalanceSunset = 8 - }; - - enum ColorFilter { - ColorFilterNone, - ColorFilterGrayscale, - ColorFilterNegative, - ColorFilterSolarize, - ColorFilterSepia, - ColorFilterPosterize, - ColorFilterWhiteboard, - ColorFilterBlackboard, - ColorFilterAqua - }; - - bool isAvailable() const; - - WhiteBalanceMode whiteBalanceMode() const; - void setWhiteBalanceMode(WhiteBalanceMode mode); - Q_INVOKABLE bool isWhiteBalanceModeSupported(WhiteBalanceMode mode) const; - - qreal manualWhiteBalance() const; - void setManualWhiteBalance(qreal colorTemperature); - - qreal brightness() const; - void setBrightness(qreal value); - - qreal contrast() const; - void setContrast(qreal value); - - qreal saturation() const; - void setSaturation(qreal value); - - qreal hue() const; - void setHue(qreal value); - - ColorFilter colorFilter() const; - void setColorFilter(ColorFilter filter); - Q_INVOKABLE bool isColorFilterSupported(ColorFilter filter) const; - -Q_SIGNALS: - void whiteBalanceModeChanged() const; - void manualWhiteBalanceChanged() const; - - void brightnessChanged(); - void contrastChanged(); - void saturationChanged(); - void hueChanged(); - - void colorFilterChanged(); - -protected: - ~QCameraImageProcessing(); - -private: - friend class QCamera; - friend class QCameraPrivate; - QCameraImageProcessing(QCamera *camera, QPlatformCamera *cameraControl); - - Q_DISABLE_COPY(QCameraImageProcessing) - Q_DECLARE_PRIVATE(QCameraImageProcessing) -}; - -QT_END_NAMESPACE - -Q_MEDIA_ENUM_DEBUG(QCameraImageProcessing, WhiteBalanceMode) -Q_MEDIA_ENUM_DEBUG(QCameraImageProcessing, ColorFilter) - -#endif // QCAMERAIMAGEPROCESSING_H diff --git a/src/multimedia/doc/snippets/multimedia-snippets/camera.cpp b/src/multimedia/doc/snippets/multimedia-snippets/camera.cpp index 1f2273002..353aacadd 100644 --- a/src/multimedia/doc/snippets/multimedia-snippets/camera.cpp +++ b/src/multimedia/doc/snippets/multimedia-snippets/camera.cpp @@ -45,7 +45,6 @@ #include "qmediadevices.h" #include "qmediacapturesession.h" #include "qcameraimagecapture.h" -#include "qcameraimageprocessing.h" #include "qvideosink.h" #include "QtMultmediaWidgets/qvideowidget.h> #include @@ -231,13 +230,9 @@ void camera_blah() void cameraimageprocessing() { - //! [Camera image whitebalance] camera = new QCamera; - QCameraImageProcessing *imageProcessing = camera->imageProcessing(); - - if (imageProcessing->isAvailable()) { - imageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFluorescent); - } + //! [Camera image whitebalance] + camera->setWhiteBalanceMode(QCamera::WhiteBalanceFluorescent); //! [Camera image whitebalance] } diff --git a/src/multimedia/doc/src/cameraoverview.qdoc b/src/multimedia/doc/src/cameraoverview.qdoc index 4128c14eb..4b1a7ca92 100644 --- a/src/multimedia/doc/src/cameraoverview.qdoc +++ b/src/multimedia/doc/src/cameraoverview.qdoc @@ -259,10 +259,10 @@ the hardware may also double as a torch. \target camera_image_processing \section3 Image Processing -The QCameraImageProcessing class lets you adjust the image processing -part of the pipeline. This includes the \l {QCameraImageProcessing::WhiteBalanceMode}{white balance} -(or color temperature), \l {QCameraImageProcessing::contrast()}{contrast}, and -\l {QCameraImageProcessing::saturation()}{saturation}. +The QCamera class lets you adjust the image processing +part of the pipeline. This includes the \l {QCamera::WhiteBalanceMode}{white balance} +(or color temperature), \l {QCamera::contrast()}{contrast}, and +\l {QCamera::saturation()}{saturation}. Most cameras support automatic settings for all of these, so you shouldn't need to adjust them unless the user wants a specific setting. diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol.cpp b/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol.cpp index bb91f8f49..08beb9a58 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol.cpp +++ b/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol.cpp @@ -47,7 +47,7 @@ QT_BEGIN_NAMESPACE QAndroidCameraImageProcessingControl::QAndroidCameraImageProcessingControl(QAndroidCameraSession *session) : QPlatformCameraImageProcessing() , m_session(session) - , m_whiteBalanceMode(QCameraImageProcessing::WhiteBalanceAuto) + , m_whiteBalanceMode(QCamera::WhiteBalanceAuto) { connect(m_session, SIGNAL(opened()), this, SLOT(onCameraOpened())); @@ -65,7 +65,7 @@ bool QAndroidCameraImageProcessingControl::isParameterValueSupported(ProcessingP { return parameter == QPlatformCameraImageProcessing::WhiteBalancePreset && m_session->camera() - && m_supportedWhiteBalanceModes.contains(value.value()); + && m_supportedWhiteBalanceModes.contains(value.value()); } void QAndroidCameraImageProcessingControl::setParameter(ProcessingParameter parameter, const QVariant &value) @@ -73,7 +73,7 @@ void QAndroidCameraImageProcessingControl::setParameter(ProcessingParameter para if (parameter != QPlatformCameraImageProcessing::WhiteBalancePreset) return; - QCameraImageProcessing::WhiteBalanceMode mode = value.value(); + QCamera::WhiteBalanceMode mode = value.value(); if (m_session->camera()) setWhiteBalanceModeHelper(mode); @@ -81,7 +81,7 @@ void QAndroidCameraImageProcessingControl::setParameter(ProcessingParameter para m_whiteBalanceMode = mode; } -void QAndroidCameraImageProcessingControl::setWhiteBalanceModeHelper(QCameraImageProcessing::WhiteBalanceMode mode) +void QAndroidCameraImageProcessingControl::setWhiteBalanceModeHelper(QCamera::WhiteBalanceMode mode) { QString wb = m_supportedWhiteBalanceModes.value(mode, QString()); if (!wb.isEmpty()) { @@ -97,34 +97,34 @@ void QAndroidCameraImageProcessingControl::onCameraOpened() for (int i = 0; i < whiteBalanceModes.size(); ++i) { const QString &wb = whiteBalanceModes.at(i); if (wb == QLatin1String("auto")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceAuto, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceAuto, QStringLiteral("auto")); } else if (wb == QLatin1String("cloudy-daylight")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceCloudy, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceCloudy, QStringLiteral("cloudy-daylight")); } else if (wb == QLatin1String("daylight")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceSunlight, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceSunlight, QStringLiteral("daylight")); } else if (wb == QLatin1String("fluorescent")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceFluorescent, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceFluorescent, QStringLiteral("fluorescent")); } else if (wb == QLatin1String("incandescent")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceTungsten, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceTungsten, QStringLiteral("incandescent")); } else if (wb == QLatin1String("shade")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceShade, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceShade, QStringLiteral("shade")); } else if (wb == QLatin1String("twilight")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceSunset, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceSunset, QStringLiteral("twilight")); } else if (wb == QLatin1String("warm-fluorescent")) { - m_supportedWhiteBalanceModes.insert(QCameraImageProcessing::WhiteBalanceFlash, + m_supportedWhiteBalanceModes.insert(QCamera::WhiteBalanceFlash, QStringLiteral("warm-fluorescent")); } } if (!m_supportedWhiteBalanceModes.contains(m_whiteBalanceMode)) - m_whiteBalanceMode = QCameraImageProcessing::WhiteBalanceAuto; + m_whiteBalanceMode = QCamera::WhiteBalanceAuto; setWhiteBalanceModeHelper(m_whiteBalanceMode); } diff --git a/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol_p.h b/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol_p.h index b8ca7e708..a7820c1c6 100644 --- a/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol_p.h +++ b/src/multimedia/platform/android/mediacapture/qandroidcameraimageprocessingcontrol_p.h @@ -71,13 +71,13 @@ private Q_SLOTS: void onCameraOpened(); private: - void setWhiteBalanceModeHelper(QCameraImageProcessing::WhiteBalanceMode mode); + void setWhiteBalanceModeHelper(QCamera::WhiteBalanceMode mode); QAndroidCameraSession *m_session; - QCameraImageProcessing::WhiteBalanceMode m_whiteBalanceMode; + QCamera::WhiteBalanceMode m_whiteBalanceMode; - QMap m_supportedWhiteBalanceModes; + QMap m_supportedWhiteBalanceModes; }; QT_END_NAMESPACE diff --git a/src/multimedia/platform/darwin/camera/avfcameraimageprocessing.mm b/src/multimedia/platform/darwin/camera/avfcameraimageprocessing.mm index 99453f6d9..4dc613c88 100644 --- a/src/multimedia/platform/darwin/camera/avfcameraimageprocessing.mm +++ b/src/multimedia/platform/darwin/camera/avfcameraimageprocessing.mm @@ -49,10 +49,10 @@ QT_BEGIN_NAMESPACE namespace { -void avf_convert_white_balance_mode(QCameraImageProcessing::WhiteBalanceMode qtMode, +void avf_convert_white_balance_mode(QCamera::WhiteBalanceMode qtMode, AVCaptureWhiteBalanceMode &avMode) { - if (qtMode == QCameraImageProcessing::WhiteBalanceAuto) + if (qtMode == QCamera::WhiteBalanceAuto) avMode = AVCaptureWhiteBalanceModeContinuousAutoWhiteBalance; else avMode = AVCaptureWhiteBalanceModeLocked; @@ -115,26 +115,26 @@ bool avf_set_white_balance_gains(AVCaptureDevice *captureDevice, AVFCameraImageProcessing::AVFCameraImageProcessing(AVFCamera *camera) : QPlatformCameraImageProcessing(camera), m_camera(camera), - m_whiteBalanceMode(QCameraImageProcessing::WhiteBalanceAuto) + m_whiteBalanceMode(QCamera::WhiteBalanceAuto) { Q_ASSERT(m_camera); // AVFoundation's API allows adjusting white balance gains values(or temperature and tint) // only for iOS #ifdef Q_OS_IOS - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceSunlight] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceSunlight] = qMakePair(5600.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceCloudy] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceCloudy] = qMakePair(6000.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceShade] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceShade] = qMakePair(7000.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceTungsten] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceTungsten] = qMakePair(3200.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceFluorescent] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceFluorescent] = qMakePair(4000.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceFlash] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceFlash] = qMakePair(5500.0, .0); - m_mappedWhiteBalancePresets[QCameraImageProcessing::WhiteBalanceSunset] + m_mappedWhiteBalancePresets[QCamera::WhiteBalanceSunset] = qMakePair(3000.0, .0); #endif @@ -170,7 +170,7 @@ bool AVFCameraImageProcessing::isParameterValueSupported( if (parameter == QPlatformCameraImageProcessing::WhiteBalancePreset) return isWhiteBalanceModeSupported( - value.value()); + value.value()); #ifdef Q_OS_IOS if (parameter == QPlatformCameraImageProcessing::ColorTemperature) { @@ -189,7 +189,7 @@ void AVFCameraImageProcessing::setParameter( { bool result = false; if (parameter == QPlatformCameraImageProcessing::WhiteBalancePreset) - result = setWhiteBalanceMode(value.value()); + result = setWhiteBalanceMode(value.value()); #ifdef Q_OS_IOS else if (parameter == QPlatformCameraImageProcessing::ColorTemperature) @@ -204,7 +204,7 @@ void AVFCameraImageProcessing::setParameter( } bool AVFCameraImageProcessing::setWhiteBalanceMode( - QCameraImageProcessing::WhiteBalanceMode mode) + QCamera::WhiteBalanceMode mode) { AVCaptureDevice *captureDevice = m_camera->device(); Q_ASSERT(captureDevice); @@ -215,14 +215,14 @@ bool AVFCameraImageProcessing::setWhiteBalanceMode( if (!isWhiteBalanceModeSupported(mode)) return false; - if (mode == QCameraImageProcessing::WhiteBalanceAuto + if (mode == QCamera::WhiteBalanceAuto && avf_set_white_balance_mode(captureDevice, avMode)) { m_whiteBalanceMode = mode; return true; } #ifdef Q_OS_IOS - if (mode == QCameraImageProcessing::WhiteBalanceManual + if (mode == QCamera::WhiteBalanceManual && avf_set_white_balance_mode(captureDevice, avMode)) { m_whiteBalanceMode = mode; return true; @@ -241,7 +241,7 @@ bool AVFCameraImageProcessing::setWhiteBalanceMode( } bool AVFCameraImageProcessing::isWhiteBalanceModeSupported( - QCameraImageProcessing::WhiteBalanceMode qtMode) const + QCamera::WhiteBalanceMode qtMode) const { AVCaptureDevice *captureDevice = m_camera->device(); Q_ASSERT(captureDevice); @@ -251,13 +251,13 @@ bool AVFCameraImageProcessing::isWhiteBalanceModeSupported( // Since AVFoundation's API does not support setting custom white balance gains // on macOS, only WhiteBalanceAuto mode is supported. - if (qtMode == QCameraImageProcessing::WhiteBalanceAuto) + if (qtMode == QCamera::WhiteBalanceAuto) return [captureDevice isWhiteBalanceModeSupported:avMode]; #ifdef Q_OS_IOS // Qt's WhiteBalanceManual corresponds to AVFoundations's WhiteBalanceModeLocked // + setting custom white balance gains (or color temperature in Qt) - if (qtMode == QCameraImageProcessing::WhiteBalanceManual) + if (qtMode == QCamera::WhiteBalanceManual) return [captureDevice isWhiteBalanceModeSupported:avMode] && captureDevice.lockingWhiteBalanceWithCustomDeviceGainsSupported; @@ -291,7 +291,7 @@ bool AVFCameraImageProcessing::setColorTemperature(float temperature) AVCaptureWhiteBalanceGains wbGains; if (avf_convert_temp_and_tint_to_wb_gains(captureDevice, temperature, .0, wbGains) && avf_set_white_balance_gains(captureDevice, wbGains)) { - m_whiteBalanceMode = QCameraImageProcessing::WhiteBalanceManual; + m_whiteBalanceMode = QCamera::WhiteBalanceManual; return true; } @@ -303,7 +303,7 @@ void AVFCameraImageProcessing::cameraActiveChanged(bool active) { if (!active) return; - setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceAuto); + setWhiteBalanceMode(QCamera::WhiteBalanceAuto); } QT_END_NAMESPACE diff --git a/src/multimedia/platform/darwin/camera/avfcameraimageprocessing_p.h b/src/multimedia/platform/darwin/camera/avfcameraimageprocessing_p.h index 0914f8121..7f0ae6788 100644 --- a/src/multimedia/platform/darwin/camera/avfcameraimageprocessing_p.h +++ b/src/multimedia/platform/darwin/camera/avfcameraimageprocessing_p.h @@ -71,7 +71,7 @@ public: bool isParameterValueSupported(ProcessingParameter parameter, const QVariant &value) const override; void setParameter(ProcessingParameter parameter, const QVariant &value) override; - bool setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode); + bool setWhiteBalanceMode(QCamera::WhiteBalanceMode mode); #ifdef Q_OS_IOS float colorTemperature() const; @@ -82,14 +82,14 @@ private Q_SLOTS: void cameraActiveChanged(bool active); private: - bool isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const; + bool isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const; AVFCamera *m_camera; - QCameraImageProcessing::WhiteBalanceMode m_whiteBalanceMode; + QCamera::WhiteBalanceMode m_whiteBalanceMode; #ifdef Q_OS_IOS float m_colorTemperature = .0; - QMap> m_mappedWhiteBalancePresets; + QMap> m_mappedWhiteBalancePresets; #endif }; diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing.cpp b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing.cpp index 936271870..1871ab590 100644 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing.cpp +++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing.cpp @@ -122,7 +122,7 @@ bool QGstreamerImageProcessing::setColorBalanceValue(ProcessingParameter paramet return true; } -bool QGstreamerImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode) +bool QGstreamerImageProcessing::setWhiteBalanceMode(QCamera::WhiteBalanceMode mode) { if (!isWhiteBalanceModeSupported(mode)) return false; @@ -130,25 +130,25 @@ bool QGstreamerImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::Whit if (auto *photography = m_camera->photography()) { GstPhotographyWhiteBalanceMode gstMode = GST_PHOTOGRAPHY_WB_MODE_AUTO; switch (mode) { - case QCameraImageProcessing::WhiteBalanceSunlight: + case QCamera::WhiteBalanceSunlight: gstMode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT; break; - case QCameraImageProcessing::WhiteBalanceCloudy: + case QCamera::WhiteBalanceCloudy: gstMode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY; break; - case QCameraImageProcessing::WhiteBalanceShade: + case QCamera::WhiteBalanceShade: gstMode = GST_PHOTOGRAPHY_WB_MODE_SHADE; break; - case QCameraImageProcessing::WhiteBalanceSunset: + case QCamera::WhiteBalanceSunset: gstMode = GST_PHOTOGRAPHY_WB_MODE_SUNSET; break; - case QCameraImageProcessing::WhiteBalanceTungsten: + case QCamera::WhiteBalanceTungsten: gstMode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN; break; - case QCameraImageProcessing::WhiteBalanceFluorescent: + case QCamera::WhiteBalanceFluorescent: gstMode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT; break; - case QCameraImageProcessing::WhiteBalanceAuto: + case QCamera::WhiteBalanceAuto: default: break; } @@ -162,13 +162,13 @@ bool QGstreamerImageProcessing::setWhiteBalanceMode(QCameraImageProcessing::Whit return false; } -bool QGstreamerImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const +bool QGstreamerImageProcessing::isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const { #if QT_CONFIG(linux_v4l) if (m_camera->isV4L2Camera()) { - if (mode == QCameraImageProcessing::WhiteBalanceAuto) + if (mode == QCamera::WhiteBalanceAuto) return true; - if (v4l2AutoWhiteBalanceSupported && mode == QCameraImageProcessing::WhiteBalanceManual) + if (v4l2AutoWhiteBalanceSupported && mode == QCamera::WhiteBalanceManual) return true; // ### Could emulate the others through hardcoded color temperatures return false; @@ -177,13 +177,13 @@ bool QGstreamerImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessi #if QT_CONFIG(gstreamer_photography) if (m_camera->photography()) { switch (mode) { - case QCameraImageProcessing::WhiteBalanceAuto: - case QCameraImageProcessing::WhiteBalanceSunlight: - case QCameraImageProcessing::WhiteBalanceCloudy: - case QCameraImageProcessing::WhiteBalanceShade: - case QCameraImageProcessing::WhiteBalanceSunset: - case QCameraImageProcessing::WhiteBalanceTungsten: - case QCameraImageProcessing::WhiteBalanceFluorescent: + case QCamera::WhiteBalanceAuto: + case QCamera::WhiteBalanceSunlight: + case QCamera::WhiteBalanceCloudy: + case QCamera::WhiteBalanceShade: + case QCamera::WhiteBalanceSunset: + case QCamera::WhiteBalanceTungsten: + case QCamera::WhiteBalanceFluorescent: return true; default: break; @@ -191,62 +191,9 @@ bool QGstreamerImageProcessing::isWhiteBalanceModeSupported(QCameraImageProcessi } #endif - return mode == QCameraImageProcessing::WhiteBalanceAuto; + return mode == QCamera::WhiteBalanceAuto; } -bool QGstreamerImageProcessing::setColorFilter(QCameraImageProcessing::ColorFilter filter) -{ -#if QT_CONFIG(gstreamer_photography) - if (GstPhotography *photography = m_camera->photography()) { - GstPhotographyColorToneMode mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL; - switch (filter) { - case QCameraImageProcessing::ColorFilterSepia: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_SEPIA; - break; - case QCameraImageProcessing::ColorFilterGrayscale: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_GRAYSCALE; - break; - case QCameraImageProcessing::ColorFilterNegative: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_NEGATIVE; - break; - case QCameraImageProcessing::ColorFilterSolarize: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_SOLARIZE; - break; - case QCameraImageProcessing::ColorFilterPosterize: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_POSTERIZE; - break; - case QCameraImageProcessing::ColorFilterWhiteboard: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_WHITEBOARD; - break; - case QCameraImageProcessing::ColorFilterBlackboard: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_BLACKBOARD; - break; - case QCameraImageProcessing::ColorFilterAqua: - mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_AQUA; - break; - case QCameraImageProcessing::ColorFilterNone: - default: - break; - } - if (gst_photography_set_color_tone_mode(photography, mode)) { - m_colorFilter = filter; - return true; - } - } -#else - Q_UNUSED(filter); -#endif - return false; -} - -bool QGstreamerImageProcessing::isColorFilterSupported(QCameraImageProcessing::ColorFilter filter) const -{ -#if QT_CONFIG(gstreamer_photography) - if (m_camera->photography()) - return true; -#endif - return filter == QCameraImageProcessing::ColorFilterNone; -} bool QGstreamerImageProcessing::isParameterSupported(QPlatformCameraImageProcessing::ProcessingParameter parameter) const { @@ -260,7 +207,6 @@ bool QGstreamerImageProcessing::isParameterSupported(QPlatformCameraImageProcess return v4l2AutoWhiteBalanceSupported; case ColorTemperature: return v4l2ColorTemperatureSupported; - case ColorFilter: default: // v4l2 doesn't have photography return false; @@ -270,7 +216,7 @@ bool QGstreamerImageProcessing::isParameterSupported(QPlatformCameraImageProcess #if QT_CONFIG(gstreamer_photography) if (m_camera->photography()) { - if (parameter == QPlatformCameraImageProcessing::WhiteBalancePreset || parameter == QPlatformCameraImageProcessing::ColorFilter) + if (parameter == QPlatformCameraImageProcessing::WhiteBalancePreset) return true; } #endif @@ -297,9 +243,7 @@ bool QGstreamerImageProcessing::isParameterValueSupported(QPlatformCameraImagePr return false; } case WhiteBalancePreset: - return isWhiteBalanceModeSupported(value.value()); - case ColorFilter: - return isColorFilterSupported(value.value()); + return isWhiteBalanceModeSupported(value.value()); default: break; } @@ -321,13 +265,10 @@ void QGstreamerImageProcessing::setParameter(QPlatformCameraImageProcessing::Pro switch (parameter) { case WhiteBalancePreset: - setWhiteBalanceMode(value.value()); + setWhiteBalanceMode(value.value()); break; case QPlatformCameraImageProcessing::ColorTemperature: break; - case QPlatformCameraImageProcessing::ColorFilter: - setColorFilter(value.value()); - break; default: break; } @@ -398,11 +339,11 @@ bool QGstreamerImageProcessing::setV4L2Param(ProcessingParameter parameter, cons case QPlatformCameraImageProcessing::WhiteBalancePreset: { if (!v4l2AutoWhiteBalanceSupported) return false; - const QCameraImageProcessing::WhiteBalanceMode mode = value.value(); - if (mode != QCameraImageProcessing::WhiteBalanceAuto && mode != QCameraImageProcessing::WhiteBalanceManual) + const QCamera::WhiteBalanceMode mode = value.value(); + if (mode != QCamera::WhiteBalanceAuto && mode != QCamera::WhiteBalanceManual) return false; control.id = V4L2_CID_AUTO_WHITE_BALANCE; - control.value = (mode == QCameraImageProcessing::WhiteBalanceAuto); + control.value = (mode == QCamera::WhiteBalanceAuto); m_whiteBalanceMode = mode; break; } diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing_p.h b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing_p.h index c304637ad..61415548e 100644 --- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing_p.h +++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamercameraimageprocessing_p.h @@ -78,11 +78,8 @@ public: QGstreamerImageProcessing(QGstreamerCamera *camera); virtual ~QGstreamerImageProcessing(); - bool setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode); - bool isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const; - - bool setColorFilter(QCameraImageProcessing::ColorFilter filter); - bool isColorFilterSupported(QCameraImageProcessing::ColorFilter mode) const; + bool setWhiteBalanceMode(QCamera::WhiteBalanceMode mode); + bool isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const; bool isParameterSupported(ProcessingParameter) const override; bool isParameterValueSupported(ProcessingParameter parameter, const QVariant &value) const override; @@ -117,8 +114,7 @@ private: }; ColorBalanceParameter colorBalanceParameters[BrightnessAdjustment + 1]; - QCameraImageProcessing::WhiteBalanceMode m_whiteBalanceMode = QCameraImageProcessing::WhiteBalanceAuto; - QCameraImageProcessing::ColorFilter m_colorFilter = QCameraImageProcessing::ColorFilterNone; + QCamera::WhiteBalanceMode m_whiteBalanceMode = QCamera::WhiteBalanceAuto; #if QT_CONFIG(linux_v4l) bool isV4L2Device = false; diff --git a/src/multimedia/platform/qnx/camera/bbcameraimageprocessingcontrol.cpp b/src/multimedia/platform/qnx/camera/bbcameraimageprocessingcontrol.cpp index 846ae6178..08e468eea 100644 --- a/src/multimedia/platform/qnx/camera/bbcameraimageprocessingcontrol.cpp +++ b/src/multimedia/platform/qnx/camera/bbcameraimageprocessingcontrol.cpp @@ -72,21 +72,21 @@ bool BbCameraImageProcessingControl::isParameterValueSupported(ProcessingParamet return false; } - QSet supportedModes; + QSet supportedModes; for (int i = 0; i < supported; ++i) { switch (modes[i]) { case CAMERA_WHITEBALANCEMODE_AUTO: - supportedModes.insert(QCameraImageProcessing::WhiteBalanceAuto); + supportedModes.insert(QCamera::WhiteBalanceAuto); break; case CAMERA_WHITEBALANCEMODE_MANUAL: - supportedModes.insert(QCameraImageProcessing::WhiteBalanceManual); + supportedModes.insert(QCamera::WhiteBalanceManual); break; default: break; } } - return supportedModes.contains(value.value()); + return supportedModes.contains(value.value()); } void BbCameraImageProcessingControl::setParameter(ProcessingParameter parameter, const QVariant &value) @@ -98,11 +98,11 @@ void BbCameraImageProcessingControl::setParameter(ProcessingParameter parameter, return; camera_whitebalancemode_t mode = CAMERA_WHITEBALANCEMODE_DEFAULT; - switch (value.value()) { - case QCameraImageProcessing::WhiteBalanceAuto: + switch (value.value()) { + case QCamera::WhiteBalanceAuto: mode = CAMERA_WHITEBALANCEMODE_AUTO; break; - case QCameraImageProcessing::WhiteBalanceManual: + case QCamera::WhiteBalanceManual: mode = CAMERA_WHITEBALANCEMODE_MANUAL; break; default: diff --git a/src/multimedia/platform/qplatformcameraimageprocessing.cpp b/src/multimedia/platform/qplatformcameraimageprocessing.cpp index 5b229f9aa..11e22d48f 100644 --- a/src/multimedia/platform/qplatformcameraimageprocessing.cpp +++ b/src/multimedia/platform/qplatformcameraimageprocessing.cpp @@ -110,7 +110,7 @@ QPlatformCameraImageProcessing::QPlatformCameraImageProcessing(QObject *parent) backend to choose the suitable parameter value. The valid values range depends on the parameter type. - For WhiteBalancePreset the value should be one of QCameraImageProcessing::WhiteBalanceMode values; + For WhiteBalancePreset the value should be one of QCamera::WhiteBalanceMode values; for Contrast, Saturation and Brightness the value should be in [0..1.0] range with invalid QVariant value indicating the default parameter value; for ContrastAdjustment, SaturationAdjustment, BrightnessAdjustment, the value should be diff --git a/src/multimedia/platform/qplatformcameraimageprocessing_p.h b/src/multimedia/platform/qplatformcameraimageprocessing_p.h index fed4581e8..341bfca61 100644 --- a/src/multimedia/platform/qplatformcameraimageprocessing_p.h +++ b/src/multimedia/platform/qplatformcameraimageprocessing_p.h @@ -74,8 +74,7 @@ public: HueAdjustment, BrightnessAdjustment, WhiteBalancePreset, - ColorTemperature, - ColorFilter, + ColorTemperature }; virtual bool isParameterSupported(ProcessingParameter) const = 0; diff --git a/src/multimedia/qmediametadata.cpp b/src/multimedia/qmediametadata.cpp index 663ec4fe0..311922a9e 100644 --- a/src/multimedia/qmediametadata.cpp +++ b/src/multimedia/qmediametadata.cpp @@ -137,7 +137,7 @@ QT_BEGIN_NAMESPACE \row \li ExposureMode \li Indicates the exposure mode set when the image was shot. \li QCamera::ExposureMode \row \li WhiteBalance - \li Indicates the white balance mode set when the image was shot. \li QCameraImageProcessing::WhiteBalanceMode + \li Indicates the white balance mode set when the image was shot. \li QCamera::WhiteBalanceMode \row \li DigitalZoomRatio \li Indicates the digital zoom ratio when the image was shot. \li qreal \row \li FocalLengthIn35mmFilm -- cgit v1.2.3