QWindowsFormatInfo: optimize creation time a bit

Querying the Media Foundation _only_ for the audio and video codecs
actually used, instead of querying _all_ codecs installed in the
system. On a default Win 10 setup, it's in 10-15% faster than
previous approach. On systems with additional codecs installed,
this may even be faster.

Task-number: QTBUG-116075
Change-Id: Ib5b572bddd21fa1dfaa1b120a7e48345ea6a1bc1
Reviewed-by: Artem Dyomin <artem.dyomin@qt.io>
(cherry picked from commit 9fcfa21aa8969ade546d475d77b214890fe05bce)
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

1 files changed, 58 insertions, 57 deletions

diff --git a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
index 5f7aa2843..d947a1f9e 100644
--- a/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
+++ b/src/plugins/multimedia/windows/qwindowsformatinfo.cpp
@@ -11,62 +11,69 @@
 
 #include <QtCore/qlist.h>
 #include <QtCore/qset.h>
+#include <QtCore/qhash.h>
 #include <QtGui/qimagewriter.h>
 
 QT_BEGIN_NAMESPACE
 
+namespace {
+
 template<typename T>
-static T codecForFormat(GUID format) = delete;
+using CheckedCodecs = QHash<QPair<T, QMediaFormat::ConversionMode>, bool>;
 
-template<>
-QMediaFormat::AudioCodec codecForFormat(GUID format)
+bool isSupportedMFT(const GUID &category, const MFT_REGISTER_TYPE_INFO &type, QMediaFormat::ConversionMode mode)
 {
-    return QWindowsMultimediaUtils::codecForAudioFormat(format);
+    UINT32 count = 0;
+    IMFActivate **activateArrayRaw = nullptr;
+    HRESULT hr = MFTEnumEx(
+            category,
+            MFT_ENUM_FLAG_ALL,
+            (mode == QMediaFormat::Encode) ? nullptr : &type,  // Input type
+            (mode == QMediaFormat::Encode) ? &type : nullptr,  // Output type
+            &activateArrayRaw,
+            &count
+            );
+
+    if (FAILED(hr))
+        return false;
+
+    QComTaskResource<IMFActivate *[], QComDeleter> activateArray(activateArrayRaw, count);
+    for (UINT32 i = 0; i < count; ++i) {
+        ComPtr<IMFTransform> transform;
+        hr = activateArray[i]->ActivateObject(IID_PPV_ARGS(transform.GetAddressOf()));
+        if (SUCCEEDED(hr))
+            return true;
+    }
+
+    return false;
 }
 
-template<>
-QMediaFormat::VideoCodec codecForFormat(GUID format)
+bool isSupportedCodec(QMediaFormat::AudioCodec codec, QMediaFormat::ConversionMode mode)
 {
-    return QWindowsMultimediaUtils::codecForVideoFormat(format);
+    return isSupportedMFT((mode == QMediaFormat::Encode) ? MFT_CATEGORY_AUDIO_ENCODER : MFT_CATEGORY_AUDIO_DECODER,
+                          { MFMediaType_Audio, QWindowsMultimediaUtils::audioFormatForCodec(codec) },
+                          mode);
 }
 
-template<typename T>
-static QSet<T> getCodecSet(GUID category)
+bool isSupportedCodec(QMediaFormat::VideoCodec codec, QMediaFormat::ConversionMode mode)
 {
-    QSet<T> codecSet;
-    IMFActivate **activateArrayRaw = nullptr;
-    UINT32 num = 0;
-
-    HRESULT hr = MFTEnumEx(category, MFT_ENUM_FLAG_ALL, nullptr, nullptr, &activateArrayRaw, &num);
-
-    if (SUCCEEDED(hr)) {
-        QComTaskResource<IMFActivate *[], QComDeleter> activateArray(activateArrayRaw, num);
-
-        for (UINT32 i = 0; i < num; ++i) {
-            ComPtr<IMFTransform> transform;
-            UINT32 typeIndex = 0;
-
-            hr = activateArray[i]->ActivateObject(IID_PPV_ARGS(transform.GetAddressOf()));
+    return isSupportedMFT((mode == QMediaFormat::Encode) ? MFT_CATEGORY_VIDEO_ENCODER : MFT_CATEGORY_VIDEO_DECODER,
+                          { MFMediaType_Video, QWindowsMultimediaUtils::videoFormatForCodec(codec) },
+                          mode);
+}
 
-            while (SUCCEEDED(hr)) {
-                ComPtr<IMFMediaType> mediaType;
+template <typename T>
+bool isSupportedCodec(T codec, QMediaFormat::ConversionMode m, CheckedCodecs<T> &checkedCodecs)
+{
+    if (auto it = checkedCodecs.constFind(qMakePair(codec, m)); it != checkedCodecs.constEnd())
+        return it.value();
 
-                if (category == MFT_CATEGORY_AUDIO_ENCODER || category == MFT_CATEGORY_VIDEO_ENCODER)
-                    hr = transform->GetOutputAvailableType(0, typeIndex++, mediaType.GetAddressOf());
-                else
-                    hr = transform->GetInputAvailableType(0, typeIndex++, mediaType.GetAddressOf());
+    const bool supported = isSupportedCodec(codec, m);
 
-                if (SUCCEEDED(hr)) {
-                    GUID subtype = GUID_NULL;
-                    hr = mediaType->GetGUID(MF_MT_SUBTYPE, &subtype);
-                    if (SUCCEEDED(hr))
-                        codecSet.insert(codecForFormat<T>(subtype));
-                }
-            }
-        }
-    }
+    checkedCodecs.insert(qMakePair(codec, m), supported);
+    return supported;
+}
 
-    return codecSet;
 }
 
 static QList<QImageCapture::FileFormat> getImageFormatList()
@@ -147,31 +154,25 @@ QWindowsFormatInfo::QWindowsFormatInfo()
         QMediaFormat::WMV,
     };
 
-    const auto audioDecoders = getCodecSet<QMediaFormat::AudioCodec>(MFT_CATEGORY_AUDIO_DECODER);
-    const auto audioEncoders = getCodecSet<QMediaFormat::AudioCodec>(MFT_CATEGORY_AUDIO_ENCODER);
-    const auto videoDecoders = getCodecSet<QMediaFormat::VideoCodec>(MFT_CATEGORY_VIDEO_DECODER);
-    const auto videoEncoders = getCodecSet<QMediaFormat::VideoCodec>(MFT_CATEGORY_VIDEO_ENCODER);
+    CheckedCodecs<QMediaFormat::AudioCodec> checkedAudioCodecs;
+    CheckedCodecs<QMediaFormat::VideoCodec> checkedVideoCodecs;
 
-    for (const auto &codecMap : containerTable) {
-
-        const QSet<QMediaFormat::AudioCodec> mapAudioSet(codecMap.audio.cbegin(), codecMap.audio.cend());
-        const QSet<QMediaFormat::VideoCodec> mapVideoSet(codecMap.video.cbegin(), codecMap.video.cend());
+    auto ensureCodecs = [&] (CodecMap &codecs, QMediaFormat::ConversionMode mode) {
+        codecs.audio.removeIf([&] (auto codec) { return !isSupportedCodec(codec, mode, checkedAudioCodecs); });
+        codecs.video.removeIf([&] (auto codec) { return !isSupportedCodec(codec, mode, checkedVideoCodecs); });
+        return !codecs.video.empty() || !codecs.audio.empty();
+    };
 
+    for (const auto &codecMap : containerTable) {
         if (decoderFormats.contains(codecMap.format)) {
-            CodecMap m;
-            m.format = codecMap.format;
-            m.audio = (audioDecoders & mapAudioSet).values();
-            m.video = (videoDecoders & mapVideoSet).values();
-            if (!m.video.empty() || !m.audio.empty())
+            auto m = codecMap;
+            if (ensureCodecs(m, QMediaFormat::Decode))
                 decoders.append(m);
         }
 
         if (encoderFormats.contains(codecMap.format)) {
-            CodecMap m;
-            m.format = codecMap.format;
-            m.audio = (audioEncoders & mapAudioSet).values();
-            m.video = (videoEncoders & mapVideoSet).values();
-            if (!m.video.empty() || !m.audio.empty())
+            auto m = codecMap;
+            if (ensureCodecs(m, QMediaFormat::Encode))
                 encoders.append(m);
         }
     }