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 <volker.hilsheimer@qt.io>

23 files changed, 417 insertions, 811 deletions

diff --git a/examples/multimedia/declarative-camera/PhotoCaptureControls.qml b/examples/multimedia/declarative-camera/PhotoCaptureControls.qml
index e7eacdb0d..bfe539468 100644
--- a/examples/multimedia/declarative-camera/PhotoCaptureControls.qml
+++ b/examples/multimedia/declarative-camera/PhotoCaptureControls.qml
@@ -87,35 +87,35 @@ FocusScope {
 
             CameraPropertyButton {
                 id : wbModesButton
-                value: CameraImageProcessing.WhiteBalanceAuto
+                value: Camera.WhiteBalanceAuto
                 model: ListModel {
                     ListElement {
                         icon: "images/camera_auto_mode.png"
-                        value: CameraImageProcessing.WhiteBalanceAuto
+                        value: Camera.WhiteBalanceAuto
                         text: "Auto"
                     }
                     ListElement {
                         icon: "images/camera_white_balance_sunny.png"
-                        value: CameraImageProcessing.WhiteBalanceSunlight
+                        value: Camera.WhiteBalanceSunlight
                         text: "Sunlight"
                     }
                     ListElement {
                         icon: "images/camera_white_balance_cloudy.png"
-                        value: CameraImageProcessing.WhiteBalanceCloudy
+                        value: Camera.WhiteBalanceCloudy
                         text: "Cloudy"
                     }
                     ListElement {
                         icon: "images/camera_white_balance_incandescent.png"
-                        value: CameraImageProcessing.WhiteBalanceTungsten
+                        value: Camera.WhiteBalanceTungsten
                         text: "Tungsten"
                     }
                     ListElement {
                         icon: "images/camera_white_balance_flourescent.png"
-                        value: CameraImageProcessing.WhiteBalanceFluorescent
+                        value: Camera.WhiteBalanceFluorescent
                         text: "Fluorescent"
                     }
                 }
-                onValueChanged: captureControls.captureSession.camera.imageProcessing.whiteBalanceMode = wbModesButton.value
+                onValueChanged: captureControls.captureSession.camera.whiteBalanceMode = wbModesButton.value
             }
 
             CameraButton {
diff --git a/examples/multimediawidgets/camera/camera.cpp b/examples/multimediawidgets/camera/camera.cpp
index 2b3091207..864e24eac 100644
--- a/examples/multimediawidgets/camera/camera.cpp
+++ b/examples/multimediawidgets/camera/camera.cpp
@@ -134,27 +134,18 @@ void Camera::setCamera(const QCameraInfo &cameraInfo)
     connect(m_imageCapture, &QCameraImageCapture::errorOccurred, this, &Camera::displayCaptureError);
     readyForCapture(m_imageCapture->isReadyForCapture());
 
-    QCameraImageProcessing *imageProcessing = m_camera->imageProcessing();
-    if (!imageProcessing) {
-        ui->brightnessSlider->setEnabled(false);
-        ui->contrastSlider->setEnabled(false);
-        ui->saturationSlider->setEnabled(false);
-        ui->hueSlider->setEnabled(false);
-    } else {
-        connect(ui->brightnessSlider, &QSlider::valueChanged, [imageProcessing](int value) {
-            imageProcessing->setBrightness(value/100.);
-        });
-        connect(ui->contrastSlider, &QSlider::valueChanged, [imageProcessing](int value) {
-            imageProcessing->setContrast(value/100.);
-        });
-        connect(ui->saturationSlider, &QSlider::valueChanged, [imageProcessing](int value) {
-            imageProcessing->setSaturation(value/100.);
-        });
-        connect(ui->hueSlider, &QSlider::valueChanged, [imageProcessing](int value) {
-            imageProcessing->setHue(value/100.);
-        });
-    }
-
+    connect(ui->brightnessSlider, &QSlider::valueChanged, [this](int value) {
+        m_camera->setBrightness(value/100.);
+    });
+    connect(ui->contrastSlider, &QSlider::valueChanged, [this](int value) {
+        m_camera->setContrast(value/100.);
+    });
+    connect(ui->saturationSlider, &QSlider::valueChanged, [this](int value) {
+        m_camera->setSaturation(value/100.);
+    });
+    connect(ui->hueSlider, &QSlider::valueChanged, [this](int value) {
+        m_camera->setHue(value/100.);
+    });
 
     updateCaptureMode();
     m_camera->start();
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();
 }
 
 /*!
@@ -237,14 +250,6 @@ void QCamera::setActive(bool 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<QCamera::WhiteBalanceMode>(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<QCamera::WhiteBalanceMode>(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 <QtCore/qobject.h>
 
-#include <QtMultimedia/qcameraimageprocessing.h>
 #include <QtMultimedia/qcamerainfo.h>
 
 #include <QtMultimedia/qmediaenumdebug.h>
@@ -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<qreal> supportedApertures(bool *continuous = nullptr) const;
     QList<qreal> 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<typename T> T actualExposureParameter(QPlatformCameraExposure::ExposureParameter parameter, const T &defaultValue) const;
     template<typename T> 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 <private/qplatformcamera_p.h>
-#include <private/qplatformcameraimageprocessing_p.h>
-
-#include <QtCore/QDebug>
-
-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<QCameraImageProcessing::WhiteBalanceMode>(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<QCameraImageProcessing::WhiteBalanceMode>(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<QCameraImageProcessing::ColorFilter>(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<QCameraImageProcessing::ColorFilter>(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 <QtCore/qstringlist.h>
-#include <QtCore/qpair.h>
-#include <QtCore/qsize.h>
-#include <QtCore/qpoint.h>
-#include <QtCore/qrect.h>
-#include <QtCore/qobject.h>
-
-#include <QtMultimedia/qtmultimediaglobal.h>
-#include <QtMultimedia/qmediaenumdebug.h>
-
-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 <QtGui/qscreen.h>
@@ -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<QCameraImageProcessing::WhiteBalanceMode>());
+            && m_supportedWhiteBalanceModes.contains(value.value<QCamera::WhiteBalanceMode>());
 }
 
 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<QCameraImageProcessing::WhiteBalanceMode>();
+    QCamera::WhiteBalanceMode mode = value.value<QCamera::WhiteBalanceMode>();
 
     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<QCameraImageProcessing::WhiteBalanceMode, QString> m_supportedWhiteBalanceModes;
+    QMap<QCamera::WhiteBalanceMode, QString> 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<QCameraImageProcessing::WhiteBalanceMode>());
+            value.value<QCamera::WhiteBalanceMode>());
 
 #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<QCameraImageProcessing::WhiteBalanceMode>());
+        result = setWhiteBalanceMode(value.value<QCamera::WhiteBalanceMode>());
 
 #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<QCameraImageProcessing::WhiteBalanceMode, QPair<float, float>> m_mappedWhiteBalancePresets;
+    QMap<QCamera::WhiteBalanceMode, QPair<float, float>> 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<QCameraImageProcessing::WhiteBalanceMode>());
-    case ColorFilter:
-        return isColorFilterSupported(value.value<QCameraImageProcessing::ColorFilter>());
+        return isWhiteBalanceModeSupported(value.value<QCamera::WhiteBalanceMode>());
     default:
         break;
     }
@@ -321,13 +265,10 @@ void QGstreamerImageProcessing::setParameter(QPlatformCameraImageProcessing::Pro
 
     switch (parameter) {
     case WhiteBalancePreset:
-        setWhiteBalanceMode(value.value<QCameraImageProcessing::WhiteBalanceMode>());
+        setWhiteBalanceMode(value.value<QCamera::WhiteBalanceMode>());
         break;
     case QPlatformCameraImageProcessing::ColorTemperature:
         break;
-    case QPlatformCameraImageProcessing::ColorFilter:
-        setColorFilter(value.value<QCameraImageProcessing::ColorFilter>());
-        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<QCameraImageProcessing::WhiteBalanceMode>();
-        if (mode != QCameraImageProcessing::WhiteBalanceAuto && mode != QCameraImageProcessing::WhiteBalanceManual)
+        const QCamera::WhiteBalanceMode mode = value.value<QCamera::WhiteBalanceMode>();
+        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<QCameraImageProcessing::WhiteBalanceMode> supportedModes;
+    QSet<QCamera::WhiteBalanceMode> 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<QCameraImageProcessing::WhiteBalanceMode>());
+    return supportedModes.contains(value.value<QCamera::WhiteBalanceMode>());
 }
 
 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<QCameraImageProcessing::WhiteBalanceMode>()) {
-    case QCameraImageProcessing::WhiteBalanceAuto:
+    switch (value.value<QCamera::WhiteBalanceMode>()) {
+    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
diff --git a/src/multimediaquick/qtmultimediaquicktypes_p.h b/src/multimediaquick/qtmultimediaquicktypes_p.h
index c104144cb..47504239f 100644
--- a/src/multimediaquick/qtmultimediaquicktypes_p.h
+++ b/src/multimediaquick/qtmultimediaquicktypes_p.h
@@ -85,14 +85,6 @@ struct QCameraForeign
     QML_NAMED_ELEMENT(Camera)
 };
 
-struct QCameraImageProcessingForeign
-{
-    Q_GADGET
-    QML_FOREIGN(QCameraImageProcessing)
-    QML_UNCREATABLE("CameraImageProcessing is provided by Camera")
-    QML_NAMED_ELEMENT(CameraImageProcessing)
-};
-
 struct QCameraImageCaptureForeign
 {
     Q_GADGET
diff --git a/tests/auto/unit/mockbackend/qmockcameraimageprocessing.h b/tests/auto/unit/mockbackend/qmockcameraimageprocessing.h
index d5c4767e4..38084ccd1 100644
--- a/tests/auto/unit/mockbackend/qmockcameraimageprocessing.h
+++ b/tests/auto/unit/mockbackend/qmockcameraimageprocessing.h
@@ -38,24 +38,24 @@ public:
     QMockCameraImageProcessing(QObject *parent = 0)
         : QPlatformCameraImageProcessing(parent)
     {
-        m_supportedWhiteBalance.insert(QCameraImageProcessing::WhiteBalanceAuto);
+        m_supportedWhiteBalance.insert(QCamera::WhiteBalanceAuto);
     }
 
-    QCameraImageProcessing::WhiteBalanceMode whiteBalanceMode() const
+    QCamera::WhiteBalanceMode whiteBalanceMode() const
     {
         return m_whiteBalanceMode;
     }
-    void setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode mode)
+    void setWhiteBalanceMode(QCamera::WhiteBalanceMode mode)
     {
         m_whiteBalanceMode = mode;
     }
 
-    bool isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceMode mode) const
+    bool isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const
     {
         return m_supportedWhiteBalance.contains(mode);
     }
 
-    void setSupportedWhiteBalanceModes(QSet<QCameraImageProcessing::WhiteBalanceMode> modes)
+    void setSupportedWhiteBalanceModes(QSet<QCamera::WhiteBalanceMode> modes)
     {
         m_supportedWhiteBalance = modes;
     }
@@ -80,7 +80,7 @@ public:
         if (parameter != WhiteBalancePreset)
             return false;
 
-        return m_supportedWhiteBalance.contains(value.value<QCameraImageProcessing::WhiteBalanceMode>());
+        return m_supportedWhiteBalance.contains(value.value<QCamera::WhiteBalanceMode>());
     }
 
     void setParameter(ProcessingParameter parameter, const QVariant &value)
@@ -99,7 +99,7 @@ public:
             m_manualWhiteBalance = value;
             break;
         case WhiteBalancePreset:
-            m_whiteBalanceMode = value.value<QCameraImageProcessing::WhiteBalanceMode>();
+            m_whiteBalanceMode = value.value<QCamera::WhiteBalanceMode>();
             break;
         default:
             break;
@@ -108,8 +108,8 @@ public:
 
 
 private:
-    QCameraImageProcessing::WhiteBalanceMode m_whiteBalanceMode;
-    QSet<QCameraImageProcessing::WhiteBalanceMode> m_supportedWhiteBalance;
+    QCamera::WhiteBalanceMode m_whiteBalanceMode;
+    QSet<QCamera::WhiteBalanceMode> m_supportedWhiteBalance;
     QVariant m_manualWhiteBalance;
     QVariant m_contrast;
     QVariant m_saturation;
diff --git a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
index 3a56ebc5c..46a3f1444 100644
--- a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
+++ b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
@@ -91,9 +91,8 @@ private slots:
     // Test cases for QPlatformCamera class.
     void testCameraControl();
 
-    // Test case for QCameraImageProcessing class
+    // Test case for image processing
     void testContrast();
-    void testIsAvailable();
     void testSaturation();
 
     void testSetVideoOutput();
@@ -142,14 +141,14 @@ void tst_QCamera::testSimpleCameraWhiteBalance()
     QCamera camera;
 
     //only WhiteBalanceAuto is supported
-    QVERIFY(!camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceAuto));
-    QVERIFY(!camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceCloudy));
-    QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto);
-    camera.imageProcessing()->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceCloudy);
-    QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto);
-    QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0);
-    camera.imageProcessing()->setManualWhiteBalance(5000);
-    QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0);
+    QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceAuto));
+    QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceCloudy));
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
+    camera.setWhiteBalanceMode(QCamera::WhiteBalanceCloudy);
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
+    QCOMPARE(camera.manualWhiteBalance()+1.0, 1.0);
+    camera.setManualWhiteBalance(5000);
+    QCOMPARE(camera.manualWhiteBalance()+1.0, 1.0);
 }
 
 void tst_QCamera::testSimpleCameraExposure()
@@ -308,36 +307,34 @@ void tst_QCamera::testCameraCaptureMetadata()
 
 void tst_QCamera::testCameraWhiteBalance()
 {
-    QSet<QCameraImageProcessing::WhiteBalanceMode> whiteBalanceModes;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceAuto;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceFlash;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceTungsten;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceManual;
+    QSet<QCamera::WhiteBalanceMode> whiteBalanceModes;
+    whiteBalanceModes << QCamera::WhiteBalanceAuto;
+    whiteBalanceModes << QCamera::WhiteBalanceFlash;
+    whiteBalanceModes << QCamera::WhiteBalanceTungsten;
+    whiteBalanceModes << QCamera::WhiteBalanceManual;
 
     QCamera camera;
     QMockCamera *mockCamera = integration.lastCamera();
     mockCamera->mockImageProcessing->setSupportedWhiteBalanceModes(whiteBalanceModes);
 
-    QCameraImageProcessing *imageProcessing = camera.imageProcessing();
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
+    camera.setWhiteBalanceMode(QCamera::WhiteBalanceFlash);
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceFlash);
+    QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceAuto));
+    QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceFlash));
+    QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceTungsten));
+    QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceCloudy));
 
-    QCOMPARE(imageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto);
-    imageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFlash);
-    QCOMPARE(imageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceFlash);
-    QVERIFY(imageProcessing->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceAuto));
-    QVERIFY(imageProcessing->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceFlash));
-    QVERIFY(imageProcessing->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceTungsten));
-    QVERIFY(!imageProcessing->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceCloudy));
+    camera.setWhiteBalanceMode(QCamera::WhiteBalanceTungsten);
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceTungsten);
 
-    imageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceTungsten);
-    QCOMPARE(imageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceTungsten);
+    camera.setWhiteBalanceMode(QCamera::WhiteBalanceManual);
+    QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceManual);
+    camera.setManualWhiteBalance(34);
+    QCOMPARE(camera.manualWhiteBalance(), 34.0);
 
-    imageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceManual);
-    QCOMPARE(imageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceManual);
-    imageProcessing->setManualWhiteBalance(34);
-    QCOMPARE(imageProcessing->manualWhiteBalance(), 34.0);
-
-    imageProcessing->setManualWhiteBalance(432.0);
-    QCOMPARE(imageProcessing->manualWhiteBalance(), 432.0);
+    camera.setManualWhiteBalance(432.0);
+    QCOMPARE(camera.manualWhiteBalance(), 432.0);
 }
 
 void tst_QCamera::testCameraExposure()
@@ -842,29 +839,19 @@ void tst_QCamera::testStatus()
     QVERIFY(camera.status() == QCamera::UnavailableStatus);
 }
 
-// Test case for QCameraImageProcessing class
 void tst_QCamera::testContrast()
 {
     QMediaCaptureSession session;
     QCamera camera;
     session.setCamera(&camera);
-    QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
-    QVERIFY(cameraImageProcessing->contrast() ==0);
 
-    cameraImageProcessing->setContrast(0.123);
-    QCOMPARE(cameraImageProcessing->contrast(), 0.123);
+    QVERIFY(camera.contrast() == 0);
 
-    cameraImageProcessing->setContrast(4.56);
-    QCOMPARE(cameraImageProcessing->contrast(), 4.56);
-}
+    camera.setContrast(0.123);
+    QCOMPARE(camera.contrast(), 0.123);
 
-void tst_QCamera::testIsAvailable()
-{
-    QMediaCaptureSession session;
-    QCamera camera;
-    session.setCamera(&camera);
-    QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
-    QVERIFY(cameraImageProcessing->isAvailable() == true);
+    camera.setContrast(4.56);
+    QCOMPARE(camera.contrast(), 4.56);
 }
 
 void tst_QCamera::testSaturation()
@@ -872,14 +859,14 @@ void tst_QCamera::testSaturation()
     QMediaCaptureSession session;
     QCamera camera;
     session.setCamera(&camera);
-    QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
-    QCOMPARE(cameraImageProcessing->saturation()+1.0, 1.0);
 
-    cameraImageProcessing->setSaturation(0.5);
-    QCOMPARE(cameraImageProcessing->saturation(), 0.5);
+    QCOMPARE(camera.saturation()+1.0, 1.0);
+
+    camera.setSaturation(0.5);
+    QCOMPARE(camera.saturation(), 0.5);
 
-    cameraImageProcessing->setSaturation(-0.5);
-    QCOMPARE(cameraImageProcessing->saturation(), -0.5);
+    camera.setSaturation(-0.5);
+    QCOMPARE(camera.saturation(), -0.5);
 }
 
 //Added this code to cover QCamera::FocusModeHyperfocal and QCamera::FocusModeAutoNear