Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 197 insertions, 0 deletions

diff --git a/dom/media/BitReader.cpp b/dom/media/BitReader.cpp
new file mode 100644
index 0000000000..f66ab76f19
--- /dev/null
+++ b/dom/media/BitReader.cpp
@@ -0,0 +1,197 @@
+/* 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/. */
+
+// Derived from Stagefright's ABitReader.
+
+#include "BitReader.h"
+
+namespace mozilla {
+
+BitReader::BitReader(const mozilla::MediaByteBuffer* aBuffer)
+    : BitReader(aBuffer->Elements(), aBuffer->Length() * 8) {}
+
+BitReader::BitReader(const mozilla::MediaByteBuffer* aBuffer, size_t aBits)
+    : BitReader(aBuffer->Elements(), aBits) {}
+
+BitReader::BitReader(const uint8_t* aBuffer, size_t aBits)
+    : mData(aBuffer),
+      mOriginalBitSize(aBits),
+      mTotalBitsLeft(aBits),
+      mSize((aBits + 7) / 8),
+      mReservoir(0),
+      mNumBitsLeft(0) {}
+
+BitReader::~BitReader() = default;
+
+uint32_t BitReader::ReadBits(size_t aNum) {
+  MOZ_ASSERT(aNum <= 32);
+  if (mTotalBitsLeft < aNum) {
+    NS_ASSERTION(false, "Reading past end of buffer");
+    return 0;
+  }
+  uint32_t result = 0;
+  while (aNum > 0) {
+    if (mNumBitsLeft == 0) {
+      FillReservoir();
+    }
+
+    size_t m = aNum;
+    if (m > mNumBitsLeft) {
+      m = mNumBitsLeft;
+    }
+
+    if (m == 32) {
+      result = mReservoir;
+      mReservoir = 0;
+    } else {
+      result = (result << m) | (mReservoir >> (32 - m));
+      mReservoir <<= m;
+    }
+    mNumBitsLeft -= m;
+    mTotalBitsLeft -= m;
+
+    aNum -= m;
+  }
+
+  return result;
+}
+
+// Read unsigned integer Exp-Golomb-coded.
+uint32_t BitReader::ReadUE() {
+  uint32_t i = 0;
+
+  while (ReadBit() == 0 && i < 32) {
+    i++;
+  }
+  if (i == 32) {
+    // This can happen if the data is invalid, or if it's
+    // short, since ReadBit() will return 0 when it runs
+    // off the end of the buffer.
+    NS_WARNING("Invalid H.264 data");
+    return 0;
+  }
+  uint32_t r = ReadBits(i);
+  r += (uint32_t(1) << i) - 1;
+
+  return r;
+}
+
+// Read signed integer Exp-Golomb-coded.
+int32_t BitReader::ReadSE() {
+  int32_t r = ReadUE();
+  if (r & 1) {
+    return (r + 1) / 2;
+  } else {
+    return -r / 2;
+  }
+}
+
+uint64_t BitReader::ReadU64() {
+  uint64_t hi = ReadU32();
+  uint32_t lo = ReadU32();
+  return (hi << 32) | lo;
+}
+
+CheckedUint64 BitReader::ReadULEB128() {
+  // See https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer
+  CheckedUint64 value = 0;
+  for (size_t i = 0; i < sizeof(uint64_t) * 8 / 7; i++) {
+    bool more = ReadBit();
+    value += static_cast<uint64_t>(ReadBits(7)) << (i * 7);
+    if (!more) {
+      break;
+    }
+  }
+  return value;
+}
+
+uint64_t BitReader::ReadUTF8() {
+  int64_t val = ReadBits(8);
+  uint32_t top = (val & 0x80) >> 1;
+
+  if ((val & 0xc0) == 0x80 || val >= 0xFE) {
+    // error.
+    return -1;
+  }
+  while (val & top) {
+    int tmp = ReadBits(8) - 128;
+    if (tmp >> 6) {
+      // error.
+      return -1;
+    }
+    val = (val << 6) + tmp;
+    top <<= 5;
+  }
+  val &= (top << 1) - 1;
+  return val;
+}
+
+size_t BitReader::BitCount() const { return mOriginalBitSize - mTotalBitsLeft; }
+
+size_t BitReader::BitsLeft() const { return mTotalBitsLeft; }
+
+void BitReader::FillReservoir() {
+  if (mSize == 0) {
+    NS_ASSERTION(false, "Attempting to fill reservoir from past end of data");
+    return;
+  }
+
+  mReservoir = 0;
+  size_t i;
+  for (i = 0; mSize > 0 && i < 4; i++) {
+    mReservoir = (mReservoir << 8) | *mData;
+    mData++;
+    mSize--;
+  }
+
+  mNumBitsLeft = 8 * i;
+  mReservoir <<= 32 - mNumBitsLeft;
+}
+
+/* static */
+uint32_t BitReader::GetBitLength(const mozilla::MediaByteBuffer* aNAL) {
+  size_t size = aNAL->Length();
+
+  while (size > 0 && aNAL->ElementAt(size - 1) == 0) {
+    size--;
+  }
+
+  if (!size) {
+    return 0;
+  }
+
+  if (size > UINT32_MAX / 8) {
+    // We can't represent it, we'll use as much as we can.
+    return UINT32_MAX;
+  }
+
+  uint8_t v = aNAL->ElementAt(size - 1);
+  size *= 8;
+
+  // Remove the stop bit and following trailing zeros.
+  if (v) {
+    // Count the consecutive zero bits (trailing) on the right by binary search.
+    // Adapted from Matt Whitlock algorithm to only bother with 8 bits integers.
+    uint32_t c;
+    if (v & 1) {
+      // Special case for odd v (assumed to happen half of the time).
+      c = 0;
+    } else {
+      c = 1;
+      if ((v & 0xf) == 0) {
+        v >>= 4;
+        c += 4;
+      }
+      if ((v & 0x3) == 0) {
+        v >>= 2;
+        c += 2;
+      }
+      c -= v & 0x1;
+    }
+    size -= c + 1;
+  }
+  return size;
+}
+
+}  // namespace mozilla