oxideav-h264 0.1.9

//! §8.4.1 — Motion vector derivation for H.264.
//!
//! Neighbouring-block based motion-vector prediction. Callers supply
//! neighbour-block MVs, reference indices, and availability; this
//! module computes MVpred and handles direct-mode derivations.
//!
//! Clean-room implementation from ITU-T Rec. H.264 (08/2024):
//! - §8.4.1.1  Derivation process for motion vector components and
//!   reference indices (entry point — dispatches to subclauses).
//! - §8.4.1.2  Luma MV for P_Skip (eq. 8-174 trivial refIdx=0, zero
//!   MVpred substitution conditions).
//! - §8.4.1.2.2 Spatial direct mode for B slices (eq. 8-184..8-190).
//! - §8.4.1.2.3 Temporal direct mode for B slices (eq. 8-191..8-202).
//! - §8.4.1.3  Luma motion vector prediction — the MVpred dispatch
//!   (16x8 / 8x16 special cases, else median).
//! - §8.4.1.3.1 Median luma MV prediction (eq. 8-207..8-213).
//! - §6.4.11.7 Derivation process for neighbouring partitions — the
//!   (A, B, C, D) lookup. For 4x4-block-sized partitions,
//!   combined with §6.4.3 (inverse 4x4 luma block scan,
//!   eq. 6-17/6-18) and §6.4.13.1 (eq. 6-38).

#![allow(dead_code)]

// ---------------------------------------------------------------------------
// Primitive data types
// ---------------------------------------------------------------------------

/// Motion vector with component resolution 1/4 luma sample.
/// Stored signed; per Annex A range constraints fit comfortably in i32.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
pub struct Mv {
    pub x: i32,
    pub y: i32,
}

impl Mv {
    pub const ZERO: Mv = Mv { x: 0, y: 0 };

    pub const fn new(x: i32, y: i32) -> Self {
        Mv { x, y }
    }
}

/// Which reference list (L0 or L1) — used only in the public API for
/// documentation; the internal derivation is list-agnostic (the spec
/// uses refIdxLX, mvLX with a generic list suffix flag).
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum RefList {
    L0,
    L1,
}

/// One neighbour block's MV + ref idx + availability, per §8.4.1.3.2.
/// The spec treats "not available or Intra coded or predFlagLX==0" as
/// mvLXN = 0 and refIdxLXN = -1 — the caller is expected to fold all
/// those cases into `available = false, ref_idx = -1, mv = (0,0)`.
///
/// `mb_available` additionally records whether the *macroblock address*
/// mbAddrN itself is available per §6.4.5 (i.e. within the picture and
/// in the same slice), independent of the intra / predFlagLX filtering
/// that collapses into `available`. The distinction is required by
/// §8.4.1.1 P_Skip: the zero-MV substitution condition "mbAddrA is not
/// available" is about the mbAddr, NOT about whether A is usable for
/// MVpred. An intra neighbour has an available mbAddr but refIdxLXA =
/// -1 (so the "refIdxL0A == 0 AND mvA == 0" condition is also false),
/// and should therefore fall through to median §8.4.1.3.
///
/// `partition_available` tracks §6.4.11.1 (sub-)partition availability:
/// the neighbour partition is "not available" if it is a later partition
/// of the current MB in decoding order (still undecoded) — even though
/// `mb_available` may be true. The §8.4.1.3.2 eq. 8-214..8-216 C→D
/// substitution is gated on THIS bit (partition-level availability),
/// not on `mb_available`, nor on `available`:
///   * an intra neighbour whose MB has been decoded is partition-
///     available per §6.4.11.1 (no substitution) and just contributes
///     mv=0, refIdx=-1 to the median (step 4 of §8.4.1.3.2);
///   * a later-partition-of-same-MB neighbour is partition-
///     unavailable per §6.4.11.1 (substitution fires) and we pull
///     D in its place.
///
/// Callers that don't care about the §8.4.1.1 distinction may leave
/// `mb_available` and `partition_available` at their defaults (which
/// both track `available`); the default preserves pre-fix behaviour
/// for all MVpred paths.
#[derive(Debug, Copy, Clone, Default)]
pub struct NeighbourMv {
    pub available: bool,
    pub mb_available: bool,
    pub partition_available: bool,
    pub ref_idx: i32,
    pub mv: Mv,
}

impl NeighbourMv {
    pub const UNAVAILABLE: NeighbourMv = NeighbourMv {
        available: false,
        mb_available: false,
        partition_available: false,
        ref_idx: -1,
        mv: Mv::ZERO,
    };

    pub const fn new(ref_idx: i32, mv: Mv) -> Self {
        NeighbourMv {
            available: ref_idx >= 0,
            mb_available: ref_idx >= 0,
            partition_available: ref_idx >= 0,
            ref_idx,
            mv,
        }
    }

    /// §8.4.1.1 constructor — an intra (or predFlagLX=0) neighbour
    /// whose mbAddr IS available in the §6.4.5 sense AND whose
    /// partition is available per §6.4.11.1 (i.e. the neighbour MB
    /// has been fully decoded). Returns a NeighbourMv with
    /// `available=false` (so MVpred treats it as unusable, mv=0,
    /// refIdx=-1) but `mb_available=true` and `partition_available=
    /// true`: the §8.4.1.1 "mbAddrA is not available" check does NOT
    /// trigger zero-forcing, and the §8.4.1.3.2 C→D substitution does
    /// NOT fire (step 2a's intra filtering has already collapsed mv=0,
    /// ref=-1 for the median's C slot).
    ///
    /// This is the §8.4.1.3.2 step 2a folding of (intra / predFlagLX=0)
    /// neighbours into the MVpred abstraction.
    pub const fn intra_but_mb_available() -> Self {
        NeighbourMv {
            available: false,
            mb_available: true,
            partition_available: true,
            ref_idx: -1,
            mv: Mv::ZERO,
        }
    }

    /// §6.4.11.1 / §8.4.1.3.2 constructor — a neighbour that is a
    /// later (sub-)partition of the CURRENT in-flight macroblock in
    /// decoding order, so it hasn't been decoded yet. Its mbAddr IS
    /// the current MB's address (i.e. available in the §6.4.5 sense)
    /// but the partition itself is NOT available per §6.4.11.1 → the
    /// §8.4.1.3.2 eq. 8-214..8-216 C→D substitution fires for this
    /// neighbour if it is the C slot.
    ///
    /// Used by neighbour lookups for 4x4 / 8x8 / 4x8 / 8x4 sub-macro-
    /// block partitions inside a P_8x8 or B_8x8 MB: when the C
    /// neighbour's position falls in a not-yet-decoded sub-partition
    /// of the current MB, C is partition-unavailable and D must
    /// substitute. See frame-1 MB 53 sub-partition-2 block-3 in the
    /// AUD_MW_E conformance trace for the motivating regression.
    pub const fn partition_not_yet_decoded_same_mb() -> Self {
        NeighbourMv {
            available: false,
            mb_available: true,
            partition_available: false,
            ref_idx: -1,
            mv: Mv::ZERO,
        }
    }
}

// ---------------------------------------------------------------------------
// §8.4.1.3 Luma MV prediction — the MVpred dispatch.
// ---------------------------------------------------------------------------

/// Current partition shape, per §8.4.1.3 eq. 8-203..8-206.
/// The three special directional cases bypass median and take the MV
/// of a specific neighbour *when its refIdx matches*. Otherwise we
/// fall through to median (§8.4.1.3.1).
#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
pub enum MvpredShape {
    /// Default: median of A, B, C (§8.4.1.3.1).
    #[default]
    Default,
    /// 16x8 top partition, mbPartIdx == 0: mvpLX = mvLXB if
    /// refIdxLXB == refIdxLX (eq. 8-203), else median.
    Partition16x8Top,
    /// 16x8 bottom partition, mbPartIdx == 1: mvpLX = mvLXA if
    /// refIdxLXA == refIdxLX (eq. 8-204), else median.
    Partition16x8Bottom,
    /// 8x16 left partition, mbPartIdx == 0: mvpLX = mvLXA if
    /// refIdxLXA == refIdxLX (eq. 8-205), else median.
    Partition8x16Left,
    /// 8x16 right partition, mbPartIdx == 1: mvpLX = mvLXC if
    /// refIdxLXC == refIdxLX (eq. 8-206), else median.
    Partition8x16Right,
}

/// Inputs to the top-level MVpred derivation (§8.4.1.3).
///
/// Per §8.4.1.3.2 the following rules apply and are handled inside
/// [`derive_mvpred`]:
///   * C→D substitution (eq. 8-214..8-216): when the physical
///     neighbour C is not available, the above-left neighbour D
///     substitutes for C. Callers that can supply D should populate
///     [`MvpredInputs::neighbour_d`]; callers that don't track D
///     may leave it at the default (`NeighbourMv::UNAVAILABLE`), in
///     which case the existing behaviour is preserved (C stays
///     unavailable and contributes (0,0) per §8.4.1.3.2).
///   * Unavailable/Intra/predFlagLX=0 neighbours (§8.4.1.3.2): the
///     caller must set `mv = 0, ref_idx = -1, available = false`.
///
/// `neighbour_d` is additive and defaults to
/// `NeighbourMv::UNAVAILABLE`, so callers that don't populate it
/// retain pre-substitution behaviour.
#[derive(Debug, Copy, Clone, Default)]
pub struct MvpredInputs {
    pub neighbour_a: NeighbourMv,
    pub neighbour_b: NeighbourMv,
    pub neighbour_c: NeighbourMv,
    pub current_ref_idx: i32,
    pub shape: MvpredShape,
}

impl MvpredInputs {
    /// Build an `MvpredInputs` from the (A, B, C) neighbour set with
    /// D left as `NeighbourMv::UNAVAILABLE`. Convenience for callers
    /// that don't track D.
    pub fn from_abc(
        neighbour_a: NeighbourMv,
        neighbour_b: NeighbourMv,
        neighbour_c: NeighbourMv,
        current_ref_idx: i32,
        shape: MvpredShape,
    ) -> Self {
        Self {
            neighbour_a,
            neighbour_b,
            neighbour_c,
            current_ref_idx,
            shape,
        }
    }
}

/// §8.4.1.3 — Derive the luma motion vector predictor mvpLX.
///
/// Implements eq. 8-203..8-206 (directional shortcuts) and falls
/// through to the median process eq. 8-207..8-213 via
/// [`derive_median_mvpred`].
///
/// For callers that track the D (above-left) neighbour, use
/// [`derive_mvpred_with_d`] to enable the §8.4.1.3.2 eq. 8-214..8-216
/// C→D substitution. `derive_mvpred` is a thin wrapper that passes
/// `NeighbourMv::UNAVAILABLE` for D, preserving the historical
/// behaviour (no substitution).
pub fn derive_mvpred(inputs: &MvpredInputs) -> Mv {
    derive_mvpred_with_d(inputs, NeighbourMv::UNAVAILABLE)
}

/// §8.4.1.3 — Derive mvpLX with an explicit above-left (D) neighbour.
///
/// Applies the §8.4.1.3.2 eq. 8-214..8-216 C→D substitution: when
/// partition C is not available but D is, C's (mv, refIdx, avail)
/// is replaced by D's before the median-of-3 derivation of
/// §8.4.1.3.1. Per spec, this substitution applies only to the
/// neighbour-data derivation feeding the median path; the directional
/// shortcut shapes (16x8 top/bottom, 8x16 left/right) in §8.4.1.3
/// eq. 8-203..8-206 address specific neighbours (A or B or C) and
/// the substitution only affects the C-based 8x16-right shortcut
/// (mvpLX := mvLXC when refIdxLXC matches). The 16x8-top /
/// 16x8-bottom / 8x16-left shortcuts don't reference C and are
/// therefore unaffected.
///
/// The C→D substitution is applied for ALL shapes here (including
/// `Partition8x16Right`, which does consult C, and the `Default`
/// median path). It is NOT applied for shapes that don't read C
/// (16x8-top, 16x8-bottom, 8x16-left) — for those the substitution
/// has no effect regardless of whether it's performed.
pub fn derive_mvpred_with_d(inputs: &MvpredInputs, neighbour_d: NeighbourMv) -> Mv {
    let MvpredInputs {
        neighbour_a: a,
        neighbour_b: b,
        neighbour_c: c_raw,
        current_ref_idx,
        shape,
    } = *inputs;

    // §8.4.1.3.2 eq. 8-214..8-216 — if partition C is not available
    // but D is, substitute D for C:
    //   mbAddrC        := mbAddrD
    //   mbPartIdxC     := mbPartIdxD
    //   subMbPartIdxC  := subMbPartIdxD
    //
    // The "partition C is not available" test refers to §6.4.11.1
    // (sub-)partition availability, which includes two cases:
    //   (1) mbAddrC itself is not available per §6.4.5 (outside the
    //       picture / different slice), AND
    //   (2) the partition mbAddrC\mbPartIdxC\subMbPartIdxC has not
    //       yet been decoded — e.g. it is a later sub-partition of
    //       the CURRENT in-flight MB.
    // It does NOT refer to the §8.4.1.3.2 step 2a filtering that
    // collapses intra-coded or predFlagLX==0 neighbours to (mvLXN=0,
    // refIdxLXN=-1): an intra neighbour whose MB has been decoded
    // still has an available partition per §6.4.11.1.
    //
    // `NeighbourMv::partition_available` tracks §6.4.11.1 partition-
    // level availability independently of MVpred-usability; gate the
    // substitution on that bit.
    let c = if !c_raw.partition_available && neighbour_d.partition_available {
        neighbour_d
    } else {
        c_raw
    };

    // §8.4.1.3 eq. 8-203..8-206 — directional shortcuts that bypass
    // median iff the selected neighbour's refIdx matches. The spec
    // phrasing is "if refIdxLXB is equal to refIdxLX": this requires
    // the neighbour to be available (refIdxLXB >= 0) and to match.
    match shape {
        MvpredShape::Partition16x8Top if b.ref_idx == current_ref_idx && b.available => {
            return b.mv;
        }
        MvpredShape::Partition16x8Bottom if a.ref_idx == current_ref_idx && a.available => {
            return a.mv;
        }
        MvpredShape::Partition8x16Left if a.ref_idx == current_ref_idx && a.available => {
            return a.mv;
        }
        MvpredShape::Partition8x16Right if c.ref_idx == current_ref_idx && c.available => {
            return c.mv;
        }
        _ => {}
    }

    derive_median_mvpred(a, b, c, current_ref_idx)
}

/// §8.4.1.3.1 — Median luma motion vector prediction.
///
/// Implements eq. 8-207..8-213. First, the "B and C both unavailable
/// but A available" rule copies A to B and C (so median collapses to
/// A). Then the "exactly one neighbour's refIdx matches current"
/// rule yields that neighbour's MV (eq. 8-211). Otherwise each
/// component is the median of A, B, C (eq. 8-212/8-213).
pub fn derive_median_mvpred(
    a: NeighbourMv,
    b: NeighbourMv,
    c: NeighbourMv,
    current_ref_idx: i32,
) -> Mv {
    // §8.4.1.3.1 step 1, eq. 8-207..8-210: when both B and C are
    // unavailable but A is available, replace B and C with A.
    //
    // "Not available" here refers to §6.4.11 (sub-)partition-level
    // availability — the partition exists in the picture and has been
    // decoded. It does NOT refer to the §8.4.1.3.2 step 2a filtering
    // that collapses intra or predFlagLX==0 neighbours to (mv=0,
    // ref=-1): those neighbours still have an available partition
    // per §6.4.11. Gate the replacement on `partition_available`.
    //
    // This is exactly the same distinction as the C→D substitution in
    // §8.4.1.3.2 eq. 8-214..8-216. See the commit message for fix
    // §8.4.1.3.2 C→D substitution trigger (partition-level vs
    // MVpred-filtered availability). Frame-18 MB #80 sub-MB 0 in
    // AUD_MW_E is the motivating regression: its B and C neighbours
    // live in an intra MB (#69) whose partition is available, while A
    // is an inter neighbour with a non-matching refIdx; the median
    // must therefore be median(mvA.x, 0, 0), not A copied to B and C.
    let (a_eff, b_eff, c_eff) =
        if !b.partition_available && !c.partition_available && a.partition_available {
            (a, a, a)
        } else {
            (a, b, c)
        };

    // §8.4.1.3.1 step 2 — count how many of A/B/C match current
    // refIdxLX. Matching requires the neighbour to be available
    // (ref_idx >= 0) — an unavailable neighbour has refIdx = -1 and
    // cannot match a valid current refIdx (>= 0).
    let a_match = a_eff.available && a_eff.ref_idx == current_ref_idx;
    let b_match = b_eff.available && b_eff.ref_idx == current_ref_idx;
    let c_match = c_eff.available && c_eff.ref_idx == current_ref_idx;
    let match_count = (a_match as u32) + (b_match as u32) + (c_match as u32);

    if match_count == 1 {
        // eq. 8-211 — take the one matching neighbour's MV.
        if a_match {
            return a_eff.mv;
        }
        if b_match {
            return b_eff.mv;
        }
        return c_eff.mv;
    }

    // Otherwise each component is the median of the three. A
    // neighbour that is unavailable contributes mv = (0, 0) per
    // §8.4.1.3.2 (the caller should already have set it so).
    let x = median3(a_eff.mv.x, b_eff.mv.x, c_eff.mv.x);
    let y = median3(a_eff.mv.y, b_eff.mv.y, c_eff.mv.y);
    Mv::new(x, y)
}

/// Median of three integers, per §8.4.1.3.1 eq. 8-212/8-213.
/// `median(a,b,c) = a + b + c - min(a,min(b,c)) - max(a,max(b,c))`.
#[inline]
fn median3(a: i32, b: i32, c: i32) -> i32 {
    let lo = a.min(b.min(c));
    let hi = a.max(b.max(c));
    a + b + c - lo - hi
}

// ---------------------------------------------------------------------------
// §8.4.1.2 P_Skip luma motion vector derivation.
// ---------------------------------------------------------------------------

/// §8.4.1.2 — Luma MV for a P_Skip macroblock.
///
/// Per eq. 8-174 refIdxL0 = 0. Per §8.4.1.2 the spec lists four
/// conditions under which mvL0 is forced to (0, 0):
///   * mbAddrA is not available,
///   * mbAddrB is not available,
///   * refIdxL0A == 0 AND both components of mvL0A are 0,
///   * refIdxL0B == 0 AND both components of mvL0B are 0.
///
/// Otherwise, the standard §8.4.1.3 median derivation is invoked
/// with mbPartIdx=0, subMbPartIdx=0, refIdxLX=0, currSubMbType="na".
///
/// Callers that track the D (above-left) neighbour should use
/// [`derive_p_skip_mv_with_d`] to enable the §8.4.1.3.2
/// eq. 8-214..8-216 C→D substitution. This wrapper passes
/// `NeighbourMv::UNAVAILABLE` for D, preserving prior behaviour.
///
/// Returns `(refIdxL0 = 0, mvL0)`.
pub fn derive_p_skip_mv(a: NeighbourMv, b: NeighbourMv, c: NeighbourMv) -> (i32, Mv) {
    derive_p_skip_mv_with_d(a, b, c, NeighbourMv::UNAVAILABLE)
}

/// §8.4.1.2 — Luma MV for a P_Skip macroblock with explicit D
/// (above-left) neighbour for §8.4.1.3.2 C→D substitution.
///
/// Same contract as [`derive_p_skip_mv`], but applies the
/// eq. 8-214..8-216 substitution when C is unavailable and D is
/// available before invoking the §8.4.1.3.1 median derivation.
pub fn derive_p_skip_mv_with_d(
    a: NeighbourMv,
    b: NeighbourMv,
    c: NeighbourMv,
    d: NeighbourMv,
) -> (i32, Mv) {
    let ref_idx_l0 = 0;

    // §8.4.1.1 zero-MV substitution conditions.
    //
    // The first two clauses ("mbAddrA is not available" /
    // "mbAddrB is not available") refer to §6.4.5 macroblock-address
    // availability — NOT to whether the neighbour is usable for
    // MVpred. An intra neighbour has an AVAILABLE mbAddr but its
    // refIdxLXN is set to −1 per §8.4.1.3.2, which causes the third
    // (A) or fourth (B) clause to NOT trigger ("refIdxL0A == 0"
    // evaluates false on −1). In that situation we fall through to
    // the §8.4.1.3 median path, contributing mv = (0, 0) for the
    // intra slot.
    //
    // `mb_available` distinguishes the two: it is true when mbAddrN
    // itself is within the picture and the same slice, regardless of
    // intra filtering. `available` continues to mean "usable for
    // MVpred" (i.e. inter, predFlagLX=1 for the relevant list).
    let force_zero = !a.mb_available
        || !b.mb_available
        || (a.ref_idx == 0 && a.mv == Mv::ZERO)
        || (b.ref_idx == 0 && b.mv == Mv::ZERO);

    if force_zero {
        return (ref_idx_l0, Mv::ZERO);
    }

    // §8.4.1.3.2 eq. 8-214..8-216 — C→D substitution before median.
    // Gated on §6.4.11.1 partition-level availability; see
    // `derive_mvpred_with_d` for the full rationale.
    let c_eff = if !c.partition_available && d.partition_available {
        d
    } else {
        c
    };

    // §8.4.1.2 otherwise — invoke §8.4.1.3 median prediction. The
    // P_Skip case always uses shape = Default (no 16x8 / 8x16
    // directional shortcut, since P_Skip is always a single 16x16
    // partition).
    let mv = derive_median_mvpred(a, b, c_eff, ref_idx_l0);
    (ref_idx_l0, mv)
}

// ---------------------------------------------------------------------------
// §8.4.1.2.2 B-slice spatial direct mode.
// ---------------------------------------------------------------------------

/// §8.4.1.2.2 — B-slice spatial direct luma MV / refIdx derivation
/// (step 4, eq. 8-184..8-190).
///
/// Implements the "common" sub-macroblock spatial direct rule:
///   refIdxL0 = MinPositive(refIdxL0A, MinPositive(refIdxL0B, refIdxL0C))   (8-184)
///   refIdxL1 = MinPositive(refIdxL1A, MinPositive(refIdxL1B, refIdxL1C))   (8-185)
/// and if both turn out < 0:
///   refIdxL0 = 0, refIdxL1 = 0, directZeroPredictionFlag = 1               (8-188..8-190)
///
/// The caller supplies the A/B/C neighbour (mv, refIdx) pairs for
/// both lists. This function does NOT perform the colZeroFlag /
/// temporal-reference-list checks of §8.4.1.2.2 steps 5..onward
/// (those require information about RefPicList1[0] that is beyond
/// the scope of this module). It returns the (refIdxL0, mvL0,
/// refIdxL1, mvL1) assuming the colZeroFlag / directZeroPredictionFlag
/// branches that force an MV to zero are not triggered. For those
/// branches, the caller should zero the corresponding MV.
///
/// Returns `(refIdxL0, mvL0, refIdxL1, mvL1)`.
pub fn derive_b_spatial_direct(
    a_l0: NeighbourMv,
    a_l1: NeighbourMv,
    b_l0: NeighbourMv,
    b_l1: NeighbourMv,
    c_l0: NeighbourMv,
    c_l1: NeighbourMv,
) -> (i32, Mv, i32, Mv) {
    derive_b_spatial_direct_with_d(
        a_l0,
        a_l1,
        b_l0,
        b_l1,
        c_l0,
        c_l1,
        NeighbourMv::UNAVAILABLE,
        NeighbourMv::UNAVAILABLE,
    )
}

/// §8.4.1.2.2 — B-slice spatial direct derivation with explicit D
/// (above-left) neighbours for both lists.
///
/// Applies the §8.4.1.3.2 eq. 8-214..8-216 C→D substitution to each
/// list's C neighbour before invoking the §8.4.1.3.1 median
/// derivation. Also substitutes D's refIdx into the MinPositive
/// chain (eq. 8-184/8-185) when C's is unavailable (ref_idx < 0
/// with available = false is our convention).
#[allow(clippy::too_many_arguments)]
pub fn derive_b_spatial_direct_with_d(
    a_l0: NeighbourMv,
    a_l1: NeighbourMv,
    b_l0: NeighbourMv,
    b_l1: NeighbourMv,
    c_l0: NeighbourMv,
    c_l1: NeighbourMv,
    d_l0: NeighbourMv,
    d_l1: NeighbourMv,
) -> (i32, Mv, i32, Mv) {
    // §8.4.1.3.2 eq. 8-214..8-216 — C→D substitution (per list).
    // Gated on §6.4.11.1 partition-level availability; see
    // `derive_mvpred_with_d` for the full rationale.
    let c_l0_eff = if !c_l0.partition_available && d_l0.partition_available {
        d_l0
    } else {
        c_l0
    };
    let c_l1_eff = if !c_l1.partition_available && d_l1.partition_available {
        d_l1
    } else {
        c_l1
    };

    // §8.4.1.2.2 eq. 8-184/8-185 — MinPositive chain, using the
    // substituted C (eq. 8-214..8-216 output).
    let mut ref_idx_l0 = min_positive(a_l0.ref_idx, min_positive(b_l0.ref_idx, c_l0_eff.ref_idx));
    let mut ref_idx_l1 = min_positive(a_l1.ref_idx, min_positive(b_l1.ref_idx, c_l1_eff.ref_idx));

    // §8.4.1.2.2 eq. 8-188..8-190 — directZeroPredictionFlag.
    let direct_zero = ref_idx_l0 < 0 && ref_idx_l1 < 0;
    if direct_zero {
        ref_idx_l0 = 0;
        ref_idx_l1 = 0;
    }

    // MVs: if refIdxLX < 0 after the above we force mv to zero;
    // otherwise invoke §8.4.1.3 median prediction with shape =
    // Default (spatial direct is always a single 4x4 or 8x8 sub
    // with no directional shortcut).
    let mv_l0 = if direct_zero || ref_idx_l0 < 0 {
        Mv::ZERO
    } else {
        derive_median_mvpred(a_l0, b_l0, c_l0_eff, ref_idx_l0)
    };
    let mv_l1 = if direct_zero || ref_idx_l1 < 0 {
        Mv::ZERO
    } else {
        derive_median_mvpred(a_l1, b_l1, c_l1_eff, ref_idx_l1)
    };

    (ref_idx_l0, mv_l0, ref_idx_l1, mv_l1)
}

/// §8.4.1.2.2 eq. 8-187 — MinPositive(x, y).
/// Returns Min(x, y) when both are >= 0, else Max(x, y).
#[inline]
fn min_positive(x: i32, y: i32) -> i32 {
    if x >= 0 && y >= 0 {
        x.min(y)
    } else {
        x.max(y)
    }
}

// ---------------------------------------------------------------------------
// §8.4.1.2.3 B-slice temporal direct mode.
// ---------------------------------------------------------------------------

/// §8.4.1.2.3 — B-slice temporal direct motion-vector scaling
/// (eq. 8-195..8-202).
///
/// Given the co-located block's motion vector `mvCol` and the POC
/// values, compute the scaled mvL0 and mvL1 for the current partition.
///
/// Inputs:
/// - `colocated_mv` — mvCol (the L0 MV of the co-located partition,
///   or the L1 MV if predFlagL0Col == 0 — the caller selects).
/// - `col_pic_poc`  — POC of pic1 (the picture containing the
///   co-located partition).
/// - `list0_ref_poc` — POC of pic0 (the L0 reference chosen for the
///   current macroblock's direct-mode prediction).
/// - `curr_pic_poc`  — POC of currPicOrField.
///
/// Returns `(mvL0, mvL1)`.
///
/// Implements:
///   tb = Clip3(-128, 127, DiffPicOrderCnt(currPicOrField, pic0))   (8-201)
///   td = Clip3(-128, 127, DiffPicOrderCnt(pic1, pic0))             (8-202)
///   if DiffPicOrderCnt(pic1, pic0) == 0 or long-term ref:
///       mvL0 = mvCol                                                (8-195)
///       mvL1 = 0                                                    (8-196)
///   else:
///       tx = (16384 + Abs(td/2)) / td                               (8-197)
///       DistScaleFactor = Clip3(-1024, 1023, (tb*tx + 32) >> 6)     (8-198)
///       mvL0 = (DistScaleFactor * mvCol + 128) >> 8                 (8-199)
///       mvL1 = mvL0 - mvCol                                         (8-200)
///
/// DiffPicOrderCnt is simply `a - b` per §8.2.1.
///
/// Note: the long-term-reference path (eq. 8-195/8-196) is selected
/// by the caller passing `col_pic_poc == list0_ref_poc`, which makes
/// `td == 0` and triggers the non-scaling branch.
pub fn derive_b_temporal_direct(
    colocated_mv: Mv,
    col_pic_poc: i32,
    curr_pic_poc: i32,
    list0_ref_poc: i32,
) -> (Mv, Mv) {
    // §8.4.1.2.3 eq. 8-201/8-202.
    let tb = clip3(-128, 127, curr_pic_poc - list0_ref_poc);
    let td_raw = col_pic_poc - list0_ref_poc;
    let td = clip3(-128, 127, td_raw);

    // Non-scaling branch: either td == 0 (DiffPicOrderCnt(pic1,pic0)
    // == 0 — eq. 8-195/8-196) or the long-term-reference case (the
    // caller signals it by setting col_pic_poc == list0_ref_poc,
    // producing td == 0 as well).
    if td == 0 {
        return (colocated_mv, Mv::ZERO);
    }

    // §8.4.1.2.3 eq. 8-197..8-200.
    // tx = (16384 + Abs(td/2)) / td
    // Per spec §5.7, "/" is integer division truncating toward zero.
    // In Rust, i32 / i32 already truncates toward zero.
    let tx = (16384 + (td / 2).abs()) / td;
    let dist_scale_factor = clip3(-1024, 1023, (tb * tx + 32) >> 6);

    let mv_l0_x = (dist_scale_factor * colocated_mv.x + 128) >> 8;
    let mv_l0_y = (dist_scale_factor * colocated_mv.y + 128) >> 8;
    let mv_l0 = Mv::new(mv_l0_x, mv_l0_y);
    let mv_l1 = Mv::new(mv_l0.x - colocated_mv.x, mv_l0.y - colocated_mv.y);

    (mv_l0, mv_l1)
}

/// §5.7 — Clip3(a, b, x): clamp x into [a, b].
#[inline]
fn clip3(a: i32, b: i32, x: i32) -> i32 {
    if x < a {
        a
    } else if x > b {
        b
    } else {
        x
    }
}

// ---------------------------------------------------------------------------
// §6.4.11.7 / §6.4.11.4 Neighbouring 4x4-luma-block derivation.
// ---------------------------------------------------------------------------

/// Source of a neighbouring 4x4 block for the A, B, C, D positions
/// per §6.4.11.7 (and §6.4.11.4 for pure 4x4 neighbours).
///
/// When the neighbour's luma location falls outside the current MB,
/// §6.4.12 dispatches to one of the four adjacent MBs (left / above /
/// above-right / above-left — Table 6-3). The 4x4 block index within
/// that adjacent MB is then computed by eq. 6-38 on the wrapped
/// coordinates.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum NeighbourSource {
    /// Neighbour is inside the current macroblock; the `u8` is its
    /// 4x4 block index (0..=15, raster order per Figure 6-10).
    InternalBlock(u8),
    /// Neighbour lies in the left macroblock (mbAddrA); the `u8` is
    /// the 4x4 block index within that MB.
    ExternalLeft(u8),
    /// Neighbour lies in the above macroblock (mbAddrB).
    ExternalAbove(u8),
    /// Neighbour lies in the above-right macroblock (mbAddrC).
    ExternalAboveRight(u8),
    /// Neighbour lies in the above-left macroblock (mbAddrD).
    ExternalAboveLeft(u8),
}

/// §6.4.3 eq. 6-17/6-18 — inverse 4x4 luma block scan: given a 4x4
/// block index (0..=15), return the (x, y) luma-sample position of
/// its upper-left corner, relative to the MB's upper-left corner.
///
/// Figure 6-10 layout (rows of 4 blocks each):
///   row 0 (y=0):   0  1  4  5   at x = 0, 4, 8, 12
///   row 1 (y=4):   2  3  6  7
///   row 2 (y=8):   8  9 12 13
///   row 3 (y=12): 10 11 14 15
#[inline]
fn inverse_4x4_luma_scan(idx: u8) -> (i32, i32) {
    // Per eq. 6-17/6-18, using the InverseRasterScan primitive:
    //   x = InverseRasterScan(idx/4, 8, 8, 16, 0) +
    //       InverseRasterScan(idx%4, 4, 4, 8, 0)
    //   y = InverseRasterScan(idx/4, 8, 8, 16, 1) +
    //       InverseRasterScan(idx%4, 4, 4, 8, 1)
    // where InverseRasterScan(a, b, c, d, 0) = (a % (d/b)) * b  (x)
    //       InverseRasterScan(a, b, c, d, 1) = (a / (d/b)) * c  (y)
    let hi = (idx / 4) as i32; // 0..=3, selects 8x8 block
    let lo = (idx % 4) as i32; // 0..=3, selects 4x4 inside 8x8

    // hi: 8x8 grid within 16x16 MB. d/b = 16/8 = 2 columns.
    let x_hi = (hi % 2) * 8;
    let y_hi = (hi / 2) * 8;
    // lo: 4x4 grid within 8x8 block. d/b = 8/4 = 2 columns.
    let x_lo = (lo % 2) * 4;
    let y_lo = (lo / 2) * 4;

    (x_hi + x_lo, y_hi + y_lo)
}

/// §6.4.13.1 eq. 6-38 — compute a 4x4 luma block index from a luma
/// (x, y) position inside a macroblock (both in 0..=15).
///
/// `luma4x4BlkIdx = 8*(y/8) + 4*(x/8) + 2*((y%8)/4) + ((x%8)/4)`.
#[inline]
fn luma_4x4_blk_idx(x: i32, y: i32) -> u8 {
    (8 * (y / 8) + 4 * (x / 8) + 2 * ((y % 8) / 4) + ((x % 8) / 4)) as u8
}

/// §6.4.11.7 / §6.4.11.4 specialised for a 4x4 current block.
///
/// Given the current 4x4 luma block index (0..=15 within the MB),
/// return `[A, B, C, D]` — the sources of the four neighbouring
/// 4x4 blocks. Per Table 6-2 the offsets are:
///   * A : (xD, yD) = (-1,  0)
///   * B : (xD, yD) = ( 0, -1)
///   * C : (xD, yD) = (predPartWidth, -1)   // here predPartWidth = 4
///   * D : (xD, yD) = (-1, -1)
///
/// And per §6.4.12 Table 6-3 the cross-MB dispatch is:
///
///   xN<0, yN<0       -> mbAddrD (above-left)
///   xN<0, 0..maxH-1  -> mbAddrA (left)
///   0..maxW-1, yN<0  -> mbAddrB (above)
///   0..maxW-1 inside -> CurrMbAddr (internal)
///   xN>maxW-1, yN<0  -> mbAddrC (above-right)
///
/// For luma, maxW = maxH = 16. The internal 4x4 index inside the
/// selected MB is computed by §6.4.13.1 eq. 6-38 on the wrapped
/// location (eq. 6-34/6-35).
///
/// Note on neighbour C "not available" substitution (eq. 8-214..8-216
/// in §8.4.1.3.2): that substitution is NOT performed here — it's
/// the caller's responsibility, after querying the availability of
/// the partition containing C.
pub fn neighbour_4x4_map(current_block_idx: u8) -> [NeighbourSource; 4] {
    const PRED_PART_WIDTH: i32 = 4; // §6.4.11.7 step 3 for a 4x4-sized lookup
    const MAX_W: i32 = 16;
    const MAX_H: i32 = 16;

    let (x, y) = inverse_4x4_luma_scan(current_block_idx);

    // Table 6-2 offsets (xD, yD) for A, B, C, D.
    let offsets: [(i32, i32); 4] = [
        (-1, 0),               // A
        (0, -1),               // B
        (PRED_PART_WIDTH, -1), // C
        (-1, -1),              // D
    ];

    let mut out = [NeighbourSource::InternalBlock(0); 4];
    for (i, (xd, yd)) in offsets.iter().copied().enumerate() {
        // Neighbouring luma location (xN, yN) = (x + xD, y + yD)
        // (§6.4.11.4 eq. 6-25/6-26 — the simple 4x4-block case).
        let xn = x + xd;
        let yn = y + yd;

        // §6.4.12.1 Table 6-3 — dispatch based on (xN, yN).
        // Then §6.4.12 eq. 6-34/6-35 give (xW, yW) inside the target MB.
        let source = if xn < 0 && yn < 0 {
            // Above-left MB.
            let xw = (xn + MAX_W).rem_euclid(MAX_W);
            let yw = (yn + MAX_H).rem_euclid(MAX_H);
            NeighbourSource::ExternalAboveLeft(luma_4x4_blk_idx(xw, yw))
        } else if xn < 0 && (0..MAX_H).contains(&yn) {
            // Left MB.
            let xw = (xn + MAX_W).rem_euclid(MAX_W);
            let yw = yn;
            NeighbourSource::ExternalLeft(luma_4x4_blk_idx(xw, yw))
        } else if (0..MAX_W).contains(&xn) && yn < 0 {
            // Above MB.
            let xw = xn;
            let yw = (yn + MAX_H).rem_euclid(MAX_H);
            NeighbourSource::ExternalAbove(luma_4x4_blk_idx(xw, yw))
        } else if (0..MAX_W).contains(&xn) && (0..MAX_H).contains(&yn) {
            // Inside the current MB.
            NeighbourSource::InternalBlock(luma_4x4_blk_idx(xn, yn))
        } else if xn > MAX_W - 1 && yn < 0 {
            // Above-right MB.
            let xw = (xn + MAX_W).rem_euclid(MAX_W);
            let yw = (yn + MAX_H).rem_euclid(MAX_H);
            NeighbourSource::ExternalAboveRight(luma_4x4_blk_idx(xw, yw))
        } else {
            // xN > maxW-1 and yN inside MB — per Table 6-3 this is
            // "not available". It should not arise for A/B/C/D
            // offsets from a 4x4 block that are bounded by (-1..=4).
            // We fall back to above-right as a conservative default
            // (it is unreachable in practice for the 4x4 case).
            NeighbourSource::ExternalAboveRight(0)
        };

        out[i] = source;
    }

    out
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    // --- median-of-3 basic -------------------------------------------------

    #[test]
    fn median3_basic() {
        assert_eq!(median3(1, 2, 3), 2);
        assert_eq!(median3(3, 1, 2), 2);
        assert_eq!(median3(-1, 0, 1), 0);
        assert_eq!(median3(5, 5, 5), 5);
        assert_eq!(median3(7, 7, 3), 7);
        assert_eq!(median3(-5, -10, -3), -5);
    }

    // --- §8.4.1.3 MVpred shapes -------------------------------------------

    #[test]
    fn mvpred_all_available_same_refidx_median() {
        // Three neighbours all available, all refIdx = 0; MVpred =
        // median of the three. Using distinct MVs to check per-
        // component median.
        let a = NeighbourMv::new(0, Mv::new(10, 20));
        let b = NeighbourMv::new(0, Mv::new(30, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 40));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        // Hand-computed per eq. 8-212/8-213:
        // median(10, 30, 20) = 20, median(20, 10, 40) = 20.
        // But wait — all three match refIdx 0, match_count = 3, so
        // we fall through to median, not the "exactly one" branch.
        assert_eq!(derive_mvpred(&inputs), Mv::new(20, 20));
    }

    #[test]
    fn mvpred_only_a_matching() {
        // Only A matches refIdx 0; the other two have refIdx = 1.
        // Per eq. 8-211, mvpLX = mvLXA.
        let a = NeighbourMv::new(0, Mv::new(7, -3));
        let b = NeighbourMv::new(1, Mv::new(100, 100));
        let c = NeighbourMv::new(1, Mv::new(-50, 50));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        assert_eq!(derive_mvpred(&inputs), Mv::new(7, -3));
    }

    #[test]
    fn mvpred_no_neighbours_available() {
        // All three unavailable — per §8.4.1.3.2 all MVs should have
        // been pre-set to zero and refIdx = -1 by the caller. With
        // zero match_count, we fall through to median of zeros.
        let inputs = MvpredInputs {
            neighbour_a: NeighbourMv::UNAVAILABLE,
            neighbour_b: NeighbourMv::UNAVAILABLE,
            neighbour_c: NeighbourMv::UNAVAILABLE,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        assert_eq!(derive_mvpred(&inputs), Mv::ZERO);
    }

    #[test]
    fn mvpred_16x8_top_uses_b_when_match() {
        // 16x8 top partition: if refIdxLXB == current_ref_idx, use
        // mvLXB regardless of A/C.
        let a = NeighbourMv::new(1, Mv::new(100, 200));
        let b = NeighbourMv::new(0, Mv::new(5, 5));
        let c = NeighbourMv::new(1, Mv::new(-1, -1));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Partition16x8Top,
        };
        assert_eq!(derive_mvpred(&inputs), Mv::new(5, 5));
    }

    #[test]
    fn mvpred_16x8_top_falls_through_to_median_when_b_mismatches() {
        // 16x8 top, B's refIdx != current -> median path.
        let a = NeighbourMv::new(0, Mv::new(10, 10));
        let b = NeighbourMv::new(1, Mv::new(999, 999));
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Partition16x8Top,
        };
        // match_count = 2 (A and C both match), so fall through to
        // median: median(10, 999, 20) = 20, median(10, 999, 20) = 20.
        assert_eq!(derive_mvpred(&inputs), Mv::new(20, 20));
    }

    #[test]
    fn mvpred_16x8_bottom_uses_a_when_match() {
        let a = NeighbourMv::new(2, Mv::new(9, 11));
        let b = NeighbourMv::new(1, Mv::new(7, 7));
        let c = NeighbourMv::new(2, Mv::new(-1, -1));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 2,
            shape: MvpredShape::Partition16x8Bottom,
        };
        assert_eq!(derive_mvpred(&inputs), Mv::new(9, 11));
    }

    #[test]
    fn mvpred_8x16_left_uses_a_and_right_uses_c() {
        let a = NeighbourMv::new(0, Mv::new(1, 2));
        let b = NeighbourMv::new(0, Mv::new(3, 4));
        let c = NeighbourMv::new(0, Mv::new(5, 6));
        let inputs_left = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Partition8x16Left,
        };
        assert_eq!(derive_mvpred(&inputs_left), Mv::new(1, 2));

        let inputs_right = MvpredInputs {
            shape: MvpredShape::Partition8x16Right,
            ..inputs_left
        };
        assert_eq!(derive_mvpred(&inputs_right), Mv::new(5, 6));
    }

    // --- §8.4.1.3.2 C→D substitution (eq. 8-214..8-216) --------------------

    #[test]
    fn mvpred_with_d_no_substitution_when_c_available() {
        // §8.4.1.3.2: C is available, D is available. The
        // substitution rule only fires when C is UNavailable, so
        // this test must produce the same result as the plain
        // derive_mvpred path (median of A, B, C, with refIdx
        // matches).
        let a = NeighbourMv::new(0, Mv::new(10, 20));
        let b = NeighbourMv::new(0, Mv::new(30, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 40));
        let d = NeighbourMv::new(0, Mv::new(999, 999)); // must not affect
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        // Expected: median(10,30,20) = 20; median(20,10,40) = 20.
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(20, 20));
        // Sanity: derive_mvpred (D = UNAVAILABLE) gives the same
        // value here, because substitution doesn't fire when C is
        // available.
        assert_eq!(derive_mvpred(&inputs), Mv::new(20, 20));
    }

    #[test]
    fn mvpred_with_d_substitutes_when_c_unavailable() {
        // §8.4.1.3.2 eq. 8-214..8-216: C is not available, D is
        // available. D's (mv, refIdx) should substitute for C.
        // All refIdxs match current_ref_idx = 0, so match_count = 3
        // and we fall through to component-wise median of
        // (A, B, D) — not (A, B, 0).
        let a = NeighbourMv::new(0, Mv::new(10, 20));
        let b = NeighbourMv::new(0, Mv::new(30, 10));
        let c = NeighbourMv::UNAVAILABLE;
        let d = NeighbourMv::new(0, Mv::new(20, 40));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        // With substitution: median(10,30,20)=20, median(20,10,40)=20.
        // Without substitution: C would contribute (0,0), giving
        // median(10,30,0)=10, median(20,10,0)=10 — which biases low.
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(20, 20));
    }

    #[test]
    fn mvpred_with_d_falls_through_when_both_c_and_d_unavailable() {
        // §8.4.1.3.2: when neither C nor D is available, no
        // substitution occurs. With A available and B unavailable,
        // the median path runs with C = (0,0), refIdxC = -1. Only
        // A matches the current_ref_idx, so match_count = 1 and
        // eq. 8-211 returns mvA.
        let a = NeighbourMv::new(0, Mv::new(7, -3));
        let b = NeighbourMv::UNAVAILABLE;
        let c = NeighbourMv::UNAVAILABLE;
        let d = NeighbourMv::UNAVAILABLE;
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        // §8.4.1.3.1 step 1: B and C both unavailable, A available ->
        // copy A to B and C -> median(A,A,A) = A = (7, -3).
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(7, -3));

        // Second scenario: A also unavailable => median of zeros.
        let inputs_all_unavail = MvpredInputs {
            neighbour_a: NeighbourMv::UNAVAILABLE,
            neighbour_b: NeighbourMv::UNAVAILABLE,
            neighbour_c: NeighbourMv::UNAVAILABLE,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        assert_eq!(
            derive_mvpred_with_d(&inputs_all_unavail, NeighbourMv::UNAVAILABLE),
            Mv::ZERO
        );
    }

    #[test]
    fn mvpred_with_d_no_substitution_when_c_is_intra_but_mb_available() {
        // §8.4.1.3.2 eq. 8-214..8-216 gates C→D substitution on
        // §6.4.11.1 partition-level availability, NOT on MVpred-
        // usability. An intra neighbour C has an available partition
        // (its MB is decoded; §6.4.11.1 says "available") but is
        // unavailable for MVpred (step 2a collapses it to mv=0,
        // ref=-1). D must NOT substitute in that case — the intra C
        // contributes (0, 0) to the median.
        //
        // This is the AUD_MW_E frame 2 MB #25 scenario: the 8x16 right
        // partition's C neighbour falls inside an I-coded MB (MB 15),
        // forcing the shortcut test `refIdxLXC == refIdxLX` to fail
        // and the median path to run with C contributing zero. Prior
        // to the fix we substituted D's MV (pulling from the above
        // MB's later partition), which produced the wrong pmv.
        let a = NeighbourMv::new(0, Mv::new(11, 7)); // left partition
        let b = NeighbourMv::new(0, Mv::new(7, 8)); // above
        let c_intra = NeighbourMv::intra_but_mb_available();
        let d = NeighbourMv::new(0, Mv::new(7, 8)); // above-left — "trap" for bug regression
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c_intra,
            current_ref_idx: 0,
            shape: MvpredShape::Partition8x16Right,
        };
        // 8x16-right shortcut: C is unavailable for MVpred (intra,
        // ref=-1) -> shortcut bypass does NOT fire (-1 != 0) -> median
        // path. A and B match ref=0, C doesn't (ref=-1). match_count=2,
        // so per-component median with C contributing 0:
        //   median(11, 7, 0) = 7
        //   median( 7, 8, 0) = 7
        // Not (7, 8) that D-substitution would have produced!
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(7, 7));
    }

    #[test]
    fn mvpred_with_d_substitutes_when_c_partition_not_yet_decoded() {
        // §6.4.11.1 / §8.4.1.3.2: C partition is within the current
        // (in-flight) MB but hasn't been decoded yet (e.g. a later
        // sub-MB partition during P_8x8 decoding). That partition is
        // NOT available per §6.4.11.1 -> D substitutes.
        //
        // This is the AUD_MW_E frame 1 MB #53 sub-partition-2 block-3
        // scenario: while decoding sub 2 block 3 (P_L0_4x4 at origin
        // (4, 12) within MB 53), the C neighbour position falls in
        // sub 3 (not yet decoded). Without substitution we'd mislabel
        // C as "inter predFlagLX=0" and leak a zero into the median.
        let a = NeighbourMv::new(0, Mv::new(14, 6));
        let b = NeighbourMv::new(0, Mv::new(13, 3));
        let c_not_yet_decoded = NeighbourMv::partition_not_yet_decoded_same_mb();
        let d = NeighbourMv::new(0, Mv::new(14, 4));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c_not_yet_decoded,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        // Substitution fires: C := D = (14, 4) ref=0. match_count=3,
        // so per-component median:
        //   median(14, 13, 14) = 14
        //   median( 6,  3,  4) =  4
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(14, 4));

        // Sanity: without D, C contributes 0 -> median(14,13,0)=13,
        // median(6,3,0)=3 -> (13, 3). So D's substitution changes the
        // result.
        let (_r, mv_no_d) = (0, derive_mvpred(&inputs));
        let _ = _r;
        assert_eq!(mv_no_d, Mv::new(13, 3));
    }

    #[test]
    fn mvpred_with_d_substitution_not_applied_for_16x8_top() {
        // §8.4.1.3 eq. 8-203: the 16x8 top directional shortcut
        // consults B only — it doesn't read C. So whether we apply
        // the C→D substitution or not, the outcome is identical
        // when B matches current_ref_idx.
        //
        // Here C is unavailable and D is available with a "trap"
        // MV that differs wildly from B. If the substitution were
        // (incorrectly) applied to the directional shortcut path
        // such that it consulted C=D instead of B, we'd get D's MV.
        // The correct behaviour is to return mvLXB.
        let a = NeighbourMv::new(1, Mv::new(100, 200));
        let b = NeighbourMv::new(0, Mv::new(5, 5));
        let c = NeighbourMv::UNAVAILABLE;
        let d = NeighbourMv::new(0, Mv::new(-999, -999)); // trap
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: b,
            neighbour_c: c,
            current_ref_idx: 0,
            shape: MvpredShape::Partition16x8Top,
        };
        // 16x8-top shortcut fires (B available, refIdxLXB matches)
        // -> mvpLX = mvLXB = (5, 5). D must not leak into the
        // result.
        assert_eq!(derive_mvpred_with_d(&inputs, d), Mv::new(5, 5));
    }

    // --- §8.4.1.3.2 C→D substitution — P_Skip ------------------------------

    #[test]
    fn p_skip_with_d_substitutes_when_c_unavailable() {
        // P_Skip median path: A, B available with refIdx 0 and
        // non-zero MVs; C unavailable; D available. Expect the
        // substitution to put D in C's place in the median.
        let a = NeighbourMv::new(0, Mv::new(10, 20));
        let b = NeighbourMv::new(0, Mv::new(30, 40));
        let c = NeighbourMv::UNAVAILABLE;
        let d = NeighbourMv::new(0, Mv::new(50, 60));
        let (ref_idx, mv) = derive_p_skip_mv_with_d(a, b, c, d);
        assert_eq!(ref_idx, 0);
        // With substitution: median(10,30,50)=30, median(20,40,60)=40.
        assert_eq!(mv, Mv::new(30, 40));
        // Without substitution: C contributes 0s -> median(10,30,0)=10,
        // median(20,40,0)=20. So the substitution changed the result.
        let (_, mv_no_sub) = derive_p_skip_mv(a, b, c);
        assert_eq!(mv_no_sub, Mv::new(10, 20));
    }

    #[test]
    fn mvpred_only_a_available_b_and_c_copied() {
        // §8.4.1.3.1 step 1: B and C both unavailable, A available.
        // Spec says replace B and C with A — then median of (A,A,A)
        // = A.
        let a = NeighbourMv::new(0, Mv::new(42, -42));
        let inputs = MvpredInputs {
            neighbour_a: a,
            neighbour_b: NeighbourMv::UNAVAILABLE,
            neighbour_c: NeighbourMv::UNAVAILABLE,
            current_ref_idx: 0,
            shape: MvpredShape::Default,
        };
        assert_eq!(derive_mvpred(&inputs), Mv::new(42, -42));
    }

    // --- §8.4.1.2 P_Skip ---------------------------------------------------

    #[test]
    fn p_skip_all_available_median() {
        // All three neighbours available with distinct non-zero MVs,
        // refIdx all = 0. None of the zero-forcing conditions apply,
        // so we take the median.
        let a = NeighbourMv::new(0, Mv::new(10, 20));
        let b = NeighbourMv::new(0, Mv::new(30, 40));
        let c = NeighbourMv::new(0, Mv::new(50, 60));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        // median(10,30,50) = 30, median(20,40,60) = 40.
        assert_eq!(mv, Mv::new(30, 40));
    }

    #[test]
    fn p_skip_a_unavailable_forces_zero() {
        let a = NeighbourMv::UNAVAILABLE;
        let b = NeighbourMv::new(0, Mv::new(10, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        assert_eq!(mv, Mv::ZERO);
    }

    #[test]
    fn p_skip_b_unavailable_forces_zero() {
        let a = NeighbourMv::new(0, Mv::new(10, 10));
        let b = NeighbourMv::UNAVAILABLE;
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        assert_eq!(mv, Mv::ZERO);
    }

    #[test]
    fn p_skip_a_zero_mv_refidx0_forces_zero() {
        let a = NeighbourMv::new(0, Mv::ZERO);
        let b = NeighbourMv::new(0, Mv::new(20, 20));
        let c = NeighbourMv::new(0, Mv::new(30, 30));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        assert_eq!(mv, Mv::ZERO);
    }

    #[test]
    fn p_skip_a_refidx_nonzero_does_not_force_zero() {
        // If A's refIdx != 0, the "refIdxL0A == 0 AND mvL0A == 0"
        // clause does NOT apply — so we proceed to median (assuming
        // B and C are fine too).
        let a = NeighbourMv::new(1, Mv::new(5, 5));
        let b = NeighbourMv::new(0, Mv::new(10, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        // current_ref_idx = 0; only B and C match -> match_count = 2
        // -> median branch. median(5,10,20) = 10, same for y.
        assert_eq!(mv, Mv::new(10, 10));
    }

    #[test]
    fn p_skip_a_intra_does_not_force_zero() {
        // §8.4.1.1 regression: an INTRA left neighbour has
        // mbAddrA available (§6.4.5) but refIdxL0A = −1 and mvL0A = 0
        // (§8.4.1.3.2). The P_Skip zero-forcing conditions:
        //   - mbAddrA not available: FALSE (mbAddr is available)
        //   - refIdxL0A == 0 AND mvL0A == 0: FALSE (refIdx is −1)
        // So the zero-forcing does NOT trigger and we proceed to the
        // §8.4.1.3 median derivation with A contributing (0, 0) /
        // refIdx = −1 (so A does not match current refIdx = 0).
        //
        // This is the AUD_MW_E frame 1 MB 78 scenario: MB 78 is
        // P_Skip whose A neighbour (MB 77) is an intra I_16x16 MB
        // embedded in a P-slice. Prior to the fix, we set A's
        // `available = false` for both cases, causing the "mbAddrA
        // not available" zero-force to fire and producing mv = 0 when
        // the spec expected a median-predicted (non-zero) MV.
        let a_intra = NeighbourMv::intra_but_mb_available();
        let b = NeighbourMv::new(0, Mv::new(10, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a_intra, b, c);
        assert_eq!(ref_idx, 0);
        // current_ref_idx = 0. A unavailable-for-MVpred (ref=−1), B
        // and C match refIdx=0 => match_count=2 (not exactly 1) =>
        // median branch. Contributions: A (0,0) since available=false
        // contributes 0 per §8.4.1.3.2; B=(10,10); C=(20,20).
        // median(0,10,20) = 10, median(0,10,20) = 10.
        assert_eq!(mv, Mv::new(10, 10));
    }

    #[test]
    fn p_skip_b_intra_does_not_force_zero() {
        // Symmetric: intra top (B) neighbour.
        let a = NeighbourMv::new(0, Mv::new(10, 10));
        let b_intra = NeighbourMv::intra_but_mb_available();
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a, b_intra, c);
        assert_eq!(ref_idx, 0);
        // median(10, 0, 20) = 10, 10.
        assert_eq!(mv, Mv::new(10, 10));
    }

    #[test]
    fn p_skip_a_unavailable_still_forces_zero() {
        // Ensure the mb_available=false path (true §6.4.5
        // unavailability — mbAddr outside the picture or different
        // slice) continues to trigger zero-forcing. Only the intra
        // path is affected by the fix; this boundary case must
        // remain stable.
        let a = NeighbourMv::UNAVAILABLE; // mb_available = false
        let b = NeighbourMv::new(0, Mv::new(10, 10));
        let c = NeighbourMv::new(0, Mv::new(20, 20));
        let (ref_idx, mv) = derive_p_skip_mv(a, b, c);
        assert_eq!(ref_idx, 0);
        assert_eq!(mv, Mv::ZERO);
    }

    // --- §8.4.1.2.2 B spatial direct --------------------------------------

    #[test]
    fn b_spatial_direct_min_positive_basic() {
        // All available with various L0 refs; L1 mostly unavailable.
        // refIdxL0 = MinPositive(2, MinPositive(5, 3)) = MinPositive(2, 3) = 2.
        let a_l0 = NeighbourMv::new(2, Mv::new(1, 2));
        let b_l0 = NeighbourMv::new(5, Mv::new(3, 4));
        let c_l0 = NeighbourMv::new(3, Mv::new(5, 6));
        let a_l1 = NeighbourMv::UNAVAILABLE;
        let b_l1 = NeighbourMv::UNAVAILABLE;
        let c_l1 = NeighbourMv::UNAVAILABLE;

        let (r0, mv0, r1, mv1) = derive_b_spatial_direct(a_l0, a_l1, b_l0, b_l1, c_l0, c_l1);
        assert_eq!(r0, 2);
        // L1 all unavailable -> MinPositive = -1 for L1. But L0 is
        // valid (>= 0), so directZeroPredictionFlag = 0. L1's MV is
        // forced to zero because refIdxL1 < 0 after
        // MinPositive.
        assert_eq!(r1, -1);
        assert_eq!(mv1, Mv::ZERO);

        // For L0: only A matches refIdx 2 -> mvpLX = mvLXA = (1, 2).
        assert_eq!(mv0, Mv::new(1, 2));
    }

    #[test]
    fn b_spatial_direct_both_negative_triggers_zero_fallback() {
        // All neighbours unavailable -> both refIdx sums are < 0 ->
        // directZeroPredictionFlag = 1 -> refs forced to 0, MVs 0.
        let (r0, mv0, r1, mv1) = derive_b_spatial_direct(
            NeighbourMv::UNAVAILABLE,
            NeighbourMv::UNAVAILABLE,
            NeighbourMv::UNAVAILABLE,
            NeighbourMv::UNAVAILABLE,
            NeighbourMv::UNAVAILABLE,
            NeighbourMv::UNAVAILABLE,
        );
        assert_eq!(r0, 0);
        assert_eq!(r1, 0);
        assert_eq!(mv0, Mv::ZERO);
        assert_eq!(mv1, Mv::ZERO);
    }

    #[test]
    fn b_spatial_direct_both_lists_present() {
        let a_l0 = NeighbourMv::new(0, Mv::new(4, 8));
        let b_l0 = NeighbourMv::new(0, Mv::new(12, 16));
        let c_l0 = NeighbourMv::new(0, Mv::new(8, 4));
        let a_l1 = NeighbourMv::new(1, Mv::new(-4, -8));
        let b_l1 = NeighbourMv::new(1, Mv::new(-12, -16));
        let c_l1 = NeighbourMv::new(1, Mv::new(-8, -4));

        let (r0, mv0, r1, mv1) = derive_b_spatial_direct(a_l0, a_l1, b_l0, b_l1, c_l0, c_l1);
        assert_eq!(r0, 0);
        assert_eq!(r1, 1);
        // L0 all match refIdx 0 -> median of (4,12,8) = 8;
        //                         median of (8,16,4) = 8.
        assert_eq!(mv0, Mv::new(8, 8));
        // L1 all match refIdx 1 -> median of (-4,-12,-8) = -8, same.
        assert_eq!(mv1, Mv::new(-8, -8));
    }

    // --- §8.4.1.2.3 B temporal direct --------------------------------------

    #[test]
    fn b_temporal_direct_forward_scaling() {
        // Hand-computed example: current at POC 10, list0 ref at
        // POC 0, colocated at POC 20. Col MV = (16, 32).
        //
        // tb = Clip3(-128,127, 10 - 0)  = 10
        // td = Clip3(-128,127, 20 - 0)  = 20
        // tx = (16384 + Abs(20/2)) / 20 = (16384 + 10) / 20 = 16394/20 = 819
        // DistScaleFactor = Clip3(-1024,1023, (10*819 + 32) >> 6)
        //                 = Clip3(..., (8190+32) >> 6)
        //                 = Clip3(..., 8222 >> 6)
        //                 = Clip3(..., 128) = 128.
        // mvL0.x = (128 * 16 + 128) >> 8 = (2048 + 128) >> 8 = 2176 >> 8 = 8.
        // mvL0.y = (128 * 32 + 128) >> 8 = (4096 + 128) >> 8 = 4224 >> 8 = 16.
        // mvL1 = mvL0 - mvCol = (8-16, 16-32) = (-8, -16).
        let (mv_l0, mv_l1) = derive_b_temporal_direct(Mv::new(16, 32), 20, 10, 0);
        assert_eq!(mv_l0, Mv::new(8, 16));
        assert_eq!(mv_l1, Mv::new(-8, -16));
    }

    #[test]
    fn b_temporal_direct_td_zero_uses_colocated_as_is() {
        // When col_pic_poc == list0_ref_poc, td = 0 -> non-scaling
        // branch: mvL0 = mvCol, mvL1 = 0.
        let col = Mv::new(3, 7);
        let (mv_l0, mv_l1) = derive_b_temporal_direct(col, 5, 10, 5);
        assert_eq!(mv_l0, col);
        assert_eq!(mv_l1, Mv::ZERO);
    }

    #[test]
    fn b_temporal_direct_symmetric_half() {
        // Current halfway between list0 ref and col pic:
        // tb = 5, td = 10 -> tx = (16384 + 5)/10 = 1638;
        // DSF = Clip3(..., (5*1638 + 32) >> 6)
        //     = Clip3(..., (8190 + 32) >> 6)
        //     = Clip3(..., 8222 >> 6) = 128.
        // mvL0 = (128 * col + 128) >> 8.
        // For col = (8, 8):
        //   mvL0 = (128*8 + 128) >> 8 = (1024+128) >> 8 = 1152 >> 8 = 4.
        //   mvL1 = (4 - 8, 4 - 8) = (-4, -4).
        let (mv_l0, mv_l1) = derive_b_temporal_direct(Mv::new(8, 8), 10, 5, 0);
        assert_eq!(mv_l0, Mv::new(4, 4));
        assert_eq!(mv_l1, Mv::new(-4, -4));
    }

    // --- §6.4.11.7 / §6.4.11.4 neighbour-4x4 map ---------------------------

    #[test]
    fn inverse_4x4_luma_scan_figure_6_10() {
        // Per figure 6-10:
        assert_eq!(inverse_4x4_luma_scan(0), (0, 0));
        assert_eq!(inverse_4x4_luma_scan(1), (4, 0));
        assert_eq!(inverse_4x4_luma_scan(2), (0, 4));
        assert_eq!(inverse_4x4_luma_scan(3), (4, 4));
        assert_eq!(inverse_4x4_luma_scan(4), (8, 0));
        assert_eq!(inverse_4x4_luma_scan(5), (12, 0));
        assert_eq!(inverse_4x4_luma_scan(6), (8, 4));
        assert_eq!(inverse_4x4_luma_scan(7), (12, 4));
        assert_eq!(inverse_4x4_luma_scan(8), (0, 8));
        assert_eq!(inverse_4x4_luma_scan(9), (4, 8));
        assert_eq!(inverse_4x4_luma_scan(10), (0, 12));
        assert_eq!(inverse_4x4_luma_scan(11), (4, 12));
        assert_eq!(inverse_4x4_luma_scan(12), (8, 8));
        assert_eq!(inverse_4x4_luma_scan(13), (12, 8));
        assert_eq!(inverse_4x4_luma_scan(14), (8, 12));
        assert_eq!(inverse_4x4_luma_scan(15), (12, 12));
    }

    #[test]
    fn luma_4x4_blk_idx_inverse_of_scan() {
        // luma_4x4_blk_idx should invert inverse_4x4_luma_scan.
        for idx in 0u8..=15 {
            let (x, y) = inverse_4x4_luma_scan(idx);
            assert_eq!(luma_4x4_blk_idx(x, y), idx);
        }
    }

    #[test]
    fn neighbour_map_block_0_top_left_of_mb() {
        // Block 0 is at (0,0). A at (-1, 0) = left MB; B at (0, -1)
        // = above MB; C at (4, -1) = above MB (since xN=4 < 16);
        // D at (-1, -1) = above-left MB.
        let [a, b, c, d] = neighbour_4x4_map(0);

        // A: ExternalLeft. Wrapped (xW, yW) = (15, 0) -> idx per
        // eq.6-38 = 8*(0/8) + 4*(15/8) + 2*((0%8)/4) + ((15%8)/4)
        //          = 0 + 4*1 + 0 + 7/4 = 4 + 1 = 5.
        // So the left-MB's block at (x=12, y=0) is block 5.
        assert_eq!(a, NeighbourSource::ExternalLeft(5));

        // B: ExternalAbove. (xW, yW) = (0, 15) -> idx =
        // 8*(15/8) + 4*(0/8) + 2*((15%8)/4) + ((0%8)/4)
        // = 8*1 + 0 + 2*(7/4) + 0 = 8 + 2 = 10.
        assert_eq!(b, NeighbourSource::ExternalAbove(10));

        // C: at (4, -1), inside current MB's x range -> ExternalAbove.
        // (xW, yW) = (4, 15) -> idx =
        // 8*(15/8) + 4*(4/8) + 2*((15%8)/4) + ((4%8)/4)
        // = 8 + 0 + 2 + 1 = 11.
        assert_eq!(c, NeighbourSource::ExternalAbove(11));

        // D: at (-1, -1) -> ExternalAboveLeft. (xW, yW) = (15, 15)
        // -> idx = 8*(15/8) + 4*(15/8) + 2*((15%8)/4) + ((15%8)/4)
        //       = 8 + 4 + 2 + 1 = 15.
        assert_eq!(d, NeighbourSource::ExternalAboveLeft(15));
    }

    #[test]
    fn neighbour_map_block_5_top_right_of_mb() {
        // Block 5 is at (12, 0) per figure 6-10.
        //   A at (11, 0)    — internal; idx = 8*0 + 4*(11/8) + 0 +
        //                    (11%8)/4 = 4 + 3/4 = 4 + 0 = 4.
        //     Wait: (11%8)/4 = 3/4 = 0. So idx = 4 + 0 = 4.
        //   B at (12, -1)   — ExternalAbove, (xW,yW) = (12, 15)
        //                    idx = 8*1 + 4*1 + 2*(7/4) + (12%8)/4
        //                        = 8 + 4 + 2 + 1 = 15.
        //   C at (16, -1)   — xN > 15 -> ExternalAboveRight.
        //                    (xW,yW) = (0, 15) -> idx = 10 (same as
        //                    block 0's B).
        //   D at (11, -1)   — ExternalAbove, (xW,yW) = (11, 15)
        //                    idx = 8*1 + 4*1 + 2*(7/4) + (11%8)/4
        //                        = 8 + 4 + 2 + 0 = 14.
        let [a, b, c, d] = neighbour_4x4_map(5);
        assert_eq!(a, NeighbourSource::InternalBlock(4));
        assert_eq!(b, NeighbourSource::ExternalAbove(15));
        assert_eq!(c, NeighbourSource::ExternalAboveRight(10));
        assert_eq!(d, NeighbourSource::ExternalAbove(14));
    }

    #[test]
    fn neighbour_map_block_6_interior() {
        // Block 6 is at (8, 4).
        //   A at (7, 4)    — internal.
        //     idx = 8*(4/8) + 4*(7/8) + 2*((4%8)/4) + ((7%8)/4)
        //         = 0 + 0 + 2 + 1 = 3.
        //   B at (8, 3)    — internal.
        //     idx = 8*(3/8) + 4*(8/8) + 2*((3%8)/4) + ((8%8)/4)
        //         = 0 + 4 + 0 + 0 = 4.
        //   C at (12, 3)   — internal.
        //     idx = 8*0 + 4*1 + 2*0 + ((12%8)/4) = 0 + 4 + 0 + 1 = 5.
        //   D at (7, 3)    — internal.
        //     idx = 8*0 + 4*0 + 2*0 + ((7%8)/4) = 0 + 0 + 0 + 1 = 1.
        let [a, b, c, d] = neighbour_4x4_map(6);
        assert_eq!(a, NeighbourSource::InternalBlock(3));
        assert_eq!(b, NeighbourSource::InternalBlock(4));
        assert_eq!(c, NeighbourSource::InternalBlock(5));
        assert_eq!(d, NeighbourSource::InternalBlock(1));
    }

    #[test]
    fn neighbour_map_block_15_bottom_right_of_mb() {
        // Block 15 is at (12, 12).
        //   A at (11, 12)  — internal.
        //     idx = 8*(12/8) + 4*(11/8) + 2*((12%8)/4) + ((11%8)/4)
        //         = 8 + 4 + 2 + 0 = 14.
        //   B at (12, 11)  — internal.
        //     idx = 8*(11/8) + 4*(12/8) + 2*((11%8)/4) + ((12%8)/4)
        //         = 8 + 4 + 0 + 1 = 13.
        //   C at (16, 11)  — xN > 15 AND yN inside MB -> per Table
        //     6-3 this is "not available" — but the C-substitution
        //     rule is applied by the caller, not here. For a 4x4
        //     block at the right edge, the neighbour map simply
        //     flags it somehow. Our fallback path returns
        //     ExternalAboveRight(0). We just check the A/B/D
        //     values and leave C to integration code.
        //   D at (11, 11)  — internal.
        //     idx = 8*(11/8) + 4*(11/8) + 2*((11%8)/4) + ((11%8)/4)
        //         = 8 + 4 + 0 + 0 = 12.
        let [a, b, _c, d] = neighbour_4x4_map(15);
        assert_eq!(a, NeighbourSource::InternalBlock(14));
        assert_eq!(b, NeighbourSource::InternalBlock(13));
        assert_eq!(d, NeighbourSource::InternalBlock(12));
    }
}