Bug 1891082 - Enable decoder reconfiguration in DecoderAgent for AAC/ADTS data through MediaChangeMonitor r=media-playback-reviewers,padenot

This patch enhances `DecoderAgent` by enabling it to reconfigure the
underlying decoder when processing *AAC/ADTS* data via
`MediaChangeMonitor`.

In cases where the `description` field is absent in the
`AudioDecoderConfig` for `mp4a.*` (*AAC*) codec, the data stream is
assumed to be in *ADTS* format. However, some websites provide raw AAC
data under these circumstances, leading to decoding failure since the
underlying decoder requires AAC-specific configuration.

This patch resolves the issue by allowing the underling decoder to be
reconfigured - recreated and reinitialized - through
`MediaChangeMonitor` whenever an AAV format change is detected. This
process mirros the handling of video format changes, such as when H264
data format changes between AnnexB and AVCC. With this change,
`DecoderAgent` simply cues the `PDMFactory` to create a
`MediaChangeMonitor` that wraps the underlying decoder, similar to the
approach used for video decoders, ensuring correct handling of both AAC
and ADTS formats without altering other components.

Depends on D220505

Differential Revision: https://phabricator.services.mozilla.com/D220506

Author: ChunMinChang

dom/media/platforms/PDMFactory.cpp

@@ -409,6 +409,11 @@ PDMFactory::CreateDecoderWithPDM(PlatformDecoderModule* aPDM,
   }
 
   if (config.IsAudio()) {
+    if (MP4Decoder::IsAAC(config.mMimeType) && !aParams.mUseNullDecoder.mUse &&
+        aParams.mWrappers.contains(media::Wrapper::MediaChangeMonitor)) {
+      // If AudioTrimmer is needed, MediaChangeMonitor will request it.
+      return MediaChangeMonitor::Create(this, aParams);
+    }
     RefPtr<PlatformDecoderModule::CreateDecoderPromise> p;
     p = aPDM->AsyncCreateDecoder(aParams)->Then(
         GetCurrentSerialEventTarget(), __func__,

dom/media/platforms/PlatformDecoderModule.h

@@ -87,6 +87,8 @@ MOZ_DEFINE_ENUM_CLASS_WITH_BASE_AND_TOSTRING(Wrapper, uint8_t,
                                               MediaChangeMonitor));
 using WrapperSet = EnumSet<Wrapper>;
 static WrapperSet GetDefaultWrapperSet(const TrackInfo& aInfo) {
+  // MediaChangeMonitor can work with some audio codecs like AAC but only
+  // WebCodecs needs it, so it's only enabled for video by default.
   WrapperSet set;
   if (aInfo.IsVideo()) {
     set += Wrapper::MediaChangeMonitor;
@@ -188,6 +190,10 @@ struct MOZ_STACK_CLASS CreateDecoderParams final {
     return *mConfig.GetAsAudioInfo();
   }
 
+  bool IsVideo() const { return mConfig.IsVideo(); }
+
+  bool IsAudio() const { return mConfig.IsAudio(); }
+
   layers::LayersBackend GetLayersBackend() const {
     if (mKnowsCompositor) {
       return mKnowsCompositor->GetCompositorBackendType();

dom/media/platforms/wrappers/MediaChangeMonitor.cpp

@@ -662,7 +662,7 @@ MediaChangeMonitor::MediaChangeMonitor(
     MediaDataDecoder* aDecoder, const CreateDecoderParams& aParams)
     : mChangeMonitor(std::move(aCodecChangeMonitor)),
       mPDMFactory(aPDMFactory),
-      mCurrentConfig(aParams.VideoConfig()),
+      mCurrentConfig(aParams.mConfig.Clone()),
       mDecoder(aDecoder),
       mParams(aParams) {}
 
@@ -671,20 +671,25 @@ RefPtr<PlatformDecoderModule::CreateDecoderPromise> MediaChangeMonitor::Create(
     PDMFactory* aPDMFactory, const CreateDecoderParams& aParams) {
   LOG("MediaChangeMonitor::Create, params = %s", aParams.ToString().get());
   UniquePtr<CodecChangeMonitor> changeMonitor;
-  const VideoInfo& currentConfig = aParams.VideoConfig();
-  if (VPXDecoder::IsVPX(currentConfig.mMimeType)) {
-    changeMonitor = MakeUnique<VPXChangeMonitor>(currentConfig);
+  if (aParams.IsVideo()) {
+    const VideoInfo& config = aParams.VideoConfig();
+    if (VPXDecoder::IsVPX(config.mMimeType)) {
+      changeMonitor = MakeUnique<VPXChangeMonitor>(config);
 #ifdef MOZ_AV1
-  } else if (AOMDecoder::IsAV1(currentConfig.mMimeType)) {
-    changeMonitor = MakeUnique<AV1ChangeMonitor>(currentConfig);
+    } else if (AOMDecoder::IsAV1(config.mMimeType)) {
+      changeMonitor = MakeUnique<AV1ChangeMonitor>(config);
 #endif
-  } else if (MP4Decoder::IsHEVC(currentConfig.mMimeType)) {
-    changeMonitor = MakeUnique<HEVCChangeMonitor>(currentConfig);
+    } else if (MP4Decoder::IsHEVC(config.mMimeType)) {
+      changeMonitor = MakeUnique<HEVCChangeMonitor>(config);
+    } else {
+      MOZ_ASSERT(MP4Decoder::IsH264(config.mMimeType));
+      changeMonitor = MakeUnique<H264ChangeMonitor>(
+          config, aParams.mOptions.contains(
+                      CreateDecoderParams::Option::FullH264Parsing));
+    }
   } else {
-    MOZ_ASSERT(MP4Decoder::IsH264(currentConfig.mMimeType));
-    changeMonitor = MakeUnique<H264ChangeMonitor>(
-        currentConfig, aParams.mOptions.contains(
-                           CreateDecoderParams::Option::FullH264Parsing));
+    MOZ_ASSERT(MP4Decoder::IsAAC(aParams.AudioConfig().mMimeType));
+    changeMonitor = MakeUnique<AACCodecChangeMonitor>(aParams.AudioConfig());
   }
 
   // The change monitor may have an updated track config. E.g. the h264 monitor
@@ -920,8 +925,8 @@ void MediaChangeMonitor::SetSeekThreshold(const media::TimeUnit& aTime) {
 
 RefPtr<MediaChangeMonitor::CreateDecoderPromise>
 MediaChangeMonitor::CreateDecoder() {
-  mCurrentConfig = *mChangeMonitor->Config().GetAsVideoInfo();
-  CreateDecoderParams currentParams = {mCurrentConfig, mParams};
+  mCurrentConfig = mChangeMonitor->Config().Clone();
+  CreateDecoderParams currentParams = {*mCurrentConfig, mParams};
   currentParams.mWrappers -= media::Wrapper::MediaChangeMonitor;
   LOG("MediaChangeMonitor::CreateDecoder, current params = %s",
       currentParams.ToString().get());

dom/media/platforms/wrappers/MediaChangeMonitor.h

@@ -127,7 +127,7 @@ class MediaChangeMonitor final
 
   UniquePtr<CodecChangeMonitor> mChangeMonitor;
   RefPtr<PDMFactory> mPDMFactory;
-  VideoInfo mCurrentConfig;
+  UniquePtr<TrackInfo> mCurrentConfig;
   nsCOMPtr<nsISerialEventTarget> mThread;
   RefPtr<MediaDataDecoder> mDecoder;
   MozPromiseRequestHolder<CreateDecoderPromise> mDecoderRequest;

dom/media/webcodecs/DecoderAgent.cpp

@@ -7,6 +7,7 @@
 #include "DecoderAgent.h"
 
 #include "ImageContainer.h"
+#include "MP4Decoder.h"
 #include "MediaDataDecoderProxy.h"
 #include "PDMFactory.h"
 #include "VideoUtils.h"
@@ -105,6 +106,10 @@ RefPtr<DecoderAgent::ConfigurePromise> DecoderAgent::Configure(
   if (aLowLatency) {
     params.mOptions += CreateDecoderParams::Option::LowLatency;
   }
+  // MediaChangeMonitor is requested to decode raw AAC in ADTS.
+  if (MP4Decoder::IsAAC(mInfo->mMimeType)) {
+    params.mWrappers += media::Wrapper::MediaChangeMonitor;
+  }
   // This should only be used for testing.
   if (StaticPrefs::media_test_null_decoder_creation_failure()) {
     params.mUseNullDecoder = CreateDecoderParams::UseNullDecoder(true);
@@ -114,10 +119,10 @@ RefPtr<DecoderAgent::ConfigurePromise> DecoderAgent::Configure(
   // decoded video frames.
   params.mOptions += CreateDecoderParams::Option::KeepOriginalPts;
 
-  LOG("DecoderAgent #%d (%p) is creating a decoder - PreferSW: %s, "
-      "low-latency: %s",
-      mId, this, aPreferSoftwareDecoder ? "yes" : "no",
-      aLowLatency ? "yes" : "no");
+  LOG("DecoderAgent #%d (%p) is creating a decoder (mime: %s) - PreferSW: %s, "
+      "low-latency: %s, create-decoder-params: %s",
+      mId, this, mInfo->mMimeType.get(), aPreferSoftwareDecoder ? "yes" : "no",
+      aLowLatency ? "yes" : "no", params.ToString().get());
 
   RefPtr<ConfigurePromise> p = mConfigurePromise.Ensure(__func__);