| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Mobility Components. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include <qmediametadata.h> |
| #include <qdatetime.h> |
| #include <qimage.h> |
| |
| #include "mfmetadatacontrol.h" |
| #include "mfplayerservice.h" |
| #include "Propkey.h" |
| |
| //#define DEBUG_MEDIAFOUNDATION |
| |
| static QString nameForGUID(GUID guid) |
| { |
| // Audio formats |
| if (guid == MFAudioFormat_AAC) |
| return QStringLiteral("MPEG AAC Audio"); |
| else if (guid == MFAudioFormat_ADTS) |
| return QStringLiteral("MPEG ADTS AAC Audio"); |
| else if (guid == MFAudioFormat_Dolby_AC3_SPDIF) |
| return QStringLiteral("Dolby AC-3 SPDIF"); |
| else if (guid == MFAudioFormat_DRM) |
| return QStringLiteral("DRM"); |
| else if (guid == MFAudioFormat_DTS) |
| return QStringLiteral("Digital Theater Systems Audio (DTS)"); |
| else if (guid == MFAudioFormat_Float) |
| return QStringLiteral("IEEE Float Audio"); |
| else if (guid == MFAudioFormat_MP3) |
| return QStringLiteral("MPEG Audio Layer-3 (MP3)"); |
| else if (guid == MFAudioFormat_MPEG) |
| return QStringLiteral("MPEG-1 Audio"); |
| else if (guid == MFAudioFormat_MSP1) |
| return QStringLiteral("Windows Media Audio Voice"); |
| else if (guid == MFAudioFormat_PCM) |
| return QStringLiteral("Uncompressed PCM Audio"); |
| else if (guid == MFAudioFormat_WMASPDIF) |
| return QStringLiteral("Windows Media Audio 9 SPDIF"); |
| else if (guid == MFAudioFormat_WMAudioV8) |
| return QStringLiteral("Windows Media Audio 8 (WMA2)"); |
| else if (guid == MFAudioFormat_WMAudioV9) |
| return QStringLiteral("Windows Media Audio 9 (WMA3"); |
| else if (guid == MFAudioFormat_WMAudio_Lossless) |
| return QStringLiteral("Windows Media Audio 9 Lossless"); |
| |
| // Video formats |
| if (guid == MFVideoFormat_DV25) |
| return QStringLiteral("DVCPRO 25 (DV25)"); |
| else if (guid == MFVideoFormat_DV50) |
| return QStringLiteral("DVCPRO 50 (DV50)"); |
| else if (guid == MFVideoFormat_DVC) |
| return QStringLiteral("DVC/DV Video"); |
| else if (guid == MFVideoFormat_DVH1) |
| return QStringLiteral("DVCPRO 100 (DVH1)"); |
| else if (guid == MFVideoFormat_DVHD) |
| return QStringLiteral("HD-DVCR (DVHD)"); |
| else if (guid == MFVideoFormat_DVSD) |
| return QStringLiteral("SDL-DVCR (DVSD)"); |
| else if (guid == MFVideoFormat_DVSL) |
| return QStringLiteral("SD-DVCR (DVSL)"); |
| else if (guid == MFVideoFormat_H264) |
| return QStringLiteral("H.264 Video"); |
| else if (guid == MFVideoFormat_M4S2) |
| return QStringLiteral("MPEG-4 part 2 Video (M4S2)"); |
| else if (guid == MFVideoFormat_MJPG) |
| return QStringLiteral("Motion JPEG (MJPG)"); |
| else if (guid == MFVideoFormat_MP43) |
| return QStringLiteral("Microsoft MPEG 4 version 3 (MP43)"); |
| else if (guid == MFVideoFormat_MP4S) |
| return QStringLiteral("ISO MPEG 4 version 1 (MP4S)"); |
| else if (guid == MFVideoFormat_MP4V) |
| return QStringLiteral("MPEG-4 part 2 Video (MP4V)"); |
| else if (guid == MFVideoFormat_MPEG2) |
| return QStringLiteral("MPEG-2 Video"); |
| else if (guid == MFVideoFormat_MPG1) |
| return QStringLiteral("MPEG-1 Video"); |
| else if (guid == MFVideoFormat_MSS1) |
| return QStringLiteral("Windows Media Screen 1 (MSS1)"); |
| else if (guid == MFVideoFormat_MSS2) |
| return QStringLiteral("Windows Media Video 9 Screen (MSS2)"); |
| else if (guid == MFVideoFormat_WMV1) |
| return QStringLiteral("Windows Media Video 7 (WMV1)"); |
| else if (guid == MFVideoFormat_WMV2) |
| return QStringLiteral("Windows Media Video 8 (WMV2)"); |
| else if (guid == MFVideoFormat_WMV3) |
| return QStringLiteral("Windows Media Video 9 (WMV3)"); |
| else if (guid == MFVideoFormat_WVC1) |
| return QStringLiteral("Windows Media Video VC1 (WVC1)"); |
| |
| else |
| return QStringLiteral("Unknown codec"); |
| } |
| |
| MFMetaDataControl::MFMetaDataControl(QObject *parent) |
| : QMetaDataReaderControl(parent) |
| , m_metaData(0) |
| , m_content(0) |
| { |
| } |
| |
| MFMetaDataControl::~MFMetaDataControl() |
| { |
| if (m_metaData) |
| m_metaData->Release(); |
| if (m_content) |
| m_content->Release(); |
| } |
| |
| bool MFMetaDataControl::isMetaDataAvailable() const |
| { |
| return m_content || m_metaData; |
| } |
| |
| QVariant MFMetaDataControl::metaData(const QString &key) const |
| { |
| QVariant value; |
| if (!isMetaDataAvailable()) |
| return value; |
| |
| int index = m_availableMetaDatas.indexOf(key); |
| if (index < 0) |
| return value; |
| |
| PROPVARIANT var; |
| PropVariantInit(&var); |
| HRESULT hr = S_FALSE; |
| if (m_content) |
| hr = m_content->GetValue(m_commonKeys[index], &var); |
| else if (m_metaData) |
| hr = m_metaData->GetProperty(reinterpret_cast<LPCWSTR>(m_commonNames[index].utf16()), &var); |
| |
| if (SUCCEEDED(hr)) { |
| value = convertValue(var); |
| |
| // some metadata needs to be reformatted |
| if (value.isValid() && m_content) { |
| if (key == QMediaMetaData::MediaType) { |
| QString v = value.toString(); |
| if (v == QLatin1String("{D1607DBC-E323-4BE2-86A1-48A42A28441E}")) |
| value = QStringLiteral("Music"); |
| else if (v == QLatin1String("{DB9830BD-3AB3-4FAB-8A37-1A995F7FF74B}")) |
| value = QStringLiteral("Video"); |
| else if (v == QLatin1String("{01CD0F29-DA4E-4157-897B-6275D50C4F11}")) |
| value = QStringLiteral("Audio"); |
| else if (v == QLatin1String("{FCF24A76-9A57-4036-990D-E35DD8B244E1}")) |
| value = QStringLiteral("Other"); |
| } else if (key == QMediaMetaData::Duration) { |
| // duration is provided in 100-nanosecond units, convert to milliseconds |
| value = (value.toLongLong() + 10000) / 10000; |
| } else if (key == QMediaMetaData::AudioCodec || key == QMediaMetaData::VideoCodec) { |
| GUID guid; |
| if (SUCCEEDED(CLSIDFromString((const WCHAR*)value.toString().utf16(), &guid))) |
| value = nameForGUID(guid); |
| } else if (key == QMediaMetaData::Resolution) { |
| QSize res; |
| res.setHeight(value.toUInt()); |
| if (m_content && SUCCEEDED(m_content->GetValue(PKEY_Video_FrameWidth, &var))) |
| res.setWidth(convertValue(var).toUInt()); |
| value = res; |
| } else if (key == QMediaMetaData::Orientation) { |
| uint orientation = 0; |
| if (m_content && SUCCEEDED(m_content->GetValue(PKEY_Video_Orientation, &var))) |
| orientation = convertValue(var).toUInt(); |
| value = orientation; |
| } else if (key == QMediaMetaData::PixelAspectRatio) { |
| QSize aspectRatio; |
| aspectRatio.setWidth(value.toUInt()); |
| if (m_content && SUCCEEDED(m_content->GetValue(PKEY_Video_VerticalAspectRatio, &var))) |
| aspectRatio.setHeight(convertValue(var).toUInt()); |
| value = aspectRatio; |
| } else if (key == QMediaMetaData::VideoFrameRate) { |
| value = value.toReal() / 1000.f; |
| } |
| } |
| } |
| |
| PropVariantClear(&var); |
| return value; |
| } |
| |
| QVariant MFMetaDataControl::convertValue(const PROPVARIANT& var) const |
| { |
| QVariant value; |
| switch (var.vt) { |
| case VT_LPWSTR: |
| value = QString::fromUtf16(reinterpret_cast<const ushort*>(var.pwszVal)); |
| break; |
| case VT_UI4: |
| value = uint(var.ulVal); |
| break; |
| case VT_UI8: |
| value = qulonglong(var.uhVal.QuadPart); |
| break; |
| case VT_BOOL: |
| value = bool(var.boolVal); |
| break; |
| case VT_FILETIME: |
| SYSTEMTIME sysDate; |
| if (!FileTimeToSystemTime(&var.filetime, &sysDate)) |
| break; |
| value = QDate(sysDate.wYear, sysDate.wMonth, sysDate.wDay); |
| break; |
| case VT_STREAM: |
| { |
| STATSTG stat; |
| if (FAILED(var.pStream->Stat(&stat, STATFLAG_NONAME))) |
| break; |
| void *data = malloc(stat.cbSize.QuadPart); |
| ULONG read = 0; |
| if (FAILED(var.pStream->Read(data, stat.cbSize.QuadPart, &read))) { |
| free(data); |
| break; |
| } |
| value = QImage::fromData((const uchar*)data, read); |
| free(data); |
| } |
| break; |
| case VT_VECTOR | VT_LPWSTR: |
| QStringList vList; |
| for (ULONG i = 0; i < var.calpwstr.cElems; ++i) |
| vList.append(QString::fromUtf16(reinterpret_cast<const ushort*>(var.calpwstr.pElems[i]))); |
| value = vList; |
| break; |
| } |
| return value; |
| } |
| |
| QStringList MFMetaDataControl::availableMetaData() const |
| { |
| return m_availableMetaDatas; |
| } |
| |
| void MFMetaDataControl::updateSource(IMFPresentationDescriptor* sourcePD, IMFMediaSource* mediaSource) |
| { |
| if (m_metaData) { |
| m_metaData->Release(); |
| m_metaData = 0; |
| } |
| |
| if (m_content) { |
| m_content->Release(); |
| m_content = 0; |
| } |
| |
| m_availableMetaDatas.clear(); |
| m_commonKeys.clear(); |
| m_commonNames.clear(); |
| |
| if (SUCCEEDED(MFGetService(mediaSource, MF_PROPERTY_HANDLER_SERVICE, IID_PPV_ARGS(&m_content)))) { |
| DWORD cProps; |
| if (SUCCEEDED(m_content->GetCount(&cProps))) { |
| for (DWORD i = 0; i < cProps; i++) |
| { |
| PROPERTYKEY key; |
| if (FAILED(m_content->GetAt(i, &key))) |
| continue; |
| bool common = true; |
| if (key == PKEY_Author) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Author); |
| } else if (key == PKEY_Title) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Title); |
| } else if (key == PKEY_Media_SubTitle) { |
| m_availableMetaDatas.push_back(QMediaMetaData::SubTitle); |
| } else if (key == PKEY_ParentalRating) { |
| m_availableMetaDatas.push_back(QMediaMetaData::ParentalRating); |
| } else if (key == PKEY_Media_EncodingSettings) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Description); |
| } else if (key == PKEY_Copyright) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Copyright); |
| } else if (key == PKEY_Comment) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Comment); |
| } else if (key == PKEY_Media_ProviderStyle) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Genre); |
| } else if (key == PKEY_Media_Year) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Year); |
| } else if (key == PKEY_Media_DateEncoded) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Date); |
| } else if (key == PKEY_Rating) { |
| m_availableMetaDatas.push_back(QMediaMetaData::UserRating); |
| } else if (key == PKEY_Keywords) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Keywords); |
| } else if (key == PKEY_Language) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Language); |
| } else if (key == PKEY_Media_Publisher) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Publisher); |
| } else if (key == PKEY_Media_ClassPrimaryID) { |
| m_availableMetaDatas.push_back(QMediaMetaData::MediaType); |
| } else if (key == PKEY_Media_Duration) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Duration); |
| } else if (key == PKEY_Audio_EncodingBitrate) { |
| m_availableMetaDatas.push_back(QMediaMetaData::AudioBitRate); |
| } else if (key == PKEY_Audio_Format) { |
| m_availableMetaDatas.push_back(QMediaMetaData::AudioCodec); |
| } else if (key == PKEY_Media_AverageLevel) { |
| m_availableMetaDatas.push_back(QMediaMetaData::AverageLevel); |
| } else if (key == PKEY_Audio_ChannelCount) { |
| m_availableMetaDatas.push_back(QMediaMetaData::ChannelCount); |
| } else if (key == PKEY_Audio_PeakValue) { |
| m_availableMetaDatas.push_back(QMediaMetaData::PeakValue); |
| } else if (key == PKEY_Audio_SampleRate) { |
| m_availableMetaDatas.push_back(QMediaMetaData::SampleRate); |
| } else if (key == PKEY_Music_AlbumTitle) { |
| m_availableMetaDatas.push_back(QMediaMetaData::AlbumTitle); |
| } else if (key == PKEY_Music_AlbumArtist) { |
| m_availableMetaDatas.push_back(QMediaMetaData::AlbumArtist); |
| } else if (key == PKEY_Music_Artist) { |
| m_availableMetaDatas.push_back(QMediaMetaData::ContributingArtist); |
| } else if (key == PKEY_Music_Composer) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Composer); |
| } else if (key == PKEY_Music_Conductor) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Conductor); |
| } else if (key == PKEY_Music_Lyrics) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Lyrics); |
| } else if (key == PKEY_Music_Mood) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Mood); |
| } else if (key == PKEY_Music_TrackNumber) { |
| m_availableMetaDatas.push_back(QMediaMetaData::TrackNumber); |
| } else if (key == PKEY_Music_Genre) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Genre); |
| } else if (key == PKEY_ThumbnailStream) { |
| m_availableMetaDatas.push_back(QMediaMetaData::ThumbnailImage); |
| } else if (key == PKEY_Video_FrameHeight) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Resolution); |
| } else if (key == PKEY_Video_Orientation) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Orientation); |
| } else if (key == PKEY_Video_HorizontalAspectRatio) { |
| m_availableMetaDatas.push_back(QMediaMetaData::PixelAspectRatio); |
| } else if (key == PKEY_Video_FrameRate) { |
| m_availableMetaDatas.push_back(QMediaMetaData::VideoFrameRate); |
| } else if (key == PKEY_Video_EncodingBitrate) { |
| m_availableMetaDatas.push_back(QMediaMetaData::VideoBitRate); |
| } else if (key == PKEY_Video_Compression) { |
| m_availableMetaDatas.push_back(QMediaMetaData::VideoCodec); |
| } else if (key == PKEY_Video_Director) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Director); |
| } else if (key == PKEY_Media_Writer) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Writer); |
| } else { |
| common = false; |
| //TODO: add more extended keys |
| } |
| if (common) |
| m_commonKeys.push_back(key); |
| } |
| } else { |
| m_content->Release(); |
| m_content = NULL; |
| } |
| } |
| |
| if (!m_content) { |
| //fallback to Vista approach |
| IMFMetadataProvider *provider = NULL; |
| if (SUCCEEDED(MFGetService(mediaSource, MF_METADATA_PROVIDER_SERVICE, IID_PPV_ARGS(&provider)))) { |
| if (SUCCEEDED(provider->GetMFMetadata(sourcePD, 0, 0, &m_metaData))) { |
| PROPVARIANT varNames; |
| PropVariantInit(&varNames); |
| if (SUCCEEDED(m_metaData->GetAllPropertyNames(&varNames)) && varNames.vt == (VT_VECTOR | VT_LPWSTR)) { |
| ULONG cElements = varNames.calpwstr.cElems; |
| for (ULONG i = 0; i < cElements; i++) |
| { |
| const WCHAR* sName = varNames.calpwstr.pElems[i]; |
| #ifdef DEBUG_MEDIAFOUNDATION |
| qDebug() << "metadata: " << QString::fromUtf16(sName); |
| #endif |
| if (wcscmp(sName, L"Author") == 0) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Author); |
| } else if (wcscmp(sName, L"Title") == 0) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Title); |
| } else if (wcscmp(sName, L"Rating") == 0) { |
| m_availableMetaDatas.push_back(QMediaMetaData::ParentalRating); |
| } else if (wcscmp(sName, L"Description") == 0) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Description); |
| } else if (wcscmp(sName, L"Copyright") == 0) { |
| m_availableMetaDatas.push_back(QMediaMetaData::Copyright); |
| //TODO: add more common keys |
| } else { |
| m_availableMetaDatas.push_back(QString::fromUtf16(reinterpret_cast<const ushort*>(sName))); |
| } |
| m_commonNames.push_back(QString::fromUtf16(reinterpret_cast<const ushort*>(sName))); |
| } |
| } |
| PropVariantClear(&varNames); |
| } else { |
| qWarning("Failed to get IMFMetadata"); |
| } |
| provider->Release(); |
| } else { |
| qWarning("Failed to get IMFMetadataProvider from source"); |
| } |
| } |
| |
| emit metaDataChanged(); |
| emit metaDataAvailableChanged(m_metaData || m_content); |
| } |
