Merge remote-tracking branch 'origin/5.10' into dev

 Conflicts:
	src/plugins/qnx/mediaplayer/mmreventmediaplayercontrol.h

Change-Id: Ic6e27742ef6d1af0532ad05902a1431ebd5f449d

31 files changed, 842 insertions, 1010 deletions

diff --git a/examples/multimedia/audiodevices/audiodevices.cpp b/examples/multimedia/audiodevices/audiodevices.cpp
index cf0947394..b447b809d 100644
--- a/examples/multimedia/audiodevices/audiodevices.cpp
+++ b/examples/multimedia/audiodevices/audiodevices.cpp
@@ -88,18 +88,16 @@ AudioDevicesBase::~AudioDevicesBase() {}
 AudioTest::AudioTest(QWidget *parent)
     : AudioDevicesBase(parent)
 {
-    mode = QAudio::AudioOutput;
-
-    connect(testButton, SIGNAL(clicked()), SLOT(test()));
-    connect(modeBox, SIGNAL(activated(int)), SLOT(modeChanged(int)));
-    connect(deviceBox, SIGNAL(activated(int)), SLOT(deviceChanged(int)));
-    connect(sampleRateBox, SIGNAL(activated(int)), SLOT(sampleRateChanged(int)));
-    connect(channelsBox, SIGNAL(activated(int)), SLOT(channelChanged(int)));
-    connect(codecsBox, SIGNAL(activated(int)), SLOT(codecChanged(int)));
-    connect(sampleSizesBox, SIGNAL(activated(int)), SLOT(sampleSizeChanged(int)));
-    connect(sampleTypesBox, SIGNAL(activated(int)), SLOT(sampleTypeChanged(int)));
-    connect(endianBox, SIGNAL(activated(int)), SLOT(endianChanged(int)));
-    connect(populateTableButton, SIGNAL(clicked()), SLOT(populateTable()));
+    connect(testButton, &QPushButton::clicked, this, &AudioTest::test);
+    connect(modeBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::modeChanged);
+    connect(deviceBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::deviceChanged);
+    connect(sampleRateBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::sampleRateChanged);
+    connect(channelsBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::channelChanged);
+    connect(codecsBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::codecChanged);
+    connect(sampleSizesBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::sampleSizeChanged);
+    connect(sampleTypesBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::sampleTypeChanged);
+    connect(endianBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::endianChanged);
+    connect(populateTableButton, &QPushButton::clicked, this, &AudioTest::populateTable);
 
     modeBox->setCurrentIndex(0);
     modeChanged(0);
@@ -107,17 +105,13 @@ AudioTest::AudioTest(QWidget *parent)
     deviceChanged(0);
 }
 
-AudioTest::~AudioTest()
-{
-}
-
 void AudioTest::test()
 {
     // tries to set all the settings picked.
     testResult->clear();
 
-    if (!deviceInfo.isNull()) {
-        if (deviceInfo.isFormatSupported(settings)) {
+    if (!m_deviceInfo.isNull()) {
+        if (m_deviceInfo.isFormatSupported(m_settings)) {
             testResult->setText(tr("Success"));
             nearestSampleRate->setText("");
             nearestChannel->setText("");
@@ -126,7 +120,7 @@ void AudioTest::test()
             nearestSampleType->setText("");
             nearestEndian->setText("");
         } else {
-            QAudioFormat nearest = deviceInfo.nearestFormat(settings);
+            QAudioFormat nearest = m_deviceInfo.nearestFormat(m_settings);
             testResult->setText(tr("Failed"));
             nearestSampleRate->setText(QString("%1").arg(nearest.sampleRate()));
             nearestChannel->setText(QString("%1").arg(nearest.channelCount()));
@@ -143,15 +137,9 @@ void AudioTest::test()
 void AudioTest::modeChanged(int idx)
 {
     testResult->clear();
-
-    // mode has changed
-    if (idx == 0)
-        mode = QAudio::AudioInput;
-    else
-        mode = QAudio::AudioOutput;
-
     deviceBox->clear();
-    foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(mode))
+    const QAudio::Mode mode = idx == 0 ? QAudio::AudioInput : QAudio::AudioOutput;
+    for (auto &deviceInfo: QAudioDeviceInfo::availableDevices(mode))
         deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
 
     deviceBox->setCurrentIndex(0);
@@ -166,52 +154,52 @@ void AudioTest::deviceChanged(int idx)
         return;
 
     // device has changed
-    deviceInfo = deviceBox->itemData(idx).value<QAudioDeviceInfo>();
+    m_deviceInfo = deviceBox->itemData(idx).value<QAudioDeviceInfo>();
 
     sampleRateBox->clear();
-    QList<int> sampleRatez = deviceInfo.supportedSampleRates();
+    QList<int> sampleRatez = m_deviceInfo.supportedSampleRates();
     for (int i = 0; i < sampleRatez.size(); ++i)
         sampleRateBox->addItem(QString("%1").arg(sampleRatez.at(i)));
     if (sampleRatez.size())
-        settings.setSampleRate(sampleRatez.at(0));
+        m_settings.setSampleRate(sampleRatez.at(0));
 
     channelsBox->clear();
-    QList<int> chz = deviceInfo.supportedChannelCounts();
+    QList<int> chz = m_deviceInfo.supportedChannelCounts();
     for (int i = 0; i < chz.size(); ++i)
         channelsBox->addItem(QString("%1").arg(chz.at(i)));
     if (chz.size())
-        settings.setChannelCount(chz.at(0));
+        m_settings.setChannelCount(chz.at(0));
 
     codecsBox->clear();
-    QStringList codecs = deviceInfo.supportedCodecs();
+    QStringList codecs = m_deviceInfo.supportedCodecs();
     for (int i = 0; i < codecs.size(); ++i)
         codecsBox->addItem(QString("%1").arg(codecs.at(i)));
     if (codecs.size())
-        settings.setCodec(codecs.at(0));
+        m_settings.setCodec(codecs.at(0));
     // Add false to create failed condition!
     codecsBox->addItem("audio/test");
 
     sampleSizesBox->clear();
-    QList<int> sampleSizez = deviceInfo.supportedSampleSizes();
+    QList<int> sampleSizez = m_deviceInfo.supportedSampleSizes();
     for (int i = 0; i < sampleSizez.size(); ++i)
         sampleSizesBox->addItem(QString("%1").arg(sampleSizez.at(i)));
     if (sampleSizez.size())
-        settings.setSampleSize(sampleSizez.at(0));
+        m_settings.setSampleSize(sampleSizez.at(0));
 
     sampleTypesBox->clear();
-    QList<QAudioFormat::SampleType> sampleTypez = deviceInfo.supportedSampleTypes();
+    QList<QAudioFormat::SampleType> sampleTypez = m_deviceInfo.supportedSampleTypes();
 
     for (int i = 0; i < sampleTypez.size(); ++i)
         sampleTypesBox->addItem(toString(sampleTypez.at(i)));
     if (sampleTypez.size())
-        settings.setSampleType(sampleTypez.at(0));
+        m_settings.setSampleType(sampleTypez.at(0));
 
     endianBox->clear();
-    QList<QAudioFormat::Endian> endianz = deviceInfo.supportedByteOrders();
+    QList<QAudioFormat::Endian> endianz = m_deviceInfo.supportedByteOrders();
     for (int i = 0; i < endianz.size(); ++i)
         endianBox->addItem(toString(endianz.at(i)));
     if (endianz.size())
-        settings.setByteOrder(endianz.at(0));
+        m_settings.setByteOrder(endianz.at(0));
 
     allFormatsTable->clearContents();
 }
@@ -221,19 +209,19 @@ void AudioTest::populateTable()
     int row = 0;
 
     QAudioFormat format;
-    foreach (QString codec, deviceInfo.supportedCodecs()) {
+    for (auto codec: m_deviceInfo.supportedCodecs()) {
         format.setCodec(codec);
-        foreach (int sampleRate, deviceInfo.supportedSampleRates()) {
+        for (auto sampleRate: m_deviceInfo.supportedSampleRates()) {
             format.setSampleRate(sampleRate);
-            foreach (int channels, deviceInfo.supportedChannelCounts()) {
+            for (auto channels: m_deviceInfo.supportedChannelCounts()) {
                 format.setChannelCount(channels);
-                foreach (QAudioFormat::SampleType sampleType, deviceInfo.supportedSampleTypes()) {
+                for (auto sampleType: m_deviceInfo.supportedSampleTypes()) {
                     format.setSampleType(sampleType);
-                    foreach (int sampleSize, deviceInfo.supportedSampleSizes()) {
+                    for (auto sampleSize: m_deviceInfo.supportedSampleSizes()) {
                         format.setSampleSize(sampleSize);
-                        foreach (QAudioFormat::Endian endian, deviceInfo.supportedByteOrders()) {
+                        for (auto endian: m_deviceInfo.supportedByteOrders()) {
                             format.setByteOrder(endian);
-                            if (deviceInfo.isFormatSupported(format)) {
+                            if (m_deviceInfo.isFormatSupported(format)) {
                                 allFormatsTable->setRowCount(row + 1);
 
                                 QTableWidgetItem *codecItem = new QTableWidgetItem(format.codec());
@@ -267,35 +255,35 @@ void AudioTest::populateTable()
 void AudioTest::sampleRateChanged(int idx)
 {
     // sample rate has changed
-    settings.setSampleRate(sampleRateBox->itemText(idx).toInt());
+    m_settings.setSampleRate(sampleRateBox->itemText(idx).toInt());
 }
 
 void AudioTest::channelChanged(int idx)
 {
-    settings.setChannelCount(channelsBox->itemText(idx).toInt());
+    m_settings.setChannelCount(channelsBox->itemText(idx).toInt());
 }
 
 void AudioTest::codecChanged(int idx)
 {
-    settings.setCodec(codecsBox->itemText(idx));
+    m_settings.setCodec(codecsBox->itemText(idx));
 }
 
 void AudioTest::sampleSizeChanged(int idx)
 {
-    settings.setSampleSize(sampleSizesBox->itemText(idx).toInt());
+    m_settings.setSampleSize(sampleSizesBox->itemText(idx).toInt());
 }
 
 void AudioTest::sampleTypeChanged(int idx)
 {
     switch (sampleTypesBox->itemText(idx).toInt()) {
         case QAudioFormat::SignedInt:
-            settings.setSampleType(QAudioFormat::SignedInt);
+            m_settings.setSampleType(QAudioFormat::SignedInt);
             break;
         case QAudioFormat::UnSignedInt:
-            settings.setSampleType(QAudioFormat::UnSignedInt);
+            m_settings.setSampleType(QAudioFormat::UnSignedInt);
             break;
         case QAudioFormat::Float:
-            settings.setSampleType(QAudioFormat::Float);
+            m_settings.setSampleType(QAudioFormat::Float);
     }
 }
 
@@ -303,9 +291,9 @@ void AudioTest::endianChanged(int idx)
 {
     switch (endianBox->itemText(idx).toInt()) {
         case QAudioFormat::LittleEndian:
-            settings.setByteOrder(QAudioFormat::LittleEndian);
+            m_settings.setByteOrder(QAudioFormat::LittleEndian);
             break;
         case QAudioFormat::BigEndian:
-            settings.setByteOrder(QAudioFormat::BigEndian);
+            m_settings.setByteOrder(QAudioFormat::BigEndian);
     }
 }
diff --git a/examples/multimedia/audiodevices/audiodevices.h b/examples/multimedia/audiodevices/audiodevices.h
index 2cc58eb6c..17f214a47 100644
--- a/examples/multimedia/audiodevices/audiodevices.h
+++ b/examples/multimedia/audiodevices/audiodevices.h
@@ -59,12 +59,11 @@ class AudioTest : public AudioDevicesBase
     Q_OBJECT
 
 public:
-    AudioTest(QWidget *parent = 0);
-    virtual ~AudioTest();
+    explicit AudioTest(QWidget *parent = nullptr);
 
-    QAudioDeviceInfo deviceInfo;
-    QAudioFormat settings;
-    QAudio::Mode mode;
+private:
+    QAudioDeviceInfo m_deviceInfo;
+    QAudioFormat m_settings;
 
 private slots:
     void modeChanged(int idx);
diff --git a/examples/multimedia/audioinput/audioinput.cpp b/examples/multimedia/audioinput/audioinput.cpp
index cdf56af99..e06df961e 100644
--- a/examples/multimedia/audioinput/audioinput.cpp
+++ b/examples/multimedia/audioinput/audioinput.cpp
@@ -38,6 +38,8 @@
 **
 ****************************************************************************/
 
+#include "audioinput.h"
+
 #include <stdlib.h>
 #include <math.h>
 
@@ -49,21 +51,8 @@
 #include <QAudioInput>
 #include <qendian.h>
 
-#include "audioinput.h"
-
-#define PUSH_MODE_LABEL "Enable push mode"
-#define PULL_MODE_LABEL "Enable pull mode"
-#define SUSPEND_LABEL   "Suspend recording"
-#define RESUME_LABEL    "Resume recording"
-
-const int BufferSize = 4096;
-
-AudioInfo::AudioInfo(const QAudioFormat &format, QObject *parent)
-    :   QIODevice(parent)
-    ,   m_format(format)
-    ,   m_maxAmplitude(0)
-    ,   m_level(0.0)
-
+AudioInfo::AudioInfo(const QAudioFormat &format)
+    : m_format(format)
 {
     switch (m_format.sampleSize()) {
     case 8:
@@ -111,10 +100,6 @@ AudioInfo::AudioInfo(const QAudioFormat &format, QObject *parent)
     }
 }
 
-AudioInfo::~AudioInfo()
-{
-}
-
 void AudioInfo::start()
 {
     open(QIODevice::WriteOnly);
@@ -196,7 +181,6 @@ RenderArea::RenderArea(QWidget *parent)
     setBackgroundRole(QPalette::Base);
     setAutoFillBackground(true);
 
-    m_level = 0;
     setMinimumHeight(30);
     setMinimumWidth(200);
 }
@@ -229,27 +213,16 @@ void RenderArea::setLevel(qreal value)
 
 
 InputTest::InputTest()
-    :   m_canvas(0)
-    ,   m_modeButton(0)
-    ,   m_suspendResumeButton(0)
-    ,   m_deviceBox(0)
-    ,   m_device(QAudioDeviceInfo::defaultInputDevice())
-    ,   m_audioInfo(0)
-    ,   m_audioInput(0)
-    ,   m_input(0)
-    ,   m_pullMode(true)
-    ,   m_buffer(BufferSize, 0)
 {
     initializeWindow();
-    initializeAudio();
+    initializeAudio(QAudioDeviceInfo::defaultInputDevice());
 }
 
-InputTest::~InputTest() {}
 
 void InputTest::initializeWindow()
 {
-    QScopedPointer<QWidget> window(new QWidget);
-    QScopedPointer<QVBoxLayout> layout(new QVBoxLayout);
+    QWidget *window = new QWidget;
+    QVBoxLayout *layout = new QVBoxLayout;
 
     m_canvas = new RenderArea(this);
     layout->addWidget(m_canvas);
@@ -257,143 +230,120 @@ void InputTest::initializeWindow()
     m_deviceBox = new QComboBox(this);
     const QAudioDeviceInfo &defaultDeviceInfo = QAudioDeviceInfo::defaultInputDevice();
     m_deviceBox->addItem(defaultDeviceInfo.deviceName(), qVariantFromValue(defaultDeviceInfo));
-    foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioInput)) {
+    for (auto &deviceInfo: QAudioDeviceInfo::availableDevices(QAudio::AudioInput)) {
         if (deviceInfo != defaultDeviceInfo)
             m_deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
     }
 
-    connect(m_deviceBox, SIGNAL(activated(int)), SLOT(deviceChanged(int)));
+    connect(m_deviceBox, QOverload<int>::of(&QComboBox::activated), this, &InputTest::deviceChanged);
     layout->addWidget(m_deviceBox);
 
     m_volumeSlider = new QSlider(Qt::Horizontal, this);
     m_volumeSlider->setRange(0, 100);
     m_volumeSlider->setValue(100);
-    connect(m_volumeSlider, SIGNAL(valueChanged(int)), SLOT(sliderChanged(int)));
+    connect(m_volumeSlider, &QSlider::valueChanged, this, &InputTest::sliderChanged);
     layout->addWidget(m_volumeSlider);
 
     m_modeButton = new QPushButton(this);
-    m_modeButton->setText(tr(PUSH_MODE_LABEL));
-    connect(m_modeButton, SIGNAL(clicked()), SLOT(toggleMode()));
+    connect(m_modeButton, &QPushButton::clicked, this, &InputTest::toggleMode);
     layout->addWidget(m_modeButton);
 
     m_suspendResumeButton = new QPushButton(this);
-    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
-    connect(m_suspendResumeButton, SIGNAL(clicked()), SLOT(toggleSuspend()));
+    connect(m_suspendResumeButton, &QPushButton::clicked, this, &InputTest::toggleSuspend);
     layout->addWidget(m_suspendResumeButton);
 
-    window->setLayout(layout.data());
-    layout.take(); // ownership transferred
+    window->setLayout(layout);
 
-    setCentralWidget(window.data());
-    QWidget *const windowPtr = window.take(); // ownership transferred
-    windowPtr->show();
+    setCentralWidget(window);
+    window->show();
 }
 
-void InputTest::initializeAudio()
+void InputTest::initializeAudio(const QAudioDeviceInfo &deviceInfo)
 {
-    m_format.setSampleRate(8000);
-    m_format.setChannelCount(1);
-    m_format.setSampleSize(16);
-    m_format.setSampleType(QAudioFormat::SignedInt);
-    m_format.setByteOrder(QAudioFormat::LittleEndian);
-    m_format.setCodec("audio/pcm");
-
-    QAudioDeviceInfo info(m_device);
-    if (!info.isFormatSupported(m_format)) {
+    QAudioFormat format;
+    format.setSampleRate(8000);
+    format.setChannelCount(1);
+    format.setSampleSize(16);
+    format.setSampleType(QAudioFormat::SignedInt);
+    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setCodec("audio/pcm");
+
+    if (!deviceInfo.isFormatSupported(format)) {
         qWarning() << "Default format not supported - trying to use nearest";
-        m_format = info.nearestFormat(m_format);
+        format = deviceInfo.nearestFormat(format);
     }
 
-    if (m_audioInfo)
-        delete m_audioInfo;
-    m_audioInfo  = new AudioInfo(m_format, this);
-    connect(m_audioInfo, SIGNAL(update()), SLOT(refreshDisplay()));
-
-    createAudioInput();
-}
+    m_audioInfo.reset(new AudioInfo(format));
+    connect(m_audioInfo.data(), &AudioInfo::update, [this]() {
+        m_canvas->setLevel(m_audioInfo->level());
+    });
 
-void InputTest::createAudioInput()
-{
-    m_audioInput = new QAudioInput(m_device, m_format, this);
+    m_audioInput.reset(new QAudioInput(deviceInfo, format));
     qreal initialVolume = QAudio::convertVolume(m_audioInput->volume(),
                                                 QAudio::LinearVolumeScale,
                                                 QAudio::LogarithmicVolumeScale);
     m_volumeSlider->setValue(qRound(initialVolume * 100));
     m_audioInfo->start();
-    m_audioInput->start(m_audioInfo);
-}
-
-void InputTest::readMore()
-{
-    if (!m_audioInput)
-        return;
-    qint64 len = m_audioInput->bytesReady();
-    if (len > BufferSize)
-        len = BufferSize;
-    qint64 l = m_input->read(m_buffer.data(), len);
-    if (l > 0)
-        m_audioInfo->write(m_buffer.constData(), l);
+    toggleMode();
 }
 
 void InputTest::toggleMode()
 {
-    // Change bewteen pull and push modes
     m_audioInput->stop();
+    toggleSuspend();
 
+    // Change bewteen pull and push modes
     if (m_pullMode) {
-        m_modeButton->setText(tr(PULL_MODE_LABEL));
-        m_input = m_audioInput->start();
-        connect(m_input, SIGNAL(readyRead()), SLOT(readMore()));
-        m_pullMode = false;
+        m_modeButton->setText(tr("Enable push mode"));
+        m_audioInput->start(m_audioInfo.data());
     } else {
-        m_modeButton->setText(tr(PUSH_MODE_LABEL));
-        m_pullMode = true;
-        m_audioInput->start(m_audioInfo);
+        m_modeButton->setText(tr("Enable pull mode"));
+        auto io = m_audioInput->start();
+        connect(io, &QIODevice::readyRead,
+            [&, io]() {
+                qint64 len = m_audioInput->bytesReady();
+                const int BufferSize = 4096;
+                if (len > BufferSize)
+                    len = BufferSize;
+
+                QByteArray buffer(len, 0);
+                qint64 l = io->read(buffer.data(), len);
+                if (l > 0)
+                    m_audioInfo->write(buffer.constData(), l);
+            });
     }
 
-    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+    m_pullMode = !m_pullMode;
 }
 
 void InputTest::toggleSuspend()
 {
     // toggle suspend/resume
-    if (m_audioInput->state() == QAudio::SuspendedState) {
+    if (m_audioInput->state() == QAudio::SuspendedState || m_audioInput->state() == QAudio::StoppedState) {
         m_audioInput->resume();
-        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+        m_suspendResumeButton->setText(tr("Suspend recording"));
     } else if (m_audioInput->state() == QAudio::ActiveState) {
         m_audioInput->suspend();
-        m_suspendResumeButton->setText(tr(RESUME_LABEL));
-    } else if (m_audioInput->state() == QAudio::StoppedState) {
-        m_audioInput->resume();
-        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+        m_suspendResumeButton->setText(tr("Resume recording"));
     } else if (m_audioInput->state() == QAudio::IdleState) {
         // no-op
     }
 }
 
-void InputTest::refreshDisplay()
-{
-    m_canvas->setLevel(m_audioInfo->level());
-}
-
 void InputTest::deviceChanged(int index)
 {
     m_audioInfo->stop();
     m_audioInput->stop();
     m_audioInput->disconnect(this);
-    delete m_audioInput;
 
-    m_device = m_deviceBox->itemData(index).value<QAudioDeviceInfo>();
-    initializeAudio();
+    initializeAudio(m_deviceBox->itemData(index).value<QAudioDeviceInfo>());
 }
 
 void InputTest::sliderChanged(int value)
 {
-    if (m_audioInput) {
-        qreal linearVolume =  QAudio::convertVolume(value / qreal(100),
-                                                    QAudio::LogarithmicVolumeScale,
-                                                    QAudio::LinearVolumeScale);
+    qreal linearVolume = QAudio::convertVolume(value / qreal(100),
+                                               QAudio::LogarithmicVolumeScale,
+                                               QAudio::LinearVolumeScale);
 
-        m_audioInput->setVolume(linearVolume);
-    }
+    m_audioInput->setVolume(linearVolume);
 }
diff --git a/examples/multimedia/audioinput/audioinput.h b/examples/multimedia/audioinput/audioinput.h
index b6deb361c..cdfb6e69b 100644
--- a/examples/multimedia/audioinput/audioinput.h
+++ b/examples/multimedia/audioinput/audioinput.h
@@ -50,14 +50,14 @@
 #include <QPushButton>
 #include <QSlider>
 #include <QWidget>
+#include <QScopedPointer>
 
 class AudioInfo : public QIODevice
 {
     Q_OBJECT
 
 public:
-    AudioInfo(const QAudioFormat &format, QObject *parent);
-    ~AudioInfo();
+    AudioInfo(const QAudioFormat &format);
 
     void start();
     void stop();
@@ -69,8 +69,8 @@ public:
 
 private:
     const QAudioFormat m_format;
-    quint32 m_maxAmplitude;
-    qreal m_level; // 0.0 <= m_level <= 1.0
+    quint32 m_maxAmplitude = 0;
+    qreal m_level = 0.0; // 0.0 <= m_level <= 1.0
 
 signals:
     void update();
@@ -82,7 +82,7 @@ class RenderArea : public QWidget
     Q_OBJECT
 
 public:
-    RenderArea(QWidget *parent = 0);
+    explicit RenderArea(QWidget *parent = nullptr);
 
     void setLevel(qreal value);
 
@@ -90,7 +90,7 @@ protected:
     void paintEvent(QPaintEvent *event) override;
 
 private:
-    qreal m_level;
+    qreal m_level = 0;
     QPixmap m_pixmap;
 };
 
@@ -101,16 +101,12 @@ class InputTest : public QMainWindow
 
 public:
     InputTest();
-    ~InputTest();
 
 private:
     void initializeWindow();
-    void initializeAudio();
-    void createAudioInput();
+    void initializeAudio(const QAudioDeviceInfo &deviceInfo);
 
 private slots:
-    void refreshDisplay();
-    void readMore();
     void toggleMode();
     void toggleSuspend();
     void deviceChanged(int index);
@@ -118,19 +114,15 @@ private slots:
 
 private:
     // Owned by layout
-    RenderArea *m_canvas;
-    QPushButton *m_modeButton;
-    QPushButton *m_suspendResumeButton;
-    QComboBox *m_deviceBox;
-    QSlider *m_volumeSlider;
-
-    QAudioDeviceInfo m_device;
-    AudioInfo *m_audioInfo;
-    QAudioFormat m_format;
-    QAudioInput *m_audioInput;
-    QIODevice *m_input;
-    bool m_pullMode;
-    QByteArray m_buffer;
+    RenderArea *m_canvas = nullptr;
+    QPushButton *m_modeButton = nullptr;
+    QPushButton *m_suspendResumeButton = nullptr;
+    QComboBox *m_deviceBox = nullptr;
+    QSlider *m_volumeSlider = nullptr;
+
+    QScopedPointer<AudioInfo> m_audioInfo;
+    QScopedPointer<QAudioInput> m_audioInput;
+    bool m_pullMode = true;
 };
 
 #endif // AUDIOINPUT_H
diff --git a/examples/multimedia/audiooutput/audiooutput.cpp b/examples/multimedia/audiooutput/audiooutput.cpp
index 3e9ec7377..543242a80 100644
--- a/examples/multimedia/audiooutput/audiooutput.cpp
+++ b/examples/multimedia/audiooutput/audiooutput.cpp
@@ -38,6 +38,8 @@
 **
 ****************************************************************************/
 
+#include "audiooutput.h"
+
 #include <QAudioDeviceInfo>
 #include <QAudioOutput>
 #include <QDebug>
@@ -45,36 +47,14 @@
 #include <qmath.h>
 #include <qendian.h>
 
-#include "audiooutput.h"
-
-#define PUSH_MODE_LABEL "Enable push mode"
-#define PULL_MODE_LABEL "Enable pull mode"
-#define SUSPEND_LABEL   "Suspend playback"
-#define RESUME_LABEL    "Resume playback"
-#define VOLUME_LABEL    "Volume:"
-
-const int DurationSeconds = 1;
-const int ToneSampleRateHz = 600;
-const int DataSampleRateHz = 44100;
-const int BufferSize      = 32768;
-
-
-Generator::Generator(const QAudioFormat &format,
-                     qint64 durationUs,
-                     int sampleRate,
-                     QObject *parent)
-    :   QIODevice(parent)
-    ,   m_pos(0)
+Generator::Generator(const QAudioFormat &format
+    , qint64 durationUs
+    , int sampleRate)
 {
     if (format.isValid())
         generateData(format, durationUs, sampleRate);
 }
 
-Generator::~Generator()
-{
-
-}
-
 void Generator::start()
 {
     open(QIODevice::ReadOnly);
@@ -90,10 +70,8 @@ void Generator::generateData(const QAudioFormat &format, qint64 durationUs, int
 {
     const int channelBytes = format.sampleSize() / 8;
     const int sampleBytes = format.channelCount() * channelBytes;
-
     qint64 length = (format.sampleRate() * format.channelCount() * (format.sampleSize() / 8))
-                        * durationUs / 100000;
-
+                        * durationUs / 1000000;
     Q_ASSERT(length % sampleBytes == 0);
     Q_UNUSED(sampleBytes) // suppress warning in release builds
 
@@ -102,32 +80,36 @@ void Generator::generateData(const QAudioFormat &format, qint64 durationUs, int
     int sampleIndex = 0;
 
     while (length) {
-        const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex % format.sampleRate()) / format.sampleRate());
+        // Produces value (-1..1)
+        const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex++ % format.sampleRate()) / format.sampleRate());
         for (int i=0; i<format.channelCount(); ++i) {
-            if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {
-                const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
-                *reinterpret_cast<quint8*>(ptr) = value;
-            } else if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::SignedInt) {
-                const qint8 value = static_cast<qint8>(x * 127);
-                *reinterpret_cast<quint8*>(ptr) = value;
-            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::UnSignedInt) {
-                quint16 value = static_cast<quint16>((1.0 + x) / 2 * 65535);
-                if (format.byteOrder() == QAudioFormat::LittleEndian)
-                    qToLittleEndian<quint16>(value, ptr);
-                else
-                    qToBigEndian<quint16>(value, ptr);
-            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::SignedInt) {
-                qint16 value = static_cast<qint16>(x * 32767);
-                if (format.byteOrder() == QAudioFormat::LittleEndian)
-                    qToLittleEndian<qint16>(value, ptr);
-                else
-                    qToBigEndian<qint16>(value, ptr);
+            if (format.sampleSize() == 8) {
+                if (format.sampleType() == QAudioFormat::UnSignedInt) {
+                    const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
+                    *reinterpret_cast<quint8 *>(ptr) = value;
+                } else if (format.sampleType() == QAudioFormat::SignedInt) {
+                    const qint8 value = static_cast<qint8>(x * 127);
+                    *reinterpret_cast<qint8 *>(ptr) = value;
+                }
+            } else if (format.sampleSize() == 16) {
+                if (format.sampleType() == QAudioFormat::UnSignedInt) {
+                    quint16 value = static_cast<quint16>((1.0 + x) / 2 * 65535);
+                    if (format.byteOrder() == QAudioFormat::LittleEndian)
+                        qToLittleEndian<quint16>(value, ptr);
+                    else
+                        qToBigEndian<quint16>(value, ptr);
+                } else if (format.sampleType() == QAudioFormat::SignedInt) {
+                    qint16 value = static_cast<qint16>(x * 32767);
+                    if (format.byteOrder() == QAudioFormat::LittleEndian)
+                        qToLittleEndian<qint16>(value, ptr);
+                    else
+                        qToBigEndian<qint16>(value, ptr);
+                }
             }
 
             ptr += channelBytes;
             length -= channelBytes;
         }
-        ++sampleIndex;
     }
 }
 
@@ -159,177 +141,149 @@ qint64 Generator::bytesAvailable() const
 }
 
 AudioTest::AudioTest()
-    :   m_pushTimer(new QTimer(this))
-    ,   m_modeButton(0)
-    ,   m_suspendResumeButton(0)
-    ,   m_deviceBox(0)
-    ,   m_device(QAudioDeviceInfo::defaultOutputDevice())
-    ,   m_generator(0)
-    ,   m_audioOutput(0)
-    ,   m_output(0)
-    ,   m_pullMode(true)
-    ,   m_buffer(BufferSize, 0)
+    : m_pushTimer(new QTimer(this))
 {
     initializeWindow();
-    initializeAudio();
+    initializeAudio(QAudioDeviceInfo::defaultOutputDevice());
+}
+
+AudioTest::~AudioTest()
+{
+    m_pushTimer->stop();
 }
 
 void AudioTest::initializeWindow()
 {
-    QScopedPointer<QWidget> window(new QWidget);
-    QScopedPointer<QVBoxLayout> layout(new QVBoxLayout);
+    QWidget *window = new QWidget;
+    QVBoxLayout *layout = new QVBoxLayout;
 
     m_deviceBox = new QComboBox(this);
     const QAudioDeviceInfo &defaultDeviceInfo = QAudioDeviceInfo::defaultOutputDevice();
     m_deviceBox->addItem(defaultDeviceInfo.deviceName(), qVariantFromValue(defaultDeviceInfo));
-    foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioOutput)) {
+    for (auto &deviceInfo: QAudioDeviceInfo::availableDevices(QAudio::AudioOutput)) {
         if (deviceInfo != defaultDeviceInfo)
             m_deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
     }
-    connect(m_deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
+    connect(m_deviceBox, QOverload<int>::of(&QComboBox::activated), this, &AudioTest::deviceChanged);
     layout->addWidget(m_deviceBox);
 
     m_modeButton = new QPushButton(this);
-    m_modeButton->setText(tr(PUSH_MODE_LABEL));
-    connect(m_modeButton, SIGNAL(clicked()), SLOT(toggleMode()));
+    connect(m_modeButton, &QPushButton::clicked, this, &AudioTest::toggleMode);
     layout->addWidget(m_modeButton);
 
     m_suspendResumeButton = new QPushButton(this);
-    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
-    connect(m_suspendResumeButton, SIGNAL(clicked()), SLOT(toggleSuspendResume()));
+    connect(m_suspendResumeButton, &QPushButton::clicked, this, &AudioTest::toggleSuspendResume);
     layout->addWidget(m_suspendResumeButton);
 
     QHBoxLayout *volumeBox = new QHBoxLayout;
     m_volumeLabel = new QLabel;
-    m_volumeLabel->setText(tr(VOLUME_LABEL));
+    m_volumeLabel->setText(tr("Volume:"));
     m_volumeSlider = new QSlider(Qt::Horizontal);
     m_volumeSlider->setMinimum(0);
     m_volumeSlider->setMaximum(100);
     m_volumeSlider->setSingleStep(10);
-    connect(m_volumeSlider, SIGNAL(valueChanged(int)), this, SLOT(volumeChanged(int)));
+    connect(m_volumeSlider, &QSlider::valueChanged, this, &AudioTest::volumeChanged);
     volumeBox->addWidget(m_volumeLabel);
     volumeBox->addWidget(m_volumeSlider);
     layout->addLayout(volumeBox);
 
-    window->setLayout(layout.data());
-    layout.take(); // ownership transferred
+    window->setLayout(layout);
 
-    setCentralWidget(window.data());
-    QWidget *const windowPtr = window.take(); // ownership transferred
-    windowPtr->show();
+    setCentralWidget(window);
+    window->show();
 }
 
-void AudioTest::initializeAudio()
+void AudioTest::initializeAudio(const QAudioDeviceInfo &deviceInfo)
 {
-    connect(m_pushTimer, SIGNAL(timeout()), SLOT(pushTimerExpired()));
-
-    m_format.setSampleRate(DataSampleRateHz);
-    m_format.setChannelCount(1);
-    m_format.setSampleSize(16);
-    m_format.setCodec("audio/pcm");
-    m_format.setByteOrder(QAudioFormat::LittleEndian);
-    m_format.setSampleType(QAudioFormat::SignedInt);
-
-    QAudioDeviceInfo info(m_device);
-    if (!info.isFormatSupported(m_format)) {
+    QAudioFormat format;
+    format.setSampleRate(44100);
+    format.setChannelCount(1);
+    format.setSampleSize(16);
+    format.setCodec("audio/pcm");
+    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setSampleType(QAudioFormat::SignedInt);
+
+    if (!deviceInfo.isFormatSupported(format)) {
         qWarning() << "Default format not supported - trying to use nearest";
-        m_format = info.nearestFormat(m_format);
+        format = deviceInfo.nearestFormat(format);
     }
 
-    if (m_generator)
-        delete m_generator;
-    m_generator = new Generator(m_format, DurationSeconds*1000000, ToneSampleRateHz, this);
-
-    createAudioOutput();
-}
-
-void AudioTest::createAudioOutput()
-{
-    delete m_audioOutput;
-    m_audioOutput = 0;
-    m_audioOutput = new QAudioOutput(m_device, m_format, this);
+    const int durationSeconds = 1;
+    const int toneSampleRateHz = 600;
+    m_generator.reset(new Generator(format, durationSeconds * 1000000, toneSampleRateHz));
+    m_audioOutput.reset(new QAudioOutput(deviceInfo, format));
     m_generator->start();
-    m_audioOutput->start(m_generator);
 
     qreal initialVolume = QAudio::convertVolume(m_audioOutput->volume(),
                                                 QAudio::LinearVolumeScale,
                                                 QAudio::LogarithmicVolumeScale);
     m_volumeSlider->setValue(qRound(initialVolume * 100));
-}
-
-AudioTest::~AudioTest()
-{
-
+    toggleMode();
 }
 
 void AudioTest::deviceChanged(int index)
 {
-    m_pushTimer->stop();
     m_generator->stop();
     m_audioOutput->stop();
     m_audioOutput->disconnect(this);
-    m_device = m_deviceBox->itemData(index).value<QAudioDeviceInfo>();
-    initializeAudio();
+    initializeAudio(m_deviceBox->itemData(index).value<QAudioDeviceInfo>());
 }
 
 void AudioTest::volumeChanged(int value)
 {
-    if (m_audioOutput) {
-        qreal linearVolume =  QAudio::convertVolume(value / qreal(100),
-                                                    QAudio::LogarithmicVolumeScale,
-                                                    QAudio::LinearVolumeScale);
+    qreal linearVolume = QAudio::convertVolume(value / qreal(100),
+                                               QAudio::LogarithmicVolumeScale,
+                                               QAudio::LinearVolumeScale);
 
-        m_audioOutput->setVolume(linearVolume);
-    }
-}
-
-void AudioTest::pushTimerExpired()
-{
-    if (m_audioOutput && m_audioOutput->state() != QAudio::StoppedState) {
-        int chunks = m_audioOutput->bytesFree()/m_audioOutput->periodSize();
-        while (chunks) {
-           const qint64 len = m_generator->read(m_buffer.data(), m_audioOutput->periodSize());
-           if (len)
-               m_output->write(m_buffer.data(), len);
-           if (len != m_audioOutput->periodSize())
-               break;
-           --chunks;
-        }
-    }
+    m_audioOutput->setVolume(linearVolume);
 }
 
 void AudioTest::toggleMode()
 {
     m_pushTimer->stop();
     m_audioOutput->stop();
+    toggleSuspendResume();
 
     if (m_pullMode) {
+        //switch to pull mode (QAudioOutput pulls from Generator as needed)
+        m_modeButton->setText(tr("Enable push mode"));
+        m_audioOutput->start(m_generator.data());
+    } else {
         //switch to push mode (periodically push to QAudioOutput using a timer)
-        m_modeButton->setText(tr(PULL_MODE_LABEL));
-        m_output = m_audioOutput->start();
-        m_pullMode = false;
+        m_modeButton->setText(tr("Enable pull mode"));
+        auto io = m_audioOutput->start();
+        m_pushTimer->disconnect();
+
+        connect(m_pushTimer, &QTimer::timeout, [this, io]() {
+            if (m_audioOutput->state() == QAudio::StoppedState)
+                return;
+
+            QByteArray buffer(32768, 0);
+            int chunks = m_audioOutput->bytesFree() / m_audioOutput->periodSize();
+            while (chunks) {
+               const qint64 len = m_generator->read(buffer.data(), m_audioOutput->periodSize());
+               if (len)
+                   io->write(buffer.data(), len);
+               if (len != m_audioOutput->periodSize())
+                   break;
+               --chunks;
+            }
+        });
+
         m_pushTimer->start(20);
-    } else {
-        //switch to pull mode (QAudioOutput pulls from Generator as needed)
-        m_modeButton->setText(tr(PUSH_MODE_LABEL));
-        m_pullMode = true;
-        m_audioOutput->start(m_generator);
     }
 
-    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+    m_pullMode = !m_pullMode;
 }
 
 void AudioTest::toggleSuspendResume()
 {
-    if (m_audioOutput->state() == QAudio::SuspendedState) {
+    if (m_audioOutput->state() == QAudio::SuspendedState || m_audioOutput->state() == QAudio::StoppedState) {
         m_audioOutput->resume();
-        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+        m_suspendResumeButton->setText(tr("Suspend recording"));
     } else if (m_audioOutput->state() == QAudio::ActiveState) {
         m_audioOutput->suspend();
-        m_suspendResumeButton->setText(tr(RESUME_LABEL));
-    } else if (m_audioOutput->state() == QAudio::StoppedState) {
-        m_audioOutput->resume();
-        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
+        m_suspendResumeButton->setText(tr("Resume playback"));
     } else if (m_audioOutput->state() == QAudio::IdleState) {
         // no-op
     }
diff --git a/examples/multimedia/audiooutput/audiooutput.h b/examples/multimedia/audiooutput/audiooutput.h
index d5c2b4cc2..489624160 100644
--- a/examples/multimedia/audiooutput/audiooutput.h
+++ b/examples/multimedia/audiooutput/audiooutput.h
@@ -53,14 +53,14 @@
 #include <QPushButton>
 #include <QSlider>
 #include <QTimer>
+#include <QScopedPointer>
 
 class Generator : public QIODevice
 {
     Q_OBJECT
 
 public:
-    Generator(const QAudioFormat &format, qint64 durationUs, int sampleRate, QObject *parent);
-    ~Generator();
+    Generator(const QAudioFormat &format, qint64 durationUs, int sampleRate);
 
     void start();
     void stop();
@@ -73,7 +73,7 @@ private:
     void generateData(const QAudioFormat &format, qint64 durationUs, int sampleRate);
 
 private:
-    qint64 m_pos;
+    qint64 m_pos = 0;
     QByteArray m_buffer;
 };
 
@@ -87,30 +87,24 @@ public:
 
 private:
     void initializeWindow();
-    void initializeAudio();
-    void createAudioOutput();
+    void initializeAudio(const QAudioDeviceInfo &deviceInfo);
 
 private:
-    QTimer *m_pushTimer;
+    QTimer *m_pushTimer = nullptr;
 
     // Owned by layout
-    QPushButton *m_modeButton;
-    QPushButton *m_suspendResumeButton;
-    QComboBox *m_deviceBox;
-    QLabel *m_volumeLabel;
-    QSlider *m_volumeSlider;
-
-    QAudioDeviceInfo m_device;
-    Generator *m_generator;
-    QAudioOutput *m_audioOutput;
-    QIODevice *m_output; // not owned
-    QAudioFormat m_format;
-
-    bool m_pullMode;
-    QByteArray m_buffer;
+    QPushButton *m_modeButton = nullptr;
+    QPushButton *m_suspendResumeButton = nullptr;
+    QComboBox *m_deviceBox = nullptr;
+    QLabel *m_volumeLabel = nullptr;
+    QSlider *m_volumeSlider = nullptr;
+
+    QScopedPointer<Generator> m_generator;
+    QScopedPointer<QAudioOutput> m_audioOutput;
+
+    bool m_pullMode = true;
 
 private slots:
-    void pushTimerExpired();
     void toggleMode();
     void toggleSuspendResume();
     void deviceChanged(int index);
diff --git a/examples/multimedia/audiorecorder/qaudiolevel.cpp b/examples/multimedia/audiorecorder/audiolevel.cpp
index 8dd172f30..5df137dd8 100644
--- a/examples/multimedia/audiorecorder/qaudiolevel.cpp
+++ b/examples/multimedia/audiorecorder/audiolevel.cpp
@@ -38,18 +38,17 @@
 **
 ****************************************************************************/
 
-#include "qaudiolevel.h"
+#include "audiolevel.h"
 #include <QPainter>
 
-QAudioLevel::QAudioLevel(QWidget *parent)
+AudioLevel::AudioLevel(QWidget *parent)
   : QWidget(parent)
-  , m_level(0.0)
 {
     setMinimumHeight(15);
     setMaximumHeight(50);
 }
 
-void QAudioLevel::setLevel(qreal level)
+void AudioLevel::setLevel(qreal level)
 {
     if (m_level != level) {
         m_level = level;
@@ -57,7 +56,7 @@ void QAudioLevel::setLevel(qreal level)
     }
 }
 
-void QAudioLevel::paintEvent(QPaintEvent *event)
+void AudioLevel::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event);
 
diff --git a/examples/multimedia/audiorecorder/qaudiolevel.h b/examples/multimedia/audiorecorder/audiolevel.h
index f8e563adc..ba6a76d90 100644
--- a/examples/multimedia/audiorecorder/qaudiolevel.h
+++ b/examples/multimedia/audiorecorder/audiolevel.h
@@ -38,16 +38,16 @@
 **
 ****************************************************************************/
 
-#ifndef QAUDIOLEVEL_H
-#define QAUDIOLEVEL_H
+#ifndef AUDIOLEVEL_H
+#define AUDIOLEVEL_H
 
 #include <QWidget>
 
-class QAudioLevel : public QWidget
+class AudioLevel : public QWidget
 {
     Q_OBJECT
 public:
-    explicit QAudioLevel(QWidget *parent = 0);
+    explicit AudioLevel(QWidget *parent = 0);
 
     // Using [0; 1.0] range
     void setLevel(qreal level);
@@ -56,7 +56,7 @@ protected:
     void paintEvent(QPaintEvent *event) override;
 
 private:
-    qreal m_level;
+    qreal m_level = 0.0;
 };
 
 #endif // QAUDIOLEVEL_H
diff --git a/examples/multimedia/audiorecorder/audiorecorder.cpp b/examples/multimedia/audiorecorder/audiorecorder.cpp
index 2fb41584e..9495085c8 100644
--- a/examples/multimedia/audiorecorder/audiorecorder.cpp
+++ b/examples/multimedia/audiorecorder/audiorecorder.cpp
@@ -38,57 +38,55 @@
 **
 ****************************************************************************/
 
+#include "audiorecorder.h"
+#include "audiolevel.h"
+
+#include "ui_audiorecorder.h"
+
 #include <QAudioProbe>
 #include <QAudioRecorder>
 #include <QDir>
 #include <QFileDialog>
 #include <QMediaRecorder>
 
-#include "audiorecorder.h"
-#include "qaudiolevel.h"
-
-#include "ui_audiorecorder.h"
-
 static qreal getPeakValue(const QAudioFormat &format);
 static QVector<qreal> getBufferLevels(const QAudioBuffer &buffer);
 
 template <class T>
 static QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels);
 
-AudioRecorder::AudioRecorder(QWidget *parent) :
-    QMainWindow(parent),
-    ui(new Ui::AudioRecorder),
-    outputLocationSet(false)
+AudioRecorder::AudioRecorder()
+    : ui(new Ui::AudioRecorder)
 {
     ui->setupUi(this);
 
-    audioRecorder = new QAudioRecorder(this);
-    probe = new QAudioProbe;
-    connect(probe, SIGNAL(audioBufferProbed(QAudioBuffer)),
-            this, SLOT(processBuffer(QAudioBuffer)));
-    probe->setSource(audioRecorder);
+    m_audioRecorder = new QAudioRecorder(this);
+    m_probe = new QAudioProbe(this);
+    connect(m_probe, &QAudioProbe::audioBufferProbed,
+            this, &AudioRecorder::processBuffer);
+    m_probe->setSource(m_audioRecorder);
 
     //audio devices
     ui->audioDeviceBox->addItem(tr("Default"), QVariant(QString()));
-    foreach (const QString &device, audioRecorder->audioInputs()) {
+    for (auto &device: m_audioRecorder->audioInputs()) {
         ui->audioDeviceBox->addItem(device, QVariant(device));
     }
 
     //audio codecs
     ui->audioCodecBox->addItem(tr("Default"), QVariant(QString()));
-    foreach (const QString &codecName, audioRecorder->supportedAudioCodecs()) {
+    for (auto &codecName: m_audioRecorder->supportedAudioCodecs()) {
         ui->audioCodecBox->addItem(codecName, QVariant(codecName));
     }
 
     //containers
     ui->containerBox->addItem(tr("Default"), QVariant(QString()));
-    foreach (const QString &containerName, audioRecorder->supportedContainers()) {
+    for (auto &containerName: m_audioRecorder->supportedContainers()) {
         ui->containerBox->addItem(containerName, QVariant(containerName));
     }
 
     //sample rate
     ui->sampleRateBox->addItem(tr("Default"), QVariant(0));
-    foreach (int sampleRate, audioRecorder->supportedAudioSampleRates()) {
+    for (int sampleRate: m_audioRecorder->supportedAudioSampleRates()) {
         ui->sampleRateBox->addItem(QString::number(sampleRate), QVariant(
                 sampleRate));
     }
@@ -110,25 +108,16 @@ AudioRecorder::AudioRecorder(QWidget *parent) :
     ui->bitrateBox->addItem(QStringLiteral("96000"), QVariant(96000));
     ui->bitrateBox->addItem(QStringLiteral("128000"), QVariant(128000));
 
-    connect(audioRecorder, SIGNAL(durationChanged(qint64)), this,
-            SLOT(updateProgress(qint64)));
-    connect(audioRecorder, SIGNAL(statusChanged(QMediaRecorder::Status)), this,
-            SLOT(updateStatus(QMediaRecorder::Status)));
-    connect(audioRecorder, SIGNAL(stateChanged(QMediaRecorder::State)),
-            this, SLOT(onStateChanged(QMediaRecorder::State)));
-    connect(audioRecorder, SIGNAL(error(QMediaRecorder::Error)), this,
-            SLOT(displayErrorMessage()));
-}
-
-AudioRecorder::~AudioRecorder()
-{
-    delete audioRecorder;
-    delete probe;
+    connect(m_audioRecorder, &QAudioRecorder::durationChanged, this, &AudioRecorder::updateProgress);
+    connect(m_audioRecorder, &QAudioRecorder::statusChanged, this, &AudioRecorder::updateStatus);
+    connect(m_audioRecorder, &QAudioRecorder::stateChanged, this, &AudioRecorder::onStateChanged);
+    connect(m_audioRecorder, QOverload<QMediaRecorder::Error>::of(&QAudioRecorder::error), this,
+            &AudioRecorder::displayErrorMessage);
 }
 
 void AudioRecorder::updateProgress(qint64 duration)
 {
-    if (audioRecorder->error() != QMediaRecorder::NoError || duration < 2000)
+    if (m_audioRecorder->error() != QMediaRecorder::NoError || duration < 2000)
         return;
 
     ui->statusbar->showMessage(tr("Recorded %1 sec").arg(duration / 1000));
@@ -140,7 +129,7 @@ void AudioRecorder::updateStatus(QMediaRecorder::Status status)
 
     switch (status) {
     case QMediaRecorder::RecordingStatus:
-        statusMessage = tr("Recording to %1").arg(audioRecorder->actualLocation().toString());
+        statusMessage = tr("Recording to %1").arg(m_audioRecorder->actualLocation().toString());
         break;
     case QMediaRecorder::PausedStatus:
         clearAudioLevels();
@@ -154,7 +143,7 @@ void AudioRecorder::updateStatus(QMediaRecorder::Status status)
         break;
     }
 
-    if (audioRecorder->error() == QMediaRecorder::NoError)
+    if (m_audioRecorder->error() == QMediaRecorder::NoError)
         ui->statusbar->showMessage(statusMessage);
 }
 
@@ -175,7 +164,7 @@ void AudioRecorder::onStateChanged(QMediaRecorder::State state)
         break;
     }
 
-    ui->pauseButton->setEnabled(audioRecorder->state() != QMediaRecorder::StoppedState);
+    ui->pauseButton->setEnabled(m_audioRecorder->state() != QMediaRecorder::StoppedState);
 }
 
 static QVariant boxValue(const QComboBox *box)
@@ -189,8 +178,8 @@ static QVariant boxValue(const QComboBox *box)
 
 void AudioRecorder::toggleRecord()
 {
-    if (audioRecorder->state() == QMediaRecorder::StoppedState) {
-        audioRecorder->setAudioInput(boxValue(ui->audioDeviceBox).toString());
+    if (m_audioRecorder->state() == QMediaRecorder::StoppedState) {
+        m_audioRecorder->setAudioInput(boxValue(ui->audioDeviceBox).toString());
 
         QAudioEncoderSettings settings;
         settings.setCodec(boxValue(ui->audioCodecBox).toString());
@@ -204,38 +193,38 @@ void AudioRecorder::toggleRecord()
 
         QString container = boxValue(ui->containerBox).toString();
 
-        audioRecorder->setEncodingSettings(settings, QVideoEncoderSettings(), container);
-        audioRecorder->record();
+        m_audioRecorder->setEncodingSettings(settings, QVideoEncoderSettings(), container);
+        m_audioRecorder->record();
     }
     else {
-        audioRecorder->stop();
+        m_audioRecorder->stop();
     }
 }
 
 void AudioRecorder::togglePause()
 {
-    if (audioRecorder->state() != QMediaRecorder::PausedState)
-        audioRecorder->pause();
+    if (m_audioRecorder->state() != QMediaRecorder::PausedState)
+        m_audioRecorder->pause();
     else
-        audioRecorder->record();
+        m_audioRecorder->record();
 }
 
 void AudioRecorder::setOutputLocation()
 {
     QString fileName = QFileDialog::getSaveFileName();
-    audioRecorder->setOutputLocation(QUrl::fromLocalFile(fileName));
-    outputLocationSet = true;
+    m_audioRecorder->setOutputLocation(QUrl::fromLocalFile(fileName));
+    m_outputLocationSet = true;
 }
 
 void AudioRecorder::displayErrorMessage()
 {
-    ui->statusbar->showMessage(audioRecorder->errorString());
+    ui->statusbar->showMessage(m_audioRecorder->errorString());
 }
 
 void AudioRecorder::clearAudioLevels()
 {
-    for (int i = 0; i < audioLevels.size(); ++i)
-        audioLevels.at(i)->setLevel(0);
+    for (int i = 0; i < m_audioLevels.size(); ++i)
+        m_audioLevels.at(i)->setLevel(0);
 }
 
 // This function returns the maximum possible sample value for a given audio format
@@ -346,17 +335,17 @@ QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels)
 
 void AudioRecorder::processBuffer(const QAudioBuffer& buffer)
 {
-    if (audioLevels.count() != buffer.format().channelCount()) {
-        qDeleteAll(audioLevels);
-        audioLevels.clear();
+    if (m_audioLevels.count() != buffer.format().channelCount()) {
+        qDeleteAll(m_audioLevels);
+        m_audioLevels.clear();
         for (int i = 0; i < buffer.format().channelCount(); ++i) {
-            QAudioLevel *level = new QAudioLevel(ui->centralwidget);
-            audioLevels.append(level);
+            AudioLevel *level = new AudioLevel(ui->centralwidget);
+            m_audioLevels.append(level);
             ui->levelsLayout->addWidget(level);
         }
     }
 
     QVector<qreal> levels = getBufferLevels(buffer);
     for (int i = 0; i < levels.count(); ++i)
-        audioLevels.at(i)->setLevel(levels.at(i));
+        m_audioLevels.at(i)->setLevel(levels.at(i));
 }
diff --git a/examples/multimedia/audiorecorder/audiorecorder.h b/examples/multimedia/audiorecorder/audiorecorder.h
index 7c8040299..9df86cac4 100644
--- a/examples/multimedia/audiorecorder/audiorecorder.h
+++ b/examples/multimedia/audiorecorder/audiorecorder.h
@@ -52,15 +52,14 @@ class QAudioProbe;
 class QAudioBuffer;
 QT_END_NAMESPACE
 
-class QAudioLevel;
+class AudioLevel;
 
 class AudioRecorder : public QMainWindow
 {
     Q_OBJECT
 
 public:
-    AudioRecorder(QWidget *parent = 0);
-    ~AudioRecorder();
+    AudioRecorder();
 
 public slots:
     void processBuffer(const QAudioBuffer&);
@@ -78,12 +77,12 @@ private slots:
 private:
     void clearAudioLevels();
 
-    Ui::AudioRecorder *ui;
+    Ui::AudioRecorder *ui = nullptr;
 
-    QAudioRecorder *audioRecorder;
-    QAudioProbe *probe;
-    QList<QAudioLevel*> audioLevels;
-    bool outputLocationSet;
+    QAudioRecorder *m_audioRecorder = nullptr;
+    QAudioProbe *m_probe = nullptr;
+    QList<AudioLevel*> m_audioLevels;
+    bool m_outputLocationSet = false;
 
 };
 
diff --git a/examples/multimedia/audiorecorder/audiorecorder.pro b/examples/multimedia/audiorecorder/audiorecorder.pro
index 593c30096..65eecc7b4 100644
--- a/examples/multimedia/audiorecorder/audiorecorder.pro
+++ b/examples/multimedia/audiorecorder/audiorecorder.pro
@@ -7,12 +7,12 @@ win32:INCLUDEPATH += $$PWD
 
 HEADERS = \
     audiorecorder.h \
-    qaudiolevel.h
+    audiolevel.h
 
 SOURCES = \
     main.cpp \
     audiorecorder.cpp \
-    qaudiolevel.cpp
+    audiolevel.cpp
 
 FORMS += audiorecorder.ui
 
diff --git a/examples/multimedia/declarative-radio/Button.qml b/examples/multimedia/declarative-radio/Button.qml
new file mode 100644
index 000000000..c01c9d388
--- /dev/null
+++ b/examples/multimedia/declarative-radio/Button.qml
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+Rectangle {
+    id: button
+    border.color: "black"
+    border.width: 1
+    radius: 5
+
+    property string text
+    signal clicked
+
+    width: d.buttonWidth
+    height: d.buttonHeight
+
+    anchors {
+        margins: root.margins
+        top: parent.top
+    }
+
+    Text {
+        anchors.fill: parent
+        verticalAlignment: Text.AlignVCenter
+        horizontalAlignment: Text.AlignHCenter
+        text: button.text
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        onClicked: button.clicked();
+    }
+}
diff --git a/examples/multimedia/declarative-radio/declarative-radio.qrc b/examples/multimedia/declarative-radio/declarative-radio.qrc
index ed01a64f6..0f7859d78 100644
--- a/examples/multimedia/declarative-radio/declarative-radio.qrc
+++ b/examples/multimedia/declarative-radio/declarative-radio.qrc
@@ -1,6 +1,7 @@
 <!DOCTYPE RCC><RCC version="1.0">
 <qresource>
 <file>view.qml</file>
+<file>Button.qml</file>
 </qresource>
 </RCC>
 
diff --git a/examples/multimedia/declarative-radio/main.cpp b/examples/multimedia/declarative-radio/main.cpp
index 0dfd4d2c9..6d7771e60 100644
--- a/examples/multimedia/declarative-radio/main.cpp
+++ b/examples/multimedia/declarative-radio/main.cpp
@@ -50,7 +50,8 @@ int main(int argc, char ** argv)
 
     QQuickView view;
 
-    view.setSource(QUrl("qrc:view.qml"));
+    view.setSource(QUrl("qrc:/view.qml"));
+    view.setMinimumSize(QSize(400, 100));
     view.show();
 
     return app.exec();
diff --git a/examples/multimedia/declarative-radio/view.qml b/examples/multimedia/declarative-radio/view.qml
index 7ab35260a..4bc3fbc4a 100644
--- a/examples/multimedia/declarative-radio/view.qml
+++ b/examples/multimedia/declarative-radio/view.qml
@@ -1,6 +1,6 @@
 /****************************************************************************
  **
- ** Copyright (C) 2015 The Qt Company Ltd.
+ ** Copyright (C) 2017 The Qt Company Ltd.
  ** Contact: http://www.qt.io/licensing/
  **
  ** This file is part of the examples of the Qt Toolkit.
@@ -42,7 +42,16 @@ import QtQuick 2.0
 import QtMultimedia 5.0
 
 Rectangle {
-    width: 400; height: 300;
+    anchors.fill: parent
+    id: root
+    property int margins: 5
+    property int spacing: 10
+
+    QtObject {
+        id: d
+        property int buttonHeight: root.height > root.width ? root.width / 3 : root.height / 3
+        property int buttonWidth: (root.width - spacing * 4) / 4
+    }
 
     Radio {
         id: radio
@@ -51,25 +60,30 @@ Rectangle {
 
     Column {
         anchors.fill: parent
-        anchors.margins: 5
-        spacing: 5
+        anchors.margins: root.margins
 
-        Row {
+        Rectangle {
+            color: root.color
+            width: parent.width
+            height: root.height - d.buttonHeight - 40
 
             Text {
                 id: freq
-
-                width: 150
-                height: 200
-
                 verticalAlignment: Text.AlignVCenter
                 text: "" + radio.frequency / 1000 + " kHz"
+                anchors {
+                    bottom: parent.bottom
+                    margins: root.margins
+                }
             }
             Text {
                 id: sig
+                anchors {
+                    bottom: parent.bottom
+                    right: parent.right
+                    margins: root.margins
 
-                width: 200
-                height: 200
+                }
 
                 verticalAlignment: Text.AlignVCenter
                 text: (radio.availability == Radio.Available ? "No Signal " : "No Radio Found")
@@ -80,112 +94,40 @@ Rectangle {
             spacing: 5
 
             Rectangle {
-                width: 350
-                height: 10
-
+                width: root.width - 10
+                height: 20
                 color: "black"
 
                 Rectangle {
                     width: 5
-                    height: 10
+                    height: 20
                     color: "red"
 
                     y: 0
                     x: (parent.width - 5) * ((radio.frequency - radio.minimumFrequency) / (radio.maximumFrequency -
                     radio.minimumFrequency))
-
                 }
             }
         }
-
-
         Row {
-            spacing: 5
-
-            Rectangle {
-                id: scanDownButton
-                border.color: "black"
-                border.width: 1
-                radius: 2
-
-                width: 90
-                height: 40
-
-                Text {
-                    anchors.fill: parent
-                    verticalAlignment: Text.AlignVCenter
-                    horizontalAlignment: Text.AlignHCenter
-                    text: "Scan Down"
-                }
-
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: radio.scanDown();
-                }
+            spacing: root.spacing
+            Button {
+                text: "Scan Down"
+                onClicked: radio.scanDown()
             }
-            Rectangle {
-                id: freqDownButton
-                border.color: "black"
-                border.width: 1
-                radius: 2
-
-                width: 90
-                height: 40
-
-                Text {
-                    anchors.fill: parent
-                    verticalAlignment: Text.AlignVCenter
-                    horizontalAlignment: Text.AlignHCenter
-                    text: "Freq Down"
-                }
-
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: radio.tuneDown();
-                }
+            Button {
+                text: "Freq Down"
+                onClicked: radio.tuneDown()
             }
-            Rectangle {
-                id: freqUpButton
-                border.color: "black"
-                border.width: 1
-                radius: 2
-
-                width: 90
-                height: 40
-
-                Text {
-                    anchors.fill: parent
-                    verticalAlignment: Text.AlignVCenter
-                    horizontalAlignment: Text.AlignHCenter
-                    text: "Freq Up"
-                }
-
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: radio.tuneUp();
-                }
+            Button {
+                text: "Freq Up"
+                onClicked: radio.tuneUp()
             }
-            Rectangle {
-                id: scanUpButton
-                border.color: "black"
-                border.width: 1
-                radius: 2
-
-                width: 90
-                height: 40
-
-                Text {
-                    anchors.fill: parent
-                    verticalAlignment: Text.AlignVCenter
-                    horizontalAlignment: Text.AlignHCenter
-                    text: "Scan Up"
-                }
-
-                MouseArea {
-                    anchors.fill: parent
-                    onClicked: radio.scanUp();
-                }
+            Button {
+                text: "Scan Up"
+                onClicked: radio.scanUp()
             }
         }
     }
 }
+
diff --git a/examples/multimediawidgets/camera/camera.cpp b/examples/multimediawidgets/camera/camera.cpp
index 7a9955b01..298285e64 100644
--- a/examples/multimediawidgets/camera/camera.cpp
+++ b/examples/multimediawidgets/camera/camera.cpp
@@ -56,9 +56,7 @@
 
 Q_DECLARE_METATYPE(QCameraInfo)
 
-Camera::Camera(QWidget *parent) :
-    QMainWindow(parent),
-    ui(new Ui::Camera)
+Camera::Camera() : ui(new Ui::Camera)
 {
     ui->setupUi(this);
 
@@ -83,57 +81,46 @@ Camera::Camera(QWidget *parent) :
     setCamera(QCameraInfo::defaultCamera());
 }
 
-Camera::~Camera()
-{
-    delete mediaRecorder;
-    delete imageCapture;
-    delete camera;
-}
-
 void Camera::setCamera(const QCameraInfo &cameraInfo)
 {
-    delete imageCapture;
-    delete mediaRecorder;
-    delete camera;
-
-    camera = new QCamera(cameraInfo);
+    m_camera.reset(new QCamera(cameraInfo));
 
-    connect(camera, &QCamera::stateChanged, this, &Camera::updateCameraState);
-    connect(camera, QOverload<QCamera::Error>::of(&QCamera::error), this, &Camera::displayCameraError);
+    connect(m_camera.data(), &QCamera::stateChanged, this, &Camera::updateCameraState);
+    connect(m_camera.data(), QOverload<QCamera::Error>::of(&QCamera::error), this, &Camera::displayCameraError);
 
-    mediaRecorder = new QMediaRecorder(camera);
-    connect(mediaRecorder, &QMediaRecorder::stateChanged, this, &Camera::updateRecorderState);
+    m_mediaRecorder.reset(new QMediaRecorder(m_camera.data()));
+    connect(m_mediaRecorder.data(), &QMediaRecorder::stateChanged, this, &Camera::updateRecorderState);
 
-    imageCapture = new QCameraImageCapture(camera);
+    m_imageCapture.reset(new QCameraImageCapture(m_camera.data()));
 
-    connect(mediaRecorder, &QMediaRecorder::durationChanged, this, &Camera::updateRecordTime);
-    connect(mediaRecorder, QOverload<QMediaRecorder::Error>::of(&QMediaRecorder::error),
+    connect(m_mediaRecorder.data(), &QMediaRecorder::durationChanged, this, &Camera::updateRecordTime);
+    connect(m_mediaRecorder.data(), QOverload<QMediaRecorder::Error>::of(&QMediaRecorder::error),
             this, &Camera::displayRecorderError);
 
-    mediaRecorder->setMetaData(QMediaMetaData::Title, QVariant(QLatin1String("Test Title")));
+    m_mediaRecorder->setMetaData(QMediaMetaData::Title, QVariant(QLatin1String("Test Title")));
 
     connect(ui->exposureCompensation, &QAbstractSlider::valueChanged, this, &Camera::setExposureCompensation);
 
-    camera->setViewfinder(ui->viewfinder);
+    m_camera->setViewfinder(ui->viewfinder);
 
-    updateCameraState(camera->state());
-    updateLockStatus(camera->lockStatus(), QCamera::UserRequest);
-    updateRecorderState(mediaRecorder->state());
+    updateCameraState(m_camera->state());
+    updateLockStatus(m_camera->lockStatus(), QCamera::UserRequest);
+    updateRecorderState(m_mediaRecorder->state());
 
-    connect(imageCapture, &QCameraImageCapture::readyForCaptureChanged, this, &Camera::readyForCapture);
-    connect(imageCapture, &QCameraImageCapture::imageCaptured, this, &Camera::processCapturedImage);
-    connect(imageCapture, &QCameraImageCapture::imageSaved, this, &Camera::imageSaved);
-    connect(imageCapture, QOverload<int, QCameraImageCapture::Error, const QString &>::of(&QCameraImageCapture::error),
+    connect(m_imageCapture.data(), &QCameraImageCapture::readyForCaptureChanged, this, &Camera::readyForCapture);
+    connect(m_imageCapture.data(), &QCameraImageCapture::imageCaptured, this, &Camera::processCapturedImage);
+    connect(m_imageCapture.data(), &QCameraImageCapture::imageSaved, this, &Camera::imageSaved);
+    connect(m_imageCapture.data(), QOverload<int, QCameraImageCapture::Error, const QString &>::of(&QCameraImageCapture::error),
             this, &Camera::displayCaptureError);
 
-    connect(camera, QOverload<QCamera::LockStatus, QCamera::LockChangeReason>::of(&QCamera::lockStatusChanged),
+    connect(m_camera.data(), QOverload<QCamera::LockStatus, QCamera::LockChangeReason>::of(&QCamera::lockStatusChanged),
             this, &Camera::updateLockStatus);
 
-    ui->captureWidget->setTabEnabled(0, (camera->isCaptureModeSupported(QCamera::CaptureStillImage)));
-    ui->captureWidget->setTabEnabled(1, (camera->isCaptureModeSupported(QCamera::CaptureVideo)));
+    ui->captureWidget->setTabEnabled(0, (m_camera->isCaptureModeSupported(QCamera::CaptureStillImage)));
+    ui->captureWidget->setTabEnabled(1, (m_camera->isCaptureModeSupported(QCamera::CaptureVideo)));
 
     updateCaptureMode();
-    camera->start();
+    m_camera->start();
 }
 
 void Camera::keyPressEvent(QKeyEvent * event)
@@ -144,14 +131,14 @@ void Camera::keyPressEvent(QKeyEvent * event)
     switch (event->key()) {
     case Qt::Key_CameraFocus:
         displayViewfinder();
-        camera->searchAndLock();
+        m_camera->searchAndLock();
         event->accept();
         break;
     case Qt::Key_Camera:
-        if (camera->captureMode() == QCamera::CaptureStillImage) {
+        if (m_camera->captureMode() == QCamera::CaptureStillImage) {
             takeImage();
         } else {
-            if (mediaRecorder->state() == QMediaRecorder::RecordingState)
+            if (m_mediaRecorder->state() == QMediaRecorder::RecordingState)
                 stop();
             else
                 record();
@@ -170,7 +157,7 @@ void Camera::keyReleaseEvent(QKeyEvent *event)
 
     switch (event->key()) {
     case Qt::Key_CameraFocus:
-        camera->unlock();
+        m_camera->unlock();
         break;
     default:
         QMainWindow::keyReleaseEvent(event);
@@ -179,7 +166,7 @@ void Camera::keyReleaseEvent(QKeyEvent *event)
 
 void Camera::updateRecordTime()
 {
-    QString str = QString("Recorded %1 sec").arg(mediaRecorder->duration()/1000);
+    QString str = QString("Recorded %1 sec").arg(m_mediaRecorder->duration()/1000);
     ui->statusbar->showMessage(str);
 }
 
@@ -199,7 +186,7 @@ void Camera::processCapturedImage(int requestId, const QImage& img)
 
 void Camera::configureCaptureSettings()
 {
-    switch (camera->captureMode()) {
+    switch (m_camera->captureMode()) {
     case QCamera::CaptureStillImage:
         configureImageSettings();
         break;
@@ -213,68 +200,68 @@ void Camera::configureCaptureSettings()
 
 void Camera::configureVideoSettings()
 {
-    VideoSettings settingsDialog(mediaRecorder);
+    VideoSettings settingsDialog(m_mediaRecorder.data());
     settingsDialog.setWindowFlags(settingsDialog.windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
-    settingsDialog.setAudioSettings(audioSettings);
-    settingsDialog.setVideoSettings(videoSettings);
-    settingsDialog.setFormat(videoContainerFormat);
+    settingsDialog.setAudioSettings(m_audioSettings);
+    settingsDialog.setVideoSettings(m_videoSettings);
+    settingsDialog.setFormat(m_videoContainerFormat);
 
     if (settingsDialog.exec()) {
-        audioSettings = settingsDialog.audioSettings();
-        videoSettings = settingsDialog.videoSettings();
-        videoContainerFormat = settingsDialog.format();
-
-        mediaRecorder->setEncodingSettings(
-                    audioSettings,
-                    videoSettings,
-                    videoContainerFormat);
+        m_audioSettings = settingsDialog.audioSettings();
+        m_videoSettings = settingsDialog.videoSettings();
+        m_videoContainerFormat = settingsDialog.format();
+
+        m_mediaRecorder->setEncodingSettings(
+                    m_audioSettings,
+                    m_videoSettings,
+                    m_videoContainerFormat);
     }
 }
 
 void Camera::configureImageSettings()
 {
-    ImageSettings settingsDialog(imageCapture);
+    ImageSettings settingsDialog(m_imageCapture.data());
     settingsDialog.setWindowFlags(settingsDialog.windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
-    settingsDialog.setImageSettings(imageSettings);
+    settingsDialog.setImageSettings(m_imageSettings);
 
     if (settingsDialog.exec()) {
-        imageSettings = settingsDialog.imageSettings();
-        imageCapture->setEncodingSettings(imageSettings);
+        m_imageSettings = settingsDialog.imageSettings();
+        m_imageCapture->setEncodingSettings(m_imageSettings);
     }
 }
 
 void Camera::record()
 {
-    mediaRecorder->record();
+    m_mediaRecorder->record();
     updateRecordTime();
 }
 
 void Camera::pause()
 {
-    mediaRecorder->pause();
+    m_mediaRecorder->pause();
 }
 
 void Camera::stop()
 {
-    mediaRecorder->stop();
+    m_mediaRecorder->stop();
 }
 
 void Camera::setMuted(bool muted)
 {
-    mediaRecorder->setMuted(muted);
+    m_mediaRecorder->setMuted(muted);
 }
 
 void Camera::toggleLock()
 {
-    switch (camera->lockStatus()) {
+    switch (m_camera->lockStatus()) {
     case QCamera::Searching:
     case QCamera::Locked:
-        camera->unlock();
+        m_camera->unlock();
         break;
     case QCamera::Unlocked:
-        camera->searchAndLock();
+        m_camera->searchAndLock();
     }
 }
 
@@ -307,8 +294,8 @@ void Camera::updateLockStatus(QCamera::LockStatus status, QCamera::LockChangeRea
 
 void Camera::takeImage()
 {
-    isCapturingImage = true;
-    imageCapture->capture();
+    m_isCapturingImage = true;
+    m_imageCapture->capture();
 }
 
 void Camera::displayCaptureError(int id, const QCameraImageCapture::Error error, const QString &errorString)
@@ -316,17 +303,17 @@ void Camera::displayCaptureError(int id, const QCameraImageCapture::Error error,
     Q_UNUSED(id);
     Q_UNUSED(error);
     QMessageBox::warning(this, tr("Image Capture Error"), errorString);
-    isCapturingImage = false;
+    m_isCapturingImage = false;
 }
 
 void Camera::startCamera()
 {
-    camera->start();
+    m_camera->start();
 }
 
 void Camera::stopCamera()
 {
-    camera->stop();
+    m_camera->stop();
 }
 
 void Camera::updateCaptureMode()
@@ -334,8 +321,8 @@ void Camera::updateCaptureMode()
     int tabIndex = ui->captureWidget->currentIndex();
     QCamera::CaptureModes captureMode = tabIndex == 0 ? QCamera::CaptureStillImage : QCamera::CaptureVideo;
 
-    if (camera->isCaptureModeSupported(captureMode))
-        camera->setCaptureMode(captureMode);
+    if (m_camera->isCaptureModeSupported(captureMode))
+        m_camera->setCaptureMode(captureMode);
 }
 
 void Camera::updateCameraState(QCamera::State state)
@@ -379,17 +366,17 @@ void Camera::updateRecorderState(QMediaRecorder::State state)
 
 void Camera::setExposureCompensation(int index)
 {
-    camera->exposure()->setExposureCompensation(index*0.5);
+    m_camera->exposure()->setExposureCompensation(index*0.5);
 }
 
 void Camera::displayRecorderError()
 {
-    QMessageBox::warning(this, tr("Capture Error"), mediaRecorder->errorString());
+    QMessageBox::warning(this, tr("Capture Error"), m_mediaRecorder->errorString());
 }
 
 void Camera::displayCameraError()
 {
-    QMessageBox::warning(this, tr("Camera Error"), camera->errorString());
+    QMessageBox::warning(this, tr("Camera Error"), m_camera->errorString());
 }
 
 void Camera::updateCameraDevice(QAction *action)
@@ -417,16 +404,16 @@ void Camera::imageSaved(int id, const QString &fileName)
     Q_UNUSED(id);
     ui->statusbar->showMessage(tr("Captured \"%1\"").arg(QDir::toNativeSeparators(fileName)));
 
-    isCapturingImage = false;
-    if (applicationExiting)
+    m_isCapturingImage = false;
+    if (m_applicationExiting)
         close();
 }
 
 void Camera::closeEvent(QCloseEvent *event)
 {
-    if (isCapturingImage) {
+    if (m_isCapturingImage) {
         setEnabled(false);
-        applicationExiting = true;
+        m_applicationExiting = true;
         event->ignore();
     } else {
         event->accept();
diff --git a/examples/multimediawidgets/camera/camera.h b/examples/multimediawidgets/camera/camera.h
index 45a73176c..4e5829cd5 100644
--- a/examples/multimediawidgets/camera/camera.h
+++ b/examples/multimediawidgets/camera/camera.h
@@ -44,6 +44,7 @@
 #include <QCamera>
 #include <QCameraImageCapture>
 #include <QMediaRecorder>
+#include <QScopedPointer>
 
 #include <QMainWindow>
 
@@ -56,8 +57,7 @@ class Camera : public QMainWindow
     Q_OBJECT
 
 public:
-    explicit Camera(QWidget *parent = nullptr);
-    ~Camera();
+    Camera();
 
 private slots:
     void setCamera(const QCameraInfo &cameraInfo);
@@ -107,16 +107,16 @@ protected:
 private:
     Ui::Camera *ui;
 
-    QCamera *camera = nullptr;
-    QCameraImageCapture *imageCapture = nullptr;
-    QMediaRecorder* mediaRecorder = nullptr;
+    QScopedPointer<QCamera> m_camera;
+    QScopedPointer<QCameraImageCapture> m_imageCapture;
+    QScopedPointer<QMediaRecorder> m_mediaRecorder;
 
-    QImageEncoderSettings imageSettings;
-    QAudioEncoderSettings audioSettings;
-    QVideoEncoderSettings videoSettings;
-    QString videoContainerFormat;
-    bool isCapturingImage = false;
-    bool applicationExiting = false;
+    QImageEncoderSettings m_imageSettings;
+    QAudioEncoderSettings m_audioSettings;
+    QVideoEncoderSettings m_videoSettings;
+    QString m_videoContainerFormat;
+    bool m_isCapturingImage = false;
+    bool m_applicationExiting = false;
 };
 
 #endif
diff --git a/examples/multimediawidgets/player/histogramwidget.cpp b/examples/multimediawidgets/player/histogramwidget.cpp
index 71c243e23..c4019b5f8 100644
--- a/examples/multimediawidgets/player/histogramwidget.cpp
+++ b/examples/multimediawidgets/player/histogramwidget.cpp
@@ -49,7 +49,7 @@ class QAudioLevel : public QWidget
 {
     Q_OBJECT
 public:
-    explicit QAudioLevel(QWidget *parent = 0);
+    explicit QAudioLevel(QWidget *parent = nullptr);
 
     // Using [0; 1.0] range
     void setLevel(qreal level);
@@ -58,12 +58,11 @@ protected:
     void paintEvent(QPaintEvent *event);
 
 private:
-    qreal m_level;
+    qreal m_level = 0;
 };
 
 QAudioLevel::QAudioLevel(QWidget *parent)
-  : QWidget(parent)
-  , m_level(0.0)
+    : QWidget(parent)
 {
     setMinimumHeight(15);
     setMaximumHeight(50);
@@ -91,12 +90,10 @@ void QAudioLevel::paintEvent(QPaintEvent *event)
 
 HistogramWidget::HistogramWidget(QWidget *parent)
     : QWidget(parent)
-    , m_levels(128)
-    , m_isBusy(false)
 {
     m_processor.moveToThread(&m_processorThread);
-    qRegisterMetaType<QVector<qreal> >("QVector<qreal>");
-    connect(&m_processor, SIGNAL(histogramReady(QVector<qreal>)), SLOT(setHistogram(QVector<qreal>)));
+    qRegisterMetaType<QVector<qreal>>("QVector<qreal>");
+    connect(&m_processor, &FrameProcessor::histogramReady, this, &HistogramWidget::setHistogram);
     m_processorThread.start(QThread::LowestPriority);
     setLayout(new QHBoxLayout);
 }
@@ -107,7 +104,7 @@ HistogramWidget::~HistogramWidget()
     m_processorThread.wait(10000);
 }
 
-void HistogramWidget::processFrame(QVideoFrame frame)
+void HistogramWidget::processFrame(const QVideoFrame &frame)
 {
     if (m_isBusy && frame.isValid())
         return; //drop frame
@@ -226,24 +223,24 @@ QVector<qreal> getBufferLevels(const T *buffer, int frames, int channels)
     return max_values;
 }
 
-void HistogramWidget::processBuffer(QAudioBuffer buffer)
+void HistogramWidget::processBuffer(const QAudioBuffer &buffer)
 {
-    if (audioLevels.count() != buffer.format().channelCount()) {
-        qDeleteAll(audioLevels);
-        audioLevels.clear();
+    if (m_audioLevels.count() != buffer.format().channelCount()) {
+        qDeleteAll(m_audioLevels);
+        m_audioLevels.clear();
         for (int i = 0; i < buffer.format().channelCount(); ++i) {
             QAudioLevel *level = new QAudioLevel(this);
-            audioLevels.append(level);
+            m_audioLevels.append(level);
             layout()->addWidget(level);
         }
     }
 
     QVector<qreal> levels = getBufferLevels(buffer);
     for (int i = 0; i < levels.count(); ++i)
-        audioLevels.at(i)->setLevel(levels.at(i));
+        m_audioLevels.at(i)->setLevel(levels.at(i));
 }
 
-void HistogramWidget::setHistogram(QVector<qreal> histogram)
+void HistogramWidget::setHistogram(const QVector<qreal> &histogram)
 {
     m_isBusy = false;
     m_histogram = histogram;
@@ -254,7 +251,7 @@ void HistogramWidget::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event);
 
-    if (!audioLevels.isEmpty())
+    if (!m_audioLevels.isEmpty())
         return;
 
     QPainter painter(this);
@@ -266,7 +263,7 @@ void HistogramWidget::paintEvent(QPaintEvent *event)
 
     qreal barWidth = width() / (qreal)m_histogram.size();
 
-    for (int i = 0; i < m_histogram.size(); i++) {
+    for (int i = 0; i < m_histogram.size(); ++i) {
         qreal h = m_histogram[i] * height();
         // draw level
         painter.fillRect(barWidth * i, height() - h, barWidth * (i + 1), height(), Qt::red);
@@ -290,7 +287,7 @@ void FrameProcessor::processFrame(QVideoFrame frame, int levels)
             frame.pixelFormat() == QVideoFrame::Format_NV12) {
             // Process YUV data
             uchar *b = frame.bits();
-            for (int y = 0; y < frame.height(); y++) {
+            for (int y = 0; y < frame.height(); ++y) {
                 uchar *lastPixel = b + frame.width();
                 for (uchar *curPixel = b; curPixel < lastPixel; curPixel++)
                     histogram[(*curPixel * levels) >> 8] += 1.0;
@@ -304,7 +301,7 @@ void FrameProcessor::processFrame(QVideoFrame frame, int levels)
                 image = image.convertToFormat(QImage::Format_RGB32);
 
                 const QRgb* b = (const QRgb*)image.bits();
-                for (int y = 0; y < image.height(); y++) {
+                for (int y = 0; y < image.height(); ++y) {
                     const QRgb *lastPixel = b + frame.width();
                     for (const QRgb *curPixel = b; curPixel < lastPixel; curPixel++)
                         histogram[(qGray(*curPixel) * levels) >> 8] += 1.0;
diff --git a/examples/multimediawidgets/player/histogramwidget.h b/examples/multimediawidgets/player/histogramwidget.h
index a85dd27e1..b55ab265f 100644
--- a/examples/multimediawidgets/player/histogramwidget.h
+++ b/examples/multimediawidgets/player/histogramwidget.h
@@ -56,7 +56,7 @@ public slots:
     void processFrame(QVideoFrame frame, int levels);
 
 signals:
-    void histogramReady(QVector<qreal> histogram);
+    void histogramReady(const QVector<qreal> &histogram);
 };
 
 class HistogramWidget : public QWidget
@@ -64,25 +64,25 @@ class HistogramWidget : public QWidget
     Q_OBJECT
 
 public:
-    explicit HistogramWidget(QWidget *parent = 0);
+    explicit HistogramWidget(QWidget *parent = nullptr);
     ~HistogramWidget();
     void setLevels(int levels) { m_levels = levels; }
 
 public slots:
-    void processFrame(QVideoFrame frame);
-    void processBuffer(QAudioBuffer buffer);
-    void setHistogram(QVector<qreal> histogram);
+    void processFrame(const QVideoFrame &frame);
+    void processBuffer(const QAudioBuffer &buffer);
+    void setHistogram(const QVector<qreal> &histogram);
 
 protected:
     void paintEvent(QPaintEvent *event) override;
 
 private:
     QVector<qreal> m_histogram;
-    int m_levels;
+    int m_levels = 128;
     FrameProcessor m_processor;
     QThread m_processorThread;
-    bool m_isBusy;
-    QVector<QAudioLevel *> audioLevels;
+    bool m_isBusy = false;
+    QVector<QAudioLevel *> m_audioLevels;
 };
 
 #endif // HISTOGRAMWIDGET_H
diff --git a/examples/multimediawidgets/player/main.cpp b/examples/multimediawidgets/player/main.cpp
index a3dabe15d..af8013502 100644
--- a/examples/multimediawidgets/player/main.cpp
+++ b/examples/multimediawidgets/player/main.cpp
@@ -63,16 +63,11 @@ int main(int argc, char *argv[])
 
     if (!parser.positionalArguments().isEmpty() && player.isPlayerAvailable()) {
         QList<QUrl> urls;
-        foreach (const QString &a, parser.positionalArguments())
+        for (auto &a: parser.positionalArguments())
             urls.append(QUrl::fromUserInput(a, QDir::currentPath(), QUrl::AssumeLocalFile));
         player.addToPlaylist(urls);
     }
 
-#if defined(Q_WS_SIMULATOR)
-    player.setAttribute(Qt::WA_LockLandscapeOrientation);
-    player.showMaximized();
-#else
     player.show();
-#endif
     return app.exec();
 }
diff --git a/examples/multimediawidgets/player/player.cpp b/examples/multimediawidgets/player/player.cpp
index 085dff6a7..ce178d4a1 100644
--- a/examples/multimediawidgets/player/player.cpp
+++ b/examples/multimediawidgets/player/player.cpp
@@ -43,6 +43,7 @@
 #include "playercontrols.h"
 #include "playlistmodel.h"
 #include "histogramwidget.h"
+#include "videowidget.h"
 
 #include <QMediaService>
 #include <QMediaPlaylist>
@@ -53,105 +54,98 @@
 
 Player::Player(QWidget *parent)
     : QWidget(parent)
-    , videoWidget(0)
-    , coverLabel(0)
-    , slider(0)
-    , colorDialog(0)
 {
 //! [create-objs]
-    player = new QMediaPlayer(this);
-    player->setAudioRole(QAudio::VideoRole);
+    m_player = new QMediaPlayer(this);
+    m_player->setAudioRole(QAudio::VideoRole);
     qInfo() << "Supported audio roles:";
-    for (QAudio::Role role : player->supportedAudioRoles())
+    for (QAudio::Role role : m_player->supportedAudioRoles())
         qInfo() << "    " << role;
     // owned by PlaylistModel
-    playlist = new QMediaPlaylist();
-    player->setPlaylist(playlist);
+    m_playlist = new QMediaPlaylist();
+    m_player->setPlaylist(m_playlist);
 //! [create-objs]
 
-    connect(player, SIGNAL(durationChanged(qint64)), SLOT(durationChanged(qint64)));
-    connect(player, SIGNAL(positionChanged(qint64)), SLOT(positionChanged(qint64)));
-    connect(player, SIGNAL(metaDataChanged()), SLOT(metaDataChanged()));
-    connect(playlist, SIGNAL(currentIndexChanged(int)), SLOT(playlistPositionChanged(int)));
-    connect(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
-            this, SLOT(statusChanged(QMediaPlayer::MediaStatus)));
-    connect(player, SIGNAL(bufferStatusChanged(int)), this, SLOT(bufferingProgress(int)));
-    connect(player, SIGNAL(videoAvailableChanged(bool)), this, SLOT(videoAvailableChanged(bool)));
-    connect(player, SIGNAL(error(QMediaPlayer::Error)), this, SLOT(displayErrorMessage()));
-    connect(player, &QMediaPlayer::stateChanged, this, &Player::stateChanged);
+    connect(m_player, &QMediaPlayer::durationChanged, this, &Player::durationChanged);
+    connect(m_player, &QMediaPlayer::positionChanged, this, &Player::positionChanged);
+    connect(m_player, QOverload<>::of(&QMediaPlayer::metaDataChanged), this, &Player::metaDataChanged);
+    connect(m_playlist, &QMediaPlaylist::currentIndexChanged, this, &Player::playlistPositionChanged);
+    connect(m_player, &QMediaPlayer::mediaStatusChanged, this, &Player::statusChanged);
+    connect(m_player, &QMediaPlayer::bufferStatusChanged, this, &Player::bufferingProgress);
+    connect(m_player, &QMediaPlayer::videoAvailableChanged, this, &Player::videoAvailableChanged);
+    connect(m_player, QOverload<QMediaPlayer::Error>::of(&QMediaPlayer::error), this, &Player::displayErrorMessage);
+    connect(m_player, &QMediaPlayer::stateChanged, this, &Player::stateChanged);
 
 //! [2]
-    videoWidget = new VideoWidget(this);
-    player->setVideoOutput(videoWidget);
+    m_videoWidget = new VideoWidget(this);
+    m_player->setVideoOutput(m_videoWidget);
 
-    playlistModel = new PlaylistModel(this);
-    playlistModel->setPlaylist(playlist);
+    m_playlistModel = new PlaylistModel(this);
+    m_playlistModel->setPlaylist(m_playlist);
 //! [2]
 
-    playlistView = new QListView(this);
-    playlistView->setModel(playlistModel);
-    playlistView->setCurrentIndex(playlistModel->index(playlist->currentIndex(), 0));
+    m_playlistView = new QListView(this);
+    m_playlistView->setModel(m_playlistModel);
+    m_playlistView->setCurrentIndex(m_playlistModel->index(m_playlist->currentIndex(), 0));
 
-    connect(playlistView, SIGNAL(activated(QModelIndex)), this, SLOT(jump(QModelIndex)));
+    connect(m_playlistView, &QAbstractItemView::activated, this, &Player::jump);
 
-    slider = new QSlider(Qt::Horizontal, this);
-    slider->setRange(0, player->duration() / 1000);
+    m_slider = new QSlider(Qt::Horizontal, this);
+    m_slider->setRange(0, m_player->duration() / 1000);
 
-    labelDuration = new QLabel(this);
-    connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(seek(int)));
+    m_labelDuration = new QLabel(this);
+    connect(m_slider, &QSlider::sliderMoved, this, &Player::seek);
 
-    labelHistogram = new QLabel(this);
-    labelHistogram->setText("Histogram:");
-    videoHistogram = new HistogramWidget(this);
-    audioHistogram = new HistogramWidget(this);
+    m_labelHistogram = new QLabel(this);
+    m_labelHistogram->setText("Histogram:");
+    m_videoHistogram = new HistogramWidget(this);
+    m_audioHistogram = new HistogramWidget(this);
     QHBoxLayout *histogramLayout = new QHBoxLayout;
-    histogramLayout->addWidget(labelHistogram);
-    histogramLayout->addWidget(videoHistogram, 1);
-    histogramLayout->addWidget(audioHistogram, 2);
+    histogramLayout->addWidget(m_labelHistogram);
+    histogramLayout->addWidget(m_videoHistogram, 1);
+    histogramLayout->addWidget(m_audioHistogram, 2);
 
-    videoProbe = new QVideoProbe(this);
-    connect(videoProbe, SIGNAL(videoFrameProbed(QVideoFrame)), videoHistogram, SLOT(processFrame(QVideoFrame)));
-    videoProbe->setSource(player);
+    m_videoProbe = new QVideoProbe(this);
+    connect(m_videoProbe, &QVideoProbe::videoFrameProbed, m_videoHistogram, &HistogramWidget::processFrame);
+    m_videoProbe->setSource(m_player);
 
-    audioProbe = new QAudioProbe(this);
-    connect(audioProbe, SIGNAL(audioBufferProbed(QAudioBuffer)), audioHistogram, SLOT(processBuffer(QAudioBuffer)));
-    audioProbe->setSource(player);
+    m_audioProbe = new QAudioProbe(this);
+    connect(m_audioProbe, &QAudioProbe::audioBufferProbed, m_audioHistogram, &HistogramWidget::processBuffer);
+    m_audioProbe->setSource(m_player);
 
     QPushButton *openButton = new QPushButton(tr("Open"), this);
 
-    connect(openButton, SIGNAL(clicked()), this, SLOT(open()));
+    connect(openButton, &QPushButton::clicked, this, &Player::open);
 
     PlayerControls *controls = new PlayerControls(this);
-    controls->setState(player->state());
-    controls->setVolume(player->volume());
+    controls->setState(m_player->state());
+    controls->setVolume(m_player->volume());
     controls->setMuted(controls->isMuted());
 
-    connect(controls, SIGNAL(play()), player, SLOT(play()));
-    connect(controls, SIGNAL(pause()), player, SLOT(pause()));
-    connect(controls, SIGNAL(stop()), player, SLOT(stop()));
-    connect(controls, SIGNAL(next()), playlist, SLOT(next()));
-    connect(controls, SIGNAL(previous()), this, SLOT(previousClicked()));
-    connect(controls, SIGNAL(changeVolume(int)), player, SLOT(setVolume(int)));
-    connect(controls, SIGNAL(changeMuting(bool)), player, SLOT(setMuted(bool)));
-    connect(controls, SIGNAL(changeRate(qreal)), player, SLOT(setPlaybackRate(qreal)));
+    connect(controls, &PlayerControls::play, m_player, &QMediaPlayer::play);
+    connect(controls, &PlayerControls::pause, m_player, &QMediaPlayer::pause);
+    connect(controls, &PlayerControls::stop, m_player, &QMediaPlayer::stop);
+    connect(controls, &PlayerControls::next, m_playlist, &QMediaPlaylist::next);
+    connect(controls, &PlayerControls::previous, this, &Player::previousClicked);
+    connect(controls, &PlayerControls::changeVolume, m_player, &QMediaPlayer::setVolume);
+    connect(controls, &PlayerControls::changeMuting, m_player, &QMediaPlayer::setMuted);
+    connect(controls, &PlayerControls::changeRate, m_player, &QMediaPlayer::setPlaybackRate);
+    connect(controls, &PlayerControls::stop, m_videoWidget, QOverload<>::of(&QVideoWidget::update));
 
-    connect(controls, SIGNAL(stop()), videoWidget, SLOT(update()));
+    connect(m_player, &QMediaPlayer::stateChanged, controls, &PlayerControls::setState);
+    connect(m_player, &QMediaPlayer::volumeChanged, controls, &PlayerControls::setVolume);
+    connect(m_player, &QMediaPlayer::mutedChanged, controls, &PlayerControls::setMuted);
 
-    connect(player, SIGNAL(stateChanged(QMediaPlayer::State)),
-            controls, SLOT(setState(QMediaPlayer::State)));
-    connect(player, SIGNAL(volumeChanged(int)), controls, SLOT(setVolume(int)));
-    connect(player, SIGNAL(mutedChanged(bool)), controls, SLOT(setMuted(bool)));
+    m_fullScreenButton = new QPushButton(tr("FullScreen"), this);
+    m_fullScreenButton->setCheckable(true);
 
-    fullScreenButton = new QPushButton(tr("FullScreen"), this);
-    fullScreenButton->setCheckable(true);
-
-    colorButton = new QPushButton(tr("Color Options..."), this);
-    colorButton->setEnabled(false);
-    connect(colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
+    m_colorButton = new QPushButton(tr("Color Options..."), this);
+    m_colorButton->setEnabled(false);
+    connect(m_colorButton, &QPushButton::clicked, this, &Player::showColorDialog);
 
     QBoxLayout *displayLayout = new QHBoxLayout;
-    displayLayout->addWidget(videoWidget, 2);
-    displayLayout->addWidget(playlistView);
+    displayLayout->addWidget(m_videoWidget, 2);
+    displayLayout->addWidget(m_playlistView);
 
     QBoxLayout *controlLayout = new QHBoxLayout;
     controlLayout->setMargin(0);
@@ -159,14 +153,14 @@ Player::Player(QWidget *parent)
     controlLayout->addStretch(1);
     controlLayout->addWidget(controls);
     controlLayout->addStretch(1);
-    controlLayout->addWidget(fullScreenButton);
-    controlLayout->addWidget(colorButton);
+    controlLayout->addWidget(m_fullScreenButton);
+    controlLayout->addWidget(m_colorButton);
 
     QBoxLayout *layout = new QVBoxLayout;
     layout->addLayout(displayLayout);
     QHBoxLayout *hLayout = new QHBoxLayout;
-    hLayout->addWidget(slider);
-    hLayout->addWidget(labelDuration);
+    hLayout->addWidget(m_slider);
+    hLayout->addWidget(m_labelDuration);
     layout->addLayout(hLayout);
     layout->addLayout(controlLayout);
     layout->addLayout(histogramLayout);
@@ -179,10 +173,10 @@ Player::Player(QWidget *parent)
                                 "Please check the media service plugins are installed."));
 
         controls->setEnabled(false);
-        playlistView->setEnabled(false);
+        m_playlistView->setEnabled(false);
         openButton->setEnabled(false);
-        colorButton->setEnabled(false);
-        fullScreenButton->setEnabled(false);
+        m_colorButton->setEnabled(false);
+        m_fullScreenButton->setEnabled(false);
     }
 
     metaDataChanged();
@@ -194,7 +188,7 @@ Player::~Player()
 
 bool Player::isPlayerAvailable() const
 {
-    return player->isAvailable();
+    return m_player->isAvailable();
 }
 
 void Player::open()
@@ -202,7 +196,7 @@ void Player::open()
     QFileDialog fileDialog(this);
     fileDialog.setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog.setWindowTitle(tr("Open Files"));
-    QStringList supportedMimeTypes = player->supportedMimeTypes();
+    QStringList supportedMimeTypes = m_player->supportedMimeTypes();
     if (!supportedMimeTypes.isEmpty()) {
         supportedMimeTypes.append("audio/x-m3u"); // MP3 playlists
         fileDialog.setMimeTypeFilters(supportedMimeTypes);
@@ -220,41 +214,41 @@ static bool isPlaylist(const QUrl &url) // Check for ".m3u" playlists.
     return fileInfo.exists() && !fileInfo.suffix().compare(QLatin1String("m3u"), Qt::CaseInsensitive);
 }
 
-void Player::addToPlaylist(const QList<QUrl> urls)
+void Player::addToPlaylist(const QList<QUrl> &urls)
 {
-    foreach (const QUrl &url, urls) {
+    for (auto &url: urls) {
         if (isPlaylist(url))
-            playlist->load(url);
+            m_playlist->load(url);
         else
-            playlist->addMedia(url);
+            m_playlist->addMedia(url);
     }
 }
 
 void Player::durationChanged(qint64 duration)
 {
-    this->duration = duration/1000;
-    slider->setMaximum(duration / 1000);
+    m_duration = duration / 1000;
+    m_slider->setMaximum(m_duration);
 }
 
 void Player::positionChanged(qint64 progress)
 {
-    if (!slider->isSliderDown()) {
-        slider->setValue(progress / 1000);
-    }
+    if (!m_slider->isSliderDown())
+        m_slider->setValue(progress / 1000);
+
     updateDurationInfo(progress / 1000);
 }
 
 void Player::metaDataChanged()
 {
-    if (player->isMetaDataAvailable()) {
+    if (m_player->isMetaDataAvailable()) {
         setTrackInfo(QString("%1 - %2")
-                .arg(player->metaData(QMediaMetaData::AlbumArtist).toString())
-                .arg(player->metaData(QMediaMetaData::Title).toString()));
+                .arg(m_player->metaData(QMediaMetaData::AlbumArtist).toString())
+                .arg(m_player->metaData(QMediaMetaData::Title).toString()));
 
-        if (coverLabel) {
-            QUrl url = player->metaData(QMediaMetaData::CoverArtUrlLarge).value<QUrl>();
+        if (m_coverLabel) {
+            QUrl url = m_player->metaData(QMediaMetaData::CoverArtUrlLarge).value<QUrl>();
 
-            coverLabel->setPixmap(!url.isEmpty()
+            m_coverLabel->setPixmap(!url.isEmpty()
                     ? QPixmap(url.toString())
                     : QPixmap());
         }
@@ -265,29 +259,29 @@ void Player::previousClicked()
 {
     // Go to previous track if we are within the first 5 seconds of playback
     // Otherwise, seek to the beginning.
-    if(player->position() <= 5000)
-        playlist->previous();
+    if (m_player->position() <= 5000)
+        m_playlist->previous();
     else
-        player->setPosition(0);
+        m_player->setPosition(0);
 }
 
 void Player::jump(const QModelIndex &index)
 {
     if (index.isValid()) {
-        playlist->setCurrentIndex(index.row());
-        player->play();
+        m_playlist->setCurrentIndex(index.row());
+        m_player->play();
     }
 }
 
 void Player::playlistPositionChanged(int currentItem)
 {
     clearHistogram();
-    playlistView->setCurrentIndex(playlistModel->index(currentItem, 0));
+    m_playlistView->setCurrentIndex(m_playlistModel->index(currentItem, 0));
 }
 
 void Player::seek(int seconds)
 {
-    player->setPosition(seconds * 1000);
+    m_player->setPosition(seconds * 1000);
 }
 
 void Player::statusChanged(QMediaPlayer::MediaStatus status)
@@ -344,86 +338,84 @@ void Player::bufferingProgress(int progress)
 void Player::videoAvailableChanged(bool available)
 {
     if (!available) {
-        disconnect(fullScreenButton, SIGNAL(clicked(bool)),
-                    videoWidget, SLOT(setFullScreen(bool)));
-        disconnect(videoWidget, SIGNAL(fullScreenChanged(bool)),
-                fullScreenButton, SLOT(setChecked(bool)));
-        videoWidget->setFullScreen(false);
+        disconnect(m_fullScreenButton, &QPushButton::clicked, m_videoWidget, &QVideoWidget::setFullScreen);
+        disconnect(m_videoWidget, &QVideoWidget::fullScreenChanged, m_fullScreenButton, &QPushButton::setChecked);
+        m_videoWidget->setFullScreen(false);
     } else {
-        connect(fullScreenButton, SIGNAL(clicked(bool)),
-                videoWidget, SLOT(setFullScreen(bool)));
-        connect(videoWidget, SIGNAL(fullScreenChanged(bool)),
-                fullScreenButton, SLOT(setChecked(bool)));
+        connect(m_fullScreenButton, &QPushButton::clicked, m_videoWidget, &QVideoWidget::setFullScreen);
+        connect(m_videoWidget, &QVideoWidget::fullScreenChanged, m_fullScreenButton, &QPushButton::setChecked);
 
-        if (fullScreenButton->isChecked())
-            videoWidget->setFullScreen(true);
+        if (m_fullScreenButton->isChecked())
+            m_videoWidget->setFullScreen(true);
     }
-    colorButton->setEnabled(available);
+    m_colorButton->setEnabled(available);
 }
 
 void Player::setTrackInfo(const QString &info)
 {
-    trackInfo = info;
-    if (!statusInfo.isEmpty())
-        setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
+    m_trackInfo = info;
+    if (!m_statusInfo.isEmpty())
+        setWindowTitle(QString("%1 | %2").arg(m_trackInfo).arg(m_statusInfo));
     else
-        setWindowTitle(trackInfo);
+        setWindowTitle(m_trackInfo);
 }
 
 void Player::setStatusInfo(const QString &info)
 {
-    statusInfo = info;
-    if (!statusInfo.isEmpty())
-        setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
+    m_statusInfo = info;
+    if (!m_statusInfo.isEmpty())
+        setWindowTitle(QString("%1 | %2").arg(m_trackInfo).arg(m_statusInfo));
     else
-        setWindowTitle(trackInfo);
+        setWindowTitle(m_trackInfo);
 }
 
 void Player::displayErrorMessage()
 {
-    setStatusInfo(player->errorString());
+    setStatusInfo(m_player->errorString());
 }
 
 void Player::updateDurationInfo(qint64 currentInfo)
 {
     QString tStr;
-    if (currentInfo || duration) {
-        QTime currentTime((currentInfo/3600)%60, (currentInfo/60)%60, currentInfo%60, (currentInfo*1000)%1000);
-        QTime totalTime((duration/3600)%60, (duration/60)%60, duration%60, (duration*1000)%1000);
+    if (currentInfo || m_duration) {
+        QTime currentTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60,
+            currentInfo % 60, (currentInfo * 1000) % 1000);
+        QTime totalTime((m_duration / 3600) % 60, (m_duration / 60) % 60,
+            m_duration % 60, (m_duration * 1000) % 1000);
         QString format = "mm:ss";
-        if (duration > 3600)
+        if (m_duration > 3600)
             format = "hh:mm:ss";
         tStr = currentTime.toString(format) + " / " + totalTime.toString(format);
     }
-    labelDuration->setText(tStr);
+    m_labelDuration->setText(tStr);
 }
 
 void Player::showColorDialog()
 {
-    if (!colorDialog) {
+    if (!m_colorDialog) {
         QSlider *brightnessSlider = new QSlider(Qt::Horizontal);
         brightnessSlider->setRange(-100, 100);
-        brightnessSlider->setValue(videoWidget->brightness());
-        connect(brightnessSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setBrightness(int)));
-        connect(videoWidget, SIGNAL(brightnessChanged(int)), brightnessSlider, SLOT(setValue(int)));
+        brightnessSlider->setValue(m_videoWidget->brightness());
+        connect(brightnessSlider, &QSlider::sliderMoved, m_videoWidget, &QVideoWidget::setBrightness);
+        connect(m_videoWidget, &QVideoWidget::brightnessChanged, brightnessSlider, &QSlider::setValue);
 
         QSlider *contrastSlider = new QSlider(Qt::Horizontal);
         contrastSlider->setRange(-100, 100);
-        contrastSlider->setValue(videoWidget->contrast());
-        connect(contrastSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setContrast(int)));
-        connect(videoWidget, SIGNAL(contrastChanged(int)), contrastSlider, SLOT(setValue(int)));
+        contrastSlider->setValue(m_videoWidget->contrast());
+        connect(contrastSlider, &QSlider::sliderMoved, m_videoWidget, &QVideoWidget::setContrast);
+        connect(m_videoWidget, &QVideoWidget::contrastChanged, contrastSlider, &QSlider::setValue);
 
         QSlider *hueSlider = new QSlider(Qt::Horizontal);
         hueSlider->setRange(-100, 100);
-        hueSlider->setValue(videoWidget->hue());
-        connect(hueSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setHue(int)));
-        connect(videoWidget, SIGNAL(hueChanged(int)), hueSlider, SLOT(setValue(int)));
+        hueSlider->setValue(m_videoWidget->hue());
+        connect(hueSlider, &QSlider::sliderMoved, m_videoWidget, &QVideoWidget::setHue);
+        connect(m_videoWidget, &QVideoWidget::hueChanged, hueSlider, &QSlider::setValue);
 
         QSlider *saturationSlider = new QSlider(Qt::Horizontal);
         saturationSlider->setRange(-100, 100);
-        saturationSlider->setValue(videoWidget->saturation());
-        connect(saturationSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setSaturation(int)));
-        connect(videoWidget, SIGNAL(saturationChanged(int)), saturationSlider, SLOT(setValue(int)));
+        saturationSlider->setValue(m_videoWidget->saturation());
+        connect(saturationSlider, &QSlider::sliderMoved, m_videoWidget, &QVideoWidget::setSaturation);
+        connect(m_videoWidget, &QVideoWidget::saturationChanged, saturationSlider, &QSlider::setValue);
 
         QFormLayout *layout = new QFormLayout;
         layout->addRow(tr("Brightness"), brightnessSlider);
@@ -434,17 +426,17 @@ void Player::showColorDialog()
         QPushButton *button = new QPushButton(tr("Close"));
         layout->addRow(button);
 
-        colorDialog = new QDialog(this);
-        colorDialog->setWindowTitle(tr("Color Options"));
-        colorDialog->setLayout(layout);
+        m_colorDialog = new QDialog(this);
+        m_colorDialog->setWindowTitle(tr("Color Options"));
+        m_colorDialog->setLayout(layout);
 
-        connect(button, SIGNAL(clicked()), colorDialog, SLOT(close()));
+        connect(button, &QPushButton::clicked, m_colorDialog, &QDialog::close);
     }
-    colorDialog->show();
+    m_colorDialog->show();
 }
 
 void Player::clearHistogram()
 {
-    QMetaObject::invokeMethod(videoHistogram, "processFrame", Qt::QueuedConnection, Q_ARG(QVideoFrame, QVideoFrame()));
-    QMetaObject::invokeMethod(audioHistogram, "processBuffer", Qt::QueuedConnection, Q_ARG(QAudioBuffer, QAudioBuffer()));
+    QMetaObject::invokeMethod(m_videoHistogram, "processFrame", Qt::QueuedConnection, Q_ARG(QVideoFrame, QVideoFrame()));
+    QMetaObject::invokeMethod(m_audioHistogram, "processBuffer", Qt::QueuedConnection, Q_ARG(QAudioBuffer, QAudioBuffer()));
 }
diff --git a/examples/multimediawidgets/player/player.h b/examples/multimediawidgets/player/player.h
index ff60f8c63..66be3f747 100644
--- a/examples/multimediawidgets/player/player.h
+++ b/examples/multimediawidgets/player/player.h
@@ -41,8 +41,6 @@
 #ifndef PLAYER_H
 #define PLAYER_H
 
-#include "videowidget.h"
-
 #include <QWidget>
 #include <QMediaPlayer>
 #include <QMediaPlaylist>
@@ -67,12 +65,12 @@ class Player : public QWidget
     Q_OBJECT
 
 public:
-    Player(QWidget *parent = 0);
+    explicit Player(QWidget *parent = nullptr);
     ~Player();
 
     bool isPlayerAvailable() const;
 
-    void addToPlaylist(const QList<QUrl> urls);
+    void addToPlaylist(const QList<QUrl> &urls);
 
 signals:
     void fullScreenChanged(bool fullScreen);
@@ -105,27 +103,27 @@ private:
     void handleCursor(QMediaPlayer::MediaStatus status);
     void updateDurationInfo(qint64 currentInfo);
 
-    QMediaPlayer *player;
-    QMediaPlaylist *playlist;
-    VideoWidget *videoWidget;
-    QLabel *coverLabel;
-    QSlider *slider;
-    QLabel *labelDuration;
-    QPushButton *fullScreenButton;
-    QPushButton *colorButton;
-    QDialog *colorDialog;
-
-    QLabel *labelHistogram;
-    HistogramWidget *videoHistogram;
-    HistogramWidget *audioHistogram;
-    QVideoProbe *videoProbe;
-    QAudioProbe *audioProbe;
-
-    PlaylistModel *playlistModel;
-    QAbstractItemView *playlistView;
-    QString trackInfo;
-    QString statusInfo;
-    qint64 duration;
+    QMediaPlayer *m_player = nullptr;
+    QMediaPlaylist *m_playlist = nullptr;
+    QVideoWidget *m_videoWidget = nullptr;
+    QLabel *m_coverLabel = nullptr;
+    QSlider *m_slider = nullptr;
+    QLabel *m_labelDuration = nullptr;
+    QPushButton *m_fullScreenButton = nullptr;
+    QPushButton *m_colorButton = nullptr;
+    QDialog *m_colorDialog = nullptr;
+
+    QLabel *m_labelHistogram = nullptr;
+    HistogramWidget *m_videoHistogram = nullptr;
+    HistogramWidget *m_audioHistogram = nullptr;
+    QVideoProbe *m_videoProbe = nullptr;
+    QAudioProbe *m_audioProbe = nullptr;
+
+    PlaylistModel *m_playlistModel = nullptr;
+    QAbstractItemView *m_playlistView = nullptr;
+    QString m_trackInfo;
+    QString m_statusInfo;
+    qint64 m_duration;
 };
 
 #endif // PLAYER_H
diff --git a/examples/multimediawidgets/player/playercontrols.cpp b/examples/multimediawidgets/player/playercontrols.cpp
index 3d968b452..daeec924c 100644
--- a/examples/multimediawidgets/player/playercontrols.cpp
+++ b/examples/multimediawidgets/player/playercontrols.cpp
@@ -49,89 +49,80 @@
 
 PlayerControls::PlayerControls(QWidget *parent)
     : QWidget(parent)
-    , playerState(QMediaPlayer::StoppedState)
-    , playerMuted(false)
-    , playButton(0)
-    , stopButton(0)
-    , nextButton(0)
-    , previousButton(0)
-    , muteButton(0)
-    , volumeSlider(0)
-    , rateBox(0)
 {
-    playButton = new QToolButton(this);
-    playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+    m_playButton = new QToolButton(this);
+    m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
 
-    connect(playButton, SIGNAL(clicked()), this, SLOT(playClicked()));
+    connect(m_playButton, &QAbstractButton::clicked, this, &PlayerControls::playClicked);
 
-    stopButton = new QToolButton(this);
-    stopButton->setIcon(style()->standardIcon(QStyle::SP_MediaStop));
-    stopButton->setEnabled(false);
+    m_stopButton = new QToolButton(this);
+    m_stopButton->setIcon(style()->standardIcon(QStyle::SP_MediaStop));
+    m_stopButton->setEnabled(false);
 
-    connect(stopButton, SIGNAL(clicked()), this, SIGNAL(stop()));
+    connect(m_stopButton, &QAbstractButton::clicked, this, &PlayerControls::stop);
 
-    nextButton = new QToolButton(this);
-    nextButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));
+    m_nextButton = new QToolButton(this);
+    m_nextButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));
 
-    connect(nextButton, SIGNAL(clicked()), this, SIGNAL(next()));
+    connect(m_nextButton, &QAbstractButton::clicked, this, &PlayerControls::next);
 
-    previousButton = new QToolButton(this);
-    previousButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));
+    m_previousButton = new QToolButton(this);
+    m_previousButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));
 
-    connect(previousButton, SIGNAL(clicked()), this, SIGNAL(previous()));
+    connect(m_previousButton, &QAbstractButton::clicked, this, &PlayerControls::previous);
 
-    muteButton = new QToolButton(this);
-    muteButton->setIcon(style()->standardIcon(QStyle::SP_MediaVolume));
+    m_muteButton = new QToolButton(this);
+    m_muteButton->setIcon(style()->standardIcon(QStyle::SP_MediaVolume));
 
-    connect(muteButton, SIGNAL(clicked()), this, SLOT(muteClicked()));
+    connect(m_muteButton, &QAbstractButton::clicked, this, &PlayerControls::muteClicked);
 
-    volumeSlider = new QSlider(Qt::Horizontal, this);
-    volumeSlider->setRange(0, 100);
+    m_volumeSlider = new QSlider(Qt::Horizontal, this);
+    m_volumeSlider->setRange(0, 100);
 
-    connect(volumeSlider, SIGNAL(valueChanged(int)), this, SLOT(onVolumeSliderValueChanged()));
+    connect(m_volumeSlider, &QSlider::valueChanged, this, &PlayerControls::onVolumeSliderValueChanged);
 
-    rateBox = new QComboBox(this);
-    rateBox->addItem("0.5x", QVariant(0.5));
-    rateBox->addItem("1.0x", QVariant(1.0));
-    rateBox->addItem("2.0x", QVariant(2.0));
-    rateBox->setCurrentIndex(1);
+    m_rateBox = new QComboBox(this);
+    m_rateBox->addItem("0.5x", QVariant(0.5));
+    m_rateBox->addItem("1.0x", QVariant(1.0));
+    m_rateBox->addItem("2.0x", QVariant(2.0));
+    m_rateBox->setCurrentIndex(1);
 
-    connect(rateBox, SIGNAL(activated(int)), SLOT(updateRate()));
+    connect(m_rateBox, QOverload<int>::of(&QComboBox::activated), this, &PlayerControls::updateRate);
 
     QBoxLayout *layout = new QHBoxLayout;
     layout->setMargin(0);
-    layout->addWidget(stopButton);
-    layout->addWidget(previousButton);
-    layout->addWidget(playButton);
-    layout->addWidget(nextButton);
-    layout->addWidget(muteButton);
-    layout->addWidget(volumeSlider);
-    layout->addWidget(rateBox);
+    layout->addWidget(m_stopButton);
+    layout->addWidget(m_previousButton);
+    layout->addWidget(m_playButton);
+    layout->addWidget(m_nextButton);
+    layout->addWidget(m_muteButton);
+    layout->addWidget(m_volumeSlider);
+    layout->addWidget(m_rateBox);
     setLayout(layout);
 }
 
 QMediaPlayer::State PlayerControls::state() const
 {
-    return playerState;
+    return m_playerState;
 }
 
 void PlayerControls::setState(QMediaPlayer::State state)
 {
-    if (state != playerState) {
-        playerState = state;
+    if (state != m_playerState) {
+        m_playerState = state;
 
         switch (state) {
         case QMediaPlayer::StoppedState:
-            stopButton->setEnabled(false);
-            playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+            m_stopButton->setEnabled(false);
+            m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
             break;
         case QMediaPlayer::PlayingState:
-            stopButton->setEnabled(true);
-            playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
+            m_stopButton->setEnabled(true);
+            m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
             break;
         case QMediaPlayer::PausedState:
-            stopButton->setEnabled(true);
-            playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+            m_stopButton->setEnabled(true);
+            m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
             break;
         }
     }
@@ -139,7 +130,7 @@ void PlayerControls::setState(QMediaPlayer::State state)
 
 int PlayerControls::volume() const
 {
-    qreal linearVolume =  QAudio::convertVolume(volumeSlider->value() / qreal(100),
+    qreal linearVolume =  QAudio::convertVolume(m_volumeSlider->value() / qreal(100),
                                                 QAudio::LogarithmicVolumeScale,
                                                 QAudio::LinearVolumeScale);
 
@@ -152,20 +143,20 @@ void PlayerControls::setVolume(int volume)
                                                     QAudio::LinearVolumeScale,
                                                     QAudio::LogarithmicVolumeScale);
 
-    volumeSlider->setValue(qRound(logarithmicVolume * 100));
+    m_volumeSlider->setValue(qRound(logarithmicVolume * 100));
 }
 
 bool PlayerControls::isMuted() const
 {
-    return playerMuted;
+    return m_playerMuted;
 }
 
 void PlayerControls::setMuted(bool muted)
 {
-    if (muted != playerMuted) {
-        playerMuted = muted;
+    if (muted != m_playerMuted) {
+        m_playerMuted = muted;
 
-        muteButton->setIcon(style()->standardIcon(muted
+        m_muteButton->setIcon(style()->standardIcon(muted
                 ? QStyle::SP_MediaVolumeMuted
                 : QStyle::SP_MediaVolume));
     }
@@ -173,7 +164,7 @@ void PlayerControls::setMuted(bool muted)
 
 void PlayerControls::playClicked()
 {
-    switch (playerState) {
+    switch (m_playerState) {
     case QMediaPlayer::StoppedState:
     case QMediaPlayer::PausedState:
         emit play();
@@ -186,25 +177,25 @@ void PlayerControls::playClicked()
 
 void PlayerControls::muteClicked()
 {
-    emit changeMuting(!playerMuted);
+    emit changeMuting(!m_playerMuted);
 }
 
 qreal PlayerControls::playbackRate() const
 {
-    return rateBox->itemData(rateBox->currentIndex()).toDouble();
+    return m_rateBox->itemData(m_rateBox->currentIndex()).toDouble();
 }
 
 void PlayerControls::setPlaybackRate(float rate)
 {
-    for (int i = 0; i < rateBox->count(); ++i) {
-        if (qFuzzyCompare(rate, float(rateBox->itemData(i).toDouble()))) {
-            rateBox->setCurrentIndex(i);
+    for (int i = 0; i < m_rateBox->count(); ++i) {
+        if (qFuzzyCompare(rate, float(m_rateBox->itemData(i).toDouble()))) {
+            m_rateBox->setCurrentIndex(i);
             return;
         }
     }
 
-    rateBox->addItem(QString("%1x").arg(rate), QVariant(rate));
-    rateBox->setCurrentIndex(rateBox->count() - 1);
+    m_rateBox->addItem(QString("%1x").arg(rate), QVariant(rate));
+    m_rateBox->setCurrentIndex(m_rateBox->count() - 1);
 }
 
 void PlayerControls::updateRate()
diff --git a/examples/multimediawidgets/player/playercontrols.h b/examples/multimediawidgets/player/playercontrols.h
index d29a06d6c..d44ae6c4a 100644
--- a/examples/multimediawidgets/player/playercontrols.h
+++ b/examples/multimediawidgets/player/playercontrols.h
@@ -55,7 +55,7 @@ class PlayerControls : public QWidget
     Q_OBJECT
 
 public:
-    PlayerControls(QWidget *parent = 0);
+    explicit PlayerControls(QWidget *parent = nullptr);
 
     QMediaPlayer::State state() const;
     int volume() const;
@@ -85,15 +85,15 @@ private slots:
     void onVolumeSliderValueChanged();
 
 private:
-    QMediaPlayer::State playerState;
-    bool playerMuted;
-    QAbstractButton *playButton;
-    QAbstractButton *stopButton;
-    QAbstractButton *nextButton;
-    QAbstractButton *previousButton;
-    QAbstractButton *muteButton;
-    QAbstractSlider *volumeSlider;
-    QComboBox *rateBox;
+    QMediaPlayer::State m_playerState = QMediaPlayer::StoppedState;
+    bool m_playerMuted = false;
+    QAbstractButton *m_playButton = nullptr;
+    QAbstractButton *m_stopButton = nullptr;
+    QAbstractButton *m_nextButton = nullptr;
+    QAbstractButton *m_previousButton = nullptr;
+    QAbstractButton *m_muteButton = nullptr;
+    QAbstractSlider *m_volumeSlider = nullptr;
+    QComboBox *m_rateBox = nullptr;
 };
 
 #endif // PLAYERCONTROLS_H
diff --git a/examples/multimediawidgets/player/playlistmodel.cpp b/examples/multimediawidgets/player/playlistmodel.cpp
index 18748c819..bd913d5d0 100644
--- a/examples/multimediawidgets/player/playlistmodel.cpp
+++ b/examples/multimediawidgets/player/playlistmodel.cpp
@@ -46,7 +46,10 @@
 
 PlaylistModel::PlaylistModel(QObject *parent)
     : QAbstractItemModel(parent)
-    , m_playlist(0)
+{
+}
+
+PlaylistModel::~PlaylistModel()
 {
 }
 
@@ -92,28 +95,28 @@ QVariant PlaylistModel::data(const QModelIndex &index, int role) const
 
 QMediaPlaylist *PlaylistModel::playlist() const
 {
-    return m_playlist;
+    return m_playlist.data();
 }
 
 void PlaylistModel::setPlaylist(QMediaPlaylist *playlist)
 {
     if (m_playlist) {
-        disconnect(m_playlist, SIGNAL(mediaAboutToBeInserted(int,int)), this, SLOT(beginInsertItems(int,int)));
-        disconnect(m_playlist, SIGNAL(mediaInserted(int,int)), this, SLOT(endInsertItems()));
-        disconnect(m_playlist, SIGNAL(mediaAboutToBeRemoved(int,int)), this, SLOT(beginRemoveItems(int,int)));
-        disconnect(m_playlist, SIGNAL(mediaRemoved(int,int)), this, SLOT(endRemoveItems()));
-        disconnect(m_playlist, SIGNAL(mediaChanged(int,int)), this, SLOT(changeItems(int,int)));
+        disconnect(m_playlist.data(), &QMediaPlaylist::mediaAboutToBeInserted, this, &PlaylistModel::beginInsertItems);
+        disconnect(m_playlist.data(), &QMediaPlaylist::mediaInserted, this, &PlaylistModel::endInsertItems);
+        disconnect(m_playlist.data(), &QMediaPlaylist::mediaAboutToBeRemoved, this, &PlaylistModel::beginRemoveItems);
+        disconnect(m_playlist.data(), &QMediaPlaylist::mediaRemoved, this, &PlaylistModel::endRemoveItems);
+        disconnect(m_playlist.data(), &QMediaPlaylist::mediaChanged, this, &PlaylistModel::changeItems);
     }
 
     beginResetModel();
-    m_playlist = playlist;
+    m_playlist.reset(playlist);
 
     if (m_playlist) {
-        connect(m_playlist, SIGNAL(mediaAboutToBeInserted(int,int)), this, SLOT(beginInsertItems(int,int)));
-        connect(m_playlist, SIGNAL(mediaInserted(int,int)), this, SLOT(endInsertItems()));
-        connect(m_playlist, SIGNAL(mediaAboutToBeRemoved(int,int)), this, SLOT(beginRemoveItems(int,int)));
-        connect(m_playlist, SIGNAL(mediaRemoved(int,int)), this, SLOT(endRemoveItems()));
-        connect(m_playlist, SIGNAL(mediaChanged(int,int)), this, SLOT(changeItems(int,int)));
+        connect(m_playlist.data(), &QMediaPlaylist::mediaAboutToBeInserted, this, &PlaylistModel::beginInsertItems);
+        connect(m_playlist.data(), &QMediaPlaylist::mediaInserted, this, &PlaylistModel::endInsertItems);
+        connect(m_playlist.data(), &QMediaPlaylist::mediaAboutToBeRemoved, this, &PlaylistModel::beginRemoveItems);
+        connect(m_playlist.data(), &QMediaPlaylist::mediaRemoved, this, &PlaylistModel::endRemoveItems);
+        connect(m_playlist.data(), &QMediaPlaylist::mediaChanged, this, &PlaylistModel::changeItems);
     }
 
     endResetModel();
diff --git a/examples/multimediawidgets/player/playlistmodel.h b/examples/multimediawidgets/player/playlistmodel.h
index 960943f1c..827312d9f 100644
--- a/examples/multimediawidgets/player/playlistmodel.h
+++ b/examples/multimediawidgets/player/playlistmodel.h
@@ -42,6 +42,7 @@
 #define PLAYLISTMODEL_H
 
 #include <QAbstractItemModel>
+#include <QScopedPointer>
 
 QT_BEGIN_NAMESPACE
 class QMediaPlaylist;
@@ -58,7 +59,8 @@ public:
         ColumnCount
     };
 
-    PlaylistModel(QObject *parent = 0);
+    explicit PlaylistModel(QObject *parent = nullptr);
+    ~PlaylistModel();
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
@@ -81,7 +83,7 @@ private slots:
     void changeItems(int start, int end);
 
 private:
-    QMediaPlaylist *m_playlist;
+    QScopedPointer<QMediaPlaylist> m_playlist;
     QMap<QModelIndex, QVariant> m_data;
 };
 
diff --git a/examples/multimediawidgets/player/videowidget.h b/examples/multimediawidgets/player/videowidget.h
index 00a27a78b..e88d01441 100644
--- a/examples/multimediawidgets/player/videowidget.h
+++ b/examples/multimediawidgets/player/videowidget.h
@@ -48,7 +48,7 @@ class VideoWidget : public QVideoWidget
     Q_OBJECT
 
 public:
-    VideoWidget(QWidget *parent = 0);
+    explicit VideoWidget(QWidget *parent = nullptr);
 
 protected:
     void keyPressEvent(QKeyEvent *event) override;
diff --git a/examples/multimediawidgets/videographicsitem/videoplayer.cpp b/examples/multimediawidgets/videographicsitem/videoplayer.cpp
index 7f5c4f0bb..82f784a1d 100644
--- a/examples/multimediawidgets/videographicsitem/videoplayer.cpp
+++ b/examples/multimediawidgets/videographicsitem/videoplayer.cpp
@@ -41,24 +41,20 @@
 #include "videoplayer.h"
 
 #include <QtWidgets>
-#include <QVideoSurfaceFormat>
 #include <QGraphicsVideoItem>
 
 VideoPlayer::VideoPlayer(QWidget *parent)
     : QWidget(parent)
-    , mediaPlayer(0, QMediaPlayer::VideoSurface)
-    , videoItem(0)
-    , playButton(0)
-    , positionSlider(0)
 {
+    m_mediaPlayer = new QMediaPlayer(this, QMediaPlayer::VideoSurface);
     const QRect screenGeometry = QApplication::desktop()->screenGeometry(this);
-    videoItem = new QGraphicsVideoItem;
-    videoItem->setSize(QSizeF(screenGeometry.width() / 3, screenGeometry.height() / 2));
+    m_videoItem = new QGraphicsVideoItem;
+    m_videoItem->setSize(QSizeF(screenGeometry.width() / 3, screenGeometry.height() / 2));
 
     QGraphicsScene *scene = new QGraphicsScene(this);
     QGraphicsView *graphicsView = new QGraphicsView(scene);
 
-    scene->addItem(videoItem);
+    scene->addItem(m_videoItem);
 
     QSlider *rotateSlider = new QSlider(Qt::Horizontal);
     rotateSlider->setToolTip(tr("Rotate Video"));
@@ -71,34 +67,34 @@ VideoPlayer::VideoPlayer(QWidget *parent)
     QAbstractButton *openButton = new QPushButton(tr("Open..."));
     connect(openButton, &QAbstractButton::clicked, this, &VideoPlayer::openFile);
 
-    playButton = new QPushButton;
-    playButton->setEnabled(false);
-    playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+    m_playButton = new QPushButton;
+    m_playButton->setEnabled(false);
+    m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
 
-    connect(playButton, &QAbstractButton::clicked, this, &VideoPlayer::play);
+    connect(m_playButton, &QAbstractButton::clicked, this, &VideoPlayer::play);
 
-    positionSlider = new QSlider(Qt::Horizontal);
-    positionSlider->setRange(0, 0);
+    m_positionSlider = new QSlider(Qt::Horizontal);
+    m_positionSlider->setRange(0, 0);
 
-    connect(positionSlider, &QAbstractSlider::sliderMoved,
+    connect(m_positionSlider, &QAbstractSlider::sliderMoved,
             this, &VideoPlayer::setPosition);
 
     QBoxLayout *controlLayout = new QHBoxLayout;
     controlLayout->setMargin(0);
     controlLayout->addWidget(openButton);
-    controlLayout->addWidget(playButton);
-    controlLayout->addWidget(positionSlider);
+    controlLayout->addWidget(m_playButton);
+    controlLayout->addWidget(m_positionSlider);
 
     QBoxLayout *layout = new QVBoxLayout(this);
     layout->addWidget(graphicsView);
     layout->addWidget(rotateSlider);
     layout->addLayout(controlLayout);
 
-    mediaPlayer.setVideoOutput(videoItem);
-    connect(&mediaPlayer, &QMediaPlayer::stateChanged,
+    m_mediaPlayer->setVideoOutput(m_videoItem);
+    connect(m_mediaPlayer, &QMediaPlayer::stateChanged,
             this, &VideoPlayer::mediaStateChanged);
-    connect(&mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
-    connect(&mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
+    connect(m_mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
+    connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
 }
 
 VideoPlayer::~VideoPlayer()
@@ -107,12 +103,12 @@ VideoPlayer::~VideoPlayer()
 
 QSize VideoPlayer::sizeHint() const
 {
-    return (videoItem->size() * qreal(3) / qreal(2)).toSize();
+    return (m_videoItem->size() * qreal(3) / qreal(2)).toSize();
 }
 
 bool VideoPlayer::isPlayerAvailable() const
 {
-    return mediaPlayer.isAvailable();
+    return m_mediaPlayer->isAvailable();
 }
 
 void VideoPlayer::openFile()
@@ -120,7 +116,7 @@ void VideoPlayer::openFile()
     QFileDialog fileDialog(this);
     fileDialog.setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog.setWindowTitle(tr("Open Movie"));
-    const QStringList supportedMimeTypes = mediaPlayer.supportedMimeTypes();
+    const QStringList supportedMimeTypes = m_mediaPlayer->supportedMimeTypes();
     if (!supportedMimeTypes.isEmpty())
         fileDialog.setMimeTypeFilters(supportedMimeTypes);
     fileDialog.setDirectory(QStandardPaths::standardLocations(QStandardPaths::MoviesLocation).value(0, QDir::homePath()));
@@ -130,18 +126,18 @@ void VideoPlayer::openFile()
 
 void VideoPlayer::load(const QUrl &url)
 {
-    mediaPlayer.setMedia(url);
-    playButton->setEnabled(true);
+    m_mediaPlayer->setMedia(url);
+    m_playButton->setEnabled(true);
 }
 
 void VideoPlayer::play()
 {
-    switch(mediaPlayer.state()) {
+    switch (m_mediaPlayer->state()) {
     case QMediaPlayer::PlayingState:
-        mediaPlayer.pause();
+        m_mediaPlayer->pause();
         break;
     default:
-        mediaPlayer.play();
+        m_mediaPlayer->play();
         break;
     }
 }
@@ -150,34 +146,34 @@ void VideoPlayer::mediaStateChanged(QMediaPlayer::State state)
 {
     switch(state) {
     case QMediaPlayer::PlayingState:
-        playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
+        m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
         break;
     default:
-        playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+        m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
         break;
     }
 }
 
 void VideoPlayer::positionChanged(qint64 position)
 {
-    positionSlider->setValue(position);
+    m_positionSlider->setValue(position);
 }
 
 void VideoPlayer::durationChanged(qint64 duration)
 {
-    positionSlider->setRange(0, duration);
+    m_positionSlider->setRange(0, duration);
 }
 
 void VideoPlayer::setPosition(int position)
 {
-    mediaPlayer.setPosition(position);
+    m_mediaPlayer->setPosition(position);
 }
 
 
 void VideoPlayer::rotateVideo(int angle)
 {
     //rotate around the center of video element
-    qreal x = videoItem->boundingRect().width() / 2.0;
-    qreal y = videoItem->boundingRect().height() / 2.0;
-    videoItem->setTransform(QTransform().translate(x, y).rotate(angle).translate(-x, -y));
+    qreal x = m_videoItem->boundingRect().width() / 2.0;
+    qreal y = m_videoItem->boundingRect().height() / 2.0;
+    m_videoItem->setTransform(QTransform().translate(x, y).rotate(angle).translate(-x, -y));
 }
diff --git a/examples/multimediawidgets/videographicsitem/videoplayer.h b/examples/multimediawidgets/videographicsitem/videoplayer.h
index ffccc9a9c..cc2626cac 100644
--- a/examples/multimediawidgets/videographicsitem/videoplayer.h
+++ b/examples/multimediawidgets/videographicsitem/videoplayer.h
@@ -42,7 +42,6 @@
 #define VIDEOPLAYER_H
 
 #include <QMediaPlayer>
-#include <QMovie>
 #include <QWidget>
 
 QT_BEGIN_NAMESPACE
@@ -56,7 +55,7 @@ class VideoPlayer : public QWidget
     Q_OBJECT
 
 public:
-    VideoPlayer(QWidget *parent = 0);
+    VideoPlayer(QWidget *parent = nullptr);
     ~VideoPlayer();
 
     void load(const QUrl &url);
@@ -76,10 +75,10 @@ private slots:
     void rotateVideo(int angle);
 
 private:
-    QMediaPlayer mediaPlayer;
-    QGraphicsVideoItem *videoItem;
-    QAbstractButton *playButton;
-    QSlider *positionSlider;
+    QMediaPlayer *m_mediaPlayer = nullptr;
+    QGraphicsVideoItem *m_videoItem = nullptr;
+    QAbstractButton *m_playButton = nullptr;
+    QSlider *m_positionSlider = nullptr;
 };
 
 #endif
diff --git a/examples/multimediawidgets/videowidget/videoplayer.cpp b/examples/multimediawidgets/videowidget/videoplayer.cpp
index 8504746c4..ead3c2cef 100644
--- a/examples/multimediawidgets/videowidget/videoplayer.cpp
+++ b/examples/multimediawidgets/videowidget/videoplayer.cpp
@@ -41,57 +41,52 @@
 #include "videoplayer.h"
 
 #include <QtWidgets>
-#include <qvideowidget.h>
-#include <qvideosurfaceformat.h>
+#include <QVideoWidget>
 
 VideoPlayer::VideoPlayer(QWidget *parent)
     : QWidget(parent)
-    , mediaPlayer(0, QMediaPlayer::VideoSurface)
-    , playButton(0)
-    , positionSlider(0)
-    , errorLabel(0)
 {
+    m_mediaPlayer = new QMediaPlayer(this, QMediaPlayer::VideoSurface);
     QVideoWidget *videoWidget = new QVideoWidget;
 
     QAbstractButton *openButton = new QPushButton(tr("Open..."));
     connect(openButton, &QAbstractButton::clicked, this, &VideoPlayer::openFile);
 
-    playButton = new QPushButton;
-    playButton->setEnabled(false);
-    playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+    m_playButton = new QPushButton;
+    m_playButton->setEnabled(false);
+    m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
 
-    connect(playButton, &QAbstractButton::clicked,
+    connect(m_playButton, &QAbstractButton::clicked,
             this, &VideoPlayer::play);
 
-    positionSlider = new QSlider(Qt::Horizontal);
-    positionSlider->setRange(0, 0);
+    m_positionSlider = new QSlider(Qt::Horizontal);
+    m_positionSlider->setRange(0, 0);
 
-    connect(positionSlider, &QAbstractSlider::sliderMoved,
+    connect(m_positionSlider, &QAbstractSlider::sliderMoved,
             this, &VideoPlayer::setPosition);
 
-    errorLabel = new QLabel;
-    errorLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
+    m_errorLabel = new QLabel;
+    m_errorLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
 
     QBoxLayout *controlLayout = new QHBoxLayout;
     controlLayout->setMargin(0);
     controlLayout->addWidget(openButton);
-    controlLayout->addWidget(playButton);
-    controlLayout->addWidget(positionSlider);
+    controlLayout->addWidget(m_playButton);
+    controlLayout->addWidget(m_positionSlider);
 
     QBoxLayout *layout = new QVBoxLayout;
     layout->addWidget(videoWidget);
     layout->addLayout(controlLayout);
-    layout->addWidget(errorLabel);
+    layout->addWidget(m_errorLabel);
 
     setLayout(layout);
 
-    mediaPlayer.setVideoOutput(videoWidget);
-    connect(&mediaPlayer, &QMediaPlayer::stateChanged,
+    m_mediaPlayer->setVideoOutput(videoWidget);
+    connect(m_mediaPlayer, &QMediaPlayer::stateChanged,
             this, &VideoPlayer::mediaStateChanged);
-    connect(&mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
-    connect(&mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
-    typedef void (QMediaPlayer::*ErrorSignal)(QMediaPlayer::Error);
-    connect(&mediaPlayer, static_cast<ErrorSignal>(&QMediaPlayer::error),
+    connect(m_mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
+    connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
+    connect(m_mediaPlayer, QOverload<QMediaPlayer::Error>::of(&QMediaPlayer::error),
             this, &VideoPlayer::handleError);
 }
 
@@ -104,7 +99,7 @@ void VideoPlayer::openFile()
     QFileDialog fileDialog(this);
     fileDialog.setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog.setWindowTitle(tr("Open Movie"));
-    QStringList supportedMimeTypes = mediaPlayer.supportedMimeTypes();
+    QStringList supportedMimeTypes = m_mediaPlayer->supportedMimeTypes();
     if (!supportedMimeTypes.isEmpty())
         fileDialog.setMimeTypeFilters(supportedMimeTypes);
     fileDialog.setDirectory(QStandardPaths::standardLocations(QStandardPaths::MoviesLocation).value(0, QDir::homePath()));
@@ -114,20 +109,20 @@ void VideoPlayer::openFile()
 
 void VideoPlayer::setUrl(const QUrl &url)
 {
-    errorLabel->setText(QString());
+    m_errorLabel->setText(QString());
     setWindowFilePath(url.isLocalFile() ? url.toLocalFile() : QString());
-    mediaPlayer.setMedia(url);
-    playButton->setEnabled(true);
+    m_mediaPlayer->setMedia(url);
+    m_playButton->setEnabled(true);
 }
 
 void VideoPlayer::play()
 {
-    switch(mediaPlayer.state()) {
+    switch (m_mediaPlayer->state()) {
     case QMediaPlayer::PlayingState:
-        mediaPlayer.pause();
+        m_mediaPlayer->pause();
         break;
     default:
-        mediaPlayer.play();
+        m_mediaPlayer->play();
         break;
     }
 }
@@ -136,37 +131,37 @@ void VideoPlayer::mediaStateChanged(QMediaPlayer::State state)
 {
     switch(state) {
     case QMediaPlayer::PlayingState:
-        playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
+        m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
         break;
     default:
-        playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
+        m_playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
         break;
     }
 }
 
 void VideoPlayer::positionChanged(qint64 position)
 {
-    positionSlider->setValue(position);
+    m_positionSlider->setValue(position);
 }
 
 void VideoPlayer::durationChanged(qint64 duration)
 {
-    positionSlider->setRange(0, duration);
+    m_positionSlider->setRange(0, duration);
 }
 
 void VideoPlayer::setPosition(int position)
 {
-    mediaPlayer.setPosition(position);
+    m_mediaPlayer->setPosition(position);
 }
 
 void VideoPlayer::handleError()
 {
-    playButton->setEnabled(false);
-    const QString errorString = mediaPlayer.errorString();
+    m_playButton->setEnabled(false);
+    const QString errorString = m_mediaPlayer->errorString();
     QString message = "Error: ";
     if (errorString.isEmpty())
-        message += " #" + QString::number(int(mediaPlayer.error()));
+        message += " #" + QString::number(int(m_mediaPlayer->error()));
     else
         message += errorString;
-    errorLabel->setText(message);
+    m_errorLabel->setText(message);
 }
diff --git a/examples/multimediawidgets/videowidget/videoplayer.h b/examples/multimediawidgets/videowidget/videoplayer.h
index f9f3b692b..e62040dcc 100644
--- a/examples/multimediawidgets/videowidget/videoplayer.h
+++ b/examples/multimediawidgets/videowidget/videoplayer.h
@@ -41,10 +41,8 @@
 #ifndef VIDEOPLAYER_H
 #define VIDEOPLAYER_H
 
-#include <qmediaplayer.h>
-
-#include <QtGui/QMovie>
-#include <QtWidgets/QWidget>
+#include <QMediaPlayer>
+#include <QWidget>
 
 QT_BEGIN_NAMESPACE
 class QAbstractButton;
@@ -57,7 +55,7 @@ class VideoPlayer : public QWidget
 {
     Q_OBJECT
 public:
-    VideoPlayer(QWidget *parent = 0);
+    VideoPlayer(QWidget *parent = nullptr);
     ~VideoPlayer();
 
     void setUrl(const QUrl &url);
@@ -74,10 +72,10 @@ private slots:
     void handleError();
 
 private:
-    QMediaPlayer mediaPlayer;
-    QAbstractButton *playButton;
-    QSlider *positionSlider;
-    QLabel *errorLabel;
+    QMediaPlayer* m_mediaPlayer;
+    QAbstractButton *m_playButton;
+    QSlider *m_positionSlider;
+    QLabel *m_errorLabel;
 };
 
 #endif