Diff
Modified: trunk/LayoutTests/ChangeLog (268575 => 268576)
--- trunk/LayoutTests/ChangeLog 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/LayoutTests/ChangeLog 2020-10-16 08:52:38 UTC (rev 268576)
@@ -1,3 +1,12 @@
+2020-10-16 Philippe Normand <[email protected]>
+
+ [GStreamer] Encoder probing support for the registry scanner
+ https://bugs.webkit.org/show_bug.cgi?id=217750
+
+ Reviewed by Xabier Rodriguez-Calvar.
+
+ * platform/glib/media/mediacapabilities-types-expected.txt: Renamed from LayoutTests/platform/gtk/media/mediacapabilities/mediacapabilities-types-expected.txt.
+
2020-10-16 Diego Pino Garcia <[email protected]>
[GLIB][GTK] Unreviewed test gardening. Update test expectations after r268573.
Copied: trunk/LayoutTests/platform/glib/media/mediacapabilities-types-expected.txt (from rev 268575, trunk/LayoutTests/platform/gtk/media/mediacapabilities/mediacapabilities-types-expected.txt) (0 => 268576)
--- trunk/LayoutTests/platform/glib/media/mediacapabilities-types-expected.txt (rev 0)
+++ trunk/LayoutTests/platform/glib/media/mediacapabilities-types-expected.txt 2020-10-16 08:52:38 UTC (rev 268576)
@@ -0,0 +1,87 @@
+Test basic dictionary and enum types of Media Capabilities API
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file' });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'media-source' });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', audio: { } });
+ } rejected promise with TypeError: Member AudioConfiguration.contentType is required and must be an instance of DOMString.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', audio: { contentType: 'video/mp4; codecs="avc1"' } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { } });
+ } rejected promise with TypeError: Member VideoConfiguration.bitrate is required and must be an instance of unsigned long long.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'audio/mp3', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Member VideoConfiguration.width is required and must be an instance of unsigned long.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1,vp9"', width:640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4', width:640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 0 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/a" } });
+ } rejected promise with TypeError: The provided value is non-finite.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/0" } });
+ } rejected promise with TypeError: The provided value is non-finite.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'invalid', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.encodingInfo({ type: 'record' });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.encodingInfo({ type: 'record', audio: { } });
+ } rejected promise with TypeError: Member AudioConfiguration.contentType is required and must be an instance of DOMString.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', audio: { } });
+ } rejected promise with TypeError: Member AudioConfiguration.contentType is required and must be an instance of DOMString.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', audio: { contentType: 'video/mp4; codecs="avc1"' } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { } });
+ } rejected promise with TypeError: Member VideoConfiguration.bitrate is required and must be an instance of unsigned long long.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'audio/mp3', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Member VideoConfiguration.width is required and must be an instance of unsigned long.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1,vp9"', width:640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4', width:640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 0 } });
+ } rejected promise with TypeError: Type error.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/a" } });
+ } rejected promise with TypeError: The provided value is non-finite.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/-1" } });
+ } rejected promise with TypeError: The provided value is non-finite.
+PASS () => {
+ return navigator.mediaCapabilities.decodingInfo({ type: 'invalid', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
+ } rejected promise with TypeError: Type error.
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
Deleted: trunk/LayoutTests/platform/gtk/media/mediacapabilities/mediacapabilities-types-expected.txt (268575 => 268576)
--- trunk/LayoutTests/platform/gtk/media/mediacapabilities/mediacapabilities-types-expected.txt 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/LayoutTests/platform/gtk/media/mediacapabilities/mediacapabilities-types-expected.txt 2020-10-16 08:52:38 UTC (rev 268576)
@@ -1,87 +0,0 @@
-Test basic dictionary and enum types of Media Capabilities API
-
-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
-
-
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file' });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'media-source' });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', audio: { } });
- } rejected promise with TypeError: Member AudioConfiguration.contentType is required and must be an instance of DOMString.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', audio: { contentType: 'video/mp4; codecs="avc1"' } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { } });
- } rejected promise with TypeError: Member VideoConfiguration.bitrate is required and must be an instance of unsigned long long.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'audio/mp3', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Member VideoConfiguration.width is required and must be an instance of unsigned long.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1,vp9"', width:640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4', width:640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 0 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/a" } });
- } rejected promise with TypeError: The provided value is non-finite.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'file', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/0" } });
- } rejected promise with TypeError: The provided value is non-finite.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'invalid', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-FAIL () => {
- return navigator.mediaCapabilities.encodingInfo({ type: 'record' });
- } should not throw exception. Threw exception TypeError: navigator.mediaCapabilities.encodingInfo is not a function. (In 'navigator.mediaCapabilities.encodingInfo({ type: 'record' })', 'navigator.mediaCapabilities.encodingInfo' is undefined).
-FAIL () => {
- return navigator.mediaCapabilities.encodingInfo({ type: 'record', audio: { } });
- } should not throw exception. Threw exception TypeError: navigator.mediaCapabilities.encodingInfo is not a function. (In 'navigator.mediaCapabilities.encodingInfo({ type: 'record', audio: { } })', 'navigator.mediaCapabilities.encodingInfo' is undefined).
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', audio: { } });
- } rejected promise with TypeError: Member AudioConfiguration.contentType is required and must be an instance of DOMString.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', audio: { contentType: 'video/mp4; codecs="avc1"' } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { } });
- } rejected promise with TypeError: Member VideoConfiguration.bitrate is required and must be an instance of unsigned long long.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'audio/mp3', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Member VideoConfiguration.width is required and must be an instance of unsigned long.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1,vp9"', width:640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4', width:640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 0 } });
- } rejected promise with TypeError: Type error.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/a" } });
- } rejected promise with TypeError: The provided value is non-finite.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'record', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: "24/-1" } });
- } rejected promise with TypeError: The provided value is non-finite.
-PASS () => {
- return navigator.mediaCapabilities.decodingInfo({ type: 'invalid', video: { contentType: 'video/mp4; codecs="avc1"', width: 640, height: 480, bitrate: 1000, framerate: 24 } });
- } rejected promise with TypeError: Type error.
-PASS successfullyParsed is true
-
-TEST COMPLETE
-
Modified: trunk/Source/WebCore/ChangeLog (268575 => 268576)
--- trunk/Source/WebCore/ChangeLog 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/ChangeLog 2020-10-16 08:52:38 UTC (rev 268576)
@@ -1,3 +1,50 @@
+2020-10-16 Philippe Normand <[email protected]>
+
+ [GStreamer] Encoder probing support for the registry scanner
+ https://bugs.webkit.org/show_bug.cgi?id=217750
+
+ Reviewed by Xabier Rodriguez-Calvar.
+
+ The scanner is now able to probe for platform encoders for the most common formats: avc1,
+ av1, ogg, theora, aac and opus. The muxers for webm and mp4 are also checked.
+
+ No new tests, existing mediacapabilities test cover this change.
+
+ * platform/graphics/gstreamer/GStreamerRegistryScanner.cpp:
+ (WebCore::GStreamerRegistryScanner::GStreamerRegistryScanner):
+ (WebCore::GStreamerRegistryScanner::~GStreamerRegistryScanner):
+ (WebCore::GStreamerRegistryScanner::mimeTypeSet):
+ (WebCore::GStreamerRegistryScanner::isContainerTypeSupported const):
+ (WebCore::GStreamerRegistryScanner::hasElementForMediaType const):
+ (WebCore::GStreamerRegistryScanner::fillMimeTypeSetFromCapsMapping):
+ (WebCore::GStreamerRegistryScanner::initializeDecoders):
+ (WebCore::GStreamerRegistryScanner::initializeEncoders):
+ (WebCore::GStreamerRegistryScanner::isCodecSupported const):
+ (WebCore::GStreamerRegistryScanner::isContentTypeSupported const):
+ (WebCore::GStreamerRegistryScanner::areAllCodecsSupported const):
+ (WebCore::GStreamerRegistryScanner::isAVC1CodecSupported const):
+ (WebCore::GStreamerRegistryScanner::configurationNameForLogging const):
+ (WebCore::GStreamerRegistryScanner::isConfigurationSupported const):
+ * platform/graphics/gstreamer/GStreamerRegistryScanner.h:
+ (WebCore::GStreamerRegistryScanner::isDecodingSupported const):
+ (WebCore::GStreamerRegistryScanner::isEncodingSupported const):
+ * platform/graphics/gstreamer/ImageDecoderGStreamer.cpp:
+ (WebCore::ImageDecoderGStreamer::supportsContainerType):
+ (WebCore::ImageDecoderGStreamer::canDecodeType):
+ * platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.cpp:
+ (WebCore::createMediaPlayerEncodingConfigurationGStreamer):
+ * platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.h:
+ * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
+ (WebCore::MediaPlayerPrivateGStreamer::getSupportedTypes):
+ (WebCore::MediaPlayerPrivateGStreamer::supportsType):
+ * platform/graphics/gstreamer/mse/AppendPipeline.cpp:
+ (WebCore::AppendPipeline::parseDemuxerSrcPadCaps):
+ * platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp:
+ (WebCore::MediaPlayerPrivateGStreamerMSE::getSupportedTypes):
+ (WebCore::MediaPlayerPrivateGStreamerMSE::supportsType):
+ * platform/mediacapabilities/MediaEngineConfigurationFactory.cpp:
+ (WebCore::factories):
+
2020-10-15 Keith Rollin <[email protected]>
Lessen the reliance on VPATH in WebCore/DerivedSources.make
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -26,6 +26,7 @@
#include <fnmatch.h>
#include <gst/pbutils/codec-utils.h>
#include <wtf/PrintStream.h>
+#include <wtf/WeakPtr.h>
namespace WebCore {
@@ -48,13 +49,22 @@
m_videoParserFactories = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_PARSER | GST_ELEMENT_FACTORY_TYPE_MEDIA_VIDEO, GST_RANK_MARGINAL);
m_demuxerFactories = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_DEMUXER, GST_RANK_MARGINAL);
- initialize();
+ m_audioEncoderFactories = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_ENCODER | GST_ELEMENT_FACTORY_TYPE_MEDIA_AUDIO, GST_RANK_MARGINAL);
+ m_videoEncoderFactories = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_ENCODER | GST_ELEMENT_FACTORY_TYPE_MEDIA_VIDEO, GST_RANK_MARGINAL);
+ m_muxerFactories = gst_element_factory_list_get_elements(GST_ELEMENT_FACTORY_TYPE_MUXER, GST_RANK_MARGINAL);
+
+ initializeDecoders();
+ initializeEncoders();
#ifndef GST_DISABLE_GST_DEBUG
GST_DEBUG("%s registry scanner initialized", m_isMediaSource ? "MSE" : "Regular playback");
- for (auto& mimeType : m_mimeTypeSet)
- GST_DEBUG("Mime-type registered: %s", mimeType.utf8().data());
- for (auto& item : m_codecMap)
- GST_DEBUG("%s codec pattern registered: %s", item.value ? "Hardware" : "Software", item.key.string().utf8().data());
+ for (auto& mimeType : m_decoderMimeTypeSet)
+ GST_DEBUG("Decoder mime-type registered: %s", mimeType.utf8().data());
+ for (auto& item : m_decoderCodecMap)
+ GST_DEBUG("%s decoder codec pattern registered: %s", item.value ? "Hardware" : "Software", item.key.string().utf8().data());
+ for (auto& mimeType : m_encoderMimeTypeSet)
+ GST_DEBUG("Encoder mime-type registered: %s", mimeType.utf8().data());
+ for (auto& item : m_encoderCodecMap)
+ GST_DEBUG("%s encoder codec pattern registered: %s", item.value ? "Hardware" : "Software", item.key.string().utf8().data());
#endif
}
@@ -65,15 +75,65 @@
gst_plugin_feature_list_free(m_videoDecoderFactories);
gst_plugin_feature_list_free(m_videoParserFactories);
gst_plugin_feature_list_free(m_demuxerFactories);
+ gst_plugin_feature_list_free(m_audioEncoderFactories);
+ gst_plugin_feature_list_free(m_videoEncoderFactories);
+ gst_plugin_feature_list_free(m_muxerFactories);
}
+const HashSet<String, ASCIICaseInsensitiveHash>& GStreamerRegistryScanner::mimeTypeSet(Configuration configuration)
+{
+ switch (configuration) {
+ case Configuration::Decoding:
+ return m_decoderMimeTypeSet;
+ case Configuration::Encoding:
+ return m_encoderMimeTypeSet;
+ }
+ ASSERT_NOT_REACHED();
+ return m_decoderMimeTypeSet;
+}
+
+bool GStreamerRegistryScanner::isContainerTypeSupported(Configuration configuration, String containerType) const
+{
+ switch (configuration) {
+ case Configuration::Decoding:
+ return m_decoderMimeTypeSet.contains(containerType);
+ case Configuration::Encoding:
+ return m_encoderMimeTypeSet.contains(containerType);
+ }
+ ASSERT_NOT_REACHED();
+ return false;
+}
+
GStreamerRegistryScanner::RegistryLookupResult GStreamerRegistryScanner::hasElementForMediaType(GList* elementFactories, const char* capsString, bool shouldCheckHardwareClassifier, Optional<Vector<String>> blackList) const
{
+ GstPadDirection padDirection = GST_PAD_SINK;
+ if (elementFactories == m_audioEncoderFactories || elementFactories == m_videoEncoderFactories || elementFactories == m_muxerFactories)
+ padDirection = GST_PAD_SRC;
GRefPtr<GstCaps> caps = adoptGRef(gst_caps_from_string(capsString));
- GList* candidates = gst_element_factory_list_filter(elementFactories, caps.get(), GST_PAD_SINK, false);
+ GList* candidates = gst_element_factory_list_filter(elementFactories, caps.get(), padDirection, false);
bool isSupported = candidates;
bool isUsingHardware = false;
+ const char* elementType = "";
+ if (elementFactories == m_audioParserFactories)
+ elementType = "audio parser";
+ else if (elementFactories == m_audioDecoderFactories)
+ elementType = "audio decoder";
+ else if (elementFactories == m_videoParserFactories)
+ elementType = "video parser";
+ else if (elementFactories == m_videoDecoderFactories)
+ elementType = "video decoder";
+ else if (elementFactories == m_demuxerFactories)
+ elementType = "demuxer";
+ else if (elementFactories == m_audioEncoderFactories)
+ elementType = "audio encoder";
+ else if (elementFactories == m_videoEncoderFactories)
+ elementType = "video encoder";
+ else if (elementFactories == m_muxerFactories)
+ elementType = "muxer";
+ else
+ ASSERT_NOT_REACHED();
+
if (blackList.hasValue() && !blackList->isEmpty()) {
bool hasValidCandidate = false;
for (GList* factories = candidates; factories; factories = g_list_next(factories)) {
@@ -84,7 +144,7 @@
break;
}
if (!hasValidCandidate) {
- GST_WARNING("All elements for caps %" GST_PTR_FORMAT " are blacklisted", caps.get());
+ GST_WARNING("All %s elements matching caps %" GST_PTR_FORMAT " are blacklisted", elementType, caps.get());
isSupported = false;
shouldCheckHardwareClassifier = false;
}
@@ -103,22 +163,7 @@
}
gst_plugin_feature_list_free(candidates);
-#ifndef GST_DISABLE_GST_DEBUG
- const char* elementType = "";
- if (elementFactories == m_audioParserFactories)
- elementType = "Audio parser";
- else if (elementFactories == m_audioDecoderFactories)
- elementType = "Audio decoder";
- else if (elementFactories == m_videoParserFactories)
- elementType = "Video parser";
- else if (elementFactories == m_videoDecoderFactories)
- elementType = "Video decoder";
- else if (elementFactories == m_demuxerFactories)
- elementType = "Demuxer";
- else
- ASSERT_NOT_REACHED();
- GST_LOG("%s lookup result for caps %" GST_PTR_FORMAT " : isSupported=%s, isUsingHardware=%s", elementType, caps.get(), boolForPrinting(isSupported), boolForPrinting(isUsingHardware));
-#endif
+ GST_LOG("Lookup result for %s matching caps %" GST_PTR_FORMAT " : isSupported=%s, isUsingHardware=%s", elementType, caps.get(), boolForPrinting(isSupported), boolForPrinting(isUsingHardware));
return GStreamerRegistryScanner::RegistryLookupResult { isSupported, isUsingHardware };
}
@@ -126,53 +171,76 @@
{
for (auto& current : mapping) {
GList* factories;
+ HashSet<String, ASCIICaseInsensitiveHash> mimeTypeSet;
+ HashMap<AtomString, bool> codecMap;
switch (current.elementType) {
case Demuxer:
factories = m_demuxerFactories;
+ codecMap = m_decoderCodecMap;
+ mimeTypeSet = m_decoderMimeTypeSet;
break;
case AudioDecoder:
factories = m_audioDecoderFactories;
+ codecMap = m_decoderCodecMap;
+ mimeTypeSet = m_decoderMimeTypeSet;
break;
case VideoDecoder:
factories = m_videoDecoderFactories;
+ codecMap = m_decoderCodecMap;
+ mimeTypeSet = m_decoderMimeTypeSet;
break;
+ case Muxer:
+ factories = m_muxerFactories;
+ codecMap = m_encoderCodecMap;
+ mimeTypeSet = m_encoderMimeTypeSet;
+ break;
+ case AudioEncoder:
+ factories = m_audioEncoderFactories;
+ codecMap = m_encoderCodecMap;
+ mimeTypeSet = m_encoderMimeTypeSet;
+ break;
+ case VideoEncoder:
+ factories = m_videoEncoderFactories;
+ codecMap = m_encoderCodecMap;
+ mimeTypeSet = m_encoderMimeTypeSet;
+ break;
}
if (hasElementForMediaType(factories, current.capsString)) {
if (!current.webkitCodecPatterns.isEmpty()) {
for (const auto& pattern : current.webkitCodecPatterns)
- m_codecMap.add(pattern, false);
+ codecMap.add(pattern, false);
}
if (!current.webkitMimeTypes.isEmpty()) {
for (const auto& mimeType : current.webkitMimeTypes)
- m_mimeTypeSet.add(mimeType);
+ mimeTypeSet.add(mimeType);
} else
- m_mimeTypeSet.add(AtomString(current.capsString));
+ mimeTypeSet.add(AtomString(current.capsString));
}
}
}
-void GStreamerRegistryScanner::initialize()
+void GStreamerRegistryScanner::initializeDecoders()
{
if (hasElementForMediaType(m_audioDecoderFactories, "audio/mpeg, mpegversion=(int)4")) {
- m_mimeTypeSet.add(AtomString("audio/aac"));
- m_mimeTypeSet.add(AtomString("audio/mp4"));
- m_mimeTypeSet.add(AtomString("audio/x-m4a"));
- m_codecMap.add(AtomString("mpeg"), false);
- m_codecMap.add(AtomString("mp4a*"), false);
+ m_decoderMimeTypeSet.add(AtomString("audio/aac"));
+ m_decoderMimeTypeSet.add(AtomString("audio/mp4"));
+ m_decoderMimeTypeSet.add(AtomString("audio/x-m4a"));
+ m_decoderCodecMap.add(AtomString("mpeg"), false);
+ m_decoderCodecMap.add(AtomString("mp4a*"), false);
}
auto opusSupported = hasElementForMediaType(m_audioDecoderFactories, "audio/x-opus");
if (opusSupported && (!m_isMediaSource || hasElementForMediaType(m_audioParserFactories, "audio/x-opus"))) {
- m_mimeTypeSet.add(AtomString("audio/opus"));
- m_codecMap.add(AtomString("opus"), false);
- m_codecMap.add(AtomString("x-opus"), false);
+ m_decoderMimeTypeSet.add(AtomString("audio/opus"));
+ m_decoderCodecMap.add(AtomString("opus"), false);
+ m_decoderCodecMap.add(AtomString("x-opus"), false);
}
auto vorbisSupported = hasElementForMediaType(m_audioDecoderFactories, "audio/x-vorbis");
if (vorbisSupported && (!m_isMediaSource || hasElementForMediaType(m_audioParserFactories, "audio/x-vorbis"))) {
- m_codecMap.add(AtomString("vorbis"), false);
- m_codecMap.add(AtomString("x-vorbis"), false);
+ m_decoderCodecMap.add(AtomString("vorbis"), false);
+ m_decoderCodecMap.add(AtomString("x-vorbis"), false);
}
bool matroskaSupported = hasElementForMediaType(m_demuxerFactories, "video/x-matroska");
@@ -181,37 +249,37 @@
auto vp9DecoderAvailable = hasElementForMediaType(m_videoDecoderFactories, "video/x-vp9", true);
if (vp8DecoderAvailable || vp9DecoderAvailable)
- m_mimeTypeSet.add(AtomString("video/webm"));
+ m_decoderMimeTypeSet.add(AtomString("video/webm"));
if (vp8DecoderAvailable) {
- m_codecMap.add(AtomString("vp8"), vp8DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("x-vp8"), vp8DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("vp8.0"), vp8DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("vp8"), vp8DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("x-vp8"), vp8DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("vp8.0"), vp8DecoderAvailable.isUsingHardware);
}
if (vp9DecoderAvailable) {
- m_codecMap.add(AtomString("vp9"), vp9DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("x-vp9"), vp9DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("vp9.0"), vp9DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("vp09*"), vp9DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("vp9"), vp9DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("x-vp9"), vp9DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("vp9.0"), vp9DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("vp09*"), vp9DecoderAvailable.isUsingHardware);
}
if (opusSupported)
- m_mimeTypeSet.add(AtomString("audio/webm"));
+ m_decoderMimeTypeSet.add(AtomString("audio/webm"));
}
auto h264DecoderAvailable = hasElementForMediaType(m_videoDecoderFactories, "video/x-h264, profile="" constrained-baseline, baseline, high }", true);
if (h264DecoderAvailable && (!m_isMediaSource || hasElementForMediaType(m_videoParserFactories, "video/x-h264"))) {
- m_mimeTypeSet.add(AtomString("video/mp4"));
- m_mimeTypeSet.add(AtomString("video/x-m4v"));
- m_codecMap.add(AtomString("x-h264"), h264DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("avc*"), h264DecoderAvailable.isUsingHardware);
- m_codecMap.add(AtomString("mp4v*"), h264DecoderAvailable.isUsingHardware);
+ m_decoderMimeTypeSet.add(AtomString("video/mp4"));
+ m_decoderMimeTypeSet.add(AtomString("video/x-m4v"));
+ m_decoderCodecMap.add(AtomString("x-h264"), h264DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("avc*"), h264DecoderAvailable.isUsingHardware);
+ m_decoderCodecMap.add(AtomString("mp4v*"), h264DecoderAvailable.isUsingHardware);
}
Vector<String> av1DecodersBlacklist { "av1dec"_s };
- if ((matroskaSupported || isContainerTypeSupported("video/mp4")) && hasElementForMediaType(m_videoDecoderFactories, "video/x-av1", false, makeOptional(WTFMove(av1DecodersBlacklist)))) {
- m_codecMap.add(AtomString("av01*"), false);
- m_codecMap.add(AtomString("av1"), false);
- m_codecMap.add(AtomString("x-av1"), false);
+ if ((matroskaSupported || isContainerTypeSupported(Configuration::Decoding, "video/mp4")) && hasElementForMediaType(m_videoDecoderFactories, "video/x-av1", false, makeOptional(WTFMove(av1DecodersBlacklist)))) {
+ m_decoderCodecMap.add(AtomString("av01*"), false);
+ m_decoderCodecMap.add(AtomString("av1"), false);
+ m_decoderCodecMap.add(AtomString("x-av1"), false);
}
if (m_isMediaSource)
@@ -248,21 +316,21 @@
fillMimeTypeSetFromCapsMapping(mapping);
if (hasElementForMediaType(m_demuxerFactories, "application/ogg")) {
- m_mimeTypeSet.add(AtomString("application/ogg"));
+ m_decoderMimeTypeSet.add(AtomString("application/ogg"));
if (vorbisSupported) {
- m_mimeTypeSet.add(AtomString("audio/ogg"));
- m_mimeTypeSet.add(AtomString("audio/x-vorbis+ogg"));
+ m_decoderMimeTypeSet.add(AtomString("audio/ogg"));
+ m_decoderMimeTypeSet.add(AtomString("audio/x-vorbis+ogg"));
}
if (hasElementForMediaType(m_audioDecoderFactories, "audio/x-speex")) {
- m_mimeTypeSet.add(AtomString("audio/ogg"));
- m_codecMap.add(AtomString("speex"), false);
+ m_decoderMimeTypeSet.add(AtomString("audio/ogg"));
+ m_decoderCodecMap.add(AtomString("speex"), false);
}
if (hasElementForMediaType(m_videoDecoderFactories, "video/x-theora")) {
- m_mimeTypeSet.add(AtomString("video/ogg"));
- m_codecMap.add(AtomString("theora"), false);
+ m_decoderMimeTypeSet.add(AtomString("video/ogg"));
+ m_decoderCodecMap.add(AtomString("theora"), false);
}
}
@@ -269,34 +337,115 @@
bool audioMpegSupported = false;
if (hasElementForMediaType(m_audioDecoderFactories, "audio/mpeg, mpegversion=(int)1, layer=(int)[1, 3]")) {
audioMpegSupported = true;
- m_mimeTypeSet.add(AtomString("audio/mp1"));
- m_mimeTypeSet.add(AtomString("audio/mp3"));
- m_mimeTypeSet.add(AtomString("audio/x-mp3"));
- m_codecMap.add(AtomString("audio/mp3"), false);
- m_codecMap.add(AtomString("mp3"), false);
+ m_decoderMimeTypeSet.add(AtomString("audio/mp1"));
+ m_decoderMimeTypeSet.add(AtomString("audio/mp3"));
+ m_decoderMimeTypeSet.add(AtomString("audio/x-mp3"));
+ m_decoderCodecMap.add(AtomString("audio/mp3"), false);
+ m_decoderCodecMap.add(AtomString("mp3"), false);
}
if (hasElementForMediaType(m_audioDecoderFactories, "audio/mpeg, mpegversion=(int)2")) {
audioMpegSupported = true;
- m_mimeTypeSet.add(AtomString("audio/mp2"));
+ m_decoderMimeTypeSet.add(AtomString("audio/mp2"));
}
- audioMpegSupported |= isContainerTypeSupported("audio/mp4");
+ audioMpegSupported |= isContainerTypeSupported(Configuration::Decoding, "audio/mp4");
if (audioMpegSupported) {
- m_mimeTypeSet.add(AtomString("audio/mpeg"));
- m_mimeTypeSet.add(AtomString("audio/x-mpeg"));
+ m_decoderMimeTypeSet.add(AtomString("audio/mpeg"));
+ m_decoderMimeTypeSet.add(AtomString("audio/x-mpeg"));
}
if (matroskaSupported) {
- m_mimeTypeSet.add(AtomString("video/x-matroska"));
+ m_decoderMimeTypeSet.add(AtomString("video/x-matroska"));
if (hasElementForMediaType(m_videoDecoderFactories, "video/x-vp10"))
- m_mimeTypeSet.add(AtomString("video/webm"));
+ m_decoderMimeTypeSet.add(AtomString("video/webm"));
}
}
-bool GStreamerRegistryScanner::isCodecSupported(String codec, bool shouldCheckForHardwareUse) const
+void GStreamerRegistryScanner::initializeEncoders()
{
+ // MSE is about playback, which means decoding. No need to check for encoders then.
+ if (m_isMediaSource)
+ return;
+
+ auto aacSupported = hasElementForMediaType(m_audioEncoderFactories, "audio/mpeg, mpegversion=(int)4");
+ if (hasElementForMediaType(m_audioEncoderFactories, "audio/mpeg, mpegversion=(int)4")) {
+ m_encoderCodecMap.add(AtomString("mpeg"), false);
+ m_encoderCodecMap.add(AtomString("mp4a*"), false);
+ }
+
+ auto opusSupported = hasElementForMediaType(m_audioEncoderFactories, "audio/x-opus");
+ if (opusSupported) {
+ m_encoderCodecMap.add(AtomString("opus"), false);
+ m_encoderCodecMap.add(AtomString("x-opus"), false);
+ }
+
+ auto vorbisSupported = hasElementForMediaType(m_audioEncoderFactories, "audio/x-vorbis");
+ if (vorbisSupported) {
+ m_encoderCodecMap.add(AtomString("vorbis"), false);
+ m_encoderCodecMap.add(AtomString("x-vorbis"), false);
+ }
+
+ Vector<String> av1EncodersBlacklist { "av1enc"_s };
+ auto av1EncoderAvailable = hasElementForMediaType(m_videoEncoderFactories, "video/x-av1", true, makeOptional(WTFMove(av1EncodersBlacklist)));
+ if (av1EncoderAvailable) {
+ m_encoderCodecMap.add(AtomString("av01*"), false);
+ m_encoderCodecMap.add(AtomString("av1"), false);
+ m_encoderCodecMap.add(AtomString("x-av1"), false);
+ }
+
+ auto vp8EncoderAvailable = hasElementForMediaType(m_videoEncoderFactories, "video/x-vp8", true);
+ if (vp8EncoderAvailable) {
+ m_encoderCodecMap.add(AtomString("vp8"), vp8EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("x-vp8"), vp8EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("vp8.0"), vp8EncoderAvailable.isUsingHardware);
+ }
+
+ auto vp9EncoderAvailable = hasElementForMediaType(m_videoEncoderFactories, "video/x-vp9", true);
+ if (vp9EncoderAvailable) {
+ m_encoderCodecMap.add(AtomString("vp9"), vp9EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("x-vp9"), vp9EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("vp9.0"), vp9EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("vp09*"), vp9EncoderAvailable.isUsingHardware);
+ }
+
+ if (hasElementForMediaType(m_muxerFactories, "video/webm") && (vp8EncoderAvailable || vp9EncoderAvailable || av1EncoderAvailable))
+ m_encoderMimeTypeSet.add(AtomString("video/webm"));
+
+ if (hasElementForMediaType(m_muxerFactories, "audio/webm")) {
+ if (opusSupported)
+ m_encoderMimeTypeSet.add(AtomString("audio/opus"));
+ m_encoderMimeTypeSet.add(AtomString("audio/webm"));
+ }
+
+ if (hasElementForMediaType(m_muxerFactories, "audio/ogg") && (vorbisSupported || opusSupported))
+ m_encoderMimeTypeSet.add(AtomString("audio/ogg"));
+
+ auto h264EncoderAvailable = hasElementForMediaType(m_videoEncoderFactories, "video/x-h264, profile="" constrained-baseline, baseline, high }", true);
+ if (h264EncoderAvailable) {
+ m_encoderCodecMap.add(AtomString("x-h264"), h264EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("avc*"), h264EncoderAvailable.isUsingHardware);
+ m_encoderCodecMap.add(AtomString("mp4v*"), h264EncoderAvailable.isUsingHardware);
+ }
+
+ if (hasElementForMediaType(m_muxerFactories, "video/quicktime")) {
+ if (opusSupported)
+ m_encoderMimeTypeSet.add(AtomString("audio/opus"));
+ if (aacSupported) {
+ m_encoderMimeTypeSet.add(AtomString("audio/aac"));
+ m_encoderMimeTypeSet.add(AtomString("audio/mp4"));
+ m_encoderMimeTypeSet.add(AtomString("audio/x-m4a"));
+ }
+ if (h264EncoderAvailable) {
+ m_encoderMimeTypeSet.add(AtomString("video/mp4"));
+ m_encoderMimeTypeSet.add(AtomString("video/x-m4v"));
+ }
+ }
+}
+
+bool GStreamerRegistryScanner::isCodecSupported(Configuration configuration, String codec, bool shouldCheckForHardwareUse) const
+{
// If the codec is named like a mimetype (eg: video/avc) remove the "video/" part.
size_t slashIndex = codec.find('/');
if (slashIndex != WTF::notFound)
@@ -304,9 +453,10 @@
bool supported = false;
if (codec.startsWith("avc1"))
- supported = isAVC1CodecSupported(codec, shouldCheckForHardwareUse);
+ supported = isAVC1CodecSupported(configuration, codec, shouldCheckForHardwareUse);
else {
- for (const auto& item : m_codecMap) {
+ auto& codecMap = configuration == Configuration::Decoding ? m_decoderCodecMap : m_encoderCodecMap;
+ for (const auto& item : codecMap) {
if (!fnmatch(item.key.string().utf8().data(), codec.utf8().data(), 0)) {
supported = shouldCheckForHardwareUse ? item.value : true;
if (supported)
@@ -315,16 +465,17 @@
}
}
- GST_LOG("Checked %s codec \"%s\" supported %s", shouldCheckForHardwareUse ? "hardware" : "software", codec.utf8().data(), boolForPrinting(supported));
+ const char* configLogString = configurationNameForLogging(configuration);
+ GST_LOG("Checked %s %s codec \"%s\" supported %s", shouldCheckForHardwareUse ? "hardware" : "software", configLogString, codec.utf8().data(), boolForPrinting(supported));
return supported;
}
-MediaPlayerEnums::SupportsType GStreamerRegistryScanner::isContentTypeSupported(const ContentType& contentType, const Vector<ContentType>& contentTypesRequiringHardwareSupport) const
+MediaPlayerEnums::SupportsType GStreamerRegistryScanner::isContentTypeSupported(Configuration configuration, const ContentType& contentType, const Vector<ContentType>& contentTypesRequiringHardwareSupport) const
{
using SupportsType = MediaPlayerEnums::SupportsType;
- const auto& containerType = contentType.containerType();
- if (!isContainerTypeSupported(containerType))
+ const auto& containerType = contentType.containerType().convertToASCIILowercase();
+ if (!isContainerTypeSupported(configuration, containerType))
return SupportsType::IsNotSupported;
const auto& codecs = contentType.codecs();
@@ -333,7 +484,8 @@
if (codecs.isEmpty())
return SupportsType::MayBeSupported;
- for (const auto& codec : codecs) {
+ for (const auto& item : codecs) {
+ auto codec = item.convertToASCIILowercase();
bool requiresHardwareSupport = contentTypesRequiringHardwareSupport
.findMatching([containerType, codec](auto& hardwareContentType) -> bool {
auto hardwareContainer = hardwareContentType.containerType();
@@ -346,16 +498,16 @@
return !fnmatch(hardwareCodec.utf8().data(), codec.utf8().data(), 0);
}) != notFound;
}) != notFound;
- if (!isCodecSupported(codec, requiresHardwareSupport))
+ if (!isCodecSupported(configuration, codec, requiresHardwareSupport))
return SupportsType::IsNotSupported;
}
return SupportsType::IsSupported;
}
-bool GStreamerRegistryScanner::areAllCodecsSupported(const Vector<String>& codecs, bool shouldCheckForHardwareUse) const
+bool GStreamerRegistryScanner::areAllCodecsSupported(Configuration configuration, const Vector<String>& codecs, bool shouldCheckForHardwareUse) const
{
for (String codec : codecs) {
- if (!isCodecSupported(codec, shouldCheckForHardwareUse))
+ if (!isCodecSupported(configuration, codec, shouldCheckForHardwareUse))
return false;
}
@@ -362,11 +514,19 @@
return true;
}
-bool GStreamerRegistryScanner::isAVC1CodecSupported(const String& codec, bool shouldCheckForHardwareUse) const
+bool GStreamerRegistryScanner::isAVC1CodecSupported(Configuration configuration, const String& codec, bool shouldCheckForHardwareUse) const
{
auto checkH264Caps = [&](const char* capsString) {
bool supported = false;
- auto lookupResult = hasElementForMediaType(m_videoDecoderFactories, capsString, true);
+ RegistryLookupResult lookupResult;
+ switch (configuration) {
+ case Configuration::Decoding:
+ lookupResult = hasElementForMediaType(m_videoDecoderFactories, capsString, true);
+ break;
+ case Configuration::Encoding:
+ lookupResult = hasElementForMediaType(m_videoEncoderFactories, capsString, true);
+ break;
+ }
supported = lookupResult;
if (shouldCheckForHardwareUse)
supported = lookupResult.isUsingHardware;
@@ -437,32 +597,48 @@
return checkH264Caps("video/x-h264");
}
-GStreamerRegistryScanner::RegistryLookupResult GStreamerRegistryScanner::isDecodingSupported(MediaConfiguration& configuration) const
+const char* GStreamerRegistryScanner::configurationNameForLogging(Configuration configuration) const
{
+ const char* configLogString = "";
+
+ switch (configuration) {
+ case Configuration::Encoding:
+ configLogString = "encoding";
+ break;
+ case Configuration::Decoding:
+ configLogString = "decoding";
+ break;
+ }
+ return configLogString;
+}
+
+GStreamerRegistryScanner::RegistryLookupResult GStreamerRegistryScanner::isConfigurationSupported(Configuration configuration, MediaConfiguration& mediaConfiguration) const
+{
bool isSupported = false;
bool isUsingHardware = false;
+ const char* configLogString = configurationNameForLogging(configuration);
- if (configuration.video) {
- auto& videoConfiguration = configuration.video.value();
- GST_DEBUG("Checking support for video configuration: \"%s\" size: %ux%u bitrate: %" G_GUINT64_FORMAT " framerate: %f",
+ if (mediaConfiguration.video) {
+ auto& videoConfiguration = mediaConfiguration.video.value();
+ GST_DEBUG("Checking %s support for video configuration: \"%s\" size: %ux%u bitrate: %" G_GUINT64_FORMAT " framerate: %f", configLogString,
videoConfiguration.contentType.utf8().data(),
videoConfiguration.width, videoConfiguration.height,
videoConfiguration.bitrate, videoConfiguration.framerate);
auto contentType = ContentType(videoConfiguration.contentType);
- isSupported = isContainerTypeSupported(contentType.containerType());
+ isSupported = isContainerTypeSupported(configuration, contentType.containerType());
auto codecs = contentType.codecs();
if (!codecs.isEmpty())
- isUsingHardware = areAllCodecsSupported(codecs, true);
+ isUsingHardware = areAllCodecsSupported(configuration, codecs, true);
}
- if (configuration.audio) {
- auto& audioConfiguration = configuration.audio.value();
- GST_DEBUG("Checking support for audio configuration: \"%s\" %s channels, bitrate: %" G_GUINT64_FORMAT " samplerate: %u",
+ if (mediaConfiguration.audio) {
+ auto& audioConfiguration = mediaConfiguration.audio.value();
+ GST_DEBUG("Checking %s support for audio configuration: \"%s\" %s channels, bitrate: %" G_GUINT64_FORMAT " samplerate: %u", configLogString,
audioConfiguration.contentType.utf8().data(), audioConfiguration.channels.utf8().data(),
audioConfiguration.bitrate, audioConfiguration.samplerate);
auto contentType = ContentType(audioConfiguration.contentType);
- isSupported = isContainerTypeSupported(contentType.containerType());
+ isSupported = isContainerTypeSupported(configuration, contentType.containerType());
}
return GStreamerRegistryScanner::RegistryLookupResult { isSupported, isUsingHardware };
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.h (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.h 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/GStreamerRegistryScanner.h 2020-10-16 08:52:38 UTC (rev 268576)
@@ -39,9 +39,13 @@
public:
static GStreamerRegistryScanner& singleton();
- HashSet<String, ASCIICaseInsensitiveHash>& mimeTypeSet() { return m_mimeTypeSet; }
+ enum Configuration {
+ Decoding = 0,
+ Encoding
+ };
- bool isContainerTypeSupported(String containerType) const { return m_mimeTypeSet.contains(containerType); }
+ const HashSet<String, ASCIICaseInsensitiveHash>& mimeTypeSet(Configuration);
+ bool isContainerTypeSupported(Configuration, String containerType) const;
struct RegistryLookupResult {
bool isSupported;
@@ -49,22 +53,29 @@
operator bool() const { return isSupported; }
};
- RegistryLookupResult isDecodingSupported(MediaConfiguration&) const;
+ RegistryLookupResult isDecodingSupported(MediaConfiguration& mediaConfiguration) const { return isConfigurationSupported(Configuration::Decoding, mediaConfiguration); };
+ RegistryLookupResult isEncodingSupported(MediaConfiguration& mediaConfiguration) const { return isConfigurationSupported(Configuration::Encoding, mediaConfiguration); }
- bool isCodecSupported(String codec, bool usingHardware = false) const;
- MediaPlayerEnums::SupportsType isContentTypeSupported(const ContentType&, const Vector<ContentType>& contentTypesRequiringHardwareSupport) const;
- bool areAllCodecsSupported(const Vector<String>& codecs, bool shouldCheckForHardwareUse = false) const;
+ bool isCodecSupported(Configuration, String codec, bool usingHardware = false) const;
+ MediaPlayerEnums::SupportsType isContentTypeSupported(Configuration, const ContentType&, const Vector<ContentType>& contentTypesRequiringHardwareSupport) const;
+ bool areAllCodecsSupported(Configuration, const Vector<String>& codecs, bool shouldCheckForHardwareUse = false) const;
protected:
GStreamerRegistryScanner(bool isMediaSource = false);
~GStreamerRegistryScanner();
- void initialize();
+ void initializeDecoders();
+ void initializeEncoders();
+ RegistryLookupResult isConfigurationSupported(Configuration, MediaConfiguration&) const;
+
enum ElementType {
AudioDecoder = 0,
VideoDecoder,
- Demuxer
+ Demuxer,
+ AudioEncoder,
+ VideoEncoder,
+ Muxer
};
struct GstCapsWebKitMapping {
ElementType elementType;
@@ -76,9 +87,11 @@
RegistryLookupResult hasElementForMediaType(GList* elementFactories, const char* capsString, bool shouldCheckHardwareClassifier = false, Optional<Vector<String>> blackList = WTF::nullopt) const;
- bool isAVC1CodecSupported(const String& codec, bool shouldCheckForHardwareUse) const;
+ bool isAVC1CodecSupported(Configuration, const String& codec, bool shouldCheckForHardwareUse) const;
private:
+ const char* configurationNameForLogging(Configuration) const;
+
bool m_isMediaSource;
GList* m_audioDecoderFactories;
GList* m_audioParserFactories;
@@ -85,8 +98,13 @@
GList* m_videoDecoderFactories;
GList* m_videoParserFactories;
GList* m_demuxerFactories;
- HashSet<String, ASCIICaseInsensitiveHash> m_mimeTypeSet;
- HashMap<AtomString, bool> m_codecMap;
+ GList* m_audioEncoderFactories;
+ GList* m_videoEncoderFactories;
+ GList* m_muxerFactories;
+ HashSet<String, ASCIICaseInsensitiveHash> m_decoderMimeTypeSet;
+ HashMap<AtomString, bool> m_decoderCodecMap;
+ HashSet<String, ASCIICaseInsensitiveHash> m_encoderMimeTypeSet;
+ HashMap<AtomString, bool> m_encoderCodecMap;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -98,7 +98,7 @@
bool ImageDecoderGStreamer::supportsContainerType(const String& type)
{
- return GStreamerRegistryScanner::singleton().isContainerTypeSupported(type);
+ return GStreamerRegistryScanner::singleton().isContainerTypeSupported(GStreamerRegistryScanner::Configuration::Decoding, type);
}
bool ImageDecoderGStreamer::canDecodeType(const String& mimeType)
@@ -106,7 +106,7 @@
if (mimeType.isEmpty())
return false;
- return GStreamerRegistryScanner::singleton().isContainerTypeSupported(mimeType);
+ return GStreamerRegistryScanner::singleton().isContainerTypeSupported(GStreamerRegistryScanner::Configuration::Decoding, mimeType);
}
EncodedDataStatus ImageDecoderGStreamer::encodedDataStatus() const
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -32,7 +32,9 @@
#include "GStreamerRegistryScanner.h"
#include "MediaCapabilitiesDecodingInfo.h"
+#include "MediaCapabilitiesEncodingInfo.h"
#include "MediaDecodingConfiguration.h"
+#include "MediaEncodingConfiguration.h"
#include "MediaPlayer.h"
#include <wtf/Function.h>
@@ -63,5 +65,16 @@
callback(WTFMove(info));
}
+void createMediaPlayerEncodingConfigurationGStreamer(MediaEncodingConfiguration&& configuration, WTF::Function<void(MediaCapabilitiesEncodingInfo&&)>&& callback)
+{
+ auto& scanner = GStreamerRegistryScanner::singleton();
+ auto lookupResult = scanner.isEncodingSupported(configuration);
+ MediaCapabilitiesEncodingInfo info;
+ info.supported = lookupResult.isSupported;
+ info.powerEfficient = lookupResult.isUsingHardware;
+ info.supportedConfiguration = WTFMove(configuration);
+
+ callback(WTFMove(info));
}
+}
#endif
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.h (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.h 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/MediaEngineConfigurationFactoryGStreamer.h 2020-10-16 08:52:38 UTC (rev 268576)
@@ -34,10 +34,12 @@
namespace WebCore {
struct MediaCapabilitiesDecodingInfo;
+struct MediaCapabilitiesEncodingInfo;
struct MediaDecodingConfiguration;
+struct MediaEncodingConfiguration;
extern void createMediaPlayerDecodingConfigurationGStreamer(MediaDecodingConfiguration&&, WTF::Function<void(MediaCapabilitiesDecodingInfo&&)>&&);
-
+extern void createMediaPlayerEncodingConfigurationGStreamer(MediaEncodingConfiguration&&, WTF::Function<void(MediaCapabilitiesEncodingInfo&&)>&&);
}
#endif
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -2663,7 +2663,7 @@
void MediaPlayerPrivateGStreamer::getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types)
{
auto& gstRegistryScanner = GStreamerRegistryScanner::singleton();
- types = gstRegistryScanner.mimeTypeSet();
+ types = gstRegistryScanner.mimeTypeSet(GStreamerRegistryScanner::Configuration::Decoding);
}
MediaPlayer::SupportsType MediaPlayerPrivateGStreamer::supportsType(const MediaEngineSupportParameters& parameters)
@@ -2685,7 +2685,7 @@
GST_DEBUG("Checking mime-type \"%s\"", parameters.type.raw().utf8().data());
auto& gstRegistryScanner = GStreamerRegistryScanner::singleton();
- result = gstRegistryScanner.isContentTypeSupported(parameters.type, parameters.contentTypesRequiringHardwareSupport);
+ result = gstRegistryScanner.isContentTypeSupported(GStreamerRegistryScanner::Configuration::Decoding, parameters.type, parameters.contentTypesRequiringHardwareSupport);
auto finalResult = extendedSupportsType(parameters, result);
GST_DEBUG("Supported: %s", convertEnumerationToString(finalResult).utf8().data());
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/mse/AppendPipeline.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -397,7 +397,7 @@
const char* originalMediaType = capsMediaType(m_demuxerSrcPadCaps.get());
auto& gstRegistryScanner = GStreamerRegistryScannerMSE::singleton();
- if (!gstRegistryScanner.isCodecSupported(originalMediaType)) {
+ if (!gstRegistryScanner.isCodecSupported(GStreamerRegistryScanner::Configuration::Decoding, originalMediaType)) {
m_presentationSize = WebCore::FloatSize();
m_streamType = WebCore::MediaSourceStreamTypeGStreamer::Invalid;
} else if (doCapsHaveType(m_demuxerSrcPadCaps.get(), GST_VIDEO_CAPS_TYPE_PREFIX)) {
Modified: trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/graphics/gstreamer/mse/MediaPlayerPrivateGStreamerMSE.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -711,7 +711,7 @@
void MediaPlayerPrivateGStreamerMSE::getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types)
{
auto& gstRegistryScanner = GStreamerRegistryScannerMSE::singleton();
- types = gstRegistryScanner.mimeTypeSet();
+ types = gstRegistryScanner.mimeTypeSet(GStreamerRegistryScanner::Configuration::Decoding);
}
MediaPlayer::SupportsType MediaPlayerPrivateGStreamerMSE::supportsType(const MediaEngineSupportParameters& parameters)
@@ -731,7 +731,7 @@
GST_DEBUG("Checking mime-type \"%s\"", parameters.type.raw().utf8().data());
auto& gstRegistryScanner = GStreamerRegistryScannerMSE::singleton();
- result = gstRegistryScanner.isContentTypeSupported(parameters.type, parameters.contentTypesRequiringHardwareSupport);
+ result = gstRegistryScanner.isContentTypeSupported(GStreamerRegistryScanner::Configuration::Decoding, parameters.type, parameters.contentTypesRequiringHardwareSupport);
auto finalResult = extendedSupportsType(parameters, result);
GST_DEBUG("Supported: %s", convertEnumerationToString(finalResult).utf8().data());
Modified: trunk/Source/WebCore/platform/mediacapabilities/MediaEngineConfigurationFactory.cpp (268575 => 268576)
--- trunk/Source/WebCore/platform/mediacapabilities/MediaEngineConfigurationFactory.cpp 2020-10-16 07:52:45 UTC (rev 268575)
+++ trunk/Source/WebCore/platform/mediacapabilities/MediaEngineConfigurationFactory.cpp 2020-10-16 08:52:38 UTC (rev 268576)
@@ -66,7 +66,7 @@
{ &createMediaPlayerDecodingConfigurationCocoa, nullptr },
#endif
#if USE(GSTREAMER)
- { &createMediaPlayerDecodingConfigurationGStreamer, nullptr },
+ { &createMediaPlayerDecodingConfigurationGStreamer, &createMediaPlayerEncodingConfigurationGStreamer },
#endif
}));
return factories;
