| 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 { |
| 49 | ftype, |
| 50 | width, height, slice_w, slice_h, |
| 51 | transparent, |
| 52 | luma_bands, chroma_bands, |
| 53 | in_q, |
| 54 | } |
| 55 | } |
| 56 | pub fn new_null(ftype: IVIFrameType) -> Self { |
| 57 | PictureHeader { |
| 58 | ftype, |
| 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 { |
| 92 | pub fn is_8x8(self) -> bool { |
| 93 | match self { |
| 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 | } |
| 100 | pub fn is_2d(self) -> bool { |
| 101 | match self { |
| 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 { |
| 121 | quant_intra, quant_inter, scan, |
| 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 { |
| 137 | quant_intra, quant_inter, scan, |
| 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; |
| 175 | rvmap.runtab.swap(pos1, pos2); |
| 176 | rvmap.valtab.swap(pos1, pos2); |
| 177 | } |
| 178 | BandHeader { |
| 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, |
| 186 | } |
| 187 | } |
| 188 | pub fn new_empty(plane_no: usize, band_no: usize) -> Self { |
| 189 | BandHeader { |
| 190 | plane_no, band_no, |
| 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 { |
| 247 | pos_x, pos_y, w, h, |
| 248 | mb_w: 0, mb_h: 0, mb: Vec::new(), |
| 249 | } |
| 250 | } |
| 251 | } |
| 252 | |
| 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 ]; |