Add Fpaq0: arithmetic encoder that does not require carry and can be run in parallel

benches/benches.rs

@@ -1,7 +1,8 @@
 use cabac::perf::{
-    h265_get_pattern, h265_get_pattern_bypass, h265_put_pattern, h265_put_pattern_bypass,
-    rans32_get_pattern, rans32_get_pattern_bypass, rans32_put_pattern, rans32_put_pattern_bypass,
-    vp8_get_pattern, vp8_get_pattern_bypass, vp8_put_pattern, vp8_put_pattern_bypass,
+    fpaq_get_pattern, fpaq_put_pattern, h265_get_pattern, h265_get_pattern_bypass,
+    h265_put_pattern, h265_put_pattern_bypass, rans32_get_pattern, rans32_get_pattern_bypass,
+    rans32_put_pattern, rans32_put_pattern_bypass, vp8_get_pattern, vp8_get_pattern_bypass,
+    vp8_put_pattern, vp8_put_pattern_bypass,
 };
 
 use criterion::{criterion_group, criterion_main, Criterion};
@@ -15,6 +16,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     let rans_pattern = rans32_put_pattern(&pattern);
     let vp8_pattern = vp8_put_pattern(&pattern);
     let h265_pattern = h265_put_pattern(&pattern);
+    let fpaq_pattern = fpaq_put_pattern(&pattern);
 
     let rans_pattern_bypass = rans32_put_pattern_bypass(&pattern);
     let vp8_pattern_bypass = vp8_put_pattern_bypass(&pattern);
@@ -56,6 +58,18 @@ fn criterion_benchmark(c: &mut Criterion) {
         })
     });
 
+    c.bench_function("Fpaq write", |b| {
+        b.iter(|| {
+            fpaq_put_pattern(&pattern);
+        })
+    });
+
+    c.bench_function("Fpaq read", |b| {
+        b.iter(|| {
+            fpaq_get_pattern(&pattern, &fpaq_pattern);
+        })
+    });
+
     c.bench_function("H265 read", |b| {
         b.iter(|| {
             h265_get_pattern(&pattern, &h265_pattern);

src/fpaq0.rs

@@ -0,0 +1,147 @@
+use crate::{
+    traits::{CabacReader, CabacWriter, GetInnerBuffer},
+    vp8::VP8Context,
+};
+use std::io::{Read, Result, Write};
+
+pub struct Fpaq0Decoder<R> {
+    inner_reader: R,
+    xl: u32,
+    xr: u32,
+    x: u32,
+}
+
+impl<R: Read> Fpaq0Decoder<R> {
+    pub fn new(mut reader: R) -> Result<Self> {
+        let mut x: u32 = 0;
+        for _ in 0..4 {
+            let mut b = [0u8];
+            let _ = reader.read(&mut b)?;
+
+            x = (x << 8) | u32::from(b[0]);
+        }
+
+        Ok(Fpaq0Decoder {
+            inner_reader: reader,
+            xl: 0,
+            xr: 0xffff_ffff,
+            x,
+        })
+    }
+
+    fn fill_bits(&mut self) -> Result<()> {
+        while 0 == ((self.xl ^ self.xr) & 0xFF00_0000) {
+            self.xl <<= 8;
+            self.xr = (self.xr << 8) | 0x0000_00FF;
+
+            let mut b = [0u8];
+            let _ = self.inner_reader.read(&mut b)?;
+
+            self.x = (self.x << 8) | u32::from(b[0]);
+        }
+        Ok(())
+    }
+}
+
+impl<R: Read> CabacReader<VP8Context> for Fpaq0Decoder<R> {
+    fn get_bypass(&mut self) -> Result<bool> {
+        let xm = self.xl + (((self.xr - self.xl) & 0xffffff00) >> 1);
+        let mut bit = true;
+        if self.x <= xm {
+            bit = false;
+            self.xr = xm;
+        } else {
+            self.xl = xm + 1;
+        }
+
+        self.fill_bits()?;
+
+        Ok(bit)
+    }
+
+    fn get(&mut self, cur_ctx: &mut VP8Context) -> Result<bool> {
+        let xm = self.xl + ((self.xr - self.xl) >> 8) * u32::from(cur_ctx.get_probability().get());
+        let mut bit = true;
+        if self.x <= xm {
+            bit = false;
+            self.xr = xm;
+        } else {
+            self.xl = xm + 1;
+        }
+
+        cur_ctx.record_and_update_bit(bit);
+
+        self.fill_bits()?;
+
+        Ok(bit)
+    }
+}
+
+pub struct Fpaq0Encoder<W> {
+    inner_writer: W,
+    xl: u32,
+    xr: u32,
+}
+
+impl GetInnerBuffer for Fpaq0Encoder<Vec<u8>> {
+    fn inner_buffer(&self) -> &[u8] {
+        &self.inner_writer
+    }
+}
+
+impl<W: Write> Fpaq0Encoder<W> {
+    pub fn new(writer: W) -> Self {
+        Fpaq0Encoder {
+            inner_writer: writer,
+            xl: 0,
+            xr: 0xffff_ffff,
+        }
+    }
+
+    fn flush_bits(&mut self) -> Result<()> {
+        while 0 == ((self.xl ^ self.xr) & 0xFF00_0000) {
+            let byte = (self.xr >> 24) as u8;
+            self.inner_writer.write_all(&[byte])?;
+            self.xl <<= 8;
+            self.xr = (self.xr << 8) | 0x0000_00FF;
+        }
+        Ok(())
+    }
+}
+
+impl<W: Write> CabacWriter<VP8Context> for Fpaq0Encoder<W> {
+    fn put(&mut self, bit: bool, branch: &mut VP8Context) -> Result<()> {
+        let xm = self.xl + ((self.xr - self.xl) >> 8) * u32::from(branch.get_probability().get());
+
+        // left/lower part of the interval corresponds to zero
+
+        if !bit {
+            self.xr = xm;
+        } else {
+            self.xl = xm + 1;
+        }
+
+        branch.record_and_update_bit(bit);
+
+        self.flush_bits()
+    }
+
+    fn put_bypass(&mut self, bit: bool) -> Result<()> {
+        let xm = self.xl + (((self.xr - self.xl) & 0xffffff00) >> 1);
+
+        // left/lower part of the interval corresponds to zero
+
+        if !bit {
+            self.xr = xm;
+        } else {
+            self.xl = xm + 1;
+        }
+
+        self.flush_bits()
+    }
+
+    fn finish(&mut self) -> Result<()> {
+        let byte = (self.xr >> 24) as u8;
+        self.inner_writer.write_all(&[byte])
+    }
+}