nihav-vivo/src/codecs/vivo.rs

   1 use nihav_core::io::bitreader::*;
   2 use nihav_core::io::codebook::*;
   3 use nihav_core::formats;
   4 use nihav_core::frame::*;
   5 use nihav_core::codecs::*;
   6 use nihav_codec_support::codecs::{MV, ZIGZAG};
   7 use nihav_codec_support::codecs::h263::*;
   8 use nihav_codec_support::codecs::h263::code::H263BlockDSP;
   9 use nihav_codec_support::codecs::h263::decoder::*;
  10 use nihav_codec_support::codecs::h263::data::*;
  11
  12 #[allow(dead_code)]
  13 struct Tables {
  14     intra_mcbpc_cb: Codebook<u8>,
  15     inter_mcbpc_cb: Codebook<u8>,
  16     cbpy_cb:        Codebook<u8>,
  17     rl_cb:          Codebook<H263RLSym>,
  18     aic_rl_cb:      Codebook<H263RLSym>,
  19     mv_cb:          Codebook<u8>,
  20 }
  21
  22 struct VivoDecoder {
  23     info:       NACodecInfoRef,
  24     dec:        H263BaseDecoder,
  25     tables:     Tables,
  26     bdsp:       H263BlockDSP,
  27     lastframe:  Option<NABufferType>,
  28     lastpts:    Option<u64>,
  29     width:      usize,
  30     height:     usize,
  31 }
  32
  33 struct VivoBR<'a> {
  34     br:     BitReader<'a>,
  35     tables: &'a Tables,
  36     gob_no: usize,
  37     mb_w:   usize,
  38     is_pb:  bool,
  39     is_ipb: bool,
  40     ref_w:  usize,
  41     ref_h:  usize,
  42     aic:    bool,
  43 }
  44
  45 fn check_marker<'a>(br: &mut BitReader<'a>) -> DecoderResult<()> {
  46     let mark = br.read(1)?;
  47     validate!(mark == 1);
  48     Ok(())
  49 }
  50
  51 impl<'a> VivoBR<'a> {
  52     fn new(src: &'a [u8], tables: &'a Tables, ref_w: usize, ref_h: usize) -> Self {
  53         VivoBR {
  54             br:     BitReader::new(src, BitReaderMode::BE),
  55             tables,
  56             gob_no: 0,
  57             mb_w:   0,
  58             is_pb:  false,
  59             is_ipb: false,
  60             ref_w, ref_h,
  61             aic:    false,
  62         }
  63     }
  64
  65     fn decode_block(&mut self, quant: u8, intra: bool, coded: bool, blk: &mut [i16; 64], plane_no: usize, acpred: ACPredMode) -> DecoderResult<()> {
  66         let br = &mut self.br;
  67         let mut idx = 0;
  68         if !self.aic && intra {
  69             let mut dc = br.read(8)? as i16;
  70             if dc == 255 { dc = 128; }
  71             blk[0] = dc << 3;
  72             idx = 1;
  73         }
  74         if !coded { return Ok(()); }
  75         let scan = match acpred {
  76                     ACPredMode::Hor => H263_SCAN_V,
  77                     ACPredMode::Ver => H263_SCAN_H,
  78                     _               => &ZIGZAG,
  79                 };
  80
  81         let rl_cb = if self.aic && intra { &self.tables.aic_rl_cb } else { &self.tables.rl_cb };
  82         let q = if plane_no == 0 { i16::from(quant * 2) } else { i16::from(H263_CHROMA_QUANT[quant as usize] * 2) };
  83         let q_add = if q == 0 || self.aic { 0i16 } else { (((q >> 1) - 1) | 1) as i16 };
  84         while idx < 64 {
  85             let code = br.read_cb(rl_cb)?;
  86             let run;
  87             let mut level;
  88             let last;
  89             if !code.is_escape() {
  90                 run   = code.get_run();
  91                 level = code.get_level();
  92                 last  = code.is_last();
  93                 if br.read_bool()? { level = -level; }
  94                 if level >= 0 {
  95                     level = (level * q) + q_add;
  96                 } else {
  97                     level = (level * q) - q_add;
  98                 }
  99             } else {
 100                 last  = br.read_bool()?;
 101                 run   = br.read(6)? as u8;
 102                 level = br.read_s(8)? as i16;
 103                 if level == -128 {
 104                     let low = br.read(5)? as i16;
 105                     let top = br.read_s(6)? as i16;
 106                     level = (top << 5) | low;
 107                 }
 108                 if level >= 0 {
 109                     level = (level * q) + q_add;
 110                 } else {
 111                     level = (level * q) - q_add;
 112                 }
 113                 if level < -2048 { level = -2048; }
 114                 if level >  2047 { level =  2047; }
 115             }
 116             idx += run;
 117             validate!(idx < 64);
 118             let oidx = scan[idx as usize];
 119             blk[oidx] = level;
 120             idx += 1;
 121             if last { break; }
 122         }
 123         Ok(())
 124     }
 125 }
 126
 127 fn decode_mv_component(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<i16> {
 128     let code = i16::from(br.read_cb(mv_cb)?);
 129     if code == 0 { return Ok(0) }
 130     if !br.read_bool()? {
 131         Ok(code)
 132     } else {
 133         Ok(-code)
 134     }
 135 }
 136
 137 fn decode_mv(br: &mut BitReader, mv_cb: &Codebook<u8>) -> DecoderResult<MV> {
 138     let xval = decode_mv_component(br, mv_cb)?;
 139     let yval = decode_mv_component(br, mv_cb)?;
 140     Ok(MV::new(xval, yval))
 141 }
 142
 143 fn decode_b_info(br: &mut BitReader, is_pb: bool, is_ipb: bool, is_intra: bool) -> DecoderResult<BBlockInfo> {
 144     if is_pb { // as improved pb
 145         if is_ipb {
 146             let pb_mv_add = if is_intra { 1 } else { 0 };
 147             if br.read_bool()?{
 148                 if br.read_bool()? {
 149                     let pb_mv_count = 1 - (br.read(1)? as usize);
 150                     let cbpb = br.read(6)? as u8;
 151                     Ok(BBlockInfo::new(true, cbpb, pb_mv_count + pb_mv_add, pb_mv_count == 1))
 152                 } else {
 153                     Ok(BBlockInfo::new(true, 0, 1 + pb_mv_add, true))
 154                 }
 155             } else {
 156                 Ok(BBlockInfo::new(true, 0, pb_mv_add, false))
 157             }
 158         } else {
 159             let mvdb = br.read_bool()?;
 160             let cbpb = if mvdb && br.read_bool()? { br.read(6)? as u8 } else { 0 };
 161             Ok(BBlockInfo::new(true, cbpb, if mvdb { 1 } else { 0 }, false))
 162         }
 163     } else {
 164         Ok(BBlockInfo::new(false, 0, 0, false))
 165     }
 166 }
 167
 168 impl<'a> BlockDecoder for VivoBR<'a> {
 169
 170 #[allow(unused_variables)]
 171 #[allow(clippy::unreadable_literal)]
 172     fn decode_pichdr(&mut self) -> DecoderResult<PicInfo> {
 173         let br = &mut self.br;
 174         let syncw = br.read(22)?;
 175         validate!(syncw == 0x000020);
 176         let tr = (br.read(8)? << 8) as u16;
 177         check_marker(br)?;
 178         let id = br.read(1)?;
 179         validate!(id == 0);
 180         br.read(1)?; // split screen indicator
 181         br.read(1)?; // document camera indicator
 182         br.read(1)?; // freeze picture release
 183         let mut sfmt = br.read(3)?;
 184         validate!(sfmt != 0b000);
 185         let is_intra = !br.read_bool()?;
 186         let umv = br.read_bool()?;
 187         br.read(1)?; // syntax arithmetic coding
 188         let apm = br.read_bool()?;
 189         self.is_pb = br.read_bool()?;
 190         let deblock;
 191         let pbplus;
 192         let aic;
 193         if sfmt == 0b110 {
 194             sfmt = br.read(3)?;
 195             validate!(sfmt != 0b000 && sfmt != 0b110);
 196             aic = br.read_bool()?;
 197             br.read(1)?; // umv mode
 198             deblock = br.read_bool()?;
 199             br.read(3)?; // unknown flags
 200             pbplus = br.read_bool()?;
 201             br.read(4)?; // unknown flags
 202         } else {
 203             aic = false;
 204             deblock = false;
 205             pbplus = false;
 206         }
 207         self.is_ipb = pbplus;
 208         let (w, h) = match sfmt {
 209                 0b001 => ( 64,  48),
 210                 0b011 => ( 88,  72),
 211                 0b010 => (176, 144),
 212                 0b100 => (352, 288),
 213                 0b101 => (704, 576),
 214                 0b111 => {
 215                     validate!((self.ref_w != 0) && (self.ref_h != 0));
 216                     ((self.ref_w + 15) & !15, (self.ref_h + 15) & !15)
 217                 },
 218                 _ => return Err(DecoderError::InvalidData),
 219             };
 220         let quant = br.read(5)?;
 221         let cpm = br.read_bool()?;
 222         validate!(!cpm);
 223
 224         let pbinfo;
 225         if self.is_pb {
 226             let trb = br.read(3)?;
 227             let dbquant = br.read(2)?;
 228             pbinfo = Some(PBInfo::new(trb as u8, dbquant as u8, pbplus));
 229         } else {
 230             pbinfo = None;
 231         }
 232         while br.read_bool()? { // skip PEI
 233             br.read(8)?;
 234         }
 235         self.gob_no = 0;
 236         self.mb_w = (w + 15) >> 4;
 237         self.aic = aic;
 238
 239         let ftype = if is_intra { Type::I } else { Type::P };
 240         let plusinfo = Some(PlusInfo::new(aic, deblock, false, false));
 241         let mvmode = if umv { MVMode::UMV } else { MVMode::Old };
 242         let picinfo = PicInfo::new(w, h, ftype, mvmode, umv, apm, quant as u8, tr, pbinfo, plusinfo);
 243         Ok(picinfo)
 244     }
 245
 246     #[allow(unused_variables)]
 247     fn decode_slice_header(&mut self, info: &PicInfo) -> DecoderResult<SliceInfo> {
 248         let br = &mut self.br;
 249         let gbsc = br.read(17)?;
 250         validate!(gbsc == 1);
 251         let gn = br.read(5)?;
 252         let gfid = br.read(2)?;
 253         let gquant = br.read(5)?;
 254         let ret = SliceInfo::new_gob(0, self.gob_no, gquant as u8);
 255         self.gob_no += 1;
 256         Ok(ret)
 257     }
 258
 259     #[allow(unused_variables)]
 260     fn decode_block_header(&mut self, info: &PicInfo, slice: &SliceInfo, sstate: &SliceState) -> DecoderResult<BlockInfo> {
 261         let br = &mut self.br;
 262         let mut q = slice.get_quant();
 263         match info.get_mode() {
 264             Type::I => {
 265                     let mut cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?;
 266                     while cbpc == 8 { cbpc = br.read_cb(&self.tables.intra_mcbpc_cb)?; }
 267                     let mut acpred = ACPredMode::None;
 268                     if let Some(ref pi) = info.plusinfo {
 269                         if pi.aic {
 270                             let acpp = br.read_bool()?;
 271                             acpred = ACPredMode::DC;
 272                             if acpp {
 273                                 acpred = if !br.read_bool()? { ACPredMode::Hor } else { ACPredMode::Ver };
 274                             }
 275                         }
 276                     }
 277                     let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 278                     let cbp = (cbpy << 2) | (cbpc & 3);
 279                     let dquant = (cbpc & 4) != 0;
 280                     if dquant {
 281                         let idx = br.read(2)? as usize;
 282                         q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 283                     }
 284                     let mut binfo = BlockInfo::new(Type::I, cbp, q);
 285                     binfo.set_acpred(acpred);
 286                     Ok(binfo)
 287                 },
 288             Type::P => {
 289                     if br.read_bool()? { return Ok(BlockInfo::new(Type::Skip, 0, info.get_quant())); }
 290                     let mut cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?;
 291                     while cbpc == 20 { cbpc = br.read_cb(&self.tables.inter_mcbpc_cb)?; }
 292                     let is_intra = (cbpc & 0x04) != 0;
 293                     let dquant   = (cbpc & 0x08) != 0;
 294                     let is_4x4   = (cbpc & 0x10) != 0;
 295                     if is_intra {
 296                         let mut acpred = ACPredMode::None;
 297                         if let Some(ref pi) = info.plusinfo {
 298                             if pi.aic {
 299                                 let acpp = br.read_bool()?;
 300                                 acpred = ACPredMode::DC;
 301                                 if acpp {
 302                                     acpred = if !br.read_bool()? { ACPredMode::Hor } else { ACPredMode::Ver };
 303                                 }
 304                             }
 305                         }
 306                         let mut mvec: Vec<MV> = Vec::new();
 307                         let bbinfo = decode_b_info(br, self.is_pb, self.is_ipb, true)?;
 308                         let cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 309                         let cbp = (cbpy << 2) | (cbpc & 3);
 310                         if dquant {
 311                             let idx = br.read(2)? as usize;
 312                             q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 313                         }
 314                         let mut binfo = BlockInfo::new(Type::I, cbp, q);
 315                         binfo.set_bpart(bbinfo);
 316                         binfo.set_acpred(acpred);
 317                         if self.is_pb {
 318                             for _ in 0..bbinfo.get_num_mv() {
 319                                 mvec.push(decode_mv(br, &self.tables.mv_cb)?);
 320                             }
 321                             binfo.set_b_mv(mvec.as_slice());
 322                         }
 323                         return Ok(binfo);
 324                     }
 325
 326                     let bbinfo = decode_b_info(br, self.is_pb, self.is_ipb, false)?;
 327                     let mut cbpy = br.read_cb(&self.tables.cbpy_cb)?;
 328 //                    if /* !aiv && */(cbpc & 3) != 3 {
 329                         cbpy ^= 0xF;
 330 //                    }
 331                     let cbp = (cbpy << 2) | (cbpc & 3);
 332                     if dquant {
 333                         let idx = br.read(2)? as usize;
 334                         q = (i16::from(q) + i16::from(H263_DQUANT_TAB[idx])) as u8;
 335                     }
 336                     let mut binfo = BlockInfo::new(Type::P, cbp, q);
 337                     binfo.set_bpart(bbinfo);
 338                     if !is_4x4 {
 339                         let mvec: [MV; 1] = [decode_mv(br, &self.tables.mv_cb)?];
 340                         binfo.set_mv(&mvec);
 341                     } else {
 342                         let mvec: [MV; 4] = [
 343                                 decode_mv(br, &self.tables.mv_cb)?,
 344                                 decode_mv(br, &self.tables.mv_cb)?,
 345                                 decode_mv(br, &self.tables.mv_cb)?,
 346                                 decode_mv(br, &self.tables.mv_cb)?
 347                             ];
 348                         binfo.set_mv(&mvec);
 349                     }
 350                     if self.is_pb {
 351                         let mut mvec: Vec<MV> = Vec::with_capacity(bbinfo.get_num_mv());
 352                         for _ in 0..bbinfo.get_num_mv() {
 353                             let mv = decode_mv(br, &self.tables.mv_cb)?;
 354                             mvec.push(mv);
 355                         }
 356                         binfo.set_b_mv(mvec.as_slice());
 357                     }
 358                     Ok(binfo)
 359                 },
 360             _ => Err(DecoderError::InvalidData),
 361         }
 362     }
 363
 364     #[allow(unused_variables)]
 365     fn decode_block_intra(&mut self, info: &BlockInfo, _sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 366         self.decode_block(quant, true, coded, blk, if no < 4 { 0 } else { no - 3 }, info.get_acpred())
 367     }
 368
 369     #[allow(unused_variables)]
 370     fn decode_block_inter(&mut self, info: &BlockInfo, _sstate: &SliceState, quant: u8, no: usize, coded: bool, blk: &mut [i16; 64]) -> DecoderResult<()> {
 371         self.decode_block(quant, false, coded, blk, if no < 4 { 0 } else { no - 3 }, ACPredMode::None)
 372     }
 373
 374     fn is_slice_end(&mut self) -> bool { self.br.peek(16) == 0 }
 375 }
 376
 377 impl VivoDecoder {
 378     fn new() -> Self {
 379         let mut coderead = H263ShortCodeReader::new(H263_INTRA_MCBPC);
 380         let intra_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 381         let mut coderead = H263ShortCodeReader::new(H263_INTER_MCBPC);
 382         let inter_mcbpc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 383         let mut coderead = H263ShortCodeReader::new(H263_CBPY);
 384         let cbpy_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 385         let mut coderead = H263RLCodeReader::new(H263_RL_CODES);
 386         let rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 387         let mut coderead = H263RLCodeReader::new(H263_RL_CODES_AIC);
 388         let aic_rl_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 389         let mut coderead = H263ShortCodeReader::new(H263_MV);
 390         let mv_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 391         let tables = Tables {
 392             intra_mcbpc_cb,
 393             inter_mcbpc_cb,
 394             cbpy_cb,
 395             rl_cb,
 396             aic_rl_cb,
 397             mv_cb,
 398         };
 399
 400         VivoDecoder{
 401             info:           NACodecInfo::new_dummy(),
 402             dec:            H263BaseDecoder::new(true),
 403             tables,
 404             bdsp:           H263BlockDSP::new(),
 405             lastframe:      None,
 406             lastpts:        None,
 407             width:          0,
 408             height:         0,
 409         }
 410     }
 411 }
 412
 413 impl NADecoder for VivoDecoder {
 414     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
 415         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
 416             let w = vinfo.get_width();
 417             let h = vinfo.get_height();
 418             let fmt = formats::YUV420_FORMAT;
 419             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
 420             self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
 421             self.width  = w;
 422             self.height = h;
 423             Ok(())
 424         } else {
 425             Err(DecoderError::InvalidData)
 426         }
 427     }
 428     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 429         let src = pkt.get_buffer();
 430
 431         if src.len() == 0 {
 432             let buftype;
 433             let ftype;
 434             if self.lastframe.is_none() {
 435                 buftype = NABufferType::None;
 436                 ftype = FrameType::Skip;
 437             } else {
 438                 let mut buf = None;
 439                 std::mem::swap(&mut self.lastframe, &mut buf);
 440                 buftype = buf.unwrap();
 441                 ftype = FrameType::B;
 442             }
 443             let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype);
 444             frm.set_keyframe(false);
 445             frm.set_frame_type(ftype);
 446             if self.lastpts.is_some() {
 447                 frm.set_pts(self.lastpts);
 448                 self.lastpts = None;
 449             }
 450             return Ok(frm.into_ref());
 451         }
 452         let mut ibr = VivoBR::new(&src, &self.tables, self.width, self.height);
 453
 454         let bufinfo = self.dec.parse_frame(&mut ibr, &self.bdsp)?;
 455
 456         let mut cur_pts = pkt.get_pts();
 457         if !self.dec.is_intra() {
 458             let bret = self.dec.get_bframe(&self.bdsp);
 459             if let Ok(b_buf) = bret {
 460                 self.lastframe = Some(b_buf);
 461                 self.lastpts = pkt.get_pts();
 462                 if let Some(pts) = pkt.get_pts() {
 463                     cur_pts = Some(pts + 1);
 464                 }
 465             }
 466         }
 467
 468         let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
 469         frm.set_keyframe(self.dec.is_intra());
 470         frm.set_frame_type(if self.dec.is_intra() { FrameType::I } else { FrameType::P });
 471         frm.set_pts(cur_pts);
 472         Ok(frm.into_ref())
 473     }
 474     fn flush(&mut self) {
 475         self.dec.flush();
 476     }
 477 }
 478
 479 impl NAOptionHandler for VivoDecoder {
 480     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 481     fn set_options(&mut self, _options: &[NAOption]) { }
 482     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 483 }
 484
 485
 486 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 487     Box::new(VivoDecoder::new())
 488 }
 489
 490 #[cfg(test)]
 491 mod test {
 492     use nihav_core::codecs::RegisteredDecoders;
 493     use nihav_core::demuxers::RegisteredDemuxers;
 494     use nihav_codec_support::test::dec_video::*;
 495     use crate::vivo_register_all_decoders;
 496     use crate::vivo_register_all_demuxers;
 497     #[test]
 498     fn test_vivo1() {
 499         let mut dmx_reg = RegisteredDemuxers::new();
 500         vivo_register_all_demuxers(&mut dmx_reg);
 501         let mut dec_reg = RegisteredDecoders::new();
 502         vivo_register_all_decoders(&mut dec_reg);
 503
 504 test_file_decoding("vivo", "assets/Misc/gr_al.viv", Some(16), true, false, Some("viv1"), &dmx_reg, &dec_reg);
 505 //        test_decoding("vivo", "vivo1", "assets/Misc/gr_al.viv", Some(16),
 506 //                      &dmx_reg, &dec_reg, ExpectedTestResult::GenerateMD5Frames));
 507     }
 508     #[test]
 509     fn test_vivo2() {
 510         let mut dmx_reg = RegisteredDemuxers::new();
 511         vivo_register_all_demuxers(&mut dmx_reg);
 512         let mut dec_reg = RegisteredDecoders::new();
 513         vivo_register_all_decoders(&mut dec_reg);
 514
 515 test_file_decoding("vivo", "assets/Misc/02-KimagureOrangeRoad.viv", Some(50), true, false, Some("viv2"), &dmx_reg, &dec_reg);
 516 panic!("end");
 517 //        test_decoding("vivo", "vivo2", "assets/Misc/greetings.viv", Some(16),
 518 //                      &dmx_reg, &dec_reg, ExpectedTestResult::GenerateMD5Frames));
 519     }
 520 }