Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 345 insertions, 0 deletions

diff --git a/dom/media/DecoderTraits.cpp b/dom/media/DecoderTraits.cpp
new file mode 100644
index 0000000000..ad64dca729
--- /dev/null
+++ b/dom/media/DecoderTraits.cpp
@@ -0,0 +1,345 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DecoderTraits.h"
+#include "MediaContainerType.h"
+#include "mozilla/Preferences.h"
+
+#include "OggDecoder.h"
+#include "OggDemuxer.h"
+
+#include "WebMDecoder.h"
+#include "WebMDemuxer.h"
+
+#ifdef MOZ_ANDROID_HLS_SUPPORT
+#  include "HLSDecoder.h"
+#endif
+#ifdef MOZ_FMP4
+#  include "MP4Decoder.h"
+#  include "MP4Demuxer.h"
+#endif
+#include "MediaFormatReader.h"
+
+#include "MP3Decoder.h"
+#include "MP3Demuxer.h"
+
+#include "WaveDecoder.h"
+#include "WaveDemuxer.h"
+
+#include "ADTSDecoder.h"
+#include "ADTSDemuxer.h"
+
+#include "FlacDecoder.h"
+#include "FlacDemuxer.h"
+
+#include "nsPluginHost.h"
+
+namespace mozilla {
+
+/* static */
+bool DecoderTraits::IsHttpLiveStreamingType(const MediaContainerType& aType) {
+  const auto& mimeType = aType.Type();
+  return  // For m3u8.
+          // https://tools.ietf.org/html/draft-pantos-http-live-streaming-19#section-10
+      mimeType == MEDIAMIMETYPE("application/vnd.apple.mpegurl") ||
+      // Some sites serve these as the informal m3u type.
+      mimeType == MEDIAMIMETYPE("application/x-mpegurl") ||
+      mimeType == MEDIAMIMETYPE("audio/mpegurl") ||
+      mimeType == MEDIAMIMETYPE("audio/x-mpegurl");
+}
+
+/* static */
+bool DecoderTraits::IsMatroskaType(const MediaContainerType& aType) {
+  const auto& mimeType = aType.Type();
+  // https://matroska.org/technical/specs/notes.html
+  return mimeType == MEDIAMIMETYPE("audio/x-matroska") ||
+         mimeType == MEDIAMIMETYPE("video/x-matroska");
+}
+
+/* static */
+bool DecoderTraits::IsMP4SupportedType(const MediaContainerType& aType,
+                                       DecoderDoctorDiagnostics* aDiagnostics) {
+#ifdef MOZ_FMP4
+  return MP4Decoder::IsSupportedType(aType, aDiagnostics);
+#else
+  return false;
+#endif
+}
+
+static CanPlayStatus CanHandleCodecsType(
+    const MediaContainerType& aType, DecoderDoctorDiagnostics* aDiagnostics) {
+  // We should have been given a codecs string, though it may be empty.
+  MOZ_ASSERT(aType.ExtendedType().HaveCodecs());
+
+  // Container type with the MIME type, no codecs.
+  const MediaContainerType mimeType(aType.Type());
+
+  if (OggDecoder::IsSupportedType(mimeType)) {
+    if (OggDecoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // ogg is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+  if (WaveDecoder::IsSupportedType(MediaContainerType(mimeType))) {
+    if (WaveDecoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested, wave
+    // is supported and working: the codec must be invalid or not supported.
+    return CANPLAY_NO;
+  }
+  if (WebMDecoder::IsSupportedType(mimeType)) {
+    if (WebMDecoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // webm is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+#ifdef MOZ_FMP4
+  if (MP4Decoder::IsSupportedType(mimeType,
+                                  /* DecoderDoctorDiagnostics* */ nullptr)) {
+    if (MP4Decoder::IsSupportedType(aType, aDiagnostics)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // fmp4 is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+#endif
+  if (MP3Decoder::IsSupportedType(mimeType)) {
+    if (MP3Decoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // mp3 is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+  if (ADTSDecoder::IsSupportedType(mimeType)) {
+    if (ADTSDecoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // adts is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+  if (FlacDecoder::IsSupportedType(mimeType)) {
+    if (FlacDecoder::IsSupportedType(aType)) {
+      return CANPLAY_YES;
+    }
+    // We can only reach this position if a particular codec was requested,
+    // flac is supported and working: the codec must be invalid.
+    return CANPLAY_NO;
+  }
+
+  return CANPLAY_MAYBE;
+}
+
+static CanPlayStatus CanHandleMediaType(
+    const MediaContainerType& aType, DecoderDoctorDiagnostics* aDiagnostics) {
+  if (DecoderTraits::IsHttpLiveStreamingType(aType)) {
+    Telemetry::Accumulate(Telemetry::MEDIA_HLS_CANPLAY_REQUESTED, true);
+  }
+#ifdef MOZ_ANDROID_HLS_SUPPORT
+  if (HLSDecoder::IsSupportedType(aType)) {
+    Telemetry::Accumulate(Telemetry::MEDIA_HLS_CANPLAY_SUPPORTED, true);
+    return CANPLAY_MAYBE;
+  }
+#endif
+
+  if (DecoderTraits::IsMatroskaType(aType)) {
+    Telemetry::Accumulate(Telemetry::MEDIA_MKV_CANPLAY_REQUESTED, true);
+  }
+
+  if (aType.ExtendedType().HaveCodecs()) {
+    CanPlayStatus result = CanHandleCodecsType(aType, aDiagnostics);
+    if (result == CANPLAY_NO || result == CANPLAY_YES) {
+      return result;
+    }
+  }
+
+  // Container type with just the MIME type/subtype, no codecs.
+  const MediaContainerType mimeType(aType.Type());
+
+  if (OggDecoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+  if (WaveDecoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+#ifdef MOZ_FMP4
+  if (MP4Decoder::IsSupportedType(mimeType, aDiagnostics)) {
+    return CANPLAY_MAYBE;
+  }
+#endif
+  if (WebMDecoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+  if (MP3Decoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+  if (ADTSDecoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+  if (FlacDecoder::IsSupportedType(mimeType)) {
+    return CANPLAY_MAYBE;
+  }
+  return CANPLAY_NO;
+}
+
+/* static */
+CanPlayStatus DecoderTraits::CanHandleContainerType(
+    const MediaContainerType& aContainerType,
+    DecoderDoctorDiagnostics* aDiagnostics) {
+  return CanHandleMediaType(aContainerType, aDiagnostics);
+}
+
+/* static */
+bool DecoderTraits::ShouldHandleMediaType(
+    const char* aMIMEType, DecoderDoctorDiagnostics* aDiagnostics) {
+  Maybe<MediaContainerType> containerType = MakeMediaContainerType(aMIMEType);
+  if (!containerType) {
+    return false;
+  }
+
+  if (WaveDecoder::IsSupportedType(*containerType)) {
+    // We should not return true for Wave types, since there are some
+    // Wave codecs actually in use in the wild that we don't support, and
+    // we should allow those to be handled by plugins or helper apps.
+    // Furthermore people can play Wave files on most platforms by other
+    // means.
+    return false;
+  }
+
+  // If an external plugin which can handle quicktime video is available
+  // (and not disabled), prefer it over native playback as there several
+  // codecs found in the wild that we do not handle.
+  if (containerType->Type() == MEDIAMIMETYPE("video/quicktime")) {
+    RefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
+    if (pluginHost &&
+        pluginHost->HavePluginForType(containerType->Type().AsString())) {
+      return false;
+    }
+  }
+
+  return CanHandleMediaType(*containerType, aDiagnostics) != CANPLAY_NO;
+}
+
+/* static */
+already_AddRefed<MediaDataDemuxer> DecoderTraits::CreateDemuxer(
+    const MediaContainerType& aType, MediaResource* aResource) {
+  MOZ_ASSERT(NS_IsMainThread());
+  RefPtr<MediaDataDemuxer> demuxer;
+
+#ifdef MOZ_FMP4
+  if (MP4Decoder::IsSupportedType(aType,
+                                  /* DecoderDoctorDiagnostics* */ nullptr)) {
+    demuxer = new MP4Demuxer(aResource);
+  } else
+#endif
+      if (MP3Decoder::IsSupportedType(aType)) {
+    demuxer = new MP3Demuxer(aResource);
+  } else if (ADTSDecoder::IsSupportedType(aType)) {
+    demuxer = new ADTSDemuxer(aResource);
+  } else if (WaveDecoder::IsSupportedType(aType)) {
+    demuxer = new WAVDemuxer(aResource);
+  } else if (FlacDecoder::IsSupportedType(aType)) {
+    demuxer = new FlacDemuxer(aResource);
+  } else if (OggDecoder::IsSupportedType(aType)) {
+    demuxer = new OggDemuxer(aResource);
+  } else if (WebMDecoder::IsSupportedType(aType)) {
+    demuxer = new WebMDemuxer(aResource);
+  }
+
+  return demuxer.forget();
+}
+
+/* static */
+MediaFormatReader* DecoderTraits::CreateReader(const MediaContainerType& aType,
+                                               MediaFormatReaderInit& aInit) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<MediaDataDemuxer> demuxer = CreateDemuxer(aType, aInit.mResource);
+  if (!demuxer) {
+    return nullptr;
+  }
+
+  MediaFormatReader* decoderReader = new MediaFormatReader(aInit, demuxer);
+
+  if (OggDecoder::IsSupportedType(aType)) {
+    static_cast<OggDemuxer*>(demuxer.get())
+        ->SetChainingEvents(&decoderReader->TimedMetadataProducer(),
+                            &decoderReader->MediaNotSeekableProducer());
+  }
+
+  return decoderReader;
+}
+
+/* static */
+bool DecoderTraits::IsSupportedInVideoDocument(const nsACString& aType) {
+  // Forbid playing media in video documents if the user has opted
+  // not to, using either the legacy WMF specific pref, or the newer
+  // catch-all pref.
+  if (!Preferences::GetBool("media.wmf.play-stand-alone", true) ||
+      !Preferences::GetBool("media.play-stand-alone", true)) {
+    return false;
+  }
+
+  Maybe<MediaContainerType> type = MakeMediaContainerType(aType);
+  if (!type) {
+    return false;
+  }
+
+  return OggDecoder::IsSupportedType(*type) ||
+         WebMDecoder::IsSupportedType(*type) ||
+#ifdef MOZ_FMP4
+         MP4Decoder::IsSupportedType(*type,
+                                     /* DecoderDoctorDiagnostics* */ nullptr) ||
+#endif
+         MP3Decoder::IsSupportedType(*type) ||
+         ADTSDecoder::IsSupportedType(*type) ||
+         FlacDecoder::IsSupportedType(*type) ||
+#ifdef MOZ_ANDROID_HLS_SUPPORT
+         HLSDecoder::IsSupportedType(*type) ||
+#endif
+         false;
+}
+
+/* static */
+nsTArray<UniquePtr<TrackInfo>> DecoderTraits::GetTracksInfo(
+    const MediaContainerType& aType) {
+  // Container type with just the MIME type/subtype, no codecs.
+  const MediaContainerType mimeType(aType.Type());
+
+  if (OggDecoder::IsSupportedType(mimeType)) {
+    return OggDecoder::GetTracksInfo(aType);
+  }
+  if (WaveDecoder::IsSupportedType(mimeType)) {
+    return WaveDecoder::GetTracksInfo(aType);
+  }
+#ifdef MOZ_FMP4
+  if (MP4Decoder::IsSupportedType(mimeType, nullptr)) {
+    return MP4Decoder::GetTracksInfo(aType);
+  }
+#endif
+  if (WebMDecoder::IsSupportedType(mimeType)) {
+    return WebMDecoder::GetTracksInfo(aType);
+  }
+  if (MP3Decoder::IsSupportedType(mimeType)) {
+    return MP3Decoder::GetTracksInfo(aType);
+  }
+  if (ADTSDecoder::IsSupportedType(mimeType)) {
+    return ADTSDecoder::GetTracksInfo(aType);
+  }
+  if (FlacDecoder::IsSupportedType(mimeType)) {
+    return FlacDecoder::GetTracksInfo(aType);
+  }
+  return nsTArray<UniquePtr<TrackInfo>>();
+}
+
+}  // namespace mozilla