Rename namespace QtMultimedia -> QMultimedia

Main code, examples, tests and docs updated. Method:
1. Mass find+replace "QtMultimedia::" -> "QMultimedia::"
2. Hand-modified declaration in qtmedianamespace.h/cpp

For consistency (with minimal disruption), namespaces with a "Qt" prefix
will be renamed.

Part of the Header Consistency Project
(http://lists.qt-project.org/pipermail/development/2012-October/007570.html)

Change-Id: I1fbc43a1aa91d996aa61869fcd8d05186bf7cf6d
Reviewed-by: Lars Knoll <lars.knoll@digia.com>
Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>

17 files changed, 171 insertions, 171 deletions

diff --git a/tests/auto/unit/qaudiodecoder/tst_qaudiodecoder.cpp b/tests/auto/unit/qaudiodecoder/tst_qaudiodecoder.cpp
index 96f9ddb9b..30b732928 100644
--- a/tests/auto/unit/qaudiodecoder/tst_qaudiodecoder.cpp
+++ b/tests/auto/unit/qaudiodecoder/tst_qaudiodecoder.cpp
@@ -348,7 +348,7 @@ void tst_QAudioDecoder::nullControl()
     QVERIFY(d.error() == QAudioDecoder::ServiceMissingError);
     QVERIFY(!d.errorString().isEmpty());
 
-    QVERIFY(d.hasSupport("MIME") == QtMultimedia::MaybeSupported);
+    QVERIFY(d.hasSupport("MIME") == QMultimedia::MaybeSupported);
 
     QVERIFY(d.state() == QAudioDecoder::StoppedState);
 
@@ -389,7 +389,7 @@ void tst_QAudioDecoder::nullService()
     QVERIFY(d.error() == QAudioDecoder::ServiceMissingError);
     QVERIFY(!d.errorString().isEmpty());
 
-    QVERIFY(d.hasSupport("MIME") == QtMultimedia::MaybeSupported);
+    QVERIFY(d.hasSupport("MIME") == QMultimedia::MaybeSupported);
 
     QVERIFY(d.state() == QAudioDecoder::StoppedState);
 
diff --git a/tests/auto/unit/qaudioprobe/tst_qaudioprobe.cpp b/tests/auto/unit/qaudioprobe/tst_qaudioprobe.cpp
index 596018c44..28fd609fa 100644
--- a/tests/auto/unit/qaudioprobe/tst_qaudioprobe.cpp
+++ b/tests/auto/unit/qaudioprobe/tst_qaudioprobe.cpp
@@ -104,7 +104,7 @@ void tst_QAudioProbe::testNullService()
     recorder = new QAudioRecorder;
 
     QVERIFY(!recorder->isAvailable());
-    QCOMPARE(recorder->availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(recorder->availability(), QMultimedia::ServiceMissing);
 
     QAudioProbe probe;
     QVERIFY(!probe.isActive());
@@ -122,7 +122,7 @@ void tst_QAudioProbe::testNullControl()
     recorder = new QAudioRecorder;
 
     QVERIFY(!recorder->isAvailable());
-    QCOMPARE(recorder->availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(recorder->availability(), QMultimedia::ServiceMissing);
 
     QAudioProbe probe;
     QVERIFY(!probe.isActive());
diff --git a/tests/auto/unit/qaudiorecorder/tst_qaudiorecorder.cpp b/tests/auto/unit/qaudiorecorder/tst_qaudiorecorder.cpp
index f2df23478..339fe9a83 100644
--- a/tests/auto/unit/qaudiorecorder/tst_qaudiorecorder.cpp
+++ b/tests/auto/unit/qaudiorecorder/tst_qaudiorecorder.cpp
@@ -106,7 +106,7 @@ void tst_QAudioRecorder::testNullService()
     QAudioRecorder source;
 
     QVERIFY(!source.isAvailable());
-    QCOMPARE(source.availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(source.availability(), QMultimedia::ServiceMissing);
 
     QCOMPARE(source.audioInputs().size(), 0);
     QCOMPARE(source.defaultAudioInput(), QString());
@@ -120,7 +120,7 @@ void tst_QAudioRecorder::testNullControl()
     QAudioRecorder source;
 
     QVERIFY(!source.isAvailable());
-    QCOMPARE(source.availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(source.availability(), QMultimedia::ServiceMissing);
 
     QCOMPARE(source.audioInputs().size(), 0);
     QCOMPARE(source.defaultAudioInput(), QString());
@@ -163,7 +163,7 @@ void tst_QAudioRecorder::testAvailability()
     QAudioRecorder source;
 
     QVERIFY(source.isAvailable());
-    QCOMPARE(source.availability(), QtMultimedia::Available);
+    QCOMPARE(source.availability(), QMultimedia::Available);
 }
 
 void tst_QAudioRecorder::testAvailableAudioInputChangedSignal()
diff --git a/tests/auto/unit/qcamera/tst_qcamera.cpp b/tests/auto/unit/qcamera/tst_qcamera.cpp
index a39945c3c..8f6339bf6 100644
--- a/tests/auto/unit/qcamera/tst_qcamera.cpp
+++ b/tests/auto/unit/qcamera/tst_qcamera.cpp
@@ -778,9 +778,9 @@ void tst_QCamera::testImageSettings()
     QVERIFY(settings != QImageEncoderSettings());
 
     settings = QImageEncoderSettings();
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
-    settings.setQuality(QtMultimedia::HighQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
+    settings.setQuality(QMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::HighQuality);
     QVERIFY(!settings.isNull());
 
     settings = QImageEncoderSettings();
@@ -808,7 +808,7 @@ void tst_QCamera::testImageSettings()
     settings = QImageEncoderSettings();
     QVERIFY(settings.isNull());
     QCOMPARE(settings.codec(), QString());
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
     QCOMPARE(settings.resolution(), QSize());
     QVERIFY(settings.encodingOptions().isEmpty());
 
@@ -821,7 +821,7 @@ void tst_QCamera::testImageSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -837,7 +837,7 @@ void tst_QCamera::testImageSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -864,11 +864,11 @@ void tst_QCamera::testImageSettings()
     QVERIFY(settings1 != settings2);
 
     settings1 = QImageEncoderSettings();
-    settings1.setQuality(QtMultimedia::NormalQuality);
+    settings1.setQuality(QMultimedia::NormalQuality);
     settings2 = QImageEncoderSettings();
-    settings2.setQuality(QtMultimedia::NormalQuality);
+    settings2.setQuality(QMultimedia::NormalQuality);
     QVERIFY(settings1 == settings2);
-    settings2.setQuality(QtMultimedia::LowQuality);
+    settings2.setQuality(QMultimedia::LowQuality);
     QVERIFY(settings1 != settings2);
 
     settings1 = QImageEncoderSettings();
@@ -1233,7 +1233,7 @@ void tst_QCamera::testQCameraIsAvailable()
 {
     QCamera camera;
     QVERIFY(camera.isAvailable());
-    QVERIFY(camera.availability() == QtMultimedia::Available);
+    QVERIFY(camera.availability() == QMultimedia::Available);
 }
 
 void tst_QCamera::testQCameraIsNotAvailable()
@@ -1243,7 +1243,7 @@ void tst_QCamera::testQCameraIsNotAvailable()
 
     QCOMPARE(camera.error(), QCamera::ServiceMissingError);
     QVERIFY(!camera.isAvailable());
-    QCOMPARE(camera.availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(camera.availability(), QMultimedia::ServiceMissing);
 }
 
 /* Test case for searchAndLock ( QCamera::LockTypes locks ) */
diff --git a/tests/auto/unit/qcameraimagecapture/tst_qcameraimagecapture.cpp b/tests/auto/unit/qcameraimagecapture/tst_qcameraimagecapture.cpp
index 2f195b788..438802a82 100644
--- a/tests/auto/unit/qcameraimagecapture/tst_qcameraimagecapture.cpp
+++ b/tests/auto/unit/qcameraimagecapture/tst_qcameraimagecapture.cpp
@@ -260,11 +260,11 @@ void tst_QCameraImageCapture::encodingSettings()
     QVERIFY(imageCapture.encodingSettings() == QImageEncoderSettings());
     QImageEncoderSettings settings;
     settings.setCodec("JPEG");
-    settings.setQuality(QtMultimedia::NormalQuality);
+    settings.setQuality(QMultimedia::NormalQuality);
     imageCapture.setEncodingSettings(settings);
     QVERIFY(!imageCapture.encodingSettings().isNull());
     QVERIFY(imageCapture.encodingSettings().codec() == "JPEG");
-    QVERIFY(imageCapture.encodingSettings().quality() == QtMultimedia::NormalQuality);
+    QVERIFY(imageCapture.encodingSettings().quality() == QMultimedia::NormalQuality);
 }
 
 //MaemoAPI-1838:test supportedImageCodecs
@@ -312,7 +312,7 @@ void tst_QCameraImageCapture::errors()
     imageCapture1.capture(QString::fromLatin1("/dev/null"));
     QVERIFY(imageCapture1.error() == QCameraImageCapture::NotSupportedFeatureError);
     QVERIFY2(!imageCapture1.errorString().isEmpty(), "Device does not support images capture");
-    QVERIFY(imageCapture1.availability() == QtMultimedia::ServiceMissing);
+    QVERIFY(imageCapture1.availability() == QMultimedia::ServiceMissing);
 
     provider->service = mockcameraservice;
 
@@ -321,12 +321,12 @@ void tst_QCameraImageCapture::errors()
     QVERIFY(imageCapture.isAvailable() == true);
     QVERIFY(imageCapture.error() == QCameraImageCapture::NoError);
     QVERIFY(imageCapture.errorString().isEmpty());
-    QVERIFY(imageCapture.availability() == QtMultimedia::Available);
+    QVERIFY(imageCapture.availability() == QMultimedia::Available);
 
     imageCapture.capture();
     QVERIFY(imageCapture.error() == QCameraImageCapture::NotReadyError);
     QVERIFY2(!imageCapture.errorString().isEmpty(), "Could not capture in stopped state");
-    QVERIFY(imageCapture.availability() == QtMultimedia::Available);
+    QVERIFY(imageCapture.availability() == QMultimedia::Available);
 }
 
 //MaemoAPI-1831:test error
diff --git a/tests/auto/unit/qmediaobject/tst_qmediaobject.cpp b/tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
index 1b83e1af0..71524fecd 100644
--- a/tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
+++ b/tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
@@ -441,52 +441,52 @@ void tst_QMediaObject::availability()
     {
         QtTestMediaObject nullObject(0);
         QCOMPARE(nullObject.isAvailable(), false);
-        QCOMPARE(nullObject.availability(), QtMultimedia::ServiceMissing);
+        QCOMPARE(nullObject.availability(), QMultimedia::ServiceMissing);
     }
 
     {
         QtTestMediaObjectService service;
         QtTestMediaObject object(&service);
         QCOMPARE(object.isAvailable(), true);
-        QCOMPARE(object.availability(), QtMultimedia::Available);
+        QCOMPARE(object.availability(), QMultimedia::Available);
     }
 
     {
-        MockAvailabilityControl available(QtMultimedia::Available);
+        MockAvailabilityControl available(QMultimedia::Available);
         QtTestMediaObjectService service(0, &available);
         QtTestMediaObject object(&service);
         QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
-        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
+        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
 
         QCOMPARE(object.isAvailable(), true);
-        QCOMPARE(object.availability(), QtMultimedia::Available);
+        QCOMPARE(object.availability(), QMultimedia::Available);
 
-        available.setAvailability(QtMultimedia::Busy);
+        available.setAvailability(QMultimedia::Busy);
         QCOMPARE(object.isAvailable(), false);
-        QCOMPARE(object.availability(), QtMultimedia::Busy);
+        QCOMPARE(object.availability(), QMultimedia::Busy);
         QCOMPARE(availabilitySpy.count(), 1);
         QCOMPARE(availabilityStatusSpy.count(), 1);
 
-        available.setAvailability(QtMultimedia::Available);
+        available.setAvailability(QMultimedia::Available);
         QCOMPARE(object.isAvailable(), true);
-        QCOMPARE(object.availability(), QtMultimedia::Available);
+        QCOMPARE(object.availability(), QMultimedia::Available);
         QCOMPARE(availabilitySpy.count(), 2);
         QCOMPARE(availabilityStatusSpy.count(), 2);
     }
 
     {
-        MockAvailabilityControl available(QtMultimedia::Busy);
+        MockAvailabilityControl available(QMultimedia::Busy);
         QtTestMediaObjectService service(0, &available);
         QtTestMediaObject object(&service);
         QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
-        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
+        QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
 
         QCOMPARE(object.isAvailable(), false);
-        QCOMPARE(object.availability(), QtMultimedia::Busy);
+        QCOMPARE(object.availability(), QMultimedia::Busy);
 
-        available.setAvailability(QtMultimedia::Available);
+        available.setAvailability(QMultimedia::Available);
         QCOMPARE(object.isAvailable(), true);
-        QCOMPARE(object.availability(), QtMultimedia::Available);
+        QCOMPARE(object.availability(), QMultimedia::Available);
         QCOMPARE(availabilitySpy.count(), 1);
         QCOMPARE(availabilityStatusSpy.count(), 1);
     }
diff --git a/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp b/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
index 2745bd921..5af1e5ed3 100644
--- a/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
+++ b/tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
@@ -222,7 +222,7 @@ void tst_QMediaPlayer::testNullService()
     QCOMPARE(player.playbackRate(), qreal(0));
     QCOMPARE(player.error(), QMediaPlayer::ServiceMissingError);
     QCOMPARE(player.isAvailable(), false);
-    QCOMPARE(player.availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(player.availability(), QMultimedia::ServiceMissing);
 
     {
         QFETCH_GLOBAL(QMediaContent, mediaContent);
@@ -501,7 +501,7 @@ void tst_QMediaPlayer::testErrorString()
 void tst_QMediaPlayer::testIsAvailable()
 {
     QCOMPARE(player->isAvailable(), true);
-    QCOMPARE(player->availability(), QtMultimedia::Available);
+    QCOMPARE(player->availability(), QMultimedia::Available);
 }
 
 void tst_QMediaPlayer::testService()
diff --git a/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp b/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
index c544e990b..1251f9f95 100644
--- a/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
+++ b/tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
@@ -215,7 +215,7 @@ void tst_QMediaRecorder::testNullControls()
 
     QAudioEncoderSettings audio;
     audio.setCodec(id);
-    audio.setQuality(QtMultimedia::LowQuality);
+    audio.setQuality(QMultimedia::LowQuality);
 
     QVideoEncoderSettings video;
     video.setCodec(id);
@@ -447,18 +447,18 @@ void tst_QMediaRecorder::testEncodingSettings()
     QCOMPARE(audioSettings.codec(), QString("audio/pcm"));
     QCOMPARE(audioSettings.bitRate(), 128*1024);
     QCOMPARE(audioSettings.sampleRate(), 8000);
-    QCOMPARE(audioSettings.quality(), QtMultimedia::NormalQuality);
+    QCOMPARE(audioSettings.quality(), QMultimedia::NormalQuality);
     QCOMPARE(audioSettings.channelCount(), -1);
 
-    QCOMPARE(audioSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
+    QCOMPARE(audioSettings.encodingMode(), QMultimedia::ConstantQualityEncoding);
 
     QVideoEncoderSettings videoSettings = capture->videoSettings();
     QCOMPARE(videoSettings.codec(), QString());
     QCOMPARE(videoSettings.bitRate(), -1);
     QCOMPARE(videoSettings.resolution(), QSize());
     QCOMPARE(videoSettings.frameRate(), 0.0);
-    QCOMPARE(videoSettings.quality(), QtMultimedia::NormalQuality);
-    QCOMPARE(videoSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
+    QCOMPARE(videoSettings.quality(), QMultimedia::NormalQuality);
+    QCOMPARE(videoSettings.encodingMode(), QMultimedia::ConstantQualityEncoding);
 
     QString format = capture->containerFormat();
     QCOMPARE(format, QString());
@@ -466,15 +466,15 @@ void tst_QMediaRecorder::testEncodingSettings()
     audioSettings.setCodec("audio/mpeg");
     audioSettings.setSampleRate(44100);
     audioSettings.setBitRate(256*1024);
-    audioSettings.setQuality(QtMultimedia::HighQuality);
-    audioSettings.setEncodingMode(QtMultimedia::AverageBitRateEncoding);
+    audioSettings.setQuality(QMultimedia::HighQuality);
+    audioSettings.setEncodingMode(QMultimedia::AverageBitRateEncoding);
 
     videoSettings.setCodec("video/3gpp");
     videoSettings.setBitRate(800);
     videoSettings.setFrameRate(24*1024);
     videoSettings.setResolution(QSize(800,600));
-    videoSettings.setQuality(QtMultimedia::HighQuality);
-    audioSettings.setEncodingMode(QtMultimedia::TwoPassEncoding);
+    videoSettings.setQuality(QMultimedia::HighQuality);
+    audioSettings.setEncodingMode(QMultimedia::TwoPassEncoding);
 
     format = QString("mov");
 
@@ -506,9 +506,9 @@ void tst_QMediaRecorder::testAudioSettings()
     QVERIFY(!settings.isNull());
 
     settings = QAudioEncoderSettings();
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
-    settings.setQuality(QtMultimedia::HighQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
+    settings.setQuality(QMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::HighQuality);
     QVERIFY(!settings.isNull());
 
     settings = QAudioEncoderSettings();
@@ -541,7 +541,7 @@ void tst_QMediaRecorder::testAudioSettings()
     QVERIFY(settings.isNull());
     QCOMPARE(settings.codec(), QString());
     QCOMPARE(settings.bitRate(), -1);
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
     QCOMPARE(settings.sampleRate(), -1);
     QVERIFY(settings.encodingOptions().isEmpty());
 
@@ -554,7 +554,7 @@ void tst_QMediaRecorder::testAudioSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -570,7 +570,7 @@ void tst_QMediaRecorder::testAudioSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -602,19 +602,19 @@ void tst_QMediaRecorder::testAudioSettings()
     QVERIFY(settings1 != settings2);
 
     settings1 = QAudioEncoderSettings();
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings2 = QAudioEncoderSettings();
-    settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     QVERIFY(settings1 == settings2);
-    settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
+    settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
     QVERIFY(settings1 != settings2);
 
     settings1 = QAudioEncoderSettings();
-    settings1.setQuality(QtMultimedia::NormalQuality);
+    settings1.setQuality(QMultimedia::NormalQuality);
     settings2 = QAudioEncoderSettings();
-    settings2.setQuality(QtMultimedia::NormalQuality);
+    settings2.setQuality(QMultimedia::NormalQuality);
     QVERIFY(settings1 == settings2);
-    settings2.setQuality(QtMultimedia::LowQuality);
+    settings2.setQuality(QMultimedia::LowQuality);
     QVERIFY(settings1 != settings2);
 
     settings1 = QAudioEncoderSettings();
@@ -653,9 +653,9 @@ void tst_QMediaRecorder::testVideoSettings()
     QVERIFY(!settings.isNull());
 
     settings = QVideoEncoderSettings();
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
-    settings.setQuality(QtMultimedia::HighQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
+    settings.setQuality(QMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::HighQuality);
     QVERIFY(!settings.isNull());
 
     settings = QVideoEncoderSettings();
@@ -692,7 +692,7 @@ void tst_QMediaRecorder::testVideoSettings()
     QVERIFY(settings.isNull());
     QCOMPARE(settings.codec(), QString());
     QCOMPARE(settings.bitRate(), -1);
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
     QCOMPARE(settings.frameRate(), qreal());
     QCOMPARE(settings.resolution(), QSize());
     QVERIFY(settings.encodingOptions().isEmpty());
@@ -706,7 +706,7 @@ void tst_QMediaRecorder::testVideoSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -722,7 +722,7 @@ void tst_QMediaRecorder::testVideoSettings()
         QCOMPARE(settings2, settings1);
         QVERIFY(settings2.isNull());
 
-        settings1.setQuality(QtMultimedia::HighQuality);
+        settings1.setQuality(QMultimedia::HighQuality);
 
         QVERIFY(settings2.isNull());
         QVERIFY(!settings1.isNull());
@@ -754,19 +754,19 @@ void tst_QMediaRecorder::testVideoSettings()
     QVERIFY(settings1 != settings2);
 
     settings1 = QVideoEncoderSettings();
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings2 = QVideoEncoderSettings();
-    settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     QVERIFY(settings1 == settings2);
-    settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
+    settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
     QVERIFY(settings1 != settings2);
 
     settings1 = QVideoEncoderSettings();
-    settings1.setQuality(QtMultimedia::NormalQuality);
+    settings1.setQuality(QMultimedia::NormalQuality);
     settings2 = QVideoEncoderSettings();
-    settings2.setQuality(QtMultimedia::NormalQuality);
+    settings2.setQuality(QMultimedia::NormalQuality);
     QVERIFY(settings1 == settings2);
-    settings2.setQuality(QtMultimedia::LowQuality);
+    settings2.setQuality(QMultimedia::LowQuality);
     QVERIFY(settings1 != settings2);
 
     settings1 = QVideoEncoderSettings();
@@ -803,7 +803,7 @@ void tst_QMediaRecorder::testSettingsApplied()
     recorder.setVideoSettings(videoSettings);
 
     QAudioEncoderSettings audioSettings;
-    audioSettings.setQuality(QtMultimedia::HighQuality);
+    audioSettings.setQuality(QMultimedia::HighQuality);
     recorder.setAudioSettings(audioSettings);
 
     recorder.setContainerFormat("mkv");
@@ -812,7 +812,7 @@ void tst_QMediaRecorder::testSettingsApplied()
     QTRY_COMPARE(recorderControl.m_settingAppliedCount, 2);
 
     //encoder settings are applied before recording if changed
-    audioSettings.setQuality(QtMultimedia::VeryHighQuality);
+    audioSettings.setQuality(QMultimedia::VeryHighQuality);
     recorder.setAudioSettings(audioSettings);
 
     QCOMPARE(recorderControl.m_settingAppliedCount, 2);
@@ -1010,8 +1010,8 @@ void tst_QMediaRecorder::testAudioSettingsCopyConstructor()
     audiosettings.setBitRate(128*1000);
     audiosettings.setChannelCount(4);
     audiosettings.setCodec("audio/pcm");
-    audiosettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings.setQuality(QtMultimedia::LowQuality);
+    audiosettings.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings.setQuality(QMultimedia::LowQuality);
     audiosettings.setSampleRate(44100);
 
     /* Copy constructor */
@@ -1040,16 +1040,16 @@ void tst_QMediaRecorder::testAudioSettingsOperatorNotEqual()
     audiosettings1.setBitRate(128*1000);
     audiosettings1.setChannelCount(4);
     audiosettings1.setCodec("audio/pcm");
-    audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings1.setQuality(QtMultimedia::LowQuality);
+    audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings1.setQuality(QMultimedia::LowQuality);
     audiosettings1.setSampleRate(44100);
 
     /* setting the desired properties for the AudioEncoder */
     audiosettings2.setBitRate(128*1000);
     audiosettings2.setChannelCount(4);
     audiosettings2.setCodec("audio/pcm");
-    audiosettings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings2.setQuality(QtMultimedia::LowQuality);
+    audiosettings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings2.setQuality(QMultimedia::LowQuality);
     audiosettings2.setSampleRate(44100);
 
     /* verify the both are equal or not */
@@ -1057,7 +1057,7 @@ void tst_QMediaRecorder::testAudioSettingsOperatorNotEqual()
 
     /* Modify the settings value for one object */
     audiosettings2.setBitRate(64*1000);
-    audiosettings2.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
+    audiosettings2.setEncodingMode(QMultimedia::ConstantQualityEncoding);
 
     /* verify the not equal opertor */
     QVERIFY(audiosettings1 != audiosettings2);
@@ -1076,8 +1076,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorEqual()
     audiosettings1.setBitRate(128*1000);
     audiosettings1.setChannelCount(4);
     audiosettings1.setCodec("audio/pcm");
-    audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings1.setQuality(QtMultimedia::LowQuality);
+    audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings1.setQuality(QMultimedia::LowQuality);
     audiosettings1.setSampleRate(44100);
 
     QAudioEncoderSettings audiosettings2;
@@ -1087,8 +1087,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorEqual()
     audiosettings2.setBitRate(128*1000);
     audiosettings2.setChannelCount(4);
     audiosettings2.setCodec("audio/pcm");
-    audiosettings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings2.setQuality(QtMultimedia::LowQuality);
+    audiosettings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings2.setQuality(QMultimedia::LowQuality);
     audiosettings2.setSampleRate(44100);
 
     /* verify both the values are same or not */
@@ -1108,8 +1108,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorAssign()
     audiosettings1.setBitRate(128*1000);
     audiosettings1.setChannelCount(4);
     audiosettings1.setCodec("audio/pcm");
-    audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    audiosettings1.setQuality(QtMultimedia::LowQuality);
+    audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    audiosettings1.setQuality(QMultimedia::LowQuality);
     audiosettings1.setSampleRate(44100);
 
     QAudioEncoderSettings audiosettings2;
@@ -1141,7 +1141,7 @@ void tst_QMediaRecorder::testAvailabilityStatus()
         MockMediaRecorderService service(0, 0);
         MockMediaObject object(0, &service);
         QMediaRecorder recorder(&object);
-        QCOMPARE(recorder.availability(), QtMultimedia::ServiceMissing);
+        QCOMPARE(recorder.availability(), QMultimedia::ServiceMissing);
         QCOMPARE(recorder.isAvailable(), false);
     }
     {
@@ -1150,7 +1150,7 @@ void tst_QMediaRecorder::testAvailabilityStatus()
         service1.mockMetaDataControl->populateMetaData();
         MockMediaObject object1(0, &service1);
         QMediaRecorder recorder1(&object1);
-        QCOMPARE(recorder1.availability(), QtMultimedia::Available);
+        QCOMPARE(recorder1.availability(), QMultimedia::Available);
         QCOMPARE(recorder1.isAvailable(), true);
     }
     {
@@ -1160,29 +1160,29 @@ void tst_QMediaRecorder::testAvailabilityStatus()
         MockMediaObject object1(0, &service1);
         QMediaRecorder recorder1(&object1);
 
-        QCOMPARE(recorder1.availability(), QtMultimedia::Available);
+        QCOMPARE(recorder1.availability(), QMultimedia::Available);
         QCOMPARE(recorder1.isAvailable(), true);
     }
     {
         MockMediaRecorderControl recorderControl(0);
-        MockAvailabilityControl availability(QtMultimedia::Available);
+        MockAvailabilityControl availability(QMultimedia::Available);
         MockMediaRecorderService service1(0, &recorderControl, &availability);
         service1.mockMetaDataControl->populateMetaData();
         MockMediaObject object1(0, &service1);
         QMediaRecorder recorder1(&object1);
 
-        QSignalSpy spy(&object1, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
+        QSignalSpy spy(&object1, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
 
-        QCOMPARE(recorder1.availability(), QtMultimedia::Available);
+        QCOMPARE(recorder1.availability(), QMultimedia::Available);
         QCOMPARE(recorder1.isAvailable(), true);
 
-        availability.setAvailability(QtMultimedia::Busy);
-        QCOMPARE(recorder1.availability(), QtMultimedia::Busy);
+        availability.setAvailability(QMultimedia::Busy);
+        QCOMPARE(recorder1.availability(), QMultimedia::Busy);
         QCOMPARE(recorder1.isAvailable(), false);
         QCOMPARE(spy.count(), 1);
 
-        availability.setAvailability(QtMultimedia::Available);
-        QCOMPARE(recorder1.availability(), QtMultimedia::Available);
+        availability.setAvailability(QMultimedia::Available);
+        QCOMPARE(recorder1.availability(), QMultimedia::Available);
         QCOMPARE(recorder1.isAvailable(), true);
         QCOMPARE(spy.count(), 2);
     }
@@ -1246,21 +1246,21 @@ void tst_QMediaRecorder::testVideoSettingsQuality()
     QVERIFY(settings == QVideoEncoderSettings());
 
     /* Verify the default value is intialised correctly*/
-    QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+    QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
 
     /* Set all types of Quality parameter and Verify if it is set correctly*/
-    settings.setQuality(QtMultimedia::HighQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
+    settings.setQuality(QMultimedia::HighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::HighQuality);
     QVERIFY(!settings.isNull());
 
-    settings.setQuality(QtMultimedia::VeryLowQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::VeryLowQuality);
+    settings.setQuality(QMultimedia::VeryLowQuality);
+    QCOMPARE(settings.quality(), QMultimedia::VeryLowQuality);
 
-    settings.setQuality(QtMultimedia::LowQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::LowQuality);
+    settings.setQuality(QMultimedia::LowQuality);
+    QCOMPARE(settings.quality(), QMultimedia::LowQuality);
 
-    settings.setQuality(QtMultimedia::VeryHighQuality);
-    QCOMPARE(settings.quality(), QtMultimedia::VeryHighQuality);
+    settings.setQuality(QMultimedia::VeryHighQuality);
+    QCOMPARE(settings.quality(), QMultimedia::VeryHighQuality);
 }
 
 /* Test  QVideoEncoderSettings encodingMode */
@@ -1272,19 +1272,19 @@ void tst_QMediaRecorder::testVideoSettingsEncodingMode()
     QVERIFY(settings == QVideoEncoderSettings());
 
     /* Verify the default values are initialised correctly*/
-    QCOMPARE(settings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
+    QCOMPARE(settings.encodingMode(), QMultimedia::ConstantQualityEncoding);
     QVERIFY(settings.isNull());
 
     /* Set each type of encoding mode and Verify if it is set correctly*/
-    settings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
-    QCOMPARE(settings.encodingMode(),QtMultimedia::ConstantBitRateEncoding);
+    settings.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
+    QCOMPARE(settings.encodingMode(),QMultimedia::ConstantBitRateEncoding);
     QVERIFY(!settings.isNull());
 
-    settings.setEncodingMode(QtMultimedia::AverageBitRateEncoding);
-    QCOMPARE(settings.encodingMode(), QtMultimedia::AverageBitRateEncoding);
+    settings.setEncodingMode(QMultimedia::AverageBitRateEncoding);
+    QCOMPARE(settings.encodingMode(), QMultimedia::AverageBitRateEncoding);
 
-    settings.setEncodingMode(QtMultimedia::TwoPassEncoding);
-    QCOMPARE(settings.encodingMode(), QtMultimedia::TwoPassEncoding);
+    settings.setEncodingMode(QMultimedia::TwoPassEncoding);
+    QCOMPARE(settings.encodingMode(), QMultimedia::TwoPassEncoding);
 }
 
 /* Test QVideoEncoderSettings copy constructor */
@@ -1294,8 +1294,8 @@ void tst_QMediaRecorder::testVideoSettingsCopyConstructor()
     QVideoEncoderSettings settings1;
     settings1.setCodec(QLatin1String("codecName"));
     settings1.setBitRate(128000);
-    settings1.setQuality(QtMultimedia::HighQuality);
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setQuality(QMultimedia::HighQuality);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings1.setFrameRate(30000.0/10001);
     settings1.setResolution(QSize(320,240));
 
@@ -1306,10 +1306,10 @@ void tst_QMediaRecorder::testVideoSettingsCopyConstructor()
     QCOMPARE(settings2 != settings1, false);
     QCOMPARE(settings2.codec(), QLatin1String("codecName"));
     QCOMPARE(settings2.bitRate(), 128000);
-    QCOMPARE(settings2.encodingMode(), QtMultimedia::ConstantBitRateEncoding);
+    QCOMPARE(settings2.encodingMode(), QMultimedia::ConstantBitRateEncoding);
     QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
     QCOMPARE(settings2.resolution(), QSize(320,240));
-    QCOMPARE(settings2.quality(), QtMultimedia::HighQuality);
+    QCOMPARE(settings2.quality(), QMultimedia::HighQuality);
 
     /* Verify both the instances are equal*/
     QCOMPARE(settings2, settings1);
@@ -1328,10 +1328,10 @@ void tst_QMediaRecorder::testVideoSettingsOperatorAssignment()
     /* Initialize all the parameters */
     settings1.setCodec(QLatin1String("codecName"));
     settings1.setBitRate(128000);
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings1.setFrameRate(30000.0/10001);
     settings1.setResolution(QSize(320,240));
-    settings1.setQuality(QtMultimedia::HighQuality);
+    settings1.setQuality(QMultimedia::HighQuality);
     /* Assign one object to other*/
     settings2 = settings1;
 
@@ -1339,10 +1339,10 @@ void tst_QMediaRecorder::testVideoSettingsOperatorAssignment()
     QCOMPARE(settings2, settings1);
     QCOMPARE(settings2.codec(), QLatin1String("codecName"));
     QCOMPARE(settings2.bitRate(), 128000);
-    QCOMPARE(settings2.encodingMode(), QtMultimedia::ConstantBitRateEncoding);
+    QCOMPARE(settings2.encodingMode(), QMultimedia::ConstantBitRateEncoding);
     QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
     QCOMPARE(settings2.resolution(), QSize(320,240));
-    QCOMPARE(settings2.quality(), QtMultimedia::HighQuality);
+    QCOMPARE(settings2.quality(), QMultimedia::HighQuality);
     QCOMPARE(settings2, settings1);
     QVERIFY(!settings2.isNull());
 }
@@ -1385,23 +1385,23 @@ void tst_QMediaRecorder::testVideoSettingsOperatorNotEqual()
 
     /* Verify EncodingMode with not equal operator*/
     settings1 = QVideoEncoderSettings();
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings2 = QVideoEncoderSettings();
-    settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     /* OperatorNotEqual returns false when both objects are equal*/
     QCOMPARE(settings1 != settings2, false);
-    settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
+    settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
     /* OperatorNotEqual returns true when both objects are not equal*/
     QVERIFY(settings1 != settings2);
 
     /* Verify Quality with not equal operator*/
     settings1 = QVideoEncoderSettings();
-    settings1.setQuality(QtMultimedia::NormalQuality);
+    settings1.setQuality(QMultimedia::NormalQuality);
     settings2 = QVideoEncoderSettings();
-    settings2.setQuality(QtMultimedia::NormalQuality);
+    settings2.setQuality(QMultimedia::NormalQuality);
     /* OperatorNotEqual returns false when both objects are equal*/
     QCOMPARE(settings1 != settings2, false);
-    settings2.setQuality(QtMultimedia::LowQuality);
+    settings2.setQuality(QMultimedia::LowQuality);
     /* OperatorNotEqual returns true when both objects are not equal*/
     QVERIFY(settings1 != settings2);
 
@@ -1456,23 +1456,23 @@ void tst_QMediaRecorder::testVideoSettingsOperatorComparison()
 
     /* Verify EncodingMode with comparison operator*/
     settings1 = QVideoEncoderSettings();
-    settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     settings2 = QVideoEncoderSettings();
-    settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
+    settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
     /* Comparison operator returns true when both objects are equal*/
     QVERIFY(settings1 == settings2);
-    settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
+    settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
     /* Comparison operator returns false when both objects are not equal*/
     QCOMPARE(settings1 == settings2, false);
 
     /* Verify Quality with comparison operator*/
     settings1 = QVideoEncoderSettings();
-    settings1.setQuality(QtMultimedia::NormalQuality);
+    settings1.setQuality(QMultimedia::NormalQuality);
     settings2 = QVideoEncoderSettings();
-    settings2.setQuality(QtMultimedia::NormalQuality);
+    settings2.setQuality(QMultimedia::NormalQuality);
     /* Comparison operator returns true when both objects are equal*/
     QVERIFY(settings1 == settings2);
-    settings2.setQuality(QtMultimedia::LowQuality);
+    settings2.setQuality(QMultimedia::LowQuality);
     /* Comparison operator returns false when both objects are not equal*/
     QCOMPARE(settings1 == settings2, false);
 
diff --git a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp
index 42d75ff7c..9faf75e45 100644
--- a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp
@@ -71,16 +71,16 @@ public:
         delete service;
     }
 
-    QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+    QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
     {
         if (codecs.contains(QLatin1String("mpeg4")))
-            return QtMultimedia::NotSupported;
+            return QMultimedia::NotSupported;
 
         if (mimeType == "audio/ogg") {
-            return QtMultimedia::ProbablySupported;
+            return QMultimedia::ProbablySupported;
         }
 
-        return QtMultimedia::MaybeSupported;
+        return QMultimedia::MaybeSupported;
     }
 
     QStringList supportedMimeTypes() const
diff --git a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
index a4f16b44a..7295003ae 100644
--- a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
@@ -71,14 +71,14 @@ public:
         delete service;
     }
 
-    QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+    QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
     {
         Q_UNUSED(codecs);
 
         if (mimeType == "audio/wav")
-            return QtMultimedia::PreferredService;
+            return QMultimedia::PreferredService;
 
-        return QtMultimedia::NotSupported;
+        return QMultimedia::NotSupported;
     }
 
     QStringList supportedMimeTypes() const
diff --git a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
index 9694040b9..1982c5cd1 100644
--- a/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
@@ -70,15 +70,15 @@ public:
         delete service;
     }
 
-    QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+    QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
     {
         if (codecs.contains(QLatin1String("jpeg2000")))
-            return QtMultimedia::NotSupported;
+            return QMultimedia::NotSupported;
 
         if (supportedMimeTypes().contains(mimeType))
-            return QtMultimedia::ProbablySupported;
+            return QMultimedia::ProbablySupported;
 
-        return QtMultimedia::MaybeSupported;
+        return QMultimedia::MaybeSupported;
     }
 
     QStringList supportedMimeTypes() const
diff --git a/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp b/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
index c2d2d2d96..8557c57a1 100644
--- a/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
+++ b/tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
@@ -119,7 +119,7 @@ void tst_QMediaServiceProvider::testHasSupport()
 {
     MockMediaServiceProvider mockProvider;
     QCOMPARE(mockProvider.hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/ogv", QStringList()),
-             QtMultimedia::MaybeSupported);
+             QMultimedia::MaybeSupported);
 
     QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
 
@@ -127,44 +127,44 @@ void tst_QMediaServiceProvider::testHasSupport()
         QSKIP("No default provider");
 
     QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/ogv", QStringList()),
-             QtMultimedia::MaybeSupported);
+             QMultimedia::MaybeSupported);
 
     QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "audio/ogg", QStringList()),
-             QtMultimedia::ProbablySupported);
+             QMultimedia::ProbablySupported);
 
     //while the service returns PreferredService, provider should return ProbablySupported
     QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "audio/wav", QStringList()),
-             QtMultimedia::ProbablySupported);
+             QMultimedia::ProbablySupported);
 
     //even while all the plugins with "hasSupport" returned NotSupported,
     //MockServicePlugin3 has no "hasSupport" interface, so MaybeSupported
     QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/avi",
                                   QStringList() << "mpeg4"),
-             QtMultimedia::MaybeSupported);
+             QMultimedia::MaybeSupported);
 
     QCOMPARE(provider->hasSupport(QByteArray("non existing service"), "video/ogv", QStringList()),
-             QtMultimedia::NotSupported);
+             QMultimedia::NotSupported);
 
-    QCOMPARE(QMediaPlayer::hasSupport("video/ogv"), QtMultimedia::MaybeSupported);
-    QCOMPARE(QMediaPlayer::hasSupport("audio/ogg"), QtMultimedia::ProbablySupported);
-    QCOMPARE(QMediaPlayer::hasSupport("audio/wav"), QtMultimedia::ProbablySupported);
+    QCOMPARE(QMediaPlayer::hasSupport("video/ogv"), QMultimedia::MaybeSupported);
+    QCOMPARE(QMediaPlayer::hasSupport("audio/ogg"), QMultimedia::ProbablySupported);
+    QCOMPARE(QMediaPlayer::hasSupport("audio/wav"), QMultimedia::ProbablySupported);
 
     //test low latency flag support
     QCOMPARE(QMediaPlayer::hasSupport("audio/wav", QStringList(), QMediaPlayer::LowLatency),
-             QtMultimedia::ProbablySupported);
+             QMultimedia::ProbablySupported);
     //plugin1 probably supports audio/ogg, it checked because it doesn't provide features iface
     QCOMPARE(QMediaPlayer::hasSupport("audio/ogg", QStringList(), QMediaPlayer::LowLatency),
-             QtMultimedia::ProbablySupported);
+             QMultimedia::ProbablySupported);
     //Plugin4 is not checked here, sine it's known not support low latency
     QCOMPARE(QMediaPlayer::hasSupport("video/quicktime", QStringList(), QMediaPlayer::LowLatency),
-             QtMultimedia::MaybeSupported);
+             QMultimedia::MaybeSupported);
 
     //test streaming flag support
     QCOMPARE(QMediaPlayer::hasSupport("video/quicktime", QStringList(), QMediaPlayer::StreamPlayback),
-             QtMultimedia::ProbablySupported);
+             QMultimedia::ProbablySupported);
     //Plugin2 is not checked here, sine it's known not support streaming
     QCOMPARE(QMediaPlayer::hasSupport("audio/wav", QStringList(), QMediaPlayer::StreamPlayback),
-             QtMultimedia::MaybeSupported);
+             QMultimedia::MaybeSupported);
 
     //ensure the correct media player plugin is chosen for mime type
     QMediaPlayer simplePlayer(0, QMediaPlayer::LowLatency);
diff --git a/tests/auto/unit/qmultimedia_common/mockavailabilitycontrol.h b/tests/auto/unit/qmultimedia_common/mockavailabilitycontrol.h
index 159abf9bd..c63b62d6b 100644
--- a/tests/auto/unit/qmultimedia_common/mockavailabilitycontrol.h
+++ b/tests/auto/unit/qmultimedia_common/mockavailabilitycontrol.h
@@ -50,18 +50,18 @@ class MockAvailabilityControl : public QMediaAvailabilityControl
     Q_OBJECT
 
 public:
-    MockAvailabilityControl(QtMultimedia::AvailabilityStatus available)
+    MockAvailabilityControl(QMultimedia::AvailabilityStatus available)
         : m_availability(available)
     {
 
     }
 
-    QtMultimedia::AvailabilityStatus availability() const
+    QMultimedia::AvailabilityStatus availability() const
     {
         return m_availability;
     }
 
-    void setAvailability(QtMultimedia::AvailabilityStatus availability)
+    void setAvailability(QMultimedia::AvailabilityStatus availability)
     {
         if (m_availability != availability) {
             m_availability = availability;
@@ -69,7 +69,7 @@ public:
         }
     }
 
-    QtMultimedia::AvailabilityStatus m_availability;
+    QMultimedia::AvailabilityStatus m_availability;
 };
 
 #endif // MOCKAVAILABILITYCONTROL_H
diff --git a/tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h b/tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h
index a2335907b..39e7898c9 100644
--- a/tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h
+++ b/tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h
@@ -65,12 +65,12 @@ public:
                 settings.resolution() == QSize(320,240))
                 resolutions << settings.resolution();
 
-            if (settings.quality() == QtMultimedia::HighQuality && settings.resolution() == QSize(640,480))
+            if (settings.quality() == QMultimedia::HighQuality && settings.resolution() == QSize(640,480))
                 resolutions << settings.resolution();
         } else {
             resolutions << QSize(160, 120);
             resolutions << QSize(320, 240);
-            if (settings.quality() == QtMultimedia::HighQuality)
+            if (settings.quality() == QMultimedia::HighQuality)
                 resolutions << QSize(640, 480);
         }
 
diff --git a/tests/auto/unit/qradiodata/tst_qradiodata.cpp b/tests/auto/unit/qradiodata/tst_qradiodata.cpp
index a42b0aa0b..0a1ea9b1f 100644
--- a/tests/auto/unit/qradiodata/tst_qradiodata.cpp
+++ b/tests/auto/unit/qradiodata/tst_qradiodata.cpp
@@ -89,7 +89,7 @@ void tst_QRadioData::initTestCase()
 {
     qRegisterMetaType<QRadioData::ProgramType>("QRadioData::ProgramType");
 
-    mockAvailability = new MockAvailabilityControl(QtMultimedia::Available);
+    mockAvailability = new MockAvailabilityControl(QMultimedia::Available);
     mockTuner = new MockRadioTunerControl(this);
     mockData = new MockRadioDataControl(this);
 
@@ -105,7 +105,7 @@ void tst_QRadioData::initTestCase()
     radio = new QRadioTuner;
     radioData = radio->radioData();
 
-    QVERIFY(radioData->availability() == QtMultimedia::Available);
+    QVERIFY(radioData->availability() == QMultimedia::Available);
 }
 
 void tst_QRadioData::cleanupTestCase()
diff --git a/tests/auto/unit/qradiotuner/tst_qradiotuner.cpp b/tests/auto/unit/qradiotuner/tst_qradiotuner.cpp
index 66416e9c6..cbf2fe6c1 100644
--- a/tests/auto/unit/qradiotuner/tst_qradiotuner.cpp
+++ b/tests/auto/unit/qradiotuner/tst_qradiotuner.cpp
@@ -95,7 +95,7 @@ void tst_QRadioTuner::initTestCase()
     qRegisterMetaType<QRadioTuner::Band>("QRadioTuner::Band");
 
     mock = new MockRadioTunerControl(this);
-    mockAvailability = new MockAvailabilityControl(QtMultimedia::Available);
+    mockAvailability = new MockAvailabilityControl(QMultimedia::Available);
 
     QMap<QString, QMediaControl *> map;
     map.insert(QRadioTunerControl_iid, mock);
@@ -108,13 +108,13 @@ void tst_QRadioTuner::initTestCase()
     radio = new QRadioTuner;
     QVERIFY(radio->service() != 0);
     QVERIFY(radio->isAvailable());
-    QVERIFY(radio->availability() == QtMultimedia::Available);
+    QVERIFY(radio->availability() == QMultimedia::Available);
 
     QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
 
     QCOMPARE(radio->state(), QRadioTuner::StoppedState);    
     radio->start();
-    QVERIFY(radio->availability() == QtMultimedia::Available);
+    QVERIFY(radio->availability() == QMultimedia::Available);
     QCOMPARE(radio->state(), QRadioTuner::ActiveState);
 
     QCOMPARE(stateSpy.count(), 1);
@@ -129,7 +129,7 @@ void tst_QRadioTuner::cleanupTestCase()
     QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
 
     radio->stop();
-    QVERIFY(radio->availability() == QtMultimedia::Available);
+    QVERIFY(radio->availability() == QMultimedia::Available);
     QCOMPARE(radio->state(), QRadioTuner::StoppedState);
     QCOMPARE(stateSpy.count(), 1);
 
diff --git a/tests/auto/unit/qvideoprobe/tst_qvideoprobe.cpp b/tests/auto/unit/qvideoprobe/tst_qvideoprobe.cpp
index eade10d11..5d83456d9 100644
--- a/tests/auto/unit/qvideoprobe/tst_qvideoprobe.cpp
+++ b/tests/auto/unit/qvideoprobe/tst_qvideoprobe.cpp
@@ -116,7 +116,7 @@ void tst_QVideoProbe::testNullService()
     player = new QMediaPlayer;
 
     QVERIFY(!player->isAvailable());
-    QCOMPARE(player->availability(), QtMultimedia::ServiceMissing);
+    QCOMPARE(player->availability(), QMultimedia::ServiceMissing);
 
     QVideoProbe probe;
     QVERIFY(!probe.isActive());