Skip to content

FilmCraft: An open-source, nonlinear video editor written by scratch in pure Rust

25.3 KB
Raw Blame
//! Slice, macroblock and block decoding (H.262 §6.2.4-§6.2.6, §7.2-§7.6; ISO/IEC 11172-2
//! §2.4.2.7-§2.4.4).

use crate::bits::Bits;
use crate::headers::{PictureCodingExtension, PictureType, SCAN};
use crate::idct::idct;
use crate::mc::{Block, Frame, predict};
use crate::vlc::{DCT_EOB, DCT_ESCAPE, MB_BWD, MB_FWD, MB_INTRA, MB_PATTERN, MB_QUANT, MBA_ESCAPE, MBA_STUFFING, tables};

/// Non-linear quantiser_scale (Table 7-6), indexed by quantiser_scale_code.
pub(crate) const NON_LINEAR_Q: [u8; 32] =
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 22, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 104, 112];

/// Motion types (frame_motion_type / field_motion_type values).
const MT_FIELD: u8 = 1;
const MT_FRAME: u8 = 2; // frame pictures; 16x8 MC in field pictures
const MT_16X8: u8 = 2;
const MT_DUAL: u8 = 3;

/// Everything slices of one picture share (read-only while slices decode in parallel).
pub(crate) struct PicParams<'a> {
    pub mpeg2: bool,
    pub ptype: PictureType,
    pub pce: PictureCodingExtension,
    pub full_pel: [bool; 2],
    /// Chroma subsampling shifts (4:2:0: 1, 1; 4:2:2: 1, 0).
    pub shx: u32,
    pub shy: u32,
    pub mb_width: usize,
    /// Macroblock rows of this picture (field rows for field pictures).
    pub mb_rows: usize,
    /// Intra luma, non-intra luma, intra chroma, non-intra chroma (raster order).
    pub matrices: [[u8; 64]; 4],
    /// Forward reference (P: the latest anchor; B: the older anchor) and backward reference.
    pub fwd: Option<&'a Frame>,
    pub bwd: Option<&'a Frame>,
    /// The first field of this frame (when decoding its second field).
    pub first_field: Option<&'a Frame>,
    /// Field pictures: parity of this field (0 top, 1 bottom).
    pub parity: usize,
    pub vertical_size_extension: bool,
}

impl PicParams<'_> {
    fn frame_picture(&self) -> bool {
        self.pce.picture_structure == 3
    }
    fn chroma_blocks(&self) -> usize {
        if self.shy == 1 { 2 } else { 4 }
    }
    /// Chroma macroblock size.
    fn cmb(&self) -> (usize, usize) {
        (16 >> self.shx, 16 >> self.shy)
    }
}

/// Where a row (or, for MPEG-1, the whole picture) of macroblocks is written.
pub(crate) struct Target<'a> {
    pub planes: [&'a mut [u8]; 3],
    pub strides: [usize; 2],
    /// First luma / chroma frame line held by `planes`.
    pub line0: [usize; 2],
    /// Field pictures: parity written.
    pub field: Option<usize>,
}

impl Target<'_> {
    fn put(&mut self, mbx: usize, mby: usize, mb: &MbBuf, cmb: (usize, usize)) {
        for (c, plane) in self.planes.iter_mut().enumerate() {
            let k = (c > 0) as usize;
            let (bw, bh) = if c == 0 { (16, 16) } else { cmb };
            let stride = self.strides[k];
            let src = if c == 0 { &mb.y[..] } else { &mb.c[c - 1][..] };
            for l in 0..bh {
                let line = match self.field {
                    None => bh * mby + l,
                    Some(p) => 2 * (bh * mby + l) + p,
                };
                let Some(local) = line.checked_sub(self.line0[k]) else { continue };
                let at = local * stride + bw * mbx;
                if at + bw <= plane.len() {
                    plane[at..at + bw].copy_from_slice(&src[l * bw..l * bw + bw]);
                }
            }
        }
    }
}

/// One macroblock's samples (luma 16×16; chroma rows of `16 >> shx` samples).
pub(crate) struct MbBuf {
    y: [u8; 256],
    c: [[u8; 256]; 2],
}

#[derive(Clone, Copy, Default)]
struct Motion {
    flags: i16,
    mtype: u8,
    /// vectors[r][s][t] in half-sample units (vertical in field units for field prediction).
    mv: [[[i32; 2]; 2]; 2],
    select: [[usize; 2]; 2],
    dmv: [i32; 2],
}

struct SliceState {
    qscale: i32,
    dc_pred: [i32; 3],
    pmv: [[[i32; 2]; 2]; 2],
    last: Motion,
}

fn dc_reset(p: &PicParams) -> i32 {
    1 << (7 + p.pce.intra_dc_precision)
}

#[derive(Debug)]
pub(crate) struct SliceError(pub &'static str);

type R<T> = std::result::Result<T, SliceError>;

/// Decode one slice (`data`: the bytes after its start code) into `t`. `row`: the slice's
/// macroblock row; `single_row`: MPEG-2 slices may not leave their row.
pub(crate) fn decode_slice(p: &PicParams, data: &[u8], row: usize, single_row: bool, t: &mut Target) -> R<()> {
    let tb = tables();
    let mut b = Bits::new(data);
    if p.vertical_size_extension {
        b.skip(3); // already applied to `row` by the caller
    }
    let qcode = b.read(5) as usize;
    if p.mpeg2 && b.peek(1) == 1 {
        b.skip(9); // intra_slice_flag, intra_slice, reserved_bits
    }
    while b.bit() {
        b.skip(8); // extra_information_slice
    }
    let mut st = SliceState { qscale: qscale(p, qcode), dc_pred: [dc_reset(p); 3], pmv: [[[0; 2]; 2]; 2], last: Motion::default() };
    let total = p.mb_width * p.mb_rows;
    let row_end = if single_row { (row + 1) * p.mb_width } else { total };
    let mut addr: isize = (row * p.mb_width) as isize - 1;
    let mut first = true;
    let mut buf = MbBuf { y: [0; 256], c: [[0; 256]; 2] };
    let mut blk = [0i32; 64];
    loop {
        // macroblock_address_increment
        let mut inc = 0isize;
        loop {
            match tb.mba.decode(&mut b) {
                Some(MBA_ESCAPE) => inc += 33,
                Some(MBA_STUFFING) => {}
                Some(n) => {
                    inc += n as isize;
                    break;
                }
                None => return Err(SliceError("bad macroblock_address_increment")),
            }
            if b.overrun() {
                return Err(SliceError("truncated slice"));
            }
        }
        if !first && inc > 1 {
            // skipped macroblocks
            for _ in 1..inc {
                addr += 1;
                if addr as usize >= row_end {
                    return Err(SliceError("macroblock address past the row"));
                }
                skipped_mb(p, &mut st, addr as usize, &mut buf, t)?;
            }
            addr += 1;
        } else {
            addr += inc;
        }
        first = false;
        if addr < 0 || addr as usize >= row_end {
            return Err(SliceError("macroblock address out of range"));
        }
        let a = addr as usize;
        macroblock(p, &mut st, &mut b, a, &mut buf, &mut blk, t)?;
        if b.overrun() {
            return Err(SliceError("truncated macroblock"));
        }
        // next_start_code: 23 zero bits end the slice
        if b.bits_left() <= 0 || b.peek(23) == 0 {
            return Ok(());
        }
    }
}

fn qscale(p: &PicParams, code: usize) -> i32 {
    if !p.mpeg2 {
        code as i32
    } else if p.pce.q_scale_type {
        NON_LINEAR_Q[code & 31] as i32
    } else {
        2 * code as i32
    }
}

/// A skipped macroblock (§7.6.6): P pictures predict from the same position with a zero vector;
/// B pictures repeat the previous macroblock's prediction.
fn skipped_mb(p: &PicParams, st: &mut SliceState, addr: usize, buf: &mut MbBuf, t: &mut Target) -> R<()> {
    st.dc_pred = [dc_reset(p); 3];
    let m = match p.ptype {
        PictureType::P => {
            st.pmv = [[[0; 2]; 2]; 2];
            let mut m = Motion { flags: MB_FWD, mtype: if p.frame_picture() { MT_FRAME } else { MT_FIELD }, ..Default::default() };
            m.select[0][0] = p.parity;
            m
        }
        PictureType::B => {
            let last = st.last;
            if last.flags & MB_INTRA != 0 {
                return Err(SliceError("skipped macroblock after an intra macroblock"));
            }
            // the previous macroblock's direction, one vector per direction (PMV[0][s]); field
            // pictures predict from the field of the same parity (§7.6.6.4)
            let mut m = Motion { flags: last.flags & (MB_FWD | MB_BWD), mtype: if p.frame_picture() { MT_FRAME } else { MT_FIELD }, ..Default::default() };
            for s in 0..2 {
                m.mv[0][s] = st.pmv[0][s];
                m.select[0][s] = p.parity;
            }
            m
        }
        _ => return Err(SliceError("skipped macroblock in an intra picture")),
    };
    let (mbx, mby) = (addr % p.mb_width, addr / p.mb_width);
    predict_mb(p, &m, mbx, mby, buf);
    t.put(mbx, mby, buf, p.cmb());
    if p.ptype == PictureType::B {
        st.last = Motion { flags: m.flags, ..st.last };
    }
    Ok(())
}

fn macroblock(p: &PicParams, st: &mut SliceState, b: &mut Bits, addr: usize, buf: &mut MbBuf, blk: &mut [i32; 64], t: &mut Target) -> R<()> {
    let tb = tables();
    let ti = match p.ptype {
        PictureType::I => 0,
        PictureType::P => 1,
        PictureType::B => 2,
        PictureType::D => 3,
    };
    let flags = tb.mbtype[ti].decode(b).ok_or(SliceError("bad macroblock_type"))?;
    let intra = flags & MB_INTRA != 0;
    let frame_pic = p.frame_picture();
    let mut m = Motion { flags, ..Default::default() };
    if flags & (MB_FWD | MB_BWD) != 0 {
        m.mtype = if frame_pic && (p.pce.frame_pred_frame_dct || !p.mpeg2) { MT_FRAME } else { b.read(2) as u8 };
        if m.mtype == 0 {
            return Err(SliceError("reserved motion type"));
        }
    } else if intra && p.pce.concealment_motion_vectors {
        m.mtype = if frame_pic { MT_FRAME } else { MT_FIELD };
    }
    let dct_type = p.mpeg2 && frame_pic && !p.pce.frame_pred_frame_dct && (intra || flags & MB_PATTERN != 0) && b.bit();
    if flags & MB_QUANT != 0 {
        st.qscale = qscale(p, b.read(5) as usize);
    }
    let concealment = intra && p.pce.concealment_motion_vectors;
    read_motion_vectors(p, st, b, &mut m, concealment)?;
    if concealment {
        b.skip(1); // marker_bit
    }
    // coded_block_pattern
    let nblocks = 4 + p.chroma_blocks();
    let cbp = read_cbp(p, b, flags, intra)?;
    let (mbx, mby) = (addr % p.mb_width, addr / p.mb_width);
    if intra {
        if !concealment {
            st.pmv = [[[0; 2]; 2]; 2];
        }
    } else {
        st.dc_pred = [dc_reset(p); 3];
        if p.ptype == PictureType::P && flags & MB_FWD == 0 {
            // "No MC": zero vector from the same position (same-parity field in field pictures)
            st.pmv = [[[0; 2]; 2]; 2];
            m.flags |= MB_FWD;
            m.mtype = if frame_pic { MT_FRAME } else { MT_FIELD };
            m.select[0][0] = p.parity;
        }
        predict_mb(p, &m, mbx, mby, buf);
    }
    // blocks
    let (cbw, cbh) = p.cmb();
    for i in 0..nblocks {
        if cbp & (1 << (nblocks - 1 - i)) == 0 {
            continue;
        }
        let cc = block_component(i);
        let dc_only = block(p, st, b, cc, intra, blk)?;
        idct(blk, dc_only);
        place_block(buf, blk, i, (cbw, cbh), dct_type, intra);
    }
    if p.ptype == PictureType::D {
        b.skip(1); // end_of_macroblock
    }
    t.put(mbx, mby, buf, (cbw, cbh));
    st.last = m;
    Ok(())
}

/// Colour component (0 luma, 1 Cb, 2 Cr) of block `i` of a macroblock.
fn block_component(i: usize) -> usize {
    if i < 4 { 0 } else { 1 + (i & 1) }
}

/// How a macroblock's motion vectors are sent.
struct MvLayout {
    /// Vectors per direction: 1, or 2 for field/16x8 prediction.
    count: usize,
    field_fmt: bool,
    dual: bool,
}

impl MvLayout {
    fn of(frame_pic: bool, mtype: u8) -> MvLayout {
        let (count, field_fmt, dual) = match (frame_pic, mtype) {
            (true, MT_FIELD) => (2, true, false),
            (true, MT_DUAL) | (false, MT_DUAL) => (1, true, true),
            (true, _) => (1, false, false),
            (false, MT_16X8) => (2, true, false),
            (false, _) => (1, true, false),
        };
        MvLayout { count, field_fmt, dual }
    }
}

/// Read the motion vectors (and dual-prime vectors) of a macroblock, updating the predictors.
fn read_motion_vectors(p: &PicParams, st: &mut SliceState, b: &mut Bits, m: &mut Motion, concealment: bool) -> R<()> {
    let tb = tables();
    let frame_pic = p.frame_picture();
    let MvLayout { count, field_fmt, dual } = MvLayout::of(frame_pic, m.mtype);
    let flags = m.flags;
    for s in 0..2 {
        let present = if s == 0 { flags & MB_FWD != 0 || concealment } else { flags & MB_BWD != 0 };
        if !present {
            continue;
        }
        for r in 0..count {
            if count == 2 || (field_fmt && !dual) {
                m.select[r][s] = b.read(1) as usize;
            }
            for c in 0..2 {
                let fc = p.pce.f_code[s][c] as i32;
                let code = tb.motion.decode(b).ok_or(SliceError("bad motion_code"))? as i32;
                let r_size = (fc - 1).max(0);
                let residual = if fc != 1 && code != 0 { b.read(r_size as u32) as i32 } else { 0 };
                if dual {
                    m.dmv[c] = tb.dmv.decode(b).ok_or(SliceError("bad dmvector"))? as i32;
                }
                let f = 1 << r_size;
                let delta = if f == 1 || code == 0 { code } else { (((code.abs() - 1) * f) + residual + 1) * code.signum() };
                let halve = p.mpeg2 && field_fmt && c == 1 && frame_pic;
                let pred = if halve { st.pmv[r][s][c] >> 1 } else { st.pmv[r][s][c] };
                let v = wrap_vector(pred, delta, f);
                st.pmv[r][s][c] = if halve { v * 2 } else { v };
                m.mv[r][s][c] = v;
            }
        }
        if count == 1 {
            st.pmv[1][s] = st.pmv[0][s];
        }
        if !p.mpeg2 && p.full_pel[s] {
            for c in 0..2 {
                m.mv[0][s][c] *= 2;
            }
        }
    }
    Ok(())
}

/// coded_block_pattern: one bit per block, first block in the most significant bit.
fn read_cbp(p: &PicParams, b: &mut Bits, flags: i16, intra: bool) -> R<u32> {
    let nblocks = 4 + p.chroma_blocks();
    Ok(if flags & MB_PATTERN != 0 {
        let v = tables().cbp.decode(b).ok_or(SliceError("bad coded_block_pattern"))? as u32;
        if nblocks == 8 { (v << 2) | b.read(2) } else { v }
    } else if intra {
        (1 << nblocks) - 1
    } else {
        0
    })
}

/// Write (intra) or add (inter) the decoded block `i` into the macroblock buffer.
fn place_block(buf: &mut MbBuf, blk: &[i32; 64], i: usize, cmb: (usize, usize), dct_type: bool, intra: bool) {
    let (cbw, cbh) = cmb;
    let cc = block_component(i);
    let (dst, stride, x0, y0, step) = if i < 4 {
        let x0 = (i & 1) * 8;
        let (y0, step) = if dct_type { (i >> 1, 2) } else { ((i >> 1) * 8, 1) };
        (&mut buf.y[..], 16, x0, y0, step)
    } else {
        let k = (i - 4) >> 1; // 0 for 4:2:0; 0/1 (top/bottom) for 4:2:2
        let (y0, step) = if cbh == 16 && dct_type { (k, 2) } else { (k * 8, 1) };
        (&mut buf.c[cc - 1][..], cbw, 0, y0, step)
    };
    for r in 0..8 {
        let at = (y0 + r * step) * stride + x0;
        let row = &mut dst[at..at + 8];
        let src = &blk[r * 8..r * 8 + 8];
        if intra {
            for (o, &v) in row.iter_mut().zip(src) {
                *o = v.clamp(0, 255) as u8;
            }
        } else {
            for (o, &v) in row.iter_mut().zip(src) {
                *o = (*o as i32 + v).clamp(0, 255) as u8;
            }
        }
    }
}

/// Decode and dequantise one block into `blk` (raster order). Returns whether only the DC
/// coefficient is non-zero.
fn block(p: &PicParams, st: &mut SliceState, b: &mut Bits, cc: usize, intra: bool, blk: &mut [i32; 64]) -> R<bool> {
    let tb = tables();
    blk.fill(0);
    let scan = &SCAN[p.pce.alternate_scan as usize];
    let w = &p.matrices[(cc > 0 && p.shy == 0) as usize * 2 + (!intra) as usize];
    let qs = st.qscale;
    let mut sum: i32 = 0;
    let mut i: usize;
    let mut ac = false;
    if intra {
        let size = if cc == 0 { tb.dc_luma.decode(b) } else { tb.dc_chroma.decode(b) }.ok_or(SliceError("bad dct_dc_size"))? as u32;
        let diff = if size == 0 {
            0
        } else {
            let v = b.read(size) as i32;
            if v & (1 << (size - 1)) == 0 { v - (1 << size) + 1 } else { v }
        };
        st.dc_pred[cc] += diff;
        let dc = if p.mpeg2 { st.dc_pred[cc] * (8 >> p.pce.intra_dc_precision) } else { st.dc_pred[cc] * 8 };
        blk[0] = dc;
        sum = dc;
        if p.ptype == PictureType::D {
            return Ok(true);
        }
        i = 0;
    } else {
        i = usize::MAX; // the first coefficient lands at run
        // "1s": run 0, level ±1 as the first coefficient of a non-intra block
        if b.peek(1) == 1 {
            b.skip(1);
            let level = if b.bit() { -1 } else { 1 };
            i = 0;
            let v = dequant(p, level, qs, w[scan[0] as usize] as i32, false);
            blk[scan[0] as usize] = v;
            sum += v;
            ac = scan[0] != 0;
        }
    }
    let table = if intra && p.pce.intra_vlc_format { &tb.dct_one } else { &tb.dct_zero };
    loop {
        let code = table.decode(b).ok_or(SliceError("bad DCT coefficient code"))?;
        if code == DCT_EOB {
            break;
        }
        let (run, level) = if code == DCT_ESCAPE {
            let run = b.read(6) as usize;
            let level = if p.mpeg2 {
                b.read_signed(12)
            } else {
                match b.read(8) as i32 {
                    0 => b.read(8) as i32,
                    128 => b.read(8) as i32 - 256,
                    v => (v << 24) >> 24,
                }
            };
            if level == 0 {
                return Err(SliceError("zero escape level"));
            }
            (run, level)
        } else {
            let run = (code & 63) as usize;
            let level = (code >> 6) as i32;
            (run, if b.bit() { -level } else { level })
        };
        i = i.wrapping_add(run + 1);
        if i > 63 {
            return Err(SliceError("coefficient index past 63"));
        }
        let pos = scan[i] as usize;
        let v = dequant(p, level, qs, w[pos] as i32, intra);
        blk[pos] = v;
        sum += v;
        ac = true;
        if b.overrun() {
            return Err(SliceError("truncated block"));
        }
    }
    if p.mpeg2 && sum & 1 == 0 {
        // mismatch control (§7.4.4)
        blk[63] ^= 1;
        ac = true;
    }
    Ok(!ac && blk[1..].iter().all(|&v| v == 0))
}

/// `prediction + delta`, brought back into [-16f, 16f-1] (§7.6.3.1). The range is restored on
/// the side the delta moves the vector, and a zero delta keeps the prediction, as the MPEG
/// Software Simulation Group reference decoder (ISO/IEC TR 13818-5) does. This only matters when
/// the prediction itself is out of range: a field vector's doubled vertical predictor before a
/// frame vector.
#[inline(always)]
pub(crate) fn wrap_vector(pred: i32, delta: i32, f: i32) -> i32 {
    let v = pred + delta;
    if delta > 0 && v > 16 * f - 1 {
        v - 32 * f
    } else if delta < 0 && v < -16 * f {
        v + 32 * f
    } else {
        v
    }
}

#[inline(always)]
fn dequant(p: &PicParams, level: i32, qs: i32, w: i32, intra: bool) -> i32 {
    if p.mpeg2 {
        let k = if intra { 0 } else { level.signum() };
        ((2 * level + k) * w * qs / 32).clamp(-2048, 2047)
    } else {
        let mut v = if intra { 2 * level * qs * w / 16 } else { (2 * level + level.signum()) * qs * w / 16 };
        if v & 1 == 0 {
            v -= v.signum();
        }
        v.clamp(-2048, 2047)
    }
}

/// The reference field (or frame) for direction `s` and field `sel` (field prediction).
fn reference<'a>(p: &PicParams<'a>, s: usize, sel: usize) -> Option<&'a Frame> {
    if s == 1 {
        return p.bwd.or(p.fwd);
    }
    if p.ptype == PictureType::P && !p.frame_picture() && sel != p.parity && p.first_field.is_some() {
        return p.first_field;
    }
    p.fwd.or(p.bwd)
}

/// Form the prediction of a non-intra macroblock in `buf` (§7.6).
fn predict_mb(p: &PicParams, m: &Motion, mbx: usize, mby: usize, buf: &mut MbBuf) {
    let (cbw, cbh) = p.cmb();
    let mb = Pred { mv: [0; 2], mbx, mby, cbw, cbh, avg: false };
    let frame_pic = p.frame_picture();
    let mut avg = false;
    for s in 0..2 {
        let dir = if s == 0 { MB_FWD } else { MB_BWD };
        if m.flags & dir == 0 {
            continue;
        }
        if frame_pic {
            match m.mtype {
                MT_FIELD => {
                    for r in 0..2 {
                        let Some(f) = reference(p, s, m.select[r][s]) else { return gray(buf) };
                        pred_block(p, buf, f, Some(m.select[r][s]), Pred { mv: m.mv[r][s], avg, ..mb }, (8, r, 2));
                    }
                }
                MT_DUAL => {
                    let Some(f) = reference(p, s, 0) else { return gray(buf) };
                    for par in 0..2 {
                        let opp = 1 - par;
                        let (mm, e) = if par == 0 { (if p.pce.top_field_first { 1 } else { 3 }, -1) } else { (if p.pce.top_field_first { 3 } else { 1 }, 1) };
                        let d = dual_vector(m.mv[0][s], m.dmv, mm, e);
                        pred_block(p, buf, f, Some(par), Pred { mv: m.mv[0][s], avg, ..mb }, (8, par, 2));
                        pred_block(p, buf, f, Some(opp), Pred { mv: d, avg: true, ..mb }, (8, par, 2));
                    }
                }
                _ => {
                    let Some(f) = reference(p, s, 0) else { return gray(buf) };
                    pred_block(p, buf, f, None, Pred { mv: m.mv[0][s], avg, ..mb }, (16, 0, 1));
                }
            }
        } else {
            match m.mtype {
                MT_16X8 => {
                    for r in 0..2 {
                        let Some(f) = reference(p, s, m.select[r][s]) else { return gray(buf) };
                        pred_half(p, buf, f, m.select[r][s], Pred { mv: m.mv[r][s], avg, ..mb }, r);
                    }
                }
                MT_DUAL => {
                    let same = p.parity;
                    let opp = 1 - same;
                    let Some(fs) = reference(p, s, same) else { return gray(buf) };
                    let Some(fo) = reference(p, s, opp) else { return gray(buf) };
                    let e = if same == 1 { 1 } else { -1 };
                    let d = dual_vector(m.mv[0][s], m.dmv, 1, e);
                    pred_block(p, buf, fs, Some(same), Pred { mv: m.mv[0][s], avg, ..mb }, (16, 0, 1));
                    pred_block(p, buf, fo, Some(opp), Pred { mv: d, avg: true, ..mb }, (16, 0, 1));
                }
                _ => {
                    let Some(f) = reference(p, s, m.select[0][s]) else { return gray(buf) };
                    pred_block(p, buf, f, Some(m.select[0][s]), Pred { mv: m.mv[0][s], avg, ..mb }, (16, 0, 1));
                }
            }
        }
        avg = true;
    }
}

fn gray(buf: &mut MbBuf) {
    buf.y.fill(128);
    buf.c[0].fill(128);
    buf.c[1].fill(128);
}

/// Dual-prime opposite-parity vector (§7.6.3.6).
fn dual_vector(v: [i32; 2], dmv: [i32; 2], m: i32, e: i32) -> [i32; 2] {
    let scale = |x: i32| (x * m + (x > 0) as i32) >> 1;
    [scale(v[0]) + dmv[0], scale(v[1]) + e + dmv[1]]
}

/// One motion-compensated prediction: vector, macroblock position, chroma block size, and
/// whether to average with what the buffer already holds.
#[derive(Clone, Copy)]
struct Pred {
    mv: [i32; 2],
    mbx: usize,
    mby: usize,
    cbw: usize,
    cbh: usize,
    avg: bool,
}

/// Predict a 16-wide luma block of `lh` lines (plus chroma) from `f` (one field when `field`),
/// into `buf` lines `first + k·step`; `lines` is `(lh, first, step)`. `lh` is 16 (frame or
/// field-picture prediction) or 8 (one field of a frame macroblock).
fn pred_block(p: &PicParams, buf: &mut MbBuf, f: &Frame, field: Option<usize>, pr: Pred, lines: (usize, usize, usize)) {
    let Pred { mv, mbx, mby, cbw, cbh, avg } = pr;
    let (lh, first, step) = lines;
    // luma: base position in the reference plane's own (frame or field) lines
    let by = if lh == 8 { mby * 8 } else { mby * 16 };
    let (x, y) = ((mbx * 16) as i32 + (mv[0] >> 1), by as i32 + (mv[1] >> 1));
    predict(&mut buf.y, first * 16, 16 * step, f.plane(0, field), Block { x, y, hx: mv[0] & 1 != 0, hy: mv[1] & 1 != 0, bw: 16, bh: lh }, avg);
    let cmv = [if p.shx == 1 { mv[0] / 2 } else { mv[0] }, if p.shy == 1 { mv[1] / 2 } else { mv[1] }];
    let clh = if lh == 8 { cbh / 2 } else { cbh };
    let cby = mby * clh;
    let (cx, cy) = ((mbx * cbw) as i32 + (cmv[0] >> 1), cby as i32 + (cmv[1] >> 1));
    let cb = Block { x: cx, y: cy, hx: cmv[0] & 1 != 0, hy: cmv[1] & 1 != 0, bw: cbw, bh: clh };
    for c in 0..2 {
        predict(&mut buf.c[c], first * cbw, cbw * step, f.plane(1 + c, field), cb, avg);
    }
}

/// 16x8 motion compensation in a field picture: half `r` (0 upper, 1 lower) of the macroblock.
fn pred_half(p: &PicParams, buf: &mut MbBuf, f: &Frame, field: usize, pr: Pred, r: usize) {
    let Pred { mv, mbx, mby, cbw, cbh, avg } = pr;
    let (x, y) = ((mbx * 16) as i32 + (mv[0] >> 1), (mby * 16 + r * 8) as i32 + (mv[1] >> 1));
    predict(&mut buf.y, r * 8 * 16, 16, f.plane(0, Some(field)), Block { x, y, hx: mv[0] & 1 != 0, hy: mv[1] & 1 != 0, bw: 16, bh: 8 }, avg);
    let cmv = [if p.shx == 1 { mv[0] / 2 } else { mv[0] }, if p.shy == 1 { mv[1] / 2 } else { mv[1] }];
    let ch = cbh / 2;
    let (cx, cy) = ((mbx * cbw) as i32 + (cmv[0] >> 1), (mby * cbh + r * ch) as i32 + (cmv[1] >> 1));
    let cb = Block { x: cx, y: cy, hx: cmv[0] & 1 != 0, hy: cmv[1] & 1 != 0, bw: cbw, bh: ch };
    for c in 0..2 {
        predict(&mut buf.c[c], r * ch * cbw, cbw, f.plane(1 + c, Some(field)), cb, avg);
    }
}

/// The macroblock row a slice starts in (slice_vertical_position and its extension).
pub(crate) fn slice_row(vertical_size_extension: bool, code: u8, payload: &[u8]) -> usize {
    let mut row = code as usize - 1;
    if vertical_size_extension && !payload.is_empty() {
        row += ((payload[0] >> 5) as usize) << 7;
    }
    row
}