Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 243 insertions, 0 deletions

diff --git a/dom/media/mediacapabilities/DecoderBenchmark.cpp b/dom/media/mediacapabilities/DecoderBenchmark.cpp
new file mode 100644
index 0000000000..b5c9a2a693
--- /dev/null
+++ b/dom/media/mediacapabilities/DecoderBenchmark.cpp
@@ -0,0 +1,243 @@
+/* -*- 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 "DecoderBenchmark.h"
+#include "mozilla/BenchmarkStorageChild.h"
+#include "mozilla/media/MediaUtils.h"
+#include "mozilla/StaticPrefs_media.h"
+
+namespace mozilla {
+
+void DecoderBenchmark::StoreScore(const nsACString& aDecoderName,
+                                  const nsACString& aKey,
+                                  RefPtr<FrameStatistics> aStats) {
+  FrameStatisticsData statsData = aStats->GetFrameStatisticsData();
+  uint64_t totalFrames = FrameStatistics::GetTotalFrames(statsData);
+  uint64_t droppedFrames = FrameStatistics::GetDroppedFrames(statsData);
+
+  MOZ_ASSERT(droppedFrames <= totalFrames);
+  MOZ_ASSERT(totalFrames >= mLastTotalFrames);
+  MOZ_ASSERT(droppedFrames >= mLastDroppedFrames);
+
+  uint64_t diffTotalFrames = totalFrames - mLastTotalFrames;
+  uint64_t diffDroppedFrames = droppedFrames - mLastDroppedFrames;
+
+  /* Update now in case the method returns at the if check bellow. */
+  mLastTotalFrames = totalFrames;
+  mLastDroppedFrames = droppedFrames;
+
+  /* A minimum number of 10 frames is required to store the score. */
+  if (diffTotalFrames < 10) {
+    return;
+  }
+
+  int32_t percentage =
+      100 - 100 * float(diffDroppedFrames) / float(diffTotalFrames);
+
+  MOZ_ASSERT(percentage >= 0);
+
+  Put(aDecoderName, aKey, percentage);
+}
+
+void DecoderBenchmark::Put(const nsACString& aDecoderName,
+                           const nsACString& aKey, int32_t aValue) {
+  MOZ_ASSERT(NS_IsMainThread());
+  const nsCString name(aDecoderName);
+  const nsCString key(aKey);
+  BenchmarkStorageChild::Instance()->SendPut(name, key, aValue);
+}
+
+RefPtr<BenchmarkScorePromise> DecoderBenchmark::GetScore(
+    const nsACString& aDecoderName, const nsACString& aKey) {
+  if (NS_IsMainThread()) {
+    return Get(aDecoderName, aKey);
+  }
+
+  RefPtr<DecoderBenchmark> self = this;
+  const nsCString decoderName(aDecoderName);
+  const nsCString key(aKey);
+  return InvokeAsync(
+      GetMainThreadSerialEventTarget(), __func__,
+      [self, decoderName, key] { return self->Get(decoderName, key); });
+}
+
+RefPtr<BenchmarkScorePromise> DecoderBenchmark::Get(
+    const nsACString& aDecoderName, const nsACString& aKey) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  const nsCString name(aDecoderName);
+  const nsCString key(aKey);
+  return BenchmarkStorageChild::Instance()->SendGet(name, key)->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [](int32_t aResult) {
+        return BenchmarkScorePromise::CreateAndResolve(aResult, __func__);
+      },
+      [](ipc::ResponseRejectReason&&) {
+        return BenchmarkScorePromise::CreateAndReject(NS_ERROR_FAILURE,
+                                                      __func__);
+      });
+}
+
+/* The key string consists of the video properties resolution, framerate,
+ * and bitdepth. There are various levels for each of them. The key is
+ * formated by the closest level, for example, a video with width=1920,
+ * height=1080, frameRate=24, and bitdepth=8bit will have the key:
+ * "ResolutionLevel5-FrameRateLevel1-8bit". */
+
+#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
+
+/* Keep them sorted */
+const uint32_t PixelLevels[] = {
+    /* 256x144   =*/36864,
+    /* 426x240   =*/102240,
+    /* 640x360   =*/230400,
+    /* 854x480   =*/409920,
+    /* 1280x720  =*/921600,
+    /* 1920x1080 =*/2073600,
+    /* 2560x1440 =*/3686400,
+    /* 3840x2160 =*/8294400,
+};
+const size_t PixelLevelsSize = NELEMS(PixelLevels);
+
+const uint32_t FrameRateLevels[] = {
+    15, 24, 30, 50, 60,
+};
+const size_t FrameRateLevelsSize = NELEMS(FrameRateLevels);
+
+/* static */
+nsCString KeyUtil::FindLevel(const uint32_t aLevels[], const size_t length,
+                             uint32_t aValue) {
+  MOZ_ASSERT(aValue);
+  if (aValue <= aLevels[0]) {
+    return "Level0"_ns;
+  }
+  nsAutoCString level("Level");
+  size_t lastIndex = length - 1;
+  if (aValue >= aLevels[lastIndex]) {
+    level.AppendInt(static_cast<uint32_t>(lastIndex));
+    return std::move(level);
+  }
+  for (size_t i = 0; i < lastIndex; ++i) {
+    if (aValue >= aLevels[i + 1]) {
+      continue;
+    }
+    if (aValue - aLevels[i] < aLevels[i + 1] - aValue) {
+      level.AppendInt(static_cast<uint32_t>(i));
+      return std::move(level);
+    }
+    level.AppendInt(static_cast<uint32_t>(i + 1));
+    return std::move(level);
+  }
+  MOZ_CRASH("Array is not sorted");
+  return ""_ns;
+}
+
+/* static */
+nsCString KeyUtil::BitDepthToStr(uint8_t aBitDepth) {
+  switch (aBitDepth) {
+    case 8:  // ColorDepth::COLOR_8
+      return "-8bit"_ns;
+    case 10:  // ColorDepth::COLOR_10
+    case 12:  // ColorDepth::COLOR_12
+    case 16:  // ColorDepth::COLOR_16
+      return "-non8bit"_ns;
+  }
+  MOZ_ASSERT_UNREACHABLE("invalid color depth value");
+  return ""_ns;
+}
+
+/* static */
+nsCString KeyUtil::CreateKey(const DecoderBenchmarkInfo& aBenchInfo) {
+  nsAutoCString key("Resolution");
+  key.Append(FindLevel(PixelLevels, PixelLevelsSize,
+                       aBenchInfo.mWidth * aBenchInfo.mHeight));
+
+  key.Append("-FrameRate");
+  key.Append(
+      FindLevel(FrameRateLevels, FrameRateLevelsSize, aBenchInfo.mFrameRate));
+
+  key.Append(BitDepthToStr(aBenchInfo.mBitDepth));
+
+  return std::move(key);
+}
+
+void DecoderBenchmark::Store(const DecoderBenchmarkInfo& aBenchInfo,
+                             RefPtr<FrameStatistics> aStats) {
+  if (!XRE_IsContentProcess()) {
+    NS_WARNING(
+        "Storing a benchmark is only allowed only from the content process.");
+    return;
+  }
+  StoreScore(aBenchInfo.mContentType, KeyUtil::CreateKey(aBenchInfo), aStats);
+}
+
+/* static */
+RefPtr<BenchmarkScorePromise> DecoderBenchmark::Get(
+    const DecoderBenchmarkInfo& aBenchInfo) {
+  if (!XRE_IsContentProcess()) {
+    NS_WARNING(
+        "Getting a benchmark is only allowed only from the content process.");
+    return BenchmarkScorePromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
+  }
+  // There is no need for any of the data members to query the database, thus
+  // it can be a static method.
+  auto bench = MakeRefPtr<DecoderBenchmark>();
+  return bench->GetScore(aBenchInfo.mContentType,
+                         KeyUtil::CreateKey(aBenchInfo));
+}
+
+static nsTHashMap<nsCStringHashKey, int32_t> DecoderVersionTable() {
+  nsTHashMap<nsCStringHashKey, int32_t> decoderVersionTable;
+
+  /*
+   * For the decoders listed here, the benchmark version number will be checked.
+   * If the version number does not exist in the database or is different than
+   * the version number listed here, all the benchmark entries for this decoder
+   * will be erased. An example of assigning the version number `1` for AV1
+   * decoder is:
+   *
+   * decoderVersionTable.InsertOrUpdate("video/av1"_ns, 1);
+   *
+   * For the decoders not listed here the `CheckVersion` method exits early, to
+   * avoid sending unecessary IPC messages.
+   */
+
+  return decoderVersionTable;
+}
+
+/* static */
+void DecoderBenchmark::CheckVersion(const nsACString& aDecoderName) {
+  if (!XRE_IsContentProcess()) {
+    NS_WARNING(
+        "Checking version is only allowed only from the content process.");
+    return;
+  }
+
+  if (!StaticPrefs::media_mediacapabilities_from_database()) {
+    return;
+  }
+
+  nsCString name(aDecoderName);
+  int32_t version;
+  if (!DecoderVersionTable().Get(name, &version)) {
+    // A version is not set for that decoder ignore.
+    return;
+  }
+
+  if (NS_IsMainThread()) {
+    BenchmarkStorageChild::Instance()->SendCheckVersion(name, version);
+    return;
+  }
+
+  DebugOnly<nsresult> rv =
+      GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+          "DecoderBenchmark::CheckVersion", [name, version]() {
+            BenchmarkStorageChild::Instance()->SendCheckVersion(name, version);
+          }));
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+
+}  // namespace mozilla