Update bitreader to 0.3.11
Test: m
Change-Id: Ide9f09e58cdfc1c83527f34ca48d639836ac086d
diff --git a/crates/bitreader/.android-checksum.json b/crates/bitreader/.android-checksum.json
new file mode 100644
index 0000000..222cce4
--- /dev/null
+++ b/crates/bitreader/.android-checksum.json
@@ -0,0 +1 @@
+{"package":null,"files":{"LICENSE":"7c6512d88b3127990067585f24881ba1f182c5c49a04cb1975b226b7be95709e","LICENSE-APACHE":"7c6512d88b3127990067585f24881ba1f182c5c49a04cb1975b226b7be95709e","README.md":"4132390002eceea3f7ae494d5f6b5ebb735e8e50ac6b2a84c8c8dac736f09101","LICENSE-MIT":"6e0640d6e8c8ea7519ca4b9213d2e2a5936dd1b89e4d87b7b18f3da7f4ba3559","Android.bp":"34976e79cf0d246007cdbf8989410e3c8e670ca77e1eeae7592bbc60e22c67f2","src/lib.rs":"1b55a3c80386a7615377dd4e8946c09a8c4d83692d4b43f180eb918d1ac81480","src/tests.rs":"04a24ba11b6bd459ffa3952b92d39a82e7bae9696eb5aa882f8b0884faa0cdf0",".cargo-checksum.json":"9d95f2aed716565044671ef2db63fa12c51d32f4d0156ef58faaa3f7770b7194","METADATA":"01a3ad363201e8d50ee5922931c233fb848e6c1ca8096f94a7250e48e8b947dd","MODULE_LICENSE_APACHE2":"0d6f8afa3940b7f06bebee651376d43bc8b0d5b437337be2696d30377451e93a","cargo_embargo.json":"aa45a963da01d3f018be316cd5b7646a5b413ce2611c5218f2914d2e8a9efd0e","Cargo.toml":"59b7e6dd12af6553ba2c00aabf8445e85e2c5f8c2d0c59b8dfb5e5369c9bccbc"}}
\ No newline at end of file
diff --git a/crates/bitreader/.cargo-checksum.json b/crates/bitreader/.cargo-checksum.json
index f9b0812..1355ecc 100644
--- a/crates/bitreader/.cargo-checksum.json
+++ b/crates/bitreader/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"ef90e90a78dd4e4f112eeceaccc0ef89e9e1c8d50a70de81f663b14514022c5c","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"8583712ee2b062ff3d4d6d3e16f19ff0f92bc3a0a4beeec11a81ef00146fbd4f","README.md":"d2ef71107ea5c09290ab5a3ea93d22ba6d6ed6ff241fe1730f9eb7c51e8ed16a","src/lib.rs":"a74d3b987846aac4678d03ae2a74e12a5206d477afe1c2e0eef2a39e893d7132","src/tests.rs":"ae425238f88621b68b5ac4e98d83e53381205dce2fc2c3a02a2de6b4b1f456ce"},"package":"bdd859c9d97f7c468252795b35aeccc412bdbb1e90ee6969c4fa6328272eaeff"}
\ No newline at end of file
+{"files":{"Cargo.toml":"d3b7d64744ccce53e2d785923d185093a13200592b2571ac0240b3a5ebeff359","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"8583712ee2b062ff3d4d6d3e16f19ff0f92bc3a0a4beeec11a81ef00146fbd4f","README.md":"d2ef71107ea5c09290ab5a3ea93d22ba6d6ed6ff241fe1730f9eb7c51e8ed16a","src/lib.rs":"b77b8d02eb72f497e6c4865419e04491b20050c0037a7646da866d72126ee52b","src/tests.rs":"a2b559907dd861748676323273f39c20c05734a11e83112294dc7bbe133cb161"},"package":"886559b1e163d56c765bc3a985febb4eee8009f625244511d8ee3c432e08c066"}
\ No newline at end of file
diff --git a/crates/bitreader/Android.bp b/crates/bitreader/Android.bp
index 4c7c146..32b2614 100644
--- a/crates/bitreader/Android.bp
+++ b/crates/bitreader/Android.bp
@@ -18,7 +18,7 @@
host_supported: true,
crate_name: "bitreader",
cargo_env_compat: true,
- cargo_pkg_version: "0.3.8",
+ cargo_pkg_version: "0.3.11",
crate_root: "src/lib.rs",
edition: "2015",
features: [
diff --git a/crates/bitreader/Cargo.toml b/crates/bitreader/Cargo.toml
index 4ffa549..440d0ea 100644
--- a/crates/bitreader/Cargo.toml
+++ b/crates/bitreader/Cargo.toml
@@ -11,14 +11,19 @@
[package]
name = "bitreader"
-version = "0.3.8"
+version = "0.3.11"
authors = ["Ilkka Rauta <ilkka.rauta@gmail.com>"]
-description = """
+build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = '''
BitReader helps reading individual bits from a slice of bytes.
-You can read \"unusual\" numbers of bits from the byte slice, for example 13 bits
+You can read "unusual" numbers of bits from the byte slice, for example 13 bits
at once. The reader internally keeps track of position within the buffer.
-"""
+'''
homepage = "https://github.com/irauta/bitreader"
documentation = "https://docs.rs/bitreader"
readme = "README.md"
@@ -30,6 +35,10 @@
license = "MIT OR Apache-2.0"
repository = "https://github.com/irauta/bitreader"
+[lib]
+name = "bitreader"
+path = "src/lib.rs"
+
[dependencies.cfg-if]
version = "1"
diff --git a/crates/bitreader/METADATA b/crates/bitreader/METADATA
index b7dbcdd..c9af4b0 100644
--- a/crates/bitreader/METADATA
+++ b/crates/bitreader/METADATA
@@ -1,17 +1,17 @@
name: "bitreader"
description: "BitReader helps reading individual bits from a slice of bytes. You can read \"unusual\" numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer."
third_party {
- version: "0.3.8"
+ version: "0.3.11"
license_type: NOTICE
last_upgrade_date {
year: 2024
- month: 1
- day: 31
+ month: 12
+ day: 19
}
homepage: "https://crates.io/crates/bitreader"
identifier {
type: "Archive"
- value: "https://static.crates.io/crates/bitreader/bitreader-0.3.8.crate"
- version: "0.3.8"
+ value: "https://static.crates.io/crates/bitreader/bitreader-0.3.11.crate"
+ version: "0.3.11"
}
}
diff --git a/crates/bitreader/src/lib.rs b/crates/bitreader/src/lib.rs
index e62571a..f06b754 100644
--- a/crates/bitreader/src/lib.rs
+++ b/crates/bitreader/src/lib.rs
@@ -79,6 +79,7 @@
impl<'a> BitReader<'a> {
/// Construct a new BitReader from a byte slice. The returned reader lives at most as long as
/// the slice given to is valid.
+ #[inline]
pub fn new(bytes: &'a [u8]) -> BitReader<'a> {
BitReader {
bytes: bytes,
@@ -110,18 +111,19 @@
/// assert_eq!(original.position(), 12);
/// assert_eq!(relative.position(), 8);
/// ```
+ #[inline]
pub fn relative_reader(&self) -> BitReader<'a> {
BitReader {
bytes: self.bytes,
position: self.position,
relative_offset: self.position,
- length: self.length - self.position,
+ length: self.length - self.position(),
}
}
/// Returns a copy of current BitReader, with the difference that its position() returns
/// positions relative to the position of the original BitReader at the construction time, and
- /// will not allow reading more than len bits. After construction, both readers are otherwise
+ /// will not allow reading more than len bits. After construction, both readers are otherwise
// completely independent, except of course for sharing the same source data.
///
/// ```
@@ -148,22 +150,25 @@
/// requested: 8
/// });
/// ```
+ #[inline]
pub fn relative_reader_atmost(&self, len: u64) -> BitReader<'a> {
BitReader {
bytes: self.bytes,
position: self.position,
relative_offset: self.position,
- length: min(self.length - self.position, len),
+ length: min(self.length - self.position(), len),
}
}
/// Read at most 8 bits into a u8.
+ #[inline]
pub fn read_u8(&mut self, bit_count: u8) -> Result<u8> {
let value = self.read_value(bit_count, 8)?;
Ok((value & 0xff) as u8)
}
/// Read at most 8 bits into a u8, but without moving the cursor forward.
+ #[inline]
pub fn peek_u8(&self, bit_count: u8) -> Result<u8> {
self.relative_reader().read_u8(bit_count)
}
@@ -188,40 +193,47 @@
}
/// Read at most 16 bits into a u16.
+ #[inline]
pub fn read_u16(&mut self, bit_count: u8) -> Result<u16> {
let value = self.read_value(bit_count, 16)?;
Ok((value & 0xffff) as u16)
}
/// Read at most 16 bits into a u16, but without moving the cursor forward.
+ #[inline]
pub fn peek_u16(&self, bit_count: u8) -> Result<u16> {
self.relative_reader().read_u16(bit_count)
}
/// Read at most 32 bits into a u32.
+ #[inline]
pub fn read_u32(&mut self, bit_count: u8) -> Result<u32> {
let value = self.read_value(bit_count, 32)?;
Ok((value & 0xffffffff) as u32)
}
/// Read at most 32 bits into a u32, but without moving the cursor forward.
+ #[inline]
pub fn peek_u32(&self, bit_count: u8) -> Result<u32> {
self.relative_reader().read_u32(bit_count)
}
/// Read at most 64 bits into a u64.
+ #[inline]
pub fn read_u64(&mut self, bit_count: u8) -> Result<u64> {
let value = self.read_value(bit_count, 64)?;
Ok(value)
}
/// Read at most 64 bits into a u64, but without moving the cursor forward.
+ #[inline]
pub fn peek_u64(&self, bit_count: u8) -> Result<u64> {
self.relative_reader().read_u64(bit_count)
}
/// Read at most 8 bits into a i8.
/// Assumes the bits are stored in two's complement format.
+ #[inline]
pub fn read_i8(&mut self, bit_count: u8) -> Result<i8> {
let value = self.read_signed_value(bit_count, 8)?;
Ok((value & 0xff) as i8)
@@ -229,6 +241,7 @@
/// Read at most 16 bits into a i16.
/// Assumes the bits are stored in two's complement format.
+ #[inline]
pub fn read_i16(&mut self, bit_count: u8) -> Result<i16> {
let value = self.read_signed_value(bit_count, 16)?;
Ok((value & 0xffff) as i16)
@@ -236,6 +249,7 @@
/// Read at most 32 bits into a i32.
/// Assumes the bits are stored in two's complement format.
+ #[inline]
pub fn read_i32(&mut self, bit_count: u8) -> Result<i32> {
let value = self.read_signed_value(bit_count, 32)?;
Ok((value & 0xffffffff) as i32)
@@ -243,6 +257,7 @@
/// Read at most 64 bits into a i64.
/// Assumes the bits are stored in two's complement format.
+ #[inline]
pub fn read_i64(&mut self, bit_count: u8) -> Result<i64> {
let value = self.read_signed_value(bit_count, 64)?;
Ok(value)
@@ -250,6 +265,7 @@
/// Read a single bit as a boolean value.
/// Interprets 1 as true and 0 as false.
+ #[inline]
pub fn read_bool(&mut self) -> Result<bool> {
match self.read_value(1, 1)? {
0 => Ok(false),
@@ -259,6 +275,7 @@
/// Read a single bit as a boolean value, but without moving the cursor forward.
/// Interprets 1 as true and 0 as false.
+ #[inline]
pub fn peek_bool(&self) -> Result<bool> {
self.relative_reader().read_bool()
}
@@ -278,13 +295,15 @@
}
/// Returns the position of the cursor, or how many bits have been read so far.
+ #[inline]
pub fn position(&self) -> u64 {
self.position - self.relative_offset
}
/// Returns the number of bits not yet read from the underlying slice.
+ #[inline]
pub fn remaining(&self) -> u64 {
- self.length - self.position
+ self.length - self.position()
}
/// Helper to make sure the "bit cursor" is exactly at the beginning of a byte, or at specific
@@ -297,6 +316,7 @@
/// This function can be used to validate the data is being read properly, for example by
/// adding invocations wrapped into `debug_assert!()` to places where it is known the data
/// should be n-byte aligned.
+ #[inline]
pub fn is_aligned(&self, alignment_bytes: u32) -> bool {
self.position % (alignment_bytes as u64 * 8) == 0
}
@@ -313,6 +333,7 @@
self.skip(bits_to_skip)
}
+ #[inline]
fn read_signed_value(&mut self, bit_count: u8, maximum_count: u8) -> Result<i64> {
if bit_count == 0 {
return Ok(0);
@@ -329,17 +350,28 @@
Ok(high_bits << bit_count | unsigned as i64)
}
+ #[cold]
+ fn too_many_bits_for_type_error(&self, bit_count: u8, maximum_count: u8) -> Result<u64> {
+ Err(BitReaderError::TooManyBitsForType {
+ position: self.position,
+ requested: bit_count,
+ allowed: maximum_count,
+ })
+ }
+
+ #[inline]
+ // Inlining allows the size checks to be eliminated for constant values
fn read_value(&mut self, bit_count: u8, maximum_count: u8) -> Result<u64> {
if bit_count == 0 {
return Ok(0);
}
if bit_count > maximum_count {
- return Err(BitReaderError::TooManyBitsForType {
- position: self.position,
- requested: bit_count,
- allowed: maximum_count,
- });
+ return self.too_many_bits_for_type_error(bit_count, maximum_count);
}
+ self.read_bits(bit_count)
+ }
+
+ fn read_bits(&mut self, bit_count: u8) -> Result<u64> {
let start_position = self.position;
let end_position = self.position + bit_count as u64;
if end_position > (self.relative_offset + self.length) {
@@ -354,7 +386,12 @@
for i in start_position..end_position {
let byte_index = (i / 8) as usize;
- let byte = self.bytes[byte_index];
+ // This will never fail, but prevents Rust from generating panic code
+ let byte = if let Some(byte) = self.bytes.get(byte_index).copied() {
+ byte
+ } else {
+ break;
+ };
let shift = 7 - (i % 8);
let bit = (byte >> shift) as u64 & 1;
value = (value << 1) | bit;
diff --git a/crates/bitreader/src/tests.rs b/crates/bitreader/src/tests.rs
index 452070a..3406ff0 100644
--- a/crates/bitreader/src/tests.rs
+++ b/crates/bitreader/src/tests.rs
@@ -329,3 +329,25 @@
let mut reader = BitReader::new(bytes);
assert_eq!(reader.read_i64(64).unwrap(), -1);
}
+
+#[test]
+fn relative_reader_remaining() {
+ let bytes = &[0b0001_0010, 0b0011_0100];
+ let mut reader = BitReader::new(bytes);
+ reader.skip(2).unwrap();
+ let relative_reader = reader.relative_reader();
+ assert_eq!(reader.remaining(), 14);
+ assert_eq!(relative_reader.remaining(), 14);
+}
+
+#[test]
+fn make_relate_reader_twice() {
+ let bytes = &[0b0011_0100, 0b0011_0100];
+ let mut reader = BitReader::new(bytes);
+ reader.skip(9).unwrap();
+ let relate_reader_a = reader.relative_reader();
+ let relate_reader_b = relate_reader_a.relative_reader();
+ assert_eq!(relate_reader_a.position(), 0);
+ assert_eq!(relate_reader_b.position(), 0);
+ assert_eq!(relate_reader_a.position, relate_reader_b.position);
+}
diff --git a/pseudo_crate/Cargo.lock b/pseudo_crate/Cargo.lock
index db8ce15..60b10d2 100644
--- a/pseudo_crate/Cargo.lock
+++ b/pseudo_crate/Cargo.lock
@@ -934,9 +934,9 @@
[[package]]
name = "bitreader"
-version = "0.3.8"
+version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdd859c9d97f7c468252795b35aeccc412bdbb1e90ee6969c4fa6328272eaeff"
+checksum = "886559b1e163d56c765bc3a985febb4eee8009f625244511d8ee3c432e08c066"
dependencies = [
"cfg-if",
]
diff --git a/pseudo_crate/Cargo.toml b/pseudo_crate/Cargo.toml
index 4782645..a6c5ba8 100644
--- a/pseudo_crate/Cargo.toml
+++ b/pseudo_crate/Cargo.toml
@@ -38,7 +38,7 @@
bindgen-cli = "=0.69.5"
bit_field = "=0.10.2"
bitflags = "=2.6.0"
-bitreader = "=0.3.8"
+bitreader = "=0.3.11"
bstr = "=1.3.0"
buddy_system_allocator = "=0.11.0"
bytemuck = "=1.19.0"
