refactor(h264,hevc): reduce parameter counts (S107)

Group geometry/size/weight parameters into tuples and a PbGeom struct.

crates/av1/src/decoder.rs

@@ -405,35 +405,49 @@ impl Decoder {
         r
     }
 
-    /// Whether an OBU belongs to the selected operating point (spec 7.5: OBUs of other layers are dropped).
-    fn in_operating_point(&self, obu: &ObuUnit) -> bool {
-        if obu.obu_type != OBU_SEQUENCE_HEADER_T
-            && obu.obu_type != OBU_TEMPORAL_DELIMITER_T
-            && obu.ext
-            && let Some(seq) = &self.seq
-            && seq.op_idc != 0
-        {
-            let idc = seq.op_idc;
-            let in_t = (idc >> obu.temporal_id) & 1;
-            let in_s = (idc >> (obu.spatial_id + 8)) & 1;
-            if in_t == 0 || in_s == 0 {
-                return false;
-            }
-        }
-        true
-    }
-
     fn parse_obus(&mut self, data: &[u8], out: &mut Vec<(Output, usize, u32)>) -> Result<()> {
         let mut tu = 0usize;
         let mut pos = 0;
         while pos < data.len() {
-            let obu = parse_obu_unit(data, pos)?;
-            pos = obu.end;
-            if !self.in_operating_point(&obu) {
-                continue;
+            let h = data[pos];
+            if h & 0x80 != 0 {
+                return Err(Error::Invalid("obu_forbidden_bit"));
             }
-            let (payload, spatial_id) = (obu.payload, obu.spatial_id);
-            match obu.obu_type {
+            let obu_type = ((h >> 3) & 0xf) as u32;
+            let ext = h & 4 != 0;
+            let has_size = h & 2 != 0;
+            let mut p = pos + 1;
+            let (mut temporal_id, mut spatial_id) = (0, 0);
+            if ext {
+                let e = *data.get(p).ok_or(Error::Truncated)?;
+                temporal_id = (e >> 5) as u32;
+                spatial_id = ((e >> 3) & 3) as u32;
+                p += 1;
+            }
+            let size = if has_size {
+                let (v, n) = leb128(data.get(p..).ok_or(Error::Truncated)?)?;
+                p += n;
+                v as usize
+            } else {
+                data.len().checked_sub(p).ok_or(Error::Truncated)?
+            };
+            let end = p.checked_add(size).filter(|&e| e <= data.len()).ok_or(Error::Truncated)?;
+            let payload = &data[p..end];
+            pos = end;
+            if obu_type != OBU_SEQUENCE_HEADER_T
+                && obu_type != OBU_TEMPORAL_DELIMITER_T
+                && ext
+                && let Some(seq) = &self.seq
+                && seq.op_idc != 0
+            {
+                let idc = seq.op_idc;
+                let in_t = (idc >> temporal_id) & 1;
+                let in_s = (idc >> (spatial_id + 8)) & 1;
+                if in_t == 0 || in_s == 0 {
+                    continue;
+                }
+            }
+            match obu_type {
                 OBU_SEQUENCE_HEADER_T => {
                     let s = SequenceHeader::parse(payload)?;
                     self.seq = Some(s);
@@ -443,11 +457,27 @@ impl Decoder {
                     tu += 1;
                 }
                 OBU_FRAME_HEADER_T | OBU_REDUNDANT_FRAME_HEADER_T | OBU_FRAME_T => {
-                    if let Some(o) = self.frame_obu(&obu)? {
+                    if self.seen_frame_header {
+                        // frame_header_copy(): identical to the active header
+                        if obu_type != OBU_FRAME_T {
+                            continue;
+                        }
+                    }
+                    let mut r = BitReader::new(payload);
+                    let shown = self.frame_header(&mut r, temporal_id, spatial_id)?;
+                    if let Some(o) = shown {
                         if out.iter().filter(|(o, _, _)| matches!(o, Output::Existing { .. })).count() >= 32 {
                             return Err(Error::Invalid("too many frame outputs in chunk"));
                         }
                         out.push((o, tu, spatial_id));
+                        continue;
+                    }
+                    if obu_type == OBU_FRAME_T {
+                        r.byte_align();
+                        let rest = payload.get(r.byte_pos()..).ok_or(Error::Truncated)?;
+                        if let Some(o) = self.tile_group(rest)? {
+                            out.push((o, tu, spatial_id));
+                        }
                     }
                 }
                 OBU_TILE_GROUP_T => {
@@ -462,22 +492,6 @@ impl Decoder {
         Ok(())
     }
 
-    /// A frame header or frame OBU: returns the picture it completes, if any.
-    fn frame_obu(&mut self, obu: &ObuUnit) -> Result<Option<Output>> {
-        // frame_header_copy(): identical to the active header
-        if self.seen_frame_header && obu.obu_type != OBU_FRAME_T {
-            return Ok(None);
-        }
-        let mut r = BitReader::new(obu.payload);
-        let shown = self.frame_header(&mut r, obu.temporal_id, obu.spatial_id)?;
-        if shown.is_some() || obu.obu_type != OBU_FRAME_T {
-            return Ok(shown);
-        }
-        r.byte_align();
-        let rest = obu.payload.get(r.byte_pos()..).ok_or(Error::Truncated)?;
-        self.tile_group(rest)
-    }
-
     /// frame_header_obu( ): returns the output for show_existing_frame.
     fn frame_header(&mut self, r: &mut BitReader, temporal_id: u32, spatial_id: u32) -> Result<Option<Output>> {
         let seq = self.seq.clone().ok_or(Error::Invalid("frame before sequence header"))?;
@@ -1003,43 +1017,6 @@ mod tests {
     }
 }
 
-/// One OBU: its header fields, payload and the position just past it.
-struct ObuUnit<'a> {
-    obu_type: u32,
-    ext: bool,
-    temporal_id: u32,
-    spatial_id: u32,
-    payload: &'a [u8],
-    end: usize,
-}
-
-fn parse_obu_unit(data: &[u8], pos: usize) -> Result<ObuUnit<'_>> {
-    let h = data[pos];
-    if h & 0x80 != 0 {
-        return Err(Error::Invalid("obu_forbidden_bit"));
-    }
-    let obu_type = ((h >> 3) & 0xf) as u32;
-    let ext = h & 4 != 0;
-    let has_size = h & 2 != 0;
-    let mut p = pos + 1;
-    let (mut temporal_id, mut spatial_id) = (0, 0);
-    if ext {
-        let e = *data.get(p).ok_or(Error::Truncated)?;
-        temporal_id = (e >> 5) as u32;
-        spatial_id = ((e >> 3) & 3) as u32;
-        p += 1;
-    }
-    let size = if has_size {
-        let (v, n) = leb128(data.get(p..).ok_or(Error::Truncated)?)?;
-        p += n;
-        v as usize
-    } else {
-        data.len().checked_sub(p).ok_or(Error::Truncated)?
-    };
-    let end = p.checked_add(size).filter(|&e| e <= data.len()).ok_or(Error::Truncated)?;
-    Ok(ObuUnit { obu_type, ext, temporal_id, spatial_id, payload: &data[p..end], end })
-}
-
 #[cfg(test)]
 mod guard_tests {
     use super::*;

crates/av1/src/grain.rs

@@ -55,79 +55,21 @@ impl Rng {
     }
 }
 
-/// Picture-level parameters shared by the grain synthesis stages.
-struct GrainCtx<'a> {
-    g: &'a FilmGrainParams,
-    bd: u32,
-    mono: bool,
-    sub_x: usize,
-    sub_y: usize,
-    w: usize,
-    h: usize,
-    grain_min: i32,
-    grain_max: i32,
-}
+pub(crate) fn apply(pic: &mut Picture, g: &FilmGrainParams, seq: &SequenceHeader) {
+    let _ = seq;
+    let bd = pic.bit_depth as u32;
+    let mono = pic.mono_chrome;
+    let num_planes = if mono { 1 } else { 3 };
+    let (sub_x, sub_y) = (pic.subsampling_x as usize, pic.subsampling_y as usize);
+    let w = pic.width as usize;
+    let h = pic.height as usize;
+    let grain_center = 128i32 << (bd - 8);
+    let grain_min = -grain_center;
+    let grain_max = (256i32 << (bd - 8)) - 1 - grain_center;
 
-impl GrainCtx<'_> {
-    fn num_planes(&self) -> usize {
-        if self.mono { 1 } else { 3 }
-    }
-
-    fn grain_shift(&self) -> u32 {
-        12 - self.bd + self.g.grain_scale_shift
-    }
-
-    fn ar_shift(&self) -> u32 {
-        self.g.ar_coeff_shift_minus_6 + 6
-    }
-
-    fn lag(&self) -> i32 {
-        self.g.ar_coeff_lag as i32
-    }
-
-    fn stripe_w(&self) -> usize {
-        self.w + 64
-    }
-}
-
-type GrainTemplate = Vec<[i32; 82]>;
-
-/// The luma, Cb and Cr grain templates (7.18.3.3).
-struct Templates {
-    luma: GrainTemplate,
-    cb: GrainTemplate,
-    cr: GrainTemplate,
-}
-
-impl Templates {
-    fn plane(&self, plane: usize) -> &GrainTemplate {
-        match plane {
-            0 => &self.luma,
-            1 => &self.cb,
-            _ => &self.cr,
-        }
-    }
-}
-
-fn luma_ar_sum(g: &FilmGrainParams, luma: &[[i32; 82]], lag: i32, y: usize, x: usize) -> i32 {
-    let mut s = 0;
-    let mut pos = 0;
-    'outer: for dr in -lag..=0 {
-        for dc in -lag..=lag {
-            if dr == 0 && dc == 0 {
-                break 'outer;
-            }
-            let c = g.ar_coeffs_y_plus_128[pos] as i32 - 128;
-            s += luma[(y as i32 + dr) as usize][(x as i32 + dc) as usize] * c;
-            pos += 1;
-        }
-    }
-    s
-}
-
-fn luma_grain(c: &GrainCtx, rng: &mut Rng) -> GrainTemplate {
-    let g = c.g;
-    let shift = c.grain_shift();
+    // Generate grain (7.18.3.3).
+    let mut rng = Rng(g.grain_seed);
+    let shift = 12 - bd + g.grain_scale_shift;
     let mut luma = vec![[0i32; 82]; 73];
     for row in luma.iter_mut() {
         for v in row.iter_mut() {
@@ -135,89 +77,77 @@ fn luma_grain(c: &GrainCtx, rng: &mut Rng) -> GrainTemplate {
             *v = round2(gv, shift);
         }
     }
-    let ar_shift = c.ar_shift();
-    let lag = c.lag();
+    let ar_shift = g.ar_coeff_shift_minus_6 + 6;
+    let lag = g.ar_coeff_lag as i32;
     for y in 3..73 {
         for x in 3..82 - 3 {
-            let s = luma_ar_sum(g, &luma, lag, y, x);
-            luma[y][x] = (luma[y][x] + round2(s, ar_shift)).clamp(c.grain_min, c.grain_max);
-        }
-    }
-    luma
-}
-
-/// The luma contribution to the chroma autoregressive filter at chroma position (y, x).
-fn chroma_luma_term(c: &GrainCtx, luma: &[[i32; 82]], y: usize, x: usize) -> i32 {
-    let mut l = 0;
-    let lx = ((x - 3) << c.sub_x) + 3;
-    let ly = ((y - 3) << c.sub_y) + 3;
-    for i in 0..=c.sub_y {
-        for j in 0..=c.sub_x {
-            l += luma[ly + i][lx + j];
-        }
-    }
-    round2(l, (c.sub_x + c.sub_y) as u32)
-}
-
-fn chroma_ar_sums(c: &GrainCtx, t: &Templates, y: usize, x: usize) -> (i32, i32) {
-    let g = c.g;
-    let lag = c.lag();
-    let mut s0 = 0;
-    let mut s1 = 0;
-    let mut pos = 0;
-    'outer: for dr in -lag..=0 {
-        for dc in -lag..=lag {
-            let c0 = g.ar_coeffs_cb_plus_128[pos] as i32 - 128;
-            let c1 = g.ar_coeffs_cr_plus_128[pos] as i32 - 128;
-            if dr == 0 && dc == 0 {
-                if g.num_y_points > 0 {
-                    let l = chroma_luma_term(c, &t.luma, y, x);
-                    s0 += l * c0;
-                    s1 += l * c1;
+            let mut s = 0;
+            let mut pos = 0;
+            'outer: for dr in -lag..=0 {
+                for dc in -lag..=lag {
+                    if dr == 0 && dc == 0 {
+                        break 'outer;
+                    }
+                    let c = g.ar_coeffs_y_plus_128[pos] as i32 - 128;
+                    s += luma[(y as i32 + dr) as usize][(x as i32 + dc) as usize] * c;
+                    pos += 1;
                 }
-                break 'outer;
             }
-            let (yy, xx) = ((y as i32 + dr) as usize, (x as i32 + dc) as usize);
-            s0 += t.cb[yy][xx] * c0;
-            s1 += t.cr[yy][xx] * c1;
-            pos += 1;
+            luma[y][x] = (luma[y][x] + round2(s, ar_shift)).clamp(grain_min, grain_max);
         }
     }
-    (s0, s1)
-}
-
-/// Chroma grain templates; zero for monochrome pictures.
-fn chroma_grain(c: &GrainCtx, rng: &mut Rng, luma: GrainTemplate) -> Templates {
-    let g = c.g;
-    let mut t = Templates { luma, cb: vec![[0i32; 82]; 73], cr: vec![[0i32; 82]; 73] };
-    if c.mono {
-        return t;
-    }
-    let shift = c.grain_shift();
-    let ar_shift = c.ar_shift();
-    let chroma_w = if c.sub_x != 0 { 44 } else { 82 };
-    let chroma_h = if c.sub_y != 0 { 38 } else { 73 };
-    for (arr, seed, on) in [(&mut t.cb, 0xb524u32, g.num_cb_points > 0), (&mut t.cr, 0x49d8, g.num_cr_points > 0)] {
-        rng.0 = g.grain_seed ^ seed;
-        for row in arr.iter_mut().take(chroma_h) {
-            for v in row.iter_mut().take(chroma_w) {
-                let gv = if on || g.chroma_scaling_from_luma { GAUSSIAN_SEQUENCE[rng.next(11) as usize] as i32 } else { 0 };
-                *v = round2(gv, shift);
+    let chroma_w = if sub_x != 0 { 44 } else { 82 };
+    let chroma_h = if sub_y != 0 { 38 } else { 73 };
+    let mut cb = vec![[0i32; 82]; 73];
+    let mut cr = vec![[0i32; 82]; 73];
+    if !mono {
+        for (arr, seed, on) in [(&mut cb, 0xb524u32, g.num_cb_points > 0), (&mut cr, 0x49d8, g.num_cr_points > 0)] {
+            rng.0 = g.grain_seed ^ seed;
+            for row in arr.iter_mut().take(chroma_h) {
+                for v in row.iter_mut().take(chroma_w) {
+                    let gv = if on || g.chroma_scaling_from_luma { GAUSSIAN_SEQUENCE[rng.next(11) as usize] as i32 } else { 0 };
+                    *v = round2(gv, shift);
+                }
+            }
+        }
+        for y in 3..chroma_h {
+            for x in 3..chroma_w - 3 {
+                let mut s0 = 0;
+                let mut s1 = 0;
+                let mut pos = 0;
+                'outer: for dr in -lag..=0 {
+                    for dc in -lag..=lag {
+                        let c0 = g.ar_coeffs_cb_plus_128[pos] as i32 - 128;
+                        let c1 = g.ar_coeffs_cr_plus_128[pos] as i32 - 128;
+                        if dr == 0 && dc == 0 {
+                            if g.num_y_points > 0 {
+                                let mut l = 0;
+                                let lx = ((x - 3) << sub_x) + 3;
+                                let ly = ((y - 3) << sub_y) + 3;
+                                for i in 0..=sub_y {
+                                    for j in 0..=sub_x {
+                                        l += luma[ly + i][lx + j];
+                                    }
+                                }
+                                let l = round2(l, (sub_x + sub_y) as u32);
+                                s0 += l * c0;
+                                s1 += l * c1;
+                            }
+                            break 'outer;
+                        }
+                        let (yy, xx) = ((y as i32 + dr) as usize, (x as i32 + dc) as usize);
+                        s0 += cb[yy][xx] * c0;
+                        s1 += cr[yy][xx] * c1;
+                        pos += 1;
+                    }
+                }
+                cb[y][x] = (cb[y][x] + round2(s0, ar_shift)).clamp(grain_min, grain_max);
+                cr[y][x] = (cr[y][x] + round2(s1, ar_shift)).clamp(grain_min, grain_max);
             }
         }
     }
-    for y in 3..chroma_h {
-        for x in 3..chroma_w - 3 {
-            let (s0, s1) = chroma_ar_sums(c, &t, y, x);
-            t.cb[y][x] = (t.cb[y][x] + round2(s0, ar_shift)).clamp(c.grain_min, c.grain_max);
-            t.cr[y][x] = (t.cr[y][x] + round2(s1, ar_shift)).clamp(c.grain_min, c.grain_max);
-        }
-    }
-    t
-}
 
-/// Scaling lookup tables (7.18.3.4), one per plane.
-fn scaling_luts(g: &FilmGrainParams, num_planes: usize) -> [[i32; 256]; 3] {
+    // Scaling lookup (7.18.3.4).
     let mut lut = [[0i32; 256]; 3];
     for (plane, l) in lut.iter_mut().enumerate().take(num_planes) {
         let (n, xs, ys) = if plane == 0 || g.chroma_scaling_from_luma {
@@ -229,141 +159,101 @@ fn scaling_luts(g: &FilmGrainParams, num_planes: usize) -> [[i32; 256]; 3] {
         };
         *l = scaling_lut(n, xs, ys);
     }
-    lut
-}
+    let scale_lut = |plane: usize, index: i32| -> i32 {
+        let sh = bd - 8;
+        let x = index >> sh;
+        let rem = index - (x << sh);
+        if bd == 8 || x == 255 {
+            lut[plane][x as usize]
+        } else {
+            let start = lut[plane][x as usize];
+            let end = lut[plane][x as usize + 1];
+            start + round2((end - start) * rem, sh)
+        }
+    };
 
-fn scale_lookup(lut: &[[i32; 256]; 3], bd: u32, plane: usize, index: i32) -> i32 {
-    let sh = bd - 8;
-    let x = index >> sh;
-    let rem = index - (x << sh);
-    if bd == 8 || x == 255 {
-        lut[plane][x as usize]
-    } else {
-        let start = lut[plane][x as usize];
-        let end = lut[plane][x as usize + 1];
-        start + round2((end - start) * rem, sh)
-    }
-}
-
-/// Fills one plane of a noise stripe from the grain template at stripe column `x`.
-fn fill_stripe_plane(c: &GrainCtx, src: &GrainTemplate, s: &mut [i32], plane: usize, offsets: (usize, usize), x: usize) {
-    let (off_x, off_y) = offsets;
-    let stripe_w = c.stripe_w();
-    let overlap = c.g.overlap_flag;
-    let psx = if plane > 0 { c.sub_x } else { 0 };
-    let psy = if plane > 0 { c.sub_y } else { 0 };
-    let pox = if psx != 0 { 6 + off_x } else { 9 + off_x * 2 };
-    let poy = if psy != 0 { 6 + off_y } else { 9 + off_y * 2 };
-    for i in 0..(34 >> psy) {
-        for j in 0..(34 >> psx) {
-            let mut gv = src[poy + i][pox + j];
-            let (idx, blend) = if psx == 0 { (i * stripe_w + x * 2 + j, j < 2) } else { (i * stripe_w + x + j, j == 0) };
-            if blend && overlap && x > 0 {
-                let old = s[idx];
-                gv = if psx != 0 {
-                    old * 23 + gv * 22
-                } else if j == 0 {
-                    old * 27 + gv * 17
-                } else {
-                    old * 17 + gv * 27
+    // Noise stripes (7.18.3.5).
+    let stripe_w = w + 64;
+    let n_stripes = (h.div_ceil(2)).div_ceil(16).max(1);
+    let mut stripes: Vec<[Vec<i32>; 3]> = (0..n_stripes).map(|_| [vec![0; 34 * stripe_w], vec![0; 34 * stripe_w], vec![0; 34 * stripe_w]]).collect();
+    let overlap = g.overlap_flag;
+    for (luma_num, stripe) in stripes.iter_mut().enumerate() {
+        let mut r = g.grain_seed;
+        r ^= (((luma_num * 37 + 178) & 255) << 8) as u32;
+        r ^= ((luma_num * 173 + 105) & 255) as u32;
+        rng.0 = r;
+        let mut x = 0;
+        while x < w.div_ceil(2) {
+            let rand = rng.next(8) as usize;
+            let off_x = rand >> 4;
+            let off_y = rand & 15;
+            for (plane, s) in stripe.iter_mut().enumerate().take(num_planes) {
+                let psx = if plane > 0 { sub_x } else { 0 };
+                let psy = if plane > 0 { sub_y } else { 0 };
+                let pox = if psx != 0 { 6 + off_x } else { 9 + off_x * 2 };
+                let poy = if psy != 0 { 6 + off_y } else { 9 + off_y * 2 };
+                let src = match plane {
+                    0 => &luma,
+                    1 => &cb,
+                    _ => &cr,
                 };
-                gv = round2(gv, 5).clamp(c.grain_min, c.grain_max);
-            }
-            s[idx] = gv;
-        }
-    }
-}
-
-/// Noise stripes (7.18.3.5).
-struct Stripes {
-    data: Vec<[Vec<i32>; 3]>,
-    stripe_w: usize,
-    overlap: bool,
-    sub_y: usize,
-    grain_min: i32,
-    grain_max: i32,
-}
-
-impl Stripes {
-    fn build(c: &GrainCtx, t: &Templates, rng: &mut Rng) -> Stripes {
-        let g = c.g;
-        let stripe_w = c.stripe_w();
-        let n_stripes = (c.h.div_ceil(2)).div_ceil(16).max(1);
-        let mut data: Vec<[Vec<i32>; 3]> = (0..n_stripes).map(|_| [vec![0; 34 * stripe_w], vec![0; 34 * stripe_w], vec![0; 34 * stripe_w]]).collect();
-        for (luma_num, stripe) in data.iter_mut().enumerate() {
-            let mut r = g.grain_seed;
-            r ^= (((luma_num * 37 + 178) & 255) << 8) as u32;
-            r ^= ((luma_num * 173 + 105) & 255) as u32;
-            rng.0 = r;
-            let mut x = 0;
-            while x < c.w.div_ceil(2) {
-                let rand = rng.next(8) as usize;
-                let offsets = (rand >> 4, rand & 15);
-                for (plane, s) in stripe.iter_mut().enumerate().take(c.num_planes()) {
-                    fill_stripe_plane(c, t.plane(plane), s, plane, offsets, x);
+                for i in 0..(34 >> psy) {
+                    for j in 0..(34 >> psx) {
+                        let mut gv = src[poy + i][pox + j];
+                        if psx == 0 {
+                            let idx = i * stripe_w + x * 2 + j;
+                            if j < 2 && overlap && x > 0 {
+                                let old = s[idx];
+                                gv = if j == 0 { old * 27 + gv * 17 } else { old * 17 + gv * 27 };
+                                gv = round2(gv, 5).clamp(grain_min, grain_max);
+                            }
+                            s[idx] = gv;
+                        } else {
+                            let idx = i * stripe_w + x + j;
+                            if j == 0 && overlap && x > 0 {
+                                let old = s[idx];
+                                gv = round2(old * 23 + gv * 22, 5).clamp(grain_min, grain_max);
+                            }
+                            s[idx] = gv;
+                        }
+                    }
                 }
-                x += 16;
             }
+            x += 16;
         }
-        Stripes { data, stripe_w, overlap: g.overlap_flag, sub_y: c.sub_y, grain_min: c.grain_min, grain_max: c.grain_max }
     }
-
-    fn noise_at(&self, plane: usize, y: usize, x: usize) -> i32 {
-        let psy = if plane > 0 { self.sub_y } else { 0 };
+    let noise_at = |plane: usize, y: usize, x: usize| -> i32 {
+        let psy = if plane > 0 { sub_y } else { 0 };
         let luma_num = y >> (5 - psy);
         let i = y - (luma_num << (5 - psy));
-        let mut gv = self.data[luma_num][plane][i * self.stripe_w + x];
+        let mut gv = stripes[luma_num][plane][i * stripe_w + x];
         if psy == 0 {
-            if i < 2 && luma_num > 0 && self.overlap {
-                let old = self.data[luma_num - 1][plane][(i + 32) * self.stripe_w + x];
+            if i < 2 && luma_num > 0 && overlap {
+                let old = stripes[luma_num - 1][plane][(i + 32) * stripe_w + x];
                 gv = if i == 0 { old * 27 + gv * 17 } else { old * 17 + gv * 27 };
-                gv = round2(gv, 5).clamp(self.grain_min, self.grain_max);
+                gv = round2(gv, 5).clamp(grain_min, grain_max);
             }
-        } else if i < 1 && luma_num > 0 && self.overlap {
-            let old = self.data[luma_num - 1][plane][(i + 16) * self.stripe_w + x];
-            gv = round2(old * 23 + gv * 22, 5).clamp(self.grain_min, self.grain_max);
+        } else if i < 1 && luma_num > 0 && overlap {
+            let old = stripes[luma_num - 1][plane][(i + 16) * stripe_w + x];
+            gv = round2(old * 23 + gv * 22, 5).clamp(grain_min, grain_max);
         }
         gv
-    }
-}
+    };
 
-/// Output clipping range and scaling shift for the blend step (7.18.3.5).
-struct BlendRange {
-    min_value: i32,
-    max_luma: i32,
-    max_chroma: i32,
-    pix_max: i32,
-    scaling_shift: u32,
-}
-
-impl BlendRange {
-    fn new(c: &GrainCtx, matrix_coefficients: usize) -> BlendRange {
-        let bd = c.bd;
-        let (min_value, max_luma, max_chroma) = if c.g.clip_to_restricted_range {
-            let ml = 235 << (bd - 8);
-            (16 << (bd - 8), ml, if matrix_coefficients == MC_IDENTITY { ml } else { 240 << (bd - 8) })
-        } else {
-            let m = (256 << (bd - 8)) - 1;
-            (0, m, m)
-        };
-        BlendRange { min_value, max_luma, max_chroma, pix_max: (1i32 << bd) - 1, scaling_shift: c.g.grain_scaling_minus_8 + 8 }
-    }
-}
-
-struct BlendEnv<'a> {
-    c: &'a GrainCtx<'a>,
-    lut: &'a [[i32; 256]; 3],
-    stripes: &'a Stripes,
-    range: &'a BlendRange,
-}
-
-impl BlendEnv<'_> {
-    fn blend_chroma(&self, py: &[u16], pu: &mut [u16], pv: &mut [u16]) {
-        let c = self.c;
-        let g = c.g;
-        let (w, h, sub_x, sub_y, bd) = (c.w, c.h, c.sub_x, c.sub_y, c.bd);
+    // Blend (7.18.3.5).
+    let (min_value, max_luma, max_chroma) = if g.clip_to_restricted_range {
+        let ml = 235 << (bd - 8);
+        (16 << (bd - 8), ml, if pic.matrix_coefficients as usize == MC_IDENTITY { ml } else { 240 << (bd - 8) })
+    } else {
+        let m = (256 << (bd - 8)) - 1;
+        (0, m, m)
+    };
+    let pix_max = (1i32 << bd) - 1;
+    let scaling_shift = g.grain_scaling_minus_8 + 8;
+    if !mono {
         let cw = (w + sub_x) >> sub_x;
         let ch = (h + sub_y) >> sub_y;
+        let [py, pu, pv] = &mut pic.planes;
         for y in 0..ch {
             for x in 0..cw {
                 let lx = x << sub_x;
@@ -382,62 +272,26 @@ impl BlendEnv<'_> {
                         avg
                     } else {
                         let combined = avg * (luma_mult as i32 - 128) + orig * (mult as i32 - 128);
-                        ((combined >> 6) + ((offset as i32 - 256) << (bd - 8))).clamp(0, self.range.pix_max)
+                        ((combined >> 6) + ((offset as i32 - 256) << (bd - 8))).clamp(0, pix_max)
                     };
-                    let noise = round2(scale_lookup(self.lut, bd, plane, merged) * self.stripes.noise_at(plane, y, x), self.range.scaling_shift);
-                    out[y * cw + x] = (orig + noise).clamp(self.range.min_value, self.range.max_chroma) as u16;
+                    let noise = round2(scale_lut(plane, merged) * noise_at(plane, y, x), scaling_shift);
+                    out[y * cw + x] = (orig + noise).clamp(min_value, max_chroma) as u16;
                 }
             }
         }
     }
-
-    fn blend_luma(&self, py: &mut [u16]) {
-        let (w, h) = (self.c.w, self.c.h);
+    if g.num_y_points > 0 {
+        let py = &mut pic.planes[0];
         for y in 0..h {
             for x in 0..w {
                 let orig = py[y * w + x] as i32;
-                let noise = round2(scale_lookup(self.lut, self.c.bd, 0, orig) * self.stripes.noise_at(0, y, x), self.range.scaling_shift);
-                py[y * w + x] = (orig + noise).clamp(self.range.min_value, self.range.max_luma) as u16;
+                let noise = round2(scale_lut(0, orig) * noise_at(0, y, x), scaling_shift);
+                py[y * w + x] = (orig + noise).clamp(min_value, max_luma) as u16;
             }
         }
     }
 }
 
-pub(crate) fn apply(pic: &mut Picture, g: &FilmGrainParams, seq: &SequenceHeader) {
-    let _ = seq;
-    let bd = pic.bit_depth as u32;
-    let grain_center = 128i32 << (bd - 8);
-    let c = GrainCtx {
-        g,
-        bd,
-        mono: pic.mono_chrome,
-        sub_x: pic.subsampling_x as usize,
-        sub_y: pic.subsampling_y as usize,
-        w: pic.width as usize,
-        h: pic.height as usize,
-        grain_min: -grain_center,
-        grain_max: (256i32 << (bd - 8)) - 1 - grain_center,
-    };
-
-    // Generate grain (7.18.3.3).
-    let mut rng = Rng(g.grain_seed);
-    let luma = luma_grain(&c, &mut rng);
-    let templates = chroma_grain(&c, &mut rng, luma);
-    let lut = scaling_luts(g, c.num_planes());
-    let stripes = Stripes::build(&c, &templates, &mut rng);
-
-    // Blend (7.18.3.5).
-    let range = BlendRange::new(&c, pic.matrix_coefficients as usize);
-    let env = BlendEnv { c: &c, lut: &lut, stripes: &stripes, range: &range };
-    if !c.mono {
-        let [py, pu, pv] = &mut pic.planes;
-        env.blend_chroma(py, pu, pv);
-    }
-    if g.num_y_points > 0 {
-        env.blend_luma(&mut pic.planes[0]);
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/av1/src/transform.rs

@@ -165,15 +165,6 @@ pub(crate) fn inverse_dct<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..len {
         t[i] = copy[brev(n, i)];
     }
-    inverse_dct_stage1(t, n, r);
-    inverse_dct_stage2(t, n, r);
-    inverse_dct_stage3(t, n, r);
-    inverse_dct_stage4(t, n, r);
-    inverse_dct_stage5(t, n, r);
-    inverse_dct_stage6(t, n, r);
-}
-
-fn inverse_dct_stage1<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n == 6 {
         for i in 0..16 {
             bf(t, 32 + i, 63 - i, 63 - 4 * brev(4, i) as i32, false);
@@ -199,9 +190,6 @@ fn inverse_dct_stage1<T: Lane>(t: &mut [T], n: u32, r: u32) {
             hd(t, 16 + 2 * i, 17 + 2 * i, i & 1 == 1, r);
         }
     }
-}
-
-fn inverse_dct_stage2<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n == 6 {
         for i in 0..4 {
             for j in 0..2 {
@@ -233,9 +221,6 @@ fn inverse_dct_stage2<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage3<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..2 {
         bf(t, 2 * i, 2 * i + 1, 32 + 16 * i as i32, i == 0);
     }
@@ -263,9 +248,6 @@ fn inverse_dct_stage3<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage4<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..2 {
         hd(t, i, 3 - i, false, r);
     }
@@ -291,9 +273,6 @@ fn inverse_dct_stage4<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage5<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n >= 3 {
         for i in 0..4 {
             hd(t, i, 7 - i, false, r);
@@ -321,9 +300,6 @@ fn inverse_dct_stage5<T: Lane>(t: &mut [T], n: u32, r: u32) {
             hd(t, i, 15 - i, false, r);
         }
     }
-}
-
-fn inverse_dct_stage6<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n >= 5 {
         for i in 0..4 {
             bf(t, 27 - i, 20 + i, 32, true);
@@ -555,9 +531,10 @@ pub(crate) fn inverse_transform_2d(dequant: &[i32], residual: &mut [i32], tx_sz:
     let col_clamp = (bit_depth + 6).max(16);
     let rk = row_kind(tx_type);
     let ck = col_kind(tx_type);
+    let mut t = [0i32; 64];
     let rect2 = log2w.abs_diff(log2h) == 1;
-    let p = Tx2d { w, h, log2w, log2h, row_shift, col_shift, row_clamp, col_clamp, rk, ck, rect2 };
     if !lossless && bit_depth <= 10 {
+        let p = Tx2d { w, h, log2w, log2h, row_shift, col_shift, row_clamp, col_clamp, rk, ck, rect2 };
         if w >= 8 && h >= 8 {
             transform_lanes::<8>(dequant, residual, &p);
         } else {
@@ -565,13 +542,6 @@ pub(crate) fn inverse_transform_2d(dequant: &[i32], residual: &mut [i32], tx_sz:
         }
         return;
     }
-    scalar_row_pass(dequant, residual, &p, lossless);
-    scalar_col_pass(residual, &p, lossless);
-}
-
-fn scalar_row_pass(dequant: &[i32], residual: &mut [i32], p: &Tx2d, lossless: bool) {
-    let (w, h, log2w, row_shift, row_clamp, col_clamp, rk, rect2) = (p.w, p.h, p.log2w, p.row_shift, p.row_clamp, p.col_clamp, p.rk, p.rect2);
-    let mut t = [0i32; 64];
     let in_w = w.min(32);
     for i in 0..h {
         // Every 1D transform maps an all-zero row to zeros (each step is linear with
@@ -602,11 +572,6 @@ fn scalar_row_pass(dequant: &[i32], residual: &mut [i32], p: &Tx2d, lossless: bo
             residual[i * w + j] = round2(t[j], row_shift).clamp(lo, hi);
         }
     }
-}
-
-fn scalar_col_pass(residual: &mut [i32], p: &Tx2d, lossless: bool) {
-    let (w, h, log2h, col_shift, col_clamp, ck) = (p.w, p.h, p.log2h, p.col_shift, p.col_clamp, p.ck);
-    let mut t = [0i32; 64];
     for j in 0..w {
         for i in 0..h {
             t[i] = residual[i * w + j];
@@ -652,16 +617,11 @@ fn transform_1d<T: Lane>(t: &mut [T], kind: Kind1d, n: u32, r: u32) {
 /// The 2D inverse transform with `L` rows (row pass) or columns (column pass) at a time;
 /// bit-identical to the one-at-a-time process for bit depths up to 10.
 fn transform_lanes<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2d) {
-    let mut t = [[0i32; L]; 64];
-    lanes_row_pass(dequant, residual, p, &mut t);
-    lanes_col_pass(residual, p, &mut t);
-}
-
-fn lanes_row_pass<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2d, t: &mut [[i32; L]; 64]) {
     let (w, h) = (p.w, p.h);
     let in_w = w.min(32);
     let lo = -(1i32 << (p.col_clamp - 1));
     let hi = (1i32 << (p.col_clamp - 1)) - 1;
+    let mut t = [[0i32; L]; 64];
     let mut i0 = 0;
     while i0 < h {
         // Rows without coefficients (and rows 32..63) transform to zeros.
@@ -689,10 +649,6 @@ fn lanes_row_pass<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2
         }
         i0 += L;
     }
-}
-
-fn lanes_col_pass<const L: usize>(residual: &mut [i32], p: &Tx2d, t: &mut [[i32; L]; 64]) {
-    let (w, h) = (p.w, p.h);
     let mut j0 = 0;
     while j0 < w {
         for i in 0..h {

crates/h264/src/dpb.rs

@@ -3,7 +3,7 @@
 
 use crate::error::{Result, ensure};
 use crate::picture::{FrameRef, RefPic};
-use crate::slice::{Mmco, RefPicListMod, SliceHeader, SliceType};
+use crate::slice::{Mmco, SliceHeader, SliceType};
 use std::sync::Arc;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -174,103 +174,6 @@ impl Dpb {
         }
     }
 
-    /// Initial reference picture lists (8.2.4.2) as DPB entries.
-    fn initial_entry_lists<'a>(
-        sh: &SliceHeader,
-        cur_poc: i32,
-        short: &[&'a DpbEntry],
-        long: &[&'a DpbEntry],
-        pic_num: impl Fn(&DpbEntry) -> i32,
-    ) -> [Vec<&'a DpbEntry>; 2] {
-        let mut entry_lists: [Vec<&'a DpbEntry>; 2] = [Vec::new(), Vec::new()];
-        if sh.slice_type != SliceType::B {
-            let mut s = short.to_vec();
-            s.sort_by_key(|e| std::cmp::Reverse(pic_num(e)));
-            entry_lists[0] = s.into_iter().chain(long.iter().copied()).collect();
-        } else {
-            let mut before: Vec<&'a DpbEntry> = short.iter().copied().filter(|e| e.poc < cur_poc).collect();
-            let mut after: Vec<&'a DpbEntry> = short.iter().copied().filter(|e| e.poc > cur_poc).collect();
-            before.sort_by_key(|e| std::cmp::Reverse(e.poc));
-            after.sort_by_key(|e| e.poc);
-            entry_lists[0] = before.iter().chain(after.iter()).chain(long.iter()).copied().collect();
-            entry_lists[1] = after.iter().chain(before.iter()).chain(long.iter()).copied().collect();
-            if entry_lists[1].len() > 1 && entry_lists[0].len() == entry_lists[1].len() {
-                let same = entry_lists[0].iter().zip(entry_lists[1].iter()).all(|(a, b)| std::ptr::eq(*a, *b));
-                if same {
-                    entry_lists[1].swap(0, 1);
-                }
-            }
-        }
-        entry_lists
-    }
-
-    /// Reference picture list modification (8.2.4.3) of one list; `n` is num_ref_idx_active.
-    fn modify_ref_list<'a>(
-        list: &mut Vec<Option<&'a DpbEntry>>,
-        mods: &[RefPicListMod],
-        n: usize,
-        cur_fn: u32,
-        max_frame_num: u32,
-        short: &[&'a DpbEntry],
-        long: &[&'a DpbEntry],
-    ) -> Result<()> {
-        let max_pic_num = max_frame_num as i32;
-        let curr_pic_num = cur_fn as i32;
-        let mut pred = curr_pic_num;
-        let mut ref_idx = 0usize;
-        for m in mods {
-            ensure!(ref_idx < n, "too many ref_pic_list_modification entries");
-            list.push(None); // temporarily one longer
-            let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc {
-                0 | 1 => {
-                    let d = m.value as i32 + 1;
-                    let no_wrap = if m.idc == 0 {
-                        if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
-                    } else if pred + d >= max_pic_num {
-                        pred + d - max_pic_num
-                    } else {
-                        pred + d
-                    };
-                    pred = no_wrap;
-                    let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
-                    (short.iter().copied().find(|e| Self::frame_num_wrap(e, cur_fn, max_frame_num) == pn), false)
-                }
-                2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true),
-                _ => continue,
-            };
-            let Some(target) = target else {
-                // Missing picture: keep the list unchanged (error concealment).
-                list.pop();
-                ref_idx += 1;
-                continue;
-            };
-            for c in (ref_idx + 1..=n).rev() {
-                list[c] = list[c - 1];
-            }
-            list[ref_idx] = Some(target);
-            ref_idx += 1;
-            let mut nidx = ref_idx;
-            for c in ref_idx..=n {
-                let keep = match list[c] {
-                    None => true,
-                    Some(e) => {
-                        if is_long {
-                            !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
-                        } else {
-                            !(e.mark == RefMark::Short && std::ptr::eq(e, target))
-                        }
-                    }
-                };
-                if keep {
-                    list[nidx] = list[c];
-                    nidx += 1;
-                }
-            }
-            list.truncate(n);
-        }
-        Ok(())
-    }
-
     /// Initial reference picture lists (8.2.4.2) + modification (8.2.4.3) for a frame slice.
     pub fn build_ref_lists(&self, sh: &SliceHeader, cur_poc: i32, max_frame_num: u32) -> Result<[Vec<RefPic>; 2]> {
         let mut lists: [Vec<RefPic>; 2] = [Vec::new(), Vec::new()];
@@ -283,7 +186,25 @@ impl Dpb {
         let mut long: Vec<&DpbEntry> = self.entries.iter().filter(|e| e.mark == RefMark::Long).collect();
         long.sort_by_key(|e| e.long_term_frame_idx);
         let to_ref = |e: &&DpbEntry| RefPic { frame: e.frame.clone(), long_term: e.mark == RefMark::Long };
-        let entry_lists = Self::initial_entry_lists(sh, cur_poc, &short, &long, pic_num);
+        let mut entry_lists: [Vec<&DpbEntry>; 2] = [Vec::new(), Vec::new()];
+        if sh.slice_type != SliceType::B {
+            let mut s = short.clone();
+            s.sort_by_key(|e| std::cmp::Reverse(pic_num(e)));
+            entry_lists[0] = s.into_iter().chain(long.iter().copied()).collect();
+        } else {
+            let mut before: Vec<&DpbEntry> = short.iter().copied().filter(|e| e.poc < cur_poc).collect();
+            let mut after: Vec<&DpbEntry> = short.iter().copied().filter(|e| e.poc > cur_poc).collect();
+            before.sort_by_key(|e| std::cmp::Reverse(e.poc));
+            after.sort_by_key(|e| e.poc);
+            entry_lists[0] = before.iter().chain(after.iter()).chain(long.iter()).copied().collect();
+            entry_lists[1] = after.iter().chain(before.iter()).chain(long.iter()).copied().collect();
+            if entry_lists[1].len() > 1 && entry_lists[0].len() == entry_lists[1].len() {
+                let same = entry_lists[0].iter().zip(entry_lists[1].iter()).all(|(a, b)| std::ptr::eq(*a, *b));
+                if same {
+                    entry_lists[1].swap(0, 1);
+                }
+            }
+        }
         let nlists = if sh.slice_type == SliceType::B { 2 } else { 1 };
         for l in 0..nlists {
             let n = sh.num_ref_idx_active[l] as usize;
@@ -291,7 +212,60 @@ impl Dpb {
             list.truncate(n);
             list.resize(n, None);
             if !sh.ref_pic_list_mod[l].is_empty() {
-                Self::modify_ref_list(&mut list, &sh.ref_pic_list_mod[l], n, cur_fn, max_frame_num, &short, &long)?;
+                let max_pic_num = max_frame_num as i32;
+                let curr_pic_num = cur_fn as i32;
+                let mut pred = curr_pic_num;
+                let mut ref_idx = 0usize;
+                for m in &sh.ref_pic_list_mod[l] {
+                    ensure!(ref_idx < n, "too many ref_pic_list_modification entries");
+                    list.push(None); // temporarily one longer
+                    let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc {
+                        0 | 1 => {
+                            let d = m.value as i32 + 1;
+                            let no_wrap = if m.idc == 0 {
+                                if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
+                            } else if pred + d >= max_pic_num {
+                                pred + d - max_pic_num
+                            } else {
+                                pred + d
+                            };
+                            pred = no_wrap;
+                            let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
+                            (short.iter().copied().find(|e| pic_num(e) == pn), false)
+                        }
+                        2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true),
+                        _ => continue,
+                    };
+                    let Some(target) = target else {
+                        // Missing picture: keep the list unchanged (error concealment).
+                        list.pop();
+                        ref_idx += 1;
+                        continue;
+                    };
+                    for c in (ref_idx + 1..=n).rev() {
+                        list[c] = list[c - 1];
+                    }
+                    list[ref_idx] = Some(target);
+                    ref_idx += 1;
+                    let mut nidx = ref_idx;
+                    for c in ref_idx..=n {
+                        let keep = match list[c] {
+                            None => true,
+                            Some(e) => {
+                                if is_long {
+                                    !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
+                                } else {
+                                    !(e.mark == RefMark::Short && std::ptr::eq(e, target))
+                                }
+                            }
+                        };
+                        if keep {
+                            list[nidx] = list[c];
+                            nidx += 1;
+                        }
+                    }
+                    list.truncate(n);
+                }
             }
             // Fill missing entries (should not happen in conforming streams) with the first valid entry.
             let fallback = list.iter().flatten().next().copied().or_else(|| self.entries.last());
@@ -301,88 +275,91 @@ impl Dpb {
         Ok(lists)
     }
 
-    /// One memory management control operation; returns true for MMCO 5.
-    fn apply_mmco(&mut self, m: &Mmco, cur_frame_num: u32, max_frame_num: u32, cur_long: &mut Option<u32>) -> bool {
+    /// Adaptive memory control (8.2.5.4). Returns true if MMCO 5 was executed.
+    fn apply_mmcos(&mut self, mmcos: &[Mmco], cur_frame_num: u32, max_frame_num: u32, cur_long: &mut Option<u32>) -> bool {
         let mut had5 = false;
         let curr_pic_num = cur_frame_num as i32;
-        match m.op {
-            1 => {
-                let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
-                        e.mark = RefMark::Unused;
+        for m in mmcos {
+            match m.op {
+                1 => {
+                    let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
+                            e.mark = RefMark::Unused;
+                        }
                     }
                 }
-            }
-            2 => {
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_pic_num {
-                        e.mark = RefMark::Unused;
+                2 => {
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_pic_num {
+                            e.mark = RefMark::Unused;
+                        }
                     }
                 }
-            }
-            3 => {
-                let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
-                        e.mark = RefMark::Long;
-                        e.long_term_frame_idx = m.long_term_frame_idx;
-                    }
-                }
-            }
-            4 => {
-                let max = m.max_long_term_frame_idx_plus1;
-                for e in &mut self.entries {
-                    if e.mark == RefMark::Long && (max == 0 || e.long_term_frame_idx > max - 1) {
-                        e.mark = RefMark::Unused;
-                    }
-                }
-                self.max_long_term_frame_idx = if max == 0 { None } else { Some(max - 1) };
-            }
-            5 => {
-                for e in &mut self.entries {
-                    e.mark = RefMark::Unused;
-                }
-                self.max_long_term_frame_idx = None;
-                had5 = true;
-            }
-            6 => {
-                // Only an index within the allowed range may be assigned (8.2.5.4.6).
-                let allowed = match self.max_long_term_frame_idx {
-                    Some(max) => m.long_term_frame_idx <= max,
-                    None => false,
-                };
-                if allowed {
+                3 => {
+                    let pn = curr_pic_num - (m.difference_of_pic_nums_minus1 as i32 + 1);
                     for e in &mut self.entries {
                         if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
                             e.mark = RefMark::Unused;
                         }
                     }
-                    *cur_long = Some(m.long_term_frame_idx);
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Short && Self::frame_num_wrap(e, cur_frame_num, max_frame_num) == pn {
+                            e.mark = RefMark::Long;
+                            e.long_term_frame_idx = m.long_term_frame_idx;
+                        }
+                    }
                 }
+                4 => {
+                    let max = m.max_long_term_frame_idx_plus1;
+                    for e in &mut self.entries {
+                        if e.mark == RefMark::Long && (max == 0 || e.long_term_frame_idx > max - 1) {
+                            e.mark = RefMark::Unused;
+                        }
+                    }
+                    self.max_long_term_frame_idx = if max == 0 { None } else { Some(max - 1) };
+                }
+                5 => {
+                    for e in &mut self.entries {
+                        e.mark = RefMark::Unused;
+                    }
+                    self.max_long_term_frame_idx = None;
+                    had5 = true;
+                }
+                6 => {
+                    let allowed = match self.max_long_term_frame_idx {
+                        Some(max) => m.long_term_frame_idx <= max,
+                        None => false,
+                    };
+                    if allowed {
+                        for e in &mut self.entries {
+                            if e.mark == RefMark::Long && e.long_term_frame_idx == m.long_term_frame_idx {
+                                e.mark = RefMark::Unused;
+                            }
+                        }
+                        *cur_long = Some(m.long_term_frame_idx);
+                    }
+                }
+                _ => {}
             }
-            _ => {}
-        }
-        had5
-    }
-
-    /// Adaptive memory control (8.2.5.4). Returns true if MMCO 5 was executed.
-    fn apply_mmcos(&mut self, mmcos: &[Mmco], cur_frame_num: u32, max_frame_num: u32, cur_long: &mut Option<u32>) -> bool {
-        let mut had5 = false;
-        for m in mmcos {
-            had5 |= self.apply_mmco(m, cur_frame_num, max_frame_num, cur_long);
         }
         self.prune();
         had5
     }
 
-    /// Reference marking of the current picture (8.2.5); returns (mark, long-term idx, MMCO 5 executed).
-    fn mark_current(&mut self, sh: &SliceHeader, max_frame_num: u32, max_num_ref_frames: usize) -> (RefMark, u32, bool) {
+    /// Reference marking for the just-decoded picture and insertion into the DPB with output bumping.
+    /// Returns pictures ready for output.
+    #[allow(clippy::too_many_arguments)]
+    pub fn store_picture(
+        &mut self,
+        sh: &SliceHeader,
+        frame: FrameRef,
+        poc: i32,
+        max_frame_num: u32,
+        max_num_ref_frames: usize,
+        meta: Arc<OutputMeta>,
+        out: &mut Vec<Output>,
+    ) {
         let mut mark = RefMark::Unused;
         let mut long_idx = 0;
         let mut had5 = false;
@@ -414,12 +391,12 @@ impl Dpb {
                 }
             }
         }
-        (mark, long_idx, had5)
-    }
-
-    /// Bumping until there is space (C.4.5.1 / C.4.5.2). Returns true when the (non-reference) current
-    /// picture has the smallest POC and is to be output directly instead of being stored.
-    fn bump_for_space(&mut self, mark: RefMark, poc: i32, out: &mut Vec<Output>) -> bool {
+        if had5 {
+            // All earlier pictures are output before the current one (C.4.4).
+            self.flush(out);
+        }
+        let frame_num = if had5 { 0 } else { sh.frame_num };
+        // Bumping until there is space (C.4.5.1 / C.4.5.2).
         if mark == RefMark::Unused {
             loop {
                 let waiting = self.entries.len();
@@ -429,7 +406,8 @@ impl Dpb {
                 // non-reference picture with the smallest POC is output directly
                 let min_poc = self.entries.iter().filter(|e| e.needed_for_output).map(|e| e.poc).min();
                 if min_poc.is_none_or(|m| poc < m) {
-                    return true;
+                    out.push(Output { frame, poc, meta });
+                    return;
                 }
                 if !self.bump(out) {
                     break;
@@ -447,32 +425,6 @@ impl Dpb {
                 }
             }
         }
-        false
-    }
-
-    /// Reference marking for the just-decoded picture and insertion into the DPB with output bumping.
-    /// Returns pictures ready for output.
-    #[allow(clippy::too_many_arguments)]
-    pub fn store_picture(
-        &mut self,
-        sh: &SliceHeader,
-        frame: FrameRef,
-        poc: i32,
-        max_frame_num: u32,
-        max_num_ref_frames: usize,
-        meta: Arc<OutputMeta>,
-        out: &mut Vec<Output>,
-    ) {
-        let (mark, long_idx, had5) = self.mark_current(sh, max_frame_num, max_num_ref_frames);
-        if had5 {
-            // All earlier pictures are output before the current one (C.4.4).
-            self.flush(out);
-        }
-        let frame_num = if had5 { 0 } else { sh.frame_num };
-        if self.bump_for_space(mark, poc, out) {
-            out.push(Output { frame, poc, meta });
-            return;
-        }
         self.entries.push(DpbEntry {
             frame,
             poc,

crates/h264/src/slicedec.rs

@@ -665,38 +665,33 @@ impl<'a> SliceDecoder<'a> {
             return Ok(());
         }
         for p in 0..4 {
-            self.derive_sub_mb_motion(p, n)?;
-        }
-        Ok(())
-    }
-
-    /// Motion of one 8x8 sub-macroblock `p` of a P8x8/B8x8 MB.
-    fn derive_sub_mb_motion(&mut self, p: usize, n: [usize; 2]) -> Result<()> {
-        let sub = self.cur.sub[p];
-        let (x8, y8) = ((p & 1) * 2, (p >> 1) * 2);
-        if sub.direct {
-            return self.derive_direct(1 << p);
-        }
-        let mut refs = [-1i8; 2];
-        for (l, r) in refs.iter_mut().enumerate() {
-            if sub.pred & (1 << l) != 0 {
-                let v = self.cur.ref_idx[l][p];
-                ensure!((v as usize) < n[l], "ref_idx {v} out of range (list {l}, size {})", n[l]);
-                *r = v;
+            let sub = self.cur.sub[p];
+            let (x8, y8) = ((p & 1) * 2, (p >> 1) * 2);
+            if sub.direct {
+                self.derive_direct(1 << p)?;
+                continue;
             }
-        }
-        for j in 0..sub.shape.num_parts() {
-            let (sx, sy, w, h) = sub.shape.rect(j);
-            let (x, y) = (x8 + sx, y8 + sy);
-            let mut mvs = [[0i16; 2]; 2];
-            for l in 0..2 {
-                if refs[l] >= 0 {
-                    let mvp = self.mvp(l, x, y, w, refs[l], 0, 0);
-                    let d = self.cur.mvd[l][p * 4 + j];
-                    mvs[l] = [mvp[0].wrapping_add(d[0]), mvp[1].wrapping_add(d[1])];
+            let mut refs = [-1i8; 2];
+            for (l, r) in refs.iter_mut().enumerate() {
+                if sub.pred & (1 << l) != 0 {
+                    let v = self.cur.ref_idx[l][p];
+                    ensure!((v as usize) < n[l], "ref_idx {v} out of range (list {l}, size {})", n[l]);
+                    *r = v;
                 }
             }
-            self.set_motion(x, y, w, h, refs, mvs);
+            for j in 0..sub.shape.num_parts() {
+                let (sx, sy, w, h) = sub.shape.rect(j);
+                let (x, y) = (x8 + sx, y8 + sy);
+                let mut mvs = [[0i16; 2]; 2];
+                for l in 0..2 {
+                    if refs[l] >= 0 {
+                        let mvp = self.mvp(l, x, y, w, refs[l], 0, 0);
+                        let d = self.cur.mvd[l][p * 4 + j];
+                        mvs[l] = [mvp[0].wrapping_add(d[0]), mvp[1].wrapping_add(d[1])];
+                    }
+                }
+                self.set_motion(x, y, w, h, refs, mvs);
+            }
         }
         Ok(())
     }
@@ -1385,11 +1380,6 @@ impl<'a> SliceDecoder<'a> {
             cavlc::residual_block(r, &mut lv, 0, 15, 16, nc)?;
             self.put_luma_dc(&lv);
         }
-        self.residual_cavlc_luma(r, cbp, kind, t8)?;
-        self.residual_cavlc_chroma(r, cbp)
-    }
-
-    fn residual_cavlc_luma(&mut self, r: &mut BitReader, cbp: u8, kind: MbKind, t8: bool) -> Result<()> {
         for b8 in 0..4 {
             let (bx8, by8) = ((b8 & 1) * 2, (b8 >> 1) * 2);
             if cbp & (1 << b8) == 0 {
@@ -1423,10 +1413,6 @@ impl<'a> SliceDecoder<'a> {
                 }
             }
         }
-        Ok(())
-    }
-
-    fn residual_cavlc_chroma(&mut self, r: &mut BitReader, cbp: u8) -> Result<()> {
         let cbp_c = cbp >> 4;
         if cbp_c & 3 != 0 {
             for c in 0..2 {