Issue 2212

src/ec.rs

@@ -804,17 +804,17 @@ impl<W: io::Write> BCodeWriter for BitWriter<W, BigEndian> {
  }
  }
  fn write_quniform(&mut self, n: u16, v: u16) -> Result<(), std::io::Error> {
- /* Encodes a value v in [0, n-1] quasi-uniformly */
- if n <= 1 {
- return Ok(());
- };
- let l = 31 ^ ((n - 1) + 1).leading_zeros();
- let m = (1 << l) - n;
- if v < m {
- self.write(l - 1, v)
+ if n > 1 {
+ let l = msb(n as i32) as u8 + 1;
+ let m = (1 << l) - n;
+ if v < m {
+ self.write(l as u32 - 1, v)
+ } else {
+ self.write(l as u32 - 1, m + ((v - m) >> 1))?;
+ self.write(1, (v - m) & 1)
+ }
  } else {
- self.write(l - 1, m + ((v - m) >> 1))?;
- self.write_bit(((v - m) & 1) != 0)
+ Ok(())
  }
  }
  fn write_subexpfin(

src/encoder.rs

@@ -604,6 +604,7 @@ impl<T: Pixel> FrameInvariants<T> {
  frame_rate,
  TilingInfo::tile_log2(1, config.tile_cols).unwrap(),
  TilingInfo::tile_log2(1, config.tile_rows).unwrap(),
+ sequence.chroma_sampling == ChromaSampling::Cs422,
  );
 
  if config.tiles > 0 {
@@ -619,6 +620,7 @@ impl<T: Pixel> FrameInvariants<T> {
  frame_rate,
  tile_cols_log2,
  tile_rows_log2,
+ sequence.chroma_sampling == ChromaSampling::Cs422,
  );
 
  if tiling.rows * tiling.cols >= config.tiles {
@@ -2621,7 +2623,6 @@ fn encode_partition_topdown<T: Pixel, W: Writer>(
  let w: &mut W = if cw.bc.cdef_coded { w_post_cdef } else { w_pre_cdef };
  cw.write_partition(w, tile_bo, partition, bsize);
  }
-
  match partition {
  PartitionType::PARTITION_NONE => {
  let part_decision = if !rdo_output.part_modes.is_empty() {

src/header.rs

@@ -12,6 +12,8 @@ use crate::context::*;
 use crate::ec::*;
 use crate::lrf::*;
 use crate::partition::*;
+use crate::tiling::MAX_TILE_WIDTH;
+use crate::util::Fixed;
 use crate::util::Pixel;
 
 use crate::DeblockState;
@@ -670,25 +672,70 @@ impl<W: io::Write> UncompressedHeader for BitWriter<W, BigEndian> {
  self.write_bit(fi.disable_frame_end_update_cdf)?;
  }
 
- // tile <https://aomediacodec.github.io/av1-spec/#tile-info-syntax>
- self.write_bit(true)?; // uniform_tile_spacing_flag
+ // tile
+ // <https://aomediacodec.github.io/av1-spec/#tile-info-syntax>
 
+ // Can we use the uniform spacing tile syntax? 'Uniform spacing'
+ // is a slight misnomer; it's more constrained than just a uniform
+ // spacing.
  let ti = &fi.tiling;
 
- let cols_ones = ti.tile_cols_log2 - ti.min_tile_cols_log2;
- for _ in 0..cols_ones {
- self.write_bit(true);
- }
- if ti.tile_cols_log2 < ti.max_tile_cols_log2 {
- self.write_bit(false);
- }
+ if fi.sb_width.align_power_of_two_and_shift(ti.tile_cols_log2)
+ == ti.tile_width_sb
+ && fi.sb_height.align_power_of_two_and_shift(ti.tile_rows_log2)
+ == ti.tile_height_sb
+ {
+ // yes; our actual tile width/height setting (which is always
+ // currently uniform) also matches the constrained width/height
+ // calculation implicit in the uniform spacing flag.
 
- let rows_ones = ti.tile_rows_log2 - ti.min_tile_rows_log2;
- for _ in 0..rows_ones {
- self.write_bit(true);
- }
- if ti.tile_rows_log2 < ti.max_tile_rows_log2 {
- self.write_bit(false);
+ self.write_bit(true)?; // uniform_tile_spacing_flag
+
+ let cols_ones = ti.tile_cols_log2 - ti.min_tile_cols_log2;
+ for _ in 0..cols_ones {
+ self.write_bit(true);
+ }
+ if ti.tile_cols_log2 < ti.max_tile_cols_log2 {
+ self.write_bit(false);
+ }
+
+ let rows_ones = ti.tile_rows_log2 - ti.min_tile_rows_log2;
+ for _ in 0..rows_ones {
+ self.write_bit(true);
+ }
+ if ti.tile_rows_log2 < ti.max_tile_rows_log2 {
+ self.write_bit(false);
+ }
+ } else {
+ self.write_bit(false)?; // uniform_tile_spacing_flag
+ let mut sofar = 0;
+ let mut widest_tile_sb = 0;
+ for _ in 0..ti.cols {
+ let max = (MAX_TILE_WIDTH
+ >> if fi.sequence.use_128x128_superblock { 7 } else { 6 })
+ .min(fi.sb_width - sofar) as u16;
+ let this_sb_width = ti.tile_width_sb.min(fi.sb_width - sofar);
+ self.write_quniform(max, (this_sb_width - 1) as u16);
+ sofar += this_sb_width;
+ widest_tile_sb = widest_tile_sb.max(this_sb_width);
+ }
+
+ let max_tile_area_sb = if ti.min_tiles_log2 > 0 {
+ (fi.sb_height * fi.sb_width) >> (ti.min_tiles_log2 + 1)
+ } else {
+ fi.sb_height * fi.sb_width
+ };
+
+ let max_tile_height_sb = (max_tile_area_sb / widest_tile_sb).max(1);
+
+ sofar = 0;
+ for i in 0..ti.rows {
+ let max = max_tile_height_sb.min(fi.sb_height - sofar) as u16;
+ let this_sb_height = ti.tile_height_sb.min(fi.sb_height - sofar);
+
+ self.write_quniform(max, (this_sb_height - 1) as u16);
+ sofar += this_sb_height;
+ }
  }
 
  let tiles_log2 = ti.tile_cols_log2 + ti.tile_rows_log2;

src/tiling/tiler.rs

@@ -44,12 +44,14 @@ pub struct TilingInfo {
  pub min_tile_rows_log2: usize,
  pub max_tile_rows_log2: usize,
  pub sb_size_log2: usize,
+ pub min_tiles_log2: usize,
 }
 
 impl TilingInfo {
  pub fn from_target_tiles(
  sb_size_log2: usize, frame_width: usize, frame_height: usize,
  frame_rate: f64, tile_cols_log2: usize, tile_rows_log2: usize,
+ is_422_p: bool,
  ) -> Self {
  // <https://aomediacodec.github.io/av1-spec/#tile-info-syntax>
 
@@ -87,7 +89,26 @@ impl TilingInfo {
 
  let tile_cols_log2 =
  tile_cols_log2.max(min_tile_cols_log2).min(max_tile_cols_log2);
- let tile_width_sb = sb_cols.align_power_of_two_and_shift(tile_cols_log2);
+ let tile_width_sb_pre =
+ sb_cols.align_power_of_two_and_shift(tile_cols_log2);
+
+ // If this is 4:2:2, our UV horizontal is subsampled but not our
+ // vertical. Loop Restoration Units must be square, so they
+ // will always have an even number of horizontal superblocks. For
+ // tiles and LRUs to align, tile_width_sb must be even in 4:2:2
+ // video.
+
+ // This is only relevant when doing loop restoration RDO inline
+ // with block/superblock encoding, that is, where tiles are
+ // relevant. If (when) we introduce optionally delaying loop-filter
+ // encode to after the partitioning loop, we won't need to make
+ // any 4:2:2 adjustment.
+
+ let tile_width_sb = if is_422_p {
+ (tile_width_sb_pre + 1) >> 1 << 1
+ } else {
+ tile_width_sb_pre
+ };
 
  let min_tile_rows_log2 = if min_tiles_log2 > tile_cols_log2 {
  min_tiles_log2 - tile_cols_log2
@@ -123,6 +144,7 @@ impl TilingInfo {
  min_tile_rows_log2,
  max_tile_rows_log2,
  sb_size_log2,
+ min_tiles_log2,
  }
  }
 
@@ -240,6 +262,7 @@ pub mod test {
  frame_rate,
  0,
  0,
+ false,
  );
  assert_eq!(1, ti.cols);
  assert_eq!(1, ti.rows);
@@ -253,6 +276,7 @@ pub mod test {
  frame_rate,
  1,
  1,
+ false,
  );
  assert_eq!(2, ti.cols);
  assert_eq!(2, ti.rows);
@@ -266,6 +290,7 @@ pub mod test {
  frame_rate,
  2,
  2,
+ false,
  );
  assert_eq!(3, ti.cols);
  assert_eq!(3, ti.rows);
@@ -280,6 +305,7 @@ pub mod test {
  frame_rate,
  10,
  8,
+ false,
  );
  assert_eq!(3, ti.cols);
  assert_eq!(3, ti.rows);
@@ -293,6 +319,7 @@ pub mod test {
  frame_rate,
  0,
  0,
+ false,
  );
  assert_eq!(1, ti.cols);
  assert_eq!(1, ti.rows);
@@ -336,6 +363,7 @@ pub mod test {
  frame_rate,
  1,
  1,
+ false,
  );
  let mut iter = ti.tile_iter_mut(&mut fs, &mut fb);
  assert_eq!(4, iter.len());
@@ -359,6 +387,7 @@ pub mod test {
  frame_rate,
  2,
  2,
+ false,
  );
  let mut iter = ti.tile_iter_mut(&mut fs, &mut fb);
  assert_eq!(9, iter.len());
@@ -406,6 +435,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
@@ -484,6 +514,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let tbs = iter.map(|ctx| ctx.tb).collect::<Vec<_>>();
@@ -524,6 +555,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
@@ -588,6 +620,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
@@ -628,6 +661,7 @@ pub mod test {
  fi.config.frame_rate(),
  1,
  1,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
@@ -690,6 +724,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let mut tile_states = iter.map(|ctx| ctx.ts).collect::<Vec<_>>();
@@ -734,6 +769,7 @@ pub mod test {
  fi.config.frame_rate(),
  2,
  2,
+ false,
  );
  let iter = ti.tile_iter_mut(&mut fs, &mut fb);
  let mut tbs = iter.map(|ctx| ctx.tb).collect::<Vec<_>>();