Delete BitBuffer
All BitBuffer usage was replaced with BitstreamReader
Bug: None
Change-Id: Ia91826cea2561679709c0c22767958de596a282c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/232125
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35056}
diff --git a/rtc_base/bit_buffer.cc b/rtc_base/bit_buffer.cc
index a73ef5d..7dc7428 100644
--- a/rtc_base/bit_buffer.cc
+++ b/rtc_base/bit_buffer.cc
@@ -18,21 +18,6 @@
namespace {
-// Returns the lowest (right-most) `bit_count` bits in `byte`.
-uint8_t LowestBits(uint8_t byte, size_t bit_count) {
- RTC_DCHECK_LE(bit_count, 8);
- return byte & ((1 << bit_count) - 1);
-}
-
-// Returns the highest (left-most) `bit_count` bits in `byte`, shifted to the
-// lowest bits (to the right).
-uint8_t HighestBits(uint8_t byte, size_t bit_count) {
- RTC_DCHECK_LE(bit_count, 8);
- uint8_t shift = 8 - static_cast<uint8_t>(bit_count);
- uint8_t mask = 0xFF << shift;
- return (byte & mask) >> shift;
-}
-
// Returns the highest byte of `val` in a uint8_t.
uint8_t HighestByte(uint64_t val) {
return static_cast<uint8_t>(val >> 56);
@@ -64,121 +49,24 @@
namespace rtc {
-BitBuffer::BitBuffer(const uint8_t* bytes, size_t byte_count)
- : bytes_(bytes), byte_count_(byte_count), byte_offset_(), bit_offset_() {
+BitBufferWriter::BitBufferWriter(uint8_t* bytes, size_t byte_count)
+ : writable_bytes_(bytes),
+ byte_count_(byte_count),
+ byte_offset_(),
+ bit_offset_() {
RTC_DCHECK(static_cast<uint64_t>(byte_count_) <=
std::numeric_limits<uint32_t>::max());
}
-uint64_t BitBuffer::RemainingBitCount() const {
+uint64_t BitBufferWriter::RemainingBitCount() const {
return (static_cast<uint64_t>(byte_count_) - byte_offset_) * 8 - bit_offset_;
}
-bool BitBuffer::ReadUInt8(uint8_t& val) {
- uint32_t bit_val;
- if (!ReadBits(sizeof(uint8_t) * 8, bit_val)) {
- return false;
- }
- RTC_DCHECK(bit_val <= std::numeric_limits<uint8_t>::max());
- val = static_cast<uint8_t>(bit_val);
- return true;
-}
-
-bool BitBuffer::ReadUInt16(uint16_t& val) {
- uint32_t bit_val;
- if (!ReadBits(sizeof(uint16_t) * 8, bit_val)) {
- return false;
- }
- RTC_DCHECK(bit_val <= std::numeric_limits<uint16_t>::max());
- val = static_cast<uint16_t>(bit_val);
- return true;
-}
-
-bool BitBuffer::ReadUInt32(uint32_t& val) {
- return ReadBits(sizeof(uint32_t) * 8, val);
-}
-
-bool BitBuffer::PeekBits(size_t bit_count, uint32_t& val) {
- // TODO(nisse): Could allow bit_count == 0 and always return success. But
- // current code reads one byte beyond end of buffer in the case that
- // RemainingBitCount() == 0 and bit_count == 0.
- RTC_DCHECK(bit_count > 0);
- if (bit_count > RemainingBitCount() || bit_count > 32) {
- return false;
- }
- const uint8_t* bytes = bytes_ + byte_offset_;
- size_t remaining_bits_in_current_byte = 8 - bit_offset_;
- uint32_t bits = LowestBits(*bytes++, remaining_bits_in_current_byte);
- // If we're reading fewer bits than what's left in the current byte, just
- // return the portion of this byte that we need.
- if (bit_count < remaining_bits_in_current_byte) {
- val = HighestBits(bits, bit_offset_ + bit_count);
- return true;
- }
- // Otherwise, subtract what we've read from the bit count and read as many
- // full bytes as we can into bits.
- bit_count -= remaining_bits_in_current_byte;
- while (bit_count >= 8) {
- bits = (bits << 8) | *bytes++;
- bit_count -= 8;
- }
- // Whatever we have left is smaller than a byte, so grab just the bits we need
- // and shift them into the lowest bits.
- if (bit_count > 0) {
- bits <<= bit_count;
- bits |= HighestBits(*bytes, bit_count);
- }
- val = bits;
- return true;
-}
-
-bool BitBuffer::PeekBits(size_t bit_count, uint64_t& val) {
- // TODO(nisse): Could allow bit_count == 0 and always return success. But
- // current code reads one byte beyond end of buffer in the case that
- // RemainingBitCount() == 0 and bit_count == 0.
- RTC_DCHECK(bit_count > 0);
- if (bit_count > RemainingBitCount() || bit_count > 64) {
- return false;
- }
- const uint8_t* bytes = bytes_ + byte_offset_;
- size_t remaining_bits_in_current_byte = 8 - bit_offset_;
- uint64_t bits = LowestBits(*bytes++, remaining_bits_in_current_byte);
- // If we're reading fewer bits than what's left in the current byte, just
- // return the portion of this byte that we need.
- if (bit_count < remaining_bits_in_current_byte) {
- val = HighestBits(bits, bit_offset_ + bit_count);
- return true;
- }
- // Otherwise, subtract what we've read from the bit count and read as many
- // full bytes as we can into bits.
- bit_count -= remaining_bits_in_current_byte;
- while (bit_count >= 8) {
- bits = (bits << 8) | *bytes++;
- bit_count -= 8;
- }
- // Whatever we have left is smaller than a byte, so grab just the bits we need
- // and shift them into the lowest bits.
- if (bit_count > 0) {
- bits <<= bit_count;
- bits |= HighestBits(*bytes, bit_count);
- }
- val = bits;
- return true;
-}
-
-bool BitBuffer::ReadBits(size_t bit_count, uint32_t& val) {
- return PeekBits(bit_count, val) && ConsumeBits(bit_count);
-}
-
-bool BitBuffer::ReadBits(size_t bit_count, uint64_t& val) {
- return PeekBits(bit_count, val) && ConsumeBits(bit_count);
-}
-
-bool BitBuffer::ConsumeBytes(size_t byte_count) {
+bool BitBufferWriter::ConsumeBytes(size_t byte_count) {
return ConsumeBits(byte_count * 8);
}
-bool BitBuffer::ConsumeBits(size_t bit_count) {
+bool BitBufferWriter::ConsumeBits(size_t bit_count) {
if (bit_count > RemainingBitCount()) {
return false;
}
@@ -188,86 +76,15 @@
return true;
}
-bool BitBuffer::ReadNonSymmetric(uint32_t num_values, uint32_t& val) {
- RTC_DCHECK_GT(num_values, 0);
- RTC_DCHECK_LE(num_values, uint32_t{1} << 31);
- if (num_values == 1) {
- // When there is only one possible value, it requires zero bits to store it.
- // But ReadBits doesn't support reading zero bits.
- val = 0;
- return true;
- }
- size_t count_bits = absl::bit_width(num_values);
- uint32_t num_min_bits_values = (uint32_t{1} << count_bits) - num_values;
-
- if (!ReadBits(count_bits - 1, val)) {
- return false;
- }
-
- if (val < num_min_bits_values) {
- return true;
- }
-
- uint32_t extra_bit;
- if (!ReadBits(/*bit_count=*/1, extra_bit)) {
- return false;
- }
-
- val = (val << 1) + extra_bit - num_min_bits_values;
- return true;
-}
-
-bool BitBuffer::ReadExponentialGolomb(uint32_t& val) {
- // Store off the current byte/bit offset, in case we want to restore them due
- // to a failed parse.
- size_t original_byte_offset = byte_offset_;
- size_t original_bit_offset = bit_offset_;
-
- // Count the number of leading 0 bits by peeking/consuming them one at a time.
- size_t zero_bit_count = 0;
- uint32_t peeked_bit;
- while (PeekBits(1, peeked_bit) && peeked_bit == 0) {
- zero_bit_count++;
- ConsumeBits(1);
- }
-
- // We should either be at the end of the stream, or the next bit should be 1.
- RTC_DCHECK(!PeekBits(1, peeked_bit) || peeked_bit == 1);
-
- // The bit count of the value is the number of zeros + 1. Make sure that many
- // bits fits in a uint32_t and that we have enough bits left for it, and then
- // read the value.
- size_t value_bit_count = zero_bit_count + 1;
- if (value_bit_count > 32 || !ReadBits(value_bit_count, val)) {
- RTC_CHECK(Seek(original_byte_offset, original_bit_offset));
- return false;
- }
- val -= 1;
- return true;
-}
-
-bool BitBuffer::ReadSignedExponentialGolomb(int32_t& val) {
- uint32_t unsigned_val;
- if (!ReadExponentialGolomb(unsigned_val)) {
- return false;
- }
- if ((unsigned_val & 1) == 0) {
- val = -static_cast<int32_t>(unsigned_val / 2);
- } else {
- val = (unsigned_val + 1) / 2;
- }
- return true;
-}
-
-void BitBuffer::GetCurrentOffset(size_t* out_byte_offset,
- size_t* out_bit_offset) {
+void BitBufferWriter::GetCurrentOffset(size_t* out_byte_offset,
+ size_t* out_bit_offset) {
RTC_CHECK(out_byte_offset != nullptr);
RTC_CHECK(out_bit_offset != nullptr);
*out_byte_offset = byte_offset_;
*out_bit_offset = bit_offset_;
}
-bool BitBuffer::Seek(size_t byte_offset, size_t bit_offset) {
+bool BitBufferWriter::Seek(size_t byte_offset, size_t bit_offset) {
if (byte_offset > byte_count_ || bit_offset > 7 ||
(byte_offset == byte_count_ && bit_offset > 0)) {
return false;
@@ -277,9 +94,6 @@
return true;
}
-BitBufferWriter::BitBufferWriter(uint8_t* bytes, size_t byte_count)
- : BitBuffer(bytes, byte_count), writable_bytes_(bytes) {}
-
bool BitBufferWriter::WriteUInt8(uint8_t val) {
return WriteBits(val, sizeof(uint8_t) * 8);
}
diff --git a/rtc_base/bit_buffer.h b/rtc_base/bit_buffer.h
index 5736616..5375550 100644
--- a/rtc_base/bit_buffer.h
+++ b/rtc_base/bit_buffer.h
@@ -14,21 +14,18 @@
#include <stddef.h> // For size_t.
#include <stdint.h> // For integer types.
-#include "absl/base/attributes.h"
#include "rtc_base/constructor_magic.h"
namespace rtc {
-// A class, similar to ByteBuffer, that can parse bit-sized data out of a set of
-// bytes. Has a similar API to ByteBuffer, plus methods for reading bit-sized
-// and exponential golomb encoded data. For a writable version, use
-// BitBufferWriter. Unlike ByteBuffer, this class doesn't make a copy of the
-// source bytes, so it can be used on read-only data.
+// A BitBuffer API for write operations. Supports symmetric write APIs to the
+// reading APIs of BitstreamReader.
// Sizes/counts specify bits/bytes, for clarity.
// Byte order is assumed big-endian/network.
-class BitBuffer {
+class BitBufferWriter {
public:
- BitBuffer(const uint8_t* bytes, size_t byte_count);
+ // Constructs a bit buffer for the writable buffer of `bytes`.
+ BitBufferWriter(uint8_t* bytes, size_t byte_count);
// Gets the current offset, in bytes/bits, from the start of the buffer. The
// bit offset is the offset into the current byte, in the range [0,7].
@@ -37,75 +34,6 @@
// The remaining bits in the byte buffer.
uint64_t RemainingBitCount() const;
- // Reads byte-sized values from the buffer. Returns false if there isn't
- // enough data left for the specified type.
- bool ReadUInt8(uint8_t& val);
- bool ReadUInt16(uint16_t& val);
- bool ReadUInt32(uint32_t& val);
- ABSL_DEPRECATED("") bool ReadUInt8(uint8_t* val) {
- return val ? ReadUInt8(*val) : false;
- }
- ABSL_DEPRECATED("") bool ReadUInt16(uint16_t* val) {
- return val ? ReadUInt16(*val) : false;
- }
- ABSL_DEPRECATED("") bool ReadUInt32(uint32_t* val) {
- return val ? ReadUInt32(*val) : false;
- }
-
- // Reads bit-sized values from the buffer. Returns false if there isn't enough
- // data left for the specified bit count.
- bool ReadBits(size_t bit_count, uint32_t& val);
- bool ReadBits(size_t bit_count, uint64_t& val);
- ABSL_DEPRECATED("") bool ReadBits(uint32_t* val, size_t bit_count) {
- return val ? ReadBits(bit_count, *val) : false;
- }
-
- // Peeks bit-sized values from the buffer. Returns false if there isn't enough
- // data left for the specified number of bits. Doesn't move the current
- // offset.
- bool PeekBits(size_t bit_count, uint32_t& val);
- bool PeekBits(size_t bit_count, uint64_t& val);
- ABSL_DEPRECATED("") bool PeekBits(uint32_t* val, size_t bit_count) {
- return val ? PeekBits(bit_count, *val) : false;
- }
-
- // Reads value in range [0, num_values - 1].
- // This encoding is similar to ReadBits(val, Ceil(Log2(num_values)),
- // but reduces wastage incurred when encoding non-power of two value ranges
- // Non symmetric values are encoded as:
- // 1) n = countbits(num_values)
- // 2) k = (1 << n) - num_values
- // Value v in range [0, k - 1] is encoded in (n-1) bits.
- // Value v in range [k, num_values - 1] is encoded as (v+k) in n bits.
- // https://aomediacodec.github.io/av1-spec/#nsn
- // Returns false if there isn't enough data left.
- bool ReadNonSymmetric(uint32_t num_values, uint32_t& val);
- ABSL_DEPRECATED("")
- bool ReadNonSymmetric(uint32_t* val, uint32_t num_values) {
- return val ? ReadNonSymmetric(num_values, *val) : false;
- }
-
- // Reads the exponential golomb encoded value at the current offset.
- // Exponential golomb values are encoded as:
- // 1) x = source val + 1
- // 2) In binary, write [countbits(x) - 1] 0s, then x
- // To decode, we count the number of leading 0 bits, read that many + 1 bits,
- // and increment the result by 1.
- // Returns false if there isn't enough data left for the specified type, or if
- // the value wouldn't fit in a uint32_t.
- bool ReadExponentialGolomb(uint32_t& val);
- ABSL_DEPRECATED("") bool ReadExponentialGolomb(uint32_t* val) {
- return val ? ReadExponentialGolomb(*val) : false;
- }
-
- // Reads signed exponential golomb values at the current offset. Signed
- // exponential golomb values are just the unsigned values mapped to the
- // sequence 0, 1, -1, 2, -2, etc. in order.
- bool ReadSignedExponentialGolomb(int32_t& val);
- ABSL_DEPRECATED("") bool ReadSignedExponentialGolomb(int32_t* val) {
- return val ? ReadSignedExponentialGolomb(*val) : false;
- }
-
// Moves current position `byte_count` bytes forward. Returns false if
// there aren't enough bytes left in the buffer.
bool ConsumeBytes(size_t byte_count);
@@ -117,26 +45,6 @@
// offset is from the given byte, in the range [0,7].
bool Seek(size_t byte_offset, size_t bit_offset);
- protected:
- const uint8_t* const bytes_;
- // The total size of `bytes_`.
- size_t byte_count_;
- // The current offset, in bytes, from the start of `bytes_`.
- size_t byte_offset_;
- // The current offset, in bits, into the current byte.
- size_t bit_offset_;
-
- RTC_DISALLOW_COPY_AND_ASSIGN(BitBuffer);
-};
-
-// A BitBuffer API for write operations. Supports symmetric write APIs to the
-// reading APIs of BitBuffer. Note that the read/write offset is shared with the
-// BitBuffer API, so both reading and writing will consume bytes/bits.
-class BitBufferWriter : public BitBuffer {
- public:
- // Constructs a bit buffer for the writable buffer of `bytes`.
- BitBufferWriter(uint8_t* bytes, size_t byte_count);
-
// Writes byte-sized values from the buffer. Returns false if there isn't
// enough data left for the specified type.
bool WriteUInt8(uint8_t val);
@@ -166,6 +74,12 @@
private:
// The buffer, as a writable array.
uint8_t* const writable_bytes_;
+ // The total size of `bytes_`.
+ const size_t byte_count_;
+ // The current offset, in bytes, from the start of `bytes_`.
+ size_t byte_offset_;
+ // The current offset, in bits, into the current byte.
+ size_t bit_offset_;
RTC_DISALLOW_COPY_AND_ASSIGN(BitBufferWriter);
};
diff --git a/rtc_base/bit_buffer_unittest.cc b/rtc_base/bit_buffer_unittest.cc
index e6bb427..198be50 100644
--- a/rtc_base/bit_buffer_unittest.cc
+++ b/rtc_base/bit_buffer_unittest.cc
@@ -12,7 +12,9 @@
#include <limits>
+#include "api/array_view.h"
#include "rtc_base/arraysize.h"
+#include "rtc_base/bitstream_reader.h"
#include "rtc_base/byte_buffer.h"
#include "test/gmock.h"
#include "test/gtest.h"
@@ -20,10 +22,11 @@
namespace rtc {
using ::testing::ElementsAre;
+using ::webrtc::BitstreamReader;
-TEST(BitBufferTest, ConsumeBits) {
- const uint8_t bytes[64] = {0};
- BitBuffer buffer(bytes, 32);
+TEST(BitBufferWriterTest, ConsumeBits) {
+ uint8_t bytes[64] = {0};
+ BitBufferWriter buffer(bytes, 32);
uint64_t total_bits = 32 * 8;
EXPECT_EQ(total_bits, buffer.RemainingBitCount());
EXPECT_TRUE(buffer.ConsumeBits(3));
@@ -43,138 +46,7 @@
EXPECT_EQ(total_bits, buffer.RemainingBitCount());
}
-TEST(BitBufferTest, ReadBytesAligned) {
- const uint8_t bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23, 0x45, 0x67, 0x89};
- uint8_t val8;
- uint16_t val16;
- uint32_t val32;
- BitBuffer buffer(bytes, 8);
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0x0Au, val8);
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0xBCu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(val16));
- EXPECT_EQ(0xDEF1u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(val32));
- EXPECT_EQ(0x23456789u, val32);
-}
-
-TEST(BitBufferTest, ReadBytesOffset4) {
- const uint8_t bytes[] = {0x0A, 0xBC, 0xDE, 0xF1, 0x23,
- 0x45, 0x67, 0x89, 0x0A};
- uint8_t val8;
- uint16_t val16;
- uint32_t val32;
- BitBuffer buffer(bytes, 9);
- EXPECT_TRUE(buffer.ConsumeBits(4));
-
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0xABu, val8);
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0xCDu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(val16));
- EXPECT_EQ(0xEF12u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(val32));
- EXPECT_EQ(0x34567890u, val32);
-}
-
-TEST(BitBufferTest, ReadBytesOffset3) {
- // The pattern we'll check against is counting down from 0b1111. It looks
- // weird here because it's all offset by 3.
- // Byte pattern is:
- // 56701234
- // 0b00011111,
- // 0b11011011,
- // 0b10010111,
- // 0b01010011,
- // 0b00001110,
- // 0b11001010,
- // 0b10000110,
- // 0b01000010
- // xxxxx <-- last 5 bits unused.
-
- // The bytes. It almost looks like counting down by two at a time, except the
- // jump at 5->3->0, since that's when the high bit is turned off.
- const uint8_t bytes[] = {0x1F, 0xDB, 0x97, 0x53, 0x0E, 0xCA, 0x86, 0x42};
-
- uint8_t val8;
- uint16_t val16;
- uint32_t val32;
- BitBuffer buffer(bytes, 8);
- EXPECT_TRUE(buffer.ConsumeBits(3));
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0xFEu, val8);
- EXPECT_TRUE(buffer.ReadUInt16(val16));
- EXPECT_EQ(0xDCBAu, val16);
- EXPECT_TRUE(buffer.ReadUInt32(val32));
- EXPECT_EQ(0x98765432u, val32);
- // 5 bits left unread. Not enough to read a uint8_t.
- EXPECT_EQ(5u, buffer.RemainingBitCount());
- EXPECT_FALSE(buffer.ReadUInt8(val8));
-}
-
-TEST(BitBufferTest, ReadBits) {
- // Bit values are:
- // 0b01001101,
- // 0b00110010
- const uint8_t bytes[] = {0x4D, 0x32};
- uint32_t val;
- BitBuffer buffer(bytes, 2);
- EXPECT_TRUE(buffer.ReadBits(3, val));
- // 0b010
- EXPECT_EQ(0x2u, val);
- EXPECT_TRUE(buffer.ReadBits(2, val));
- // 0b01
- EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(7, val));
- // 0b1010011
- EXPECT_EQ(0x53u, val);
- EXPECT_TRUE(buffer.ReadBits(2, val));
- // 0b00
- EXPECT_EQ(0x0u, val);
- EXPECT_TRUE(buffer.ReadBits(1, val));
- // 0b1
- EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(1, val));
- // 0b0
- EXPECT_EQ(0x0u, val);
-
- EXPECT_FALSE(buffer.ReadBits(1, val));
-}
-
-TEST(BitBufferTest, ReadBits64) {
- const uint8_t bytes[] = {0x4D, 0x32, 0xAB, 0x54, 0x00, 0xFF, 0xFE, 0x01,
- 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89};
- BitBuffer buffer(bytes, 16);
- uint64_t val;
-
- // Peek and read first 33 bits.
- EXPECT_TRUE(buffer.PeekBits(33, val));
- EXPECT_EQ(0x4D32AB5400FFFE01ull >> (64 - 33), val);
- val = 0;
- EXPECT_TRUE(buffer.ReadBits(33, val));
- EXPECT_EQ(0x4D32AB5400FFFE01ull >> (64 - 33), val);
-
- // Peek and read next 31 bits.
- constexpr uint64_t kMask31Bits = (1ull << 32) - 1;
- EXPECT_TRUE(buffer.PeekBits(31, val));
- EXPECT_EQ(0x4D32AB5400FFFE01ull & kMask31Bits, val);
- val = 0;
- EXPECT_TRUE(buffer.ReadBits(31, val));
- EXPECT_EQ(0x4D32AB5400FFFE01ull & kMask31Bits, val);
-
- // Peek and read remaining 64 bits.
- EXPECT_TRUE(buffer.PeekBits(64, val));
- EXPECT_EQ(0xABCDEF0123456789ull, val);
- val = 0;
- EXPECT_TRUE(buffer.ReadBits(64, val));
- EXPECT_EQ(0xABCDEF0123456789ull, val);
-
- // Nothing more to read.
- EXPECT_FALSE(buffer.ReadBits(1, val));
-}
-
-TEST(BitBufferDeathTest, SetOffsetValues) {
+TEST(BitBufferWriterDeathTest, SetOffsetValues) {
uint8_t bytes[4] = {0};
BitBufferWriter buffer(bytes, 4);
@@ -213,21 +85,6 @@
#endif
}
-TEST(BitBufferTest, ReadNonSymmetricSameNumberOfBitsWhenNumValuesPowerOf2) {
- const uint8_t bytes[2] = {0xf3, 0xa0};
- BitBuffer reader(bytes, 2);
-
- uint32_t values[4];
- ASSERT_EQ(reader.RemainingBitCount(), 16u);
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[0]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[1]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[2]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1 << 4, values[3]));
- ASSERT_EQ(reader.RemainingBitCount(), 0u);
-
- EXPECT_THAT(values, ElementsAre(0xf, 0x3, 0xa, 0x0));
-}
-
TEST(BitBufferWriterTest,
WriteNonSymmetricSameNumberOfBitsWhenNumValuesPowerOf2) {
uint8_t bytes[2] = {};
@@ -274,28 +131,14 @@
// 00.01.100.101.110.111 = 00011001|01110111 = 0x19|77
EXPECT_THAT(bytes, ElementsAre(0x19, 0x77));
- rtc::BitBuffer reader(bytes, 2);
- uint32_t values[6];
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[0]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[1]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[2]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[3]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[4]));
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/6, values[5]));
-
- EXPECT_THAT(values, ElementsAre(0, 1, 2, 3, 4, 5));
-}
-
-TEST(BitBufferTest, ReadNonSymmetricOnlyValueConsumesNoBits) {
- const uint8_t bytes[2] = {};
- BitBuffer reader(bytes, 2);
- uint32_t value = 0xFFFFFFFF;
- ASSERT_EQ(reader.RemainingBitCount(), 16u);
-
- EXPECT_TRUE(reader.ReadNonSymmetric(/*num_values=*/1, value));
-
- EXPECT_EQ(value, 0u);
- EXPECT_EQ(reader.RemainingBitCount(), 16u);
+ BitstreamReader reader(bytes);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 0u);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 1u);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 2u);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 3u);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 4u);
+ EXPECT_EQ(reader.ReadNonSymmetric(/*num_values=*/6), 5u);
+ EXPECT_TRUE(reader.Ok());
}
TEST(BitBufferWriterTest, WriteNonSymmetricOnlyValueConsumesNoBits) {
@@ -308,74 +151,6 @@
EXPECT_EQ(writer.RemainingBitCount(), 16u);
}
-uint64_t GolombEncoded(uint32_t val) {
- val++;
- uint32_t bit_counter = val;
- uint64_t bit_count = 0;
- while (bit_counter > 0) {
- bit_count++;
- bit_counter >>= 1;
- }
- return static_cast<uint64_t>(val) << (64 - (bit_count * 2 - 1));
-}
-
-TEST(BitBufferTest, GolombUint32Values) {
- ByteBufferWriter byteBuffer;
- byteBuffer.Resize(16);
- BitBuffer buffer(reinterpret_cast<const uint8_t*>(byteBuffer.Data()),
- byteBuffer.Capacity());
- // Test over the uint32_t range with a large enough step that the test doesn't
- // take forever. Around 20,000 iterations should do.
- const int kStep = std::numeric_limits<uint32_t>::max() / 20000;
- for (uint32_t i = 0; i < std::numeric_limits<uint32_t>::max() - kStep;
- i += kStep) {
- uint64_t encoded_val = GolombEncoded(i);
- byteBuffer.Clear();
- byteBuffer.WriteUInt64(encoded_val);
- uint32_t decoded_val;
- EXPECT_TRUE(buffer.Seek(0, 0));
- EXPECT_TRUE(buffer.ReadExponentialGolomb(decoded_val));
- EXPECT_EQ(i, decoded_val);
- }
-}
-
-TEST(BitBufferTest, SignedGolombValues) {
- uint8_t golomb_bits[] = {
- 0x80, // 1
- 0x40, // 010
- 0x60, // 011
- 0x20, // 00100
- 0x38, // 00111
- };
- int32_t expected[] = {0, 1, -1, 2, -3};
- for (size_t i = 0; i < sizeof(golomb_bits); ++i) {
- BitBuffer buffer(&golomb_bits[i], 1);
- int32_t decoded_val;
- ASSERT_TRUE(buffer.ReadSignedExponentialGolomb(decoded_val));
- EXPECT_EQ(expected[i], decoded_val)
- << "Mismatch in expected/decoded value for golomb_bits[" << i
- << "]: " << static_cast<int>(golomb_bits[i]);
- }
-}
-
-TEST(BitBufferTest, NoGolombOverread) {
- const uint8_t bytes[] = {0x00, 0xFF, 0xFF};
- // Make sure the bit buffer correctly enforces byte length on golomb reads.
- // If it didn't, the above buffer would be valid at 3 bytes.
- BitBuffer buffer(bytes, 1);
- uint32_t decoded_val;
- EXPECT_FALSE(buffer.ReadExponentialGolomb(decoded_val));
-
- BitBuffer longer_buffer(bytes, 2);
- EXPECT_FALSE(longer_buffer.ReadExponentialGolomb(decoded_val));
-
- BitBuffer longest_buffer(bytes, 3);
- EXPECT_TRUE(longest_buffer.ReadExponentialGolomb(decoded_val));
- // Golomb should have read 9 bits, so 0x01FF, and since it is golomb, the
- // result is 0x01FF - 1 = 0x01FE.
- EXPECT_EQ(0x01FEu, decoded_val);
-}
-
TEST(BitBufferWriterTest, SymmetricReadWrite) {
uint8_t bytes[16] = {0};
BitBufferWriter buffer(bytes, 4);
@@ -390,22 +165,15 @@
// That should be all that fits in the buffer.
EXPECT_FALSE(buffer.WriteBits(1, 1));
- EXPECT_TRUE(buffer.Seek(0, 0));
- uint32_t val;
- EXPECT_TRUE(buffer.ReadBits(3, val));
- EXPECT_EQ(0x2u, val);
- EXPECT_TRUE(buffer.ReadBits(2, val));
- EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(7, val));
- EXPECT_EQ(0x53u, val);
- EXPECT_TRUE(buffer.ReadBits(2, val));
- EXPECT_EQ(0x0u, val);
- EXPECT_TRUE(buffer.ReadBits(1, val));
- EXPECT_EQ(0x1u, val);
- EXPECT_TRUE(buffer.ReadBits(17, val));
- EXPECT_EQ(0x1ABCDu, val);
+ BitstreamReader reader(rtc::MakeArrayView(bytes, 4));
+ EXPECT_EQ(reader.ReadBits(3), 0x2u);
+ EXPECT_EQ(reader.ReadBits(2), 0x1u);
+ EXPECT_EQ(reader.ReadBits(7), 0x53u);
+ EXPECT_EQ(reader.ReadBits(2), 0x0u);
+ EXPECT_EQ(reader.ReadBits(1), 0x1u);
+ EXPECT_EQ(reader.ReadBits(17), 0x1ABCDu);
// And there should be nothing left.
- EXPECT_FALSE(buffer.ReadBits(1, val));
+ EXPECT_EQ(reader.RemainingBitCount(), 0);
}
TEST(BitBufferWriterTest, SymmetricBytesMisaligned) {
@@ -418,16 +186,12 @@
EXPECT_TRUE(buffer.WriteUInt16(0x3456u));
EXPECT_TRUE(buffer.WriteUInt32(0x789ABCDEu));
- buffer.Seek(0, 3);
- uint8_t val8;
- uint16_t val16;
- uint32_t val32;
- EXPECT_TRUE(buffer.ReadUInt8(val8));
- EXPECT_EQ(0x12u, val8);
- EXPECT_TRUE(buffer.ReadUInt16(val16));
- EXPECT_EQ(0x3456u, val16);
- EXPECT_TRUE(buffer.ReadUInt32(val32));
- EXPECT_EQ(0x789ABCDEu, val32);
+ BitstreamReader reader(bytes);
+ reader.ConsumeBits(3);
+ EXPECT_EQ(reader.Read<uint8_t>(), 0x12u);
+ EXPECT_EQ(reader.Read<uint16_t>(), 0x3456u);
+ EXPECT_EQ(reader.Read<uint32_t>(), 0x789ABCDEu);
+ EXPECT_TRUE(reader.Ok());
}
TEST(BitBufferWriterTest, SymmetricGolomb) {
@@ -437,13 +201,11 @@
for (size_t i = 0; i < arraysize(test_string); ++i) {
EXPECT_TRUE(buffer.WriteExponentialGolomb(test_string[i]));
}
- buffer.Seek(0, 0);
+ BitstreamReader reader(bytes);
for (size_t i = 0; i < arraysize(test_string); ++i) {
- uint32_t val;
- EXPECT_TRUE(buffer.ReadExponentialGolomb(val));
- EXPECT_LE(val, std::numeric_limits<uint8_t>::max());
- EXPECT_EQ(test_string[i], static_cast<char>(val));
+ EXPECT_EQ(int64_t{reader.ReadExponentialGolomb()}, int64_t{test_string[i]});
}
+ EXPECT_TRUE(reader.Ok());
}
TEST(BitBufferWriterTest, WriteClearsBits) {
