Get rid of QImageEncoderSettings

Move the API for setting file format, quality and resolution
into QCameraImageCapture and get rid of the separate
QImageEncoderSettings class.

This simplifies our API and makes the QML integration easier.

Change-Id: Iaac2a6e3ff50c7379c44d70001db7c52d8cb0c90
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

25 files changed, 287 insertions, 476 deletions

diff --git a/examples/multimedia/audiorecorder/audiorecorder.cpp b/examples/multimedia/audiorecorder/audiorecorder.cpp
index 7771d3cd2..8ef57b33a 100644
--- a/examples/multimedia/audiorecorder/audiorecorder.cpp
+++ b/examples/multimedia/audiorecorder/audiorecorder.cpp
@@ -62,6 +62,7 @@
 #include <qaudiodevice.h>
 #include <qaudiobuffer.h>
 #include <qaudioinput.h>
+#include <qcameraimagecapture.h>
 
 static QList<qreal> getBufferLevels(const QAudioBuffer &buffer);
 
@@ -112,8 +113,8 @@ AudioRecorder::AudioRecorder()
     ui->channelsBox->addItem(QStringLiteral("4"), QVariant(4));
 
     //quality
-    ui->qualitySlider->setRange(0, int(QImageEncoderSettings::VeryHighQuality));
-    ui->qualitySlider->setValue(int(QImageEncoderSettings::NormalQuality));
+    ui->qualitySlider->setRange(0, int(QCameraImageCapture::VeryHighQuality));
+    ui->qualitySlider->setValue(int(QCameraImageCapture::NormalQuality));
 
     //bitrates:
     ui->bitrateBox->addItem(tr("Default"), QVariant(0));
diff --git a/examples/multimediawidgets/camera/camera.cpp b/examples/multimediawidgets/camera/camera.cpp
index 0e8d2b4a3..ef33c98e7 100644
--- a/examples/multimediawidgets/camera/camera.cpp
+++ b/examples/multimediawidgets/camera/camera.cpp
@@ -206,11 +206,8 @@ void Camera::configureImageSettings()
     ImageSettings settingsDialog(m_imageCapture);
     settingsDialog.setWindowFlags(settingsDialog.windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
-    settingsDialog.setImageSettings(m_imageSettings);
-
     if (settingsDialog.exec()) {
-        m_imageSettings = settingsDialog.imageSettings();
-        m_imageCapture->setEncodingSettings(m_imageSettings);
+        settingsDialog.applyImageSettings();
     }
 }
 
diff --git a/examples/multimediawidgets/camera/camera.h b/examples/multimediawidgets/camera/camera.h
index c30927deb..1bf1f1dde 100644
--- a/examples/multimediawidgets/camera/camera.h
+++ b/examples/multimediawidgets/camera/camera.h
@@ -138,7 +138,6 @@ private:
     QCameraImageCapture *m_imageCapture;
     QScopedPointer<QMediaEncoder> m_mediaEncoder;
 
-    QImageEncoderSettings m_imageSettings;
     QMediaEncoderSettings m_encoderSettings;
     bool m_isCapturingImage = false;
     bool m_applicationExiting = false;
diff --git a/examples/multimediawidgets/camera/imagesettings.cpp b/examples/multimediawidgets/camera/imagesettings.cpp
index df0056029..8e58fc7d4 100644
--- a/examples/multimediawidgets/camera/imagesettings.cpp
+++ b/examples/multimediawidgets/camera/imagesettings.cpp
@@ -66,13 +66,13 @@ ImageSettings::ImageSettings(QCameraImageCapture *imageCapture, QWidget *parent)
 
     //image codecs
     ui->imageCodecBox->addItem(tr("Default image format"), QVariant(QString()));
-    const auto supportedImageFormats = QImageEncoderSettings::supportedFormats();
+    const auto supportedImageFormats = QCameraImageCapture::supportedFormats();
     for (const auto &f : supportedImageFormats) {
-        QString description = QImageEncoderSettings::fileFormatDescription(f);
-        ui->imageCodecBox->addItem(QImageEncoderSettings::fileFormatName(f) + ": " + description, QVariant::fromValue(f));
+        QString description = QCameraImageCapture::fileFormatDescription(f);
+        ui->imageCodecBox->addItem(QCameraImageCapture::fileFormatName(f) + ": " + description, QVariant::fromValue(f));
     }
 
-    ui->imageQualitySlider->setRange(0, int(QImageEncoderSettings::VeryHighQuality));
+    ui->imageQualitySlider->setRange(0, int(QCameraImageCapture::VeryHighQuality));
 
     ui->imageResolutionBox->addItem(tr("Default Resolution"));
     const QList<QSize> supportedResolutions = imagecapture->captureSession()->camera()->cameraInfo().photoResolutions();
@@ -80,6 +80,10 @@ ImageSettings::ImageSettings(QCameraImageCapture *imageCapture, QWidget *parent)
         ui->imageResolutionBox->addItem(QString("%1x%2").arg(resolution.width()).arg(resolution.height()),
                                         QVariant(resolution));
     }
+
+    selectComboBoxItem(ui->imageCodecBox, QVariant::fromValue(imagecapture->fileFormat()));
+    selectComboBoxItem(ui->imageResolutionBox, QVariant(imagecapture->resolution()));
+    ui->imageQualitySlider->setValue(imagecapture->quality());
 }
 
 ImageSettings::~ImageSettings()
@@ -99,21 +103,11 @@ void ImageSettings::changeEvent(QEvent *e)
     }
 }
 
-QImageEncoderSettings ImageSettings::imageSettings() const
-{
-    QImageEncoderSettings settings = imagecapture->encodingSettings();
-    settings.setFormat(boxValue(ui->imageCodecBox).value<QImageEncoderSettings::FileFormat>());
-    settings.setQuality(QImageEncoderSettings::Quality(ui->imageQualitySlider->value()));
-    settings.setResolution(boxValue(ui->imageResolutionBox).toSize());
-
-    return settings;
-}
-
-void ImageSettings::setImageSettings(const QImageEncoderSettings &imageSettings)
+void ImageSettings::applyImageSettings() const
 {
-    selectComboBoxItem(ui->imageCodecBox, QVariant::fromValue(imageSettings.format()));
-    selectComboBoxItem(ui->imageResolutionBox, QVariant(imageSettings.resolution()));
-    ui->imageQualitySlider->setValue(imageSettings.quality());
+    imagecapture->setFileFormat(boxValue(ui->imageCodecBox).value<QCameraImageCapture::FileFormat>());
+    imagecapture->setQuality(QCameraImageCapture::Quality(ui->imageQualitySlider->value()));
+    imagecapture->setResolution(boxValue(ui->imageResolutionBox).toSize());
 }
 
 QVariant ImageSettings::boxValue(const QComboBox *box) const
diff --git a/examples/multimediawidgets/camera/imagesettings.h b/examples/multimediawidgets/camera/imagesettings.h
index 26b309126..cb7691045 100644
--- a/examples/multimediawidgets/camera/imagesettings.h
+++ b/examples/multimediawidgets/camera/imagesettings.h
@@ -68,8 +68,7 @@ public:
     explicit ImageSettings(QCameraImageCapture *imageCapture, QWidget *parent = nullptr);
     ~ImageSettings();
 
-    QImageEncoderSettings imageSettings() const;
-    void setImageSettings(const QImageEncoderSettings &settings);
+    void applyImageSettings() const;
 
     QString format() const;
     void setFormat(const QString &format);
diff --git a/examples/multimediawidgets/camera/videosettings.cpp b/examples/multimediawidgets/camera/videosettings.cpp
index 29764eb9a..cb17fda57 100644
--- a/examples/multimediawidgets/camera/videosettings.cpp
+++ b/examples/multimediawidgets/camera/videosettings.cpp
@@ -113,7 +113,7 @@ VideoSettings::VideoSettings(QMediaEncoder *mediaRecorder, QWidget *parent)
                                         QVariant::fromValue(format));
     }
 
-    ui->qualitySlider->setRange(0, int(QImageEncoderSettings::VeryHighQuality));
+    ui->qualitySlider->setRange(0, int(QMediaEncoderSettings::VeryHighQuality));
 }
 
 VideoSettings::~VideoSettings()
diff --git a/src/multimedia/camera/qcameraimagecapture.cpp b/src/multimedia/camera/qcameraimagecapture.cpp
index e90d11fdd..0a503479b 100644
--- a/src/multimedia/camera/qcameraimagecapture.cpp
+++ b/src/multimedia/camera/qcameraimagecapture.cpp
@@ -42,6 +42,7 @@
 #include <qmediametadata.h>
 #include <private/qplatformmediacapture_p.h>
 #include <private/qplatformmediaintegration_p.h>
+#include <private/qplatformmediaformatinfo_p.h>
 #include <qmediacapturesession.h>
 
 #include "private/qobject_p.h"
@@ -204,34 +205,6 @@ QString QCameraImageCapture::errorString() const
 }
 
 /*!
-    Returns the image encoder settings being used.
-
-    \sa setEncodingSettings()
-*/
-
-QImageEncoderSettings QCameraImageCapture::encodingSettings() const
-{
-    return d_func()->control ?
-           d_func()->control->imageSettings() : QImageEncoderSettings();
-}
-
-/*!
-    Sets the image encoding \a settings.
-
-    If some parameters are not specified, or null settings are passed,
-    the encoder choose the default encoding parameters.
-
-    \sa encodingSettings()
-*/
-void QCameraImageCapture::setEncodingSettings(const QImageEncoderSettings &settings)
-{
-    Q_D(QCameraImageCapture);
-
-    if (d->control)
-        d->control->setImageSettings(settings);
-}
-
-/*!
     Returns the meta data that will get embedded into the image. A couple of additional fields
     such as a time stamp or location might get added by the camera backend.
 */
@@ -419,6 +392,165 @@ int QCameraImageCapture::capture()
     the frame with request \a id was saved to \a fileName.
 */
 
+/*!
+    Returns the image format.
+*/
+
+QCameraImageCapture::FileFormat QCameraImageCapture::fileFormat() const
+{
+    Q_D(const QCameraImageCapture);
+    if (!d->control)
+        return UnspecifiedFormat;
+    return d->control->imageSettings().format();
+}
+
+/*!
+    Sets the image \a format.
+*/
+void QCameraImageCapture::setFileFormat(QCameraImageCapture::FileFormat format)
+{
+    Q_D(QCameraImageCapture);
+    if (!d->control)
+        return;
+    auto fmt = d->control->imageSettings();
+    if (fmt.format() == format)
+        return;
+    fmt.setFormat(format);
+    d->control->setImageSettings(fmt);
+    emit fileFormatChanged();
+}
+
+QList<QCameraImageCapture::FileFormat> QCameraImageCapture::supportedFormats()
+{
+    return QPlatformMediaIntegration::instance()->formatInfo()->imageFormats;
+}
+
+QString QCameraImageCapture::fileFormatName(QCameraImageCapture::FileFormat f)
+{
+    const char *name = nullptr;
+    switch (f) {
+    case UnspecifiedFormat:
+        name = "Unspecified image format";
+        break;
+    case JPEG:
+        name = "JPEG";
+        break;
+    case PNG:
+        name = "PNG";
+        break;
+    case WebP:
+        name = "WebP";
+        break;
+    case Tiff:
+        name = "Tiff";
+        break;
+    }
+    return QString::fromUtf8(name);
+}
+
+QString QCameraImageCapture::fileFormatDescription(QCameraImageCapture::FileFormat f)
+{
+    const char *name = nullptr;
+    switch (f) {
+    case UnspecifiedFormat:
+        name = "Unspecified image format";
+        break;
+    case JPEG:
+        name = "JPEG";
+        break;
+    case PNG:
+        name = "PNG";
+        break;
+    case WebP:
+        name = "WebP";
+        break;
+    case Tiff:
+        name = "Tiff";
+        break;
+    }
+    return QString::fromUtf8(name);
+}
+
+/*!
+    Returns the resolution of the encoded image.
+*/
+
+QSize QCameraImageCapture::resolution() const
+{
+    Q_D(const QCameraImageCapture);
+    if (!d->control)
+        return QSize();
+    return d->control->imageSettings().resolution();
+}
+
+/*!
+    Sets the \a resolution of the encoded image.
+
+    An empty QSize indicates the encoder should make an optimal choice based on
+    what is available from the image source and the limitations of the codec.
+*/
+void QCameraImageCapture::setResolution(const QSize &resolution)
+{
+    Q_D(QCameraImageCapture);
+    if (!d->control)
+        return;
+    auto fmt = d->control->imageSettings();
+    if (fmt.resolution() == resolution)
+        return;
+    fmt.setResolution(resolution);
+    d->control->setImageSettings(fmt);
+    emit resolutionChanged();
+}
+
+/*!
+    Sets the \a width and \a height of the resolution of the encoded image.
+
+    \overload
+*/
+void QCameraImageCapture::setResolution(int width, int height)
+{
+    setResolution(QSize(width, height));
+}
+
+/*!
+    \enum QCameraImageCapture::EncodingQuality
+
+    Enumerates quality encoding levels.
+
+    \value VeryLowQuality
+    \value LowQuality
+    \value NormalQuality
+    \value HighQuality
+    \value VeryHighQuality
+*/
+
+/*!
+    Returns the image encoding quality.
+*/
+QCameraImageCapture::Quality QCameraImageCapture::quality() const
+{
+    Q_D(const QCameraImageCapture);
+    if (!d->control)
+        return NormalQuality;
+    return d->control->imageSettings().quality();
+}
+
+/*!
+    Sets the image encoding \a quality.
+*/
+void QCameraImageCapture::setQuality(Quality quality)
+{
+    Q_D(QCameraImageCapture);
+    if (!d->control)
+        return;
+    auto fmt = d->control->imageSettings();
+    if (fmt.quality() == quality)
+        return;
+    fmt.setQuality(quality);
+    d->control->setImageSettings(fmt);
+    emit resolutionChanged();
+}
+
 QT_END_NAMESPACE
 
 #include "moc_qcameraimagecapture.cpp"
diff --git a/src/multimedia/camera/qcameraimagecapture.h b/src/multimedia/camera/qcameraimagecapture.h
index ec34bff44..015b7f0a3 100644
--- a/src/multimedia/camera/qcameraimagecapture.h
+++ b/src/multimedia/camera/qcameraimagecapture.h
@@ -66,6 +66,8 @@ class Q_MULTIMEDIA_EXPORT QCameraImageCapture : public QObject
     Q_PROPERTY(QMediaMetaData metaData READ metaData WRITE setMetaData NOTIFY metaDataChanged)
     Q_PROPERTY(Error error READ error NOTIFY errorChanged)
     Q_PROPERTY(QString errorString READ errorString NOTIFY errorChanged)
+    Q_PROPERTY(FileFormat fileFormat READ fileFormat NOTIFY setFileFormat NOTIFY fileFormatChanged)
+    Q_PROPERTY(Quality quality READ quality NOTIFY setQuality NOTIFY qualityChanged)
 public:
     enum Error
     {
@@ -78,6 +80,26 @@ public:
     };
     Q_ENUM(Error)
 
+    enum Quality
+    {
+        VeryLowQuality,
+        LowQuality,
+        NormalQuality,
+        HighQuality,
+        VeryHighQuality
+    };
+    Q_ENUM(Quality)
+
+    enum FileFormat {
+        UnspecifiedFormat,
+        JPEG,
+        PNG,
+        WebP,
+        Tiff,
+        LastFileFormat = Tiff
+    };
+    Q_ENUM(FileFormat)
+
     explicit QCameraImageCapture(QObject *parent = nullptr);
     ~QCameraImageCapture();
 
@@ -90,8 +112,19 @@ public:
 
     bool isReadyForCapture() const;
 
-    QImageEncoderSettings encodingSettings() const;
-    void setEncodingSettings(const QImageEncoderSettings& settings);
+    FileFormat fileFormat() const;
+    void setFileFormat(FileFormat format);
+
+    static QList<FileFormat> supportedFormats();
+    static QString fileFormatName(FileFormat c);
+    static QString fileFormatDescription(FileFormat c);
+
+    QSize resolution() const;
+    void setResolution(const QSize &);
+    void setResolution(int width, int height);
+
+    Quality quality() const;
+    void setQuality(Quality quality);
 
     QMediaMetaData metaData() const;
     void setMetaData(const QMediaMetaData &metaData);
@@ -108,6 +141,10 @@ Q_SIGNALS:
     void readyForCaptureChanged(bool ready);
     void metaDataChanged();
 
+    void fileFormatChanged();
+    void qualityChanged();
+    void resolutionChanged();
+
     void imageExposed(int id);
     void imageCaptured(int id, const QImage &preview);
     void imageMetadataAvailable(int id, const QMediaMetaData &metaData);
diff --git a/src/multimedia/doc/snippets/multimedia-snippets/media.cpp b/src/multimedia/doc/snippets/multimedia-snippets/media.cpp
index 9a896e460..f2ed71cf7 100644
--- a/src/multimedia/doc/snippets/multimedia-snippets/media.cpp
+++ b/src/multimedia/doc/snippets/multimedia-snippets/media.cpp
@@ -103,7 +103,7 @@ void MediaExample::ImageEncoderSettings()
 {
     //! [Image encoder settings]
     QImageEncoderSettings imageSettings;
-    imageSettings.setFormat(QImageEncoderSettings::JPEG);
+    imageSettings.setFormat(QCameraImageCapture::JPEG);
     imageSettings.setResolution(1600, 1200);
 
     imageCapture->setEncodingSettings(imageSettings);
diff --git a/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp b/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp
index 1f1229944..a5cb1a467 100644
--- a/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp
+++ b/src/multimedia/platform/android/mediacapture/qandroidcamerasession.cpp
@@ -463,7 +463,7 @@ void QAndroidCameraSession::applyImageSettings()
         return;
 
     // only supported format right now.
-    m_actualImageSettings.setFormat(QImageEncoderSettings::JPEG);
+    m_actualImageSettings.setFormat(QCameraImageCapture::JPEG);
 
     const QSize requestedResolution = m_requestedImageSettings.resolution();
     const QList<QSize> supportedResolutions = m_camera->getSupportedPictureSizes();
@@ -485,19 +485,19 @@ void QAndroidCameraSession::applyImageSettings()
 
     int jpegQuality = 100;
     switch (m_requestedImageSettings.quality()) {
-    case QImageEncoderSettings::VeryLowQuality:
+    case QCameraImageCapture::VeryLowQuality:
         jpegQuality = 20;
         break;
-    case QImageEncoderSettings::LowQuality:
+    case QCameraImageCapture::LowQuality:
         jpegQuality = 40;
         break;
-    case QImageEncoderSettings::NormalQuality:
+    case QCameraImageCapture::NormalQuality:
         jpegQuality = 60;
         break;
-    case QImageEncoderSettings::HighQuality:
+    case QCameraImageCapture::HighQuality:
         jpegQuality = 80;
         break;
-    case QImageEncoderSettings::VeryHighQuality:
+    case QCameraImageCapture::VeryHighQuality:
         jpegQuality = 100;
         break;
     }
diff --git a/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h b/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h
index 7caf782e9..75929b489 100644
--- a/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h
+++ b/src/multimedia/platform/android/mediacapture/qandroidcamerasession_p.h
@@ -58,6 +58,7 @@
 #include <QSet>
 #include <QMutex>
 #include <private/qmediastoragelocation_p.h>
+#include <private/qplatformcameraimagecapture_p.h>
 #include "androidcamera_p.h"
 
 QT_BEGIN_NAMESPACE
diff --git a/src/multimedia/platform/android/qandroidformatsinfo.cpp b/src/multimedia/platform/android/qandroidformatsinfo.cpp
index c0cf72149..4d31cc15d 100644
--- a/src/multimedia/platform/android/qandroidformatsinfo.cpp
+++ b/src/multimedia/platform/android/qandroidformatsinfo.cpp
@@ -53,7 +53,7 @@ QAndroidFormatInfo::QAndroidFormatInfo()
     };
     encoders = decoders;
 
-    imageFormats << QImageEncoderSettings::JPEG;
+    imageFormats << QCameraImageCapture::JPEG;
 }
 
 QAndroidFormatInfo::~QAndroidFormatInfo()
diff --git a/src/multimedia/platform/darwin/camera/avfcameraimagecapture.mm b/src/multimedia/platform/darwin/camera/avfcameraimagecapture.mm
index 60a4484ff..7536d88d3 100644
--- a/src/multimedia/platform/darwin/camera/avfcameraimagecapture.mm
+++ b/src/multimedia/platform/darwin/camera/avfcameraimagecapture.mm
@@ -301,7 +301,7 @@ QImageEncoderSettings AVFCameraImageCapture::imageSettings() const
     }
 
     settings.setResolution(res);
-    settings.setFormat(QImageEncoderSettings::JPEG);
+    settings.setFormat(QCameraImageCapture::JPEG);
 
     return settings;
 }
@@ -330,7 +330,7 @@ bool AVFCameraImageCapture::applySettings()
         return false;
     }
 
-    if (m_settings.format() != QImageEncoderSettings::UnspecifiedFormat && m_settings.format() != QImageEncoderSettings::JPEG) {
+    if (m_settings.format() != QCameraImageCapture::UnspecifiedFormat && m_settings.format() != QCameraImageCapture::JPEG) {
         qDebugCamera() << Q_FUNC_INFO << "unsupported format:" << m_settings.format();
         return false;
     }
diff --git a/src/multimedia/platform/darwin/qdarwinformatsinfo.mm b/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
index 1cbbee939..59c563537 100644
--- a/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
+++ b/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
@@ -166,7 +166,7 @@ QDarwinFormatInfo::QDarwinFormatInfo()
 // #endif
 
     // ###
-    imageFormats << QImageEncoderSettings::JPEG;
+    imageFormats << QCameraImageCapture::JPEG;
 }
 
 QDarwinFormatInfo::~QDarwinFormatInfo()
diff --git a/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp b/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
index 6bb4de423..f89cf36c7 100644
--- a/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
+++ b/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
@@ -140,22 +140,22 @@ QMediaFormat::FileFormat QGstreamerFormatInfo::fileFormatForCaps(QGstStructure s
 }
 
 
-QImageEncoderSettings::FileFormat QGstreamerFormatInfo::imageFormatForCaps(QGstStructure structure)
+QCameraImageCapture::FileFormat QGstreamerFormatInfo::imageFormatForCaps(QGstStructure structure)
 {
     const char *name = structure.name().data();
 
     if (!strcmp(name, "image/jpeg")) {
-        return QImageEncoderSettings::JPEG;
+        return QCameraImageCapture::JPEG;
     } else if (!strcmp(name, "image/png")) {
-        return QImageEncoderSettings::PNG;
+        return QCameraImageCapture::PNG;
     } else if (!strcmp(name, "image/webp")) {
-        return QImageEncoderSettings::WebP;
+        return QCameraImageCapture::WebP;
     } else if (!strcmp(name, "image/webp")) {
-        return QImageEncoderSettings::WebP;
+        return QCameraImageCapture::WebP;
     } else if (!strcmp(name, "image/tiff")) {
-        return QImageEncoderSettings::Tiff;
+        return QCameraImageCapture::Tiff;
     }
-    return QImageEncoderSettings::UnspecifiedFormat;
+    return QCameraImageCapture::UnspecifiedFormat;
 }
 
 static QPair<QList<QMediaFormat::AudioCodec>, QList<QMediaFormat::VideoCodec>> getCodecsList(bool decode)
@@ -266,9 +266,9 @@ QList<QGstreamerFormatInfo::CodecMap> QGstreamerFormatInfo::getMuxerList(bool de
     return muxers;
 }
 
-static QList<QImageEncoderSettings::FileFormat> getImageFormatList()
+static QList<QCameraImageCapture::FileFormat> getImageFormatList()
 {
-    QSet<QImageEncoderSettings::FileFormat> formats;
+    QSet<QCameraImageCapture::FileFormat> formats;
 
     GList *elementList = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_ENCODER,
                                                                GST_RANK_MARGINAL);
@@ -289,7 +289,7 @@ static QList<QImageEncoderSettings::FileFormat> getImageFormatList()
                 for (int i = 0; i < caps.size(); i++) {
                     QGstStructure structure = caps.at(i);
                     auto f = QGstreamerFormatInfo::imageFormatForCaps(structure);
-                    if (f != QImageEncoderSettings::UnspecifiedFormat) {
+                    if (f != QCameraImageCapture::UnspecifiedFormat) {
 //                        qDebug() << structure.toString() << f;
                         formats.insert(f);
                     }
diff --git a/src/multimedia/platform/gstreamer/qgstreamerformatinfo_p.h b/src/multimedia/platform/gstreamer/qgstreamerformatinfo_p.h
index d198b4fff..47d0f133a 100644
--- a/src/multimedia/platform/gstreamer/qgstreamerformatinfo_p.h
+++ b/src/multimedia/platform/gstreamer/qgstreamerformatinfo_p.h
@@ -71,7 +71,7 @@ public:
     static QMediaFormat::AudioCodec audioCodecForCaps(QGstStructure structure);
     static QMediaFormat::VideoCodec videoCodecForCaps(QGstStructure structure);
     static QMediaFormat::FileFormat fileFormatForCaps(QGstStructure structure);
-    static QImageEncoderSettings::FileFormat imageFormatForCaps(QGstStructure structure);
+    static QCameraImageCapture::FileFormat imageFormatForCaps(QGstStructure structure);
 
     QList<CodecMap> getMuxerList(bool demuxer, QList<QMediaFormat::AudioCodec> audioCodecs, QList<QMediaFormat::VideoCodec> videoCodecs);
 };
diff --git a/src/multimedia/platform/qplatformcameraimagecapture_p.h b/src/multimedia/platform/qplatformcameraimagecapture_p.h
index b7a12a561..65f96a97d 100644
--- a/src/multimedia/platform/qplatformcameraimagecapture_p.h
+++ b/src/multimedia/platform/qplatformcameraimagecapture_p.h
@@ -53,12 +53,39 @@
 
 #include <QtMultimedia/qcameraimagecapture.h>
 #include <QtMultimedia/qmediametadata.h>
+#include <QtMultimedia/qcameraimagecapture.h>
 
 QT_BEGIN_NAMESPACE
 
 class QImage;
 class QPlatformMediaCaptureSession;
 
+class QImageEncoderSettingsPrivate;
+class Q_MULTIMEDIA_EXPORT QImageEncoderSettings
+{
+    QCameraImageCapture::FileFormat m_format = QCameraImageCapture::UnspecifiedFormat;
+    QSize m_resolution;
+    QCameraImageCapture::Quality m_quality = QCameraImageCapture::NormalQuality;
+
+public:
+    bool operator==(const QImageEncoderSettings &other) {
+        return m_format == other.m_format &&
+               m_resolution == other.m_resolution &&
+               m_quality == other.m_quality;
+    }
+    bool operator!=(const QImageEncoderSettings &other) { return !operator==(other); }
+
+    QCameraImageCapture::FileFormat format() const { return m_format; }
+    void setFormat(QCameraImageCapture::FileFormat f) { m_format = f; }
+
+    QSize resolution() const { return m_resolution; }
+    void setResolution(const QSize &s) { m_resolution = s; }
+    void setResolution(int width, int height) { m_resolution = QSize(width, height); }
+
+    QCameraImageCapture::Quality quality() const { return m_quality; }
+    void setQuality(QCameraImageCapture::Quality quality) { m_quality = quality; }
+};
+
 class Q_MULTIMEDIA_EXPORT QPlatformCameraImageCapture : public QObject
 {
     Q_OBJECT
diff --git a/src/multimedia/platform/qplatformmediaformatinfo_p.h b/src/multimedia/platform/qplatformmediaformatinfo_p.h
index a1b93f5f4..984065b17 100644
--- a/src/multimedia/platform/qplatformmediaformatinfo_p.h
+++ b/src/multimedia/platform/qplatformmediaformatinfo_p.h
@@ -53,6 +53,7 @@
 
 #include <private/qtmultimediaglobal_p.h>
 #include <qmediaencodersettings.h>
+#include <qcameraimagecapture.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -76,7 +77,7 @@ public:
     QList<CodecMap> encoders;
     QList<CodecMap> decoders;
 
-    QList<QImageEncoderSettings::FileFormat> imageFormats;
+    QList<QCameraImageCapture::FileFormat> imageFormats;
 };
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture.cpp b/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture.cpp
index e37a62c6b..b4499d61c 100644
--- a/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture.cpp
+++ b/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture.cpp
@@ -169,21 +169,21 @@ void QWindowsCameraImageCapture::saveImage(int captureId, const QString &fileNam
                               Q_ARG(int, captureId), Q_ARG(QString, fileName));
 }
 
-QString QWindowsCameraImageCapture::writerFormat(QImageEncoderSettings::FileFormat reqFormat)
+QString QWindowsCameraImageCapture::writerFormat(QCameraImageCapture::FileFormat reqFormat)
 {
     QString format;
 
     switch (reqFormat) {
-    case QImageEncoderSettings::FileFormat::JPEG:
+    case QCameraImageCapture::FileFormat::JPEG:
         format = QLatin1String("jpg");
         break;
-    case QImageEncoderSettings::FileFormat::PNG:
+    case QCameraImageCapture::FileFormat::PNG:
         format = QLatin1String("png");
         break;
-    case QImageEncoderSettings::FileFormat::WebP:
+    case QCameraImageCapture::FileFormat::WebP:
         format = QLatin1String("webp");
         break;
-    case QImageEncoderSettings::FileFormat::Tiff:
+    case QCameraImageCapture::FileFormat::Tiff:
         format = QLatin1String("tiff");
         break;
     default:
@@ -199,21 +199,21 @@ QString QWindowsCameraImageCapture::writerFormat(QImageEncoderSettings::FileForm
 }
 
 int QWindowsCameraImageCapture::writerQuality(const QString &writerFormat,
-                                              QImageEncoderSettings::Quality quality)
+                                              QCameraImageCapture::Quality quality)
 {
     if (writerFormat.compare(QLatin1String("jpg"), Qt::CaseInsensitive) == 0 ||
             writerFormat.compare(QLatin1String("jpeg"), Qt::CaseInsensitive) == 0) {
 
         switch (quality) {
-        case QImageEncoderSettings::Quality::VeryLowQuality:
+        case QCameraImageCapture::Quality::VeryLowQuality:
             return 10;
-        case QImageEncoderSettings::Quality::LowQuality:
+        case QCameraImageCapture::Quality::LowQuality:
             return 30;
-        case QImageEncoderSettings::Quality::NormalQuality:
+        case QCameraImageCapture::Quality::NormalQuality:
             return 75;
-        case QImageEncoderSettings::Quality::HighQuality:
+        case QCameraImageCapture::Quality::HighQuality:
             return 90;
-        case QImageEncoderSettings::Quality::VeryHighQuality:
+        case QCameraImageCapture::Quality::VeryHighQuality:
             return 98;
         default:
             return 75;
diff --git a/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture_p.h b/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture_p.h
index d45d38255..4cd405454 100644
--- a/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture_p.h
+++ b/src/multimedia/platform/windows/mediacapture/qwindowscameraimagecapture_p.h
@@ -85,9 +85,9 @@ private:
     void saveImage(int captureId, const QString &fileName,
                    const QImage &image, const QMediaMetaData &metaData,
                    const QImageEncoderSettings &settings);
-    QString writerFormat(QImageEncoderSettings::FileFormat reqFormat);
+    QString writerFormat(QCameraImageCapture::FileFormat reqFormat);
     int writerQuality(const QString &writerFormat,
-                      QImageEncoderSettings::Quality quality);
+                      QCameraImageCapture::Quality quality);
 
     QWindowsMediaCaptureService  *m_captureService = nullptr;
     QWindowsMediaDeviceSession   *m_mediaDeviceSession = nullptr;
diff --git a/src/multimedia/platform/windows/qwindowsformatinfo.cpp b/src/multimedia/platform/windows/qwindowsformatinfo.cpp
index 9bfa66f8d..2e308ffbe 100644
--- a/src/multimedia/platform/windows/qwindowsformatinfo.cpp
+++ b/src/multimedia/platform/windows/qwindowsformatinfo.cpp
@@ -81,7 +81,7 @@ QWindowsFormatInfo::QWindowsFormatInfo()
     };
 
     // ####
-    imageFormats = { QImageEncoderSettings::JPEG, QImageEncoderSettings::PNG };
+    imageFormats = { QCameraImageCapture::JPEG, QCameraImageCapture::PNG };
 
 }
 
diff --git a/src/multimedia/recording/qmediaencodersettings.cpp b/src/multimedia/recording/qmediaencodersettings.cpp
index 561a63de9..833155089 100644
--- a/src/multimedia/recording/qmediaencodersettings.cpp
+++ b/src/multimedia/recording/qmediaencodersettings.cpp
@@ -344,233 +344,4 @@ bool QMediaEncoderSettings::operator==(const QMediaEncoderSettings &other) const
         d->videoBitRate == other.d->videoBitRate;
 }
 
-
-class QImageEncoderSettingsPrivate  : public QSharedData
-{
-public:
-    bool isNull = true;
-    QImageEncoderSettings::FileFormat format = QImageEncoderSettings::UnspecifiedFormat;
-    QSize resolution;
-    QImageEncoderSettings::Quality quality = QImageEncoderSettings::NormalQuality;
-};
-
-/*!
-    \class QImageEncoderSettings
-
-
-    \brief The QImageEncoderSettings class provides a set of image encoder
-    settings.
-
-    \inmodule QtMultimedia
-    \ingroup multimedia
-    \ingroup multimedia_camera
-
-    A image encoder settings object is used to specify the image encoder
-    settings used by QCameraImageCapture.  Image encoder settings are selected
-    by constructing a QImageEncoderSettings object, setting the desired
-    properties and then passing it to a QCameraImageCapture instance using the
-    QCameraImageCapture::setImageSettings() function.
-
-    \snippet multimedia-snippets/media.cpp Image encoder settings
-
-    \sa QImageEncoderControl
-*/
-
-/*!
-    Constructs a null image encoder settings object.
-*/
-
-QImageEncoderSettings::QImageEncoderSettings()
-    :d(new QImageEncoderSettingsPrivate)
-{
-}
-
-/*!
-    Constructs a copy of the image encoder settings object \a other.
-*/
-
-QImageEncoderSettings::QImageEncoderSettings(const QImageEncoderSettings& other) = default;
-
-/*!
-    Destroys a image encoder settings object.
-*/
-
-QImageEncoderSettings::~QImageEncoderSettings() = default;
-
-/*!
-    Assigns the value of \a other to a image encoder settings object.
-*/
-QImageEncoderSettings &QImageEncoderSettings::operator=(const QImageEncoderSettings &other) = default;
-
-/*!
-    Determines if \a other is of equal value to a image encoder settings
-    object.
-
-    Returns true if the settings objects are of equal value, and false if they
-    are not of equal value.
-*/
-bool QImageEncoderSettings::operator==(const QImageEncoderSettings &other) const
-{
-    return (d == other.d) ||
-           (d->isNull == other.d->isNull &&
-            d->quality == other.d->quality &&
-            d->format == other.d->format &&
-            d->resolution == other.d->resolution);
-
-}
-
-/*!
-    Determines if \a other is of equal value to a image encoder settings
-    object.
-
-    Returns true if the settings objects are not of equal value, and false if
-    they are of equal value.
-*/
-bool QImageEncoderSettings::operator!=(const QImageEncoderSettings &other) const
-{
-    return !(*this == other);
-}
-
-/*!
-    Identifies if a image encoder settings object is uninitalized.
-
-    Returns true if the settings are null, and false if they are not.
-*/
-bool QImageEncoderSettings::isNull() const
-{
-    return d->isNull;
-}
-
-/*!
-    Returns the image format.
-*/
-
-QImageEncoderSettings::FileFormat QImageEncoderSettings::format() const
-{
-    return d->format;
-}
-
-/*!
-    Sets the image \a format.
-*/
-void QImageEncoderSettings::setFormat(QImageEncoderSettings::FileFormat format)
-{
-    d->isNull = false;
-    d->format = format;
-}
-
-QList<QImageEncoderSettings::FileFormat> QImageEncoderSettings::supportedFormats()
-{
-    return QPlatformMediaIntegration::instance()->formatInfo()->imageFormats;
-}
-
-QString QImageEncoderSettings::fileFormatName(QImageEncoderSettings::FileFormat f)
-{
-    const char *name = nullptr;
-    switch (f) {
-    case UnspecifiedFormat:
-        name = "Unspecified image format";
-        break;
-    case JPEG:
-        name = "JPEG";
-        break;
-    case PNG:
-        name = "PNG";
-        break;
-    case WebP:
-        name = "WebP";
-        break;
-    case Tiff:
-        name = "Tiff";
-        break;
-    }
-    return QString::fromUtf8(name);
-}
-
-QString QImageEncoderSettings::fileFormatDescription(QImageEncoderSettings::FileFormat f)
-{
-    const char *name = nullptr;
-    switch (f) {
-    case UnspecifiedFormat:
-        name = "Unspecified image format";
-        break;
-    case JPEG:
-        name = "JPEG";
-        break;
-    case PNG:
-        name = "PNG";
-        break;
-    case WebP:
-        name = "WebP";
-        break;
-    case Tiff:
-        name = "Tiff";
-        break;
-    }
-    return QString::fromUtf8(name);
-}
-
-/*!
-    Returns the resolution of the encoded image.
-*/
-
-QSize QImageEncoderSettings::resolution() const
-{
-    return d->resolution;
-}
-
-/*!
-    Sets the \a resolution of the encoded image.
-
-    An empty QSize indicates the encoder should make an optimal choice based on
-    what is available from the image source and the limitations of the codec.
-*/
-
-void QImageEncoderSettings::setResolution(const QSize &resolution)
-{
-    d->isNull = false;
-    d->resolution = resolution;
-}
-
-/*!
-    Sets the \a width and \a height of the resolution of the encoded image.
-
-    \overload
-*/
-
-void QImageEncoderSettings::setResolution(int width, int height)
-{
-    d->isNull = false;
-    d->resolution = QSize(width, height);
-}
-
-/*!
-    \enum QImageEncoderSettings::EncodingQuality
-
-    Enumerates quality encoding levels.
-
-    \value VeryLowQuality
-    \value LowQuality
-    \value NormalQuality
-    \value HighQuality
-    \value VeryHighQuality
-*/
-
-/*!
-    Returns the image encoding quality.
-*/
-QImageEncoderSettings::Quality QImageEncoderSettings::quality() const
-{
-    return d->quality;
-}
-
-/*!
-    Sets the image encoding \a quality.
-*/
-void QImageEncoderSettings::setQuality(Quality quality)
-{
-    d->isNull = false;
-    d->quality = quality;
-}
-
 QT_END_NAMESPACE
diff --git a/src/multimedia/recording/qmediaencodersettings.h b/src/multimedia/recording/qmediaencodersettings.h
index 0c489c5d5..99efabb00 100644
--- a/src/multimedia/recording/qmediaencodersettings.h
+++ b/src/multimedia/recording/qmediaencodersettings.h
@@ -129,57 +129,6 @@ private:
     QSharedDataPointer<QMediaEncoderSettingsPrivate> d;
 };
 
-class QImageEncoderSettingsPrivate;
-class Q_MULTIMEDIA_EXPORT QImageEncoderSettings
-{
-public:
-    enum Quality
-    {
-        VeryLowQuality,
-        LowQuality,
-        NormalQuality,
-        HighQuality,
-        VeryHighQuality
-    };
-
-    enum FileFormat {
-        UnspecifiedFormat,
-        JPEG,
-        PNG,
-        WebP,
-        Tiff,
-        LastFileFormat = Tiff
-    };
-
-    QImageEncoderSettings();
-    QImageEncoderSettings(const QImageEncoderSettings& other);
-
-    ~QImageEncoderSettings();
-
-    QImageEncoderSettings& operator=(const QImageEncoderSettings &other);
-    bool operator==(const QImageEncoderSettings &other) const;
-    bool operator!=(const QImageEncoderSettings &other) const;
-
-    bool isNull() const;
-
-    FileFormat format() const;
-    void setFormat(FileFormat format);
-
-    static QList<FileFormat> supportedFormats();
-    static QString fileFormatName(FileFormat c);
-    static QString fileFormatDescription(FileFormat c);
-
-    QSize resolution() const;
-    void setResolution(const QSize &);
-    void setResolution(int width, int height);
-
-    Quality quality() const;
-    void setQuality(Quality quality);
-
-private:
-    QSharedDataPointer<QImageEncoderSettingsPrivate> d;
-};
-
 QT_END_NAMESPACE
 
 #endif
diff --git a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
index 682f480a8..5e227f64a 100644
--- a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
+++ b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
@@ -69,7 +69,6 @@ private slots:
     void testCameraFocus();
     void testCameraCapture();
     void testCameraCaptureMetadata();
-    void testImageSettings();
     void testCameraEncodingProperyChange();
 
     void testConstructor();
@@ -438,98 +437,6 @@ void tst_QCamera::testCameraFocus()
     QCOMPARE(camera.customFocusPoint(), QPointF(1.0, 1.0));
 }
 
-void tst_QCamera::testImageSettings()
-{
-    QImageEncoderSettings settings;
-    QVERIFY(settings.isNull());
-    QVERIFY(settings == QImageEncoderSettings());
-
-    QCOMPARE(settings.format(), QImageEncoderSettings::UnspecifiedFormat);
-    settings.setFormat(QImageEncoderSettings::Tiff);
-    QCOMPARE(settings.format(), QImageEncoderSettings::Tiff);
-    QVERIFY(!settings.isNull());
-    QVERIFY(settings != QImageEncoderSettings());
-
-    settings = QImageEncoderSettings();
-    QCOMPARE(settings.quality(), QImageEncoderSettings::NormalQuality);
-    settings.setQuality(QImageEncoderSettings::HighQuality);
-    QCOMPARE(settings.quality(), QImageEncoderSettings::HighQuality);
-    QVERIFY(!settings.isNull());
-
-    settings = QImageEncoderSettings();
-    QCOMPARE(settings.resolution(), QSize());
-    settings.setResolution(QSize(320,240));
-    QCOMPARE(settings.resolution(), QSize(320,240));
-    settings.setResolution(800,600);
-    QCOMPARE(settings.resolution(), QSize(800,600));
-    QVERIFY(!settings.isNull());
-
-    settings = QImageEncoderSettings();
-    QVERIFY(settings.isNull());
-    QCOMPARE(settings.format(), QImageEncoderSettings::UnspecifiedFormat);
-    QCOMPARE(settings.quality(), QImageEncoderSettings::NormalQuality);
-    QCOMPARE(settings.resolution(), QSize());
-
-    {
-        QImageEncoderSettings settings1;
-        QImageEncoderSettings settings2;
-        QCOMPARE(settings2, settings1);
-
-        settings2 = settings1;
-        QCOMPARE(settings2, settings1);
-        QVERIFY(settings2.isNull());
-
-        settings1.setQuality(QImageEncoderSettings::HighQuality);
-
-        QVERIFY(settings2.isNull());
-        QVERIFY(!settings1.isNull());
-        QVERIFY(settings1 != settings2);
-    }
-
-    {
-        QImageEncoderSettings settings1;
-        QImageEncoderSettings settings2(settings1);
-        QCOMPARE(settings2, settings1);
-
-        settings2 = settings1;
-        QCOMPARE(settings2, settings1);
-        QVERIFY(settings2.isNull());
-
-        settings1.setQuality(QImageEncoderSettings::HighQuality);
-
-        QVERIFY(settings2.isNull());
-        QVERIFY(!settings1.isNull());
-        QVERIFY(settings1 != settings2);
-    }
-
-    QImageEncoderSettings settings1;
-    QImageEncoderSettings settings2;
-
-    settings1 = QImageEncoderSettings();
-    settings1.setResolution(800,600);
-    settings2 = QImageEncoderSettings();
-    settings2.setResolution(QSize(800,600));
-    QVERIFY(settings1 == settings2);
-    settings2.setResolution(QSize(400,300));
-    QVERIFY(settings1 != settings2);
-
-    settings1 = QImageEncoderSettings();
-    settings1.setFormat(QImageEncoderSettings::PNG);
-    settings2 = QImageEncoderSettings();
-    settings2.setFormat(QImageEncoderSettings::PNG);
-    QVERIFY(settings1 == settings2);
-    settings2.setFormat(QImageEncoderSettings::Tiff);
-    QVERIFY(settings1 != settings2);
-
-    settings1 = QImageEncoderSettings();
-    settings1.setQuality(QImageEncoderSettings::NormalQuality);
-    settings2 = QImageEncoderSettings();
-    settings2.setQuality(QImageEncoderSettings::NormalQuality);
-    QVERIFY(settings1 == settings2);
-    settings2.setQuality(QImageEncoderSettings::LowQuality);
-    QVERIFY(settings1 != settings2);
-}
-
 void tst_QCamera::testCameraEncodingProperyChange()
 {
     QMediaCaptureSession session;
diff --git a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
index 3fda9b0de..c69af0621 100644
--- a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
+++ b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
@@ -181,14 +181,10 @@ void tst_QCameraImageCapture::encodingSettings()
     session.setImageCapture(&imageCapture);
 
     QVERIFY(imageCapture.isAvailable() == true);
-    QVERIFY(imageCapture.encodingSettings() == QImageEncoderSettings());
-    QImageEncoderSettings settings;
-    settings.setFormat(QImageEncoderSettings::JPEG);
-    settings.setQuality(QImageEncoderSettings::NormalQuality);
-    imageCapture.setEncodingSettings(settings);
-    QVERIFY(!imageCapture.encodingSettings().isNull());
-    QVERIFY(imageCapture.encodingSettings().format() == QImageEncoderSettings::JPEG);
-    QVERIFY(imageCapture.encodingSettings().quality() == QImageEncoderSettings::NormalQuality);
+    imageCapture.setFileFormat(QCameraImageCapture::JPEG);
+    imageCapture.setQuality(QCameraImageCapture::NormalQuality);
+    QVERIFY(imageCapture.fileFormat() == QCameraImageCapture::JPEG);
+    QVERIFY(imageCapture.quality() == QCameraImageCapture::NormalQuality);
 }
 
 void tst_QCameraImageCapture::errors()