use std::sync::Arc;
use crate::decode::picture::Plane;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub enum MbKind {
#[default]
None,
I4x4,
I8x8,
I16x16,
IPcm,
P,
B,
PSkip,
BSkip,
}
impl MbKind {
#[inline]
pub fn is_intra(self) -> bool {
matches!(self, MbKind::I4x4 | MbKind::I8x8 | MbKind::I16x16 | MbKind::IPcm)
}
#[inline]
pub fn is_skip(self) -> bool {
matches!(self, MbKind::PSkip | MbKind::BSkip)
}
#[inline]
pub fn is_nxn(self) -> bool {
matches!(self, MbKind::I4x4 | MbKind::I8x8)
}
}
#[derive(Clone, Copy, Debug)]
pub struct MbInfo {
pub slice: u32,
pub kind: MbKind,
pub b_direct16: bool,
pub qp: i8,
pub qpc: [i8; 2],
pub cbp: u8,
pub t8x8: bool,
pub chroma_mode: u8,
pub ipred: [u8; 16],
pub nnz: [u8; 16],
pub nnz_c: [[u8; 8]; 2],
pub cbf_dc: u8,
pub nz_mask: u16,
pub direct8: u8,
pub ref_idx: [[i8; 4]; 2],
pub ref_id: [[i32; 4]; 2],
pub mv: [[[i16; 2]; 16]; 2],
pub mvd: [[[u8; 2]; 16]; 2],
pub field: bool,
}
impl Default for MbInfo {
fn default() -> Self {
MbInfo {
slice: u32::MAX,
kind: MbKind::None,
b_direct16: false,
qp: 0,
qpc: [0; 2],
cbp: 0,
t8x8: false,
chroma_mode: 0,
ipred: [2; 16],
nnz: [0; 16],
nnz_c: [[0; 8]; 2],
cbf_dc: 0,
nz_mask: 0,
direct8: 0,
ref_idx: [[-1; 4]; 2],
ref_id: [[-1; 4]; 2],
mv: [[[0; 2]; 16]; 2],
mvd: [[[0; 2]; 16]; 2],
field: false,
}
}
}
pub struct MbSyn {
pub kind: MbKind,
pub mb_type: u32,
pub i16_mode: u8,
pub prev_flag: [bool; 16],
pub rem: [u8; 16],
pub chroma_mode: u8,
pub sub: [u8; 4],
pub ref_idx: [[i8; 4]; 2],
pub mvd: [[[i32; 2]; 16]; 2],
pub cbp: u8,
pub t8x8: bool,
pub qp_delta: i32,
pub pcm: Vec<u16>,
pub coef: [[i32; 16]; 16],
pub coef8: [[i32; 64]; 4],
pub dc_luma: [i32; 16],
pub dc_c: [[i32; 8]; 2],
pub ac_c: [[[i32; 16]; 8]; 2],
pub coded: u16,
pub coded8: u8,
pub coded_c: [u8; 2],
}
impl MbSyn {
pub fn new() -> Self {
MbSyn {
kind: MbKind::None,
mb_type: 0,
i16_mode: 0,
prev_flag: [false; 16],
rem: [0; 16],
chroma_mode: 0,
sub: [0; 4],
ref_idx: [[0; 4]; 2],
mvd: [[[0; 2]; 16]; 2],
cbp: 0,
t8x8: false,
qp_delta: 0,
pcm: vec![0; 512],
coef: [[0; 16]; 16],
coef8: [[0; 64]; 4],
dc_luma: [0; 16],
dc_c: [[0; 8]; 2],
ac_c: [[[0; 16]; 8]; 2],
coded: 0,
coded8: 0,
coded_c: [0; 2],
}
}
pub fn reset(&mut self) {
for b in 0..16 {
if self.coded & (1 << b) != 0 {
self.coef[b] = [0; 16];
}
}
for b in 0..4 {
if self.coded8 & (1 << b) != 0 {
self.coef8[b] = [0; 64];
}
}
self.dc_luma = [0; 16];
self.dc_c = [[0; 8]; 2];
for c in 0..2 {
if self.coded_c[c] != 0 {
self.ac_c[c] = [[0; 16]; 8];
}
}
self.coded = 0;
self.coded8 = 0;
self.coded_c = [0; 2];
self.kind = MbKind::None;
self.mb_type = 0;
self.i16_mode = 0;
self.prev_flag = [false; 16];
self.rem = [0; 16];
self.chroma_mode = 0;
self.sub = [0; 4];
self.ref_idx = [[0; 4]; 2];
self.mvd = [[[0; 2]; 16]; 2];
self.cbp = 0;
self.t8x8 = false;
self.qp_delta = 0;
}
}
impl Default for MbSyn {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Shape {
S16x16,
S16x8,
S8x16,
S8x8,
}
impl Shape {
pub fn parts(self) -> &'static [(usize, usize, usize, usize)] {
match self {
Shape::S16x16 => &[(0, 0, 4, 4)],
Shape::S16x8 => &[(0, 0, 4, 2), (0, 2, 4, 2)],
Shape::S8x16 => &[(0, 0, 2, 4), (2, 0, 2, 4)],
Shape::S8x8 => &[(0, 0, 2, 2), (2, 0, 2, 2), (0, 2, 2, 2), (2, 2, 2, 2)],
}
}
}
pub type PredFlags = u8;
pub fn p_mb_layout(t: u32) -> (Shape, [PredFlags; 2]) {
match t {
0 => (Shape::S16x16, [1, 0]),
1 => (Shape::S16x8, [1, 1]),
2 => (Shape::S8x16, [1, 1]),
_ => (Shape::S8x8, [1, 1]),
}
}
pub fn b_mb_layout(t: u32) -> (Shape, [PredFlags; 2]) {
const T: [(Shape, [u8; 2]); 21] = [
(Shape::S16x16, [1, 0]),
(Shape::S16x16, [2, 0]),
(Shape::S16x16, [3, 0]),
(Shape::S16x8, [1, 1]),
(Shape::S8x16, [1, 1]),
(Shape::S16x8, [2, 2]),
(Shape::S8x16, [2, 2]),
(Shape::S16x8, [1, 2]),
(Shape::S8x16, [1, 2]),
(Shape::S16x8, [2, 1]),
(Shape::S8x16, [2, 1]),
(Shape::S16x8, [1, 3]),
(Shape::S8x16, [1, 3]),
(Shape::S16x8, [2, 3]),
(Shape::S8x16, [2, 3]),
(Shape::S16x8, [3, 1]),
(Shape::S8x16, [3, 1]),
(Shape::S16x8, [3, 2]),
(Shape::S8x16, [3, 2]),
(Shape::S16x8, [3, 3]),
(Shape::S8x16, [3, 3]),
];
if (1..=21).contains(&t) {
T[t as usize - 1]
} else {
(Shape::S8x8, [0, 0])
}
}
pub fn p_sub_layout(t: u8) -> (PredFlags, usize, usize) {
match t {
0 => (1, 2, 2),
1 => (1, 2, 1),
2 => (1, 1, 2),
_ => (1, 1, 1),
}
}
pub fn b_sub_layout(t: u8) -> (PredFlags, usize, usize) {
match t {
0 => (0, 2, 2),
1 => (1, 2, 2),
2 => (2, 2, 2),
3 => (3, 2, 2),
4 => (1, 2, 1),
5 => (1, 1, 2),
6 => (2, 2, 1),
7 => (2, 1, 2),
8 => (3, 2, 1),
9 => (3, 1, 2),
10 => (1, 1, 1),
11 => (2, 1, 1),
_ => (3, 1, 1),
}
}
#[derive(Clone)]
pub struct RefPic {
pub id: u32,
pub planes: Arc<[Plane; 3]>,
pub field_planes: [Option<Arc<[Plane; 3]>>; 2],
pub mbs: Arc<Vec<MbInfo>>,
pub field_mbs: [Option<Arc<Vec<MbInfo>>>; 2],
pub field_poc: [i32; 2],
pub poc: i32,
pub frame_num: u32,
pub frame_num_wrap: i32,
pub short: u8,
pub long: u8,
pub lt_idx: u32,
}
impl RefPic {
pub fn is_ref(&self) -> bool {
self.short | self.long != 0
}
pub fn field(&mut self, parity: usize) -> Arc<[Plane; 3]> {
if let Some(p) = &self.field_planes[parity] {
return p.clone();
}
let f = |p: &Plane| {
let h = p.height / 2;
let mut out = Plane::new(p.width, h, 0);
for y in 0..h {
let src = (2 * y + parity) * p.width;
out.data[y * p.width..(y + 1) * p.width].copy_from_slice(&p.data[src..src + p.width]);
}
out
};
let a = Arc::new([f(&self.planes[0]), f(&self.planes[1]), f(&self.planes[2])]);
self.field_planes[parity] = Some(a.clone());
a
}
}
#[derive(Clone, Debug)]
pub struct RefEntry {
pub dpb: usize,
pub id: u32,
pub poc: i32,
pub long_term: bool,
pub structure: u8,
pub planes: Arc<[Plane; 3]>,
}