Change namespace; QtMedia -> QtMultimedia

10 files changed, 102 insertions, 102 deletions

diff --git a/src/multimedia/base/qmediaobject.cpp b/src/multimedia/base/qmediaobject.cpp
index 34b57c9..b2b8c1b 100644
--- a/src/multimedia/base/qmediaobject.cpp
+++ b/src/multimedia/base/qmediaobject.cpp
@@ -96,9 +96,9 @@ QMediaObject::~QMediaObject()
     Returns the service availability error state.
 */
 
-QtMedia::AvailabilityError QMediaObject::availabilityError() const
+QtMultimedia::AvailabilityError QMediaObject::availabilityError() const
 {
-    return QtMedia::ServiceMissingError;
+    return QtMultimedia::ServiceMissingError;
 }
 
 /*!
@@ -305,7 +305,7 @@ bool QMediaObject::isMetaDataWritable() const
 /*!
     Returns the value associated with a meta-data \a key.
 */
-QVariant QMediaObject::metaData(QtMedia::MetaData key) const
+QVariant QMediaObject::metaData(QtMultimedia::MetaData key) const
 {
     Q_D(const QMediaObject);
 
@@ -317,7 +317,7 @@ QVariant QMediaObject::metaData(QtMedia::MetaData key) const
 /*!
     Sets a \a value for a meta-data \a key.
 */
-void QMediaObject::setMetaData(QtMedia::MetaData key, const QVariant &value)
+void QMediaObject::setMetaData(QtMultimedia::MetaData key, const QVariant &value)
 {
     Q_D(QMediaObject);
 
@@ -328,13 +328,13 @@ void QMediaObject::setMetaData(QtMedia::MetaData key, const QVariant &value)
 /*!
     Returns a list of keys there is meta-data available for.
 */
-QList<QtMedia::MetaData> QMediaObject::availableMetaData() const
+QList<QtMultimedia::MetaData> QMediaObject::availableMetaData() const
 {
     Q_D(const QMediaObject);
 
     return d->metaDataControl
             ? d->metaDataControl->availableMetaData()
-            : QList<QtMedia::MetaData>();
+            : QList<QtMultimedia::MetaData>();
 }
 
 /*!
diff --git a/src/multimedia/base/qmediaobject.h b/src/multimedia/base/qmediaobject.h
index a6eff1e..d09b1af 100644
--- a/src/multimedia/base/qmediaobject.h
+++ b/src/multimedia/base/qmediaobject.h
@@ -67,7 +67,7 @@ public:
     ~QMediaObject();
 
     virtual bool isAvailable() const;
-    virtual QtMedia::AvailabilityError availabilityError() const;
+    virtual QtMultimedia::AvailabilityError availabilityError() const;
 
     virtual QMediaService* service() const;
 
@@ -80,9 +80,9 @@ public:
     bool isMetaDataAvailable() const;
     bool isMetaDataWritable() const;
 
-    QVariant metaData(QtMedia::MetaData key) const;
-    void setMetaData(QtMedia::MetaData key, const QVariant &value);
-    QList<QtMedia::MetaData> availableMetaData() const;
+    QVariant metaData(QtMultimedia::MetaData key) const;
+    void setMetaData(QtMultimedia::MetaData key, const QVariant &value);
+    QList<QtMultimedia::MetaData> availableMetaData() const;
 
     QVariant extendedMetaData(const QString &key) const;
     void setExtendedMetaData(const QString &key, const QVariant &value);
diff --git a/src/multimedia/base/qmediaserviceprovider.cpp b/src/multimedia/base/qmediaserviceprovider.cpp
index 3b8dd2c..fcf06d3 100644
--- a/src/multimedia/base/qmediaserviceprovider.cpp
+++ b/src/multimedia/base/qmediaserviceprovider.cpp
@@ -333,9 +333,9 @@ public:
                 }
                 break;
             case QMediaServiceProviderHint::ContentType: {
-                    QtMedia::SupportEstimate estimate = QtMedia::NotSupported;
+                    QtMultimedia::SupportEstimate estimate = QtMultimedia::NotSupported;
                     foreach (QMediaServiceProviderPlugin *currentPlugin, plugins) {
-                        QtMedia::SupportEstimate currentEstimate = QtMedia::MaybeSupported;
+                        QtMultimedia::SupportEstimate currentEstimate = QtMultimedia::MaybeSupported;
                         QMediaServiceSupportedFormatsInterface *iface =
                                 qobject_cast<QMediaServiceSupportedFormatsInterface*>(currentPlugin);
 
@@ -346,7 +346,7 @@ public:
                             estimate = currentEstimate;
                             plugin = currentPlugin;
 
-                            if (currentEstimate == QtMedia::PreferedService)
+                            if (currentEstimate == QtMultimedia::PreferedService)
                                 break;
                         }
                     }
@@ -377,7 +377,7 @@ public:
         }
     }
 
-    QtMedia::SupportEstimate hasSupport(const QByteArray &serviceType,
+    QtMultimedia::SupportEstimate hasSupport(const QByteArray &serviceType,
                                      const QString &mimeType,
                                      const QStringList& codecs,
                                      int flags) const
@@ -385,10 +385,10 @@ public:
         QList<QObject*> instances = loader()->instances(serviceType);
 
         if (instances.isEmpty())
-            return QtMedia::NotSupported;
+            return QtMultimedia::NotSupported;
 
         bool allServicesProvideInterface = true;
-        QtMedia::SupportEstimate supportEstimate = QtMedia::NotSupported;
+        QtMultimedia::SupportEstimate supportEstimate = QtMultimedia::NotSupported;
 
         foreach(QObject *obj, instances) {
             QMediaServiceSupportedFormatsInterface *iface =
@@ -411,12 +411,12 @@ public:
         }
 
         //don't return PreferedService
-        supportEstimate = qMin(supportEstimate, QtMedia::ProbablySupported);
+        supportEstimate = qMin(supportEstimate, QtMultimedia::ProbablySupported);
 
         //Return NotSupported only if no services are available of serviceType
         //or all the services returned NotSupported, otherwise return at least MaybeSupported
         if (!allServicesProvideInterface)
-            supportEstimate = qMax(QtMedia::MaybeSupported, supportEstimate);
+            supportEstimate = qMax(QtMultimedia::MaybeSupported, supportEstimate);
 
         return supportEstimate;
     }
@@ -515,7 +515,7 @@ Q_GLOBAL_STATIC(QPluginServiceProvider, pluginProvider);
     service that is able to play media of a specific \a mimeType that is encoded using the listed
     \a codecs while adhearing to constraints identified in \a flags.
 */
-QtMedia::SupportEstimate QMediaServiceProvider::hasSupport(const QByteArray &serviceType,
+QtMultimedia::SupportEstimate QMediaServiceProvider::hasSupport(const QByteArray &serviceType,
                                                         const QString &mimeType,
                                                         const QStringList& codecs,
                                                         int flags) const
@@ -525,7 +525,7 @@ QtMedia::SupportEstimate QMediaServiceProvider::hasSupport(const QByteArray &ser
     Q_UNUSED(codecs);
     Q_UNUSED(flags);
 
-    return QtMedia::MaybeSupported;
+    return QtMultimedia::MaybeSupported;
 }
 
 /*!
diff --git a/src/multimedia/base/qmediaserviceprovider.h b/src/multimedia/base/qmediaserviceprovider.h
index f108d32..2ee0ae4 100644
--- a/src/multimedia/base/qmediaserviceprovider.h
+++ b/src/multimedia/base/qmediaserviceprovider.h
@@ -105,7 +105,7 @@ public:
     virtual QMediaService* requestService(const QByteArray &type, const QMediaServiceProviderHint &hint = QMediaServiceProviderHint()) = 0;
     virtual void releaseService(QMediaService *service) = 0;
 
-    virtual QtMedia::SupportEstimate hasSupport(const QByteArray &serviceType,
+    virtual QtMultimedia::SupportEstimate hasSupport(const QByteArray &serviceType,
                                              const QString &mimeType,
                                              const QStringList& codecs,
                                              int flags = 0) const;
diff --git a/src/multimedia/base/qmediaserviceproviderplugin.h b/src/multimedia/base/qmediaserviceproviderplugin.h
index 0381093..b1e728b 100644
--- a/src/multimedia/base/qmediaserviceproviderplugin.h
+++ b/src/multimedia/base/qmediaserviceproviderplugin.h
@@ -76,7 +76,7 @@ Q_DECLARE_INTERFACE(QMediaServiceProviderFactoryInterface, QMediaServiceProvider
 struct Q_MULTIMEDIA_EXPORT QMediaServiceSupportedFormatsInterface
 {
     virtual ~QMediaServiceSupportedFormatsInterface() {}
-    virtual QtMedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const = 0;
+    virtual QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const = 0;
     virtual QStringList supportedMimeTypes() const = 0;
 };
 
diff --git a/src/multimedia/base/qmetadatacontrol.h b/src/multimedia/base/qmetadatacontrol.h
index 5609f10..8e18c16 100644
--- a/src/multimedia/base/qmetadatacontrol.h
+++ b/src/multimedia/base/qmetadatacontrol.h
@@ -63,9 +63,9 @@ public:
     virtual bool isWritable() const = 0;
     virtual bool isMetaDataAvailable() const = 0;
 
-    virtual QVariant metaData(QtMedia::MetaData key) const = 0;
-    virtual void setMetaData(QtMedia::MetaData key, const QVariant &value) = 0;
-    virtual QList<QtMedia::MetaData> availableMetaData() const = 0;
+    virtual QVariant metaData(QtMultimedia::MetaData key) const = 0;
+    virtual void setMetaData(QtMultimedia::MetaData key, const QVariant &value) = 0;
+    virtual QList<QtMultimedia::MetaData> availableMetaData() const = 0;
 
     virtual QVariant extendedMetaData(const QString &key) const = 0;
     virtual void setExtendedMetaData(const QString &key, const QVariant &value) = 0;
diff --git a/src/multimedia/base/qtmedianamespace.h b/src/multimedia/base/qtmedianamespace.h
index c3b4896..2a56fc3 100644
--- a/src/multimedia/base/qtmedianamespace.h
+++ b/src/multimedia/base/qtmedianamespace.h
@@ -51,7 +51,7 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Multimedia)
 
-namespace QtMedia
+namespace QtMultimedia
 {
     enum MetaData
     {
diff --git a/src/multimedia/playback/qmediaplayer.cpp b/src/multimedia/playback/qmediaplayer.cpp
index 6ce34ab..5f50fdb 100644
--- a/src/multimedia/playback/qmediaplayer.cpp
+++ b/src/multimedia/playback/qmediaplayer.cpp
@@ -645,7 +645,7 @@ void QMediaPlayer::unbind(QObject *obj)
     The \a flags argument allows additional requirements such as performance indicators to be
     specified.
 */
-QtMedia::SupportEstimate QMediaPlayer::hasSupport(const QString &mimeType,
+QtMultimedia::SupportEstimate QMediaPlayer::hasSupport(const QString &mimeType,
                                                const QStringList& codecs,
                                                Flags flags)
 {
diff --git a/src/multimedia/playback/qmediaplayer.h b/src/multimedia/playback/qmediaplayer.h
index 91d6790..1b761ce 100644
--- a/src/multimedia/playback/qmediaplayer.h
+++ b/src/multimedia/playback/qmediaplayer.h
@@ -116,7 +116,7 @@ public:
     QMediaPlayer(QObject *parent = 0, Flags flags = 0, QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider());
     ~QMediaPlayer();
 
-    static QtMedia::SupportEstimate hasSupport(const QString &mimeType,
+    static QtMultimedia::SupportEstimate hasSupport(const QString &mimeType,
                                             const QStringList& codecs = QStringList(),
                                             Flags flags = 0);
     static QStringList supportedMimeTypes(Flags flags = 0);
diff --git a/src/multimedia/qml/qmetadatacontrolmetaobject.cpp b/src/multimedia/qml/qmetadatacontrolmetaobject.cpp
index 882d8a6..7f9575e 100644
--- a/src/multimedia/qml/qmetadatacontrolmetaobject.cpp
+++ b/src/multimedia/qml/qmetadatacontrolmetaobject.cpp
@@ -106,101 +106,101 @@ namespace
 {
     struct MetaDataKey
     {
-        QtMedia::MetaData key;
+        QtMultimedia::MetaData key;
         const char *name;
     };
 
     const MetaDataKey qt_metaDataKeys[] =
     {
-        { QtMedia::Title, "title" },
-        { QtMedia::SubTitle, "subTitle" },
-        { QtMedia::Author, "author" },
-        { QtMedia::Comment, "comment" },
-        { QtMedia::Description, "description" },
-        { QtMedia::Category, "category" },
-        { QtMedia::Genre, "genre" },
-        { QtMedia::Year, "year" },
-        { QtMedia::Date, "date" },
-        { QtMedia::UserRating, "userRating" },
-        { QtMedia::Keywords, "keywords" },
-        { QtMedia::Language, "language" },
-        { QtMedia::Publisher, "publisher" },
-        { QtMedia::Copyright, "copyright" },
-        { QtMedia::ParentalRating, "parentalRating" },
-        { QtMedia::RatingOrganisation, "ratingOrganisation" },
+        { QtMultimedia::Title, "title" },
+        { QtMultimedia::SubTitle, "subTitle" },
+        { QtMultimedia::Author, "author" },
+        { QtMultimedia::Comment, "comment" },
+        { QtMultimedia::Description, "description" },
+        { QtMultimedia::Category, "category" },
+        { QtMultimedia::Genre, "genre" },
+        { QtMultimedia::Year, "year" },
+        { QtMultimedia::Date, "date" },
+        { QtMultimedia::UserRating, "userRating" },
+        { QtMultimedia::Keywords, "keywords" },
+        { QtMultimedia::Language, "language" },
+        { QtMultimedia::Publisher, "publisher" },
+        { QtMultimedia::Copyright, "copyright" },
+        { QtMultimedia::ParentalRating, "parentalRating" },
+        { QtMultimedia::RatingOrganisation, "ratingOrganisation" },
 
         // Media
-        { QtMedia::Size, "size" },
-        { QtMedia::MediaType, "mediaType" },
+        { QtMultimedia::Size, "size" },
+        { QtMultimedia::MediaType, "mediaType" },
 //        { QtMedia::Duration, "duration" },
 
         // Audio
-        { QtMedia::AudioBitRate, "audioBitRate" },
-        { QtMedia::AudioCodec, "audioCodec" },
-        { QtMedia::AverageLevel, "averageLevel" },
-        { QtMedia::ChannelCount, "channelCount" },
-        { QtMedia::PeakValue, "peakValue" },
-        { QtMedia::SampleRate, "sampleRate" },
+        { QtMultimedia::AudioBitRate, "audioBitRate" },
+        { QtMultimedia::AudioCodec, "audioCodec" },
+        { QtMultimedia::AverageLevel, "averageLevel" },
+        { QtMultimedia::ChannelCount, "channelCount" },
+        { QtMultimedia::PeakValue, "peakValue" },
+        { QtMultimedia::SampleRate, "sampleRate" },
 
         // Music
-        { QtMedia::AlbumTitle, "albumTitle" },
-        { QtMedia::AlbumArtist, "albumArtist" },
-        { QtMedia::ContributingArtist, "contributingArtist" },
-        { QtMedia::Composer, "composer" },
-        { QtMedia::Conductor, "conductor" },
-        { QtMedia::Lyrics, "lyrics" },
-        { QtMedia::Mood, "mood" },
-        { QtMedia::TrackNumber, "trackNumber" },
-        { QtMedia::TrackCount, "trackCount" },
-
-        { QtMedia::CoverArtUrlSmall, "coverArtUrlSmall" },
-        { QtMedia::CoverArtUrlLarge, "coverArtUrlLarge" },
+        { QtMultimedia::AlbumTitle, "albumTitle" },
+        { QtMultimedia::AlbumArtist, "albumArtist" },
+        { QtMultimedia::ContributingArtist, "contributingArtist" },
+        { QtMultimedia::Composer, "composer" },
+        { QtMultimedia::Conductor, "conductor" },
+        { QtMultimedia::Lyrics, "lyrics" },
+        { QtMultimedia::Mood, "mood" },
+        { QtMultimedia::TrackNumber, "trackNumber" },
+        { QtMultimedia::TrackCount, "trackCount" },
+
+        { QtMultimedia::CoverArtUrlSmall, "coverArtUrlSmall" },
+        { QtMultimedia::CoverArtUrlLarge, "coverArtUrlLarge" },
 
         // Image/Video
-        { QtMedia::Resolution, "resolution" },
-        { QtMedia::PixelAspectRatio, "pixelAspectRatio" },
+        { QtMultimedia::Resolution, "resolution" },
+        { QtMultimedia::PixelAspectRatio, "pixelAspectRatio" },
 
         // Video
-        { QtMedia::VideoFrameRate, "videoFrameRate" },
-        { QtMedia::VideoBitRate, "videoBitRate" },
-        { QtMedia::VideoCodec, "videoCodec" },
+        { QtMultimedia::VideoFrameRate, "videoFrameRate" },
+        { QtMultimedia::VideoBitRate, "videoBitRate" },
+        { QtMultimedia::VideoCodec, "videoCodec" },
 
-        { QtMedia::PosterUrl, "posterUrl" },
+        { QtMultimedia::PosterUrl, "posterUrl" },
 
         // Movie
-        { QtMedia::ChapterNumber, "chapterNumber" },
-        { QtMedia::Director, "director" },
-        { QtMedia::LeadPerformer, "leadPerformer" },
-        { QtMedia::Writer, "writer" },
+        { QtMultimedia::ChapterNumber, "chapterNumber" },
+        { QtMultimedia::Director, "director" },
+        { QtMultimedia::LeadPerformer, "leadPerformer" },
+        { QtMultimedia::Writer, "writer" },
 
         // Photos
-        { QtMedia::CameraManufacturer, "cameraManufacturer" },
-        { QtMedia::CameraModel, "cameraModel" },
-        { QtMedia::Event, "event" },
-        { QtMedia::Subject, "subject" },
-        { QtMedia::Orientation, "orientation" },
-        { QtMedia::ExposureTime, "exposureTime" },
-        { QtMedia::FNumber, "fNumber" },
-        { QtMedia::ExposureProgram, "exposureProgram" },
-        { QtMedia::ISOSpeedRatings, "isoSpeedRatings" },
-        { QtMedia::ExposureBiasValue, "exposureBiasValue" },
-        { QtMedia::DateTimeOriginal, "dateTimeOriginal" },
-        { QtMedia::DateTimeDigitized, "dateTimeDigitized" },
-        { QtMedia::SubjectDistance, "subjectDistance" },
-        { QtMedia::MeteringMode, "meteringMode" },
-        { QtMedia::LightSource, "lightSource" },
-        { QtMedia::Flash, "flash" },
-        { QtMedia::FocalLength, "focalLength" },
-        { QtMedia::ExposureMode, "exposureMode" },
-        { QtMedia::WhiteBalance, "whiteBalance" },
-        { QtMedia::DigitalZoomRatio, "digitalZoomRatio" },
-        { QtMedia::FocalLengthIn35mmFilm, "focalLengthIn35mmFilm" },
-        { QtMedia::SceneCaptureType, "sceneCaptureType" },
-        { QtMedia::GainControl, "gainControl" },
-        { QtMedia::Contrast, "contrast" },
-        { QtMedia::Saturation, "saturation" },
-        { QtMedia::Sharpness, "sharpness" },
-        { QtMedia::DeviceSettingDescription, "deviceSettingDescription" }
+        { QtMultimedia::CameraManufacturer, "cameraManufacturer" },
+        { QtMultimedia::CameraModel, "cameraModel" },
+        { QtMultimedia::Event, "event" },
+        { QtMultimedia::Subject, "subject" },
+        { QtMultimedia::Orientation, "orientation" },
+        { QtMultimedia::ExposureTime, "exposureTime" },
+        { QtMultimedia::FNumber, "fNumber" },
+        { QtMultimedia::ExposureProgram, "exposureProgram" },
+        { QtMultimedia::ISOSpeedRatings, "isoSpeedRatings" },
+        { QtMultimedia::ExposureBiasValue, "exposureBiasValue" },
+        { QtMultimedia::DateTimeOriginal, "dateTimeOriginal" },
+        { QtMultimedia::DateTimeDigitized, "dateTimeDigitized" },
+        { QtMultimedia::SubjectDistance, "subjectDistance" },
+        { QtMultimedia::MeteringMode, "meteringMode" },
+        { QtMultimedia::LightSource, "lightSource" },
+        { QtMultimedia::Flash, "flash" },
+        { QtMultimedia::FocalLength, "focalLength" },
+        { QtMultimedia::ExposureMode, "exposureMode" },
+        { QtMultimedia::WhiteBalance, "whiteBalance" },
+        { QtMultimedia::DigitalZoomRatio, "digitalZoomRatio" },
+        { QtMultimedia::FocalLengthIn35mmFilm, "focalLengthIn35mmFilm" },
+        { QtMultimedia::SceneCaptureType, "sceneCaptureType" },
+        { QtMultimedia::GainControl, "gainControl" },
+        { QtMultimedia::Contrast, "contrast" },
+        { QtMultimedia::Saturation, "saturation" },
+        { QtMultimedia::Sharpness, "sharpness" },
+        { QtMultimedia::DeviceSettingDescription, "deviceSettingDescription" }
     };
 
     class QMetaDataControlObject : public QObject