[nihav.git] / nihav-indeo / src / codecs / ivi.rs

use super::ivibr::{IVICodebook,IVI_CB_ZERO,RVMap,IVI_ZERO_RVMAP,IVI_RVMAPS};

pub fn clip8(a: i16) -> u8 {
    if a < 0 { 0 }
    else if a > 255 { 255 }
    else { a as u8 }
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub enum IVIFrameType {
    Intra,
    Inter,
    Bidir,
    Intra1,
    InterDroppable,
    InterScal,
    NULL,
    NULL2,
}

impl IVIFrameType {
    pub fn is_intra(self) -> bool {
        (self == IVIFrameType::Intra) || (self == IVIFrameType::Intra1)
    }
    pub fn is_null(self) -> bool {
        (self == IVIFrameType::NULL) || (self == IVIFrameType::NULL2)
    }
    pub fn is_bidir(self) -> bool {
        self == IVIFrameType::Bidir
    }
}

#[derive(Clone,Copy)]
pub struct PictureHeader {
    pub ftype:          IVIFrameType,
    pub width:          usize,
    pub height:         usize,
    pub slice_w:        usize,
    pub slice_h:        usize,
    pub transparent:    bool,
    pub luma_bands:     usize,
    pub chroma_bands:   usize,
    pub in_q:           bool,
}

impl PictureHeader {
    pub fn new(ftype: IVIFrameType, width: usize, height: usize, slice_w: usize, slice_h: usize, transparent: bool, luma_bands: usize, chroma_bands: usize, in_q: bool) -> Self {
        PictureHeader {
            ftype,
            width, height, slice_w, slice_h,
            transparent,
            luma_bands, chroma_bands,
            in_q,
        }
    }
    pub fn new_null(ftype: IVIFrameType) -> Self {
        PictureHeader {
            ftype,
            width: 0, height: 0, slice_w: 0, slice_h: 0,
            transparent: false,
            luma_bands: 0, chroma_bands: 0,
            in_q: false,
        }
    }
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub enum TSize {
    T8x8,
    T4x4,
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub enum TDir {
    TwoD,
    Row,
    Col,
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub enum IVITransformType {
    Haar (TSize, TDir),
    Slant(TSize, TDir),
    DCT  (TSize, TDir),
    None (TSize),
}

pub type TrFunc   = fn (&mut [i32; 64]);
pub type TrFuncDC = fn (&mut [i32; 64], i32);

impl IVITransformType {
    pub fn is_8x8(self) -> bool {
        match self {
            IVITransformType::Haar (ref sz, _) => { *sz == TSize::T8x8 },
            IVITransformType::Slant(ref sz, _) => { *sz == TSize::T8x8 },
            IVITransformType::DCT  (ref sz, _) => { *sz == TSize::T8x8 },
            IVITransformType::None (ref sz)    => { *sz == TSize::T8x8 },
        }
    }
    pub fn is_2d(self) -> bool {
        match self {
            IVITransformType::Haar (_, ref dir) => { *dir == TDir::TwoD },
            IVITransformType::Slant(_, ref dir) => { *dir == TDir::TwoD },
            IVITransformType::DCT  (_, ref dir) => { *dir == TDir::TwoD },
            _                                   => { false },
        }
    }
}

#[allow(dead_code)]
#[derive(Clone)]
pub struct TxParams4x4 {
    pub quant_intra:    &'static [u16; 16],
    pub quant_inter:    &'static [u16; 16],
    pub scan:           &'static [usize; 16],
}

impl TxParams4x4 {
    pub fn new(quant_intra: &'static [u16; 16], quant_inter: &'static [u16; 16], scan: &'static [usize; 16]) -> Self {
        TxParams4x4 {
            quant_intra, quant_inter, scan,
        }
    }
}

#[allow(dead_code)]
#[derive(Clone)]
pub struct TxParams8x8 {
    pub quant_intra:    &'static [u16; 64],
    pub quant_inter:    &'static [u16; 64],
    pub scan:           &'static [usize; 64],
}

impl TxParams8x8 {
    pub fn new(quant_intra: &'static [u16; 64], quant_inter: &'static [u16; 64], scan: &'static [usize; 64]) -> Self {
        TxParams8x8 {
            quant_intra, quant_inter, scan,
        }
    }
}

#[derive(Clone)]
pub enum TxType {
    Transform4(TxParams4x4),
    Transform8(TxParams8x8),
    None,
}

pub const CORR_MAP_SIZE: usize = 122;

#[derive(Clone)]
pub struct BandHeader {
    pub plane_no:   usize,
    pub band_no:    usize,
    pub empty:      bool,
    pub mb_size:    usize,
    pub blk_size:   usize,
    pub halfpel:    bool,
    pub inherit_mv: bool,
    pub has_qdelta: bool,
    pub inherit_qd: bool,
    pub quant:      u32,
    pub blk_cb:     IVICodebook,
    pub rvmap:      RVMap,
    pub tr:         IVITransformType,
    pub ttype:      TxType,
}

impl BandHeader {
    pub fn new(plane_no: usize, band_no: usize, mb_size: usize, blk_size: usize, halfpel: bool, inherit_mv: bool, has_qdelta: bool, inherit_qd: bool, quant: u32, rvmap_idx: usize, num_corr: usize, corr_map: [u8; CORR_MAP_SIZE], blk_cb: IVICodebook, tr: IVITransformType, ttype: TxType) -> Self {
        let mut rvmap = IVI_RVMAPS[rvmap_idx].clone();
        for i in 0..num_corr {
            let pos1 = corr_map[i * 2 + 0] as usize;
            let pos2 = corr_map[i * 2 + 1] as usize;
            rvmap.runtab.swap(pos1, pos2);
            rvmap.valtab.swap(pos1, pos2);
        }
        BandHeader {
            plane_no, band_no,
            empty: false, halfpel,
            inherit_mv,
            has_qdelta, inherit_qd, quant,
            mb_size, blk_size,
            rvmap, blk_cb,
            tr, ttype,
        }
    }
    pub fn new_empty(plane_no: usize, band_no: usize) -> Self {
        BandHeader {
            plane_no, band_no,
            empty: true, halfpel: true,
            inherit_mv: false, has_qdelta: false, inherit_qd: false, quant: 0,
            mb_size: 0, blk_size: 0,
            rvmap: IVI_ZERO_RVMAP, blk_cb: IVI_CB_ZERO,
            tr: IVITransformType::None(TSize::T8x8), ttype: TxType::None,
        }
    }
}

#[derive(Debug,Clone,Copy,PartialEq)]
pub enum MBType {
    Intra,
    Inter,
    Backward,
    Bidir,
}

#[derive(Clone,Copy)]
pub struct MB {
    pub mtype:  MBType,
    pub pos_x:  usize,
    pub pos_y:  usize,
    pub mv_x:   i32,
    pub mv_y:   i32,
    pub mv2_x:  i32,
    pub mv2_y:  i32,
    pub qd:     i16,
    pub q:      u8,
    pub cbp:    u8,
}

impl MB {
    pub fn new(x: usize, y: usize) -> Self {
        MB {
            mtype: MBType::Intra,
            pos_x: x, pos_y: y,
            mv_x: 0, mv_y: 0,
            mv2_x: 0, mv2_y: 0,
            cbp: 0, q: 0, qd: 0,
        }
    }
}

pub struct IVITile {
    pub pos_x:  usize,
    pub pos_y:  usize,
    pub mb_w:   usize,
    pub mb_h:   usize,
    pub w:      usize,
    pub h:      usize,
    pub mb:     Vec<MB>,
}

impl IVITile {
    pub fn new(pos_x: usize, pos_y: usize, w: usize, h: usize) -> Self {
        IVITile {
            pos_x, pos_y, w, h,
            mb_w: 0, mb_h: 0, mb: Vec::new(),
        }
    }
}

pub const IVI_SCAN_8X8_VER: [usize; 64] = [
    0,  8, 16, 24, 32, 40, 48, 56,
    1,  9, 17, 25, 33, 41, 49, 57,
    2, 10, 18, 26, 34, 42, 50, 58,
    3, 11, 19, 27, 35, 43, 51, 59,
    4, 12, 20, 28, 36, 44, 52, 60,
    5, 13, 21, 29, 37, 45, 53, 61,
    6, 14, 22, 30, 38, 46, 54, 62,
    7, 15, 23, 31, 39, 47, 55, 63
];
pub const IVI_SCAN_8X8_HOR: [usize; 64] = [
     0,  1,  2,  3,  4,  5,  6,  7,
     8,  9, 10, 11, 12, 13, 14, 15,
    16, 17, 18, 19, 20, 21, 22, 23,
    24, 25, 26, 27, 28, 29, 30, 31,
    32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43, 44, 45, 46, 47,
    48, 49, 50, 51, 52, 53, 54, 55,
    56, 57, 58, 59, 60, 61, 62, 63
];
pub const IVI_SCAN_4X4: [usize; 16] = [ 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 ];
Commit	Line	Data
01c971c5 KS	1	use super::ivibr::{IVICodebook,IVI_CB_ZERO,RVMap,IVI_ZERO_RVMAP,IVI_RVMAPS};
	2
	3	pub fn clip8(a: i16) -> u8 {
	4	if a < 0 { 0 }
	5	else if a > 255 { 255 }
	6	else { a as u8 }
	7	}
	8
	9	#[derive(Debug,Clone,Copy,PartialEq)]
	10	pub enum IVIFrameType {
	11	Intra,
	12	Inter,
	13	Bidir,
	14	Intra1,
	15	InterDroppable,
	16	InterScal,
	17	NULL,
	18	NULL2,
	19	}
	20
	21	impl IVIFrameType {
	22	pub fn is_intra(self) -> bool {
	23	(self == IVIFrameType::Intra) \|\| (self == IVIFrameType::Intra1)
	24	}
	25	pub fn is_null(self) -> bool {
	26	(self == IVIFrameType::NULL) \|\| (self == IVIFrameType::NULL2)
	27	}
	28	pub fn is_bidir(self) -> bool {
	29	self == IVIFrameType::Bidir
	30	}
	31	}
	32
	33	#[derive(Clone,Copy)]
	34	pub struct PictureHeader {
	35	pub ftype: IVIFrameType,
	36	pub width: usize,
	37	pub height: usize,
	38	pub slice_w: usize,
	39	pub slice_h: usize,
	40	pub transparent: bool,
	41	pub luma_bands: usize,
	42	pub chroma_bands: usize,
	43	pub in_q: bool,
	44	}
	45
	46	impl PictureHeader {
	47	pub fn new(ftype: IVIFrameType, width: usize, height: usize, slice_w: usize, slice_h: usize, transparent: bool, luma_bands: usize, chroma_bands: usize, in_q: bool) -> Self {
	48	PictureHeader {
f2af8eca KS	49	ftype,
	50	width, height, slice_w, slice_h,
	51	transparent,
	52	luma_bands, chroma_bands,
	53	in_q,
01c971c5 KS	54	}
	55	}
	56	pub fn new_null(ftype: IVIFrameType) -> Self {
	57	PictureHeader {
f2af8eca	58	ftype,
01c971c5 KS	59	width: 0, height: 0, slice_w: 0, slice_h: 0,
	60	transparent: false,
	61	luma_bands: 0, chroma_bands: 0,
	62	in_q: false,
	63	}
	64	}
	65	}
	66
	67	#[derive(Debug,Clone,Copy,PartialEq)]
	68	pub enum TSize {
	69	T8x8,
	70	T4x4,
	71	}
	72
	73	#[derive(Debug,Clone,Copy,PartialEq)]
	74	pub enum TDir {
	75	TwoD,
	76	Row,
	77	Col,
	78	}
	79
	80	#[derive(Debug,Clone,Copy,PartialEq)]
	81	pub enum IVITransformType {
	82	Haar (TSize, TDir),
	83	Slant(TSize, TDir),
	84	DCT (TSize, TDir),
	85	None (TSize),
	86	}
	87
	88	pub type TrFunc = fn (&mut [i32; 64]);
	89	pub type TrFuncDC = fn (&mut [i32; 64], i32);
	90
	91	impl IVITransformType {
f2af8eca KS	92	pub fn is_8x8(self) -> bool {
f2af8eca KS	93	match self {
01c971c5 KS	94	IVITransformType::Haar (ref sz, _) => { *sz == TSize::T8x8 },
	95	IVITransformType::Slant(ref sz, _) => { *sz == TSize::T8x8 },
	96	IVITransformType::DCT (ref sz, _) => { *sz == TSize::T8x8 },
	97	IVITransformType::None (ref sz) => { *sz == TSize::T8x8 },
	98	}
	99	}
f2af8eca KS	100	pub fn is_2d(self) -> bool {
f2af8eca KS	101	match self {
01c971c5 KS	102	IVITransformType::Haar (_, ref dir) => { *dir == TDir::TwoD },
	103	IVITransformType::Slant(_, ref dir) => { *dir == TDir::TwoD },
	104	IVITransformType::DCT (_, ref dir) => { *dir == TDir::TwoD },
	105	_ => { false },
	106	}
	107	}
	108	}
	109
	110	#[allow(dead_code)]
	111	#[derive(Clone)]
	112	pub struct TxParams4x4 {
	113	pub quant_intra: &'static [u16; 16],
	114	pub quant_inter: &'static [u16; 16],
	115	pub scan: &'static [usize; 16],
	116	}
	117
	118	impl TxParams4x4 {
	119	pub fn new(quant_intra: &'static [u16; 16], quant_inter: &'static [u16; 16], scan: &'static [usize; 16]) -> Self {
	120	TxParams4x4 {
f2af8eca	121	quant_intra, quant_inter, scan,
01c971c5 KS	122	}
	123	}
	124	}
	125
	126	#[allow(dead_code)]
	127	#[derive(Clone)]
	128	pub struct TxParams8x8 {
	129	pub quant_intra: &'static [u16; 64],
	130	pub quant_inter: &'static [u16; 64],
	131	pub scan: &'static [usize; 64],
	132	}
	133
	134	impl TxParams8x8 {
	135	pub fn new(quant_intra: &'static [u16; 64], quant_inter: &'static [u16; 64], scan: &'static [usize; 64]) -> Self {
	136	TxParams8x8 {
f2af8eca	137	quant_intra, quant_inter, scan,
01c971c5 KS	138	}
	139	}
	140	}
	141
	142	#[derive(Clone)]
	143	pub enum TxType {
	144	Transform4(TxParams4x4),
	145	Transform8(TxParams8x8),
	146	None,
	147	}
	148
	149	pub const CORR_MAP_SIZE: usize = 122;
	150
	151	#[derive(Clone)]
	152	pub struct BandHeader {
	153	pub plane_no: usize,
	154	pub band_no: usize,
	155	pub empty: bool,
	156	pub mb_size: usize,
	157	pub blk_size: usize,
	158	pub halfpel: bool,
	159	pub inherit_mv: bool,
	160	pub has_qdelta: bool,
	161	pub inherit_qd: bool,
	162	pub quant: u32,
	163	pub blk_cb: IVICodebook,
	164	pub rvmap: RVMap,
	165	pub tr: IVITransformType,
	166	pub ttype: TxType,
	167	}
	168
	169	impl BandHeader {
	170	pub fn new(plane_no: usize, band_no: usize, mb_size: usize, blk_size: usize, halfpel: bool, inherit_mv: bool, has_qdelta: bool, inherit_qd: bool, quant: u32, rvmap_idx: usize, num_corr: usize, corr_map: [u8; CORR_MAP_SIZE], blk_cb: IVICodebook, tr: IVITransformType, ttype: TxType) -> Self {
	171	let mut rvmap = IVI_RVMAPS[rvmap_idx].clone();
	172	for i in 0..num_corr {
	173	let pos1 = corr_map[i * 2 + 0] as usize;
	174	let pos2 = corr_map[i * 2 + 1] as usize;
f2af8eca KS	175	rvmap.runtab.swap(pos1, pos2);
f2af8eca KS	176	rvmap.valtab.swap(pos1, pos2);
01c971c5 KS	177	}
01c971c5 KS	178	BandHeader {
f2af8eca KS	179	plane_no, band_no,
	180	empty: false, halfpel,
	181	inherit_mv,
	182	has_qdelta, inherit_qd, quant,
	183	mb_size, blk_size,
	184	rvmap, blk_cb,
	185	tr, ttype,
01c971c5 KS	186	}
	187	}
	188	pub fn new_empty(plane_no: usize, band_no: usize) -> Self {
	189	BandHeader {
f2af8eca	190	plane_no, band_no,
01c971c5 KS	191	empty: true, halfpel: true,
	192	inherit_mv: false, has_qdelta: false, inherit_qd: false, quant: 0,
	193	mb_size: 0, blk_size: 0,
	194	rvmap: IVI_ZERO_RVMAP, blk_cb: IVI_CB_ZERO,
	195	tr: IVITransformType::None(TSize::T8x8), ttype: TxType::None,
	196	}
	197	}
	198	}
	199
	200	#[derive(Debug,Clone,Copy,PartialEq)]
	201	pub enum MBType {
	202	Intra,
	203	Inter,
	204	Backward,
	205	Bidir,
	206	}
	207
	208	#[derive(Clone,Copy)]
	209	pub struct MB {
	210	pub mtype: MBType,
	211	pub pos_x: usize,
	212	pub pos_y: usize,
	213	pub mv_x: i32,
	214	pub mv_y: i32,
	215	pub mv2_x: i32,
	216	pub mv2_y: i32,
	217	pub qd: i16,
	218	pub q: u8,
	219	pub cbp: u8,
	220	}
	221
	222	impl MB {
	223	pub fn new(x: usize, y: usize) -> Self {
	224	MB {
	225	mtype: MBType::Intra,
	226	pos_x: x, pos_y: y,
	227	mv_x: 0, mv_y: 0,
	228	mv2_x: 0, mv2_y: 0,
	229	cbp: 0, q: 0, qd: 0,
	230	}
	231	}
	232	}
	233
	234	pub struct IVITile {
	235	pub pos_x: usize,
	236	pub pos_y: usize,
	237	pub mb_w: usize,
	238	pub mb_h: usize,
	239	pub w: usize,
	240	pub h: usize,
	241	pub mb: Vec<MB>,
	242	}
	243
	244	impl IVITile {
	245	pub fn new(pos_x: usize, pos_y: usize, w: usize, h: usize) -> Self {
	246	IVITile {
f2af8eca	247	pos_x, pos_y, w, h,
01c971c5 KS	248	mb_w: 0, mb_h: 0, mb: Vec::new(),
	249	}
	250	}
	251	}
	252
01c971c5 KS	253	pub const IVI_SCAN_8X8_VER: [usize; 64] = [
	254	0, 8, 16, 24, 32, 40, 48, 56,
	255	1, 9, 17, 25, 33, 41, 49, 57,
	256	2, 10, 18, 26, 34, 42, 50, 58,
	257	3, 11, 19, 27, 35, 43, 51, 59,
	258	4, 12, 20, 28, 36, 44, 52, 60,
	259	5, 13, 21, 29, 37, 45, 53, 61,
	260	6, 14, 22, 30, 38, 46, 54, 62,
	261	7, 15, 23, 31, 39, 47, 55, 63
	262	];
	263	pub const IVI_SCAN_8X8_HOR: [usize; 64] = [
	264	0, 1, 2, 3, 4, 5, 6, 7,
	265	8, 9, 10, 11, 12, 13, 14, 15,
	266	16, 17, 18, 19, 20, 21, 22, 23,
	267	24, 25, 26, 27, 28, 29, 30, 31,
	268	32, 33, 34, 35, 36, 37, 38, 39,
	269	40, 41, 42, 43, 44, 45, 46, 47,
	270	48, 49, 50, 51, 52, 53, 54, 55,
	271	56, 57, 58, 59, 60, 61, 62, 63
	272	];
	273	pub const IVI_SCAN_4X4: [usize; 16] = [ 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 ];