Implement AudioDecoder.isConfigSupported()

API and motivations described here:
https://github.com/WICG/web-codecs/issues/98

Spec PR here:
https://github.com/WICG/web-codecs/pull/120

Bug: 1141707
Test: new layout tests
Change-Id: I3a0f3cbc2bb64a86dcefdc454d6b03e72d3f36bd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2622421Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Commit-Queue: Chrome Cunningham <chcunningham@chromium.org>
Cr-Commit-Position: refs/heads/master@{#842153}

third_party/blink/renderer/modules/webcodecs/audio_decoder.cc

@@ -14,6 +14,7 @@
 #include "media/base/supported_types.h"
 #include "media/base/waiting.h"
 #include "third_party/blink/public/mojom/web_feature/web_feature.mojom-blink.h"
+#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_audio_decoder_config.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_audio_decoder_init.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_encoded_audio_chunk.h"
@@ -27,6 +28,28 @@
 
 namespace blink {
 
+bool IsValidConfig(const AudioDecoderConfig& config,
+                   media::AudioType& out_audio_type,
+                   String& out_console_message) {
+  media::AudioCodec codec = media::kUnknownAudioCodec;
+  bool is_codec_ambiguous = true;
+  bool parse_succeeded = ParseAudioCodecString("", config.codec().Utf8(),
+                                               &is_codec_ambiguous, &codec);
+
+  if (!parse_succeeded) {
+    out_console_message = "Failed to parse codec string.";
+    return false;
+  }
+
+  if (is_codec_ambiguous) {
+    out_console_message = "Codec string is ambiguous.";
+    return false;
+  }
+
+  out_audio_type = {codec};
+  return true;
+}
+
 // static
 std::unique_ptr<AudioDecoderTraits::MediaDecoderType>
 AudioDecoderTraits::CreateDecoder(
@@ -81,30 +104,31 @@ AudioDecoder* AudioDecoder::Create(ScriptState* script_state,
                                             exception_state);
 }
 
+// static
+ScriptPromise AudioDecoder::isConfigSupported(ScriptState* script_state,
+                                              const AudioDecoderConfig* config,
+                                              ExceptionState& exception_state) {
+  media::AudioType audio_type;
+  String console_message;
+
+  if (!IsValidConfig(*config, audio_type, console_message)) {
+    exception_state.ThrowTypeError(console_message);
+    return ScriptPromise();
+  }
+
+  bool is_supported = media::IsSupportedAudioType(audio_type);
+  return ScriptPromise::Cast(script_state, ToV8(is_supported, script_state));
+}
+
 // static
 CodecConfigEval AudioDecoder::MakeMediaAudioDecoderConfig(
     const ConfigType& config,
     MediaConfigType& out_media_config,
     String& out_console_message) {
-  media::AudioCodec codec = media::kUnknownAudioCodec;
-  bool is_codec_ambiguous = true;
-  bool parse_succeeded = ParseAudioCodecString("", config.codec().Utf8(),
-                                               &is_codec_ambiguous, &codec);
+  media::AudioType audio_type;
 
-  if (!parse_succeeded) {
-    out_console_message = "Failed to parse codec string.";
+  if (!IsValidConfig(config, audio_type, out_console_message))
     return CodecConfigEval::kInvalid;
-  }
-
-  if (is_codec_ambiguous) {
-    out_console_message = "Codec string is ambiguous.";
-    return CodecConfigEval::kInvalid;
-  }
-
-  if (!media::IsSupportedAudioType({codec})) {
-    out_console_message = "Configuration is not supported.";
-    return CodecConfigEval::kUnsupported;
-  }
 
   std::vector<uint8_t> extra_data;
   if (config.hasDescription()) {
@@ -131,8 +155,8 @@ CodecConfigEval AudioDecoder::MakeMediaAudioDecoderConfig(
 
   // TODO(chcunningham): Add sample format to IDL.
   out_media_config.Initialize(
-      codec, media::kSampleFormatPlanarF32, channel_layout, config.sampleRate(),
-      extra_data, media::EncryptionScheme::kUnencrypted,
+      audio_type.codec, media::kSampleFormatPlanarF32, channel_layout,
+      config.sampleRate(), extra_data, media::EncryptionScheme::kUnencrypted,
       base::TimeDelta() /* seek preroll */, 0 /* codec delay */);
 
   return CodecConfigEval::kSupported;

third_party/blink/renderer/modules/webcodecs/audio_decoder.h

@@ -12,7 +12,6 @@
 #include "media/base/status.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_video_frame_output_callback.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_webcodecs_error_callback.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/modules/webcodecs/codec_config_eval.h"
@@ -38,6 +37,7 @@ class AudioFrame;
 class EncodedAudioChunk;
 class ExceptionState;
 class AudioDecoderInit;
+class ScriptPromise;
 class V8AudioFrameOutputCallback;
 
 class MODULES_EXPORT AudioDecoderTraits {
@@ -77,6 +77,10 @@ class MODULES_EXPORT AudioDecoder : public DecoderTemplate<AudioDecoderTraits> {
                               const AudioDecoderInit*,
                               ExceptionState&);
 
+  static ScriptPromise isConfigSupported(ScriptState*,
+                                         const AudioDecoderConfig*,
+                                         ExceptionState&);
+
   // For use by MediaSource and by ::MakeMediaConfig.
   static CodecConfigEval MakeMediaAudioDecoderConfig(
       const ConfigType& config,

third_party/blink/renderer/modules/webcodecs/audio_decoder.idl

@@ -23,6 +23,9 @@
   // |decodeQueueSize| is greater than a constant.
   readonly attribute long decodeQueueSize;
 
+  // Which state the decoder is in, indicating which methods can be called.
+  readonly attribute CodecState state;
+
   // Set the stream configuration for future decode() requests.
   //
   // The next decode request must be for a keyframe.
@@ -57,6 +60,7 @@
   // Not recoverable: make a new AudioDecoder if needed.
   [RaisesException] void close();
 
-  // Which state the decoder is in, indicating which methods can be called.
-  readonly attribute CodecState state;
+  // Call prior to configure() to determine whether config will be supported.
+  [CallWith=ScriptState, RaisesException]
+  static Promise<boolean> isConfigSupported(AudioDecoderConfig config);
 };

third_party/blink/renderer/modules/webcodecs/decoder_template.cc

@@ -269,9 +269,9 @@ bool DecoderTemplate<Traits>::ProcessConfigureRequest(Request* request) {
     decoder_ = Traits::CreateDecoder(*ExecutionContext::From(script_state_),
                                      gpu_factories_, logger_->log());
     if (!decoder_) {
-      Shutdown(logger_->MakeException(
-          "Configuration error: Could not create decoder.",
-          media::StatusCode::kDecoderCreationFailed));
+      Shutdown(
+          logger_->MakeException("Internal error: Could not create decoder.",
+                                 media::StatusCode::kDecoderCreationFailed));
       return false;
     }
 
@@ -468,7 +468,9 @@ void DecoderTemplate<Traits>::OnConfigureFlushDone(media::Status status) {
   DCHECK_EQ(pending_request_->type, Request::Type::kConfigure);
 
   if (!status.is_ok()) {
-    Shutdown(logger_->MakeException("Configuration error.", status));
+    Shutdown(logger_->MakeException(
+        "Internal error: failed to flush out frames from previous config.",
+        status));
     return;
   }
 
@@ -490,7 +492,13 @@ void DecoderTemplate<Traits>::OnInitializeDone(media::Status status) {
   DCHECK_EQ(pending_request_->type, Request::Type::kConfigure);
 
   if (!status.is_ok()) {
-    Shutdown(logger_->MakeException("Decoder initialization error.", status));
+    std::string error_message = "Decoder initialization error.";
+    if (status.code() == media::StatusCode::kDecoderUnsupportedConfig) {
+      error_message =
+          "Unsupported configuration. Check isConfigSupported() prior to "
+          "calling configure().";
+    }
+    Shutdown(logger_->MakeException(error_message, status));
     return;
   }
 

third_party/blink/web_tests/external/wpt/webcodecs/audio-decoder.any.js

@@ -15,6 +15,55 @@ function getFakeChunk() {
   });
 }
 
+const invalidConfigs = [
+  {
+    comment: 'Emtpy codec',
+    config: {codec: ''},
+  },
+  {
+    comment: 'Unrecognized codec',
+    config: {codec: 'bogus'},
+  },
+  {
+    comment: 'Video codec',
+    config: {codec: 'vp8'},
+  },
+  {
+    comment: 'Ambiguous codec',
+    config: {codec: 'vp9'},
+  },
+  {
+    comment: 'Codec with MIME type',
+    config: {codec: 'audio/webm; codecs="opus"'},
+  },
+];
+
+invalidConfigs.forEach(entry => {
+  promise_test(t => {
+    return promise_rejects_js(t, TypeError, AudioDecoder.isConfigSupported(entry.config));
+  }, 'Test that AudioDecoder.isConfigSupported() rejects invalid config:' + entry.comment);
+});
+
+
+invalidConfigs.forEach(entry => {
+  async_test(t => {
+    let codec = new AudioDecoder(getDefaultCodecInit(t));
+    assert_throws_js(TypeError, () => { codec.configure(entry.config); });
+    t.done();
+  }, 'Test that AudioDecoder.configure() rejects invalid config:' + entry.comment);
+});
+
+promise_test(t => {
+  return AudioDecoder.isConfigSupported({
+    codec: 'opus',
+    sampleRate: 48000,
+    numberOfChannels: 2,
+    // Opus header extradata.
+    description: new Uint8Array([0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64,
+        0x01, 0x02, 0x38, 0x01, 0x80, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x00])
+  });
+}, 'Test AudioDecoder.isConfigSupported() with a valid config');
+
 promise_test(t => {
   // AudioDecoderInit lacks required fields.
   assert_throws_js(TypeError, () => { new AudioDecoder({}); });

third_party/blink/web_tests/webexposed/global-interface-listing-dedicated-worker-expected.txt

@@ -16,6 +16,7 @@ Starting worker: resources/global-interface-listing-worker.js
 [Worker]     method constructor
 [Worker]     setter onabort
 [Worker] interface AudioDecoder
+[Worker]     static method isConfigSupported
 [Worker]     attribute @@toStringTag
 [Worker]     getter decodeQueueSize
 [Worker]     getter state

third_party/blink/web_tests/webexposed/global-interface-listing-expected.txt

@@ -271,6 +271,7 @@ interface AudioContext : BaseAudioContext
     method resume
     method suspend
 interface AudioDecoder
+    static method isConfigSupported
     attribute @@toStringTag
     getter decodeQueueSize
     getter state