Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtmobility/plugins/multimedia/wmp/qwmpmetadata.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
child 15 1f895d8a5b2b
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4 
    55 #include <QtCore/qvariant.h>
 
    55 #include <QtCore/qvariant.h>
 
    56 
    56 
    57 
    57 
    58 struct QWmpMetaDataKeyLookup
 
    58 struct QWmpMetaDataKeyLookup
 
    59 {
 
    59 {
 
    60     QtMediaServices::MetaData key;
 
    60     QtMultimedia::MetaData key;
 
    61     const wchar_t *token;
 
    61     const wchar_t *token;
 
    62 };
 
    62 };
 
    63 
    63 
    64 static const QWmpMetaDataKeyLookup qt_wmpMetaDataKeys[] =
 
    64 static const QWmpMetaDataKeyLookup qt_wmpMetaDataKeys[] =
 
    65 {
 
    65 {
 
    66     { QtMediaServices::Title, L"Title" },
 
    66     { QtMultimedia::Title, L"Title" },
 
    67     { QtMediaServices::SubTitle, L"WM/SubTitle" },
 
    67     { QtMultimedia::SubTitle, L"WM/SubTitle" },
 
    68     { QtMediaServices::Author, L"Author" },
 
    68     { QtMultimedia::Author, L"Author" },
 
    69     { QtMediaServices::Comment, L"Comment" },
 
    69     { QtMultimedia::Comment, L"Comment" },
 
    70     { QtMediaServices::Description, L"Description" },
 
    70     { QtMultimedia::Description, L"Description" },
 
    71     { QtMediaServices::Category, L"WM/Category" },
 
    71     { QtMultimedia::Category, L"WM/Category" },
 
    72     { QtMediaServices::Genre, L"WM/Genre" },
 
    72     { QtMultimedia::Genre, L"WM/Genre" },
 
    73     //{ QtMediaServices::Date, 0 },
 
    73     //{ QtMultimedia::Date, 0 },
 
    74     { QtMediaServices::Year, L"WM/Year" },
 
    74     { QtMultimedia::Year, L"WM/Year" },
 
    75     { QtMediaServices::UserRating, L"UserRating" },
 
    75     { QtMultimedia::UserRating, L"UserRating" },
 
    76     //{ QtMediaServices::MetaDatawords, 0 },
 
    76     //{ QtMultimedia::MetaDatawords, 0 },
 
    77     { QtMediaServices::Language, L"Language" },
 
    77     { QtMultimedia::Language, L"Language" },
 
    78     { QtMediaServices::Publisher, L"WM/Publisher" },
 
    78     { QtMultimedia::Publisher, L"WM/Publisher" },
 
    79     { QtMediaServices::Copyright, L"Copyright" },
 
    79     { QtMultimedia::Copyright, L"Copyright" },
 
    80     { QtMediaServices::ParentalRating, L"ParentalRating" },
 
    80     { QtMultimedia::ParentalRating, L"ParentalRating" },
 
    81     { QtMediaServices::RatingOrganisation, L"RatingOrganisation" },
 
    81     { QtMultimedia::RatingOrganisation, L"RatingOrganisation" },
 
    82 
    82 
    83     // Media
 
    83     // Media
 
    84     { QtMediaServices::Size, L"FileSize" },
 
    84     { QtMultimedia::Size, L"FileSize" },
 
    85     { QtMediaServices::MediaType, L"MediaType" },
 
    85     { QtMultimedia::MediaType, L"MediaType" },
 
    86     { QtMediaServices::Duration, L"Duration" },
 
    86     { QtMultimedia::Duration, L"Duration" },
 
    87 
    87 
    88     // Audio
 
    88     // Audio
 
    89     { QtMediaServices::AudioBitRate, L"AudioBitrate" },
 
    89     { QtMultimedia::AudioBitRate, L"AudioBitrate" },
 
    90     { QtMediaServices::AudioCodec, L"AudioCodec" },
 
    90     { QtMultimedia::AudioCodec, L"AudioCodec" },
 
    91     { QtMediaServices::ChannelCount, L"Channels" },
 
    91     { QtMultimedia::ChannelCount, L"Channels" },
 
    92     { QtMediaServices::SampleRate, L"Frequency" },
 
    92     { QtMultimedia::SampleRate, L"Frequency" },
 
    93 
    93 
    94     // Music
 
    94     // Music
 
    95     { QtMediaServices::AlbumTitle, L"WM/AlbumTitle" },
 
    95     { QtMultimedia::AlbumTitle, L"WM/AlbumTitle" },
 
    96     { QtMediaServices::AlbumArtist, L"WM/AlbumArtist" },
 
    96     { QtMultimedia::AlbumArtist, L"WM/AlbumArtist" },
 
    97     { QtMediaServices::ContributingArtist, L"Author" },
 
    97     { QtMultimedia::ContributingArtist, L"Author" },
 
    98     { QtMediaServices::Composer, L"WM/Composer" },
 
    98     { QtMultimedia::Composer, L"WM/Composer" },
 
    99     { QtMediaServices::Conductor, L"WM/Conductor" },
 
    99     { QtMultimedia::Conductor, L"WM/Conductor" },
 
   100     { QtMediaServices::Lyrics, L"WM/Lyrics" },
 
   100     { QtMultimedia::Lyrics, L"WM/Lyrics" },
 
   101     { QtMediaServices::Mood, L"WM/Mood" },
 
   101     { QtMultimedia::Mood, L"WM/Mood" },
 
   102     { QtMediaServices::TrackNumber, L"WM/TrackNumber" },
 
   102     { QtMultimedia::TrackNumber, L"WM/TrackNumber" },
 
   103     //{ QtMediaServices::TrackCount, 0 },
 
   103     //{ QtMultimedia::TrackCount, 0 },
 
   104     //{ QtMediaServices::CoverArtUrlSmall, 0 },
 
   104     //{ QtMultimedia::CoverArtUrlSmall, 0 },
 
   105     //{ QtMediaServices::CoverArtUrlLarge, 0 },
 
   105     //{ QtMultimedia::CoverArtUrlLarge, 0 },
 
   106 
   106 
   107     // Image/Video
 
   107     // Image/Video
 
   108     //{ QtMediaServices::Resolution, 0 },
 
   108     //{ QtMultimedia::Resolution, 0 },
 
   109     //{ QtMediaServices::PixelAspectRatio, 0 },
 
   109     //{ QtMultimedia::PixelAspectRatio, 0 },
 
   110 
   110 
   111     // Video
 
   111     // Video
 
   112     //{ QtMediaServices::FrameRate, 0 },
 
   112     //{ QtMultimedia::FrameRate, 0 },
 
   113     { QtMediaServices::VideoBitRate, L"VideoBitRate" },
 
   113     { QtMultimedia::VideoBitRate, L"VideoBitRate" },
 
   114     { QtMediaServices::VideoCodec, L"VideoCodec" },
 
   114     { QtMultimedia::VideoCodec, L"VideoCodec" },
 
   115 
   115 
   116     //{ QtMediaServices::PosterUrl, 0 },
 
   116     //{ QtMultimedia::PosterUrl, 0 },
 
   117 
   117 
   118     // Movie
 
   118     // Movie
 
   119     { QtMediaServices::ChapterNumber, L"ChapterNumber" },
 
   119     { QtMultimedia::ChapterNumber, L"ChapterNumber" },
 
   120     { QtMediaServices::Director, L"WM/Director" },
 
   120     { QtMultimedia::Director, L"WM/Director" },
 
   121     { QtMediaServices::LeadPerformer, L"LeadPerformer" },
 
   121     { QtMultimedia::LeadPerformer, L"LeadPerformer" },
 
   122     { QtMediaServices::Writer, L"WM/Writer" },
 
   122     { QtMultimedia::Writer, L"WM/Writer" },
 
   123 
   123 
   124     // Photos
 
   124     // Photos
 
   125     { QtMediaServices::CameraManufacturer, L"CameraManufacturer" },
 
   125     { QtMultimedia::CameraManufacturer, L"CameraManufacturer" },
 
   126     { QtMediaServices::CameraModel, L"CameraModel" },
 
   126     { QtMultimedia::CameraModel, L"CameraModel" },
 
   127     { QtMediaServices::Event, L"Event" },
 
   127     { QtMultimedia::Event, L"Event" },
 
   128     { QtMediaServices::Subject, L"Subject" }
 
   128     { QtMultimedia::Subject, L"Subject" }
 
   129 };
 
   129 };
 
   130 
   130 
   131 QWmpMetaData::QWmpMetaData(IWMPCore3 *player, QWmpEvents *events, QObject *parent)
 
   131 QWmpMetaData::QWmpMetaData(IWMPCore3 *player, QWmpEvents *events, QObject *parent)
 
   132     : QMetaDataControl(parent)
 
   132     : QMetaDataReaderControl(parent)
 
   133     , m_media(0)
 
   133     , m_media(0)
 
   134 {
 
   134 {
 
   135     player->get_currentMedia(&m_media);
 
   135     player->get_currentMedia(&m_media);
 
   136 
   136 
   137     connect(events, SIGNAL(CurrentItemChange(IDispatch*)),
 
   137     connect(events, SIGNAL(CurrentItemChange(IDispatch*)),
 
   153 bool QWmpMetaData::isWritable() const
 
   153 bool QWmpMetaData::isWritable() const
 
   154 {
 
   154 {
 
   155     return m_media != 0;
 
   155     return m_media != 0;
 
   156 }
 
   156 }
 
   157 
   157 
   158 QVariant QWmpMetaData::metaData(QtMediaServices::MetaData key) const
 
   158 QVariant QWmpMetaData::metaData(QtMultimedia::MetaData key) const
 
   159 {
 
   159 {
 
   160     static const int  count = sizeof(qt_wmpMetaDataKeys) / sizeof(QWmpMetaDataKeyLookup);
 
   160     static const int  count = sizeof(qt_wmpMetaDataKeys) / sizeof(QWmpMetaDataKeyLookup);
 
   161 
   161 
   162     switch (key) {
 
   162     switch (key) {
 
   163     case QtMediaServices::Date:
 
   163     case QtMultimedia::Date:
 
   164         {
 
   164         {
 
   165             QVariant day = value(m_media, QAutoBStr(L"ReleaseDateDay"));
 
   165             QVariant day = value(m_media, QAutoBStr(L"ReleaseDateDay"));
 
   166             QVariant month = value(m_media, QAutoBStr(L"ReleaseDateMonth"));
 
   166             QVariant month = value(m_media, QAutoBStr(L"ReleaseDateMonth"));
 
   167             QVariant year = value(m_media, QAutoBStr(L"ReleaseDateYear"));
 
   167             QVariant year = value(m_media, QAutoBStr(L"ReleaseDateYear"));
 
   168 
   168 
   169             if (!day.isNull() && !month.isNull() && !year.isNull())
 
   169             if (!day.isNull() && !month.isNull() && !year.isNull())
 
   170                 return QDate(year.toInt(), month.toInt(), day.toInt());
 
   170                 return QDate(year.toInt(), month.toInt(), day.toInt());
 
   171         }
 
   171         }
 
   172         break;
 
   172         break;
 
   173     case QtMediaServices::CoverArtUrlSmall:
 
   173     case QtMultimedia::CoverArtUrlSmall:
 
   174         return albumArtUrl(m_media, "_Small.jpg");
 
   174         return albumArtUrl(m_media, "_Small.jpg");
 
   175     case QtMediaServices::CoverArtUrlLarge:
 
   175     case QtMultimedia::CoverArtUrlLarge:
 
   176         return albumArtUrl(m_media, "_Large.jpg");
 
   176         return albumArtUrl(m_media, "_Large.jpg");
 
   177     case QtMediaServices::Resolution:
 
   177     case QtMultimedia::Resolution:
 
   178         {
 
   178         {
 
   179             QVariant width = value(m_media, QAutoBStr(L"WM/VideoWidth"));
 
   179             QVariant width = value(m_media, QAutoBStr(L"WM/VideoWidth"));
 
   180             QVariant height = value(m_media, QAutoBStr(L"WM/VideoHeight"));
 
   180             QVariant height = value(m_media, QAutoBStr(L"WM/VideoHeight"));
 
   181 
   181 
   182             if (!width.isNull() && !height.isNull())
 
   182             if (!width.isNull() && !height.isNull())
 
   183                 return QSize(width.toInt(), height.toInt());
 
   183                 return QSize(width.toInt(), height.toInt());
 
   184         }
 
   184         }
 
   185         break;
 
   185         break;
 
   186     case QtMediaServices::PixelAspectRatio:
 
   186     case QtMultimedia::PixelAspectRatio:
 
   187         {
 
   187         {
 
   188             QVariant x = value(m_media, QAutoBStr(L"PixelAspectRatioX"));
 
   188             QVariant x = value(m_media, QAutoBStr(L"PixelAspectRatioX"));
 
   189             QVariant y = value(m_media, QAutoBStr(L"PixelAspectRatioY"));
 
   189             QVariant y = value(m_media, QAutoBStr(L"PixelAspectRatioY"));
 
   190 
   190 
   191             if (!x.isNull() && !y.isNull())
 
   191             if (!x.isNull() && !y.isNull())
 
   192                 return QSize(x.toInt(), y.toInt());
 
   192                 return QSize(x.toInt(), y.toInt());
 
   193         }
 
   193         }
 
   194         break;
 
   194         break;
 
   195     case QtMediaServices::VideoFrameRate:
 
   195     case QtMultimedia::VideoFrameRate:
 
   196         break;
 
   196         break;
 
   197     default:
 
   197     default:
 
   198         for (int i = 0; i < count; ++i) {
 
   198         for (int i = 0; i < count; ++i) {
 
   199             if (qt_wmpMetaDataKeys[i].key == key)
 
   199             if (qt_wmpMetaDataKeys[i].key == key)
 
   200                 return value(m_media, QAutoBStr(qt_wmpMetaDataKeys[i].token));
 
   200                 return value(m_media, QAutoBStr(qt_wmpMetaDataKeys[i].token));
 
   202         break;
 
   202         break;
 
   203     }
 
   203     }
 
   204     return QVariant();
 
   204     return QVariant();
 
   205 }
 
   205 }
 
   206 
   206 
   207 void QWmpMetaData::setMetaData(QtMediaServices::MetaData key, const QVariant &value)
 
   207 QList<QtMultimedia::MetaData> QWmpMetaData::availableMetaData() const
 
   208 {
 
   208 {
 
   209     static const int  count = sizeof(qt_wmpMetaDataKeys) / sizeof(QWmpMetaDataKeyLookup);
 
   209     QList<QtMultimedia::MetaData> keys;
 
   210 
       
   211     for (int i = 0; i < count; ++i) {
 
       
   212         if (qt_wmpMetaDataKeys[i].key == key) {
 
       
   213             setValue(m_media, QAutoBStr(qt_wmpMetaDataKeys[i].token), value);
 
       
   214             return;
 
       
   215         }
 
       
   216     }
 
       
   217 }
 
       
   218 
       
   219 QList<QtMediaServices::MetaData> QWmpMetaData::availableMetaData() const
 
       
   220 {
 
       
   221     QList<QtMediaServices::MetaData> keys;
 
       
   222 
   210 
   223     if (m_media) {
 
   211     if (m_media) {
 
   224         // WMP will return a list of all possible keys so there's no point in filtering the keys
 
   212         // WMP will return a list of all possible keys so there's no point in filtering the keys
 
   225         // in the lookup table.
 
   213         // in the lookup table.
 
   226         static const int  count = sizeof(qt_wmpMetaDataKeys) / sizeof(QWmpMetaDataKeyLookup);
 
   214         static const int  count = sizeof(qt_wmpMetaDataKeys) / sizeof(QWmpMetaDataKeyLookup);
 
   240                 QString albumArtSmall = QLatin1String("AlbumArt_") + uuid + QLatin1String("_Small.jpg");
 
   228                 QString albumArtSmall = QLatin1String("AlbumArt_") + uuid + QLatin1String("_Small.jpg");
 
   241 
   229 
   242                 QDir dir = QFileInfo(url).absoluteDir();
 
   230                 QDir dir = QFileInfo(url).absoluteDir();
 
   243 
   231 
   244                 if (dir.exists(albumArtLarge))
 
   232                 if (dir.exists(albumArtLarge))
 
   245                     keys.append(QtMediaServices::CoverArtUrlLarge);
 
   233                     keys.append(QtMultimedia::CoverArtUrlLarge);
 
   246                 if (dir.exists(albumArtSmall))
 
   234                 if (dir.exists(albumArtSmall))
 
   247                     keys.append(QtMediaServices::CoverArtUrlSmall);
 
   235                     keys.append(QtMultimedia::CoverArtUrlSmall);
 
   248             }
 
   236             }
 
   249         }
 
   237         }
 
   250     }
 
   238     }
 
   251     return keys;
 
   239     return keys;
 
   252 }
 
   240 }
 
   253 
   241 
   254 QVariant QWmpMetaData::extendedMetaData(const QString &key) const
 
   242 QVariant QWmpMetaData::extendedMetaData(const QString &key) const
 
   255 {
 
   243 {
 
   256     return value(m_media, QAutoBStr(key));
 
   244     return value(m_media, QAutoBStr(key));
 
   257 }
 
   245 }
 
   258 
       
   259 void QWmpMetaData::setExtendedMetaData(const QString &key, const QVariant &value)
 
       
   260 {
 
       
   261     setValue(m_media, QAutoBStr(key), value);
 
       
   262 }
 
       
   263 
       
   264 
   246 
   265 QStringList QWmpMetaData::availableExtendedMetaData() const
 
   247 QStringList QWmpMetaData::availableExtendedMetaData() const
 
   266 {
 
   248 {
 
   267     return keys(m_media);
 
   249     return keys(m_media);
 
   268 }
 
   250 }
 
   355     case 1:
 
   337     case 1:
 
   356         return values.first();
 
   338         return values.first();
 
   357     default:
 
   339     default:
 
   358         return values;
 
   340         return values;
 
   359     }
 
   341     }
 
   360 }
 
       
   361 
       
   362 void QWmpMetaData::setValue(IWMPMedia *media, BSTR key, const QVariant &value)
 
       
   363 {
 
       
   364     if (qVariantCanConvert<QString>(value))
 
       
   365         media->setItemInfo(key, QAutoBStr(value.toString()));
 
       
   366 }
 
   342 }
 
   367 
   343 
   368 QMediaContent QWmpMetaData::resources(IWMPMedia *media)
 
   344 QMediaContent QWmpMetaData::resources(IWMPMedia *media)
 
   369 {
 
   345 {
 
   370     QMediaContent content;
 
   346     QMediaContent content;
FCL/sf/mw/qtextensions