nihav-codec-support/src/codecs/h263/mod.rs

   1 use nihav_core::codecs::DecoderResult;
   2 use super::{MV, ZERO_MV};
   3 use nihav_core::frame::NAVideoBuffer;
   4
   5 #[allow(clippy::many_single_char_names)]
   6 pub mod code;
   7 pub mod data;
   8 #[allow(clippy::needless_range_loop)]
   9 pub mod decoder;
  10
  11 pub trait BlockDecoder {
  12     fn decode_pichdr(&mut self) -> DecoderResult<PicInfo>;
  13     fn decode_slice_header(&mut self, pinfo: &PicInfo) -> DecoderResult<SliceInfo>;
  14     fn decode_block_header(&mut self, pinfo: &PicInfo, sinfo: &SliceInfo, sstate: &SliceState) -> DecoderResult<BlockInfo>;
  15     fn decode_block_intra(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()>;
  16     fn decode_block_inter(&mut self, info: &BlockInfo, sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()>;
  17     fn is_slice_end(&mut self) -> bool;
  18 }
  19
  20 pub trait BlockDSP {
  21     fn idct(&self, blk: &mut [i16; 64]);
  22     fn copy_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV);
  23     fn avg_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV);
  24     fn filter_row(&self, buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo);
  25 }
  26
  27 #[allow(dead_code)]
  28 #[derive(Debug,Clone,Copy,PartialEq)]
  29 pub enum Type {
  30     I, P, PB, Skip, B, Special
  31 }
  32
  33 impl Type {
  34     pub fn is_ref(self) -> bool {
  35         match self {
  36             Type::I | Type::P | Type::PB => true,
  37             _                            => false,
  38         }
  39     }
  40 }
  41
  42 #[allow(dead_code)]
  43 #[derive(Debug,Clone,Copy)]
  44 pub struct PBInfo {
  45     trb:        u8,
  46     dbquant:    u8,
  47     improved:   bool,
  48 }
  49
  50 impl PBInfo {
  51     pub fn new(trb: u8, dbquant: u8, improved: bool) -> Self {
  52         PBInfo{ trb, dbquant, improved }
  53     }
  54     pub fn get_trb(self) -> u8 { self.trb }
  55     pub fn get_dbquant(self) -> u8 { self.dbquant }
  56     pub fn is_improved(self) -> bool { self.improved }
  57 }
  58
  59 #[allow(dead_code)]
  60 #[derive(Debug,Clone,Copy)]
  61 pub struct PicInfo {
  62     pub w:          usize,
  63     pub h:          usize,
  64     pub mode:       Type,
  65     pub mvmode:     MVMode,
  66     pub umv:        bool,
  67     pub apm:        bool,
  68     pub quant:      u8,
  69     pub pb:         Option<PBInfo>,
  70     pub ts:         u16,
  71     pub plusinfo:   Option<PlusInfo>,
  72 }
  73
  74 #[allow(dead_code)]
  75 impl PicInfo {
  76     pub fn new(w: usize, h: usize, mode: Type, mvmode: MVMode, umv: bool, apm: bool, quant: u8, ts: u16, pb: Option<PBInfo>, plusinfo: Option<PlusInfo>) -> Self {
  77         PicInfo {
  78             w, h, mode, mvmode,
  79             umv, apm, quant,
  80             pb, ts, plusinfo
  81         }
  82     }
  83     pub fn get_width(&self) -> usize { self.w }
  84     pub fn get_height(&self) -> usize { self.h }
  85     pub fn get_mode(&self) -> Type { self.mode }
  86     pub fn get_quant(&self) -> u8 { self.quant }
  87     pub fn get_apm(&self) -> bool { self.apm }
  88     pub fn is_pb(&self) -> bool { self.pb.is_some() }
  89     pub fn is_ipb(&self) -> bool {
  90             if let Some(ref pbi) = self.pb {
  91                 pbi.is_improved()
  92             } else {
  93                 false
  94             }
  95         }
  96     pub fn get_ts(&self) -> u16 { self.ts }
  97     pub fn get_pbinfo(&self) -> PBInfo { self.pb.unwrap() }
  98     pub fn get_plusifo(&self) -> Option<PlusInfo> { self.plusinfo }
  99     pub fn get_mvmode(&self) -> MVMode { self.mvmode }
 100 }
 101
 102 #[allow(dead_code)]
 103 #[derive(Debug,Clone,Copy)]
 104 pub struct PlusInfo {
 105     pub aic:        bool,
 106     pub deblock:    bool,
 107     pub aiv_mode:   bool,
 108     pub mq_mode:    bool,
 109 }
 110
 111 impl PlusInfo {
 112     pub fn new(aic: bool, deblock: bool, aiv_mode: bool, mq_mode: bool) -> Self {
 113         PlusInfo { aic, deblock, aiv_mode, mq_mode }
 114     }
 115 }
 116
 117 #[allow(dead_code)]
 118 #[derive(Debug,Clone,Copy)]
 119 pub struct SliceInfo {
 120     pub mb_x:   usize,
 121     pub mb_y:   usize,
 122     pub mb_end: usize,
 123     pub quant:  u8,
 124 }
 125
 126 #[allow(dead_code)]
 127 #[derive(Debug,Clone,Copy)]
 128 pub struct SliceState {
 129     pub is_iframe:  bool,
 130     pub mb_x:       usize,
 131     pub mb_y:       usize,
 132     pub first_line: bool,
 133     pub first_mb:   bool,
 134     pub slice_mb_x: usize,
 135     pub slice_mb_y: usize,
 136     pub quant:      u8,
 137 }
 138
 139 const SLICE_NO_END: usize = 99999999;
 140
 141 impl SliceInfo {
 142     pub fn new(mb_x: usize, mb_y: usize, mb_end: usize, quant: u8) -> Self {
 143         SliceInfo{ mb_x, mb_y, mb_end, quant }
 144     }
 145     pub fn new_gob(mb_x: usize, mb_y: usize, quant: u8) -> Self {
 146         SliceInfo{ mb_x, mb_y, mb_end: SLICE_NO_END, quant }
 147     }
 148     pub fn get_default_slice(pinfo: &PicInfo) -> Self {
 149         SliceInfo{ mb_x: 0, mb_y: 0, mb_end: SLICE_NO_END, quant: pinfo.get_quant() }
 150     }
 151     pub fn get_quant(&self) -> u8 { self.quant }
 152     pub fn is_at_end(&self, mb_pos: usize) -> bool { self.mb_end == mb_pos }
 153     pub fn needs_check(&self) -> bool { self.mb_end == SLICE_NO_END }
 154 }
 155
 156 impl SliceState {
 157     pub fn new(is_iframe: bool) -> Self {
 158         SliceState {
 159             is_iframe, mb_x: 0, mb_y: 0, first_line: true, first_mb: true,
 160             slice_mb_x: 0, slice_mb_y: 0, quant: 0
 161         }
 162     }
 163     pub fn next_mb(&mut self) {
 164         self.mb_x += 1; self.first_mb = false;
 165         if self.mb_x >= self.slice_mb_x && self.mb_y > self.slice_mb_y {
 166             self.first_line = false;
 167         }
 168     }
 169     pub fn new_row(&mut self) {
 170         self.mb_x = 0; self.mb_y += 1;
 171         if self.mb_x >= self.slice_mb_x && self.mb_y > self.slice_mb_y {
 172             self.first_line = false;
 173         }
 174         self.first_mb = true;
 175     }
 176     pub fn reset_slice(&mut self, smb_x: usize, smb_y: usize) {
 177         self.slice_mb_x = smb_x;
 178         self.slice_mb_y = smb_y;
 179         self.first_line = true;
 180         self.first_mb   = true;
 181     }
 182 }
 183
 184 #[derive(Debug,Clone,Copy)]
 185 pub struct BlockInfo {
 186     pub intra:   bool,
 187     pub skip:    bool,
 188     pub mode:    Type,
 189     pub cbp:     u8,
 190     pub q:       u8,
 191     pub mv:      [MV; 4],
 192     pub num_mv:  usize,
 193     pub bpart:   bool,
 194     pub b_cbp:   u8,
 195     pub mv2:     [MV; 2],
 196     pub num_mv2: usize,
 197     pub fwd:     bool,
 198     pub acpred:  ACPredMode,
 199 }
 200
 201 #[allow(dead_code)]
 202 #[derive(Debug,Clone,Copy)]
 203 pub struct BBlockInfo {
 204     present: bool,
 205     cbp:     u8,
 206     num_mv:  usize,
 207     fwd:     bool,
 208 }
 209
 210 #[allow(non_camel_case_types)]
 211 #[derive(Debug,Clone,Copy)]
 212 pub enum BlockMVInfo {
 213     Intra,
 214     Inter_1MV(MV),
 215     Inter_4MV([MV; 4]),
 216 }
 217
 218 #[allow(dead_code)]
 219 #[derive(Debug,Clone,Copy,PartialEq)]
 220 pub enum ACPredMode {
 221     None,
 222     DC,
 223     Ver,
 224     Hor,
 225 }
 226
 227 #[allow(dead_code)]
 228 impl BlockInfo {
 229     pub fn new(mode: Type, cbp: u8, q: u8) -> Self {
 230         BlockInfo {
 231             intra:   mode == Type::I,
 232             skip:    (cbp == 0) && (mode != Type::I),
 233             mode,
 234             cbp,
 235             q,
 236             mv:      [MV::new(0, 0), MV::new(0, 0), MV::new(0, 0), MV::new(0, 0)],
 237             num_mv:  0,
 238             bpart:   false,
 239             b_cbp:   0,
 240             mv2:     [ZERO_MV, ZERO_MV],
 241             num_mv2: 0,
 242             fwd:     false,
 243             acpred:  ACPredMode::None,
 244         }
 245     }
 246     pub fn is_intra(&self) -> bool { self.intra }
 247     pub fn is_skipped(&self) -> bool { self.skip }
 248     pub fn get_mode(&self) -> Type { self.mode }
 249     pub fn get_cbp(&self) -> u8 { self.cbp }
 250     pub fn get_q(&self) -> u8 { self.q }
 251     pub fn get_num_mvs(&self) -> usize { self.num_mv }
 252     pub fn get_mv(&self, idx: usize) -> MV { self.mv[idx] }
 253     pub fn has_b_part(&self) -> bool { self.bpart }
 254     pub fn get_cbp_b(&self) -> u8 { self.b_cbp }
 255     pub fn get_num_mvs2(&self) -> usize { self.num_mv2 }
 256     pub fn get_mv2(&self, idx: usize) -> MV { self.mv2[idx] }
 257     pub fn set_mv(&mut self, mvs: &[MV]) {
 258         if !mvs.is_empty() { self.skip = false; }
 259         let mut mv_arr: [MV; 4] = [MV::new(0, 0), MV::new(0, 0), MV::new(0, 0), MV::new(0, 0)];
 260         for i in 0..mvs.len() { mv_arr[i] = mvs[i]; }
 261         self.mv     = mv_arr;
 262         self.num_mv = mvs.len();
 263     }
 264     pub fn set_bpart(&mut self, bbinfo: BBlockInfo) {
 265         self.bpart = bbinfo.present;
 266         self.b_cbp = bbinfo.cbp;
 267         self.fwd   = bbinfo.fwd;
 268         self.num_mv2 = bbinfo.get_num_mv();
 269     }
 270     pub fn set_b_mv(&mut self, mvs: &[MV]) {
 271         if !mvs.is_empty() { self.skip = false; }
 272         let mut mv_arr: [MV; 2] = [ZERO_MV, ZERO_MV];
 273         for i in 0..mvs.len() { mv_arr[i] = mvs[i]; }
 274         self.mv2     = mv_arr;
 275         self.num_mv2 = mvs.len();
 276     }
 277     pub fn is_b_fwd(&self) -> bool { self.fwd }
 278     pub fn set_acpred(&mut self, acpred: ACPredMode) { self.acpred = acpred }
 279     pub fn get_acpred(&self) -> ACPredMode { self.acpred }
 280 }
 281
 282 impl BBlockInfo {
 283     pub fn new(present: bool, cbp: u8, num_mv: usize, fwd: bool) -> Self {
 284         BBlockInfo {
 285             present,
 286             cbp,
 287             num_mv,
 288             fwd,
 289         }
 290     }
 291     pub fn get_num_mv(&self) -> usize { self.num_mv }
 292 }
 293
 294 #[derive(Debug,Clone,Copy)]
 295 pub enum MVMode {
 296     Old,
 297     Long,
 298     UMV,
 299 }
 300
 301 pub trait H263MVTrait {
 302     fn add_umv(pred_mv: MV, add: MV, mvmode: MVMode) -> MV;
 303     fn scale(&self, trb: u16, trd: u16) -> MV;
 304     fn b_sub(pvec: MV, fwdvec: MV, bvec: MV, trb: u16, trd: u16) -> MV;
 305 }
 306
 307 impl H263MVTrait for MV {
 308     fn add_umv(pred_mv: MV, add: MV, mvmode: MVMode) -> MV {
 309         let mut new_mv = pred_mv + add;
 310         match mvmode {
 311             MVMode::Old => {
 312                     if      new_mv.x >=  64 { new_mv.x -= 64; }
 313                     else if new_mv.x <= -64 { new_mv.x += 64; }
 314                     if      new_mv.y >=  64 { new_mv.y -= 64; }
 315                     else if new_mv.y <= -64 { new_mv.y += 64; }
 316                 },
 317             MVMode::Long => {
 318                     if      new_mv.x >  31 { new_mv.x -= 64; }
 319                     else if new_mv.x < -32 { new_mv.x += 64; }
 320                     if      new_mv.y >  31 { new_mv.y -= 64; }
 321                     else if new_mv.y < -32 { new_mv.y += 64; }
 322                 },
 323             MVMode::UMV => {
 324                     if pred_mv.x >  32 && new_mv.x >  63 { new_mv.x -= 64; }
 325                     if pred_mv.x < -31 && new_mv.x < -63 { new_mv.x += 64; }
 326                     if pred_mv.y >  32 && new_mv.y >  63 { new_mv.y -= 64; }
 327                     if pred_mv.y < -31 && new_mv.y < -63 { new_mv.y += 64; }
 328                 },
 329         };
 330         new_mv
 331     }
 332     fn scale(&self, trb: u16, trd: u16) -> MV {
 333         if (trd == 0) || (trb == 0) {
 334             ZERO_MV
 335         } else {
 336             MV { x: (((self.x as i32) * (trb as i32)) / (trd as i32)) as i16, y: (((self.y as i32) * (trb as i32)) / (trd as i32)) as i16 }
 337         }
 338     }
 339     fn b_sub(pvec: MV, fwdvec: MV, bvec: MV, trb: u16, trd: u16) -> MV {
 340         let bscale = (trb as i32) - (trd as i32);
 341         let x = if bvec.x != 0 { fwdvec.x - pvec.x } else if trd != 0 { (bscale * (pvec.x as i32) / (trd as i32)) as i16 } else { 0 };
 342         let y = if bvec.y != 0 { fwdvec.y - pvec.y } else if trd != 0 { (bscale * (pvec.y as i32) / (trd as i32)) as i16 } else { 0 };
 343         MV { x, y }
 344     }
 345 }
 346
 347 #[allow(dead_code)]
 348 pub struct CBPInfo {
 349     cbp:        Vec<u8>,
 350     q:          Vec<u8>,
 351     mb_w:       usize,
 352 }
 353
 354 impl CBPInfo {
 355     fn new() -> Self { CBPInfo{ cbp: Vec::new(), q: Vec::new(), mb_w: 0 } }
 356     fn reset(&mut self, mb_w: usize) {
 357         self.mb_w = mb_w;
 358         self.cbp.truncate(0);
 359         self.cbp.resize(self.mb_w * 2, 0);
 360         self.q.truncate(0);
 361         self.q.resize(self.mb_w * 2, 0);
 362     }
 363     fn update_row(&mut self) {
 364         for i in 0..self.mb_w {
 365             self.cbp[i] = self.cbp[self.mb_w + i];
 366             self.q[i]   = self.q[self.mb_w + i];
 367         }
 368     }
 369     fn set_cbp(&mut self, mb_x: usize, cbp: u8) {
 370         self.cbp[self.mb_w + mb_x] = cbp;
 371     }
 372     fn set_q(&mut self, mb_x: usize, q: u8) {
 373         self.q[self.mb_w + mb_x] = q;
 374     }
 375     pub fn get_q(&self, mb_x: usize) -> u8 { self.q[mb_x] }
 376     pub fn is_coded(&self, mb_x: usize, blk_no: usize) -> bool {
 377         (self.cbp[self.mb_w + mb_x] & (1 << (5 - blk_no))) != 0
 378     }
 379     pub fn is_coded_top(&self, mb_x: usize, blk_no: usize) -> bool {
 380         let cbp     = self.cbp[self.mb_w + mb_x];
 381         let cbp_top = self.cbp[mb_x];
 382         match blk_no {
 383             0 => { (cbp_top & 0b001000) != 0 },
 384             1 => { (cbp_top & 0b000100) != 0 },
 385             2 => { (cbp     & 0b100000) != 0 },
 386             3 => { (cbp     & 0b010000) != 0 },
 387             4 => { (cbp_top & 0b000010) != 0 },
 388             _ => { (cbp_top & 0b000001) != 0 },
 389         }
 390     }
 391 }
 392